2024/03/07/22:40

analysis/model_train/bayes_model.py

@@ -41,24 +41,24 @@ class NaiveBayesClassifierParams:
 
 
 # 朴素贝叶斯分类
-def naive_bayes_classifier(container, params_list, model=None):
+def naive_bayes_classifier(container, params, 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)
+    params = transform_params_list(NaiveBayesClassifierParams, params, model)
 
     if model == "MultinomialNB":
         naive_bayes_model = MultinomialNB()
-        params = params_list
+        params = params
     elif model == "GaussianNB":
         naive_bayes_model = GaussianNB()
-        params = params_list
+        params = params
     elif model == "ComplementNB":
         naive_bayes_model = ComplementNB()
-        params = params_list
+        params = params
     else:
         naive_bayes_model = GaussianNB()
-        params = params_list
+        params = params
 
     if hyper_params_optimize == "grid_search":
         best_model = grid_search(params, naive_bayes_model, x_train, y_train)

analysis/model_train/distance_model.py

@@ -28,14 +28,13 @@ class KNNClassifierParams:
 
 
 # KNN分类
-def knn_classifier(container, params_list):
+def knn_classifier(container, params):
     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)
+    params = transform_params_list(KNNClassifierParams, params)
 
     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)
@@ -87,14 +86,13 @@ class KNNRegressionParams:
 
 
 # KNN回归
-def knn_regressor(container, params_list):
+def knn_regressor(container, params):
     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)
+    params = transform_params_list(KNNRegressionParams, params)
 
     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)

analysis/model_train/gradient_model.py

@@ -17,7 +17,6 @@ class GradientBoostingParams:
             'max_depth': StaticValue.INT,
             'min_samples_split': StaticValue.INT,
             'min_samples_leaf': StaticValue.INT,
-            'random_state': StaticValue.INT
         }
 
     @classmethod
@@ -28,19 +27,18 @@ class GradientBoostingParams:
             '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):
+def gradient_boosting_regressor(container, params):
     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)
+    params = transform_params_list(GradientBoostingParams, params)
+    params['random_state'] = [StaticValue.RANDOM_STATE]
 
     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)

analysis/model_train/kernel_model.py

@@ -31,14 +31,13 @@ class SVMRegressionParams:
 
 
 # 支持向量机回归
-def svm_regressor(container, params_list):
+def svm_regressor(container, params):
     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)
+    params = transform_params_list(SVMRegressionParams, params)
 
     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)
@@ -79,7 +78,6 @@ class SVMClassifierParams:
             "C": StaticValue.FLOAT,
             "kernel": StaticValue.STR,
             "gamma": StaticValue.FLOAT,
-            'random_state': StaticValue.INT
         }
 
     @classmethod
@@ -88,19 +86,18 @@ class SVMClassifierParams:
             "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):
+def svm_classifier(container, params):
     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)
+    params = transform_params_list(SVMClassifierParams, params)
+    params['random_state'] = [StaticValue.RANDOM_STATE]
 
     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)

analysis/model_train/linear_model.py

@@ -23,7 +23,6 @@ class LinearRegressionParams:
             return {
                 "fit_intercept": StaticValue.BOOL,
                 "alpha": StaticValue.FLOAT,
-                "random_state": StaticValue.INT
             }
         else:
             return {
@@ -36,7 +35,6 @@ class LinearRegressionParams:
             return {
                 "fit_intercept": [True, False],
                 "alpha": [0.001, 0.01, 0.1, 1.0, 10.0],
-                "random_state": [StaticValue.RANDOM_STATE]
             }
         else:
             return {
@@ -45,27 +43,28 @@ class LinearRegressionParams:
 
 
 # 线性回归
-def linear_regressor(container, params_list, model=None):
+def linear_regressor(container, params, 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)
+    params = transform_params_list(LinearRegressionParams, params, model)
+    params['random_state'] = [StaticValue.RANDOM_STATE]
 
     if model == "Lasso":
         linear_regression_model = Lasso(alpha=0.1, random_state=StaticValue.RANDOM_STATE)
-        params = input_params
+        params = params
     elif model == "Ridge":
         linear_regression_model = Ridge(alpha=0.1, random_state=StaticValue.RANDOM_STATE)
-        params = input_params
+        params = params
     elif model == "ElasticNet":
         linear_regression_model = ElasticNet(alpha=0.1, random_state=StaticValue.RANDOM_STATE)
-        params = input_params
+        params = params
     elif model == "LinearRegression":
         linear_regression_model = LinearRegression()
-        params = input_params
+        params = params
     else:
         linear_regression_model = LinearRegression()
-        params = input_params
+        params = params
 
     try:
         if hyper_params_optimize == "grid_search":
@@ -126,18 +125,17 @@ class PolynomialRegressionParams:
 
 
 # 多项式回归
-def polynomial_regressor(container, params_list):
+def polynomial_regressor(container, params):
     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)
+    params = transform_params_list(PolynomialRegressionParams, params)
 
     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)
@@ -186,7 +184,6 @@ class LogisticRegressionParams:
             "C": StaticValue.FLOAT,
             "max_iter": StaticValue.INT,
             "solver": StaticValue.STR,
-            "random_state": StaticValue.INT
         }
 
     @classmethod
@@ -195,19 +192,18 @@ class LogisticRegressionParams:
             "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):
+def logistic_classifier(container, params):
     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)
+    params = transform_params_list(LogisticRegressionParams, params)
+    params['random_state'] = [StaticValue.RANDOM_STATE]
 
     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)

analysis/model_train/tree_model.py

@@ -21,7 +21,6 @@ class RandomForestRegressionParams:
             'max_depth': StaticValue.INT,
             'min_samples_split': StaticValue.INT,
             'min_samples_leaf': StaticValue.INT,
-            'random_state': StaticValue.INT
         }
 
     @classmethod
@@ -31,19 +30,18 @@ class RandomForestRegressionParams:
             '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):
+def random_forest_regressor(container, params):
     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)
+    params = transform_params_list(RandomForestRegressionParams, params)
+    params['random_state'] = [StaticValue.RANDOM_STATE]
 
     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)
@@ -86,7 +84,6 @@ class DecisionTreeClassifierParams:
             "max_depth": StaticValue.INT,
             "min_samples_split": StaticValue.INT,
             "min_samples_leaf": StaticValue.INT,
-            'random_state': StaticValue.INT
         }
 
     @classmethod
@@ -97,19 +94,18 @@ class DecisionTreeClassifierParams:
             "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):
+def decision_tree_classifier(container, params):
     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)
+    params = transform_params_list(DecisionTreeClassifierParams, params)
+    params['random_state'] = [StaticValue.RANDOM_STATE]
 
     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)
@@ -151,7 +147,6 @@ class RandomForestClassifierParams:
             "max_depth": StaticValue.INT,
             "min_samples_split": StaticValue.INT,
             "min_samples_leaf": StaticValue.INT,
-            "random_state": StaticValue.INT
         }
 
     @classmethod
@@ -162,19 +157,18 @@ class RandomForestClassifierParams:
             "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):
+def random_forest_classifier(container, params):
     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)
+    params = transform_params_list(RandomForestClassifierParams, params)
+    params['random_state'] = [StaticValue.RANDOM_STATE]
 
     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)
@@ -219,7 +213,6 @@ class XgboostClassifierParams:
             "gamma": StaticValue.FLOAT,
             "subsample": StaticValue.FLOAT,
             "colsample_bytree": StaticValue.FLOAT,
-            "random_state": StaticValue.INT
         }
 
     @classmethod
@@ -232,19 +225,18 @@ class XgboostClassifierParams:
             "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):
+def xgboost_classifier(container, params):
     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)
+    params = transform_params_list(XgboostClassifierParams, params)
+    params['random_state'] = [StaticValue.RANDOM_STATE]
 
     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)
@@ -285,14 +277,14 @@ class LightGBMClassifierParams:
 
 
 # lightGBM分��
-def lightGBM_classifier(container, params_list):
+def lightGBM_classifier(container, params):
     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)
+    params = transform_params_list(LightGBMClassifierParams, params)
+    params['random_state'] = [StaticValue.RANDOM_STATE]
 
     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)