app.py

import copy
import math
import os.path
import random

import gradio as gr
import matplotlib.pyplot as plt
from sklearn import preprocessing
from sklearn.model_selection import train_test_split
import pandas as pd

from analysis.bayes_model import *
from analysis.distance_model import *
from analysis.gradient_model import *
from analysis.kernel_model import *
from analysis.shap_model import *
from analysis.tree_model import *
from metrics.calculate_classification_metrics import ClassificationMetrics
from metrics.calculate_regression_metrics import RegressionMetrics
from static.process import *
from analysis.linear_model import *
from visualization.draw_boxplot import draw_boxplot
from visualization.draw_data_fit_total import draw_data_fit_total
from visualization.draw_heat_map import draw_heat_map
from visualization.draw_histogram import draw_histogram
from visualization.draw_learning_curve_total import draw_learning_curve_total
from static.new_class import *

import warnings

warnings.filterwarnings("ignore")


# [模型]
class ChooseModelMetrics:
    @classmethod
    def choose(cls, cur_model):
        if cur_model == MN.linear_regression:
            return RegressionMetrics.get_metrics()
        elif cur_model == MN.polynomial_regression:
            return RegressionMetrics.get_metrics()
        elif cur_model == MN.logistic_regression:
            return ClassificationMetrics.get_metrics()
        elif cur_model == MN.decision_tree_classifier:
            return ClassificationMetrics.get_metrics()
        elif cur_model == MN.random_forest_classifier:
            return ClassificationMetrics.get_metrics()
        elif cur_model == MN.random_forest_regression:
            return RegressionMetrics.get_metrics()
        elif cur_model == MN.xgboost_classifier:
            return ClassificationMetrics.get_metrics()
        elif cur_model == MN.lightGBM_classifier:
            return ClassificationMetrics.get_metrics()
        elif cur_model == MN.gradient_boosting_regression:
            return RegressionMetrics.get_metrics()
        elif cur_model == MN.svm_classifier:
            return ClassificationMetrics.get_metrics()
        elif cur_model == MN.svm_regression:
            return RegressionMetrics.get_metrics()
        elif cur_model == MN.knn_classifier:
            return ClassificationMetrics.get_metrics()
        elif cur_model == MN.knn_regression:
            return RegressionMetrics.get_metrics()
        elif cur_model == MN.naive_bayes_classification:
            return ClassificationMetrics.get_metrics()


# [模型]
class ChooseModelParams:
    @classmethod
    def choose(cls, cur_model):
        if cur_model == MN.linear_regression:
            return LinearRegressionParams.get_params(Dataset.linear_regression_model_type)
        elif cur_model == MN.polynomial_regression:
            return PolynomialRegressionParams.get_params()
        elif cur_model == MN.logistic_regression:
            return LogisticRegressionParams.get_params()
        elif cur_model == MN.decision_tree_classifier:
            return DecisionTreeClassifierParams.get_params()
        elif cur_model == MN.random_forest_classifier:
            return RandomForestClassifierParams.get_params()
        elif cur_model == MN.random_forest_regression:
            return RandomForestRegressionParams.get_params()
        elif cur_model == MN.xgboost_classifier:
            return XgboostClassifierParams.get_params()
        elif cur_model == MN.lightGBM_classifier:
            return LightGBMClassifierParams.get_params()
        elif cur_model == MN.gradient_boosting_regression:
            return GradientBoostingParams.get_params()
        elif cur_model == MN.svm_classifier:
            return SVMClassifierParams.get_params()
        elif cur_model == MN.svm_regression:
            return SVMRegressionParams.get_params()
        elif cur_model == MN.knn_classifier:
            return KNNClassifierParams.get_params()
        elif cur_model == MN.knn_regression:
            return KNNRegressionParams.get_params()
        elif cur_model == MN.naive_bayes_classification:
            return NaiveBayesClassifierParams.get_params(Dataset.naive_bayes_classifier_model_type)


class StaticValue:
    max_num = 20


class FilePath:
    png_base = "./buffer/{}.png"
    excel_base = "./buffer/{}.xlsx"

    # [绘图]
    display_dataset = "current_excel_data"

    data_distribution_plot = "data_distribution_plot"
    descriptive_indicators_plot = "descriptive_indicators_plot"
    heatmap_plot = "heatmap_plot"
    learning_curve_plot = "learning_curve_plot"
    shap_beeswarm_plot = "shap_beeswarm_plot"
    data_fit_plot = "data_fit_plot"
    waterfall_plot = "waterfall_plot"
    force_plot = "force_plot"
    dependence_plot = "dependence_plot"


class MN:  # ModelName
    classification = "classification"
    regression = "regression"

    # [模型]
    linear_regression = "linear regressor"
    polynomial_regression = "polynomial regressor"
    logistic_regression = "logistic regressor"
    decision_tree_classifier = "decision tree classifier"
    random_forest_classifier = "random forest classifier"
    random_forest_regression = "random forest regressor"
    xgboost_classifier = "xgboost classifier"
    lightGBM_classifier = "lightGBM classifier"
    gradient_boosting_regression = "gradient boosting regressor"
    svm_classifier = "svm classifier"
    svm_regression = "svm regressor"
    knn_classifier = "knn classifier"
    knn_regression = "knn regressor"
    naive_bayes_classification = "naive bayes classification"

    # [绘图]
    data_distribution = "data_distribution"
    descriptive_indicators = "descriptive_indicators"
    heatmap = "heatmap"
    learning_curve = "learning_curve"
    shap_beeswarm = "shap_beeswarm"
    data_fit = "data_fit"
    waterfall = "waterfall"
    force = "force"
    dependence = "dependence"


class LN:  # LabelName
    choose_dataset_radio = "选择所需数据源 [必选]"
    display_total_col_num_text = "总列数"
    display_total_row_num_text = "总行数"
    display_na_list_text = "存在缺失值的列"
    del_all_na_col_button = "删除所有存在缺失值的列 [可选]"
    display_duplicate_num_text = "重复的行数"
    del_col_checkboxgroup = "选择所需删除的列"
    del_col_button = "删除 [可选]"
    remain_row_slider = "保留的行数"
    remain_row_button = "保留 [可选]"
    del_duplicate_button = "删除所有重复行 [可选]"
    encode_label_checkboxgroup = "选择所需标签编码的字符型数值列"
    display_encode_label_dataframe = "标签编码信息"
    encode_label_button = "字符型转数值型 [可选]"
    change_data_type_to_float_button = "将所有数据强制转换为浮点型（除第1列以外）[必选]"
    standardize_data_checkboxgroup = "选择所需标准化的列"
    standardize_data_button = "标准化 [可选]"
    select_as_y_radio = "选择因变量 [必选]"
    choose_assign_radio = "选择任务类型（同时会根据任务类型将第1列数据强制转换）[必选]"
    model_optimize_radio = "选择超参数优化方法"
    model_train_button = "训练"
    model_train_params_dataframe = "训练后的模型参数"
    model_train_metrics_dataframe = "训练后的模型指标"
    select_as_model_radio = "选择所需训练的模型"

    # [模型]
    linear_regression_model_radio = "选择线性回归的模型"
    naive_bayes_classification_model_radio = "选择朴素贝叶斯分类的模型"

    title_name_textbox = "标题"
    x_label_textbox = "x 轴名称"
    y_label_textbox = "y 轴名称"
    colors = ["颜色 {}".format(i) for i in range(StaticValue.max_num)]
    labels = ["图例 {}".format(i) for i in range(StaticValue.max_num)]

    # [绘图]
    heatmap_is_rotate = "x轴标签是否旋转"
    heatmap_checkboxgroup = "选择所需绘制系数热力图的列"
    heatmap_button = "绘制系数热力图"
    data_distribution_radio = "选择所需绘制数据分布图的列"
    data_distribution_is_rotate = "x轴标签是否旋转"
    data_distribution_button = "绘制数据分布图"
    descriptive_indicators_checkboxgroup = "选择所需绘制箱线统计图的列"
    descriptive_indicators_is_rotate = "x轴标签是否旋转"
    descriptive_indicators_button = "绘制箱线统计图"
    learning_curve_checkboxgroup = "选择所需绘制学习曲线图的模型"
    learning_curve_button = "绘制学习曲线图"
    shap_beeswarm_radio = "选择所需绘制特征蜂群图的模型"
    shap_beeswarm_type = "选择图像类型"
    shap_beeswarm_button = "绘制特征蜂群图"
    data_fit_checkboxgroup = "选择所需绘制数据拟合图的模型"
    data_fit_button = "绘制数据拟合图"
    waterfall_radio = "选择所需绘制特征瀑布图的模型"
    waterfall_number = "输入相关特征的变量索引"
    waterfall_button = "绘制特征瀑布图"
    force_radio = "选择所需绘制特征力图的模型"
    force_number = "输入相关特征的变量索引"
    force_button = "绘制特征力图"
    dependence_radio = "选择所需绘制特征依赖图的模型"
    dependence_col = "选择相应的列"
    dependence_button = "绘制特征依赖图"

    data_distribution_plot = "数据分布图"
    descriptive_indicators_plot = "箱线统计图"
    heatmap_plot = "系数热力图"
    learning_curve_plot = "学习曲线图"
    shap_beeswarm_plot = "特征蜂群图"
    data_fit_plot = "数据拟合图"
    waterfall_plot = "特征瀑布图"
    force_plot = "特征力图"
    dependence_plot = "特征依赖图"


def get_return_extra(is_visible, extra_gr_dict: dict = None):
    if is_visible:
        gr_dict = {
            draw_file: gr.File(Dataset.after_get_file(), visible=Dataset.check_file()),
        }

        if extra_gr_dict:
            gr_dict.update(extra_gr_dict)

        return gr_dict

    gr_dict = {
        draw_plot: gr.Plot(visible=False),
        draw_file: gr.File(visible=False),
    }

    gr_dict.update(dict(zip(colorpickers, [gr.ColorPicker(visible=False)] * StaticValue.max_num)))
    gr_dict.update(dict(zip(color_textboxs, [gr.Textbox(visible=False)] * StaticValue.max_num)))
    gr_dict.update(dict(zip(legend_labels_textboxs, [gr.Textbox(visible=False)] * StaticValue.max_num)))
    gr_dict.update({title_name_textbox: gr.Textbox(visible=False)})
    gr_dict.update({x_label_textbox: gr.Textbox(visible=False)})
    gr_dict.update({y_label_textbox: gr.Textbox(visible=False)})

    return gr_dict


def get_outputs():
    gr_set = {
        choose_custom_dataset_file,
        display_dataset_dataframe,
        display_total_col_num_text,
        display_total_row_num_text,
        display_na_list_text,
        del_all_na_col_button,
        display_duplicate_num_text,
        del_duplicate_button,
        del_col_checkboxgroup,
        del_col_button,
        remain_row_slider,
        remain_row_button,
        encode_label_button,
        display_encode_label_dataframe,
        encode_label_checkboxgroup,
        data_type_dataframe,
        change_data_type_to_float_button,
        standardize_data_checkboxgroup,
        standardize_data_button,
        select_as_y_radio,
        model_optimize_radio,
        model_train_button,
        model_train_checkbox,
        model_train_params_dataframe,
        model_train_metrics_dataframe,
        select_as_model_radio,
        choose_assign_radio,
        display_dataset,
        draw_plot,
        draw_file,
        title_name_textbox,
        x_label_textbox,
        y_label_textbox,

        # [模型]
        linear_regression_model_radio,
        naive_bayes_classification_model_radio,

        # [绘图]
        heatmap_is_rotate,
        heatmap_checkboxgroup,
        heatmap_button,
        data_distribution_radio,
        data_distribution_is_rotate,
        data_distribution_button,
        descriptive_indicators_checkboxgroup,
        descriptive_indicators_is_rotate,
        descriptive_indicators_dataframe,
        descriptive_indicators_button,
        learning_curve_checkboxgroup,
        learning_curve_button,
        shap_beeswarm_radio,
        shap_beeswarm_type,
        shap_beeswarm_button,
        data_fit_checkboxgroup,
        data_fit_button,
        waterfall_radio,
        waterfall_number,
        waterfall_button,
        force_radio,
        force_number,
        force_button,
        dependence_radio,
        dependence_col,
        dependence_button,
    }

    gr_set.update(set(colorpickers))
    gr_set.update(set(color_textboxs))
    gr_set.update(set(legend_labels_textboxs))

    return gr_set


def get_return(is_visible, extra_gr_dict: dict = None):
    if is_visible:
        gr_dict = {
            display_dataset_dataframe: gr.Dataframe(add_index_into_df(Dataset.data), type="pandas", visible=True),
            display_dataset: gr.File(Dataset.after_get_display_dataset_file(), visible=Dataset.check_display_dataset_file()),
            display_total_col_num_text: gr.Textbox(str(Dataset.get_total_col_num()), visible=True, label=LN.display_total_col_num_text),
            display_total_row_num_text: gr.Textbox(str(Dataset.get_total_row_num()), visible=True, label=LN.display_total_row_num_text),
            display_na_list_text: gr.Textbox(Dataset.get_na_list_str(), visible=True, label=LN.display_na_list_text),
            del_all_na_col_button: gr.Button(LN.del_all_na_col_button, visible=True),
            display_duplicate_num_text: gr.Textbox(str(Dataset.get_duplicate_num()), visible=True, label=LN.display_duplicate_num_text),
            del_duplicate_button: gr.Button(LN.del_duplicate_button, visible=True),
            del_col_checkboxgroup: gr.Checkboxgroup(Dataset.get_col_list(), visible=True, label=LN.del_col_checkboxgroup),
            del_col_button: gr.Button(LN.del_col_button, visible=True),
            remain_row_slider: gr.Slider(0, Dataset.get_max_num(), value=Dataset.get_total_row_num(), step=1, visible=True, label=LN.remain_row_slider),
            remain_row_button: gr.Button(LN.remain_row_button, visible=True),
            encode_label_button: gr.Button(LN.encode_label_button, visible=True),
            encode_label_checkboxgroup: gr.Checkboxgroup(Dataset.get_non_numeric_list(), visible=True, label=LN.encode_label_checkboxgroup),
            display_encode_label_dataframe: gr.Dataframe(visible=False),
            data_type_dataframe: gr.Dataframe(Dataset.get_data_type(), visible=True),
            change_data_type_to_float_button: gr.Button(LN.change_data_type_to_float_button, visible=True),
            select_as_y_radio: gr.Radio(Dataset.get_col_list(), visible=True, label=LN.select_as_y_radio),
            standardize_data_checkboxgroup: gr.Checkboxgroup(Dataset.get_non_standardized_data(), visible=True, label=LN.standardize_data_checkboxgroup),
            standardize_data_button: gr.Button(LN.standardize_data_button, visible=True),
            choose_assign_radio: gr.Radio(Dataset.get_assign_list(), visible=True, label=LN.choose_assign_radio),

            select_as_model_radio: gr.Radio(Dataset.get_model_list(), visible=Dataset.check_before_train(), label=LN.select_as_model_radio),
            model_optimize_radio: gr.Radio(Dataset.get_optimize_list(), visible=Dataset.check_before_train(), label=LN.model_optimize_radio),
            model_train_button: gr.Button(LN.model_train_button, visible=Dataset.check_before_train()),
            model_train_checkbox: gr.Checkbox(Dataset.get_model_container_status(), visible=Dataset.check_select_model(), label=Dataset.get_model_label()),
            model_train_params_dataframe: gr.Dataframe(Dataset.get_model_train_params_dataframe(), type="pandas", visible=Dataset.get_model_container_status()),
            model_train_metrics_dataframe: gr.Dataframe(Dataset.get_model_train_metrics_dataframe(), type="pandas", visible=Dataset.get_model_container_status()),

            draw_plot: gr.Plot(visible=False),
            draw_file: gr.File(visible=False),
            title_name_textbox: gr.Textbox(visible=False),
            x_label_textbox: gr.Textbox(visible=False),
            y_label_textbox: gr.Textbox(visible=False),

            # [模型]
            linear_regression_model_radio: gr.Radio(Dataset.get_linear_regression_model_list(), visible=Dataset.get_linear_regression_mark(), label=LN.linear_regression_model_radio),
            naive_bayes_classification_model_radio: gr.Radio(Dataset.get_naive_bayes_classifier_model_list(), visible=Dataset.get_naive_bayes_classifier_mark(), label=LN.naive_bayes_classification_model_radio),

            # [绘图]
            heatmap_checkboxgroup: gr.Checkboxgroup(Dataset.get_float_col_list(), visible=True, label=LN.heatmap_checkboxgroup),
            heatmap_is_rotate: gr.Checkbox(visible=True, label=LN.heatmap_is_rotate),
            heatmap_button: gr.Button(LN.heatmap_button, visible=True),
            descriptive_indicators_checkboxgroup: gr.Checkboxgroup(Dataset.get_float_col_list(), visible=True, label=LN.descriptive_indicators_checkboxgroup),
            data_distribution_radio: gr.Radio(Dataset.get_str_col_list(), visible=True, label=LN.data_distribution_radio),
            data_distribution_is_rotate: gr.Checkbox(visible=True, label=LN.data_distribution_is_rotate),
            data_distribution_button: gr.Button(LN.data_distribution_button, visible=True),
            descriptive_indicators_is_rotate: gr.Checkbox(visible=True, label=LN.descriptive_indicators_is_rotate),
            descriptive_indicators_dataframe: gr.Dataframe(Dataset.get_descriptive_indicators_df(), type="pandas", visible=Dataset.check_descriptive_indicators_df()),
            descriptive_indicators_button: gr.Button(LN.descriptive_indicators_button, visible=True),
            learning_curve_checkboxgroup: gr.Checkboxgroup(Dataset.get_trained_model_list(), visible=Dataset.check_before_train(), label=LN.learning_curve_checkboxgroup),
            learning_curve_button: gr.Button(LN.learning_curve_button, visible=Dataset.check_before_train()),
            shap_beeswarm_radio: gr.Radio(Dataset.get_trained_model_list(), visible=Dataset.check_before_train(), label=LN.shap_beeswarm_radio),
            shap_beeswarm_type: gr.Radio(Dataset.get_shap_beeswarm_plot_type(), visible=Dataset.check_before_train(), label=LN.shap_beeswarm_type),
            shap_beeswarm_button: gr.Button(LN.shap_beeswarm_button, visible=Dataset.check_before_train()),
            data_fit_checkboxgroup: gr.Checkboxgroup(Dataset.get_trained_model_list(), visible=Dataset.check_before_train(), label=LN.data_fit_checkboxgroup),
            data_fit_button: gr.Button(LN.data_fit_button, visible=Dataset.check_before_train()),
            waterfall_radio: gr.Radio(Dataset.get_trained_model_list(), visible=Dataset.check_before_train(), label=LN.waterfall_radio),
            waterfall_number: gr.Slider(0, Dataset.get_total_row_num(), value=0, step=1, visible=Dataset.check_before_train(), label=LN.waterfall_number),
            waterfall_button: gr.Button(LN.waterfall_button, visible=Dataset.check_before_train()),
            force_radio: gr.Radio(Dataset.get_trained_model_list(), visible=Dataset.check_before_train(), label=LN.force_radio),
            force_number: gr.Slider(0, Dataset.get_total_row_num(), value=0, step=1, visible=Dataset.check_before_train(), label=LN.force_number),
            force_button: gr.Button(LN.force_button, visible=Dataset.check_before_train()),
            dependence_radio: gr.Radio(Dataset.get_trained_model_list(), visible=Dataset.check_before_train(), label=LN.dependence_radio),
            dependence_col: gr.Radio(Dataset.get_col_list(), visible=Dataset.check_before_train(), label=LN.dependence_col),
            dependence_button: gr.Button(LN.dependence_button, visible=Dataset.check_before_train()),

        }

        gr_dict.update(dict(zip(colorpickers, [gr.ColorPicker(visible=False)] * StaticValue.max_num)))
        gr_dict.update(dict(zip(color_textboxs, [gr.Textbox(visible=False)] * StaticValue.max_num)))
        gr_dict.update(dict(zip(legend_labels_textboxs, [gr.Textbox(visible=False)] * StaticValue.max_num)))

        if extra_gr_dict:
            gr_dict.update(extra_gr_dict)

        return gr_dict

    gr_dict = {
        choose_custom_dataset_file: gr.File(None, visible=True),
        display_dataset_dataframe: gr.Dataframe(visible=False),
        display_dataset: gr.File(visible=False),
        display_total_col_num_text: gr.Textbox(visible=False),
        display_total_row_num_text: gr.Textbox(visible=False),
        display_na_list_text: gr.Textbox(visible=False),
        del_all_na_col_button: gr.Button(visible=False),
        display_duplicate_num_text: gr.Textbox(visible=False),
        del_duplicate_button: gr.Button(visible=False),
        del_col_checkboxgroup: gr.Checkboxgroup(visible=False),
        del_col_button: gr.Button(visible=False),
        remain_row_slider: gr.Slider(visible=False),
        encode_label_button: gr.Button(visible=False),
        display_encode_label_dataframe: gr.Dataframe(visible=False),
        encode_label_checkboxgroup: gr.Checkboxgroup(visible=False),
        data_type_dataframe: gr.Dataframe(visible=False),
        change_data_type_to_float_button: gr.Button(visible=False),
        standardize_data_checkboxgroup: gr.Checkboxgroup(visible=False),
        standardize_data_button: gr.Button(visible=False),
        select_as_y_radio: gr.Radio(visible=False),
        model_optimize_radio: gr.Radio(visible=False),
        model_train_button: gr.Button(visible=False),
        model_train_checkbox: gr.Checkbox(visible=False),
        model_train_metrics_dataframe: gr.Dataframe(visible=False),
        model_train_params_dataframe: gr.Dataframe(visible=False),
        select_as_model_radio: gr.Radio(visible=False),
        choose_assign_radio: gr.Radio(visible=False),

        draw_plot: gr.Plot(visible=False),
        draw_file: gr.File(visible=False),
        title_name_textbox: gr.Textbox(visible=False),
        x_label_textbox: gr.Textbox(visible=False),
        y_label_textbox: gr.Textbox(visible=False),

        # [模型]
        linear_regression_model_radio: gr.Radio(visible=False),
        naive_bayes_classification_model_radio: gr.Radio(visible=False),

        # [绘图]
        heatmap_checkboxgroup: gr.Checkboxgroup(visible=False),
        heatmap_is_rotate: gr.Checkbox(visible=False),
        heatmap_button: gr.Button(visible=False),
        data_distribution_radio: gr.Radio(visible=False),
        data_distribution_is_rotate: gr.Checkbox(visible=False),
        data_distribution_button: gr.Button(visible=False),
        descriptive_indicators_checkboxgroup: gr.Checkboxgroup(visible=False),
        descriptive_indicators_is_rotate: gr.Checkbox(visible=False),
        descriptive_indicators_dataframe: gr.Dataframe(visible=False),
        descriptive_indicators_button: gr.Button(visible=False),
        learning_curve_checkboxgroup: gr.Checkboxgroup(visible=False),
        learning_curve_button: gr.Button(visible=False),
        shap_beeswarm_radio: gr.Radio(visible=False),
        shap_beeswarm_type: gr.Radio(visible=False),
        shap_beeswarm_button: gr.Button(visible=False),
        data_fit_checkboxgroup: gr.Checkboxgroup(visible=False),
        data_fit_button: gr.Button(visible=False),
        waterfall_radio: gr.Radio(visible=False),
        waterfall_number: gr.Slider(visible=False),
        waterfall_button: gr.Button(visible=False),
        force_radio: gr.Radio(visible=False),
        force_number: gr.Slider(visible=False),
        force_button: gr.Button(visible=False),
        dependence_radio: gr.Radio(visible=False),
        dependence_col: gr.Radio(visible=False),
        dependence_button: gr.Button(visible=False),
    }

    gr_dict.update(dict(zip(colorpickers, [gr.ColorPicker(visible=False)] * StaticValue.max_num)))
    gr_dict.update(dict(zip(color_textboxs, [gr.Textbox(visible=False)] * StaticValue.max_num)))
    gr_dict.update(dict(zip(legend_labels_textboxs, [gr.Textbox(visible=False)] * StaticValue.max_num)))

    return gr_dict


class Dataset:
    file = ""
    data = pd.DataFrame()

    na_list = []
    non_numeric_list = []
    str2int_mappings = {}
    max_num = 0
    data_copy = pd.DataFrame()
    assign = ""
    cur_model = ""
    select_y_mark = False

    descriptive_indicators_df = pd.DataFrame()

    linear_regression_model_type = ""
    naive_bayes_classifier_model_type = ""

    container_dict = {
        # [模型]
        MN.linear_regression: Container(),
        MN.polynomial_regression: Container(),
        MN.logistic_regression: Container(),
        MN.decision_tree_classifier: Container(),
        MN.random_forest_classifier: Container(),
        MN.random_forest_regression: Container(),
        MN.xgboost_classifier: Container(),
        MN.lightGBM_classifier: Container(),
        MN.gradient_boosting_regression: Container(),
        MN.svm_classifier: Container(),
        MN.svm_regression: Container(),
        MN.knn_classifier: Container(),
        MN.knn_regression: Container(),
        MN.naive_bayes_classification: Container(),
    }

    visualize = ""

    @classmethod
    def check_descriptive_indicators_df(cls):
        return True if not cls.descriptive_indicators_df.empty else False

    @classmethod
    def get_descriptive_indicators_df(cls):
        return cls.descriptive_indicators_df

    @classmethod
    def get_notes(cls):
        notes = ""
        with open("./data/notes.md", "r", encoding="utf-8") as f:
            notes = str(f.read())
        return notes

    @classmethod
    def get_dataset_list(cls):
        return ["自定义", "Iris Dataset", "Wine Dataset", "Breast Cancer Dataset", "Diabetes Dataset", "California Housing Dataset"]

    @classmethod
    def get_col_list(cls):
        return [x for x in cls.data.columns.values]

    @classmethod
    def get_na_list_str(cls) -> str:
        na_series = cls.data.isna().any(axis=0)
        na_list = []
        na_list_str = ""
        for i in range(len(na_series)):
            cur_value = na_series[i]
            cur_index = na_series.index[i]
            if cur_value:
                na_list_str += cur_index + ", "
                na_list.append(cur_index)

        na_list_str = na_list_str.rstrip(", ")

        cls.na_list = na_list

        if not na_list:
            return "无"

        return na_list_str

    @classmethod
    def get_total_col_num(cls) -> int:
        return len(cls.data.columns)

    @classmethod
    def get_total_row_num(cls) -> int:
        return len(cls.data)

    @classmethod
    def update(cls, file: str, data: pd.DataFrame):
        cls.file = file
        cls.data = data
        cls.max_num = len(data)
        cls.data_copy = data

    @classmethod
    def clear(cls):
        cls.file = ""
        cls.data = pd.DataFrame()

    @classmethod
    def get_display_dataset_file(cls):
        file_path = FilePath.excel_base.format(FilePath.display_dataset)

        return file_path

    @classmethod
    def check_display_dataset_file(cls):
        return os.path.exists(cls.get_display_dataset_file())

    @classmethod
    def after_get_display_dataset_file(cls):
        if not cls.data.empty:
            cls.data.to_excel(cls.get_display_dataset_file(), index=False)

        return cls.get_display_dataset_file() if cls.check_display_dataset_file() else None

    @classmethod
    def del_col(cls, col_list: list):
        for col in col_list:
            if col in cls.data.columns.values:
                cls.data.drop(col, axis=1, inplace=True)

    @classmethod
    def get_max_num(cls):
        return cls.max_num

    @classmethod
    def remain_row(cls, num):
        cls.data = cls.data_copy.iloc[:num, :]

    @classmethod
    def del_all_na_col(cls):
        for col in cls.na_list:
            if col in cls.data.columns.values:
                cls.data.drop(col, axis=1, inplace=True)

    @classmethod
    def get_duplicate_num(cls):
        data_copy = copy.deepcopy(cls.data)
        return len(cls.data) - len(data_copy.drop_duplicates())

    @classmethod
    def del_duplicate(cls):
        cls.data = cls.data.drop_duplicates().reset_index().drop("index", axis=1)

    @classmethod
    def encode_label(cls, col_list: list, extra_mark=False):
        data_copy = copy.deepcopy(cls.data)

        str2int_mappings = dict(zip(col_list, [{} for _ in range(len(col_list))]))

        for col in str2int_mappings.keys():
            keys = np.array(data_copy[col].drop_duplicates())
            values = [x for x in range(len(keys))]
            str2int_mappings[col] = dict(zip(keys, values))

        for col, mapping in str2int_mappings.items():
            series = data_copy[col]

            for k, v in mapping.items():
                series.replace(k, v, inplace=True)
            data_copy[col] = series

        for k, v in str2int_mappings.items():
            if np.nan in v.keys():
                v.update({"nan": v.pop(np.nan)})
                str2int_mappings[k] = v

        if extra_mark:
            return data_copy
        else:
            cls.data = data_copy
            cls.str2int_mappings = str2int_mappings

    @classmethod
    def get_str2int_mappings_df(cls):
        columns_list = ["列名", "字符型", "数值型"]
        str2int_mappings_df = pd.DataFrame(columns=columns_list)

        for k, v in cls.str2int_mappings.items():
            cur_df = pd.DataFrame(columns=columns_list)
            cur_df["列名"] = pd.DataFrame([k] * len(v.keys()))
            cur_df["字符型"] = pd.DataFrame([x for x in v.keys()])
            cur_df["数值型"] = pd.DataFrame([x for x in v.values()])

            str2int_mappings_df = pd.concat([str2int_mappings_df, cur_df], axis=0)

            blank_df = pd.DataFrame(columns=columns_list)
            blank_df.loc[0] = ["", "", ""]
            str2int_mappings_df = pd.concat([str2int_mappings_df, blank_df], axis=0)

        return str2int_mappings_df.iloc[:-1, :]

    @classmethod
    def get_non_numeric_list(cls):
        data_copy = copy.deepcopy(cls.data)
        data_copy = data_copy.astype(str)

        non_numeric_list = []
        for col in data_copy.columns.values:
            if pd.to_numeric(data_copy[col], errors="coerce").isnull().values.any():
                non_numeric_list.append(col)

        cls.non_numeric_list = non_numeric_list

        return non_numeric_list

    @classmethod
    def get_data_type(cls):
        columns_list = ["列名", "数据类型"]

        data_type_dict = {}

        for col in cls.data.columns.values:
            data_type_dict[col] = cls.data[col].dtype.name

        data_type_df = pd.DataFrame(columns=columns_list)
        data_type_df["列名"] = [x for x in data_type_dict.keys()]
        data_type_df["数据类型"] = [x for x in data_type_dict.values()]

        return data_type_df

    @classmethod
    def change_data_type_to_float(cls):
        data_copy = cls.data

        for i, col in enumerate(data_copy.columns.values):
            if i != 0:
                data_copy[col] = data_copy[col].astype(float)

        cls.data = data_copy

    @classmethod
    def get_non_standardized_data(cls):
        not_standardized_data_list = []

        for col in cls.data.columns.values:
            if cls.data[col].dtype.name in ["int64", "float64"]:
                if not np.array_equal(np.round(preprocessing.scale(cls.data[col]), decimals=2),
                                      np.round(cls.data[col].values.round(2), decimals=2)):
                    not_standardized_data_list.append(col)

        return not_standardized_data_list

    @classmethod
    def check_before_train(cls):
        if cls.assign == "" or not cls.select_y_mark:
            return False

        for i, col in enumerate(cls.data.columns.values):
            if i == 0:
                if not (all(isinstance(x, str) for x in cls.data.iloc[:, 0]) or all(isinstance(x, float) for x in cls.data.iloc[:, 0])):
                    return False
            else:
                if cls.data[col].dtype.name != "float64":
                    return False

        return True

    @classmethod
    def standardize_data(cls, col_list: list):
        for col in col_list:
            cls.data[col] = preprocessing.scale(cls.data[col])

    @classmethod
    def select_as_y(cls, col: str):
        cls.data = pd.concat([cls.data[col], cls.data.drop(col, axis=1)], axis=1)
        cls.select_y_mark = True

    @classmethod
    def get_optimize_list(cls):
        return ["无", "网格搜索", "贝叶斯优化"]

    @classmethod
    def get_optimize_name_mapping(cls):
        return dict(zip(cls.get_optimize_list(), ["None", "grid_search", "bayes_search"]))

    @classmethod
    def get_linear_regression_model_list(cls):
        return ["线性回归", "Lasso回归", "Ridge回归", "弹性网络回归"]

    @classmethod
    def get_naive_bayes_classifier_model_list(cls):
        return ["多项式朴素贝叶斯分类", "高斯朴素贝叶斯分类", "补充朴素贝叶斯分类"]

    @classmethod
    def get_linear_regression_model_name_mapping(cls):
        return dict(zip(cls.get_linear_regression_model_list(), ["LinearRegression", "Lasso", "Ridge", "ElasticNet"]))

    @classmethod
    def get_naive_bayes_classifier_model_name_mapping(cls):
        return dict(zip(cls.get_naive_bayes_classifier_model_list(), ["MultinomialNB", "GaussianNB", "ComplementNB"]))

    @classmethod
    def train_model(cls, optimize, linear_regression_model_type=None, naive_bayes_classifier_model_type=None):
        optimize = cls.get_optimize_name_mapping()[optimize]

        data_copy = cls.data
        if cls.assign == MN.classification:
            data_copy = cls.encode_label([cls.data.columns.values[0]], True)

        x_train, x_test, y_train, y_test = train_test_split(
            data_copy.values[:, 1:],
            data_copy.values[:, :1],
            random_state=Config.RANDOM_STATE,
            train_size=0.8
        )
        container = Container(x_train, y_train, x_test, y_test, optimize)

        # [模型]
        if cls.cur_model == MN.linear_regression:
            cls.linear_regression_model_type = cls.get_linear_regression_model_name_mapping()[linear_regression_model_type]
            container = linear_regression(container, cls.linear_regression_model_type)
        elif cls.cur_model == MN.polynomial_regression:
            container = polynomial_regression(container)
        elif cls.cur_model == MN.logistic_regression:
            container = logistic_regression(container)
        elif cls.cur_model == MN.decision_tree_classifier:
            container = decision_tree_classifier(container)
        elif cls.cur_model == MN.random_forest_classifier:
            container = random_forest_classifier(container)
        elif cls.cur_model == MN.random_forest_regression:
            container = random_forest_regression(container)
        elif cls.cur_model == MN.xgboost_classifier:
            container = xgboost_classifier(container)
        elif cls.cur_model == MN.lightGBM_classifier:
            container = lightGBM_classifier(container)
        elif cls.cur_model == MN.gradient_boosting_regression:
            container = gradient_boosting_regression(container)
        elif cls.cur_model == MN.svm_classifier:
            container = svm_classifier(container)
        elif cls.cur_model == MN.svm_regression:
            container = svm_regression(container)
        elif cls.cur_model == MN.knn_classifier:
            container = knn_classifier(container)
        elif cls.cur_model == MN.knn_regression:
            container = knn_regression(container)
        elif cls.cur_model == MN.naive_bayes_classification:
            cls.naive_bayes_classifier_model_type = cls.get_naive_bayes_classifier_model_name_mapping()[naive_bayes_classifier_model_type]
            container = naive_bayes_classification(container, cls.naive_bayes_classifier_model_type)

        cls.container_dict[cls.cur_model] = container

    @classmethod
    def get_model_container_status(cls):
        return True if cls.cur_model != "" and cls.container_dict[cls.cur_model].get_status() == "trained" else False

    @classmethod
    def get_model_label(cls):
        return str(cls.get_model_name_mapping()[cls.cur_model]) + "模型是否完成训练" if cls.cur_model != "" else ""

    @classmethod
    def check_select_model(cls):
        return True if cls.cur_model != "" and cls.check_before_train() else False

    @classmethod
    def get_model_name(cls):
        return [x for x in cls.container_dict.keys()]

    # [模型]
    @classmethod
    def get_model_chinese_name(cls):
        return ["线性回归", "多项式回归", "逻辑斯谛分类", "决策树分类", "随机森林分类", "随机森林回归", "XGBoost分类", "LightGBM分类",
                "梯度提升回归", "支持向量机分类", "支持向量机回归", "K-最近邻分类", "K-最近邻回归", "朴素贝叶斯分类"]

    @classmethod
    def get_model_name_mapping(cls):
        return dict(zip(cls.get_model_name(), cls.get_model_chinese_name()))

    @classmethod
    def get_model_name_mapping_reverse(cls):
        return dict(zip(cls.get_model_chinese_name(), cls.get_model_name()))

    @classmethod
    def get_trained_model_list(cls):
        trained_model_list = []

        for model_name, container in cls.container_dict.items():
            if container.get_status() == "trained":
                trained_model_list.append(cls.get_model_name_mapping()[model_name])

        return trained_model_list

    @classmethod
    def draw_plot(cls, select_model, color_list: list, label_list: list, name: str, x_label: str, y_label: str, is_default: bool):
        # [绘图]
        if cls.visualize == MN.learning_curve:
            return cls.draw_learning_curve_plot(select_model, color_list, label_list, name, x_label, y_label, is_default)
        elif cls.visualize == MN.shap_beeswarm:
            return cls.draw_shap_beeswarm_plot(select_model, color_list, label_list, name, x_label, y_label, is_default)
        elif cls.visualize == MN.data_fit:
            return cls.draw_data_fit_plot(select_model, color_list, label_list, name, x_label, y_label, is_default)
        elif cls.visualize == MN.waterfall:
            return cls.draw_waterfall_plot(select_model, color_list, label_list, name, x_label, y_label, is_default)
        elif cls.visualize == MN.force:
            return cls.draw_force_plot(select_model, color_list, label_list, name, x_label, y_label, is_default)
        elif cls.visualize == MN.dependence:
            return cls.draw_dependence_plot(select_model, color_list, label_list, name, x_label, y_label, is_default)
        elif cls.visualize == MN.data_distribution:
            return cls.draw_data_distribution_plot(select_model, color_list, label_list, name, x_label, y_label, is_default)
        elif cls.visualize == MN.descriptive_indicators:
            return cls.draw_descriptive_indicators_plot(select_model, color_list, label_list, name, x_label, y_label, is_default)
        elif cls.visualize == MN.heatmap:
            return cls.draw_heatmap_plot(select_model, color_list, label_list, name, x_label, y_label, is_default)

    @classmethod
    def draw_heatmap_plot(cls, select_model, color_list: list, label_list: list, name: str, x_label: str, y_label: str, is_default: bool):
        color_cur_list = [] if is_default else color_list
        x_cur_label = "Indicators" if is_default else x_label
        y_cur_label = "Value" if is_default else y_label
        cur_name = "" if is_default else name

        paint_object = PaintObject()
        paint_object.set_color_cur_list(color_cur_list)
        paint_object.set_x_cur_label(x_cur_label)
        paint_object.set_y_cur_label(y_cur_label)
        paint_object.set_name(cur_name)

        if cls.check_col_list(select_model.get_heatmap_col()):
            return cls.error_return_draw(paint_object)

        df = Dataset.data
        heatmap_col = select_model.get_heatmap_col()

        covX = np.around(np.corrcoef(df[heatmap_col].T), decimals=3)
        std_dev = np.sqrt(np.diag(covX))
        pearson_matrix = covX / np.outer(std_dev, std_dev)

        return draw_heat_map(pearson_matrix, heatmap_col, paint_object, select_model.get_heatmap_is_rotate())

    @classmethod
    def draw_descriptive_indicators_plot(cls, select_model, color_list: list, label_list: list, name: str, x_label: str, y_label: str, is_default: bool):
        color_cur_list = [Config.COLORS[random.randint(0, 11)]]*3 if is_default else color_list
        x_cur_label = "Indicators" if is_default else x_label
        y_cur_label = "Value" if is_default else y_label
        cur_name = "" if is_default else name

        paint_object = PaintObject()
        paint_object.set_color_cur_list(color_cur_list)
        paint_object.set_x_cur_label(x_cur_label)
        paint_object.set_y_cur_label(y_cur_label)
        paint_object.set_name(cur_name)

        if cls.check_col_list(select_model.get_descriptive_indicators_col()):
            return cls.error_return_draw(paint_object)

        df = Dataset.data
        descriptive_indicators_col = select_model.get_descriptive_indicators_col()

        descriptive_indicators_df = pd.DataFrame(
            index=list(descriptive_indicators_col),
            columns=[
                "Name",
                "Min",
                "Max",
                "Avg",
                "Standard Deviation",
                "Standard Error",
                "Upper Quartile",
                "Median",
                "Lower Quartile",
                "Interquartile Distance",
                "Kurtosis",
                "Skewness",
                "Coefficient of Variation"
            ]
        )

        for col in descriptive_indicators_col:
            descriptive_indicators_df["Name"][col] = col
            descriptive_indicators_df["Min"][col] = df[col].min()
            descriptive_indicators_df["Max"][col] = df[col].max()
            descriptive_indicators_df["Avg"][col] = df[col].mean()
            descriptive_indicators_df["Standard Deviation"][col] = df[col].std()
            descriptive_indicators_df["Standard Error"][col] = descriptive_indicators_df["Standard Deviation"][
                                                                   col] / math.sqrt(len(df[col]))
            descriptive_indicators_df["Upper Quartile"][col] = df[col].quantile(0.75)
            descriptive_indicators_df["Median"][col] = df[col].quantile(0.5)
            descriptive_indicators_df["Lower Quartile"][col] = df[col].quantile(0.25)
            descriptive_indicators_df["Interquartile Distance"][col] = descriptive_indicators_df["Lower Quartile"][
                                                                           col] - \
                                                                       descriptive_indicators_df["Upper Quartile"][col]
            descriptive_indicators_df["Kurtosis"][col] = df[col].kurt()
            descriptive_indicators_df["Skewness"][col] = df[col].skew()
            descriptive_indicators_df["Coefficient of Variation"][col] = \
            descriptive_indicators_df["Standard Deviation"][col] / descriptive_indicators_df["Avg"][col]

        cls.descriptive_indicators_df = descriptive_indicators_df

        cur_df = df[descriptive_indicators_col].astype(float)

        return draw_boxplot(cur_df, paint_object, select_model.get_descriptive_indicators_is_rotate())

    @classmethod
    def error_return_draw(cls, paint_object):
        cur_plt = plt.Figure(figsize=(10, 8))
        return cur_plt, paint_object

    @classmethod
    def draw_data_distribution_plot(cls, select_model, color_list: list, label_list: list, name: str, x_label: str, y_label: str, is_default: bool):
        cur_col = select_model.get_data_distribution_col()

        color_cur_list = [Config.COLORS[random.randint(0, 11)]] if is_default else color_list
        x_cur_label = cur_col if is_default else x_label
        y_cur_label = "Num" if is_default else y_label
        cur_name = "" if is_default else name

        paint_object = PaintObject()
        paint_object.set_color_cur_list(color_cur_list)
        paint_object.set_x_cur_label(x_cur_label)
        paint_object.set_y_cur_label(y_cur_label)
        paint_object.set_name(cur_name)

        if cls.check_col_list(select_model.get_data_distribution_col()):
            return cls.error_return_draw(paint_object)

        counts_mapping = {}
        for x in Dataset.data.loc[:, cur_col].values:
            if x in counts_mapping.keys():
                counts_mapping[x] += 1
            else:
                counts_mapping[x] = 1

        sorting = sorted(counts_mapping.items(), reverse=True, key=lambda m: m[1])
        nums = [x[1] for x in sorting]
        labels = [x[0] for x in sorting]

        if Dataset.check_data_distribution_type(cur_col) == "histogram":
            return draw_histogram(nums, labels, paint_object, select_model.get_data_distribution_is_rotate())
        else:
            return cls.error_return_draw(paint_object)

    @classmethod
    def draw_dependence_plot(cls, select_model, color_list: list, label_list: list, name: str, x_label: str, y_label: str, is_default: bool):
        model_name = select_model.get_models()

        model_name = cls.get_model_name_mapping_reverse()[model_name]
        container = cls.container_dict[model_name]

        # color_cur_list = Config.COLORS if is_default else color_list
        # label_cur_list = [x for x in learning_curve_dict.keys()] if is_default else label_list
        # x_cur_label = "Train Sizes" if is_default else x_label
        # y_cur_label = "Accuracy" if is_default else y_label
        cur_name = "" if is_default else name

        paint_object = PaintObject()
        # paint_object.set_color_cur_list(color_cur_list)
        # paint_object.set_label_cur_list(label_cur_list)
        # paint_object.set_x_cur_label(x_cur_label)
        # paint_object.set_y_cur_label(y_cur_label)
        paint_object.set_name(cur_name)

        return draw_dependence(container.get_model(), container.x_train, cls.data.columns.values.tolist()[1:], select_model.get_dependence_col(), paint_object)

    @classmethod
    def draw_force_plot(cls, select_model, color_list: list, label_list: list, name: str, x_label: str, y_label: str, is_default: bool):
        model_name = select_model.get_models()

        model_name = cls.get_model_name_mapping_reverse()[model_name]
        container = cls.container_dict[model_name]

        # color_cur_list = Config.COLORS if is_default else color_list
        # label_cur_list = [x for x in learning_curve_dict.keys()] if is_default else label_list
        # x_cur_label = "Train Sizes" if is_default else x_label
        # y_cur_label = "Accuracy" if is_default else y_label
        cur_name = "" if is_default else name

        paint_object = PaintObject()
        # paint_object.set_color_cur_list(color_cur_list)
        # paint_object.set_label_cur_list(label_cur_list)
        # paint_object.set_x_cur_label(x_cur_label)
        # paint_object.set_y_cur_label(y_cur_label)
        paint_object.set_name(cur_name)

        return draw_force(container.get_model(), container.x_train, cls.data.columns.values.tolist()[1:], select_model.get_force_number(), paint_object)

    @classmethod
    def draw_waterfall_plot(cls, select_model, color_list: list, label_list: list, name: str, x_label: str, y_label: str, is_default: bool):
        model_name = select_model.get_models()

        model_name = cls.get_model_name_mapping_reverse()[model_name]
        container = cls.container_dict[model_name]

        # color_cur_list = Config.COLORS if is_default else color_list
        # label_cur_list = [x for x in learning_curve_dict.keys()] if is_default else label_list
        # x_cur_label = "Train Sizes" if is_default else x_label
        # y_cur_label = "Accuracy" if is_default else y_label
        cur_name = "" if is_default else name

        paint_object = PaintObject()
        # paint_object.set_color_cur_list(color_cur_list)
        # paint_object.set_label_cur_list(label_cur_list)
        # paint_object.set_x_cur_label(x_cur_label)
        # paint_object.set_y_cur_label(y_cur_label)
        paint_object.set_name(cur_name)

        return draw_waterfall(container.get_model(), container.x_train, cls.data.columns.values.tolist()[1:], select_model.get_waterfall_number(), paint_object)

    @classmethod
    def draw_learning_curve_plot(cls, select_model, color_list: list, label_list: list, name: str, x_label: str, y_label: str, is_default: bool):
        cur_dict = {}

        model_list = select_model.get_models()

        for model_name in model_list:
            model_name = cls.get_model_name_mapping_reverse()[model_name]
            cur_dict[model_name] = cls.container_dict[model_name].get_learning_curve_values()

        color_cur_list = Config.COLORS if is_default else color_list
        if is_default:
            label_cur_list = []
            for x in cur_dict.keys():
                label_cur_list.append("train " + str(x))
                label_cur_list.append("validation " + str(x))
        else:
            label_cur_list = label_list

        x_cur_label = "Train Sizes" if is_default else x_label
        y_cur_label = "Accuracy" if is_default else y_label
        cur_name = "" if is_default else name

        paint_object = PaintObject()
        paint_object.set_color_cur_list(color_cur_list)
        paint_object.set_label_cur_list(label_cur_list)
        paint_object.set_x_cur_label(x_cur_label)
        paint_object.set_y_cur_label(y_cur_label)
        paint_object.set_name(cur_name)

        if cls.check_cur_dict(cur_dict):
            return cls.error_return_draw(paint_object)

        return draw_learning_curve_total(cur_dict, paint_object)

    @classmethod
    def draw_shap_beeswarm_plot(cls, select_model, color_list: list, label_list: list, name: str, x_label: str, y_label: str, is_default: bool):
        model_name = select_model.get_models()

        model_name = cls.get_model_name_mapping_reverse()[model_name]
        container = cls.container_dict[model_name]

        # color_cur_list = Config.COLORS if is_default else color_list
        # label_cur_list = [x for x in learning_curve_dict.keys()] if is_default else label_list
        # x_cur_label = "Train Sizes" if is_default else x_label
        # y_cur_label = "Accuracy" if is_default else y_label
        cur_name = "" if is_default else name

        paint_object = PaintObject()
        # paint_object.set_color_cur_list(color_cur_list)
        # paint_object.set_label_cur_list(label_cur_list)
        # paint_object.set_x_cur_label(x_cur_label)
        # paint_object.set_y_cur_label(y_cur_label)
        paint_object.set_name(cur_name)

        return draw_shap_beeswarm(container.get_model(), container.x_train, cls.data.columns.values.tolist()[1:], select_model.get_beeswarm_plot_type(), paint_object)

    @classmethod
    def draw_data_fit_plot(cls, select_model, color_list: list, label_list: list, name: str, x_label: str, y_label: str, is_default: bool):
        cur_dict = {}

        model_list = select_model.get_models()

        for model_name in model_list:
            model_name = cls.get_model_name_mapping_reverse()[model_name]
            cur_dict[model_name] = cls.container_dict[model_name].get_data_fit_values()

        color_cur_list = Config.COLORS if is_default else color_list
        if is_default:
            label_cur_list = []
            for x in cur_dict.keys():
                label_cur_list.append("pred " + str(x))
            label_cur_list.append("real data")
        else:
            label_cur_list = label_list

        x_cur_label = "n value" if is_default else x_label
        y_cur_label = "y value" if is_default else y_label
        cur_name = "" if is_default else name

        paint_object = PaintObject()
        paint_object.set_color_cur_list(color_cur_list)
        paint_object.set_label_cur_list(label_cur_list)
        paint_object.set_x_cur_label(x_cur_label)
        paint_object.set_y_cur_label(y_cur_label)
        paint_object.set_name(cur_name)

        return draw_data_fit_total(cur_dict, paint_object)

    @classmethod
    def get_shap_beeswarm_plot_type(cls):
        return ["bar", "violin"]

    @classmethod
    def get_file(cls):
        # [绘图]
        if cls.visualize == MN.learning_curve:
            return FilePath.png_base.format(FilePath.learning_curve_plot)
        elif cls.visualize == MN.shap_beeswarm:
            return FilePath.png_base.format(FilePath.shap_beeswarm_plot)
        elif cls.visualize == MN.data_fit:
            return FilePath.png_base.format(FilePath.data_fit_plot)
        elif cls.visualize == MN.waterfall:
            return FilePath.png_base.format(FilePath.waterfall_plot)
        elif cls.visualize == MN.force:
            return FilePath.png_base.format(FilePath.force_plot)
        elif cls.visualize == MN.dependence:
            return FilePath.png_base.format(FilePath.dependence_plot)
        elif cls.visualize == MN.data_distribution:
            return FilePath.png_base.format(FilePath.data_distribution_plot)
        elif cls.visualize == MN.descriptive_indicators:
            return FilePath.png_base.format(FilePath.descriptive_indicators_plot)
        elif cls.visualize == MN.heatmap:
            return FilePath.png_base.format(FilePath.heatmap_plot)

    @classmethod
    def check_file(cls):
        return os.path.exists(cls.get_file())

    @classmethod
    def after_get_file(cls):
        return cls.get_file() if cls.check_file() else None

    @classmethod
    def get_model_list(cls):
        model_list = []
        for model_name in cls.container_dict.keys():
            model_list.append(cls.get_model_name_mapping()[model_name])

        return model_list

    @classmethod
    def select_as_model(cls, model_name: str):
        cls.cur_model = cls.get_model_name_mapping_reverse()[model_name]

    @classmethod
    def get_model_mark(cls):
        return True if cls.cur_model != "" else False

    @classmethod
    def get_linear_regression_mark(cls):
        return True if cls.cur_model == MN.linear_regression else False

    @classmethod
    def get_naive_bayes_classifier_mark(cls):
        return True if cls.cur_model == MN.naive_bayes_classification else False

    @classmethod
    def get_assign_list(cls):
        return ["分类", "回归"]

    @classmethod
    def get_assign_mapping_reverse(cls):
        return dict(zip(cls.get_assign_list(), [MN.classification, MN.regression]))

    @classmethod
    def choose_assign(cls, assign: str):
        cls.assign = cls.get_assign_mapping_reverse()[assign]

        data_copy = cls.data

        if cls.assign == MN.classification:
            data_copy.iloc[:, 0] = data_copy.iloc[:, 0].astype(str)
        else:
            data_copy.iloc[:, 0] = data_copy.iloc[:, 0].astype(float)

        cls.data = data_copy
        cls.change_data_type_to_float()

    @classmethod
    def colorpickers_change(cls, paint_object):
        cur_num = paint_object.get_color_cur_num()

        true_list = [gr.ColorPicker(paint_object.get_color_cur_list()[i], visible=True, label=LN.colors[i]) for i in range(cur_num)]

        return true_list + [gr.ColorPicker(visible=False)] * (StaticValue.max_num - cur_num)

    @classmethod
    def color_textboxs_change(cls, paint_object):
        cur_num = paint_object.get_color_cur_num()

        true_list = [gr.Textbox(paint_object.get_color_cur_list()[i], visible=True, show_label=False) for i in range(cur_num)]

        return true_list + [gr.Textbox(visible=False)] * (StaticValue.max_num - cur_num)

    @classmethod
    def labels_change(cls, paint_object):
        cur_num = paint_object.get_label_cur_num()

        true_list = [gr.Textbox(paint_object.get_label_cur_list()[i], visible=True, label=LN.labels[i]) for i in range(cur_num)]

        return true_list + [gr.Textbox(visible=False)] * (StaticValue.max_num - cur_num)

    @classmethod
    def get_model_train_metrics_dataframe(cls):
        if cls.cur_model != "" and cls.get_model_container_status():
            columns_list = ["指标", "数值"]

            output_dict = cls.container_dict[cls.cur_model].get_info()["指标"]

            output_df = pd.DataFrame(columns=columns_list)
            output_df["指标"] = [x for x in output_dict.keys() if x in ChooseModelMetrics.choose(cls.cur_model)]
            output_df["数值"] = [output_dict[x] for x in output_df["指标"]]

            return output_df

    @classmethod
    def get_model_train_params_dataframe(cls):
        if cls.cur_model != "" and cls.get_model_container_status():
            columns_list = ["参数", "数值"]

            output_dict = cls.container_dict[cls.cur_model].get_info()["参数"]

            output_df = pd.DataFrame(columns=columns_list)
            output_df["参数"] = [x for x in output_dict.keys() if x in ChooseModelParams.choose(cls.cur_model).keys()]
            output_df["数值"] = [output_dict[x] for x in output_df["参数"]]

            return output_df

    @classmethod
    def get_str_col_list(cls):
        str_col_list = []
        for col in cls.get_col_list():
            if all(isinstance(x, str) for x in cls.data.loc[:, col]):
                str_col_list.append(col)

        return str_col_list

    @classmethod
    def get_float_col_list(cls):
        float_col_list = []
        for col in cls.get_col_list():
            if all(isinstance(x, float) for x in cls.data.loc[:, col]):
                float_col_list.append(col)

        return float_col_list

    @classmethod
    def check_data_distribution_type(cls, col):
        if all(isinstance(x, str) for x in cls.data.loc[:, col]):
            return "histogram"
        # elif all(isinstance(x, float) for x in cls.data.loc[:, col]):
        #     return "line_graph"
        else:
            gr.Warning("所选列的所有数据必须为字符型或浮点型")

    @classmethod
    def check_col_list(cls, col):
        if not col:
            gr.Warning("请选择所需列")
            return True
        return False

    @classmethod
    def check_train_model(cls, optimize):
        if cls.cur_model == "":
            gr.Warning("请选择所需训练的模型")
            return True
        if not optimize:
            gr.Warning("请选择超参数优化方法")
            return True
        return False

    @classmethod
    def error_return_train(cls):
        return get_return(True)

    @classmethod
    def check_train_model_other_related(cls, linear_regression_model_type, naive_bayes_classifier_model_type):
        if cls.cur_model == MN.linear_regression:
            if not linear_regression_model_type:
                gr.Warning("请选择线性回归对应的模型")
                return True
        elif cls.cur_model == MN.naive_bayes_classification:
            if not naive_bayes_classifier_model_type:
                gr.Warning("请选择朴素贝叶斯对应的模型")
                return True
        return False

    @classmethod
    def check_cur_dict(cls, cur_dict):
        if not cur_dict:
            gr.Warning("请选择绘图所需的模型")
            return True
        return False


def choose_assign(assign: str):
    Dataset.choose_assign(assign)

    return get_return(True)


def select_as_model(model_name: str):
    Dataset.select_as_model(model_name)

    return get_return(True)


# [绘图]
def heatmap_first_draw_plot(*inputs):
    Dataset.visualize = MN.heatmap
    return before_train_first_draw_plot(inputs)


def descriptive_indicators_first_draw_plot(*inputs):
    Dataset.visualize = MN.descriptive_indicators
    return before_train_first_draw_plot(inputs)


def data_distribution_first_draw_plot(*inputs):
    Dataset.visualize = MN.data_distribution
    return before_train_first_draw_plot(inputs)


def dependence_first_draw_plot(*inputs):
    Dataset.visualize = MN.dependence
    return first_draw_plot(inputs)


def force_first_draw_plot(*inputs):
    Dataset.visualize = MN.force
    return first_draw_plot(inputs)


def waterfall_first_draw_plot(*inputs):
    Dataset.visualize = MN.waterfall
    return first_draw_plot(inputs)


def data_fit_first_draw_plot(*inputs):
    Dataset.visualize = MN.data_fit
    return first_draw_plot(inputs)


def shap_beeswarm_first_draw_plot(*inputs):
    Dataset.visualize = MN.shap_beeswarm
    return first_draw_plot(inputs)


def learning_curve_first_draw_plot(*inputs):
    Dataset.visualize = MN.learning_curve
    return first_draw_plot(inputs)


def before_train_first_draw_plot(inputs):
    select_model = SelectModel()
    x_label = ""
    y_label = ""
    name = ""
    color_list = []
    label_list = []

    # [绘图][无训练模型]
    if Dataset.visualize == MN.data_distribution:
        select_model.set_data_distribution_col(inputs[0])
        select_model.set_data_distribution_is_rotate(inputs[1])
    elif Dataset.visualize == MN.descriptive_indicators:
        select_model.set_descriptive_indicators_is_rotate(inputs[0])
        select_model.set_descriptive_indicators_col(inputs[1])
    elif Dataset.visualize == MN.heatmap:
        select_model.set_heatmap_col(inputs[0])
        select_model.set_heatmap_is_rotate(inputs[1])

    cur_plt, paint_object = Dataset.draw_plot(select_model, color_list, label_list, name, x_label, y_label, True)

    return first_draw_plot_with_non_first_draw_plot(cur_plt, paint_object)


def first_draw_plot(inputs):
    select_model = SelectModel()
    select_model.set_models(inputs[0])
    x_label = ""
    y_label = ""
    name = ""
    color_list = []
    label_list = []

    # [绘图][有训练模型]
    if Dataset.visualize == MN.shap_beeswarm:
        select_model.set_beeswarm_plot_type(inputs[1])
    elif Dataset.visualize == MN.waterfall:
        select_model.set_waterfall_number(inputs[1])
    elif Dataset.visualize == MN.force:
        select_model.set_force_number(inputs[1])
    elif Dataset.visualize == MN.dependence:
        select_model.set_dependence_col(inputs[1])

    cur_plt, paint_object = Dataset.draw_plot(select_model, color_list, label_list, name, x_label, y_label, True)

    return first_draw_plot_with_non_first_draw_plot(cur_plt, paint_object)


def out_non_first_draw_plot(*inputs):
    return non_first_draw_plot(inputs)


def non_first_draw_plot(inputs):
    name = inputs[0]
    x_label = inputs[1]
    y_label = inputs[2]
    color_list = list(inputs[3: StaticValue.max_num+3])
    label_list = list(inputs[StaticValue.max_num+3: 2*StaticValue.max_num+3])
    start_index = 2*StaticValue.max_num+3

    select_model = SelectModel()

    # 绘图
    if Dataset.visualize == MN.learning_curve:
        select_model.set_models(inputs[start_index+0])
        select_model.set_beeswarm_plot_type(inputs[start_index+1])
    elif Dataset.visualize == MN.shap_beeswarm:
        select_model.set_models(inputs[start_index+2])
    elif Dataset.visualize == MN.data_fit:
        select_model.set_models(inputs[start_index+3])
    elif Dataset.visualize == MN.waterfall:
        select_model.set_models(inputs[start_index+4])
        select_model.set_waterfall_number(inputs[start_index+5])
    elif Dataset.visualize == MN.force:
        select_model.set_models(inputs[start_index+6])
        select_model.set_force_number(inputs[start_index+7])
    elif Dataset.visualize == MN.dependence:
        select_model.set_models(inputs[start_index+8])
        select_model.set_dependence_col(inputs[start_index+9])
    elif Dataset.visualize == MN.data_distribution:
        select_model.set_data_distribution_col(inputs[start_index+10])
        select_model.set_data_distribution_is_rotate(inputs[start_index+11])
    elif Dataset.visualize == MN.descriptive_indicators:
        select_model.set_descriptive_indicators_is_rotate(inputs[start_index+12])
        select_model.set_descriptive_indicators_col(inputs[start_index+13])
    elif Dataset.visualize == MN.descriptive_indicators:
        select_model.set_heatmap_col(inputs[start_index+14])
        select_model.set_heatmap_is_rotate(inputs[start_index+15])

    else:
        select_model.set_models(inputs[start_index])

    cur_plt, paint_object = Dataset.draw_plot(select_model, color_list, label_list, name, x_label, y_label, False)

    return first_draw_plot_with_non_first_draw_plot(cur_plt, paint_object)


def first_draw_plot_with_non_first_draw_plot(cur_plt, paint_object):
    extra_gr_dict = {}

    # [绘图]
    if Dataset.visualize == MN.learning_curve:
        cur_plt.savefig(FilePath.png_base.format(FilePath.learning_curve_plot), dpi=300)
        extra_gr_dict.update({draw_plot: gr.Plot(cur_plt, visible=True, label=LN.learning_curve_plot)})
    elif Dataset.visualize == MN.shap_beeswarm:
        cur_plt.savefig(FilePath.png_base.format(FilePath.shap_beeswarm_plot), dpi=300)
        extra_gr_dict.update({draw_plot: gr.Plot(cur_plt, visible=True, label=LN.shap_beeswarm_plot)})
    elif Dataset.visualize == MN.data_fit:
        cur_plt.savefig(FilePath.png_base.format(FilePath.data_fit_plot), dpi=300)
        extra_gr_dict.update({draw_plot: gr.Plot(cur_plt, visible=True, label=LN.data_fit_plot)})
    elif Dataset.visualize == MN.waterfall:
        cur_plt.savefig(FilePath.png_base.format(FilePath.waterfall_plot), dpi=300)
        extra_gr_dict.update({draw_plot: gr.Plot(cur_plt, visible=True, label=LN.waterfall_plot)})
    elif Dataset.visualize == MN.force:
        cur_plt.savefig(FilePath.png_base.format(FilePath.force_plot), dpi=300)
        extra_gr_dict.update({draw_plot: gr.Plot(cur_plt, visible=True, label=LN.force_plot)})
    elif Dataset.visualize == MN.dependence:
        cur_plt.savefig(FilePath.png_base.format(FilePath.dependence_plot), dpi=300)
        extra_gr_dict.update({draw_plot: gr.Plot(cur_plt, visible=True, label=LN.dependence_plot)})
    elif Dataset.visualize == MN.data_distribution:
        cur_plt.savefig(FilePath.png_base.format(FilePath.data_distribution_plot), dpi=300)
        extra_gr_dict.update({draw_plot: gr.Plot(cur_plt, visible=True, label=LN.data_distribution_plot)})
    elif Dataset.visualize == MN.descriptive_indicators:
        cur_plt.savefig(FilePath.png_base.format(FilePath.descriptive_indicators_plot), dpi=300)
        extra_gr_dict.update({draw_plot: gr.Plot(cur_plt, visible=True, label=LN.descriptive_indicators_plot)})
        extra_gr_dict.update({descriptive_indicators_dataframe: gr.Dataframe(Dataset.get_descriptive_indicators_df(), type="pandas", visible=Dataset.check_descriptive_indicators_df())})
    elif Dataset.visualize == MN.heatmap:
        cur_plt.savefig(FilePath.png_base.format(FilePath.heatmap_plot), dpi=300)
        extra_gr_dict.update({draw_plot: gr.Plot(cur_plt, visible=True, label=LN.heatmap_plot)})

    extra_gr_dict.update(dict(zip(colorpickers, Dataset.colorpickers_change(paint_object))))
    extra_gr_dict.update(dict(zip(color_textboxs, Dataset.color_textboxs_change(paint_object))))
    extra_gr_dict.update(dict(zip(legend_labels_textboxs, Dataset.labels_change(paint_object))))
    extra_gr_dict.update({title_name_textbox: gr.Textbox(paint_object.get_name(), visible=True, label=LN.title_name_textbox)})
    extra_gr_dict.update({x_label_textbox: gr.Textbox(paint_object.get_x_cur_label(), visible=True, label=LN.x_label_textbox)})
    extra_gr_dict.update({y_label_textbox: gr.Textbox(paint_object.get_y_cur_label(), visible=True, label=LN.y_label_textbox)})

    return get_return_extra(True, extra_gr_dict)


# [模型]
def train_model(optimize, linear_regression_model_type, naive_bayes_classifier_model_type):
    if Dataset.check_train_model(optimize):
        return Dataset.error_return_train()

    if Dataset.check_train_model_other_related(linear_regression_model_type, naive_bayes_classifier_model_type):
        return Dataset.error_return_train()

    Dataset.train_model(optimize, linear_regression_model_type, naive_bayes_classifier_model_type)

    return get_return(True)


def select_as_y(col: str):
    Dataset.select_as_y(col)

    return get_return(True)


def standardize_data(col_list: list):
    Dataset.standardize_data(col_list)

    return get_return(True)


def change_data_type_to_float():
    Dataset.change_data_type_to_float()

    return get_return(True)


def encode_label(col_list: list):
    Dataset.encode_label(col_list)

    return get_return(True, {display_encode_label_dataframe: gr.Dataframe(Dataset.get_str2int_mappings_df(), type="pandas", visible=True, label=LN.display_encode_label_dataframe)})


def del_duplicate():
    Dataset.del_duplicate()

    return get_return(True)


def del_all_na_col():
    Dataset.del_all_na_col()

    return get_return(True)


def remain_row(num):
    Dataset.remain_row(num)

    return get_return(True)


def del_col(col_list: list):
    Dataset.del_col(col_list)

    return get_return(True)


def add_index_into_df(df: pd.DataFrame) -> pd.DataFrame:
    if df.empty:
        return df

    index_df = pd.DataFrame([x for x in range(len(df))], columns=["[*index]"])

    return pd.concat([index_df, df], axis=1)


def choose_dataset(file: str):
    if file == "自定义":
        Dataset.clear()

        return get_return(False)

    df = load_data(file)
    Dataset.update(file, df)

    return get_return(True, {choose_custom_dataset_file: gr.File(visible=False)})


def choose_custom_dataset(file: str):
    df = load_custom_data(file)
    Dataset.update(file, df)

    return get_return(True, {choose_custom_dataset_file: gr.File(Dataset.file, visible=True)})


with gr.Blocks(js=Config.JS_0) as demo:
    '''
        组件
    '''

    with gr.Tab("机器学习"):
        # 选择数据源
        with gr.Accordion("数据源"):
            with gr.Group():
                choose_dataset_radio = gr.Radio(Dataset.get_dataset_list(), label=LN.choose_dataset_radio)
                choose_custom_dataset_file = gr.File(visible=False)

        # 显示数据表信息
        with gr.Accordion("当前数据信息"):
            display_dataset_dataframe = gr.Dataframe(visible=False)
            display_dataset = gr.File(visible=False)
            with gr.Row():
                display_total_col_num_text = gr.Textbox(visible=False)
                display_total_row_num_text = gr.Textbox(visible=False)
                with gr.Column():
                    remain_row_slider = gr.Slider(visible=False)
                    remain_row_button = gr.Button(visible=False)
            with gr.Row():
                with gr.Column():
                    with gr.Row():
                        display_na_list_text = gr.Textbox(visible=False)
                        display_duplicate_num_text = gr.Textbox(visible=False)
                    with gr.Row():
                        del_all_na_col_button = gr.Button(visible=False)
                        del_duplicate_button = gr.Button(visible=False)

        # 操作数据表
        with gr.Accordion("数据处理"):
            select_as_y_radio = gr.Radio(visible=False)
            with gr.Row():
                with gr.Column():
                    data_type_dataframe = gr.Dataframe(visible=False)
                    change_data_type_to_float_button = gr.Button(visible=False)
                    choose_assign_radio = gr.Radio(visible=False)
                with gr.Column():
                    del_col_checkboxgroup = gr.Checkboxgroup(visible=False)
                    del_col_button = gr.Button(visible=False)
                    encode_label_checkboxgroup = gr.Checkboxgroup(visible=False)
                    encode_label_button = gr.Button(visible=False)
                    display_encode_label_dataframe = gr.Dataframe(visible=False)
                    standardize_data_checkboxgroup = gr.Checkboxgroup(visible=False)
                    standardize_data_button = gr.Button(visible=False)

        # 数据模型
        with gr.Accordion("数据模型"):
            # [模型]
            select_as_model_radio = gr.Radio(visible=False)
            linear_regression_model_radio = gr.Radio(visible=False)
            naive_bayes_classification_model_radio = gr.Radio(visible=False)
            model_optimize_radio = gr.Radio(visible=False)
            model_train_button = gr.Button(visible=False)
            model_train_checkbox = gr.Checkbox(visible=False)
            model_train_params_dataframe = gr.Dataframe(visible=False)
            model_train_metrics_dataframe = gr.Dataframe(visible=False)

        # 可视化
        with gr.Accordion("数据可视化"):
            with gr.Tab("数据分布图"):
                data_distribution_radio = gr.Radio(visible=False)
                data_distribution_is_rotate = gr.Checkbox(visible=False)
                data_distribution_button = gr.Button(visible=False)

            with gr.Tab("箱线统计图"):
                descriptive_indicators_checkboxgroup = gr.Checkboxgroup(visible=False)
                descriptive_indicators_is_rotate = gr.Checkbox(visible=False)
                descriptive_indicators_button = gr.Button(visible=False)
                descriptive_indicators_dataframe = gr.Dataframe(visible=False)

            with gr.Tab("系数热力图"):
                heatmap_checkboxgroup = gr.Checkboxgroup(visible=False)
                heatmap_is_rotate = gr.Checkbox(visible=False)
                heatmap_button = gr.Button(visible=False)

            # with gr.Tab("主成分分析"):
            #     pca_button = gr.Button(visible=False)
            #     pca_replace_data_button = gr.Button(visible=False)


            with gr.Tab("学习曲线图"):
                learning_curve_checkboxgroup = gr.Checkboxgroup(visible=False)
                learning_curve_button = gr.Button(visible=False)

            with gr.Tab("数据拟合图"):
                data_fit_checkboxgroup = gr.Checkboxgroup(visible=False)
                data_fit_button = gr.Button(visible=False)

            with gr.Tab("特征蜂群图"):
                shap_beeswarm_radio = gr.Radio(visible=False)
                shap_beeswarm_type = gr.Radio(visible=False)
                shap_beeswarm_button = gr.Button(visible=False)

            with gr.Tab("特征瀑布图"):
                waterfall_radio = gr.Radio(visible=False)
                waterfall_number = gr.Slider(visible=False)
                waterfall_button = gr.Button(visible=False)

            with gr.Tab("特征力图"):
                force_radio = gr.Radio(visible=False)
                force_number = gr.Slider(visible=False)
                force_button = gr.Button(visible=False)

            with gr.Tab("特征依赖图"):
                dependence_radio = gr.Radio(visible=False)
                dependence_col = gr.Radio(visible=False)
                dependence_button = gr.Button(visible=False)

            legend_labels_textboxs = []
            with gr.Accordion("图例"):
                with gr.Row():
                    for i in range(StaticValue.max_num):
                        with gr.Row():
                            label = gr.Textbox(visible=False)
                            legend_labels_textboxs.append(label)

            with gr.Accordion("坐标轴"):
                with gr.Row():
                    title_name_textbox = gr.Textbox(visible=False)
                    x_label_textbox = gr.Textbox(visible=False)
                    y_label_textbox = gr.Textbox(visible=False)

            colorpickers = []
            color_textboxs = []
            with gr.Accordion("颜色"):
                with gr.Row():
                    for i in range(StaticValue.max_num):
                        with gr.Row():
                            colorpicker = gr.ColorPicker(visible=False)
                            colorpickers.append(colorpicker)
                            color_textbox = gr.Textbox(visible=False)
                            color_textboxs.append(color_textbox)

            draw_plot = gr.Plot(visible=False)
            draw_file = gr.File(visible=False)

    with gr.Tab("文字说明"):
        notes = gr.Markdown(Dataset.get_notes(), visible=True)

    '''
        监听事件
    '''

    # 选择数据源
    choose_dataset_radio.change(fn=choose_dataset, inputs=[choose_dataset_radio], outputs=get_outputs())
    choose_custom_dataset_file.upload(fn=choose_custom_dataset, inputs=[choose_custom_dataset_file], outputs=get_outputs())

    # 操作数据表

    # 删除所选列
    del_col_button.click(fn=del_col, inputs=[del_col_checkboxgroup], outputs=get_outputs())
    # 保留行
    remain_row_button.click(fn=remain_row, inputs=[remain_row_slider], outputs=get_outputs())
    # 删除所有存在缺失值的列
    del_all_na_col_button.click(fn=del_all_na_col, outputs=get_outputs())
    # 删除所有重复的行
    del_duplicate_button.click(fn=del_duplicate, outputs=get_outputs())
    # 字符型列转数值型列
    encode_label_button.click(fn=encode_label, inputs=[encode_label_checkboxgroup], outputs=get_outputs())
    # 将所有数据强制转换为浮点型(除第1列之外)
    change_data_type_to_float_button.click(fn=change_data_type_to_float, outputs=get_outputs())
    # 标准化数据
    standardize_data_button.click(fn=standardize_data, inputs=[standardize_data_checkboxgroup], outputs=get_outputs())
    # 选择因变量
    select_as_y_radio.change(fn=select_as_y, inputs=[select_as_y_radio], outputs=get_outputs())
    # 选择任务类型(强制转换第1列)
    choose_assign_radio.change(fn=choose_assign, inputs=[choose_assign_radio], outputs=get_outputs())

    # 数据模型
    select_as_model_radio.change(fn=select_as_model, inputs=[select_as_model_radio], outputs=get_outputs())

    # [模型]
    model_train_button.click(fn=train_model, inputs=[model_optimize_radio, linear_regression_model_radio, naive_bayes_classification_model_radio], outputs=get_outputs())

    # [绘图]

    # 可视化
    data_distribution_button.click(fn=data_distribution_first_draw_plot, inputs=[data_distribution_radio] + [data_distribution_is_rotate], outputs=get_outputs())
    descriptive_indicators_button.click(fn=descriptive_indicators_first_draw_plot, inputs=[descriptive_indicators_is_rotate] + [descriptive_indicators_checkboxgroup], outputs=get_outputs())
    heatmap_button.click(fn=heatmap_first_draw_plot, inputs=[heatmap_checkboxgroup] + [heatmap_is_rotate], outputs=get_outputs())
    learning_curve_button.click(fn=learning_curve_first_draw_plot, inputs=[learning_curve_checkboxgroup], outputs=get_outputs())
    shap_beeswarm_button.click(fn=shap_beeswarm_first_draw_plot, inputs=[shap_beeswarm_radio] + [shap_beeswarm_type], outputs=get_outputs())
    data_fit_button.click(fn=data_fit_first_draw_plot, inputs=[data_fit_checkboxgroup], outputs=get_outputs())
    waterfall_button.click(fn=waterfall_first_draw_plot, inputs=[waterfall_radio] + [waterfall_number], outputs=get_outputs())
    force_button.click(fn=force_first_draw_plot, inputs=[force_radio] + [force_number], outputs=get_outputs())
    dependence_button.click(fn=dependence_first_draw_plot, inputs=[dependence_radio] + [dependence_col], outputs=get_outputs())

    title_name_textbox.blur(fn=out_non_first_draw_plot, inputs=[title_name_textbox] + [x_label_textbox] + [y_label_textbox] + colorpickers + legend_labels_textboxs
                                                               + [learning_curve_checkboxgroup] + [shap_beeswarm_radio] + [shap_beeswarm_type] + [data_fit_checkboxgroup] + [waterfall_radio] + [waterfall_number]
                                                               + [force_radio] + [force_number] + [dependence_radio] + [dependence_col] + [data_distribution_radio] + [data_distribution_is_rotate]
                            + [descriptive_indicators_is_rotate] + [descriptive_indicators_checkboxgroup] + [heatmap_checkboxgroup] + [heatmap_is_rotate], outputs=get_outputs())

    x_label_textbox.blur(fn=out_non_first_draw_plot, inputs=[title_name_textbox] + [x_label_textbox] + [y_label_textbox] + colorpickers + legend_labels_textboxs
                                                            + [learning_curve_checkboxgroup] + [shap_beeswarm_radio] + [shap_beeswarm_type] + [data_fit_checkboxgroup] + [waterfall_radio] + [waterfall_number]
                                                            + [force_radio] + [force_number] + [dependence_radio] + [dependence_col] + [data_distribution_radio] + [data_distribution_is_rotate]
                         + [descriptive_indicators_is_rotate] + [descriptive_indicators_checkboxgroup] + [heatmap_checkboxgroup] + [heatmap_is_rotate], outputs=get_outputs())

    y_label_textbox.blur(fn=out_non_first_draw_plot, inputs=[title_name_textbox] + [x_label_textbox] + [y_label_textbox] + colorpickers + legend_labels_textboxs
                                                            + [learning_curve_checkboxgroup] + [shap_beeswarm_radio] + [shap_beeswarm_type] + [data_fit_checkboxgroup] + [waterfall_radio] + [waterfall_number]
                                                            + [force_radio] + [force_number] + [dependence_radio] + [dependence_col] + [data_distribution_radio] + [data_distribution_is_rotate]
                         + [descriptive_indicators_is_rotate] + [descriptive_indicators_checkboxgroup] + [heatmap_checkboxgroup] + [heatmap_is_rotate], outputs=get_outputs())

    for i in range(StaticValue.max_num):
        colorpickers[i].blur(fn=out_non_first_draw_plot, inputs=[title_name_textbox] + [x_label_textbox] + [y_label_textbox] + colorpickers + legend_labels_textboxs
                                                                + [learning_curve_checkboxgroup] + [shap_beeswarm_radio] + [shap_beeswarm_type] + [data_fit_checkboxgroup] + [waterfall_radio] + [waterfall_number]
                                                                + [force_radio] + [force_number] + [dependence_radio] + [dependence_col] + [data_distribution_radio] + [data_distribution_is_rotate]
                             + [descriptive_indicators_is_rotate] + [descriptive_indicators_checkboxgroup] + [heatmap_checkboxgroup] + [heatmap_is_rotate], outputs=get_outputs())

        color_textboxs[i].blur(fn=out_non_first_draw_plot, inputs=[title_name_textbox] + [x_label_textbox] + [y_label_textbox] + color_textboxs + legend_labels_textboxs
                                                                  + [learning_curve_checkboxgroup] + [shap_beeswarm_radio] + [shap_beeswarm_type] + [data_fit_checkboxgroup] + [waterfall_radio] + [waterfall_number]
                                                                  + [force_radio] + [force_number] + [dependence_radio] + [dependence_col] + [data_distribution_radio] + [data_distribution_is_rotate]
                               + [descriptive_indicators_is_rotate] + [descriptive_indicators_checkboxgroup] + [heatmap_checkboxgroup] + [heatmap_is_rotate], outputs=get_outputs())

        legend_labels_textboxs[i].blur(fn=out_non_first_draw_plot, inputs=[title_name_textbox] + [x_label_textbox] + [y_label_textbox] + colorpickers + legend_labels_textboxs
                                                                          + [learning_curve_checkboxgroup] + [shap_beeswarm_radio] + [shap_beeswarm_type] + [data_fit_checkboxgroup] + [waterfall_radio] + [waterfall_number]
                                                                          + [force_radio] + [force_number] + [dependence_radio] + [dependence_col] + [data_distribution_radio] + [data_distribution_is_rotate]
                                       + [descriptive_indicators_is_rotate] + [descriptive_indicators_checkboxgroup] + [heatmap_checkboxgroup] + [heatmap_is_rotate], outputs=get_outputs())

if __name__ == "__main__":
    demo.launch()