2024/03/09/11:50

analysis/bayes_model.py

@@ -1,82 +0,0 @@
-from sklearn.model_selection import learning_curve
-from sklearn.naive_bayes import *
-import numpy as np
-
-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
-
-
-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 = {}
-
-    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)
-
-    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/descriptive_analysis.py

@@ -1,303 +0,0 @@
-
-from datetime import datetime
-
-import json
-import sys
-import numpy as np
-import pandas as pd
-import math
-import time as sys_time
-
-from coding.llh.visualization.draw_boxplot import draw_boxplot
-from coding.llh.visualization.draw_heat_map import draw_heat_map
-from coding.llh.visualization.draw_histogram import draw_histogram
-from coding.llh.visualization.draw_histogram_line_subgraph import draw_histogram_line_subgraph
-from coding.llh.visualization.draw_line_graph import draw_line_graph
-from tqdm import tqdm
-
-
-# 0202:
-def data_transformation_extra(df: pd.DataFrame, str2int_mappings: dict) -> (pd.DataFrame):
-
-    # Delete "match_id" column
-    # df.drop("match_id", axis=1, inplace=True)
-    df["match_id"] = df["match_id"].apply(lambda x: x[-4:])
-
-    # Dissolve the two-mode data mapping into two part
-
-    value_to_replace_dict = {
-        "AD": "50"
-    }
-
-    value_to_replace = "AD"
-    df["p1_score"].replace(value_to_replace, value_to_replace_dict[value_to_replace], inplace=True)
-    df["p2_score"].replace(value_to_replace, value_to_replace_dict[value_to_replace], inplace=True)
-
-    str2int_mappings_to_dissolve = {
-        "p1_score": {"0": 0},
-        "p2_score": {"0": 0}
-    }
-
-    df["p1_score_mark"] = 0
-    df["p2_score_mark"] = 0
-
-    for key in str2int_mappings_to_dissolve.keys():
-        for i in range(1, len(df)):
-            if df.loc[i, key] == "15" and df.loc[i-1, key] == "0":
-                df.loc[i, key+"_mark"] = 1
-            elif df.loc[i, key] == "1" and df.loc[i-1, key] == "0":
-                df.loc[i, key + "_mark"] = 2
-
-    df["p1_score_normal"] = 0
-    df["p1_score_tiebreak"] = 0
-    df["p2_score_normal"] = 0
-    df["p2_score_tiebreak"] = 0
-
-    normal_counter = 0
-    tiebreak_counter = 0
-    for key in str2int_mappings_to_dissolve.keys():
-        for i in range(0, len(df)):
-            if df.loc[i, key] == "0":
-                normal_counter = 0
-                tiebreak_counter = 0
-                continue
-
-            if df.loc[i, key+"_mark"] == 1 or normal_counter > 0:
-                if int(df.loc[i, key]) > int(df.loc[i-1, key]):
-                    normal_counter += 1
-                    df.loc[i, key + "_normal"] = normal_counter
-                    if df.loc[i, key] == value_to_replace_dict[value_to_replace]:
-                        str2int_mappings_to_dissolve[key][value_to_replace] = normal_counter
-                    else:
-                        str2int_mappings_to_dissolve[key][df.loc[i, key]] = normal_counter
-
-                elif int(df.loc[i, key]) < int(df.loc[i-1, key]):
-                    normal_counter -= 1
-                    df.loc[i, key + "_normal"] = normal_counter
-
-                else:
-                    df.loc[i, key + "_normal"] = normal_counter
-
-            elif df.loc[i, key+"_mark"] == 2 or tiebreak_counter > 0:
-                if int(df.loc[i, key]) > int(df.loc[i - 1, key]):
-                    tiebreak_counter += 1
-                    df.loc[i, key+"_tiebreak"] = tiebreak_counter
-                    if df.loc[i, key] == value_to_replace_dict[value_to_replace]:
-                        str2int_mappings_to_dissolve[key][value_to_replace] = tiebreak_counter
-                    else:
-                        str2int_mappings_to_dissolve[key][df.loc[i, key]] = tiebreak_counter
-
-                elif int(df.loc[i, key]) < int(df.loc[i - 1, key]):
-                    tiebreak_counter -= 1
-                    df.loc[i, key+"_tiebreak"] = tiebreak_counter
-
-                else:
-                    df.loc[i, key + "_tiebreak"] = tiebreak_counter
-
-    str2int_mappings.update(str2int_mappings_to_dissolve)
-
-    df.drop("p1_score_mark", axis=1, inplace=True)
-    df.drop("p2_score_mark", axis=1, inplace=True)
-    df.drop("p1_score", axis=1, inplace=True)
-    df.drop("p2_score", axis=1, inplace=True)
-
-    # Transform "elapsed_time" time column
-
-    def transform_time_col(time: str):
-        h, m, s = time.strip().split(":")
-        seconds = int(h) * 3600 + int(m) * 60 + int(s)
-        return seconds
-
-    df["elapsed_time"] = df["elapsed_time"].apply(transform_time_col)
-
-    # Calculate "game_victor", "set_victor" column cumulative value
-
-    df["p1_game_victor"] = df.apply(lambda x: 1 if x["game_victor"] == 1 else 0, axis=1)
-    df["p2_game_victor"] = df.apply(lambda x: 1 if x["game_victor"] == 2 else 0, axis=1)
-    df["p1_set_victor"] = df.apply(lambda x: 1 if x["set_victor"] == 1 else 0, axis=1)
-    df["p2_set_victor"] = df.apply(lambda x: 1 if x["set_victor"] == 2 else 0, axis=1)
-
-    df["p1_game_victor"] = df.groupby(["player1", "player2"])["p1_game_victor"].cumsum()
-    df["p2_game_victor"] = df.groupby(["player1", "player2"])["p2_game_victor"].cumsum()
-    df["p1_set_victor"] = df.groupby(["player1", "player2"])["p1_set_victor"].cumsum()
-    df["p2_set_victor"] = df.groupby(["player1", "player2"])["p2_set_victor"].cumsum()
-
-    # Forced conversion of data types
-    for col in df.columns.values:
-        df[col] = df[col].astype("float")
-
-    # Save the mappings to a json format file
-    with open("./data/mappings.json", "w", encoding="utf-8") as f:
-        json.dump(str2int_mappings, f, indent=4, ensure_ascii=False)
-
-    return df
-
-
-def data_transformation(df: pd.DataFrame) -> (pd.DataFrame, dict):
-    """
-    0.
-    1. Define mappings
-    2. Create mappings
-    3. Modify the original data according to the mappings
-    4. Get type exception
-    5. Forced conversion of data types
-    """
-
-    info = {}
-
-    # Define mappings
-    str2int_mappings = {
-        "player1": {},
-        "player2": {},
-        "winner_shot_type": {},
-        "serve_width": {},
-        "serve_depth": {},
-        "return_depth": {}
-    }
-
-    # Create mappings
-    for col in str2int_mappings.copy():
-        keys = np.array(df[col].drop_duplicates())
-        values = [x for x in range(len(keys))]
-        str2int_mappings[col] = dict(zip(keys, values))
-
-    # Modify the original data according to the mappings
-    for col, mapping in str2int_mappings.items():
-        series = df[col]
-
-        for k, v in mapping.items():
-            series.replace(k, v, inplace=True)
-        df[col] = series
-
-    df.replace('Not A Number', 0, inplace=True)
-
-    # Get type exception
-
-    # abnormal_type_values = []
-    #
-    # for col in df.columns.values:
-    #     if col not in str2int_mappings.keys():
-    #         for row in df[col]:
-
-    #             if not (0 <= row <= sys.maxsize):
-    #                 abnormal_type_values.append(row)
-    #
-    # info["Number of abnormal type value"] = sorted(abnormal_type_values)
-
-
-    # # Forced conversion of data types
-    # for col in df.columns.values:
-    #     df[col] = df[col].astype("float")
-    #
-    # # Save the mappings to a json format file
-    # with open("./mappings.json", "w", encoding="utf-8") as f:
-    #     json.dump(str2int_mappings, f, indent=4, ensure_ascii=False)
-
-
-    # 0202:
-    df = data_transformation_extra(df, str2int_mappings)
-
-    return df, info
-
-
-# Get descriptive indicators and filtered data based on boxplpot
-def get_descriptive_indicators_related(df):
-    info = {}
-
-    descriptive_indicators_df = pd.DataFrame(
-        index=list(df.columns.values),
-        columns=[
-            "Min",
-            "Max",
-            "Avg",
-            "Standard Deviation",
-            "Standard Error",
-            "Upper Quartile",
-            "Median",
-            "Lower Quartile",
-            "Interquartile Distance",
-            "Kurtosis",
-            "Skewness",
-            "Coefficient of Variation"
-        ]
-    )
-
-    for col in df.columns.values:
-        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]
-
-    # draw_heat_map(descriptive_indicators_df.to_numpy(), "descriptive indicators", True)
-    #
-    # draw_boxplot(df, "descriptive indicators boxplot")
-
-    len_0 = len(df)
-
-    # tmp_df = \
-    # df[(df >= (descriptive_indicators_df["Lower Quartile"] - 1.5 * (descriptive_indicators_df["Upper Quartile"] -
-    #                                                                 descriptive_indicators_df["Lower Quartile"])))
-    #    & (df <= (descriptive_indicators_df["Upper Quartile"] + 1.5 * (descriptive_indicators_df["Upper Quartile"] -
-    #                                                                   descriptive_indicators_df["Lower Quartile"])))][[
-    #     "ProductChoice", "MembershipPoints", "ModeOfPayment", "ResidentCity", "PurchaseTenure", "IncomeClass",
-    #     "CustomerPropensity", "CustomerAge", "LastPurchaseDuration"
-    # ]]
-
-    # tmp_df.dropna(inplace=True)
-
-    # df = pd.concat([tmp_df, df[["ProductChoice", "Channel", "MartialStatus"]]], axis=1, join="inner")
-
-    # df = pd.concat([df.iloc[:, :9], df.iloc[:, 10:]], axis=1)
-
-    # info["Number of offsetting value"] = len_0 - len(df)
-    #
-    # info["Total size of filtered data after descriptive analysis"] = len(df)
-
-    return df, info
-
-
-# Create images of the distribution of the number of each variable
-def variable_distribution(df):
-    counts_mappings = {}
-    print("counts analysis")
-    for col in tqdm(df.columns.values, desc='columns:'):
-        counts_mapping = {}
-        for x in tqdm(df[col], desc='cells'):
-            if x in counts_mapping.keys():
-                counts_mapping[x] += 1
-            else:
-                counts_mapping[x] = 1
-        counts_mappings[col] = counts_mapping
-
-    total_data_for_plot = []
-    print("plotting")
-    for col, mapping in tqdm(counts_mappings.items(), desc='columns'):
-        if col in ["set_no", 'game_no']:
-            sorting = sorted(mapping.items(), reverse=True, key=lambda m: m[0])
-            data = [x[1] for x in sorting]
-            labels = [x[0] for x in sorting]
-
-            total_data_for_plot.append(["line_graph", labels, data, col])
-            draw_line_graph(labels, data, col)
-        else:
-            sorting = sorted(mapping.items(), reverse=True, key=lambda m: m[1])
-            data = [x[1] for x in sorting]
-            labels = [x[0] for x in sorting]
-
-            will_rotate = True if col in ["player1","player2", "match_id"] else False
-            will_show_text = False if col in ["ResidentCity"] else True
-
-            total_data_for_plot.append(["histogram", data, labels, will_rotate, will_show_text, col])
-            draw_histogram(data, labels, will_rotate, will_show_text, col)
-    # draw_histogram_line_subgraph(total_data_for_plot)

analysis/distance_model.py

@@ -1,115 +0,0 @@
-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/evaluation_model.py

@@ -1,99 +0,0 @@
-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/exploratory_analysis.py

@@ -1,130 +0,0 @@
-import numpy as np
-import sklearn.metrics
-from sklearn.cluster import KMeans
-from factor_analyzer.factor_analyzer import calculate_bartlett_sphericity
-from factor_analyzer.factor_analyzer import calculate_kmo
-
-from coding.llh.visualization.draw_heat_map import draw_heat_map
-from coding.llh.visualization.draw_scatter import draw_scatter_2D, draw_scatter_2D_1, draw_scatter_3D_1, draw_scatter_3D
-
-
-# K-means
-def k_means(array: np.ndarray):
-    info = {}
-
-    draw_scatter_2D_1(array, "2D scatter data before k-means")
-    draw_scatter_3D_1(array, "3D scatter data before k-means")
-
-    K = 60
-
-    info["Number of clustering centers"] = K
-
-    k_means_model = KMeans(n_clusters=K, init='k-means++')
-
-    k_means_model.fit(array)
-
-    sum_of_squared_errors = k_means_model.inertia_
-
-    info["SSE"] = sum_of_squared_errors
-
-    draw_scatter_2D(array, k_means_model.labels_, k_means_model.cluster_centers_, "2D scatter data after k-means")
-    draw_scatter_3D(array, k_means_model.labels_, k_means_model.cluster_centers_, "3D scatter data after k-means")
-
-    result = k_means_model.fit_predict(array[:200])
-
-    silhouette_score = sklearn.metrics.silhouette_score(array[:200], result)
-
-    info["Silhouette score"] = silhouette_score
-
-    return info
-
-
-# Bartlett sphericity test
-def bartlett_test(df):
-    _, p_value = calculate_bartlett_sphericity(df)
-
-    return p_value
-
-
-# KMO test
-def kmo_test(df):
-    _, kmo_score = calculate_kmo(df)
-
-    return kmo_score
-
-
-# Principal component analysis
-def pca(df):
-    # Only consider the correlation of the independent variables
-    info = {}
-
-    # array_x = df.iloc[:, 1:]
-    array_x = df.iloc[:, :]
-    array_y = df.iloc[:, :1]
-
-    # Bartlett sphericity test
-    p_value = bartlett_test(array_x)
-    info["p value of bartlett sphericity test"] = p_value
-    if p_value < 0.05:
-        info["Result of bartlett sphericity test"] = "Accept"
-    else:
-        info["Result of bartlett sphericity test"] = "Reject"
-
-    # KMO test
-    kmo_score = kmo_test(array_x)
-    info["Score of KMO test"] = kmo_score
-    if kmo_score > 0.5:
-        info["Result of KMO test"] = "Accept"
-    else:
-        info["Result of KMO test"] = "Reject"
-
-    # get the matrix of correlation coefficients
-    covX = np.around(np.corrcoef(array_x.T), decimals=3)
-
-    # 计算协方差矩阵的对角线元素的标准差
-    std_dev = np.sqrt(np.diag(covX))
-
-    # 计算皮尔逊相关系数矩阵
-    pearson_matrix = covX / np.outer(std_dev, std_dev)
-
-    # draw_heat_map(pearson_matrix, "pearson matrix", True, df.columns.values)
-
-    # Solve the eigenvalues and eigenvectors of the coefficient correlation matrix
-    eigenvalues, eigenvectors = np.linalg.eig(covX.T)
-
-    eigenvalues = np.around(eigenvalues, decimals=3)
-
-    eigenvalues_dict = dict(zip(eigenvalues.tolist(), list(range(0, len(eigenvalues)))))
-
-    # Sort feature values in descending order
-    eigenvalues = sorted(eigenvalues, reverse=True)
-
-    for i, value in enumerate(eigenvalues):
-        if i == 0:
-            sorted_eigenvectors = eigenvectors[:, eigenvalues_dict[value]].reshape(-1, 1)
-        else:
-            sorted_eigenvectors = np.concatenate((sorted_eigenvectors, eigenvectors[:, eigenvalues_dict[value]].reshape(-1, 1)), axis=1)
-
-    # draw_line_graph(range(1, len(eigenvalues) + 1), eigenvalues, "Eigenvalue")
-
-    # get the contribution of the eigenvalues
-    contribution = eigenvalues / np.sum(eigenvalues)
-
-    # get the cumulative contribution of the eigenvalues
-    cumulative_contribution = np.cumsum(contribution)
-
-    # Selection of principal components
-    main_factors_index = [i for i in range(len(cumulative_contribution)) if cumulative_contribution[i] < 0.80]
-
-    main_factor_num = len(main_factors_index)
-
-    info["Main factor num"] = main_factor_num
-
-    # Get the projection matrix
-    projected_array = array_x.dot(sorted_eigenvectors[:, :main_factor_num])
-    projected_array = np.concatenate((array_y.values, projected_array), axis=1)
-
-    return projected_array, info
-
-
-

analysis/gaussian_model.py

@@ -1,28 +0,0 @@
-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/gradient_model.py

@@ -1,65 +0,0 @@
-import numpy as np
-from sklearn.ensemble import GradientBoostingRegressor
-from sklearn.model_selection import learning_curve
-
-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 = {}
-
-    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, 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/kernel_model.py

@@ -1,119 +0,0 @@
-import numpy as np
-from sklearn.model_selection import learning_curve
-from sklearn.svm import SVC
-from sklearn.svm import SVR
-
-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 = {}
-
-    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, 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(cls):
-        return {
-            "C": [0.1, 1, 10, 100],
-            "kernel": ['linear', 'rbf', 'poly'],
-            "gamma": [0.1, 1, 10]
-        }
-
-
-# 支持向量机分类
-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 = {}
-
-    svm_classifier_model = SVC(kernel="rbf")
-    params = SVMClassifierParams.get_params()
-
-    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/linear_model.py

@@ -1,217 +0,0 @@
-import numpy as np
-from sklearn.linear_model import LinearRegression
-from sklearn.preprocessing import PolynomialFeatures
-from sklearn.linear_model import Lasso
-from sklearn.linear_model import Ridge
-from sklearn.linear_model import ElasticNet
-from sklearn.linear_model import LogisticRegression
-from sklearn.pipeline import Pipeline
-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 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]
-            }
-
-
-# 线性回归
-def linear_regression(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 = {}
-
-    if model == "Lasso":
-        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, random_state=Config.RANDOM_STATE)
-        params = LinearRegressionParams.get_params(model)
-    elif model == "ElasticNet":
-        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 = LinearRegressionParams.get_params(model)
-
-    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)
-
-    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(cls):
-        return {
-            "polynomial_features__degree": [2, 3],
-            "linear_regression_model__fit_intercept": [True, False]
-        }
-
-
-# 多项式回归
-def polynomial_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 = {}
-
-    polynomial_features = PolynomialFeatures(degree=2)
-    linear_regression_model = LinearRegression()
-
-    polynomial_regression_model = Pipeline([("polynomial_features", polynomial_features),
-                                            ("linear_regression_model", linear_regression_model)])
-    params = PolynomialRegressionParams.get_params()
-
-    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(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
-    x_test = container.x_test
-    y_test = container.y_test
-    hyper_params_optimize = container.hyper_params_optimize
-    info = {}
-
-    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)
-    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/markov_model.py

@@ -1,98 +0,0 @@
-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/model_train/tree_model.py

@@ -99,21 +99,12 @@ class DecisionTreeClassifierParams:
 
 # 决策树分类
 def decision_tree_classifier(container, params):
-    import logging
-    logging.basicConfig(level=logging.NOTSET)
-    logging.info(str(params), logging.getLevelName(logging.INFO))
-    print(str(params))
-
-
     x_train, y_train, x_test, y_test, hyper_params_optimize = get_values_from_container_class(container)
     info = {}
 
     params = transform_params_list(DecisionTreeClassifierParams, params)
     params['random_state'] = [StaticValue.RANDOM_STATE]
 
-    logging.info(str(params), logging.getLevelName(logging.INFO))
-    print(str(params))
-
     random_forest_regression_model = DecisionTreeClassifier(random_state=StaticValue.RANDOM_STATE)
 
     if hyper_params_optimize == "grid_search":

analysis/my_learning_curve.py

@@ -1,33 +0,0 @@
-import numpy as np
-import matplotlib.pyplot as plt
-from sklearn.metrics import r2_score
-from sklearn.model_selection import train_test_split
-from sklearn.metrics import accuracy_score
-
-from coding.llh.metrics.calculate_regression_metrics import calculate_ar2
-
-
-def my_learning_curve(estimator, X, y, cv=5):
-    train_sizes = np.linspace(0.1, 1.0, 10)[:-1]
-    train_scores = []
-    val_scores = []
-
-    for train_size in train_sizes:
-        # Split the dataset into training and validation sets
-        X_train, X_val, y_train, y_val = train_test_split(X, y, train_size=train_size, random_state=42)
-
-        # Train the model on the training set
-        # estimator.fit(X_train, y_train)
-
-        # Evaluate the model on the training set
-        y_train_pred = estimator.predict(X_train)
-        train_accuracy = r2_score(y_train, y_train_pred)
-        train_scores.append(train_accuracy)
-
-        # Evaluate the model on the validation set
-        y_val_pred = estimator.predict(X_val)
-        val_accuracy = r2_score(y_val, y_val_pred)
-        val_scores.append(val_accuracy)
-
-    return train_sizes, train_scores, val_scores
-

analysis/neural_model.py

@@ -1,321 +0,0 @@
-import matplotlib.pyplot as plt
-import numpy as np
-import pandas as pd
-import torch
-import torch.nn as nn
-from sklearn import preprocessing
-from torch.utils.data import TensorDataset
-from tqdm import tqdm
-import json
-import os
-import warnings
-from sklearn.neural_network import MLPRegressor
-
-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 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 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
-
-warnings.filterwarnings("ignore")
-
-
-def mlp_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):
-    info = {}
-    model_name = "mlp regression model"
-
-    model = MLPRegressor()
-    params = {
-        'hidden_layer_sizes': [(50,), (100,), (50, 50), (100, 50)],
-        'activation': ['relu', 'tanh', 'logistic'],
-        'alpha': [0.0001, 0.001, 0.01],
-        'learning_rate': ['constant', 'invscaling', 'adaptive'],
-        'max_iter': [100, 200, 300]
-    }
-
-    if hyper_params_optimize == "grid_search":
-        best_model = grid_search(params, model, x_train_and_validate, y_train_and_validate)
-    elif hyper_params_optimize == "bayes_search":
-        best_model = bayes_search(params, model, x_train_and_validate, y_train_and_validate)
-    else:
-        best_model = model
-        best_model.fit(x, y)
-
-    info["{} Params".format(model_name)] = best_model.get_params()
-
-    y_pred = best_model.predict(x_test).reshape(-1, 1)
-
-    # 0202:
-
-    train_sizes, train_scores, test_scores = learning_curve(best_model, x[:500], y[:500], cv=5, scoring="r2")
-
-    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)
-
-    # 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)
-
-    # shap_calculate(best_model, x_test, feature_names)
-
-    return info, train_sizes, train_scores_mean, train_scores_std, test_scores_mean, test_scores_std
-
-
-def ann(df):
-    # 参数初始化
-    lr = 0.0001
-    batch_size = 32
-    input_dim = 10
-    output_dim = 4
-    epochs = 40
-    best_acc = 0
-    save_path = "./model/model.pth"
-
-    # 硬件定义
-    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    print("Device loaded for training: [{}]".format(device))
-
-    # 数据集分割
-    def split_data(data: pd.DataFrame):
-        data = np.array(data)
-
-        dataX = data[:, 1:]
-        dataY = data[:, :1]
-
-        dataX = np.array(dataX)
-        dataY = np.array(dataY)
-
-        total_size = dataX.shape[0]
-        train_size = int(np.round(0.8 * total_size))
-
-        x_train = dataX[: train_size, :]
-        y_train = dataY[: train_size]
-
-        x_test = dataX[train_size:, :]
-        y_test = dataY[train_size:]
-
-        return x_train, y_train, x_test, y_test, total_size, train_size
-
-    x_train, y_train, x_test, y_test, total_size, train_size = split_data(df)
-
-    # 数据预处理
-    x_train = preprocessing.scale(x_train)
-    x_test = preprocessing.scale(x_test)
-
-    y_train = y_train - 1
-    y_test = y_test - 1
-
-    # 数据格式转换
-    x_train_tensor = torch.from_numpy(x_train).to(torch.float32)
-    y_train_tensor = torch.from_numpy(y_train).to(torch.float32)
-    x_test_tensor = torch.from_numpy(x_test).to(torch.float32)
-    y_test_tensor = torch.from_numpy(y_test).to(torch.float32)
-
-    train_data = TensorDataset(x_train_tensor, y_train_tensor)
-    test_data = TensorDataset(x_test_tensor, y_test_tensor)
-
-    train_loader = torch.utils.data.DataLoader(train_data, batch_size, True)
-    test_loader = torch.utils.data.DataLoader(test_data, batch_size, False)
-
-    print("Data loaded for training: [{}]".format(len(train_data)))
-    print("Data loaded for testing: [{}]".format(len(test_data)))
-
-    # 模型定义
-    class ANN(nn.Module):
-        def __init__(self, input_dim, output_dim):
-            super(ANN, self).__init__()
-
-            self.hidden1 = nn.Sequential(
-                nn.Linear(input_dim, 16, bias=True),
-                nn.ReLU()
-            )
-            self.hidden2 = nn.Sequential(
-                nn.Linear(16, 32, bias=True),
-                nn.ReLU()
-            )
-            self.hidden3 = nn.Sequential(
-                nn.Linear(32, 64, bias=True),
-                nn.ReLU()
-            )
-            self.hidden4 = nn.Sequential(
-                nn.Linear(64, 128, bias=True),
-                nn.ReLU()
-            )
-            self.hidden5 = nn.Sequential(
-                nn.Linear(128, 256, bias=True),
-                nn.ReLU()
-            )
-            self.hidden6 = nn.Sequential(
-                nn.Linear(256, 512, bias=True),
-                nn.ReLU()
-            )
-            self.hidden7 = nn.Sequential(
-                nn.Linear(512, 1024, bias=True),
-                nn.ReLU()
-            )
-            self.hidden8 = nn.Sequential(
-                nn.Linear(1024, output_dim, bias=True),
-                nn.Softmax()
-            )
-
-        def forward(self, x):
-            x = self.hidden1(x)
-            x = self.hidden2(x)
-            x = self.hidden3(x)
-            x = self.hidden4(x)
-            x = self.hidden5(x)
-            x = self.hidden6(x)
-            x = self.hidden7(x)
-            x = self.hidden8(x)
-
-            return x
-
-    model = ANN(input_dim, output_dim).to(device)
-    print("Model set: [{}]".format(model))
-
-    # 损失函数定义
-    criterion = nn.CrossEntropyLoss()
-    print("Criterion set: [{}]".format(type(criterion)))
-
-    # 优化器定义
-    optimizer = torch.optim.Adam(model.parameters(), lr)
-    print("Optimizer set: [{}]".format(type(optimizer)))
-    print()
-
-    if os.path.isfile(save_path):
-        # 模型加载
-        state_dict = torch.load(save_path)
-        model.load_state_dict(state_dict, strict=False)
-        print("!Model loaded")
-
-        with open("./model/best_acc.json", "r") as f:
-            print("Best accuracy of current model: [{}]".format(json.load(f)))
-
-    else:
-        print("!Training starting\n")
-
-        train_loss_list = []
-        train_acc_list = []
-        test_loss_list = []
-        test_acc_list = []
-
-        y_pred_list = []
-        y_real_list = []
-
-        for epoch in range(epochs):
-            # 模型训练
-            model.train()
-
-            train_loss = 0
-            train_acc = 0
-            train_acc_count = 0
-            train_count = 0
-            train_bar = tqdm(train_loader)
-            for data in train_bar:
-                x_train, y_train = data
-                x_train = x_train.to(device)
-                y_train = y_train.to(device)
-                # 优化器重置
-                optimizer.zero_grad()
-                # 前向传播
-                output = model(x_train)
-                # 计算误差
-                loss = criterion(output, y_train.reshape(-1).long())
-                # 反向传播：更新梯度
-                loss.backward()
-                # 反向传播：更新参数
-                optimizer.step()
-
-                train_loss += loss.item()
-                train_bar.desc = "Train epoch[{}/{}] loss: {:.3f}".format(epoch + 1, epochs, loss)
-                train_acc_count += (output.argmax(axis=1) == y_train.view(-1).int()).sum().item()
-                train_count += len(x_train)
-
-            train_acc = train_acc_count / train_count
-
-            # 模型测试
-            model.eval()
-
-            test_loss = 0
-            test_acc = 0
-            test_acc_count = 0
-            test_count = 0
-            with torch.no_grad():
-                test_bar = tqdm(test_loader)
-                for data in test_bar:
-                    x_test, y_test = data
-                    x_test = x_test.to(device)
-                    y_test = y_test.to(device)
-                    # 前向传播
-                    output = model(x_test)
-
-                    y_pred_list.append(output.tolist())
-                    y_real_list.append(y_test.tolist())
-
-                    # 计算误差
-                    loss = criterion(output, y_test.reshape(-1).long())
-
-                    test_loss += loss.item()
-                    test_bar.desc = "Test epoch[{}/{}] loss: {:.3f}".format(epoch + 1, epochs, loss)
-                    test_acc_count += (output.argmax(axis=1) == y_test.view(-1).int()).sum().item()
-                    test_count += len(x_test)
-
-                test_acc = test_acc_count / test_count
-
-            print("\nEpoch: {}".format(epoch + 1))
-            print("Train_loss: {:.4f}".format(train_loss))
-            print("Train_accuracy: {:.4f}".format(train_acc))
-            print("Test_loss: {:.4f}".format(test_loss))
-            print("Test_accuracy: {:.4f}".format(test_acc))
-            print("\n")
-
-            train_loss_list.append(train_loss)
-            train_acc_list.append(train_acc)
-            test_loss_list.append(test_loss)
-            test_acc_list.append(test_acc)
-
-            # 保存当前最优模型和最优准确率值
-            if test_acc > best_acc:
-                best_acc = test_acc
-                with open("./model/info.json", "w") as f:
-                    json.dump({
-                        "best_acc": [best_acc],
-                        "train_loss_list": train_loss_list,
-                        "train_acc_list": train_acc_list,
-                        "test_loss_list": test_loss_list,
-                        "test_acc_list": test_acc_list,
-                        "y_pred_list": y_pred_list,
-                        "y_real_list": y_real_list
-                    }, f)
-
-                torch.save(model.state_dict(), save_path)
-
-        print("\n!Training finished")
-        print("Best accuracy: {:.4f}".format(best_acc))
-
-        # 数据可视化
-        draw_line_graph(
-            range(len(y_pred_list)),
-            [y_pred_list, y_real_list],
-            "ANN prediction",
-            ["predict, real"]
-        )
-

analysis/others/evaluation_model.py

@@ -1,99 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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/poly_model.py

@@ -1,12 +0,0 @@
-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,55 +0,0 @@
-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
-
-
-
-

analysis/tree_model.py

@@ -1,290 +0,0 @@
-from metrics.calculate_regression_metrics import calculate_regression_metrics
-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
-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 = {}
-
-    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, 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(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]
-        }
-
-
-# 决策树分类
-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 = {}
-
-    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, 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(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(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, 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(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)
-
-    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: 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 = {}
-
-    lightgbm_classifier_model = lightGBMClassifier
-    params = LightGBMClassifierParams.get_params()
-
-    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/two_exponential_smoothing_model.py

@@ -1,48 +0,0 @@
-import matplotlib.pyplot as plt
-
-
-# 双指数平滑
-def double_exponential_smoothing(series, alpha, beta):
-    """
-        series - dataset with timeseries
-        alpha - float [0.0, 1.0], smoothing parameter for level
-        beta - float [0.0, 1.0], smoothing parameter for trend
-    """
-    # first value is same as series
-    result = [series[0]]
-    for n in range(1, len(series) + 1):
-        if n == 1:
-            level, trend = series[0], series[1] - series[0]
-        if n >= len(series):  # forecasting
-            value = result[-1]
-        else:
-            value = series[n]
-        last_level, level = level, alpha * value + (1 - alpha) * (level + trend)
-        trend = beta * (level - last_level) + (1 - beta) * trend
-        result.append(level + trend)
-    return result
-
-
-def plotDoubleExponentialSmoothing(series, alphas, betas):
-    """
-        Plots double exponential smoothing with different alphas and betas
-
-        series - dataset with timestamps
-        alphas - list of floats, smoothing parameters for level
-        betas - list of floats, smoothing parameters for trend
-    """
-
-    with plt.style.context('seaborn-white'):
-        plt.figure(figsize=(13, 5))
-        for alpha in alphas:
-            for beta in betas:
-                plt.plot(double_exponential_smoothing(series, alpha, beta),
-                         label="Alpha {}, beta {}".format(alpha, beta))
-        plt.plot(series.values, label="Actual")
-        plt.legend(loc="best")
-        plt.axis('tight')
-        plt.title("Double Exponential Smoothing")
-        plt.grid(True)
-
-
-plotDoubleExponentialSmoothing(data['trend'], alphas=[0.5, 0.3], betas=[0.9, 0.3])

functions/process.py

@@ -3,6 +3,9 @@ def get_values_from_container_class(container):
 
 
 def transform_params_list(params_class, params_list, model=None):
+    # test
+    print("params_class: {}, params_list: {}".format(str(params_class), str(params_list)))
+
     input_params_keys = []
     input_params_values = []
     inner_value_list = []
@@ -18,21 +21,24 @@ def transform_params_list(params_class, params_list, model=None):
             inner_value_list.append(param)
     else:
         input_params_values.append(inner_value_list)
-    input_params = dict(zip(input_params_keys, input_params_values))
+    params = dict(zip(input_params_keys, input_params_values))
 
-    for k, v in input_params.items():
+    for k, v in 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]]
+                    params[k] = [int(x) for x in params[k]]
                 elif value_type == "float":
-                    input_params[k] = [float(x) for x in input_params[k]]
+                    params[k] = [float(x) for x in params[k]]
                 elif value_type == "bool":
-                    input_params[k] = [x == "True" for x in input_params[k]]
+                    params[k] = [x == "True" for x in params[k]]
                 elif value_type == "str":
-                    input_params[k] = [str(x) for x in input_params[k]]
+                    params[k] = [str(x) for x in params[k]]
             except Exception:
-                input_params[k] = [str(x) for x in input_params[k]]
+                params[k] = [str(x) for x in params[k]]
+
+    # test
+    print("params: {}".format(str(params)))
 
-    return input_params
+    return params

static/col.py

@@ -1,68 +0,0 @@
-def get_pca_col():
-    return [
-        "p1_momentum_value_better",
-        "elapsed_time",
-        "server",
-        "serve_no",
-        "p1_ace",
-        "p2_ace",
-        "p1_winner",
-        "p2_winner",
-        "winner_shot_type",
-        # "p1_double_fault",
-        "p2_double_fault",
-        "p1_unf_err",
-        "p2_unf_err",
-        "p1_net_pt",
-        "p2_net_pt",
-        "p1_net_pt_won",
-        "p2_net_pt_won",
-        "p1_break_pt",
-        "p2_break_pt",
-        "p1_break_pt_won",
-        "p2_break_pt_won",
-        "p1_break_pt_missed",
-        "p2_break_pt_missed",
-        "p1_distance_run",
-        "p2_distance_run",
-        "rally_count",
-        "speed_mph",
-        "serve_width",
-        "serve_depth",
-        "return_depth"
-    ]
-
-
-def get_momentum_col(p):
-    return [
-        "point_victor",
-        "elapsed_time",
-        "server",
-        "serve_no",
-        "{}_ace".format(p),
-        # "p2_ace",
-        "{}_winner".format(p),
-        # "p2_winner",
-        "winner_shot_type",
-        # "p1_double_fault",
-        # "p2_double_fault",
-        "{}_unf_err".format(p),
-        # "p2_unf_err",
-        "{}_net_pt".format(p),
-        # "p2_net_pt",
-        "{}_net_pt_won".format(p),
-        # "p2_net_pt_won",
-        "{}_break_pt".format(p),
-        # "p2_break_pt",
-        "{}_break_pt_won".format(p),
-        # "p2_break_pt_won",
-        "{}_break_pt_missed".format(p),
-        # "p2_break_pt_missed",
-        "{}_distance_run".format(p),
-        # "p2_distance_run",
-        "rally_count",
-        "speed_mph",
-        "serve_width",
-        "serve_depth",
-        "return_depth"
-    ]

static/config.py

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

static/new_class.py

@@ -1,195 +0,0 @@
-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/paint.py

@@ -1,51 +0,0 @@
-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

static/process.py

@@ -1,326 +0,0 @@
-import numpy as np
-from sklearn.model_selection import train_test_split
-from sklearn.model_selection import KFold
-from sklearn import preprocessing
-from sklearn.model_selection import GridSearchCV
-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, load_wine, load_breast_cancer, load_diabetes
-from scipy.linalg import eig
-
-from static.config import Config
-
-
-def match_split(df: pd.DataFrame):
-    return df.groupby("match_id")
-
-
-# 斯皮尔曼秩相关系数
-def calculate_spearmanr(x, y):
-    rho, p_value = spearmanr(x, y)
-
-    return rho, p_value
-
-
-def calculate_remain_positive_points(df: pd.DataFrame):
-    # remain_positive距离无限远设置为len(df)
-
-    df["p1_remain_positive"] = 0
-    df["p2_remain_positive"] = 0
-    p1_zero_distance_list = []
-    p2_zero_distance_list = []
-
-    for i in range(1, len(df)):
-        if (df.loc[i, "p1_momentum_value_better"] > 0
-            and i != 0):
-            p1_zero_distance_list.append(i)
-        elif (df.loc[i, "p1_momentum_value_better"] < 0
-            and i != 0):
-            p2_zero_distance_list.append(i)
-
-    for j in range(len(df)):
-        for x in p1_zero_distance_list:
-            if j <= x:
-                df.loc[j, "p1_remain_positive"] = x - j
-                break
-        else:
-            continue
-
-    for j in range(len(df)):
-        for x in p2_zero_distance_list:
-            if j <= x:
-                df.loc[j, "p2_remain_positive"] = x - j
-                break
-        else:
-            continue
-
-    return df
-
-
-def calculate_swing_point(df:pd.DataFrame):
-    # swing距离无限远设置为len(df)
-
-    df["swing"] = 0
-    zero_distance_list = []
-
-    for i in range(1, len(df)):
-        if (df.loc[i, "p1_momentum_value_better"] > 0 and df.loc[i-1, "p1_momentum_value_better"] < 0
-            and i != 0) or (df.loc[i, "p1_momentum_value_better"] < 0 and df.loc[i - 1, "p1_momentum_value_better"] > 0
-             and i != 0):
-            zero_distance_list.append(i)
-
-    for j in range(len(df)):
-        for x in zero_distance_list:
-            if j <= x:
-                df.loc[j, "swing"] = x - j
-                break
-        else:
-            continue
-
-    return df
-
-
-def replace_na_to_label(df: pd.DataFrame):
-    return df.fillna("Not A Number")
-
-
-def get_state_distribution(data):
-    # get the matrix of correlation coefficients
-    covX = np.around(np.corrcoef(data.T), decimals=3)
-
-    # draw_heat_map(covX, "related", False)
-
-    # Solve the eigenvalues and eigenvectors of the coefficient correlation matrix
-    eigenvalues, eigenvectors = np.linalg.eig(covX.T)
-
-    eigenvalues = np.around(eigenvalues, decimals=3)
-
-    eigenvalues_dict = dict(zip(eigenvalues.tolist(), list(range(0, len(eigenvalues)))))
-
-    # Sort feature values in descending order
-    eigenvalues = sorted(eigenvalues, reverse=True)
-
-    for i, value in enumerate(eigenvalues):
-        if i == 0:
-            sorted_eigenvectors = eigenvectors[:, eigenvalues_dict[value]].reshape(-1, 1)
-        else:
-            sorted_eigenvectors = np.concatenate((sorted_eigenvectors, eigenvectors[:, eigenvalues_dict[value]].reshape(-1, 1)), axis=1)
-
-    # draw_line_graph(range(1, len(eigenvalues) + 1), eigenvalues, "Eigenvalue")
-
-    # get the contribution of the eigenvalues
-    contribution = eigenvalues / np.sum(eigenvalues)
-
-    return contribution
-
-
-# 指数加权平均
-def exponential_moving_average(df):
-    alpha = 0.3
-
-    ema = [df[0]]
-
-    for i in range(1, len(df)):
-        ema_value = alpha * df[i] + (1 - alpha) * ema[i-1]
-        ema.append(ema_value)
-
-    return ema
-
-
-def need_to_mark_in_plot(df, col_name):
-    return df.where(df[col_name] == 1).dropna()
-
-
-def point_victor_mapping(df):
-    mapping = {
-        1: 0.0,
-        2: 1.0
-    }
-    df["point_victor"] = df["point_victor"].map(mapping)
-
-    return df
-
-
-def pick_matches_with_name(df, name):
-    df = df.where(df["match_id"] == name).dropna()
-
-    p1_name = df["player1"].iloc[0]
-    p2_name = df["player2"].iloc[0]
-
-    return df, p1_name, p2_name
-
-
-def pick_matches_with_longest(df):
-    target_match_id = df.groupby("match_id").size().idxmax()
-
-    df = df.where(df["match_id"] == target_match_id).dropna()
-
-    p1_name = df["player1"].iloc[0]
-    p2_name = df["player2"].iloc[0]
-
-    return df, p1_name, p2_name
-
-
-def choose_y_col_in_dataframe(df: pd.DataFrame, y_col: str):
-    y_data = df[y_col]
-    df.drop(y_col, axis=1, inplace=True)
-    df.insert(0, y_col, y_data)
-
-    return df
-
-
-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"
-
-    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
-
-    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)
-
-    df = pd.DataFrame(data=sk_data, columns=sk_feature_names)
-
-    return df
-
-
-def load_custom_data(file):
-    if "xlsx" in file or "xls" in file:
-        return pd.read_excel(file)
-    elif "csv" in file:
-        return pd.read_csv(file)
-
-
-def preprocess_raw_data_filtering(df):
-    info = {}
-
-    len_0 = len(df)
-    info["Total size of raw data"] = len_0
-
-    # Delete the column "CUSTOMER_ID"
-    # df.drop("CUSTOMER_ID", axis=1, inplace=True)
-
-    # Remove duplicate data
-    df.drop_duplicates()
-    len_1 = len_0 - len(df)
-    info["Number of duplicates in the raw data"] = len_1
-
-    # Remove "nan" data
-    # df = remove_nan_from_data(df)
-    # len_2 = len_0 - len_1 - len(df)
-    # info["Number of nan in the raw data"] = len_2
-
-    info["Total size of filtered data after data preprocessing"] = len(df)
-
-    # Save the cleaned data to a csv format file
-    # df.to_csv("../data/filtered_data.csv", index=False)
-
-    return df, info
-
-
-def remove_nan_from_data(df):
-    # Remove "nan" data
-    df.dropna(inplace=True)
-
-    return df
-
-
-# Get standardized data
-def get_standardized_data(df):
-    array = np.concatenate(((df.iloc[:, :1]).values, preprocessing.scale(df.iloc[:, 1:])), axis=1)
-
-    return array
-
-
-def split_dataset(array):
-    x_train_and_validate, x_test, y_train_and_validate, y_test = train_test_split(
-        array[:, 1:],
-        array[:, :1],
-        random_state=Config.RANDOM_STATE,
-        train_size=0.8
-    )
-
-    return x_train_and_validate, x_test, y_train_and_validate, y_test
-
-
-def k_fold_cross_validation_data_segmentation(x_train, y_train):
-    k = 5
-
-    train_data_array = np.concatenate((y_train, x_train), axis=1)
-
-    k_fold = KFold(n_splits=k, shuffle=True, random_state=Config.RANDOM_STATE)
-
-    train_data_list = []
-    validate_data_list = []
-    for train_index, validate_index in k_fold.split(train_data_array):
-        train_data_list.append(train_data_array[train_index])
-        validate_data_list.append(train_data_array[validate_index])
-
-    train_and_validate_data_list = []
-
-    for i in range(k):
-        train_and_validate_data_list.append((
-            train_data_list[i][:, 1:],
-            validate_data_list[i][:, 1:],
-            train_data_list[i][:, 0],
-            validate_data_list[i][:, 0]
-        ))
-
-    return train_and_validate_data_list
-
-
-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
-
-