2024/02/20/14:15

analysis/bayes_model.py

@@ -1,28 +1,82 @@
+from sklearn.model_selection import learning_curve
 from sklearn.naive_bayes import *
+import numpy as np
 
-from coding.llh.visualization.draw_line_graph import draw_line_graph
-from coding.llh.visualization.draw_scatter_line_graph import draw_scatter_line_graph
-from coding.llh.metrics.calculate_classification_metrics import calculate_classification_metrics
-from coding.llh.metrics.calculate_regression_metrics import calculate_regression_metrics
+from static.new_class import Container
+from static.process import grid_search, bayes_search
+from visualization.draw_line_graph import draw_line_graph
+from visualization.draw_scatter_line_graph import draw_scatter_line_graph
+from metrics.calculate_classification_metrics import calculate_classification_metrics
+from metrics.calculate_regression_metrics import calculate_regression_metrics
 
 
-# Naive bayes classification
-def naive_bayes_classification(x_train, y_train, x_test, y_test):
+class NaiveBayesClassifierParams:
+    @classmethod
+    def get_params(cls, sort):
+        if sort == "MultinomialNB":
+            return {
+                "alpha": [0.1, 0.5, 1.0, 2.0]
+            }
+        elif sort == "GaussianNB":
+            return {}
+        elif sort == "ComplementNB":
+            return {
+                "alpha": [0.1, 0.5, 1, 10],
+                "fit_prior": [True, False],
+                "norm": [True, False]
+            }
+
+
+# 朴素贝叶斯分类
+def naive_bayes_classification(container: Container, model=None):
+    x_train = container.x_train
+    y_train = container.y_train
+    x_test = container.x_test
+    y_test = container.y_test
+    hyper_params_optimize = container.hyper_params_optimize
     info = {}
 
-    # multinomial_naive_bayes_classification_model = MultinomialNB()
-    Gaussian_naive_bayes_classification_model = GaussianNB()
-    # bernoulli_naive_bayes_classification_model = BernoulliNB()
-    # complement_naive_bayes_classification_model = ComplementNB()
+    if model == "MultinomialNB":
+        naive_bayes_model = MultinomialNB()
+        params = NaiveBayesClassifierParams.get_params(model)
+    elif model == "GaussianNB":
+        naive_bayes_model = GaussianNB()
+        params = NaiveBayesClassifierParams.get_params(model)
+    elif model == "ComplementNB":
+        naive_bayes_model = ComplementNB()
+        params = NaiveBayesClassifierParams.get_params(model)
+    else:
+        naive_bayes_model = GaussianNB()
+        params = NaiveBayesClassifierParams.get_params(model)
+
+    if hyper_params_optimize == "grid_search":
+        best_model = grid_search(params, naive_bayes_model, x_train, y_train)
+    elif hyper_params_optimize == "bayes_search":
+        best_model = bayes_search(params, naive_bayes_model, x_train, y_train)
+    else:
+        best_model = naive_bayes_model
+        best_model.fit(x_train, y_train)
+
+    info["参数"] = best_model.get_params()
+
+    y_pred = best_model.predict(x_test)
+    # y_pred = best_model.predict(x_test).reshape(-1, 1)
+    container.set_y_pred(y_pred)
 
-    Gaussian_naive_bayes_classification_model.fit(x_train, y_train)
+    train_sizes, train_scores, test_scores = learning_curve(best_model, x_train, y_train, cv=5)
 
-    y_pred = Gaussian_naive_bayes_classification_model.predict(x_test).reshape(-1, 1)
+    train_scores_mean = np.mean(train_scores, axis=1)
+    train_scores_std = np.std(train_scores, axis=1)
+    test_scores_mean = np.mean(test_scores, axis=1)
+    test_scores_std = np.std(test_scores, axis=1)
+    container.set_learning_curve_values(train_sizes, train_scores_mean, train_scores_std, test_scores_mean,
+                                        test_scores_std)
 
-    # draw_scatter_line_graph(x_test, y_pred, y_test, lr_coef, lr_intercept, ["pred", "real"], "Gaussian naive bayes classification model residual plot")
+    info["指标"] = calculate_classification_metrics(y_pred, y_test)
 
-    info.update(calculate_regression_metrics(y_pred, y_test, "Gaussian naive bayes classification"))
-    info.update(calculate_classification_metrics(y_pred, y_test, "Gaussian naive bayes classification"))
+    container.set_info(info)
+    container.set_status("trained")
+    container.set_model(best_model)
 
-    return info
+    return container
 

analysis/descriptive_analysis.py

@@ -236,8 +236,7 @@ def get_descriptive_indicators_related(df):
                                                                    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["Coefficient of Variation"][col] = descriptive_indicators_df["Standard Deviation"][col] \
                                                                      / descriptive_indicators_df["Avg"][col]
 
     # draw_heat_map(descriptive_indicators_df.to_numpy(), "descriptive indicators", True)

analysis/distance_model.py

@@ -0,0 +1,115 @@
+from sklearn.model_selection import learning_curve
+
+from sklearn.neighbors import KNeighborsClassifier, KNeighborsRegressor
+from analysis.shap_model import *
+from metrics.calculate_classification_metrics import calculate_classification_metrics
+from metrics.calculate_regression_metrics import calculate_regression_metrics
+from static.new_class import *
+from static.process import grid_search, bayes_search
+
+
+class KNNClassifierParams:
+    @classmethod
+    def get_params(cls):
+        return {
+            "n_neighbors": [3, 5, 7, 9],
+            "weights": ['uniform', 'distance'],
+            "p": [1, 2]
+        }
+
+
+# KNN分类
+def knn_classifier(container: Container):
+    x_train = container.x_train
+    y_train = container.y_train
+    x_test = container.x_test
+    y_test = container.y_test
+    hyper_params_optimize = container.hyper_params_optimize
+    info = {}
+
+    knn_classifier_model = KNeighborsClassifier()
+    params = KNNClassifierParams.get_params()
+
+    if hyper_params_optimize == "grid_search":
+        best_model = grid_search(params, knn_classifier_model, x_train, y_train)
+    elif hyper_params_optimize == "bayes_search":
+        best_model = bayes_search(params, knn_classifier_model, x_train, y_train)
+    else:
+        best_model = knn_classifier_model
+        best_model.fit(x_train, y_train)
+
+    info["参数"] = best_model.get_params()
+
+    y_pred = best_model.predict(x_test)
+    container.set_y_pred(y_pred)
+
+    train_sizes, train_scores, test_scores = learning_curve(best_model, x_train, y_train, cv=5)
+
+    train_scores_mean = np.mean(train_scores, axis=1)
+    train_scores_std = np.std(train_scores, axis=1)
+    test_scores_mean = np.mean(test_scores, axis=1)
+    test_scores_std = np.std(test_scores, axis=1)
+    container.set_learning_curve_values(train_sizes, train_scores_mean, train_scores_std, test_scores_mean,
+                                        test_scores_std)
+
+    info["指标"] = calculate_classification_metrics(y_pred, y_test)
+
+    container.set_info(info)
+    container.set_status("trained")
+    container.set_model(best_model)
+
+    return container
+
+
+class KNNRegressionParams:
+    @classmethod
+    def get_params(cls):
+        return {
+            "n_neighbors": [3, 5, 7, 9],
+            "weights": ['uniform', 'distance'],
+            "p": [1, 2]
+        }
+
+
+# KNN回归
+def knn_regression(container: Container):
+    x_train = container.x_train
+    y_train = container.y_train
+    x_test = container.x_test
+    y_test = container.y_test
+    hyper_params_optimize = container.hyper_params_optimize
+    info = {}
+
+    knn_regression_model = KNeighborsRegressor()
+    params = KNNRegressionParams.get_params()
+
+    if hyper_params_optimize == "grid_search":
+        best_model = grid_search(params, knn_regression_model, x_train, y_train)
+    elif hyper_params_optimize == "bayes_search":
+        best_model = bayes_search(params, knn_regression_model, x_train, y_train)
+    else:
+        best_model = knn_regression_model
+        best_model.fit(x_train, y_train)
+
+    info["参数"] = best_model.get_params()
+
+    y_pred = best_model.predict(x_test)
+    # y_pred = best_model.predict(x_test).reshape(-1, 1)
+    container.set_y_pred(y_pred)
+
+    train_sizes, train_scores, test_scores = learning_curve(best_model, x_train, y_train, cv=5)
+
+    train_scores_mean = np.mean(train_scores, axis=1)
+    train_scores_std = np.std(train_scores, axis=1)
+    test_scores_mean = np.mean(test_scores, axis=1)
+    test_scores_std = np.std(test_scores, axis=1)
+    container.set_learning_curve_values(train_sizes, train_scores_mean, train_scores_std, test_scores_mean,
+                                        test_scores_std)
+
+    info["指标"] = calculate_regression_metrics(y_pred, y_test)
+
+    container.set_info(info)
+    container.set_status("trained")
+    container.set_model(best_model)
+
+    return container

analysis/gradient_model.py

@@ -1,72 +1,65 @@
+import numpy as np
 from sklearn.ensemble import GradientBoostingRegressor
-from sklearn.tree import DecisionTreeClassifier
-from sklearn.ensemble import RandomForestClassifier
-from xgboost import XGBClassifier
 from sklearn.model_selection import learning_curve
-import numpy as np
-
-from analysis.shap_model import shap_calculate
-from coding.llh.static.config import Config
-from coding.llh.static.process import grid_search, bayes_search
-from coding.llh.visualization.draw_learning_curve import draw_learning_curve
-from coding.llh.visualization.draw_line_graph import draw_line_graph
-from coding.llh.visualization.draw_scatter_line_graph import draw_scatter_line_graph
-from coding.llh.metrics.calculate_classification_metrics import calculate_classification_metrics
-from coding.llh.metrics.calculate_regression_metrics import calculate_regression_metrics
-from sklearn.ensemble import RandomForestRegressor
 
-
-def gradient_boosting_regression(feature_names, x, y, x_train_and_validate, y_train_and_validate, x_test, y_test, train_and_validate_data_list=None, hyper_params_optimize=None):
+from analysis.shap_model import draw_shap_beeswarm
+from metrics.calculate_regression_metrics import calculate_regression_metrics
+from static.config import Config
+from static.new_class import Container
+from static.process import grid_search, bayes_search
+
+
+class GradientBoostingParams:
+    @classmethod
+    def get_params(cls):
+        return {
+            'n_estimators': [50, 100, 150],
+            'learning_rate': [0.01, 0.1, 0.2],
+            'max_depth': [3, 5, 7],
+            'min_samples_split': [2, 5, 10],
+            'min_samples_leaf': [1, 2, 4]
+        }
+
+
+# 梯度提升回归
+def gradient_boosting_regression(container: Container):
+    x_train = container.x_train
+    y_train = container.y_train
+    x_test = container.x_test
+    y_test = container.y_test
+    hyper_params_optimize = container.hyper_params_optimize
     info = {}
-    model_name = "Double Exponential Smoothing Plus"
 
-    model = GradientBoostingRegressor()
-    params = {
-        'n_estimators': [50, 100, 150],
-        'learning_rate': [0.01, 0.1, 0.2],
-        'max_depth': [3, 5, 7],
-        'min_samples_split': [2, 5, 10],
-        'min_samples_leaf': [1, 2, 4]
-    }
+    gradient_boosting_regression_model = GradientBoostingRegressor(random_state=Config.RANDOM_STATE)
+    params = GradientBoostingParams.get_params()
 
     if hyper_params_optimize == "grid_search":
-        best_model = grid_search(params, model, x_train_and_validate, y_train_and_validate)
+        best_model = grid_search(params, gradient_boosting_regression_model, x_train, y_train)
     elif hyper_params_optimize == "bayes_search":
-        best_model = bayes_search(params, model, x_train_and_validate, y_train_and_validate)
+        best_model = bayes_search(params, gradient_boosting_regression_model, x_train, y_train)
     else:
-        best_model = model
-        best_model.fit(x, y)
-
-    info["{} Params".format(model_name)] = best_model.get_params()
+        best_model = gradient_boosting_regression_model
+        best_model.fit(x_train, y_train)
 
-    y_pred = best_model.predict(x_test).reshape(-1, 1)
+    info["参数"] = best_model.get_params()
 
-    # 0202:
+    y_pred = best_model.predict(x_test)
+    # y_pred = best_model.predict(x_test).reshape(-1, 1)
+    container.set_y_pred(y_pred)
 
-    train_sizes, train_scores, test_scores = learning_curve(best_model, x, y, cv=5, scoring="r2")
+    train_sizes, train_scores, test_scores = learning_curve(best_model, x_train, y_train, cv=5)
 
     train_scores_mean = np.mean(train_scores, axis=1)
     train_scores_std = np.std(train_scores, axis=1)
     test_scores_mean = np.mean(test_scores, axis=1)
     test_scores_std = np.std(test_scores, axis=1)
+    container.set_learning_curve_values(train_sizes, train_scores_mean, train_scores_std, test_scores_mean,
+                                        test_scores_std)
 
-    # 修正
-    train_scores_mean[0] = 0.984
-    test_scores_mean[1] = 0.89
-    test_scores_mean[2] = 0.93
-    test_scores_mean[3] = 0.97
-    test_scores_mean[4] = 0.98
-
-
-    # draw_learning_curve(train_sizes, train_scores_mean, train_scores_std, test_scores_mean, test_scores_std)
-
-    # draw_scatter_line_graph(x_test, y_pred, y_test, lr_coef, lr_intercept, ["pred", "real"], "logistic regression model residual plot")
-
-    info.update(calculate_regression_metrics(y_pred, y_test, model_name))
-    # info.update(calculate_classification_metrics(y_pred, y_test, "logistic regression"))
-    # mae, mse, rsme, r2, ar2 = calculate_regression_metrics(y_pred, y_test, model_name)
+    info["指标"] = calculate_regression_metrics(y_pred, y_test)
 
-    shap_calculate(best_model, x[:1000], feature_names)
+    container.set_info(info)
+    container.set_status("trained")
+    container.set_model(best_model)
 
-    # return y_pred, info
-    return y_pred, info, train_sizes, train_scores_mean, train_scores_std, test_scores_mean, test_scores_std
+    return container

analysis/kernel_model.py

@@ -1,97 +1,119 @@
+import numpy as np
 from sklearn.model_selection import learning_curve
 from sklearn.svm import SVC
 from sklearn.svm import SVR
-import numpy as np
-
-from coding.llh.analysis.my_learning_curve import my_learning_curve
-from coding.llh.analysis.shap_model import shap_calculate
-from coding.llh.static.process import grid_search, bayes_search
-from coding.llh.visualization.draw_line_graph import draw_line_graph
-from coding.llh.visualization.draw_scatter_line_graph import draw_scatter_line_graph
-from coding.llh.metrics.calculate_classification_metrics import calculate_classification_metrics
-from coding.llh.metrics.calculate_regression_metrics import calculate_regression_metrics
-
 
-def svm_regression(feature_names, x, y, x_train_and_validate, y_train_and_validate, x_test, y_test, train_and_validate_data_list=None, hyper_params_optimize=None):
+from metrics.calculate_classification_metrics import calculate_classification_metrics
+from metrics.calculate_regression_metrics import calculate_regression_metrics
+from static.config import Config
+from static.new_class import Container
+from static.process import grid_search, bayes_search
+
+
+class SVMRegressionParams:
+    @classmethod
+    def get_params(cls):
+        return {
+            'kernel': ['linear', 'rbf'],
+            'C': [0.1, 1, 10, 100],
+            'gamma': [0.01, 0.1, 1, 10],
+            'epsilon': [0.01, 0.1, 1]
+        }
+
+
+# 支持向量机回归
+def svm_regression(container: Container):
+    x_train = container.x_train
+    y_train = container.y_train
+    x_test = container.x_test
+    y_test = container.y_test
+    hyper_params_optimize = container.hyper_params_optimize
     info = {}
-    model_name = "Support Vector Regression"
 
-    model = SVR(kernel='rbf', C=100, gamma=0.1, epsilon=0.1)
-    params = {
-        'kernel': ['linear', 'rbf'],
-        'C': [0.1, 1, 10, 100],
-        'gamma': [0.01, 0.1, 1, 10],
-        'epsilon': [0.01, 0.1, 1]
-    }
+    svm_regression_model = SVR(kernel='rbf', C=100, gamma=0.1, epsilon=0.1)
+    params = SVMRegressionParams.get_params()
 
     if hyper_params_optimize == "grid_search":
-        best_model = grid_search(params, model, x_train_and_validate, y_train_and_validate)
+        best_model = grid_search(params, svm_regression_model, x_train, y_train)
     elif hyper_params_optimize == "bayes_search":
-        best_model = bayes_search(params, model, x_train_and_validate, y_train_and_validate)
+        best_model = bayes_search(params, svm_regression_model, x_train, y_train)
     else:
-        best_model = model
-        best_model.fit(x, y)
+        best_model = svm_regression_model
+        best_model.fit(x_train, y_train)
 
-    info["{} Params".format(model_name)] = best_model.get_params()
+    info["参数"] = best_model.get_params()
 
-    y_pred = best_model.predict(x_test).reshape(-1, 1)
+    y_pred = best_model.predict(x_test)
+    # y_pred = best_model.predict(x_test).reshape(-1, 1)
+    container.set_y_pred(y_pred)
 
-    # 0202:
-
-    # train_sizes, train_scores, test_scores = my_learning_curve(best_model, x[:300], y[:300], cv=5)
-    train_sizes, train_scores, test_scores = learning_curve(best_model, x, y, cv=5, scoring="r2")
+    train_sizes, train_scores, test_scores = learning_curve(best_model, x_train, y_train, cv=5)
 
     train_scores_mean = np.mean(train_scores, axis=1)
     train_scores_std = np.std(train_scores, axis=1)
     test_scores_mean = np.mean(test_scores, axis=1)
     test_scores_std = np.std(test_scores, axis=1)
+    container.set_learning_curve_values(train_sizes, train_scores_mean, train_scores_std, test_scores_mean,
+                                        test_scores_std)
 
-    # 修正
-    train_scores_mean[0] = 0.99
-    test_scores_mean[0] = 0.02
-
-    # draw_learning_curve(train_sizes, train_scores_mean, train_scores_std, test_scores_mean, test_scores_std)
+    info["指标"] = calculate_regression_metrics(y_pred, y_test)
 
-    # draw_scatter_line_graph(x_test, y_pred, y_test, lr_coef, lr_intercept, ["pred", "real"], "logistic regression model residual plot")
+    container.set_info(info)
+    container.set_status("trained")
+    container.set_model(best_model)
 
-    info.update(calculate_regression_metrics(y_pred, y_test, model_name))
-    # info.update(calculate_classification_metrics(y_pred, y_test, "logistic regression"))
-    # mae, mse, rsme, r2, ar2 = calculate_regression_metrics(y_pred, y_test, model_name)
+    return container
 
-    # shap_calculate(best_model, x_test, feature_names)
 
-    return y_pred, info, train_sizes, train_scores_mean, train_scores_std, test_scores_mean, test_scores_std
+class SVMClassifierParams:
+    @classmethod
+    def get_params(cls):
+        return {
+            "C": [0.1, 1, 10, 100],
+            "kernel": ['linear', 'rbf', 'poly'],
+            "gamma": [0.1, 1, 10]
+        }
 
 
-# svm classification
-def svm_classification(x_train, y_train, x_test, y_test):
+# 支持向量机分类
+def svm_classifier(container: Container):
+    x_train = container.x_train
+    y_train = container.y_train
+    x_test = container.x_test
+    y_test = container.y_test
+    hyper_params_optimize = container.hyper_params_optimize
     info = {}
 
-    # # Linear kernel SVM
-    # svm_classification_model = SVC(kernel="linear")
-    #
-    # # Polynomial kernel SVM
-    # svm_classification_model = SVC(kernel="poly")
-    #
-    # Radial base kernel SVM
-    svm_classification_model = SVC(kernel="rbf")
+    svm_classifier_model = SVC(kernel="rbf")
+    params = SVMClassifierParams.get_params()
 
-    # # Sigmoid kernel SVM
-    # svm_classification_model = SVC(kernel="rbf")
+    if hyper_params_optimize == "grid_search":
+        best_model = grid_search(params, svm_classifier_model, x_train, y_train)
+    elif hyper_params_optimize == "bayes_search":
+        best_model = bayes_search(params, svm_classifier_model, x_train, y_train)
+    else:
+        best_model = svm_classifier_model
+        best_model.fit(x_train, y_train)
 
-    svm_classification_model.fit(x_train, y_train)
+    info["参数"] = best_model.get_params()
 
-    lr_intercept = svm_classification_model.intercept_
-    info["Intercept of linear regression equation"] = lr_intercept
+    y_pred = best_model.predict(x_test)
+    # y_pred = best_model.predict(x_test).reshape(-1, 1)
+    container.set_y_pred(y_pred)
 
-    lr_coef = svm_classification_model.coef_
-    info["Coefficients of linear regression equation"] = lr_coef
+    train_sizes, train_scores, test_scores = learning_curve(best_model, x_train, y_train, cv=5)
 
-    y_pred = svm_classification_model.predict(x_test)
+    train_scores_mean = np.mean(train_scores, axis=1)
+    train_scores_std = np.std(train_scores, axis=1)
+    test_scores_mean = np.mean(test_scores, axis=1)
+    test_scores_std = np.std(test_scores, axis=1)
+    container.set_learning_curve_values(train_sizes, train_scores_mean, train_scores_std, test_scores_mean,
+                                        test_scores_std)
 
-    # draw_scatter_line_graph(x_test, y_pred, y_test, lr_coef, lr_intercept, ["pred", "real"], "linear regression model residual plot")
+    info["指标"] = calculate_classification_metrics(y_pred, y_test)
 
-    info.update(calculate_regression_metrics(y_pred, y_test, "linear regression"))
-    info.update(calculate_classification_metrics(y_pred, y_test, "linear regression"))
+    container.set_info(info)
+    container.set_status("trained")
+    container.set_model(best_model)
 
-    return info
+    return container

analysis/linear_model.py

@@ -11,7 +11,23 @@ from sklearn.model_selection import learning_curve
 from static.process import grid_search, bayes_search
 from metrics.calculate_classification_metrics import calculate_classification_metrics
 from metrics.calculate_regression_metrics import calculate_regression_metrics
-from app import Container
+from static.new_class import *
+from static.config import Config
+
+
+class LinearRegressionParams:
+    @classmethod
+    def get_params(cls, sort):
+        if sort in ["Lasso", "Ridge", "ElasticNet"]:
+            return {
+                "fit_intercept": [True, False],
+                "alpha": [0.001, 0.01, 0.1, 1.0, 10.0],
+                "random_state": [Config.RANDOM_STATE]
+            }
+        else:
+            return {
+                "fit_intercept": [True, False]
+            }
 
 
 # 线性回归
@@ -24,28 +40,20 @@ def linear_regression(container: Container, model=None):
     info = {}
 
     if model == "Lasso":
-        linear_regression_model = Lasso(alpha=0.1)
-        params = {
-            "fit_intercept": [True, False],
-            "alpha": [0.001, 0.01, 0.1, 1.0, 10.0]
-        }
+        linear_regression_model = Lasso(alpha=0.1, random_state=Config.RANDOM_STATE)
+        params = LinearRegressionParams.get_params(model)
     elif model == "Ridge":
-        linear_regression_model = Ridge(alpha=0.1)
-        params = {
-            "fit_intercept": [True, False],
-            "alpha": [0.001, 0.01, 0.1, 1.0, 10.0]
-        }
+        linear_regression_model = Ridge(alpha=0.1, random_state=Config.RANDOM_STATE)
+        params = LinearRegressionParams.get_params(model)
     elif model == "ElasticNet":
-        linear_regression_model = ElasticNet(alpha=0.1)
-        params = {
-            "fit_intercept": [True, False],
-            "alpha": [0.001, 0.01, 0.1, 1.0, 10.0]
-        }
+        linear_regression_model = ElasticNet(alpha=0.1, random_state=Config.RANDOM_STATE)
+        params = LinearRegressionParams.get_params(model)
+    elif model == "LinearRegression":
+        linear_regression_model = LinearRegression()
+        params = LinearRegressionParams.get_params(model)
     else:
         linear_regression_model = LinearRegression()
-        params = {
-            "fit_intercept": [True, False]
-        }
+        params = LinearRegressionParams.get_params(model)
 
     if hyper_params_optimize == "grid_search":
         best_model = grid_search(params, linear_regression_model, x_train, y_train)
@@ -55,13 +63,13 @@ def linear_regression(container: Container, model=None):
         best_model = linear_regression_model
         best_model.fit(x_train, y_train)
 
-    info["linear regression Params"] = best_model.get_params()
-
-    lr_intercept = best_model.intercept_
-    info["Intercept of linear regression equation"] = lr_intercept
+    info["参数"] = best_model.get_params()
 
-    lr_coef = best_model.coef_
-    info["Coefficients of linear regression equation"] = lr_coef
+    # lr_intercept = best_model.intercept_
+    # info["Intercept of linear regression equation"] = lr_intercept
+    #
+    # lr_coef = best_model.coef_
+    # info["Coefficients of linear regression equation"] = lr_coef
 
     y_pred = best_model.predict(x_test)
     container.set_y_pred(y_pred)
@@ -72,9 +80,10 @@ def linear_regression(container: Container, model=None):
     train_scores_std = np.std(train_scores, axis=1)
     test_scores_mean = np.mean(test_scores, axis=1)
     test_scores_std = np.std(test_scores, axis=1)
-    container.set_learning_curve_values(train_sizes, train_scores_mean, train_scores_std, test_scores_mean, test_scores_std)
+    container.set_learning_curve_values(train_sizes, train_scores_mean, train_scores_std, test_scores_mean,
+                                        test_scores_std)
 
-    info.update(calculate_regression_metrics(y_pred, y_test, "linear regression"))
+    info["参数"] = calculate_regression_metrics(y_pred, y_test)
 
     container.set_info(info)
     container.set_status("trained")
@@ -83,6 +92,15 @@ def linear_regression(container: Container, model=None):
     return container
 
 
+class PolynomialRegressionParams:
+    @classmethod
+    def get_params(cls):
+        return {
+            "polynomial_features__degree": [2, 3],
+            "linear_regression_model__fit_intercept": [True, False]
+        }
+
+
 # 多项式回归
 def polynomial_regression(container: Container):
     x_train = container.x_train
@@ -97,10 +115,7 @@ def polynomial_regression(container: Container):
 
     polynomial_regression_model = Pipeline([("polynomial_features", polynomial_features),
                                             ("linear_regression_model", linear_regression_model)])
-    params = {
-        "polynomial_features__degree": [2, 3],
-        "linear_regression_model__fit_intercept": [True, False]
-    }
+    params = PolynomialRegressionParams.get_params()
 
     if hyper_params_optimize == "grid_search":
         best_model = grid_search(params, polynomial_regression_model, x_train, y_train)
@@ -110,16 +125,16 @@ def polynomial_regression(container: Container):
         best_model = polynomial_regression_model
         best_model.fit(x_train, y_train)
 
-    info["polynomial regression Params"] = best_model.get_params()
-
-    feature_names = best_model["polynomial_features"].get_feature_names_out()
-    info["Feature names of polynomial regression"] = feature_names
+    info["参数"] = best_model.get_params()
 
-    lr_intercept = best_model["linear_regression_model"].intercept_
-    info["Intercept of polynomial regression equation"] = lr_intercept
-
-    lr_coef = best_model["linear_regression_model"].coef_
-    info["Coefficients of polynomial regression equation"] = lr_coef
+    # feature_names = best_model["polynomial_features"].get_feature_names_out()
+    # info["Feature names of polynomial regression"] = feature_names
+    #
+    # lr_intercept = best_model["linear_regression_model"].intercept_
+    # info["Intercept of polynomial regression equation"] = lr_intercept
+    #
+    # lr_coef = best_model["linear_regression_model"].coef_
+    # info["Coefficients of polynomial regression equation"] = lr_coef
 
     x_test_ = best_model["polynomial_features"].fit_transform(x_test)
     y_pred = best_model["linear_regression_model"].predict(x_test_)
@@ -133,7 +148,7 @@ def polynomial_regression(container: Container):
     test_scores_std = np.std(test_scores, axis=1)
     container.set_learning_curve_values(train_sizes, train_scores_mean, train_scores_std, test_scores_mean, test_scores_std)
 
-    info.update(calculate_regression_metrics(y_pred, y_test, "polynomial regression"))
+    info["指标"] = calculate_regression_metrics(y_pred, y_test)
 
     container.set_info(info)
     container.set_status("trained")
@@ -142,7 +157,18 @@ def polynomial_regression(container: Container):
     return container
 
 
-# 逻辑斯谛回归
+class LogisticRegressionParams:
+    @classmethod
+    def get_params(cls):
+        return {
+            "C": [0.001, 0.01, 0.1, 1.0, 10.0],
+            "max_iter": [100, 200, 300],
+            "solver": ["liblinear", "lbfgs", "newton-cg", "sag", "saga"],
+            "random_state": [Config.RANDOM_STATE]
+        }
+
+
+# 逻辑斯谛分类
 def logistic_regression(container: Container):
     x_train = container.x_train
     y_train = container.y_train
@@ -151,12 +177,8 @@ def logistic_regression(container: Container):
     hyper_params_optimize = container.hyper_params_optimize
     info = {}
 
-    logistic_regression_model = LogisticRegression()
-    params = {
-        "C": [0.001, 0.01, 0.1, 1.0, 10.0],
-        "max_iter": [100, 200, 300],
-        "solver": ["liblinear", "lbfgs", "newton-cg", "sag", "saga"]
-    }
+    logistic_regression_model = LogisticRegression(random_state=Config.RANDOM_STATE)
+    params = LogisticRegressionParams.get_params()
 
     if hyper_params_optimize == "grid_search":
         best_model = grid_search(params, logistic_regression_model, x_train, y_train)
@@ -166,13 +188,13 @@ def logistic_regression(container: Container):
         best_model = logistic_regression_model
         best_model.fit(x_train, y_train)
 
-    info["logistic regression Params"] = best_model.get_params()
+    info["参数"] = best_model.get_params()
 
-    lr_intercept = best_model.intercept_
-    info["Intercept of logistic regression equation"] = lr_intercept.tolist()
-
-    lr_coef = best_model.coef_
-    info["Coefficients of logistic regression equation"] = lr_coef.tolist()
+    # lr_intercept = best_model.intercept_
+    # info["Intercept of logistic regression equation"] = lr_intercept.tolist()
+    #
+    # lr_coef = best_model.coef_
+    # info["Coefficients of logistic regression equation"] = lr_coef.tolist()
 
     y_pred = best_model.predict(x_test)
     container.set_y_pred(y_pred)
@@ -183,9 +205,10 @@ def logistic_regression(container: Container):
     train_scores_std = np.std(train_scores, axis=1)
     test_scores_mean = np.mean(test_scores, axis=1)
     test_scores_std = np.std(test_scores, axis=1)
-    container.set_learning_curve_values(train_sizes, train_scores_mean, train_scores_std, test_scores_mean, test_scores_std)
+    container.set_learning_curve_values(train_sizes, train_scores_mean, train_scores_std, test_scores_mean,
+                                        test_scores_std)
 
-    info.update(calculate_classification_metrics(y_pred, y_test, "logistic regression"))
+    info["指标"] = calculate_classification_metrics(y_pred, y_test)
 
     container.set_info(info)
     container.set_status("trained")

analysis/others/evaluation_model.py

@@ -0,0 +1,99 @@
+import numpy as np
+import skfuzzy as fuzz
+from skfuzzy import control as ctrl
+import matplotlib.pyplot as plt
+
+
+def fuzzy_comprehensive_evaluation_model():
+    # 创建模糊变量和模糊集合
+    technical_skill = ctrl.Antecedent(np.arange(0, 101, 1), 'technical_skill')
+    physical_condition = ctrl.Antecedent(np.arange(0, 101, 1), 'physical_condition')
+    mental_toughness = ctrl.Antecedent(np.arange(0, 101, 1), 'mental_toughness')
+    opponent_strength = ctrl.Antecedent(np.arange(0, 101, 1), 'opponent_strength')
+
+    performance = ctrl.Consequent(np.arange(0, 101, 1), 'performance')
+
+    # 设定模糊隶属度函数
+    technical_skill['low'] = fuzz.trimf(technical_skill.universe, [0, 0, 50])
+    technical_skill['medium'] = fuzz.trimf(technical_skill.universe, [0, 50, 100])
+    technical_skill['high'] = fuzz.trimf(technical_skill.universe, [50, 100, 100])
+
+    physical_condition['low'] = fuzz.trimf(physical_condition.universe, [0, 0, 50])
+    physical_condition['medium'] = fuzz.trimf(physical_condition.universe, [0, 50, 100])
+    physical_condition['high'] = fuzz.trimf(physical_condition.universe, [50, 100, 100])
+
+    mental_toughness['low'] = fuzz.trimf(mental_toughness.universe, [0, 0, 50])
+    mental_toughness['medium'] = fuzz.trimf(mental_toughness.universe, [0, 50, 100])
+    mental_toughness['high'] = fuzz.trimf(mental_toughness.universe, [50, 100, 100])
+
+    opponent_strength['low'] = fuzz.trimf(opponent_strength.universe, [0, 0, 50])
+    opponent_strength['medium'] = fuzz.trimf(opponent_strength.universe, [0, 50, 100])
+    opponent_strength['high'] = fuzz.trimf(opponent_strength.universe, [50, 100, 100])
+
+    performance['poor'] = fuzz.trimf(performance.universe, [0, 0, 50])
+    performance['average'] = fuzz.trimf(performance.universe, [0, 50, 100])
+    performance['excellent'] = fuzz.trimf(performance.universe, [50, 100, 100])
+
+    # 设定输出的解模糊方法——质心解模糊方式
+    performance.defuzzify_method = 'centroid'
+
+    # 设定规则
+    rule1 = ctrl.Rule(
+        technical_skill['low'] | physical_condition['low'] | mental_toughness['low'] | opponent_strength['low'],
+        performance['poor']
+    )
+    rule2 = ctrl.Rule(
+        technical_skill['medium'] | physical_condition['medium'] | mental_toughness['medium'] | opponent_strength['medium'],
+        performance['average']
+    )
+    rule3 = ctrl.Rule(
+        technical_skill['high'] | physical_condition['high'] | mental_toughness['high'] | opponent_strength['high'],
+        performance['excellent']
+    )
+
+    # 创建控制系统
+    performance_evaluation = ctrl.ControlSystem([rule1, rule2, rule3])
+    performance_evaluator = ctrl.ControlSystemSimulation(performance_evaluation)
+
+    # 输入数据
+    performance_evaluator.input['technical_skill'] = 75
+    performance_evaluator.input['physical_condition'] = 80
+    performance_evaluator.input['mental_toughness'] = 85
+    performance_evaluator.input['opponent_strength'] = 60
+
+    # 计算模糊综合评分
+    performance_evaluator.compute()
+
+    # 输出结果
+    print("模糊综合评分:", performance_evaluator.output['performance'])
+
+    # 打印模糊集合的可视化图表
+    technical_skill.view("technical_skill", sim=performance_evaluator)
+    physical_condition.view("physical_condition", sim=performance_evaluator)
+    mental_toughness.view("mental_toughness", sim=performance_evaluator)
+    opponent_strength.view("opponent_strength", sim=performance_evaluator)
+    performance.view("performance", sim=performance_evaluator)
+
+    # Perform sensitivity analyze (to change input value)
+
+    # input_var_1:
+
+    # input_values = np.arange(0, 11, 1)
+    # output_values = []
+    #
+    # for val in input_values:
+    #     fuzzy_control_sys_simulation.input["input_var_1"] = val
+    #     fuzzy_control_sys_simulation.compute()
+    #     output_values.append(fuzzy_control_sys_simulation.output["output_var"])
+    #
+    # plt.plot(
+    #     input_values,
+    #     output_values,
+    #     label="Sensitivity Analysis"
+    # )
+    # plt.xlabel("Input Variable 1")
+    # plt.ylabel("Output Variable")
+    # plt.legend()
+    # plt.show()
+    #
+    # return fuzzy_control_sys_simulation.output["output_var"]

analysis/others/gaussian_model.py

@@ -0,0 +1,28 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.mixture import GaussianMixture
+
+
+def gaussian_mix(x):
+    x = x.reshape(-1, 1)
+    n_components = 2000  # 你可以根据需要调整混合组件的数量
+    gmm = GaussianMixture(n_components=n_components, covariance_type='full')
+
+    # 拟合模型
+    gmm.fit(x)
+
+    # 预测每个数据点所属的组件
+    continuous_data = gmm.sample(len(x))[0].reshape(-1)
+
+    return continuous_data
+
+    # 使用高斯混合模型拟合数据
+    # gmm = GaussianMixture(n_components=50)  # 选择混合成分的数量
+    # gmm.fit(x.reshape(-1, 1))
+
+    # 生成连续数据
+    # return np.linspace(min(x), max(x), len(x)).flatten()
+
+    # z = np.exp(gmm.score_samples(y.reshape(-1, 1)))
+
+    # return z

analysis/others/markov_model.py

@@ -0,0 +1,98 @@
+import numpy as np
+import pandas as pd
+from hmmlearn import hmm
+
+
+def train_and_predict_hidden_markov_model(df):
+    window_size = 10
+
+    # train_df = df[['point_won', 'point_loss', 'ace', 'winner', 'double_fault', 'unf_err', 'net_point', 'net_point_won', 'break_pt', 'break_pt_won', 'break_pt_miss']]
+
+    train_df = df
+    #         "p1_winner",
+    #         "p2_winner",
+    #         "winner_shot_type",
+    #         "p1_double_fault",
+    #         "p2_double_fault",
+    #         "p1_unf_err",
+    #         "p2_unf_err",
+    #         "p1_net_pt_won",
+    #         "p2_net_pt_won",
+    #         "p1_break_pt_won",
+    #         "p2_break_pt_won",
+    #         "rally_count",
+    #         "serve_width",
+    #         "serve_depth",
+    #         "return_depth"
+    df["observation"] = 0
+
+    # mapping = {}
+    # counter = 0
+    # for i in range(len(train_df)):
+    #     cur_combination = train_df.iloc[i].to_list()
+    #
+    #     if str(cur_combination) not in mapping.keys():
+    #         mapping[str(cur_combination)] = counter
+    #         df.loc[i, "observation"] = counter
+    #         counter += 1
+    #     else:
+    #         df.loc[i, "observation"] = mapping[str(cur_combination)]
+
+    observation_list = df["observation"].to_list()
+
+    # value_separated_observation_list = [observation_list[i - window_size: i] for i in range(window_size, len(observation_list))]
+    # value_separated_observation_list = [[0] * window_size] * window_size + value_separated_observation_list
+
+    observations = np.array([np.sum(np.array([train_df.iloc[j].to_list() for j in range(i-window_size, i)]).astype(int), axis=0) for i in range(window_size, len(train_df))])
+
+    observations = abs(np.min(observations)) + observations
+
+    observations = observations.astype(int)
+
+    m_observations = np.concatenate(
+        (np.array([observations[0].tolist()] * window_size), observations),
+        axis=0
+    )
+
+    df = pd.concat([df, pd.DataFrame({"window_observation": m_observations.tolist()})], axis=1)
+
+    hidden_markov_model = hmm.MultinomialHMM(n_components=5, n_iter=50, tol=0.01)
+
+    hidden_markov_model.fit(observations)
+
+    start_prob = hidden_markov_model.startprob_
+    transition_prob = hidden_markov_model.transmat_
+    emission_prob = hidden_markov_model.emissionprob_
+
+    neg_log_likelihood, pred = calculate_momentum(df, hidden_markov_model, m_observations)
+
+    _, hidden2observation = hidden_markov_model.score_samples(observations)
+
+    state_impacts = np.sum(hidden2observation, axis=0)
+
+    return state_impacts, neg_log_likelihood, pred, start_prob, transition_prob, emission_prob
+
+    state_impacts = np.zeros((num_states, num_obs))
+
+    for t in range(num_obs):
+        for i in range(num_states):
+            state_impacts[i, t] = (forward_prob[t, i] * backward_prob[t, i]) / np.sum(
+                forward_prob[t, :] * backward_prob[t, :])
+
+    return neg_log_likelihood, pred, start_prob, transition_prob, emission_prob
+
+
+def calculate_momentum(df, hidden_markov_model, m_observations):
+    # pred_list = []
+    # neg_log_likelihood_list = []
+    # for i in range(len(df)):
+    #     neg_log_likelihood, pred = hidden_markov_model.decode(np.array([df.loc[i, "window_observation"]]))
+    #     pred_list.append(pred[0])
+    #     neg_log_likelihood_list.append(neg_log_likelihood)
+    #
+    # return pred_list, neg_log_likelihood_list
+
+    neg_log_likelihood, pred = hidden_markov_model.decode(m_observations)
+
+    return neg_log_likelihood, pred
+

analysis/others/poly_model.py

@@ -0,0 +1,12 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def poly_fit(x_values, y_values, degree=60):
+    # 使用 numpy 的 polyfit 函数进行多项式拟合
+    coefficients = np.polyfit(x_values, y_values, degree)
+
+    # 生成拟合的多项式函数
+    fitted_curve = np.poly1d(coefficients)
+
+    return fitted_curve(x_values)

analysis/shap_model.py

@@ -1,15 +1,52 @@
 import matplotlib.pyplot as plt
-
+import numpy as np
 import shap
 
 
-def shap_calculate(model, x, feature_names, paint_object):
-    explainer = shap.Explainer(model.predict, x)
+def draw_shap_beeswarm(model, x, feature_names, type, paint_object):
+    explainer = shap.KernelExplainer(model.predict, x)
+    shap_values = explainer(x)
+
+    shap.summary_plot(shap_values, x, feature_names=feature_names, plot_type=type, show=False)
+
+    plt.title(paint_object.get_name())
+    plt.tight_layout()
+
+    return plt, paint_object
+
+
+def draw_waterfall(model, x, feature_names, number, paint_object):
+    explainer = shap.KernelExplainer(model.predict, x, feature_names=feature_names)
+    shap_values = explainer(x)
+
+    shap.waterfall_plot(shap_values[number], show=False)
+
+    plt.title(paint_object.get_name())
+    plt.tight_layout()
+
+    return plt, paint_object
+
+
+def draw_force(model, x, feature_names, number, paint_object):
+    explainer = shap.KernelExplainer(model.predict, x, feature_names=feature_names)
+    shap_values = explainer(x[number])
+
+    shap.force_plot(explainer.expected_value, shap_values.values, feature_names=feature_names, show=False, matplotlib=True)
+
+    plt.title(paint_object.get_name())
+    plt.tight_layout()
+
+    return plt, paint_object
+
+
+def draw_dependence(model, x, feature_names, col, paint_object):
+    explainer = shap.KernelExplainer(model.predict, x, feature_names=feature_names)
     shap_values = explainer(x)
 
-    shap.summary_plot(shap_values, x, feature_names=feature_names, show=False)
+    shap.dependence_plot(feature_names.index(col), shap_values.values, x, feature_names=feature_names, show=False)
 
     plt.title(paint_object.get_name())
+    plt.tight_layout()
 
     return plt, paint_object
 

analysis/tree_model.py

@@ -1,208 +1,290 @@
-from sklearn.tree import DecisionTreeClassifier
+from metrics.calculate_regression_metrics import calculate_regression_metrics
 from sklearn.ensemble import RandomForestClassifier
-from xgboost import XGBClassifier
-from sklearn.model_selection import learning_curve
-import numpy as np
-
-from coding.llh.analysis.shap_model import shap_calculate
-from coding.llh.static.config import Config
-from coding.llh.static.process import grid_search, bayes_search
-from coding.llh.visualization.draw_learning_curve import draw_learning_curve
-from coding.llh.visualization.draw_line_graph import draw_line_graph
-from coding.llh.visualization.draw_scatter_line_graph import draw_scatter_line_graph
-from coding.llh.metrics.calculate_classification_metrics import calculate_classification_metrics
-from coding.llh.metrics.calculate_regression_metrics import calculate_regression_metrics
 from sklearn.ensemble import RandomForestRegressor
-
-
-def random_forest_regression(feature_names, x, y, x_train_and_validate, y_train_and_validate, x_test, y_test, train_and_validate_data_list=None, hyper_params_optimize=None):
+from sklearn.model_selection import learning_curve
+from sklearn.tree import DecisionTreeClassifier
+from xgboost import XGBClassifier
+import lightgbm as lightGBMClassifier
+
+from analysis.shap_model import *
+from metrics.calculate_classification_metrics import calculate_classification_metrics
+from static.config import Config
+from static.process import grid_search, bayes_search
+from static.new_class import *
+
+
+class RandomForestRegressionParams:
+    @classmethod
+    def get_params(cls):
+        return {
+            'n_estimators': [10, 50, 100, 200],
+            'max_depth': [None, 10, 20, 30],
+            'min_samples_split': [2, 5, 10],
+            'min_samples_leaf': [1, 2, 4]
+        }
+
+
+# 随机森林回归
+def random_forest_regression(container: Container):
+    x_train = container.x_train
+    y_train = container.y_train
+    x_test = container.x_test
+    y_test = container.y_test
+    hyper_params_optimize = container.hyper_params_optimize
     info = {}
-    model_name = "Random Forest Regression"
 
-    model = RandomForestRegressor(n_estimators=5)
-    params = {
-        'n_estimators': [10, 50, 100, 200],
-        'max_depth': [None, 10, 20, 30],
-        'min_samples_split': [2, 5, 10],
-        'min_samples_leaf': [1, 2, 4]
-    }
+    random_forest_regression_model = RandomForestRegressor(n_estimators=5, random_state=Config.RANDOM_STATE)
+    params = RandomForestRegressionParams.get_params()
 
     if hyper_params_optimize == "grid_search":
-        best_model = grid_search(params, model, x_train_and_validate, y_train_and_validate)
+        best_model = grid_search(params, random_forest_regression_model, x_train, y_train)
     elif hyper_params_optimize == "bayes_search":
-        best_model = bayes_search(params, model, x_train_and_validate, y_train_and_validate)
+        best_model = bayes_search(params, random_forest_regression_model, x_train, y_train)
     else:
-        best_model = model
-        best_model.fit(x, y)
-
-    info["{} Params".format(model_name)] = best_model.get_params()
+        best_model = random_forest_regression_model
+        best_model.fit(x_train, y_train)
 
-    y_pred = best_model.predict(x_test).reshape(-1, 1)
+    info["参数"] = best_model.get_params()
 
+    y_pred = best_model.predict(x_test)
+    # y_pred = best_model.predict(x_test).reshape(-1, 1)
+    container.set_y_pred(y_pred)
 
-
-    # 0202:
-
-    train_sizes, train_scores, test_scores = learning_curve(best_model, x, y, cv=5, scoring="r2")
+    train_sizes, train_scores, test_scores = learning_curve(best_model, x_train, y_train, cv=5)
 
     train_scores_mean = np.mean(train_scores, axis=1)
     train_scores_std = np.std(train_scores, axis=1)
     test_scores_mean = np.mean(test_scores, axis=1)
     test_scores_std = np.std(test_scores, axis=1)
+    container.set_learning_curve_values(train_sizes, train_scores_mean, train_scores_std, test_scores_mean,
+                                        test_scores_std)
 
-    # 修正
-    train_scores_mean[0] = 0.98
+    info["指标"] = calculate_regression_metrics(y_pred, y_test)
 
-    # draw_learning_curve(train_sizes, train_scores_mean, train_scores_std, test_scores_mean, test_scores_std)
+    container.set_info(info)
+    container.set_status("trained")
+    container.set_model(best_model)
 
-    # draw_scatter_line_graph(x_test, y_pred, y_test, lr_coef, lr_intercept, ["pred", "real"], "logistic regression model residual plot")
+    return container
 
-    info.update(calculate_regression_metrics(y_pred, y_test, model_name))
-    # info.update(calculate_classification_metrics(y_pred, y_test, "logistic regression"))
-    # mae, mse, rsme, r2, ar2 = calculate_regression_metrics(y_pred, y_test, model_name)
 
-    # shap_calculate(best_model, x_test, feature_names)
+class DecisionTreeClassifierParams:
+    @classmethod
+    def get_params(cls):
+        return {
+            "criterion": ["gini", "entropy"],
+            "splitter": ["best", "random"],
+            "max_depth": [None, 5, 10, 15],
+            "min_samples_split": [2, 5, 10],
+            "min_samples_leaf": [1, 2, 4]
+        }
 
-    return y_pred, info, train_sizes, train_scores_mean, train_scores_std, test_scores_mean, test_scores_std
 
-
-# Decision tree classifier
-def decision_tree_classifier(x_train_and_validate, y_train_and_validate, x_test, y_test, train_and_validate_data_list=None, hyper_params_optimize=None):
+# 决策树分类
+def decision_tree_classifier(container: Container):
+    x_train = container.x_train
+    y_train = container.y_train
+    x_test = container.x_test
+    y_test = container.y_test
+    hyper_params_optimize = container.hyper_params_optimize
     info = {}
 
-    decision_tree_classifier_model = DecisionTreeClassifier(random_state=Config.RANDOM_STATE)
-    params = {
-        "criterion": ["gini", "entropy"],
-        "splitter": ["best", "random"],
-        "max_depth": [None, 5, 10, 15],
-        "min_samples_split": [2, 5, 10],
-        "min_samples_leaf": [1, 2, 4]
-    }
+    random_forest_regression_model = DecisionTreeClassifier(random_state=Config.RANDOM_STATE)
+    params = DecisionTreeClassifierParams.get_params()
 
     if hyper_params_optimize == "grid_search":
-        best_model = grid_search(params, decision_tree_classifier_model, x_train_and_validate, y_train_and_validate)
+        best_model = grid_search(params, random_forest_regression_model, x_train, y_train)
     elif hyper_params_optimize == "bayes_search":
-        best_model = bayes_search(params, decision_tree_classifier_model, x_train_and_validate, y_train_and_validate)
+        best_model = bayes_search(params, random_forest_regression_model, x_train, y_train)
     else:
-        best_model = decision_tree_classifier_model
-        for epoch in train_and_validate_data_list:
-            # TODO
-            x_train, x_validate, y_train, y_validate = epoch
+        best_model = random_forest_regression_model
+        best_model.fit(x_train, y_train)
 
-            best_model.fit(x_train, y_train)
+    info["参数"] = best_model.get_params()
 
     y_pred = best_model.predict(x_test)
+    container.set_y_pred(y_pred)
+
+    train_sizes, train_scores, test_scores = learning_curve(best_model, x_train, y_train, cv=5)
 
-    # draw_scatter_line_graph(x_test, y_pred, y_test, lr_coef, lr_intercept, ["pred", "real"], "decision tree classifier model residual plot")
+    train_scores_mean = np.mean(train_scores, axis=1)
+    train_scores_std = np.std(train_scores, axis=1)
+    test_scores_mean = np.mean(test_scores, axis=1)
+    test_scores_std = np.std(test_scores, axis=1)
+    container.set_learning_curve_values(train_sizes, train_scores_mean, train_scores_std, test_scores_mean,
+                                        test_scores_std)
 
-    info.update(calculate_regression_metrics(y_pred, y_test, "decision tree classifier"))
-    info.update(calculate_classification_metrics(y_pred, y_test, "decision tree classifier"))
+    info["指标"] = calculate_classification_metrics(y_pred, y_test)
 
-    return info
+    container.set_info(info)
+    container.set_status("trained")
+    container.set_model(best_model)
 
+    return container
 
-# Random forest classifier
-def random_forest_classifier(x, y, x_train_and_validate, y_train_and_validate, x_test, y_test, train_and_validate_data_list=None, hyper_params_optimize=None):
+
+class RandomForestClassifierParams:
+    @classmethod
+    def get_params(cls):
+        return {
+            "criterion": ["gini", "entropy"],
+            "n_estimators": [50, 100, 150],
+            "max_depth": [None, 5, 10, 15],
+            "min_samples_split": [2, 5, 10],
+            "min_samples_leaf": [1, 2, 4]
+        }
+
+
+# 随机森林分类
+def random_forest_classifier(container: Container):
+    x_train = container.x_train
+    y_train = container.y_train
+    x_test = container.x_test
+    y_test = container.y_test
+    hyper_params_optimize = container.hyper_params_optimize
     info = {}
 
-    random_forest_classifier_model = RandomForestClassifier(random_state=Config.RANDOM_STATE)
-    params = {
-        "criterion": ["gini", "entropy"],
-        "n_estimators": [50, 100, 150],
-        "max_depth": [None, 5, 10, 15],
-        "min_samples_split": [2, 5, 10],
-        "min_samples_leaf": [1, 2, 4],
-        "n_jobs": [-1]
-    }
+    random_forest_classifier_model = RandomForestClassifier(n_estimators=5, random_state=Config.RANDOM_STATE)
+    params = RandomForestClassifierParams.get_params()
 
     if hyper_params_optimize == "grid_search":
-        best_model = grid_search(params, random_forest_classifier_model, x_train_and_validate, y_train_and_validate)
+        best_model = grid_search(params, random_forest_classifier_model, x_train, y_train)
     elif hyper_params_optimize == "bayes_search":
-        best_model = bayes_search(params, random_forest_classifier_model, x_train_and_validate, y_train_and_validate)
+        best_model = bayes_search(params, random_forest_classifier_model, x_train, y_train)
     else:
         best_model = random_forest_classifier_model
-        for epoch in train_and_validate_data_list:
-            # TODO
-            x_train, x_validate, y_train, y_validate = epoch
+        best_model.fit(x_train, y_train)
 
-            best_model.fit(x_train, y_train)
-
-    info["random forest Params"] = best_model.get_params()
+    info["参数"] = best_model.get_params()
 
     y_pred = best_model.predict(x_test)
+    # y_pred = best_model.predict(x_test).reshape(-1, 1)
+    container.set_y_pred(y_pred)
 
-    # 0202:
+    train_sizes, train_scores, test_scores = learning_curve(best_model, x_train, y_train, cv=5)
 
-    train_sizes, train_scores, test_scores = learning_curve(best_model, x, y, cv=5, scoring="accuracy")
+    train_scores_mean = np.mean(train_scores, axis=1)
+    train_scores_std = np.std(train_scores, axis=1)
+    test_scores_mean = np.mean(test_scores, axis=1)
+    test_scores_std = np.std(test_scores, axis=1)
+    container.set_learning_curve_values(train_sizes, train_scores_mean, train_scores_std, test_scores_mean,
+                                        test_scores_std)
+
+    info["指标"] = calculate_classification_metrics(y_pred, y_test)
+
+    container.set_info(info)
+    container.set_status("trained")
+    container.set_model(best_model)
+
+    return container
+
+
+class XgboostClassifierParams:
+    @classmethod
+    def get_params(cls):
+        return {
+            "n_estimators": [50, 100, 150],
+            "learning_rate": [0.01, 0.1, 0.2],
+            "max_depth": [3, 4, 5],
+            "min_child_weight": [1, 2, 3],
+            "gamma": [0, 0.1, 0.2],
+            "subsample": [0.5, 0.8, 0.9, 1.0],
+            "colsample_bytree": [0.8, 0.9, 1.0]
+        }
+
+
+# xgboost分类
+def xgboost_classifier(container: Container):
+    x_train = container.x_train
+    y_train = container.y_train
+    x_test = container.x_test
+    y_test = container.y_test
+    hyper_params_optimize = container.hyper_params_optimize
+    info = {}
+
+    xgboost_classifier_model = XGBClassifier(random_state=Config.RANDOM_STATE)
+    params = XgboostClassifierParams.get_params()
+
+    if hyper_params_optimize == "grid_search":
+        best_model = grid_search(params, xgboost_classifier_model, x_train, y_train)
+    elif hyper_params_optimize == "bayes_search":
+        best_model = bayes_search(params, xgboost_classifier_model, x_train, y_train)
+    else:
+        best_model = xgboost_classifier_model
+        best_model.fit(x_train, y_train)
+
+    info["参数"] = best_model.get_params()
+
+    y_pred = best_model.predict(x_test)
+    # y_pred = best_model.predict(x_test).reshape(-1, 1)
+    container.set_y_pred(y_pred)
+
+    train_sizes, train_scores, test_scores = learning_curve(best_model, x_train, y_train, cv=5)
 
     train_scores_mean = np.mean(train_scores, axis=1)
     train_scores_std = np.std(train_scores, axis=1)
     test_scores_mean = np.mean(test_scores, axis=1)
     test_scores_std = np.std(test_scores, axis=1)
+    container.set_learning_curve_values(train_sizes, train_scores_mean, train_scores_std, test_scores_mean,
+                                        test_scores_std)
 
-    # draw_learning_curve(train_sizes, train_scores_mean, train_scores_std, test_scores_mean, test_scores_std)
+    info["指标"] = calculate_classification_metrics(y_pred, y_test)
 
-    # draw_scatter_line_graph(x_test, y_pred, y_test, lr_coef, lr_intercept, ["pred", "real"], "random forest classifier model residual plot")
+    container.set_info(info)
+    container.set_status("trained")
+    container.set_model(best_model)
 
-    # info.update(calculate_regression_metrics(y_pred, y_test, "random forest classifier"))
-    # info.update(calculate_classification_metrics(y_pred, y_test, "random forest classifier"))
+    return container
 
-    f1_score, fpr, tpr, thresholds = calculate_classification_metrics(y_pred, y_test, "random forest")
 
-    return info, train_sizes, train_scores_mean, train_scores_std, test_scores_mean, test_scores_std, f1_score, fpr, tpr, thresholds
+class LightGBMClassifierParams:
+    @classmethod
+    def get_params(cls):
+        return
 
 
-# xgboost classifier
-def xgboost_classifier(x, y, x_train_and_validate, y_train_and_validate, x_test, y_test, train_and_validate_data_list=None, hyper_params_optimize=None):
+# lightGBM分类
+def lightGBM_classifier(container: Container):
+    x_train = container.x_train
+    y_train = container.y_train
+    x_test = container.x_test
+    y_test = container.y_test
+    hyper_params_optimize = container.hyper_params_optimize
     info = {}
 
-    xgboost_classifier_model = XGBClassifier(random_state=Config.RANDOM_STATE)
-    params = {
-        "n_estimators": [50, 100, 150],
-        "learning_rate": [0.01, 0.1, 0.2],
-        "max_depth": [3, 4, 5],
-        "min_child_weight": [1, 2, 3],
-        "gamma": [0, 0.1, 0.2],
-        "subsample": [0.8, 0.9, 1.0],
-        "colsample_bytree": [0.8, 0.9, 1.0]
-    }
+    lightgbm_classifier_model = lightGBMClassifier
+    params = LightGBMClassifierParams.get_params()
 
     if hyper_params_optimize == "grid_search":
-        best_model = grid_search(params, xgboost_classifier_model, x_train_and_validate, y_train_and_validate)
+        best_model = grid_search(params, lightgbm_classifier_model, x_train, y_train)
     elif hyper_params_optimize == "bayes_search":
-        best_model = bayes_search(params, xgboost_classifier_model, x_train_and_validate, y_train_and_validate)
+        best_model = bayes_search(params, lightgbm_classifier_model, x_train, y_train)
     else:
-        best_model = xgboost_classifier_model
-        for epoch in train_and_validate_data_list:
-            # TODO
-            x_train, x_validate, y_train, y_validate = epoch
+        best_model = lightgbm_classifier_model
+        best_model.train(x_train, y_train)
 
-            best_model.fit(x_train, y_train)
-
-    info["xgboost Params"] = best_model.get_params()
+    info["参数"] = best_model.get_params()
 
     y_pred = best_model.predict(x_test)
+    # y_pred = best_model.predict(x_test).reshape(-1, 1)
+    container.set_y_pred(y_pred)
 
-    # 0202:
-
-    train_sizes, train_scores, test_scores = learning_curve(best_model, x, y, cv=5, scoring="accuracy")
+    train_sizes, train_scores, test_scores = learning_curve(best_model, x_train, y_train, cv=5)
 
     train_scores_mean = np.mean(train_scores, axis=1)
     train_scores_std = np.std(train_scores, axis=1)
     test_scores_mean = np.mean(test_scores, axis=1)
     test_scores_std = np.std(test_scores, axis=1)
+    container.set_learning_curve_values(train_sizes, train_scores_mean, train_scores_std, test_scores_mean,
+                                        test_scores_std)
 
-    # draw_learning_curve(train_sizes, train_scores_mean, train_scores_std, test_scores_mean, test_scores_std)
-
-    # draw_scatter_line_graph(x_test, y_pred, y_test, lr_coef, lr_intercept, ["pred", "real"], "xgboost classifier model residual plot")
-
-    # info.update(calculate_regression_metrics(y_pred, y_test, "xgboost classifier"))
-    # info.update(calculate_classification_metrics(y_pred, y_test, "xgboost classifier"))
-
-    f1_score, fpr, tpr, thresholds = calculate_classification_metrics(y_pred, y_test, "xgboost")
+    info["指标"] = calculate_classification_metrics(y_pred, y_test)
 
-    return info, train_sizes, train_scores_mean, train_scores_std, test_scores_mean, test_scores_std, f1_score, fpr, tpr, thresholds
+    container.set_info(info)
+    container.set_status("trained")
+    container.set_model(best_model)
 
+    return container
 
 
 

app.py

@@ -1,5 +1,7 @@
 import copy
+import math
 import os.path
+import random
 
 import gradio as gr
 import matplotlib.pyplot as plt
@@ -7,71 +9,98 @@ from sklearn import preprocessing
 from sklearn.model_selection import train_test_split
 import pandas as pd
 
-from analysis.shap_model import shap_calculate
+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.paint import *
+from static.new_class 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 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 = 10
+    max_num = 20
 
 
 class FilePath:
@@ -80,23 +109,48 @@ class FilePath:
 
     # [绘图]
     display_dataset = "current_excel_data"
-    learning_curve_train_plot = "learning_curve_train_plot"
-    learning_curve_validation_plot = "learning_curve_validation_plot"
+
+    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_regression"
-    polynomial_regression = "polynomial_regression"
-    logistic_regression = "logistic_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"
 
     # [绘图]
-    learning_curve_train = "learning_curve_train"
-    learning_curve_validation = "learning_curve_validation"
+    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
@@ -119,11 +173,16 @@ class LN:  # LabelName
     standardize_data_button = "标准化 [可选]"
     select_as_y_radio = "选择因变量 [必选]"
     choose_assign_radio = "选择任务类型（同时会根据任务类型将第1列数据强制转换）[必选]"
-    linear_regression_model_radio = "选择线性回归的模型"
     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 轴名称"
@@ -131,15 +190,41 @@ class LN:  # LabelName
     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 = "蜂群特征图"
+    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):
@@ -190,10 +275,11 @@ def get_outputs():
         standardize_data_checkboxgroup,
         standardize_data_button,
         select_as_y_radio,
-        linear_regression_model_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,
@@ -203,12 +289,37 @@ def get_outputs():
         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_train_button,
-        learning_curve_validation_button,
+        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))
@@ -245,11 +356,10 @@ def get_return(is_visible, extra_gr_dict: dict = None):
 
             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()),
+            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),
@@ -257,12 +367,38 @@ def get_return(is_visible, extra_gr_dict: dict = None):
             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_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()),
+            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)))
@@ -295,10 +431,11 @@ def get_return(is_visible, extra_gr_dict: dict = None):
         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),
+        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),
 
@@ -308,12 +445,37 @@ def get_return(is_visible, extra_gr_dict: dict = None):
         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_train_button: gr.Button(visible=False),
-        learning_curve_validation_button: gr.Button(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)))
@@ -336,17 +498,49 @@ class Dataset:
     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", "自定义"]
+        return ["自定义", "Iris Dataset", "Wine Dataset", "Breast Cancer Dataset", "Diabetes Dataset", "California Housing Dataset"]
 
     @classmethod
     def get_col_list(cls):
@@ -545,8 +739,7 @@ class Dataset:
 
         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])):
+                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":
@@ -576,12 +769,20 @@ class Dataset:
     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 train_model(cls, optimize, linear_regression_model_type=None):
+    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
@@ -596,12 +797,37 @@ class Dataset:
         )
         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])
+            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
 
@@ -621,9 +847,11 @@ class Dataset:
     def get_model_name(cls):
         return [x for x in cls.container_dict.keys()]
 
+    # [模型]
     @classmethod
     def get_model_chinese_name(cls):
-        return ["线性回归", "多项式回归", "逻辑斯谛分类"]
+        return ["线性回归", "多项式回归", "逻辑斯谛分类", "决策树分类", "随机森林分类", "随机森林回归", "XGBoost分类", "LightGBM分类",
+                "梯度提升回归", "支持向量机分类", "支持向量机回归", "K-最近邻分类", "K-最近邻回归", "朴素贝叶斯分类"]
 
     @classmethod
     def get_model_name_mapping(cls):
@@ -646,46 +874,237 @@ class Dataset:
     @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)
+        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_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 = {}
+    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
 
-        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()
+        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)
 
-        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
+        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_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)
+        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_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 = {}
+    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]
-            learning_curve_dict[model_name] = cls.container_dict[model_name].get_learning_curve_values()
+            cur_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
+        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
@@ -697,10 +1116,15 @@ class Dataset:
         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)
+        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, model_name, color_list: list, label_list: list, name: str, x_label: str, y_label: str, is_default: bool):
+    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]
 
@@ -717,17 +1141,65 @@ class Dataset:
         # 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)
+        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_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)
+        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):
@@ -757,6 +1229,10 @@ class Dataset:
     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 ["分类", "回归"]
@@ -803,6 +1279,99 @@ class Dataset:
 
         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)
@@ -817,29 +1386,94 @@ def select_as_model(model_name: str):
 
 
 # [绘图]
+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_validation_first_draw_plot(*inputs):
-    Dataset.visualize = MN.learning_curve_validation
+def learning_curve_first_draw_plot(*inputs):
+    Dataset.visualize = MN.learning_curve
     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 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 = inputs[0]
+    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)
@@ -857,16 +1491,37 @@ def non_first_draw_plot(inputs):
     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_train:
-        select_model = inputs[start_index]
-    elif Dataset.visualize == MN.learning_curve_validation:
-        select_model = inputs[start_index]
+    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 = inputs[start_index+1]
+        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 = inputs[start_index: start_index+1]
+        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)
 
@@ -877,15 +1532,34 @@ 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)})
+    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))))
@@ -897,8 +1571,15 @@ def first_draw_plot_with_non_first_draw_plot(cur_plt, paint_object):
     return get_return_extra(True, extra_gr_dict)
 
 
-def train_model(optimize, linear_regression_model_type):
-    Dataset.train_model(optimize, linear_regression_model_type)
+# [模型]
+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)
 
@@ -924,9 +1605,7 @@ def change_data_type_to_float():
 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)})
+    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():
@@ -981,7 +1660,7 @@ def choose_custom_dataset(file: str):
     return get_return(True, {choose_custom_dataset_file: gr.File(Dataset.file, visible=True)})
 
 
-with gr.Blocks() as demo:
+with gr.Blocks(js=Config.JS_0) as demo:
     '''
         组件
     '''
@@ -1031,24 +1710,67 @@ with gr.Blocks() as demo:
 
         # 数据模型
         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)
-                with gr.Row():
-                    learning_curve_train_button = gr.Button(visible=False)
-                    learning_curve_validation_button = gr.Button(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("蜂群特征图"):
+            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():
@@ -1077,6 +1799,9 @@ with gr.Blocks() as demo:
             draw_plot = gr.Plot(visible=False)
             draw_file = gr.File(visible=False)
 
+    with gr.Tab("文字说明"):
+        notes = gr.Markdown(Dataset.get_notes(), visible=True)
+
     '''
         监听事件
     '''
@@ -1108,26 +1833,53 @@ with gr.Blocks() as demo:
 
     # 数据模型
     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())
+
+    # [模型]
+    model_train_button.click(fn=train_model, inputs=[model_optimize_radio, linear_regression_model_radio, naive_bayes_classification_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())
+    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], outputs=get_outputs())
+                                                               + [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], outputs=get_outputs())
+                                                            + [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], outputs=get_outputs())
+                                                            + [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], outputs=get_outputs())
+                                                                + [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], outputs=get_outputs())
+                                                                  + [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], outputs=get_outputs())
+                                                                          + [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()

data/notes.md

@@ -0,0 +1,12 @@
+# EasyMachineLearning
+### 介绍
+- 版本：v1.0
+- 作者：李凌浩
+- 有任何新功能的想法和已出现的问题请和作者联系 ~
+- *( WX: llh13857750421 )*
+### 尚未实现的功能
+1. [困难] 模型训练的进度条可视化（sklearn模型训练函数无回调函数） 
+2. 模型训练完毕后保存模型文件，后续可直接加载
+3. 数据分析AI助手（直接处理Excel数据）
+4. PCA主成分分析
+5. 聚类

metrics/calculate_classification_metrics.py

@@ -5,20 +5,27 @@ from sklearn.preprocessing import label_binarize
 from visualization.draw_line_graph import draw_line_graph
 
 
-def calculate_classification_metrics(pred_data, real_data, model_name):
+class ClassificationMetrics:
+    @classmethod
+    def get_metrics(cls):
+        return ["Accuracy", "Precision", "Recall", "F1-score"]
+
+
+def calculate_classification_metrics(pred_data, real_data):
     info = {}
 
     real_data = np.round(real_data, 0).astype(int)
     pred_data = np.round(pred_data, 0).astype(int)
 
     cur_confusion_matrix = confusion_matrix(real_data[:, 0], pred_data)
-    info["Confusion matrix of "+model_name] = cur_confusion_matrix
+    info["Confusion matrix"] = cur_confusion_matrix
 
-    info["Accuracy of "+model_name] = np.sum(cur_confusion_matrix.diagonal()) / np.sum(cur_confusion_matrix)
-    info["Precision of "+model_name] = cur_confusion_matrix.diagonal() / np.sum(cur_confusion_matrix, axis=1)
-    info["Recall of "+model_name] = cur_confusion_matrix.diagonal() / np.sum(cur_confusion_matrix, axis=0)
-    info["F1-score of "+model_name] = np.mean(2 * np.multiply(info["Precision of "+model_name], info["Recall of "+model_name]) / \
-                                      (info["Precision of "+model_name] + info["Recall of "+model_name]))
+    info["Accuracy"] = np.sum(cur_confusion_matrix.diagonal()) / np.sum(cur_confusion_matrix)
+    info["Precision"] = cur_confusion_matrix.diagonal() / np.sum(cur_confusion_matrix, axis=1)
+    info["Recall"] = cur_confusion_matrix.diagonal() / np.sum(cur_confusion_matrix, axis=0)
+    info["F1-score"] = np.mean(2 * np.multiply(info["Precision"], info["Recall"]) / (info["Precision"] + info["Recall"]))
+
+    return info
 
     max_class = max(real_data)[0]
     min_class = min(real_data)[0]
@@ -29,7 +36,3 @@ def calculate_classification_metrics(pred_data, real_data, model_name):
         fpr, tpr, thresholds = roc_curve(real_data_[:, i], pred_data_[:, i])
         # draw_line_graph(fpr, tpr, "ROC curve with AUC={:.2f}".format(auc(fpr, tpr)))
 
-    info["AUC of "+model_name] = roc_auc_score(real_data_, pred_data_)
-
-    return info
-

metrics/calculate_regression_metrics.py

@@ -2,44 +2,28 @@ import numpy as np
 from sklearn.metrics import *
 
 
-def calculate_ar2(real_data, pred_data):
-    model_name = "a"
-    info = {}
-
-    info["MAE of "+model_name] = mean_absolute_error(real_data, pred_data)
-    # mae = mean_absolute_error(real_data, pred_data)
-    info["MSE of "+model_name] = mean_squared_error(real_data, pred_data)
-    # mse = mean_squared_error(real_data, pred_data)
-    info["RSME of "+model_name] = np.sqrt(info["MSE of "+model_name])
-    # rsme = np.sqrt(info["MSE of "+model_name])
-    info["R-Sqaure of "+model_name] = r2_score(real_data, pred_data)
-    # r2 = r2_score(real_data, pred_data)
-    if isinstance(max(real_data), np.ndarray):
-        info["Adjusted R-Square of " + model_name] = 1 - (1 - info["R-Sqaure of "+model_name]) * (len(pred_data)-1) / (len(pred_data)-max(real_data)[0]-1)
-        # ar2 = 1 - (1 - info["R-Sqaure of "+model_name]) * (len(pred_data)-1) / (len(pred_data)-max(real_data)[0]-1)
-    else:
-        info["Adjusted R-Square of " + model_name] = 1 - (1 - info["R-Sqaure of " + model_name]) * (len(pred_data) - 1) / (len(pred_data) - max(real_data) - 1)
-        # ar2 = 1 - (1 - info["R-Sqaure of " + model_name]) * (len(pred_data) - 1) / (len(pred_data) - max(real_data) - 1)
-
-    return info["Adjusted R-Square of " + model_name]
+class RegressionMetrics:
+    @classmethod
+    def get_metrics(cls):
+        return ["MAE", "MSE", "RSME", "R-Sqaure", "Adjusted R-Square"]
 
 
-def calculate_regression_metrics(pred_data, real_data, model_name):
+def calculate_regression_metrics(pred_data, real_data):
     info = {}
 
-    info["MAE of "+model_name] = mean_absolute_error(real_data, pred_data)
+    info["MAE"] = mean_absolute_error(real_data, pred_data)
     # mae = mean_absolute_error(real_data, pred_data)
-    info["MSE of "+model_name] = mean_squared_error(real_data, pred_data)
+    info["MSE"] = mean_squared_error(real_data, pred_data)
     # mse = mean_squared_error(real_data, pred_data)
-    info["RSME of "+model_name] = np.sqrt(info["MSE of "+model_name])
+    info["RSME"] = np.sqrt(info["MSE"])
     # rsme = np.sqrt(info["MSE of "+model_name])
-    info["R-Sqaure of "+model_name] = r2_score(real_data, pred_data)
+    info["R-Sqaure"] = r2_score(real_data, pred_data)
     # r2 = r2_score(real_data, pred_data)
     if isinstance(max(real_data), np.ndarray):
-        info["Adjusted R-Square of " + model_name] = 1 - (1 - info["R-Sqaure of "+model_name]) * (len(pred_data)-1) / (len(pred_data)-max(real_data)[0]-1)
+        info["Adjusted R-Square"] = 1 - (1 - info["R-Sqaure"]) * (len(pred_data)-1) / (len(pred_data)-max(real_data)[0]-1)
         # ar2 = 1 - (1 - info["R-Sqaure of "+model_name]) * (len(pred_data)-1) / (len(pred_data)-max(real_data)[0]-1)
     else:
-        info["Adjusted R-Square of " + model_name] = 1 - (1 - info["R-Sqaure of " + model_name]) * (len(pred_data) - 1) / (len(pred_data) - max(real_data) - 1)
+        info["Adjusted R-Square"] = 1 - (1 - info["R-Sqaure"]) * (len(pred_data) - 1) / (len(pred_data) - max(real_data) - 1)
         # ar2 = 1 - (1 - info["R-Sqaure of " + model_name]) * (len(pred_data) - 1) / (len(pred_data) - max(real_data) - 1)
 
     return info

requirements.txt

@@ -1,13 +1,15 @@
 numpy~=1.23.5
 pandas~=1.5.3
-scikit-learn~=1.2.1
+scikit-learn~=1.4.1.post1
 hmmlearn~=0.3.0
 matplotlib~=3.7.0
 scikit-fuzzy~=0.4.2
 gradio~=4.17.0
+shap~=0.44.1
 networkx~=2.8.4
 scipy~=1.10.0
+lightgbm~=4.3.0
 xgboost~=2.0.3
+torch~=2.2.0+cu118
 tqdm~=4.64.1
-shap~=0.44.1
-scikit-optimize~=0.9.0
+scikit-optimize~=0.9.0

static/config.py

@@ -1,8 +1,31 @@
 class Config:
     # 随机种子
     RANDOM_STATE = 123
+
+    # 预测图展示的点个数
+    DISPLAY_RANGE = 100
+
     # 绘图颜色组
+    COLOR_ITER_NUM = 3
+
     COLORS = [
+        "#ca5353",
+        "#c874a5",
+        "#b674c8",
+        "#8274c8",
+        "#748dc8",
+        "#74acc8",
+        "#74c8b7",
+        "#74c88d",
+        "#a6c874",
+        "#e0e27e",
+        "#df9b77",
+        "#404040",
+        "#999999",
+        "#d4d4d4"
+    ] * COLOR_ITER_NUM
+
+    COLORS_0 = [
         "#8074C8",
         "#7895C1",
         "#A8CBDF",
@@ -11,44 +34,103 @@ class Config:
         "#E3625D",
         "#EF8B67",
         "#F0C284"
-    ]
+    ] * COLOR_ITER_NUM
 
+    COLORS_1 = [
+        "#4A5F7E",
+        "#719AAC",
+        "#72B063",
+        "#94C6CD",
+        "#B8DBB3",
+        "#E29135"
+    ] * COLOR_ITER_NUM
 
+    COLORS_2 = [
+        "#4485C7",
+        "#D4562E",
+        "#DBB428",
+        "#682487",
+        "#84BA42",
+        "#7ABBDB",
+        "#A51C36"
+    ] * COLOR_ITER_NUM
 
-    COLORS_1 = [
+    COLORS_3 = [
+        "#8074C8",
+        "#7895C1",
+        "#A8CBDF",
+        "#F5EBAE",
+        "#F0C284",
+        "#EF8B67",
+        "#E3625D",
+        "#B54764"
+    ] * COLOR_ITER_NUM
+
+    COLORS_4 = [
+        "#979998",
+        "#C69287",
+        "#E79A90",
+        "#EFBC91",
+        "#E4CD87",
+        "#FAE5BB",
+        "#DDDDDF"
+    ] * COLOR_ITER_NUM
+
+    COLORS_5 = [
         "#91CCC0",
         "#7FABD1",
         "#F7AC53",
         "#EC6E66",
         "#B5CE4E",
         "#BD7795",
-        "#B55384",
-        "#474769",
-        "#257D88",
-        "#ED8D5A",
-        "#BFDFD2",
-        "#EFCE87"
-    ]
+        "#7C7979"
+    ] * COLOR_ITER_NUM
+
+    COLORS_6 = [
+        "#E9687A",
+        "#F58F7A",
+        "#FDE2D8",
+        "#CFCFD0",
+        "#B6B3D6"
+    ] * COLOR_ITER_NUM
+
+    JS_0 = """
+function createGradioAnimation() {
+    var container = document.createElement('div');
+    container.id = 'gradio-animation';
+    container.style.fontSize = '2em';
+    container.style.fontWeight = 'bold';
+    container.style.textAlign = 'center';
+    container.style.marginBottom = '20px';
+
+    var text = 'Welcome to EasyMachineLearning!';
+    for (var i = 0; i < text.length; i++) {
+        (function(i){
+            setTimeout(function(){
+                var letter = document.createElement('span');
+                letter.style.opacity = '0';
+                letter.style.transition = 'opacity 0.5s';
+                letter.innerText = text[i];
+
+                container.appendChild(letter);
+
+                setTimeout(function() {
+                    letter.style.opacity = '1';
+                }, 50);
+            }, i * 250);
+        })(i);
+    }
+
+    var gradioContainer = document.querySelector('.gradio-container');
+    gradioContainer.insertBefore(container, gradioContainer.firstChild);
+
+    return 'Animation created';
+}
+"""
+
+
 
-    COLORS_2 = [
-        "#A21A54",
-        "#E7724F",
-        "#32183C"
-    ]
 
-    COLORS_3 = [
-        "#ABD1BC",
-        "#CCCC99",
-        "#E3BBED"
-    ]
 
 
-    COLORS_4 = [
-        "#CFCFD0",
-        "#B6B3D6",
-        "#F58F7A",
-        "#E9687A",
-    ]
 
-    # 预测图展示的点个数
-    DISPLAY_RANGE = 100

static/new_class.py

@@ -0,0 +1,195 @@
+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 = {"参数": {}, "指标": {}}
+        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 get_info(self):
+        return self.info
+
+    def set_info(self, info: dict):
+        self.info = info
+
+    def set_y_pred(self, y_pred):
+        self.y_pred = y_pred
+
+    def get_data_fit_values(self):
+        return [
+            self.y_pred,
+            self.y_test
+        ]
+
+    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 PaintObject:
+    def __init__(self):
+        self.color_cur_num = 0
+        self.color_cur_list = []
+        self.label_cur_num = 0
+        self.label_cur_list = []
+        self.x_cur_label = ""
+        self.y_cur_label = ""
+        self.name = ""
+
+    def get_color_cur_num(self):
+        return self.color_cur_num
+
+    def set_color_cur_num(self, color_cur_num):
+        self.color_cur_num = color_cur_num
+
+    def get_color_cur_list(self):
+        return self.color_cur_list
+
+    def set_color_cur_list(self, color_cur_list):
+        self.color_cur_list = color_cur_list
+
+    def get_label_cur_num(self):
+        return self.label_cur_num
+
+    def set_label_cur_num(self, label_cur_num):
+        self.label_cur_num = label_cur_num
+
+    def get_label_cur_list(self):
+        return self.label_cur_list
+
+    def set_label_cur_list(self, label_cur_list):
+        self.label_cur_list = label_cur_list
+
+    def get_x_cur_label(self):
+        return self.x_cur_label
+
+    def set_x_cur_label(self, x_cur_label):
+        self.x_cur_label = x_cur_label
+
+    def get_y_cur_label(self):
+        return self.y_cur_label
+
+    def set_y_cur_label(self, y_cur_label):
+        self.y_cur_label = y_cur_label
+
+    def get_name(self):
+        return self.name
+
+    def set_name(self, name):
+        self.name = name
+
+
+class SelectModel:
+    def __init__(self):
+        self.models = None
+        self.waterfall_number = None
+        self.force_number = None
+        self.beeswarm_plot_type = None
+        self.dependence_col = None
+        self.data_distribution_col = None
+        self.data_distribution_is_rotate = None
+        self.descriptive_indicators_col = None
+        self.descriptive_indicators_is_rotate = None
+        self.heatmap_col = None
+        self.heatmap_is_rotate = None
+
+    def get_heatmap_col(self):
+        return self.heatmap_col
+
+    def set_heatmap_col(self, heatmap_col):
+        self.heatmap_col = heatmap_col
+
+    def get_heatmap_is_rotate(self):
+        return self.heatmap_is_rotate
+
+    def set_heatmap_is_rotate(self, heatmap_is_rotate):
+        self.heatmap_is_rotate = heatmap_is_rotate
+
+    def get_models(self):
+        return self.models
+
+    def set_models(self, models):
+        self.models = models
+
+    def get_waterfall_number(self):
+        return self.waterfall_number
+
+    def set_waterfall_number(self, waterfall_number):
+        self.waterfall_number = waterfall_number
+
+    def get_force_number(self):
+        return self.force_number
+
+    def set_force_number(self, force_number):
+        self.force_number = force_number
+
+    def get_beeswarm_plot_type(self):
+        return self.beeswarm_plot_type
+
+    def set_beeswarm_plot_type(self, beeswarm_plot_type):
+        self.beeswarm_plot_type = beeswarm_plot_type
+
+    def get_dependence_col(self):
+        return self.dependence_col
+
+    def set_dependence_col(self, dependence_col):
+        self.dependence_col = dependence_col
+
+    def get_data_distribution_col(self):
+        return self.data_distribution_col
+
+    def set_data_distribution_col(self, data_distribution_col):
+        self.data_distribution_col = data_distribution_col
+
+    def get_data_distribution_is_rotate(self):
+        return self.data_distribution_is_rotate
+
+    def set_data_distribution_is_rotate(self, data_distribution_is_rotate):
+        self.data_distribution_is_rotate = data_distribution_is_rotate
+
+    def get_descriptive_indicators_is_rotate(self):
+        return self.descriptive_indicators_is_rotate
+
+    def set_descriptive_indicators_is_rotate(self, descriptive_indicators_is_rotate):
+        self.descriptive_indicators_is_rotate = descriptive_indicators_is_rotate
+
+    def get_descriptive_indicators_col(self):
+        return self.descriptive_indicators_col
+
+    def set_descriptive_indicators_col(self, descriptive_indicators_col):
+        self.descriptive_indicators_col = descriptive_indicators_col
+
+

static/process.py

@@ -7,10 +7,10 @@ from skopt import BayesSearchCV
 import copy
 import pandas as pd
 from scipy.stats import spearmanr
+from io import StringIO
+from contextlib import redirect_stdout
 
-from sklearn.datasets import load_iris
-from sklearn.datasets import load_wine
-from sklearn.datasets import load_breast_cancer
+from sklearn.datasets import load_iris, load_wine, load_breast_cancer, load_diabetes
 from scipy.linalg import eig
 
 from static.config import Config
@@ -175,20 +175,36 @@ def choose_y_col_in_dataframe(df: pd.DataFrame, y_col: str):
 
 
 def load_data(sort):
+    type = ""
     if sort == "Iris Dataset":
         sk_data = load_iris()
+        type = "classification"
     elif sort == "Wine Dataset":
         sk_data = load_wine()
+        type = "classification"
     elif sort == "Breast Cancer Dataset":
         sk_data = load_breast_cancer()
+        type = "classification"
+    elif sort == "Diabetes Dataset":
+        sk_data = load_diabetes()
+        type = "regression"
+    elif sort == "California Housing Dataset":
+        df = pd.read_csv("./data/fetch_california_housing.csv")
+        return df
+    else:
+        sk_data = load_iris()
+        type = "classification"
 
-    target_data = sk_data.target.astype(str)
-    for i in range(len(sk_data.target_names)):
-        target_data = np.where(target_data == str(i), sk_data.target_names[i], target_data)
+    if type == "classification":
+        target_data = sk_data.target.astype(str)
+        for i in range(len(sk_data.target_names)):
+            target_data = np.where(target_data == str(i), sk_data.target_names[i], target_data)
+    else:
+        target_data = sk_data.target
 
-    sk_feature_names = sk_data.feature_names
+    feature_names = sk_data.feature_names
+    sk_feature_names = ["target"] + feature_names.tolist() if isinstance(feature_names, np.ndarray) else ["target"] + feature_names
     sk_data = np.concatenate((target_data.reshape(-1, 1), sk_data.data), axis=1)
-    sk_feature_names = np.insert(sk_feature_names, 0, "species")
 
     df = pd.DataFrame(data=sk_data, columns=sk_feature_names)
 
@@ -283,10 +299,7 @@ def k_fold_cross_validation_data_segmentation(x_train, y_train):
 def grid_search(params, model, x_train, y_train, scoring=None):
     info = {}
 
-    if scoring == "neg_mean_squared_error":
-        grid_search_model = GridSearchCV(model, params, cv=5, scoring="neg_mean_squared_error")
-    else:
-        grid_search_model = GridSearchCV(model, params, cv=5)
+    grid_search_model = GridSearchCV(model, params, cv=3, n_jobs=-1)
 
     grid_search_model.fit(x_train, y_train.ravel())
 
@@ -300,10 +313,7 @@ def grid_search(params, model, x_train, y_train, scoring=None):
 def bayes_search(params, model, x_train, y_train, scoring=None):
     info = {}
 
-    if scoring == "neg_mean_squared_error":
-        bayes_search_model = BayesSearchCV(model, params, cv=5, n_iter=50, scoring="neg_mean_squared_error")
-    else:
-        bayes_search_model = BayesSearchCV(model, params, cv=5, n_iter=50)
+    bayes_search_model = BayesSearchCV(model, params, cv=3, n_iter=50, n_jobs=-1)
 
     bayes_search_model.fit(x_train, y_train)
 

visualization/draw_boxplot.py

@@ -1,26 +1,33 @@
 import matplotlib.pyplot as plt
+import numpy as np
 
-from coding.llh.static.config import Config
+from static.config import Config
 
 
-# draw boxplot
-def draw_boxplot(x_data, title):
-    plt.figure(figsize=(10, 14))
+def draw_boxplot(x_data, paint_object, will_rotate=False):
+    plt.figure(figsize=(10, 8), dpi=300)
+
     plt.grid(True)
 
     plt.boxplot(
         x_data,
         meanline=True,
         showmeans=True,
-        medianprops={"color": Config.COLORS[0], "linewidth": 1.5},
-        meanprops={"color": Config.COLORS[1], "ls": "--", "linewidth": 1.5},
-        flierprops={"marker": "o", "markerfacecolor": Config.COLORS[2]},
+        medianprops={"color": paint_object.get_color_cur_list()[0], "linewidth": 1.5},
+        meanprops={"color": paint_object.get_color_cur_list()[1], "ls": "--", "linewidth": 1.5},
+        flierprops={"marker": "o", "markerfacecolor": paint_object.get_color_cur_list()[2]},
         labels=x_data.columns.values
     )
 
-    plt.xticks(rotation=-45)
-    plt.title(title)
+    if will_rotate:
+        plt.xticks(rotation=-45)
+
+    plt.title(paint_object.get_name())
+
+    plt.xlabel(paint_object.get_x_cur_label())
+    plt.ylabel(paint_object.get_y_cur_label())
+
+    paint_object.set_color_cur_num(3)
 
-    plt.savefig("./diagram/{}.png".format(title), dpi=300)
+    return plt, paint_object
 
-    plt.show()

visualization/draw_data_fit_total.py

@@ -0,0 +1,48 @@
+import numpy as np
+from matplotlib import pyplot as plt
+
+from static.new_class import PaintObject
+from static.config import Config
+
+
+def draw_data_fit_total(input_dict, paint_object: PaintObject):
+    plt.figure(figsize=(10, 6), dpi=300)
+
+    for i, input_dict_items in enumerate(input_dict.items()):
+        name, cur_list = input_dict_items
+
+        if i == len(input_dict.keys())-1:
+            final_list = cur_list
+
+        plt.plot(
+            np.array([x for x in range(len(cur_list[0]))]),
+            cur_list[0],
+            "-",
+            color=paint_object.get_color_cur_list()[i],
+            alpha=0.9,
+            label=paint_object.get_label_cur_list()[i]
+        )
+
+    plt.plot(
+        np.array([x for x in range(len(final_list[1]))]),
+        final_list[1],
+        "--",
+        color=paint_object.get_color_cur_list()[len(input_dict.keys())],
+        alpha=0.9,
+        label=paint_object.get_label_cur_list()[len(input_dict.keys())]
+    )
+
+    plt.title(paint_object.get_name())
+
+    plt.xlabel(paint_object.get_x_cur_label())
+    plt.ylabel(paint_object.get_y_cur_label())
+    plt.legend()
+
+    # plt.savefig("./diagram/{}.png".format(title), dpi=300)
+    # plt.show()
+
+    paint_object.set_color_cur_num(len(input_dict.values())+1)
+    paint_object.set_label_cur_num(len(input_dict.values())+1)
+
+    return plt, paint_object
+

visualization/draw_heat_map.py

@@ -2,16 +2,13 @@ import numpy as np
 import matplotlib.pyplot as plt
 import pandas as pd
 
-from coding.llh.static.config import Config
+from static.config import Config
 
 
-# Draw heat map
-def draw_heat_map(x_data, title, is_rotate, col_name):
-    # col_name = np.delete(col_name, np.where(col_name == "swing"))
-
+def draw_heat_map(x_data, col_list, paint_object, will_rotate=False):
     plt.rcParams.update({'figure.autolayout': True})
 
-    plt.figure(figsize=(16, 16))
+    plt.figure(figsize=(10, 8), dpi=300)
 
     if isinstance(x_data, np.ndarray):
         np_data = np.around(x_data.astype("float64"), 2)
@@ -24,17 +21,22 @@ def draw_heat_map(x_data, title, is_rotate, col_name):
         for j in range(np_data.shape[1]):
             plt.text(j, i, np_data[i, j], ha="center", va="center", color="w")
 
-    if is_rotate:
-        plt.xticks(np.arange(len(pd_data.columns.values)), col_name, rotation=-90)
+    if will_rotate:
+        plt.xticks(np.arange(len(col_list)), col_list, rotation=-90)
     else:
-        plt.xticks(np.arange(len(pd_data.columns.values)), col_name)
+        plt.xticks(np.arange(len(col_list)), col_list)
 
-    plt.yticks(np.arange(len(pd_data.index.values)), col_name)
+    plt.yticks(np.arange(len(col_list)), col_list)
     plt.imshow(np_data)
-    # plt.colorbar(False)
+    plt.colorbar(True)
     plt.tight_layout()
-    # plt.title(title)
 
-    plt.savefig("./diagram/{}.png".format(title), dpi=300)
+    plt.title(paint_object.get_name())
+
+    plt.xlabel(paint_object.get_x_cur_label())
+    plt.ylabel(paint_object.get_y_cur_label())
+
+    paint_object.set_color_cur_num(0)
+
+    return plt, paint_object
 
-    plt.show()

visualization/draw_histogram.py

@@ -1,26 +1,27 @@
+import random
+
 import numpy as np
 import matplotlib.pyplot as plt
 
-from coding.llh.static.config import Config
+from static.config import Config
+from static.new_class import PaintObject
 
 
-# Plot bar charts
-def draw_histogram(x_data, y_data, will_rotate, will_show_text, title):
-    fig, ax = plt.subplots(figsize=(10, 8))
+def draw_histogram(nums, labels, paint_object, will_rotate=False, will_show_text=True):
+    plt.figure(figsize=(10, 8), dpi=300)
 
     bars = plt.bar(
-        np.arange(0, len(x_data)),
-        x_data,
+        np.arange(0, len(nums)),
+        nums,
         align="center",
         alpha=1,
-        color=Config.COLORS,
-        tick_label=y_data
+        color=paint_object.get_color_cur_list()[0],
+        tick_label=labels
     )
 
-    # Bar annotation
     if will_show_text:
         for bar in bars:
-            ax.annotate(
+            plt.annotate(
                 str(bar.get_height()),
                 xy=(bar.get_x() + bar.get_width() / 2,
                     bar.get_height()),
@@ -31,10 +32,14 @@ def draw_histogram(x_data, y_data, will_rotate, will_show_text, title):
             )
 
     if will_rotate:
-        plt.xticks(rotation=-90)
+        plt.xticks(rotation=-45)
+
+    plt.title(paint_object.get_name())
+
+    plt.xlabel(paint_object.get_x_cur_label())
+    plt.ylabel(paint_object.get_y_cur_label())
 
-    plt.title(title)
+    paint_object.set_color_cur_num(1)
 
-    plt.savefig("./diagram/{}.png".format(title), dpi=300)
+    return plt, paint_object
 
-    plt.show()

visualization/draw_histogram_line_subgraph.py

@@ -1,7 +1,7 @@
 import numpy as np
 from matplotlib import pyplot as plt
 
-from coding.llh.static.config import Config
+from static.config import Config
 
 
 def draw_histogram_line_subgraph(total_data_for_plot):

visualization/draw_learning_curve_total.py

@@ -1,59 +1,48 @@
-import numpy as np
 from matplotlib import pyplot as plt
 
-from static.paint import PaintObject
-from static.config import Config
-
-
-def draw_learning_curve_total(input_dict, type, paint_object: PaintObject):
-    plt.figure(figsize=(10, 6), dpi=300)
-
-    if type == "train":
-        for i, values in enumerate(input_dict.values()):
-            train_sizes = values[0]
-            train_scores_mean = values[1]
-            train_scores_std = values[2]
-            test_scores_mean = values[3]
-            test_scores_std = values[4]
-
-            plt.fill_between(
-                train_sizes,
-                train_scores_mean - train_scores_std,
-                train_scores_mean + train_scores_std,
-                alpha=0.1,
-                color=paint_object.get_color_cur_list()[i]
-            )
-
-            plt.plot(
-                train_sizes,
-                train_scores_mean,
-                "o-",
-                color=paint_object.get_color_cur_list()[i],
-                label=paint_object.get_label_cur_list()[i]
-            )
-
-    else:
-        for i, values in enumerate(input_dict.values()):
-            train_sizes = values[0]
-            train_scores_mean = values[1]
-            train_scores_std = values[2]
-            test_scores_mean = values[3]
-            test_scores_std = values[4]
-
-            plt.fill_between(
-                train_sizes,
-                test_scores_mean - test_scores_std,
-                test_scores_mean + test_scores_std,
-                alpha=0.1,
-                color=paint_object.get_color_cur_list()[i]
-            )
-            plt.plot(
-                train_sizes,
-                test_scores_mean,
-                "o-",
-                color=paint_object.get_color_cur_list()[i],
-                label=paint_object.get_label_cur_list()[i]
-            )
+from static.new_class import PaintObject
+
+
+def draw_learning_curve_total(input_dict, paint_object: PaintObject):
+    plt.figure(figsize=(10, 8), dpi=300)
+
+    for i, values in enumerate(input_dict.values()):
+        train_sizes = values[0]
+        train_scores_mean = values[1]
+        train_scores_std = values[2]
+        test_scores_mean = values[3]
+        test_scores_std = values[4]
+
+        plt.fill_between(
+            train_sizes,
+            train_scores_mean - train_scores_std,
+            train_scores_mean + train_scores_std,
+            alpha=0.1,
+            color=paint_object.get_color_cur_list()[2*i]
+        )
+
+        plt.plot(
+            train_sizes,
+            train_scores_mean,
+            "o-",
+            color=paint_object.get_color_cur_list()[2*i],
+            label=paint_object.get_label_cur_list()[2*i]
+        )
+
+        plt.fill_between(
+            train_sizes,
+            test_scores_mean - test_scores_std,
+            test_scores_mean + test_scores_std,
+            alpha=0.1,
+            color=paint_object.get_color_cur_list()[2*i+1]
+        )
+        plt.plot(
+            train_sizes,
+            test_scores_mean,
+            "o-",
+            color=paint_object.get_color_cur_list()[2*i+1],
+            label=paint_object.get_label_cur_list()[2*i+1]
+        )
 
     plt.title(paint_object.get_name())
 
@@ -61,11 +50,8 @@ def draw_learning_curve_total(input_dict, type, paint_object: PaintObject):
     plt.ylabel(paint_object.get_y_cur_label())
     plt.legend()
 
-    # plt.savefig("./diagram/{}.png".format(title), dpi=300)
-    # plt.show()
-
-    paint_object.set_color_cur_num(len(input_dict.keys()))
-    paint_object.set_label_cur_num(len(input_dict.keys()))
+    paint_object.set_color_cur_num(2*len(input_dict.values()))
+    paint_object.set_label_cur_num(2*len(input_dict.values()))
 
     return plt, paint_object
 

visualization/draw_line_graph.py

@@ -4,37 +4,24 @@ import matplotlib.pyplot as plt
 from static.config import Config
 
 
-# draw line graph
-def draw_line_graph(x_data, y_data: list, title):
-    plt.figure(figsize=(10, 8))
+def draw_line_graph(nums, labels, paint_object):
+    plt.figure(figsize=(10, 8), dpi=300)
 
     plt.plot(
-        x_data,
-        y_data,
+        nums,
+        labels,
         "-o",
-        color=Config.COLORS[0]
+        color=paint_object.get_color_cur_list()[0]
     )
 
-    plt.title(title)
-    plt.savefig("./diagram/{}.png".format(title), dpi=300)
+    plt.title(paint_object.get_name())
 
-    plt.show()
+    plt.xlabel(paint_object.get_x_cur_label())
+    plt.ylabel(paint_object.get_y_cur_label())
 
+    paint_object.set_color_cur_num(1)
 
-def draw_line_graph_1(x_data, y_data: list, title, labels: list):
-    plt.figure(figsize=(10, 8))
+    return plt, paint_object
 
-    for i, single_y_data in enumerate(y_data):
-        plt.plot(
-            x_data,
-            single_y_data,
-            "-o",
-            color=Config.COLORS[i],
-            label=labels[i]
-        )
 
-    plt.legend()
-    plt.title(title)
-    plt.savefig("./diagram/{}.png".format(title), dpi=300)
 
-    plt.show()

visualization/draw_pred_total.py

@@ -7,30 +7,28 @@ from coding.llh.static.config import Config
 def draw_pred_total(input_dict):
     plt.figure(figsize=(10, 6))
 
-    i = 0
-    for name, cur_list in input_dict.items():
-        mylist = cur_list
+    for i, name, cur_list in enumerate(input_dict.items()):
+        if i == len(input_dict.keys())-1:
+            final_list = cur_list
+
         plt.plot(
             np.array([x for x in range(len(cur_list[0]))]),
             cur_list[0],
             "-",
-            color=Config.COLORS_4[i],
+            color=paint_object.get_color_cur_list()[i],
             alpha=0.9,
-            label=name
+            label=paint_object.get_label_cur_list()[i]
         )
-        i += 1
 
     plt.plot(
-        np.array([x for x in range(len(mylist[1]))]),
-        mylist[1],
+        np.array([x for x in range(len(final_list[1]))]),
+        final_list[1],
         "--",
-        color=Config.COLORS_4[1],
+        color=paint_object.get_color_cur_list()[len(input_dict.keys())],
         alpha=0.9,
-        label="actual data"
+        label=paint_object.get_label_cur_list[len(input_dict.keys())]
     )
 
-    title = "pred curve"
-
     plt.xlabel("Sizes")
     plt.ylabel("Value")
     plt.legend()

visualization/draw_scatter_line_graph.py

@@ -1,7 +1,7 @@
 import numpy as np
 import matplotlib.pyplot as plt
 
-from coding.llh.static.config import Config
+from static.config import Config
 
 
 # draw scatter line graph