2024/03/07/16:46

.gitignore

@@ -0,0 +1,4 @@
+/programmer.md
+/venv
+/test
+/old

README.md

@@ -1,5 +1,5 @@
 ---
-title: EasyMachineLearning test
+title: EasyMachineLearning
 emoji: 🔥
 colorFrom: red
 colorTo: red

analysis/model_train/bayes_model.py

@@ -0,0 +1,93 @@
+import numpy as np
+from sklearn.model_selection import learning_curve
+from sklearn.naive_bayes import *
+from analysis.others.hyperparam_optimize import *
+from classes.static_custom_class import StaticValue
+from functions.process import transform_params_list, get_values_from_container_class
+
+from metrics.calculate_classification_metrics import calculate_classification_metrics
+
+
+class NaiveBayesClassifierParams:
+    @classmethod
+    def get_params_type(cls, sort):
+        if sort == "MultinomialNB":
+            return {
+                "alpha": StaticValue.FLOAT
+            }
+        elif sort == "GaussianNB":
+            return {}
+        elif sort == "ComplementNB":
+            return {
+                "alpha": StaticValue.FLOAT,
+                "fit_prior": StaticValue.BOOL,
+                "norm": StaticValue.BOOL
+            }
+
+    @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_classifier(container, params_list, model=None):
+    x_train, y_train, x_test, y_test, hyper_params_optimize = get_values_from_container_class(container)
+    info = {}
+
+    params_list = transform_params_list(NaiveBayesClassifierParams, params_list, model)
+
+    if model == "MultinomialNB":
+        naive_bayes_model = MultinomialNB()
+        params = params_list
+    elif model == "GaussianNB":
+        naive_bayes_model = GaussianNB()
+        params = params_list
+    elif model == "ComplementNB":
+        naive_bayes_model = ComplementNB()
+        params = params_list
+    else:
+        naive_bayes_model = GaussianNB()
+        params = params_list
+
+    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)
+
+    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
+

analysis/model_train/distance_model.py

@@ -0,0 +1,128 @@
+from sklearn.model_selection import learning_curve
+from sklearn.neighbors import KNeighborsClassifier, KNeighborsRegressor
+
+from analysis.others.shap_model import *
+from classes.static_custom_class import StaticValue
+from functions.process import get_values_from_container_class, transform_params_list
+from metrics.calculate_classification_metrics import calculate_classification_metrics
+from metrics.calculate_regression_metrics import calculate_regression_metrics
+from analysis.others.hyperparam_optimize import *
+
+
+class KNNClassifierParams:
+    @classmethod
+    def get_params_type(cls):
+        return {
+            "n_neighbors": StaticValue.INT,
+            "weights": StaticValue.STR,
+            "p": StaticValue.INT
+        }
+
+    @classmethod
+    def get_params(cls):
+        return {
+            "n_neighbors": [3, 5, 7, 9],
+            "weights": ['uniform', 'distance'],
+            "p": [1, 2]
+        }
+
+
+# KNN分类
+def knn_classifier(container, params_list):
+    x_train, y_train, x_test, y_test, hyper_params_optimize = get_values_from_container_class(container)
+    info = {}
+
+    params_list = transform_params_list(KNNClassifierParams, params_list)
+
+    knn_classifier_model = KNeighborsClassifier()
+    params = params_list
+
+    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_type(cls):
+        return {
+            "n_neighbors": StaticValue.INT,
+            "weights": StaticValue.STR,
+            "p": StaticValue.INT
+        }
+
+    @classmethod
+    def get_params(cls):
+        return {
+            "n_neighbors": [3, 5, 7, 9],
+            "weights": ['uniform', 'distance'],
+            "p": [1, 2]
+        }
+
+
+# KNN回归
+def knn_regressor(container, params_list):
+    x_train, y_train, x_test, y_test, hyper_params_optimize = get_values_from_container_class(container)
+    info = {}
+
+    params_list = transform_params_list(KNNRegressionParams, params_list)
+
+    knn_regression_model = KNeighborsRegressor()
+    params = params_list
+
+    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/model_train/gradient_model.py

@@ -0,0 +1,74 @@
+import numpy as np
+from sklearn.ensemble import GradientBoostingRegressor
+from sklearn.model_selection import learning_curve
+
+from functions.process import transform_params_list, get_values_from_container_class
+from metrics.calculate_regression_metrics import calculate_regression_metrics
+from analysis.others.hyperparam_optimize import *
+from classes.static_custom_class import StaticValue
+
+
+class GradientBoostingParams:
+    @classmethod
+    def get_params_type(cls):
+        return {
+            'n_estimators': StaticValue.INT,
+            'learning_rate': StaticValue.FLOAT,
+            'max_depth': StaticValue.INT,
+            'min_samples_split': StaticValue.INT,
+            'min_samples_leaf': StaticValue.INT,
+            'random_state': StaticValue.INT
+        }
+
+    @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],
+            'random_state': [StaticValue.RANDOM_STATE]
+        }
+
+
+# 梯度提升回归
+def gradient_boosting_regressor(container, params_list):
+    x_train, y_train, x_test, y_test, hyper_params_optimize = get_values_from_container_class(container)
+    info = {}
+
+    params_list = transform_params_list(GradientBoostingParams, params_list)
+
+    gradient_boosting_regression_model = GradientBoostingRegressor(random_state=StaticValue.RANDOM_STATE)
+    params = params_list
+
+    if hyper_params_optimize == "grid_search":
+        best_model = grid_search(params, gradient_boosting_regression_model, x_train, y_train)
+    elif hyper_params_optimize == "bayes_search":
+        best_model = bayes_search(params, gradient_boosting_regression_model, x_train, y_train)
+    else:
+        best_model = gradient_boosting_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/model_train/kernel_model.py

@@ -0,0 +1,134 @@
+import numpy as np
+from sklearn.model_selection import learning_curve
+from sklearn.svm import SVC
+from sklearn.svm import SVR
+
+from classes.static_custom_class import StaticValue
+from functions.process import get_values_from_container_class, transform_params_list
+from metrics.calculate_classification_metrics import calculate_classification_metrics
+from metrics.calculate_regression_metrics import calculate_regression_metrics
+from analysis.others.hyperparam_optimize import *
+
+
+class SVMRegressionParams:
+    @classmethod
+    def get_params_type(cls):
+        return {
+            'kernel': StaticValue.STR,
+            'C': StaticValue.FLOAT,
+            'gamma': StaticValue.FLOAT,
+            'epsilon': StaticValue.FLOAT
+        }
+
+    @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_regressor(container, params_list):
+    x_train, y_train, x_test, y_test, hyper_params_optimize = get_values_from_container_class(container)
+    info = {}
+
+    params_list = transform_params_list(SVMRegressionParams, params_list)
+
+    svm_regression_model = SVR(kernel='rbf', C=100, gamma=0.1, epsilon=0.1)
+    params = params_list
+
+    if hyper_params_optimize == "grid_search":
+        best_model = grid_search(params, svm_regression_model, x_train, y_train)
+    elif hyper_params_optimize == "bayes_search":
+        best_model = bayes_search(params, svm_regression_model, x_train, y_train)
+    else:
+        best_model = svm_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
+
+
+class SVMClassifierParams:
+    @classmethod
+    def get_params_type(cls):
+        return {
+            "C": StaticValue.FLOAT,
+            "kernel": StaticValue.STR,
+            "gamma": StaticValue.FLOAT,
+            'random_state': StaticValue.INT
+        }
+
+    @classmethod
+    def get_params(cls):
+        return {
+            "C": [0.1, 1, 10, 100],
+            "kernel": ['linear', 'rbf', 'poly'],
+            "gamma": [0.1, 1, 10],
+            'random_state': [StaticValue.RANDOM_STATE]
+        }
+
+
+# 支持向量机分类
+def svm_classifier(container, params_list):
+    x_train, y_train, x_test, y_test, hyper_params_optimize = get_values_from_container_class(container)
+    info = {}
+
+    params_list = transform_params_list(SVMClassifierParams, params_list)
+
+    svm_classifier_model = SVC(kernel="rbf", random_state=StaticValue.RANDOM_STATE)
+    params = params_list
+
+    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)
+
+    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_classification_metrics(y_pred, y_test)
+
+    container.set_info(info)
+    container.set_status("trained")
+    container.set_model(best_model)
+
+    return container

analysis/model_train/linear_model.py

@@ -0,0 +1,246 @@
+import numpy as np
+import gradio as gr
+from sklearn.linear_model import ElasticNet
+from sklearn.linear_model import Lasso
+from sklearn.linear_model import LinearRegression
+from sklearn.linear_model import LogisticRegression
+from sklearn.linear_model import Ridge
+from sklearn.model_selection import learning_curve
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import PolynomialFeatures
+
+from functions.process import get_values_from_container_class, transform_params_list
+from metrics.calculate_classification_metrics import calculate_classification_metrics
+from metrics.calculate_regression_metrics import calculate_regression_metrics
+from analysis.others.hyperparam_optimize import *
+from classes.static_custom_class import StaticValue
+
+
+class LinearRegressionParams:
+    @classmethod
+    def get_params_type(cls, sort):
+        if sort in ["Lasso", "Ridge", "ElasticNet"]:
+            return {
+                "fit_intercept": StaticValue.BOOL,
+                "alpha": StaticValue.FLOAT,
+                "random_state": StaticValue.INT
+            }
+        else:
+            return {
+                "fit_intercept": StaticValue.BOOL
+            }
+
+    @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": [StaticValue.RANDOM_STATE]
+            }
+        else:
+            return {
+                "fit_intercept": [True, False]
+            }
+
+
+# 线性回归
+def linear_regressor(container, params_list, model=None):
+    x_train, y_train, x_test, y_test, hyper_params_optimize = get_values_from_container_class(container)
+    info = {}
+
+    input_params = transform_params_list(LinearRegressionParams, params_list, model)
+
+    if model == "Lasso":
+        linear_regression_model = Lasso(alpha=0.1, random_state=StaticValue.RANDOM_STATE)
+        params = input_params
+    elif model == "Ridge":
+        linear_regression_model = Ridge(alpha=0.1, random_state=StaticValue.RANDOM_STATE)
+        params = input_params
+    elif model == "ElasticNet":
+        linear_regression_model = ElasticNet(alpha=0.1, random_state=StaticValue.RANDOM_STATE)
+        params = input_params
+    elif model == "LinearRegression":
+        linear_regression_model = LinearRegression()
+        params = input_params
+    else:
+        linear_regression_model = LinearRegression()
+        params = input_params
+
+    try:
+        if hyper_params_optimize == "grid_search":
+            best_model = grid_search(params, linear_regression_model, x_train, y_train)
+        elif hyper_params_optimize == "bayes_search":
+            best_model = bayes_search(params, linear_regression_model, x_train, y_train)
+        else:
+            best_model = linear_regression_model
+            best_model.fit(x_train, y_train)
+    except Exception:
+        gr.Warning("超参数设置有误，将按照默认模型训练")
+        best_model = LinearRegression()
+        best_model.fit(x_train, y_train)
+
+    info["参数"] = best_model.get_params()
+
+    # 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)
+
+    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
+
+
+class PolynomialRegressionParams:
+    @classmethod
+    def get_params_type(cls):
+        return {
+            "polynomial_features__degree": StaticValue.INT,
+            "linear_regression_model__fit_intercept": StaticValue.BOOL
+        }
+
+    @classmethod
+    def get_params(cls):
+        return {
+            "polynomial_features__degree": [2, 3],
+            "linear_regression_model__fit_intercept": [True, False]
+        }
+
+
+# 多项式回归
+def polynomial_regressor(container, params_list):
+    x_train, y_train, x_test, y_test, hyper_params_optimize = get_values_from_container_class(container)
+    info = {}
+
+    params_list = transform_params_list(PolynomialRegressionParams, params_list)
+
+    polynomial_features = PolynomialFeatures(degree=2)
+    linear_regression_model = LinearRegression()
+
+    polynomial_regression_model = Pipeline([("polynomial_features", polynomial_features),
+                                            ("linear_regression_model", linear_regression_model)])
+    params = params_list
+
+    if hyper_params_optimize == "grid_search":
+        best_model = grid_search(params, polynomial_regression_model, x_train, y_train)
+    elif hyper_params_optimize == "bayes_search":
+        best_model = bayes_search(params, polynomial_regression_model, x_train, y_train)
+    else:
+        best_model = polynomial_regression_model
+        best_model.fit(x_train, y_train)
+
+    info["参数"] = best_model.get_params()
+
+    # 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_)
+    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
+
+
+class LogisticRegressionParams:
+    @classmethod
+    def get_params_type(cls):
+        return {
+            "C": StaticValue.FLOAT,
+            "max_iter": StaticValue.INT,
+            "solver": StaticValue.STR,
+            "random_state": StaticValue.INT
+        }
+
+    @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": [StaticValue.RANDOM_STATE]
+        }
+
+
+# 逻辑斯谛分类
+def logistic_classifier(container, params_list):
+    x_train, y_train, x_test, y_test, hyper_params_optimize = get_values_from_container_class(container)
+    info = {}
+
+    params_list = transform_params_list(LogisticRegressionParams, params_list)
+
+    logistic_regression_model = LogisticRegression(random_state=StaticValue.RANDOM_STATE)
+    params = params_list
+
+    if hyper_params_optimize == "grid_search":
+        best_model = grid_search(params, logistic_regression_model, x_train, y_train)
+    elif hyper_params_optimize == "bayes_search":
+        best_model = bayes_search(params, logistic_regression_model, x_train, y_train)
+    else:
+        best_model = logistic_regression_model
+        best_model.fit(x_train, y_train)
+
+    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()
+
+    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

analysis/model_train/tree_model.py

@@ -0,0 +1,329 @@
+import lightgbm as lightGBMClassifier
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.model_selection import learning_curve
+from sklearn.tree import DecisionTreeClassifier
+from xgboost import XGBClassifier
+
+from analysis.others.shap_model import *
+from functions.process import get_values_from_container_class, transform_params_list
+from metrics.calculate_classification_metrics import calculate_classification_metrics
+from metrics.calculate_regression_metrics import calculate_regression_metrics
+from analysis.others.hyperparam_optimize import *
+from classes.static_custom_class import StaticValue
+
+
+class RandomForestRegressionParams:
+    @classmethod
+    def get_params_type(cls):
+        return {
+            'n_estimators': StaticValue.INT,
+            'max_depth': StaticValue.INT,
+            'min_samples_split': StaticValue.INT,
+            'min_samples_leaf': StaticValue.INT,
+            'random_state': StaticValue.INT
+        }
+
+    @classmethod
+    def get_params(cls):
+        return {
+            'n_estimators': [10, 50, 100, 200],
+            'max_depth': [0, 10, 20, 30],
+            'min_samples_split': [2, 5, 10],
+            'min_samples_leaf': [1, 2, 4],
+            'random_state': [StaticValue.RANDOM_STATE]
+        }
+
+
+# 随机森林回归
+def random_forest_regressor(container, params_list):
+    x_train, y_train, x_test, y_test, hyper_params_optimize = get_values_from_container_class(container)
+    info = {}
+
+    params_list = transform_params_list(RandomForestRegressionParams, params_list)
+
+    random_forest_regression_model = RandomForestRegressor(n_estimators=5, random_state=StaticValue.RANDOM_STATE)
+    params = params_list
+
+    if hyper_params_optimize == "grid_search":
+        best_model = grid_search(params, random_forest_regression_model, x_train, y_train)
+    elif hyper_params_optimize == "bayes_search":
+        best_model = bayes_search(params, random_forest_regression_model, x_train, y_train)
+    else:
+        best_model = random_forest_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
+
+
+class DecisionTreeClassifierParams:
+    @classmethod
+    def get_params_type(cls):
+        return {
+            "criterion": StaticValue.STR,
+            "splitter": StaticValue.STR,
+            "max_depth": StaticValue.INT,
+            "min_samples_split": StaticValue.INT,
+            "min_samples_leaf": StaticValue.INT,
+            'random_state': StaticValue.INT
+        }
+
+    @classmethod
+    def get_params(cls):
+        return {
+            "criterion": ["gini", "entropy"],
+            "splitter": ["best", "random"],
+            "max_depth": [0, 5, 10, 15],
+            "min_samples_split": [2, 5, 10],
+            "min_samples_leaf": [1, 2, 4],
+            'random_state': [StaticValue.RANDOM_STATE]
+        }
+
+
+# 决策树分类
+def decision_tree_classifier(container, params_list):
+    x_train, y_train, x_test, y_test, hyper_params_optimize = get_values_from_container_class(container)
+    info = {}
+
+    params_list = transform_params_list(DecisionTreeClassifierParams, params_list)
+
+    random_forest_regression_model = DecisionTreeClassifier(random_state=StaticValue.RANDOM_STATE)
+    params = params_list
+
+    if hyper_params_optimize == "grid_search":
+        best_model = grid_search(params, random_forest_regression_model, x_train, y_train)
+    elif hyper_params_optimize == "bayes_search":
+        best_model = bayes_search(params, random_forest_regression_model, x_train, y_train)
+    else:
+        best_model = random_forest_regression_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 RandomForestClassifierParams:
+    @classmethod
+    def get_params_type(cls):
+        return {
+            "criterion": StaticValue.STR,
+            "n_estimators": StaticValue.INT,
+            "max_depth": StaticValue.INT,
+            "min_samples_split": StaticValue.INT,
+            "min_samples_leaf": StaticValue.INT,
+            "random_state": StaticValue.INT
+        }
+
+    @classmethod
+    def get_params(cls):
+        return {
+            "criterion": ["gini", "entropy"],
+            "n_estimators": [50, 100, 150],
+            "max_depth": [0, 5, 10, 15],
+            "min_samples_split": [2, 5, 10],
+            "min_samples_leaf": [1, 2, 4],
+            "random_state": [StaticValue.RANDOM_STATE]
+        }
+
+
+# 随机森林分类
+def random_forest_classifier(container, params_list):
+    x_train, y_train, x_test, y_test, hyper_params_optimize = get_values_from_container_class(container)
+    info = {}
+
+    params_list = transform_params_list(RandomForestClassifierParams, params_list)
+
+    random_forest_classifier_model = RandomForestClassifier(n_estimators=5, random_state=StaticValue.RANDOM_STATE)
+    params = params_list
+
+    if hyper_params_optimize == "grid_search":
+        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, y_train)
+    else:
+        best_model = random_forest_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)
+
+    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_type(cls):
+        return {
+            "n_estimators": StaticValue.INT,
+            "learning_rate": StaticValue.FLOAT,
+            "max_depth": StaticValue.INT,
+            "min_child_weight": StaticValue.INT,
+            "gamma": StaticValue.FLOAT,
+            "subsample": StaticValue.FLOAT,
+            "colsample_bytree": StaticValue.FLOAT,
+            "random_state": StaticValue.INT
+        }
+
+    @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],
+            "random_state": [StaticValue.RANDOM_STATE]
+        }
+
+
+# xgboost分类
+def xgboost_classifier(container, params_list):
+    x_train, y_train, x_test, y_test, hyper_params_optimize = get_values_from_container_class(container)
+    info = {}
+
+    params_list = transform_params_list(XgboostClassifierParams, params_list)
+
+    xgboost_classifier_model = XGBClassifier(random_state=StaticValue.RANDOM_STATE)
+    params = params_list
+
+    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)
+
+    info["指标"] = calculate_classification_metrics(y_pred, y_test)
+
+    container.set_info(info)
+    container.set_status("trained")
+    container.set_model(best_model)
+
+    return container
+
+
+class LightGBMClassifierParams:
+    @classmethod
+    def get_params(cls):
+        return
+
+
+# lightGBM分类
+def lightGBM_classifier(container, params_list):
+    x_train, y_train, x_test, y_test, hyper_params_optimize = get_values_from_container_class(container)
+    info = {}
+
+    params_list = transform_params_list(LightGBMClassifierParams, params_list)
+
+    lightgbm_classifier_model = lightGBMClassifier
+    params = params_list
+
+    if hyper_params_optimize == "grid_search":
+        best_model = grid_search(params, lightgbm_classifier_model, x_train, y_train)
+    elif hyper_params_optimize == "bayes_search":
+        best_model = bayes_search(params, lightgbm_classifier_model, x_train, y_train)
+    else:
+        best_model = lightgbm_classifier_model
+        best_model.train(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_classification_metrics(y_pred, y_test)
+
+    container.set_info(info)
+    container.set_status("trained")
+    container.set_model(best_model)
+
+    return container
+
+
+

analysis/others/hyperparam_optimize.py

@@ -0,0 +1,30 @@
+from sklearn.model_selection import GridSearchCV
+from skopt import BayesSearchCV
+
+
+def grid_search(params, model, x_train, y_train, scoring=None):
+    info = {}
+
+    grid_search_model = GridSearchCV(model, params, cv=3, n_jobs=-1)
+
+    grid_search_model.fit(x_train, y_train.ravel())
+
+    info["Optimal hyperparameters"] = grid_search_model.best_params_
+
+    best_model = grid_search_model.best_estimator_
+
+    return best_model
+
+
+def bayes_search(params, model, x_train, y_train, scoring=None):
+    info = {}
+
+    bayes_search_model = BayesSearchCV(model, params, cv=3, n_iter=50, n_jobs=-1)
+
+    bayes_search_model.fit(x_train, y_train)
+
+    info["Optimal hyperparameters"] = bayes_search_model.best_params_
+
+    best_model = bayes_search_model.best_estimator_
+
+    return best_model

analysis/others/shap_model.py

@@ -0,0 +1,55 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import shap
+
+
+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.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
+
+
+
+

classes/static_custom_class.py

@@ -0,0 +1,248 @@
+# 全局静态变量值存储类
+class StaticValue:
+    # 超参数文本框的最大组件数量
+    MAX_PARAMS_NUM = 60
+    # 颜色和标签显示的最大组件数量
+    MAX_NUM = 20
+    # 随机种子 (数据集切分+模型训练)
+    RANDOM_STATE = 123
+
+    # 参数类型
+    INT = "int"
+    FLOAT = "float"
+    BOOL = "bool"
+    STR = "str"
+
+    # 画图颜色组重复次数
+    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",
+                   "#992224",
+                   "#B54764",
+                   "#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_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",
+                   "#7C7979"
+               ] * COLOR_ITER_NUM
+
+    COLORS_6 = [
+                   "#E9687A",
+                   "#F58F7A",
+                   "#FDE2D8",
+                   "#CFCFD0",
+                   "#B6B3D6"
+               ] * COLOR_ITER_NUM
+
+
+# 文件路径相关静态变量存储类
+class FilePath:
+    png_base = "./buffer/{}.png"
+    excel_base = "./buffer/{}.xlsx"
+
+    # [绘图]
+    display_dataset = "current_excel_data"
+
+    data_distribution_plot = "data_distribution_plot"
+    descriptive_indicators_plot = "descriptive_indicators_plot"
+    heatmap_plot = "heatmap_plot"
+    learning_curve_plot = "learning_curve_plot"
+    shap_beeswarm_plot = "shap_beeswarm_plot"
+    data_fit_plot = "data_fit_plot"
+    waterfall_plot = "waterfall_plot"
+    force_plot = "force_plot"
+    dependence_plot = "dependence_plot"
+    # 绘图Step 15:在这里添加新的绘图方法名称
+
+
+# 模型名称静态变量存储类
+class MN:  # ModelName
+    classification = "classification"
+    regression = "regression"
+
+    # [模型]
+    linear_regressor = "linear regressor"
+    polynomial_regressor = "polynomial regressor"
+    logistic_classifier = "logistic classifier"
+    decision_tree_classifier = "decision tree classifier"
+    random_forest_classifier = "random forest classifier"
+    random_forest_regressor = "random forest regressor"
+    xgboost_classifier = "xgboost classifier"
+    lightGBM_classifier = "lightGBM classifier"
+    gradient_boosting_regressor = "gradient boosting regressor"
+    svm_classifier = "svm classifier"
+    svm_regressor = "svm regressor"
+    knn_classifier = "knn classifier"
+    knn_regressor = "knn regressor"
+    naive_bayes_classifier = "naive bayes classifier"
+    # 模型Step 4:在这里添加新的模型名称
+
+    # [绘图]
+    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"
+    # 绘图Step 4:在这里添加新的绘图方法名称
+
+
+# 组件标签名称静态变量存储类
+class LN:  # LabelName
+    choose_dataset_radio = "选择所需数据源 [必选]"
+    display_total_col_num_text = "总列数"
+    display_total_row_num_text = "总行数"
+    display_na_list_text = "存在缺失值的列"
+    del_all_na_col_button = "删除所有存在缺失值的列 [可选]"
+    display_duplicate_num_text = "重复的行���"
+    del_col_checkboxgroup = "选择所需删除的列"
+    del_col_button = "删除 [可选]"
+    remain_row_slider = "保留的行数"
+    remain_row_button = "保留 [可选]"
+    del_duplicate_button = "删除所有重复行 [可选]"
+    encode_label_checkboxgroup = "选择所需标签编码的字符型数值列"
+    display_encode_label_dataframe = "标签编码信息"
+    encode_label_button = "字符型转数值型 [可选]"
+    change_data_type_to_float_button = "将所有数据强制转换为浮点型（除第1列以外）[必选]"
+    standardize_data_checkboxgroup = "选择所需标准化的列"
+    standardize_data_button = "标准化 [可选]"
+    select_as_y_radio = "选择因变量 [必选]"
+    choose_assign_radio = "选择任务类型（同时会根据任务类型将第1列数据强制转换）[必选]"
+    train_size_textbox = "分割出的训练集所占比例"
+    model_optimize_radio = "选择超参数优化方法"
+    model_train_input_params_dataframe = "超参数列表"
+    model_train_button = "训练"
+    model_train_params_dataframe = "训练后的模型参数"
+    model_train_metrics_dataframe = "训练后的模型指标"
+    select_as_model_radio = "选择所需训练的模型"
+
+    # [模型]
+    linear_regression_model_radio = "选择线性回归的模型"
+    naive_bayes_classification_model_radio = "选择朴素贝叶斯分类的模型"
+    # 模型Step 5:在这里添加新的模型额外组件名称
+
+    title_name_textbox = "标题"
+    x_label_textbox = "x 轴名称"
+    y_label_textbox = "y 轴名称"
+    colors = ["颜色 {}".format(i) for i in range(StaticValue.MAX_NUM)]
+    labels = ["图例 {}".format(i) for i in range(StaticValue.MAX_NUM)]
+
+    # [绘图]
+    heatmap_is_rotate = "x轴标签是否旋转"
+    heatmap_checkboxgroup = "选择所需绘制系数热力图的列"
+    heatmap_button = "绘制系数热力图"
+    data_distribution_radio = "选择所需绘制数据分布图的列"
+    data_distribution_is_rotate = "x轴标签是否旋转"
+    data_distribution_button = "绘制数据分布图"
+    descriptive_indicators_checkboxgroup = "选择所需绘制箱线统计图的列"
+    descriptive_indicators_is_rotate = "x轴标签是否旋转"
+    descriptive_indicators_button = "绘制箱线统计图"
+    learning_curve_checkboxgroup = "选择所需绘制学习曲线图的模型"
+    learning_curve_button = "绘制学习曲线图"
+    shap_beeswarm_radio = "选择所需绘制特征蜂群图的模型"
+    shap_beeswarm_type = "选择图像类型"
+    shap_beeswarm_button = "绘制特征蜂群图"
+    data_fit_checkboxgroup = "选择所需绘制数据拟合图的模型"
+    data_fit_button = "绘制数据拟合图"
+    waterfall_radio = "选择所需绘制特征瀑布图的模型"
+    waterfall_number = "输入相关特征的变量索引"
+    waterfall_button = "绘制特征瀑布图"
+    force_radio = "选择所需绘制特征力图的模型"
+    force_number = "输入相关特征的变量索引"
+    force_button = "绘制特征力图"
+    dependence_radio = "选择所需绘制特征依赖图的模型"
+    dependence_col = "选择相应的列"
+    dependence_button = "绘制特征依赖图"
+    # 绘图Step 5:在这里添加新的绘图方法相关组件名称
+
+    data_distribution_plot = "数据分布图"
+    descriptive_indicators_plot = "箱线统计图"
+    heatmap_plot = "系数热力图"
+    learning_curve_plot = "学习曲线图"
+    shap_beeswarm_plot = "特征蜂群图"
+    data_fit_plot = "数据拟合图"
+    waterfall_plot = "特征瀑布图"
+    force_plot = "特征力图"
+    dependence_plot = "特征依赖图"
+    # 绘图Step 6:在这里添加新的绘图方法名称
+
+
+
+
+
+
+
+
+

data/notes.md

@@ -1,12 +1,198 @@
 # EasyMachineLearning
-### 介绍
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+## 介绍
 - 版本：v1.0
 - 作者：李凌浩
-- 有任何新功能的想法和已出现的问题请和作者联系 ~
+- 有任何出现的问题请私信 或 在Github上反馈 ~
+- 有任何新功能的想法请加作者微信 ~
+- 合作请联系作者 ~
 - *( WX: llh13857750421 )*
-### 尚未实现的功能
-1. [困难] 模型训练的进度条可视化（sklearn模型训练函数无回调函数） 
-2. 模型训练完毕后保存模型文件，后续可直接加载
-3. 数据分析AI助手（直接处理Excel数据）
-4. PCA主成分分析
-5. 聚类
+-  ଘ(੭ˊ꒳​ˋ)੭
+
+## 注意事项
+- 模型训练和可视化过程暂未实现进度条，后续版本可能会出该功能
+
+## 解释
+### 1.数据源
+##### *i.选择所需数据源 [必选]*
+```angular2html
+·自定义：上传自己的Excel表格作为数据源
+·Iris Dataset: 鸢尾花数据集 (用于分类任务) [sklearn内置数据集]
+·Wine Dataset: 酒的数据集 (用于分类任务) [sklearn内置数据集]
+·Breast Cancer Dataset: 乳腺癌数据集 (用于分类任务) [sklearn内置数据集]
+·Diabetes Dataset: 糖尿病数据集 (用于回归任务) [sklearn内置数据集]
+·California Housing Dataset: 加利福尼亚房价数据集 (用于回归任务) [程序内置数据集]
+
+·为机器学习任务的起始操作
+·更改数据源会自动清理所有已训练的模型缓存和其他部分缓存
+```
+### 2.当前数据信息
+```angular2html
+·总列数: 当前操作的数据的总列数
+·总行数: 当前操作的数据的总行数
+·保留的行数 [可选]: 拖动滑动条可以选择 当前操作的数据中所需保留的行数，其余行全部删除
+·存在缺失值的列: 显示当前操作的数据中有缺失值如Nan等的列名
+·删除所有存在缺失值的列 [可选]: 删除当前操作的数据中含有缺失值如Nan等的列
+·重复的行数: 当前操作的数据中一样的行数
+·删除所有重复行 [可选]: 删除当前操作的数据中一样的行
+
+·实时显示当前操作的数据 (只能查看，不能更改)
+·[*index]列为当前数据索引，非数据内的列 (自动添加该列是为了方便查看数据)
+·最左边第一列始终为因变量的列，其余为自变量的列
+·可随时将当前操作的数据下载到本地 (Excel格式)
+
+```
+### 3.数据处理
+##### *i.选择因变量 [必选]*
+```angular2html
+·当前操作数据中的所有列名
+
+·在显示的所有行名字中选择作为任务的因变量的列 (选中后自动将该列移动到当前数据的第一列)
+```
+##### *ii.将所有数据强制转换为浮点型 (除第1列以外) [必选]*
+```angular2html
+·"列名-数据类型"数据表: 当前操作中的数据的所有列对应的数据类型 (字符型为"object")
+
+·第1列因变量的列在这里不会成为被转换的对象
+```
+##### *iii.选择任务类型 (同时会根据任务类型将第1列数据强制转换) [必选]*
+```angular2html
+·分类
+·回归
+
+·选择分类会将第1列的数据强制转换为字符型数据
+·选择回归会将第1列的数据强制转换为浮点型数据
+```
+##### *iv.选择所需删除的列*
+```angular2html
+·当前操作数据中的所有列名
+
+·删除 [可选]: 在当前操作的数据中删除所选列
+```
+##### *v.选择所需标签编码的字符型数值列*
+```angular2html
+·当前操作数据中是字符型数据的所有列名
+
+·字符型转数值型 [可选]: 将选中的数据列强制转换为浮点型
+```
+##### *vi.选择所需标准化的列*
+```angular2html
+·当前操作数据中尚未标准化的所有列名
+
+·标准化 [可选]: 将选中的数据列根据各自列进行标准化 (变成0~1范围)
+```
+### 4.数据模型 (上述[必选]全部选择完毕后才会显示!)
+##### *i.选择所需训练的模型*
+```angular2html
+·当前可选择的所有模型名
+
+·选中后会展示当前选中模型的相关信息和选项
+```
+##### *ii.分割出的训练集所占比例*
+```angular2html
+·该比例为训练集占所有数据的比例
+·默认为0.8
+```
+##### *iii.选择超参数优化方法*
+```angular2html
+·无: 直接训练 (速度快) (如果其他超参数优化方法速度较慢可选择当前项看效果)
+·网格搜索: (速度相对适中) (请作为模型调参的首选项)
+·贝叶斯优化: (速度很慢)
+
+·请优先选择网格搜索
+·树模型如决策树、随机森林、XGBoost模型的超参数优化速度在数据量大的情况下非常慢，自行考虑是否需要等待 
+·参数量越大速度越慢
+```
+##### *iv.超参数列表 (选择超参数优化方法后会显示)*
+```angular2html
+·橙色边框的文本框为超参数名称 (可修改)
+·每行无颜色边框的文本框为超参数对应的各个候选参数 (可修改)
+
+·将文本框中的参数删除后(空字符串)，就相当于删除了该参数
+·只能修改和减少参数，不能增加
+·每次加载默认显示每个模型的默认参数字典
+```
+##### *v.模型是否完成训练*
+```angular2html
+·若选中的该模型训练完成后，会勾选
+```
+### 5.数据可视化
+##### *i.数据分布图*
+```angular2html
+·需要选择可视化的相应列
+·每列数据的数量统计的柱状图
+```
+##### *ii.箱线统计图*
+```angular2html
+·需要选择可视化的相应列
+·每列数据的常见统计量的箱线图
+```
+##### *iii.系数热力图*
+```angular2html
+·需要选择可视化的相应列
+·列与列之间的皮尔逊相关系数
+```
+##### *iv.学习曲线图*
+```angular2html
+·需要选择已训练的模型名称
+·训练集与验证集数据的拟合效果 (1个模型有2条曲线)
+```
+##### *v.数据拟合图*
+```angular2html
+·需要选择已训练的模型名称
+·测试集的真实数值曲线与模型预测数值曲线
+```
+##### *vi.特征蜂群图*
+```angular2html
+·需要选择已训练的模型名称
+·需要选择图像类型
+·特征对模型整体能力的表征程度
+```
+##### *vii.特征瀑布图*
+```angular2html
+·需要选择已训练的模型名称
+·需要选择相关特征的变量索引
+·特征对模型整体能力的表征程度
+```
+##### *viii.特征力图*
+```angular2html
+·需要选择已训练的模型名称
+·需要选择相关特征的变量索引
+·特征对模型整体能力的表征程度
+```
+##### *viiii.特征依赖图*
+```angular2html
+·需要选择已训练的模型名称
+·需要选择对应的列
+·特征对模型整体能力的表征程度
+```
+##### *图例*
+```angular2html
+·图中每个图例的名称
+
+·图中有图例才会显示 (不支持中文)
+```
+##### *坐标轴*
+```angular2html
+·标题
+·x轴名称
+·y轴名称
+
+·不支持中文
+```
+##### *颜色*
+```angular2html
+·图中每个颜色对应的取色器和十六进制
+
+·图中有可更改的颜色才会显示
+```
+##### *图*
+```angular2html
+·可随时将当前操作的图片下载到本地 (png格式)
+```
+
+
+
+
+
+

design/custom.css

@@ -0,0 +1,5 @@
+.params_name textarea {
+    font-weight: bold;
+    font-style: oblique;
+    border: solid #ee9900;
+}

design/welcome.js

@@ -0,0 +1,31 @@
+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';
+    }

functions/process.py

@@ -0,0 +1,38 @@
+def get_values_from_container_class(container):
+    return container.x_train, container.y_train, container.x_test, container.y_test, container.hyper_params_optimize
+
+
+def transform_params_list(params_class, params_list, model=None):
+    input_params_keys = []
+    input_params_values = []
+    inner_value_list = []
+
+    keys = params_class.get_params(model).keys() if model else params_class.get_params().keys()
+    for i, param in enumerate(params_list):
+        if param in keys:
+            input_params_keys.append(param)
+            if i != 0:
+                input_params_values.append(inner_value_list)
+            inner_value_list = []
+        else:
+            inner_value_list.append(param)
+    else:
+        input_params_values.append(inner_value_list)
+    input_params = dict(zip(input_params_keys, input_params_values))
+
+    for k, v in input_params.items():
+        if k in keys:
+            value_type = params_class.get_params_type(model)[k] if model else params_class.get_params_type()[k]
+            try:
+                if value_type == "int":
+                    input_params[k] = [int(x) for x in input_params[k]]
+                elif value_type == "float":
+                    input_params[k] = [float(x) for x in input_params[k]]
+                elif value_type == "bool":
+                    input_params[k] = [x == "True" for x in input_params[k]]
+                elif value_type == "str":
+                    input_params[k] = [str(x) for x in input_params[k]]
+            except Exception:
+                input_params[k] = [str(x) for x in input_params[k]]
+
+    return input_params

visualization/draw_boxplot.py

@@ -1,7 +1,4 @@
 import matplotlib.pyplot as plt
-import numpy as np
-
-from static.config import Config
 
 
 def draw_boxplot(x_data, paint_object, will_rotate=False):

visualization/draw_data_fit_total.py

@@ -1,11 +1,8 @@
 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):
+def draw_data_fit_total(input_dict, paint_object):
     plt.figure(figsize=(10, 6), dpi=300)
 
     for i, input_dict_items in enumerate(input_dict.items()):

visualization/draw_heat_map.py

@@ -1,9 +1,7 @@
-import numpy as np
 import matplotlib.pyplot as plt
+import numpy as np
 import pandas as pd
 
-from static.config import Config
-
 
 def draw_heat_map(x_data, col_list, paint_object, will_rotate=False):
     plt.rcParams.update({'figure.autolayout': True})
@@ -28,8 +26,8 @@ def draw_heat_map(x_data, col_list, paint_object, will_rotate=False):
 
     plt.yticks(np.arange(len(col_list)), col_list)
     plt.imshow(np_data)
-    plt.colorbar(True)
-    plt.tight_layout()
+    plt.colorbar()
+    # plt.tight_layout()
 
     plt.title(paint_object.get_name())
 

visualization/draw_histogram.py

@@ -1,10 +1,5 @@
-import random
-
-import numpy as np
 import matplotlib.pyplot as plt
-
-from static.config import Config
-from static.new_class import PaintObject
+import numpy as np
 
 
 def draw_histogram(nums, labels, paint_object, will_rotate=False, will_show_text=True):

visualization/draw_histogram_line_subgraph.py

@@ -1,7 +1,7 @@
 import numpy as np
 from matplotlib import pyplot as plt
 
-from static.config import Config
+from classes.static_custom_class import *
 
 
 def draw_histogram_line_subgraph(total_data_for_plot):
@@ -22,7 +22,7 @@ def draw_histogram_line_subgraph(total_data_for_plot):
                 data[1],
                 data[2],
                 "-o",
-                color=Config.COLORS[0],
+                color=StaticValue.COLORS[0],
                 markersize=4
             )
             ax[str(chr(i+65))].set_title(data[3])
@@ -33,7 +33,7 @@ def draw_histogram_line_subgraph(total_data_for_plot):
                 data[1],
                 align="center",
                 alpha=1,
-                color=Config.COLORS,
+                color=StaticValue.COLORS,
                 tick_label=data[2]
             )
 

visualization/draw_learning_curve.py

@@ -1,7 +1,6 @@
-import numpy as np
 from matplotlib import pyplot as plt
 
-from static.config import Config
+from classes.static_custom_class import *
 
 
 def draw_learning_curve(train_sizes, train_scores_mean, train_scores_std, test_scores_mean, test_scores_std):
@@ -12,13 +11,13 @@ def draw_learning_curve(train_sizes, train_scores_mean, train_scores_std, test_s
         train_scores_mean - train_scores_std,
         train_scores_mean + train_scores_std,
         alpha=0.1,
-        color=Config.COLORS[0]
+        color=StaticValue.COLORS[0]
     )
     plt.plot(
         train_sizes,
         train_scores_mean,
         "o-",
-        color=Config.COLORS[0],
+        color=StaticValue.COLORS[0],
         label="Training score"
     )
 
@@ -27,13 +26,13 @@ def draw_learning_curve(train_sizes, train_scores_mean, train_scores_std, test_s
         test_scores_mean - test_scores_std,
         test_scores_mean + test_scores_std,
         alpha=0.1,
-        color=Config.COLORS[1]
+        color=StaticValue.COLORS[1]
     )
     plt.plot(
         train_sizes,
         test_scores_mean,
         "o-",
-        color=Config.COLORS[1],
+        color=StaticValue.COLORS[1],
         label="Cross-validation score"
     )
 

visualization/draw_learning_curve_total.py

@@ -1,9 +1,7 @@
 from matplotlib import pyplot as plt
 
-from static.new_class import PaintObject
 
-
-def draw_learning_curve_total(input_dict, paint_object: PaintObject):
+def draw_learning_curve_total(input_dict, paint_object):
     plt.figure(figsize=(10, 8), dpi=300)
 
     for i, values in enumerate(input_dict.values()):

visualization/draw_line_graph.py

@@ -1,8 +1,5 @@
-import numpy as np
 import matplotlib.pyplot as plt
 
-from static.config import Config
-
 
 def draw_line_graph(nums, labels, paint_object):
     plt.figure(figsize=(10, 8), dpi=300)

visualization/draw_momentum.py

@@ -1,9 +1,4 @@
-import numpy as np
 import matplotlib.pyplot as plt
-from sklearn.metrics import *
-from sklearn.preprocessing import label_binarize
-
-from coding.llh.static.config import Config
 
 
 def draw_momentum(df, p1_name, p2_name):

visualization/draw_parallel_coordinates.py

@@ -1,7 +1,5 @@
-import pandas as pd
 import matplotlib.pyplot as plt
-
-from coding.llh.static.config import Config
+import pandas as pd
 
 
 def draw_parallel_coordinates(df):

visualization/draw_play_flow.py

@@ -1,9 +1,4 @@
-import numpy as np
 import matplotlib.pyplot as plt
-from sklearn.metrics import *
-from sklearn.preprocessing import label_binarize
-
-from coding.llh.static.config import Config
 
 
 def draw_play_flow(df, p1_name, p2_name, p1_ace, p2_ace, p1_net_pt_won, p2_net_pt_won, p1_break_pt_won, p2_break_pt_won):

visualization/draw_pred_total.py

@@ -1,8 +1,6 @@
 import numpy as np
 from matplotlib import pyplot as plt
 
-from coding.llh.static.config import Config
-
 
 def draw_pred_total(input_dict):
     plt.figure(figsize=(10, 6))

visualization/draw_roc_auc_curve_total.py

@@ -1,9 +1,7 @@
-import numpy as np
 import matplotlib.pyplot as plt
 from sklearn.metrics import *
-from sklearn.preprocessing import label_binarize
 
-from coding.llh.static.config import Config
+from classes.static_custom_class import *
 
 
 def draw_roc_auc_curve_total(input_dict, type):
@@ -20,7 +18,7 @@ def draw_roc_auc_curve_total(input_dict, type):
                 fpr,
                 tpr,
                 "o-",
-                color=Config.COLORS[i],
+                color=StaticValue.COLORS[i],
                 label=label_name+str(round(auc(fpr, tpr), 2))
             )
 
@@ -40,7 +38,7 @@ def draw_roc_auc_curve_total(input_dict, type):
                 fpr,
                 tpr,
                 "o-",
-                color=Config.COLORS[i],
+                color=StaticValue.COLORS[i],
                 label=label_name + str(round(auc(fpr, tpr), 2))
             )
 

visualization/draw_scatter.py

@@ -1,9 +1,7 @@
-import numpy as np
 import matplotlib.pyplot as plt
+import numpy as np
 from mpl_toolkits.mplot3d import Axes3D
 
-from coding.llh.static.config import Config
-
 
 # Draw scatter
 def draw_scatter_2D(x_data, y_data, centers, title):

visualization/draw_scatter_line_graph.py

@@ -1,7 +1,7 @@
-import numpy as np
 import matplotlib.pyplot as plt
+import numpy as np
 
-from static.config import Config
+from classes.static_custom_class import *
 
 
 # draw scatter line graph
@@ -15,9 +15,9 @@ def draw_scatter_line_graph(x_data, y_pred_data, y_real_data, coef, intercept, l
     fig, ax = plt.subplot_mosaic(layout, figsize=(16, 16))
 
     for i in range(np.size(x_data, 1)):
-        ax[str(chr(i+65))].scatter(x_data[:, i], y_pred_data.T, color=Config.COLORS[0], s=4, label=labels[0])
-        ax[str(chr(i+65))].scatter(x_data[:, i], y_real_data, color=Config.COLORS[1], s=4, label=labels[1])
-        ax[str(chr(i+65))].plot(x_data[:, i], x_data[:, i] * coef[i] + intercept, color=Config.COLORS[2], markersize=4)
+        ax[str(chr(i+65))].scatter(x_data[:, i], y_pred_data.T, color=StaticValue.COLORS[0], s=4, label=labels[0])
+        ax[str(chr(i+65))].scatter(x_data[:, i], y_real_data, color=StaticValue.COLORS[1], s=4, label=labels[1])
+        ax[str(chr(i+65))].plot(x_data[:, i], x_data[:, i] * coef[i] + intercept, color=StaticValue.COLORS[2], markersize=4)
         ax[str(chr(i + 65))].legend()
 
     plt.suptitle(title)

visualization/draw_swings_and_positives.py

@@ -1,9 +1,4 @@
-import numpy as np
 import matplotlib.pyplot as plt
-from sklearn.metrics import *
-from sklearn.preprocessing import label_binarize
-
-from coding.llh.static.config import Config
 
 
 def draw_swings_and_positives(df, p1_name, p2_name):