app.py

import copy
import os.path

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.shap_model import shap_calculate
from static.process import *
from analysis.linear_model import *
from visualization.draw_learning_curve_total import draw_learning_curve_total
from static.paint import *

import warnings

warnings.filterwarnings("ignore")


class Container:
    def __init__(self, x_train=None, y_train=None, x_test=None, y_test=None, hyper_params_optimize=None):
        self.x_train = x_train
        self.y_train = y_train
        self.x_test = x_test
        self.y_test = y_test
        self.hyper_params_optimize = hyper_params_optimize
        self.info = dict()
        self.y_pred = None
        self.train_sizes = None
        self.train_scores_mean = None
        self.train_scores_std = None
        self.test_scores_mean = None
        self.test_scores_std = None
        self.status = None
        self.model = None

    def set_info(self, info: dict):
        self.info = info

    def set_y_pred(self, y_pred):
        self.y_pred = y_pred

    def get_learning_curve_values(self):
        return [
            self.train_sizes,
            self.train_scores_mean,
            self.train_scores_std,
            self.test_scores_mean,
            self.test_scores_std
        ]

    def set_learning_curve_values(self, train_sizes, train_scores_mean, train_scores_std, test_scores_mean, test_scores_std):
        self.train_sizes = train_sizes
        self.train_scores_mean = train_scores_mean
        self.train_scores_std = train_scores_std
        self.test_scores_mean = test_scores_mean
        self.test_scores_std = test_scores_std

    def get_status(self):
        return self.status

    def set_status(self, status: str):
        self.status = status

    def get_model(self):
        return self.model

    def set_model(self, model):
        self.model = model


class StaticValue:
    max_num = 10


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

    # [绘图]
    display_dataset = "current_excel_data"
    learning_curve_train_plot = "learning_curve_train_plot"
    learning_curve_validation_plot = "learning_curve_validation_plot"
    shap_beeswarm_plot = "shap_beeswarm_plot"


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

    linear_regression = "linear_regression"
    polynomial_regression = "polynomial_regression"
    logistic_regression = "logistic_regression"

    # [绘图]
    learning_curve_train = "learning_curve_train"
    learning_curve_validation = "learning_curve_validation"
    shap_beeswarm = "shap_beeswarm"


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列数据强制转换）[必选]"
    linear_regression_model_radio = "选择线性回归的模型"
    model_optimize_radio = "选择超参数优化方法"
    model_train_button = "训练"
    select_as_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)]

    # [绘图]
    learning_curve_checkboxgroup = "选择所需绘制学习曲线的模型"
    learning_curve_train_button = "绘制训练集学习曲线"
    learning_curve_validation_button = "绘制验证集学习曲线"
    shap_beeswarm_radio = "选择所需绘制蜂群特征图的模型"
    shap_beeswarm_button = "绘制蜂群特征图"

    learning_curve_train_plot = "训练集学习曲线"
    learning_curve_validation_plot = "验证集学习曲线"
    shap_beeswarm_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,
        linear_regression_model_radio,
        model_optimize_radio,
        model_train_button,
        model_train_checkbox,
        select_as_model_radio,
        choose_assign_radio,
        display_dataset,
        draw_plot,
        draw_file,
        title_name_textbox,
        x_label_textbox,
        y_label_textbox,

        # [绘图]
        learning_curve_checkboxgroup,
        learning_curve_train_button,
        learning_curve_validation_button,
        shap_beeswarm_radio,
        shap_beeswarm_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),

            linear_regression_model_radio: gr.Radio(Dataset.get_linear_regression_model_list(), visible=Dataset.get_linear_regression_mark(), label=LN.linear_regression_model_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()),

            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),

            # [绘图]
            learning_curve_checkboxgroup: gr.Checkboxgroup(Dataset.get_trained_model_list(), visible=Dataset.check_before_train(), label=LN.learning_curve_checkboxgroup),
            learning_curve_train_button: gr.Button(LN.learning_curve_train_button, visible=Dataset.check_before_train()),
            learning_curve_validation_button: gr.Button(LN.learning_curve_validation_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_button: gr.Button(LN.shap_beeswarm_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),
        linear_regression_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),
        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),

        # [绘图]
        learning_curve_checkboxgroup: gr.Checkboxgroup(visible=False),
        learning_curve_train_button: gr.Button(visible=False),
        learning_curve_validation_button: gr.Button(visible=False),
        shap_beeswarm_radio: gr.Radio(visible=False),
        shap_beeswarm_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

    container_dict = {
        MN.linear_regression: Container(),
        MN.polynomial_regression: Container(),
        MN.logistic_regression: Container(),
    }

    visualize = ""

    @classmethod
    def get_dataset_list(cls):
        return ["Iris Dataset", "Wine Dataset", "Breast Cancer 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_linear_regression_model_name_mapping(cls):
        return dict(zip(cls.get_linear_regression_model_list(), ["LinearRegression", "Lasso", "Ridge", "ElasticNet"]))

    @classmethod
    def train_model(cls, optimize, linear_regression_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:
            container = linear_regression(container, cls.get_linear_regression_model_name_mapping()[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)

        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 ["线性回归", "多项式回归", "逻辑斯谛分类"]

    @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_train:
            return cls.draw_learning_curve_train_plot(select_model, color_list, label_list, name, x_label, y_label, is_default)
        elif cls.visualize == MN.learning_curve_validation:
            return cls.draw_learning_curve_validation_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)

    @classmethod
    def draw_learning_curve_train_plot(cls, model_list, color_list: list, label_list: list, name: str, x_label: str, y_label: str, is_default: bool):
        learning_curve_dict = {}

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

        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_learning_curve_total(learning_curve_dict, "train", paint_object)

    @classmethod
    def draw_learning_curve_validation_plot(cls, model_list, color_list: list, label_list: list, name: str, x_label: str, y_label: str, is_default: bool):
        learning_curve_dict = {}

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

        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_learning_curve_total(learning_curve_dict, "validation", paint_object)

    @classmethod
    def draw_shap_beeswarm_plot(cls, model_name, color_list: list, label_list: list, name: str, x_label: str, y_label: str, is_default: bool):
        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 shap_calculate(container.get_model(), container.x_train, cls.data.columns.values, paint_object)

    @classmethod
    def get_file(cls):
        # [绘图]
        if cls.visualize == MN.learning_curve_train:
            return FilePath.png_base.format(FilePath.learning_curve_train_plot)
        elif cls.visualize == MN.learning_curve_validation:
            return FilePath.png_base.format(FilePath.learning_curve_validation_plot)
        elif cls.visualize == MN.shap_beeswarm:
            return FilePath.png_base.format(FilePath.shap_beeswarm_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_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)


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 shap_beeswarm_first_draw_plot(*inputs):
    Dataset.visualize = MN.shap_beeswarm
    return first_draw_plot(inputs)


def learning_curve_validation_first_draw_plot(*inputs):
    Dataset.visualize = MN.learning_curve_validation
    return first_draw_plot(inputs)


def learning_curve_train_first_draw_plot(*inputs):
    Dataset.visualize = MN.learning_curve_train
    return first_draw_plot(inputs)


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

    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

    # 绘图
    if Dataset.visualize == MN.learning_curve_train:
        select_model = inputs[start_index]
    elif Dataset.visualize == MN.learning_curve_validation:
        select_model = inputs[start_index]
    elif Dataset.visualize == MN.shap_beeswarm:
        select_model = inputs[start_index+1]

    else:
        select_model = inputs[start_index: start_index+1]

    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_train:
        cur_plt.savefig(FilePath.png_base.format(FilePath.learning_curve_train_plot), dpi=300)
        extra_gr_dict.update({draw_plot: gr.Plot(cur_plt, visible=True, label=LN.learning_curve_train_plot)})
    elif Dataset.visualize == MN.learning_curve_validation:
        cur_plt.savefig(FilePath.png_base.format(FilePath.learning_curve_validation_plot), dpi=300)
        extra_gr_dict.update({draw_plot: gr.Plot(cur_plt, visible=True, label=LN.learning_curve_validation_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)})

    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):
    Dataset.train_model(optimize, linear_regression_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() 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)
            model_optimize_radio = gr.Radio(visible=False)
            model_train_button = gr.Button(visible=False)
            model_train_checkbox = gr.Checkbox(visible=False)

        # 可视化
        with gr.Accordion("数据可视化"):
            with gr.Tab("学习曲线图"):
                learning_curve_checkboxgroup = gr.Checkboxgroup(visible=False)
                with gr.Row():
                    learning_curve_train_button = gr.Button(visible=False)
                    learning_curve_validation_button = gr.Button(visible=False)

            with gr.Tab("蜂群特征图"):
                shap_beeswarm_radio = gr.Radio(visible=False)
                shap_beeswarm_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)

    '''
        监听事件
    '''

    # 选择数据源
    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], outputs=get_outputs())

    # 可视化
    learning_curve_train_button.click(fn=learning_curve_train_first_draw_plot, inputs=[learning_curve_checkboxgroup], outputs=get_outputs())
    learning_curve_validation_button.click(fn=learning_curve_validation_first_draw_plot, inputs=[learning_curve_checkboxgroup], outputs=get_outputs())
    shap_beeswarm_button.click(fn=shap_beeswarm_first_draw_plot, inputs=[shap_beeswarm_radio], 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], 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], 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], 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], 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], 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], outputs=get_outputs())

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