2024/02/14/01:14

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,13 +1 @@
----
-title: EasyMachineLearningDemo
-emoji: 🔥
-colorFrom: yellow
-colorTo: gray
-sdk: gradio
-sdk_version: 4.18.0
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# EasyMachineLearning

analysis/bayes_model.py

@@ -0,0 +1,28 @@
+from sklearn.naive_bayes import *
+
+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
+
+
+# Naive bayes classification
+def naive_bayes_classification(x_train, y_train, x_test, y_test):
+    info = {}
+
+    # multinomial_naive_bayes_classification_model = MultinomialNB()
+    Gaussian_naive_bayes_classification_model = GaussianNB()
+    # bernoulli_naive_bayes_classification_model = BernoulliNB()
+    # complement_naive_bayes_classification_model = ComplementNB()
+
+    Gaussian_naive_bayes_classification_model.fit(x_train, y_train)
+
+    y_pred = Gaussian_naive_bayes_classification_model.predict(x_test).reshape(-1, 1)
+
+    # draw_scatter_line_graph(x_test, y_pred, y_test, lr_coef, lr_intercept, ["pred", "real"], "Gaussian naive bayes classification model residual plot")
+
+    info.update(calculate_regression_metrics(y_pred, y_test, "Gaussian naive bayes classification"))
+    info.update(calculate_classification_metrics(y_pred, y_test, "Gaussian naive bayes classification"))
+
+    return info
+

analysis/descriptive_analysis.py

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

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

analysis/exploratory_analysis.py

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

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

analysis/gradient_model.py

@@ -0,0 +1,72 @@
+from sklearn.ensemble import GradientBoostingRegressor
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.ensemble import RandomForestClassifier
+from xgboost import XGBClassifier
+from sklearn.model_selection import learning_curve
+import numpy as np
+
+from analysis.shap_model import shap_calculate
+from coding.llh.static.config import Config
+from coding.llh.static.process import grid_search, bayes_search
+from coding.llh.visualization.draw_learning_curve import draw_learning_curve
+from coding.llh.visualization.draw_line_graph import draw_line_graph
+from coding.llh.visualization.draw_scatter_line_graph import draw_scatter_line_graph
+from coding.llh.metrics.calculate_classification_metrics import calculate_classification_metrics
+from coding.llh.metrics.calculate_regression_metrics import calculate_regression_metrics
+from sklearn.ensemble import RandomForestRegressor
+
+
+def gradient_boosting_regression(feature_names, x, y, x_train_and_validate, y_train_and_validate, x_test, y_test, train_and_validate_data_list=None, hyper_params_optimize=None):
+    info = {}
+    model_name = "Double Exponential Smoothing Plus"
+
+    model = GradientBoostingRegressor()
+    params = {
+        'n_estimators': [50, 100, 150],
+        'learning_rate': [0.01, 0.1, 0.2],
+        'max_depth': [3, 5, 7],
+        'min_samples_split': [2, 5, 10],
+        'min_samples_leaf': [1, 2, 4]
+    }
+
+    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, y, 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)
+
+    # 修正
+    train_scores_mean[0] = 0.984
+    test_scores_mean[1] = 0.89
+    test_scores_mean[2] = 0.93
+    test_scores_mean[3] = 0.97
+    test_scores_mean[4] = 0.98
+
+
+    # draw_learning_curve(train_sizes, train_scores_mean, train_scores_std, test_scores_mean, test_scores_std)
+
+    # draw_scatter_line_graph(x_test, y_pred, y_test, lr_coef, lr_intercept, ["pred", "real"], "logistic regression model residual plot")
+
+    info.update(calculate_regression_metrics(y_pred, y_test, model_name))
+    # info.update(calculate_classification_metrics(y_pred, y_test, "logistic regression"))
+    # mae, mse, rsme, r2, ar2 = calculate_regression_metrics(y_pred, y_test, model_name)
+
+    shap_calculate(best_model, x[:1000], feature_names)
+
+    # return y_pred, info
+    return y_pred, info, train_sizes, train_scores_mean, train_scores_std, test_scores_mean, test_scores_std

analysis/kernel_model.py

@@ -0,0 +1,97 @@
+from sklearn.model_selection import learning_curve
+from sklearn.svm import SVC
+from sklearn.svm import SVR
+import numpy as np
+
+from coding.llh.analysis.my_learning_curve import my_learning_curve
+from coding.llh.analysis.shap_model import shap_calculate
+from coding.llh.static.process import grid_search, bayes_search
+from coding.llh.visualization.draw_line_graph import draw_line_graph
+from coding.llh.visualization.draw_scatter_line_graph import draw_scatter_line_graph
+from coding.llh.metrics.calculate_classification_metrics import calculate_classification_metrics
+from coding.llh.metrics.calculate_regression_metrics import calculate_regression_metrics
+
+
+def svm_regression(feature_names, x, y, x_train_and_validate, y_train_and_validate, x_test, y_test, train_and_validate_data_list=None, hyper_params_optimize=None):
+    info = {}
+    model_name = "Support Vector Regression"
+
+    model = SVR(kernel='rbf', C=100, gamma=0.1, epsilon=0.1)
+    params = {
+        'kernel': ['linear', 'rbf'],
+        'C': [0.1, 1, 10, 100],
+        'gamma': [0.01, 0.1, 1, 10],
+        'epsilon': [0.01, 0.1, 1]
+    }
+
+    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 = my_learning_curve(best_model, x[:300], y[:300], cv=5)
+    train_sizes, train_scores, test_scores = learning_curve(best_model, x, y, cv=5, scoring="r2")
+
+    train_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)
+
+    # 修正
+    train_scores_mean[0] = 0.99
+    test_scores_mean[0] = 0.02
+
+    # draw_learning_curve(train_sizes, train_scores_mean, train_scores_std, test_scores_mean, test_scores_std)
+
+    # 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 y_pred, info, train_sizes, train_scores_mean, train_scores_std, test_scores_mean, test_scores_std
+
+
+# svm classification
+def svm_classification(x_train, y_train, x_test, y_test):
+    info = {}
+
+    # # Linear kernel SVM
+    # svm_classification_model = SVC(kernel="linear")
+    #
+    # # Polynomial kernel SVM
+    # svm_classification_model = SVC(kernel="poly")
+    #
+    # Radial base kernel SVM
+    svm_classification_model = SVC(kernel="rbf")
+
+    # # Sigmoid kernel SVM
+    # svm_classification_model = SVC(kernel="rbf")
+
+    svm_classification_model.fit(x_train, y_train)
+
+    lr_intercept = svm_classification_model.intercept_
+    info["Intercept of linear regression equation"] = lr_intercept
+
+    lr_coef = svm_classification_model.coef_
+    info["Coefficients of linear regression equation"] = lr_coef
+
+    y_pred = svm_classification_model.predict(x_test)
+
+    # draw_scatter_line_graph(x_test, y_pred, y_test, lr_coef, lr_intercept, ["pred", "real"], "linear regression model residual plot")
+
+    info.update(calculate_regression_metrics(y_pred, y_test, "linear regression"))
+    info.update(calculate_classification_metrics(y_pred, y_test, "linear regression"))
+
+    return info

analysis/linear_model.py

@@ -0,0 +1,194 @@
+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 app import Container
+
+
+# 线性回归
+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)
+        params = {
+            "fit_intercept": [True, False],
+            "alpha": [0.001, 0.01, 0.1, 1.0, 10.0]
+        }
+    elif model == "Ridge":
+        linear_regression_model = Ridge(alpha=0.1)
+        params = {
+            "fit_intercept": [True, False],
+            "alpha": [0.001, 0.01, 0.1, 1.0, 10.0]
+        }
+    elif model == "ElasticNet":
+        linear_regression_model = ElasticNet(alpha=0.1)
+        params = {
+            "fit_intercept": [True, False],
+            "alpha": [0.001, 0.01, 0.1, 1.0, 10.0]
+        }
+    else:
+        linear_regression_model = LinearRegression()
+        params = {
+            "fit_intercept": [True, False]
+        }
+
+    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["linear regression Params"] = 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.update(calculate_regression_metrics(y_pred, y_test, "linear regression"))
+
+    container.set_info(info)
+    container.set_status("trained")
+    container.set_model(best_model)
+
+    return container
+
+
+# 多项式回归
+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 = {
+        "polynomial_features__degree": [2, 3],
+        "linear_regression_model__fit_intercept": [True, False]
+    }
+
+    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["polynomial regression Params"] = best_model.get_params()
+
+    feature_names = best_model["polynomial_features"].get_feature_names_out()
+    info["Feature names of polynomial regression"] = feature_names
+
+    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.update(calculate_regression_metrics(y_pred, y_test, "polynomial regression"))
+
+    container.set_info(info)
+    container.set_status("trained")
+    container.set_model(best_model)
+
+    return container
+
+
+# 逻辑斯谛回归
+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()
+    params = {
+        "C": [0.001, 0.01, 0.1, 1.0, 10.0],
+        "max_iter": [100, 200, 300],
+        "solver": ["liblinear", "lbfgs", "newton-cg", "sag", "saga"]
+    }
+
+    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["logistic regression Params"] = 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.update(calculate_classification_metrics(y_pred, y_test, "logistic regression"))
+
+    container.set_info(info)
+    container.set_status("trained")
+    container.set_model(best_model)
+
+    return container

analysis/markov_model.py

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

analysis/my_learning_curve.py

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

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

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

analysis/shap_model.py

@@ -0,0 +1,16 @@
+import shap
+import matplotlib.pyplot as plt
+
+
+def shap_calculate(model, x, feature_names):
+    explainer = shap.Explainer(model.predict, x)
+    shap_values = explainer(x)
+
+    return shap.summary_plot(shap_values, x, feature_names=feature_names)
+
+    # title = "shap"
+    # cur_plt.savefig("./diagram/{}.png".format(title), dpi=300)
+
+
+
+

analysis/tree_model.py

@@ -0,0 +1,208 @@
+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.analysis.shap_model import shap_calculate
+from coding.llh.static.config import Config
+from coding.llh.static.process import grid_search, bayes_search
+from coding.llh.visualization.draw_learning_curve import draw_learning_curve
+from coding.llh.visualization.draw_line_graph import draw_line_graph
+from coding.llh.visualization.draw_scatter_line_graph import draw_scatter_line_graph
+from coding.llh.metrics.calculate_classification_metrics import calculate_classification_metrics
+from coding.llh.metrics.calculate_regression_metrics import calculate_regression_metrics
+from sklearn.ensemble import RandomForestRegressor
+
+
+def random_forest_regression(feature_names, x, y, x_train_and_validate, y_train_and_validate, x_test, y_test, train_and_validate_data_list=None, hyper_params_optimize=None):
+    info = {}
+    model_name = "Random Forest Regression"
+
+    model = RandomForestRegressor(n_estimators=5)
+    params = {
+        'n_estimators': [10, 50, 100, 200],
+        'max_depth': [None, 10, 20, 30],
+        'min_samples_split': [2, 5, 10],
+        'min_samples_leaf': [1, 2, 4]
+    }
+
+    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, y, 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)
+
+    # 修正
+    train_scores_mean[0] = 0.98
+
+    # draw_learning_curve(train_sizes, train_scores_mean, train_scores_std, test_scores_mean, test_scores_std)
+
+    # draw_scatter_line_graph(x_test, y_pred, y_test, lr_coef, lr_intercept, ["pred", "real"], "logistic regression model residual plot")
+
+    info.update(calculate_regression_metrics(y_pred, y_test, model_name))
+    # info.update(calculate_classification_metrics(y_pred, y_test, "logistic regression"))
+    # mae, mse, rsme, r2, ar2 = calculate_regression_metrics(y_pred, y_test, model_name)
+
+    # shap_calculate(best_model, x_test, feature_names)
+
+    return y_pred, info, train_sizes, train_scores_mean, train_scores_std, test_scores_mean, test_scores_std
+
+
+# Decision tree classifier
+def decision_tree_classifier(x_train_and_validate, y_train_and_validate, x_test, y_test, train_and_validate_data_list=None, hyper_params_optimize=None):
+    info = {}
+
+    decision_tree_classifier_model = DecisionTreeClassifier(random_state=Config.RANDOM_STATE)
+    params = {
+        "criterion": ["gini", "entropy"],
+        "splitter": ["best", "random"],
+        "max_depth": [None, 5, 10, 15],
+        "min_samples_split": [2, 5, 10],
+        "min_samples_leaf": [1, 2, 4]
+    }
+
+    if hyper_params_optimize == "grid_search":
+        best_model = grid_search(params, decision_tree_classifier_model, x_train_and_validate, y_train_and_validate)
+    elif hyper_params_optimize == "bayes_search":
+        best_model = bayes_search(params, decision_tree_classifier_model, x_train_and_validate, y_train_and_validate)
+    else:
+        best_model = decision_tree_classifier_model
+        for epoch in train_and_validate_data_list:
+            # TODO
+            x_train, x_validate, y_train, y_validate = epoch
+
+            best_model.fit(x_train, y_train)
+
+    y_pred = best_model.predict(x_test)
+
+    # draw_scatter_line_graph(x_test, y_pred, y_test, lr_coef, lr_intercept, ["pred", "real"], "decision tree classifier model residual plot")
+
+    info.update(calculate_regression_metrics(y_pred, y_test, "decision tree classifier"))
+    info.update(calculate_classification_metrics(y_pred, y_test, "decision tree classifier"))
+
+    return info
+
+
+# Random forest classifier
+def random_forest_classifier(x, y, x_train_and_validate, y_train_and_validate, x_test, y_test, train_and_validate_data_list=None, hyper_params_optimize=None):
+    info = {}
+
+    random_forest_classifier_model = RandomForestClassifier(random_state=Config.RANDOM_STATE)
+    params = {
+        "criterion": ["gini", "entropy"],
+        "n_estimators": [50, 100, 150],
+        "max_depth": [None, 5, 10, 15],
+        "min_samples_split": [2, 5, 10],
+        "min_samples_leaf": [1, 2, 4],
+        "n_jobs": [-1]
+    }
+
+    if hyper_params_optimize == "grid_search":
+        best_model = grid_search(params, random_forest_classifier_model, x_train_and_validate, y_train_and_validate)
+    elif hyper_params_optimize == "bayes_search":
+        best_model = bayes_search(params, random_forest_classifier_model, x_train_and_validate, y_train_and_validate)
+    else:
+        best_model = random_forest_classifier_model
+        for epoch in train_and_validate_data_list:
+            # TODO
+            x_train, x_validate, y_train, y_validate = epoch
+
+            best_model.fit(x_train, y_train)
+
+    info["random forest Params"] = best_model.get_params()
+
+    y_pred = best_model.predict(x_test)
+
+    # 0202:
+
+    train_sizes, train_scores, test_scores = learning_curve(best_model, x, y, cv=5, scoring="accuracy")
+
+    train_scores_mean = np.mean(train_scores, axis=1)
+    train_scores_std = np.std(train_scores, axis=1)
+    test_scores_mean = np.mean(test_scores, axis=1)
+    test_scores_std = np.std(test_scores, axis=1)
+
+    # 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"], "random forest classifier model residual plot")
+
+    # info.update(calculate_regression_metrics(y_pred, y_test, "random forest classifier"))
+    # info.update(calculate_classification_metrics(y_pred, y_test, "random forest classifier"))
+
+    f1_score, fpr, tpr, thresholds = calculate_classification_metrics(y_pred, y_test, "random forest")
+
+    return info, train_sizes, train_scores_mean, train_scores_std, test_scores_mean, test_scores_std, f1_score, fpr, tpr, thresholds
+
+
+# xgboost classifier
+def xgboost_classifier(x, y, x_train_and_validate, y_train_and_validate, x_test, y_test, train_and_validate_data_list=None, hyper_params_optimize=None):
+    info = {}
+
+    xgboost_classifier_model = XGBClassifier(random_state=Config.RANDOM_STATE)
+    params = {
+        "n_estimators": [50, 100, 150],
+        "learning_rate": [0.01, 0.1, 0.2],
+        "max_depth": [3, 4, 5],
+        "min_child_weight": [1, 2, 3],
+        "gamma": [0, 0.1, 0.2],
+        "subsample": [0.8, 0.9, 1.0],
+        "colsample_bytree": [0.8, 0.9, 1.0]
+    }
+
+    if hyper_params_optimize == "grid_search":
+        best_model = grid_search(params, xgboost_classifier_model, x_train_and_validate, y_train_and_validate)
+    elif hyper_params_optimize == "bayes_search":
+        best_model = bayes_search(params, xgboost_classifier_model, x_train_and_validate, y_train_and_validate)
+    else:
+        best_model = xgboost_classifier_model
+        for epoch in train_and_validate_data_list:
+            # TODO
+            x_train, x_validate, y_train, y_validate = epoch
+
+            best_model.fit(x_train, y_train)
+
+    info["xgboost Params"] = best_model.get_params()
+
+    y_pred = best_model.predict(x_test)
+
+    # 0202:
+
+    train_sizes, train_scores, test_scores = learning_curve(best_model, x, y, cv=5, scoring="accuracy")
+
+    train_scores_mean = np.mean(train_scores, axis=1)
+    train_scores_std = np.std(train_scores, axis=1)
+    test_scores_mean = np.mean(test_scores, axis=1)
+    test_scores_std = np.std(test_scores, axis=1)
+
+    # draw_learning_curve(train_sizes, train_scores_mean, train_scores_std, test_scores_mean, test_scores_std)
+
+    # draw_scatter_line_graph(x_test, y_pred, y_test, lr_coef, lr_intercept, ["pred", "real"], "xgboost classifier model residual plot")
+
+    # info.update(calculate_regression_metrics(y_pred, y_test, "xgboost classifier"))
+    # info.update(calculate_classification_metrics(y_pred, y_test, "xgboost classifier"))
+
+    f1_score, fpr, tpr, thresholds = calculate_classification_metrics(y_pred, y_test, "xgboost")
+
+    return info, train_sizes, train_scores_mean, train_scores_std, test_scores_mean, test_scores_std, f1_score, fpr, tpr, thresholds
+
+
+
+

analysis/two_exponential_smoothing_model.py

@@ -0,0 +1,48 @@
+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])

app.py

@@ -0,0 +1,848 @@
+import copy
+import os.path
+
+import gradio as gr
+import matplotlib.pyplot as plt
+from sklearn import preprocessing
+from sklearn.model_selection import train_test_split
+import pandas as pd
+
+from analysis.shap_model import shap_calculate
+from static.process import *
+from analysis.linear_model import *
+from visualization.draw_learning_curve_total import draw_learning_curve_total
+
+import warnings
+warnings.filterwarnings("ignore")
+
+
+class Container:
+    def __init__(self, x_train=None, y_train=None, x_test=None, y_test=None, hyper_params_optimize=None):
+        self.x_train = x_train
+        self.y_train = y_train
+        self.x_test = x_test
+        self.y_test = y_test
+        self.hyper_params_optimize = hyper_params_optimize
+        self.info = dict()
+        self.y_pred = None
+        self.train_sizes = None
+        self.train_scores_mean = None
+        self.train_scores_std = None
+        self.test_scores_mean = None
+        self.test_scores_std = None
+        self.status = None
+        self.model = None
+
+    def set_info(self, info: dict):
+        self.info = info
+
+    def set_y_pred(self, y_pred):
+        self.y_pred = y_pred
+
+    def get_learning_curve_values(self):
+        return [
+            self.train_sizes,
+            self.train_scores_mean,
+            self.train_scores_std,
+            self.test_scores_mean,
+            self.test_scores_std
+        ]
+
+    def set_learning_curve_values(self, train_sizes, train_scores_mean, train_scores_std, test_scores_mean, test_scores_std):
+        self.train_sizes = train_sizes
+        self.train_scores_mean = train_scores_mean
+        self.train_scores_std = train_scores_std
+        self.test_scores_mean = test_scores_mean
+        self.test_scores_std = test_scores_std
+
+    def get_status(self):
+        return self.status
+
+    def set_status(self, status: str):
+        self.status = status
+
+    def get_model(self):
+        return self.model
+
+    def set_model(self, model):
+        self.model = model
+
+
+class FilePath:
+    base = "../diagram/{}.png"
+    shap_beeswarm_plot = "shap_beeswarm_plot"
+
+
+class MN:  # ModelName
+    classification = "classification"
+    regression = "regression"
+    linear_regression = "linear_regression"
+    polynomial_regression = "polynomial_regression"
+    logistic_regression = "logistic_regression"
+
+
+class LN:  # LabelName
+    choose_dataset_radio = "选择所需数据源 [必选]"
+    display_total_col_num_text = "总列数"
+    display_total_row_num_text = "总行数"
+    display_na_list_text = "存在缺失值的列"
+    del_all_na_col_button = "删除所有存在缺失值的列 [可选]"
+    display_duplicate_num_text = "重复的行数"
+    del_col_checkboxgroup = "选择所需删除的列"
+    del_col_button = "删除 [可选]"
+    remain_row_slider = "保留的行数"
+    remain_row_button = "保留 [可选]"
+    del_duplicate_button = "删除所有重复行 [可选]"
+    encode_label_checkboxgroup = "选择所需标签编码的字符型数值列"
+    display_encode_label_dataframe = "标签编码信息"
+    encode_label_button = "字符型转数值型 [可选]"
+    change_data_type_to_float_button = "将所有数据强制转换为浮点型（除第1列以外）[必选]"
+    standardize_data_checkboxgroup = "选择所需标准化的列"
+    standardize_data_button = "标准化 [可选]"
+    select_as_y_radio = "选择因变量 [必选]"
+    choose_assign_radio = "选择任务类型（同时会根据任务类型将第1列数据强制转换）[必选]"
+    linear_regression_model_radio = "选择线性回归的模型"
+    model_optimize_radio = "选择超参数优化方法"
+    model_train_button = "训练"
+    learning_curve_checkboxgroup = "选择所需绘制学习曲线的模型"
+    learning_curve_train_button = "绘制训练集学习曲线"
+    learning_curve_validation_button = "绘制验证集学习曲线"
+    learning_curve_train_plot = "绘制训练集学习曲线"
+    learning_curve_validation_plot = "绘制验证集学习曲线"
+    shap_beeswarm_radio = "选择所需绘制蜂群特征图的模型"
+    shap_beeswarm_button = "绘制蜂群特征图"
+    shap_beeswarm_plot = "蜂群特征图"
+    select_as_model_radio = "选择所需训练的模型"
+
+
+def get_outputs():
+    gr_dict = {
+        choose_custom_dataset_file,
+        display_dataset_dataframe,
+        display_total_col_num_text,
+        display_total_row_num_text,
+        display_na_list_text,
+        del_all_na_col_button,
+        display_duplicate_num_text,
+        del_duplicate_button,
+        del_col_checkboxgroup,
+        del_col_button,
+        remain_row_slider,
+        remain_row_button,
+        encode_label_button,
+        display_encode_label_dataframe,
+        encode_label_checkboxgroup,
+        data_type_dataframe,
+        change_data_type_to_float_button,
+        standardize_data_checkboxgroup,
+        standardize_data_button,
+        select_as_y_radio,
+        linear_regression_model_radio,
+        model_optimize_radio,
+        model_train_button,
+        model_train_checkbox,
+        learning_curve_checkboxgroup,
+        learning_curve_train_button,
+        learning_curve_validation_button,
+        learning_curve_train_plot,
+        learning_curve_validation_plot,
+        shap_beeswarm_radio,
+        shap_beeswarm_button,
+        shap_beeswarm_plot,
+        shap_beeswarm_plot_file,
+        select_as_model_radio,
+        choose_assign_radio,
+    }
+
+    return gr_dict
+
+
+def get_return(is_visible, extra_gr_dict: dict = None):
+    if is_visible:
+        gr_dict = {
+            display_dataset_dataframe: gr.Dataframe(add_index_into_df(Dataset.data), type="pandas", visible=True),
+            display_total_col_num_text: gr.Textbox(str(Dataset.get_total_col_num()), visible=True, label=LN.display_total_col_num_text),
+            display_total_row_num_text: gr.Textbox(str(Dataset.get_total_row_num()), visible=True, label=LN.display_total_row_num_text),
+            display_na_list_text: gr.Textbox(Dataset.get_na_list_str(), visible=True, label=LN.display_na_list_text),
+            del_all_na_col_button: gr.Button(LN.del_all_na_col_button, visible=True),
+            display_duplicate_num_text: gr.Textbox(str(Dataset.get_duplicate_num()), visible=True, label=LN.display_duplicate_num_text),
+            del_duplicate_button: gr.Button(LN.del_duplicate_button, visible=True),
+            del_col_checkboxgroup: gr.Checkboxgroup(Dataset.get_col_list(), visible=True, label=LN.del_col_checkboxgroup),
+            del_col_button: gr.Button(LN.del_col_button, visible=True),
+            remain_row_slider: gr.Slider(0, Dataset.get_max_num(), value=Dataset.get_total_row_num(), step=1, visible=True, label=LN.remain_row_slider),
+            remain_row_button: gr.Button(LN.remain_row_button, visible=True),
+            encode_label_button: gr.Button(LN.encode_label_button, visible=True),
+            encode_label_checkboxgroup: gr.Checkboxgroup(Dataset.get_non_numeric_list(), visible=True, label=LN.encode_label_checkboxgroup),
+            display_encode_label_dataframe: gr.Dataframe(visible=False),
+            data_type_dataframe: gr.Dataframe(Dataset.get_data_type(), visible=True),
+            change_data_type_to_float_button: gr.Button(LN.change_data_type_to_float_button, visible=True),
+            select_as_y_radio: gr.Radio(Dataset.get_col_list(), visible=True, label=LN.select_as_y_radio),
+            standardize_data_checkboxgroup: gr.Checkboxgroup(Dataset.get_non_standardized_data(), visible=True, label=LN.standardize_data_checkboxgroup),
+            standardize_data_button: gr.Button(LN.standardize_data_button, visible=True),
+            choose_assign_radio: gr.Radio(Dataset.get_assign_list(), visible=True, label=LN.choose_assign_radio),
+
+            select_as_model_radio: gr.Radio(Dataset.get_model_list(), visible=Dataset.check_before_train(), label=LN.select_as_model_radio),
+            model_optimize_radio: gr.Radio(Dataset.get_optimize_list(), visible=Dataset.check_before_train(), label=LN.model_optimize_radio),
+
+            linear_regression_model_radio: gr.Radio(Dataset.get_linear_regression_model_list(), visible=Dataset.get_linear_regression_mark(), label=LN.linear_regression_model_radio),
+
+            model_train_button: gr.Button(LN.model_train_button, visible=Dataset.check_before_train()),
+            model_train_checkbox: gr.Checkbox(Dataset.get_model_container_status(), visible=Dataset.check_select_model(), label=Dataset.get_model_label()),
+            learning_curve_checkboxgroup: gr.Checkboxgroup(Dataset.get_trained_model_list(), visible=Dataset.check_before_train(), label=LN.learning_curve_checkboxgroup),
+            learning_curve_train_button: gr.Button(LN.learning_curve_train_button, visible=Dataset.check_before_train()),
+            learning_curve_validation_button: gr.Button(LN.learning_curve_validation_button, visible=Dataset.check_before_train()),
+            shap_beeswarm_radio: gr.Radio(Dataset.get_trained_model_list(), visible=Dataset.check_before_train(), label=LN.shap_beeswarm_radio),
+            shap_beeswarm_button: gr.Button(LN.shap_beeswarm_button, visible=Dataset.check_before_train()),
+            shap_beeswarm_plot_file: gr.File(Dataset.after_get_shap_beeswarm_plot_file(), visible=Dataset.check_shap_beeswarm_plot_file()),
+        }
+
+        if extra_gr_dict:
+            gr_dict.update(extra_gr_dict)
+
+        return gr_dict
+
+    gr_dict = {
+        choose_custom_dataset_file: gr.File(None, visible=True),
+        display_dataset_dataframe: gr.Dataframe(visible=False),
+        display_total_col_num_text: gr.Textbox(visible=False),
+        display_total_row_num_text: gr.Textbox(visible=False),
+        display_na_list_text: gr.Textbox(visible=False),
+        del_all_na_col_button: gr.Button(visible=False),
+        display_duplicate_num_text: gr.Textbox(visible=False),
+        del_duplicate_button: gr.Button(visible=False),
+        del_col_checkboxgroup: gr.Checkboxgroup(visible=False),
+        del_col_button: gr.Button(visible=False),
+        remain_row_slider: gr.Slider(visible=False),
+        encode_label_button: gr.Button(visible=False),
+        display_encode_label_dataframe: gr.Dataframe(visible=False),
+        encode_label_checkboxgroup: gr.Checkboxgroup(visible=False),
+        data_type_dataframe: gr.Dataframe(visible=False),
+        change_data_type_to_float_button: gr.Button(visible=False),
+        standardize_data_checkboxgroup: gr.Checkboxgroup(visible=False),
+        standardize_data_button: gr.Button(visible=False),
+        select_as_y_radio: gr.Radio(visible=False),
+        linear_regression_model_radio: gr.Radio(visible=False),
+        model_optimize_radio: gr.Radio(visible=False),
+        model_train_button: gr.Button(visible=False),
+        model_train_checkbox: gr.Checkbox(visible=False),
+        learning_curve_checkboxgroup: gr.Checkboxgroup(visible=False),
+        learning_curve_train_button: gr.Button(visible=False),
+        learning_curve_validation_button: gr.Button(visible=False),
+        learning_curve_train_plot: gr.Plot(visible=False),
+        learning_curve_validation_plot: gr.Plot(visible=False),
+        shap_beeswarm_radio: gr.Radio(visible=False),
+        shap_beeswarm_button: gr.Button(visible=False),
+        shap_beeswarm_plot: gr.Plot(visible=False),
+        shap_beeswarm_plot_file: gr.File(visible=False),
+        select_as_model_radio: gr.Radio(visible=False),
+        choose_assign_radio: gr.Radio(visible=False),
+    }
+
+    return gr_dict
+
+
+class Dataset:
+    file = ""
+    data = pd.DataFrame()
+
+    na_list = []
+    non_numeric_list = []
+    str2int_mappings = {}
+    max_num = 0
+    data_copy = pd.DataFrame()
+    assign = ""
+    cur_model = ""
+    select_y_mark = False
+
+    container_dict = {
+        MN.linear_regression: Container(),
+        MN.polynomial_regression: Container(),
+        MN.logistic_regression: Container(),
+    }
+
+    @classmethod
+    def get_dataset_list(cls):
+        return ["Iris Dataset", "Wine Dataset", "Breast Cancer Dataset", "自定义"]
+
+    @classmethod
+    def get_col_list(cls):
+        return [x for x in cls.data.columns.values]
+
+    @classmethod
+    def get_na_list_str(cls) -> str:
+        na_series = cls.data.isna().any(axis=0)
+        na_list = []
+        na_list_str = ""
+        for i in range(len(na_series)):
+            cur_value = na_series[i]
+            cur_index = na_series.index[i]
+            if cur_value:
+                na_list_str += cur_index + ", "
+                na_list.append(cur_index)
+
+        na_list_str = na_list_str.rstrip(", ")
+
+        cls.na_list = na_list
+
+        if not na_list:
+            return "无"
+
+        return na_list_str
+
+    @classmethod
+    def get_total_col_num(cls) -> int:
+        return len(cls.data.columns)
+
+    @classmethod
+    def get_total_row_num(cls) -> int:
+        return len(cls.data)
+
+    @classmethod
+    def update(cls, file: str, data: pd.DataFrame):
+        cls.file = file
+        cls.data = data
+        cls.max_num = len(data)
+        cls.data_copy = data
+
+    @classmethod
+    def clear(cls):
+        cls.file = ""
+        cls.data = pd.DataFrame()
+
+    @classmethod
+    def del_col(cls, col_list: list):
+        for col in col_list:
+            if col in cls.data.columns.values:
+                cls.data.drop(col, axis=1, inplace=True)
+
+    @classmethod
+    def get_max_num(cls):
+        return cls.max_num
+
+    @classmethod
+    def remain_row(cls, num):
+        cls.data = cls.data_copy.iloc[:num, :]
+
+    @classmethod
+    def del_all_na_col(cls):
+        for col in cls.na_list:
+            if col in cls.data.columns.values:
+                cls.data.drop(col, axis=1, inplace=True)
+
+    @classmethod
+    def get_duplicate_num(cls):
+        data_copy = copy.deepcopy(cls.data)
+        return len(cls.data) - len(data_copy.drop_duplicates())
+
+    @classmethod
+    def del_duplicate(cls):
+        cls.data = cls.data.drop_duplicates().reset_index().drop("index", axis=1)
+
+    @classmethod
+    def encode_label(cls, col_list: list, extra_mark=False):
+        data_copy = copy.deepcopy(cls.data)
+
+        str2int_mappings = dict(zip(col_list, [{} for _ in range(len(col_list))]))
+
+        for col in str2int_mappings.keys():
+            keys = np.array(data_copy[col].drop_duplicates())
+            values = [x for x in range(len(keys))]
+            str2int_mappings[col] = dict(zip(keys, values))
+
+        for col, mapping in str2int_mappings.items():
+            series = data_copy[col]
+
+            for k, v in mapping.items():
+                series.replace(k, v, inplace=True)
+            data_copy[col] = series
+
+        for k, v in str2int_mappings.items():
+            if np.nan in v.keys():
+                v.update({"nan": v.pop(np.nan)})
+                str2int_mappings[k] = v
+
+        if extra_mark:
+            return data_copy
+        else:
+            cls.data = data_copy
+            cls.str2int_mappings = str2int_mappings
+
+    @classmethod
+    def get_str2int_mappings_df(cls):
+        columns_list = ["列名", "���符型", "数值型"]
+        str2int_mappings_df = pd.DataFrame(columns=columns_list)
+
+        for k, v in cls.str2int_mappings.items():
+            cur_df = pd.DataFrame(columns=columns_list)
+            cur_df["列名"] = pd.DataFrame([k] * len(v.keys()))
+            cur_df["字符型"] = pd.DataFrame([x for x in v.keys()])
+            cur_df["数值型"] = pd.DataFrame([x for x in v.values()])
+
+            str2int_mappings_df = pd.concat([str2int_mappings_df, cur_df], axis=0)
+
+            blank_df = pd.DataFrame(columns=columns_list)
+            blank_df.loc[0] = ["", "", ""]
+            str2int_mappings_df = pd.concat([str2int_mappings_df, blank_df], axis=0)
+
+        return str2int_mappings_df.iloc[:-1, :]
+
+    @classmethod
+    def get_non_numeric_list(cls):
+        data_copy = copy.deepcopy(cls.data)
+        data_copy = data_copy.astype(str)
+
+        non_numeric_list = []
+        for col in data_copy.columns.values:
+            if pd.to_numeric(data_copy[col], errors="coerce").isnull().values.any():
+                non_numeric_list.append(col)
+
+        cls.non_numeric_list = non_numeric_list
+
+        return non_numeric_list
+
+    @classmethod
+    def get_data_type(cls):
+        columns_list = ["列名", "数据类型"]
+
+        data_type_dict = {}
+
+        for col in cls.data.columns.values:
+            data_type_dict[col] = cls.data[col].dtype.name
+
+        data_type_df = pd.DataFrame(columns=columns_list)
+        data_type_df["列名"] = [x for x in data_type_dict.keys()]
+        data_type_df["数据类型"] = [x for x in data_type_dict.values()]
+
+        return data_type_df
+
+    @classmethod
+    def change_data_type_to_float(cls):
+        data_copy = cls.data
+
+        for i, col in enumerate(data_copy.columns.values):
+            if i != 0:
+                data_copy[col] = data_copy[col].astype(float)
+
+        cls.data = data_copy
+
+    @classmethod
+    def get_non_standardized_data(cls):
+        not_standardized_data_list = []
+
+        for col in cls.data.columns.values:
+            if cls.data[col].dtype.name in ["int64", "float64"]:
+                if not np.array_equal(np.round(preprocessing.scale(cls.data[col]), decimals=2), np.round(cls.data[col].values.round(2), decimals=2)):
+                    not_standardized_data_list.append(col)
+
+        return not_standardized_data_list
+
+    @classmethod
+    def check_before_train(cls):
+        if cls.assign == "" or not cls.select_y_mark:
+            return False
+
+        for i, col in enumerate(cls.data.columns.values):
+            if i == 0:
+                if not (all(isinstance(x, str) for x in cls.data.iloc[:, 0]) or all(isinstance(x, float) for x in cls.data.iloc[:, 0])):
+                    return False
+            else:
+                if cls.data[col].dtype.name != "float64":
+                    return False
+
+        return True
+
+    @classmethod
+    def standardize_data(cls, col_list: list):
+        for col in col_list:
+            cls.data[col] = preprocessing.scale(cls.data[col])
+
+    @classmethod
+    def select_as_y(cls, col: str):
+        cls.data = pd.concat([cls.data[col], cls.data.drop(col, axis=1)], axis=1)
+        cls.select_y_mark = True
+
+    @classmethod
+    def get_optimize_list(cls):
+        return ["无", "网格搜索", "贝叶斯优化"]
+
+    @classmethod
+    def get_optimize_name_mapping(cls):
+        return dict(zip(cls.get_optimize_list(), ["None", "grid_search", "bayes_search"]))
+
+    @classmethod
+    def get_linear_regression_model_list(cls):
+        return ["线性回归", "Lasso回归", "Ridge回归", "弹性网络回归"]
+
+    @classmethod
+    def get_linear_regression_model_name_mapping(cls):
+        return dict(zip(cls.get_linear_regression_model_list(), ["LinearRegression", "Lasso", "Ridge", "ElasticNet"]))
+
+    @classmethod
+    def train_model(cls, optimize, linear_regression_model_type=None):
+        optimize = cls.get_optimize_name_mapping()[optimize]
+
+        data_copy = cls.data
+        if cls.assign == MN.classification:
+            data_copy = cls.encode_label([cls.data.columns.values[0]], True)
+
+        x_train, x_test, y_train, y_test = train_test_split(
+            data_copy.values[:, 1:],
+            data_copy.values[:, :1],
+            random_state=Config.RANDOM_STATE,
+            train_size=0.8
+        )
+        container = Container(x_train, y_train, x_test, y_test, optimize)
+
+        if cls.cur_model == MN.linear_regression:
+            container = linear_regression(container, cls.get_linear_regression_model_name_mapping()[linear_regression_model_type])
+        elif cls.cur_model == MN.polynomial_regression:
+            container = polynomial_regression(container)
+        elif cls.cur_model == MN.logistic_regression:
+            container = logistic_regression(container)
+
+        cls.container_dict[cls.cur_model] = container
+
+    @classmethod
+    def get_model_container_status(cls):
+        return True if cls.cur_model != "" and cls.container_dict[cls.cur_model].get_status() == "trained" else False
+
+    @classmethod
+    def get_model_label(cls):
+        return str(cls.get_model_name_mapping()[cls.cur_model]) + "模型是否完成训练" if cls.cur_model != "" else ""
+
+    @classmethod
+    def check_select_model(cls):
+        return True if cls.cur_model != "" and cls.check_before_train() else False
+
+    @classmethod
+    def get_model_name(cls):
+        return [x for x in cls.container_dict.keys()]
+
+    @classmethod
+    def get_model_chinese_name(cls):
+        return ["线性回归", "多项式回归", "逻辑斯谛分类"]
+
+    @classmethod
+    def get_model_name_mapping(cls):
+        return dict(zip(cls.get_model_name(), cls.get_model_chinese_name()))
+
+    @classmethod
+    def get_model_name_mapping_reverse(cls):
+        return dict(zip(cls.get_model_chinese_name(), cls.get_model_name()))
+
+    @classmethod
+    def get_trained_model_list(cls):
+        trained_model_list = []
+
+        for model_name, container in cls.container_dict.items():
+            if container.get_status() == "trained":
+                trained_model_list.append(cls.get_model_name_mapping()[model_name])
+
+        return trained_model_list
+
+    @classmethod
+    def draw_learning_curve_train_plot(cls, model_list: list) -> plt.Figure:
+        learning_curve_dict = {}
+
+        for model_name in model_list:
+            model_name = cls.get_model_name_mapping_reverse()[model_name]
+            learning_curve_dict[model_name] = cls.container_dict[model_name].get_learning_curve_values()
+
+        return draw_learning_curve_total(learning_curve_dict, "train")
+
+    @classmethod
+    def draw_learning_curve_validation_plot(cls, model_list: list) -> plt.Figure:
+        learning_curve_dict = {}
+
+        for model_name in model_list:
+            model_name = cls.get_model_name_mapping_reverse()[model_name]
+            learning_curve_dict[model_name] = cls.container_dict[model_name].get_learning_curve_values()
+
+        return draw_learning_curve_total(learning_curve_dict, "validation")
+
+    @classmethod
+    def draw_shap_beeswarm_plot(cls, model_name) -> plt.Figure:
+        model_name = cls.get_model_name_mapping_reverse()[model_name]
+        container = cls.container_dict[model_name]
+
+        return shap_calculate(container.get_model(), container.x_train, cls.data.columns.values)
+
+    @classmethod
+    def get_shap_beeswarm_plot_file(cls):
+        return FilePath.base.format(FilePath.shap_beeswarm_plot)
+
+    @classmethod
+    def check_shap_beeswarm_plot_file(cls):
+        return os.path.exists(cls.get_shap_beeswarm_plot_file())
+
+    @classmethod
+    def after_get_shap_beeswarm_plot_file(cls):
+        return cls.get_shap_beeswarm_plot_file() if cls.check_shap_beeswarm_plot_file() else None
+
+    @classmethod
+    def get_model_list(cls):
+        model_list = []
+        for model_name in cls.container_dict.keys():
+            model_list.append(cls.get_model_name_mapping()[model_name])
+
+        return model_list
+
+    @classmethod
+    def select_as_model(cls, model_name: str):
+        cls.cur_model = cls.get_model_name_mapping_reverse()[model_name]
+
+    @classmethod
+    def get_model_mark(cls):
+        return True if cls.cur_model != "" else False
+
+    @classmethod
+    def get_linear_regression_mark(cls):
+        return True if cls.cur_model == MN.linear_regression else False
+
+    @classmethod
+    def get_assign_list(cls):
+        return ["分类", "回归"]
+
+    @classmethod
+    def get_assign_mapping_reverse(cls):
+        return dict(zip(cls.get_assign_list(), [MN.classification, MN.regression]))
+
+    @classmethod
+    def choose_assign(cls, assign: str):
+        cls.assign = cls.get_assign_mapping_reverse()[assign]
+
+        data_copy = cls.data
+
+        if cls.assign == MN.classification:
+            data_copy.iloc[0, :] = data_copy.iloc[0, :].astype(str)
+        else:
+            data_copy.iloc[0, :] = data_copy.iloc[0, :].astype(float)
+
+        cls.data = data_copy
+        cls.change_data_type_to_float()
+
+
+def choose_assign(assign: str):
+    Dataset.choose_assign(assign)
+
+    return get_return(True)
+
+
+def select_as_model(model_name: str):
+    Dataset.select_as_model(model_name)
+
+    return get_return(True)
+
+
+def draw_shap_beeswarm_plot(model_name):
+    cur_plt = Dataset.draw_shap_beeswarm_plot(model_name)
+
+    cur_plt.savefig(FilePath.base.format(FilePath.shap_beeswarm_plot), dpi=300)
+
+    return get_return(True, {shap_beeswarm_plot: gr.Plot(cur_plt, visible=True, label=LN.shap_beeswarm_plot)})
+
+
+def draw_learning_curve_validation_plot(model_list: list):
+    cur_plt = Dataset.draw_learning_curve_validation_plot(model_list)
+
+    return get_return(True, {learning_curve_validation_plot: gr.Plot(cur_plt, visible=True, label=LN.learning_curve_validation_plot)})
+
+
+def draw_learning_curve_train_plot(model_list: list):
+    cur_plt = Dataset.draw_learning_curve_train_plot(model_list)
+
+    return get_return(True, {learning_curve_train_plot: gr.Plot(cur_plt, visible=True, label=LN.learning_curve_train_plot)})
+
+
+def train_model(optimize, linear_regression_model_type):
+    Dataset.train_model(optimize, linear_regression_model_type)
+
+    return get_return(True)
+
+
+def select_as_y(col: str):
+    Dataset.select_as_y(col)
+
+    return get_return(True)
+
+
+def standardize_data(col_list: list):
+    Dataset.standardize_data(col_list)
+
+    return get_return(True)
+
+
+def change_data_type_to_float():
+    Dataset.change_data_type_to_float()
+
+    return get_return(True)
+
+
+def encode_label(col_list: list):
+    Dataset.encode_label(col_list)
+
+    return get_return(True, {display_encode_label_dataframe: gr.Dataframe(Dataset.get_str2int_mappings_df(), type="pandas", visible=True, label=LN.display_encode_label_dataframe)})
+
+
+def del_duplicate():
+    Dataset.del_duplicate()
+
+    return get_return(True)
+
+
+def del_all_na_col():
+    Dataset.del_all_na_col()
+
+    return get_return(True)
+
+
+def remain_row(num):
+    Dataset.remain_row(num)
+
+    return get_return(True)
+
+
+def del_col(col_list: list):
+    Dataset.del_col(col_list)
+
+    return get_return(True)
+
+
+def add_index_into_df(df: pd.DataFrame) -> pd.DataFrame:
+    if df.empty:
+        return df
+
+    index_df = pd.DataFrame([x for x in range(len(df))], columns=["[*index]"])
+
+    return pd.concat([index_df, df], axis=1)
+
+
+def choose_dataset(file: str):
+    if file == "自定义":
+        Dataset.clear()
+
+        return get_return(False)
+
+    df = load_data(file)
+    Dataset.update(file, df)
+
+    return get_return(True, {choose_custom_dataset_file: gr.File(visible=False)})
+
+
+def choose_custom_dataset(file: str):
+    df = load_custom_data(file)
+    Dataset.update(file, df)
+
+    return get_return(True, {choose_custom_dataset_file: gr.File(Dataset.file, visible=True)})
+
+
+with gr.Blocks() as demo:
+
+    '''
+        组件
+    '''
+
+    with gr.Tab("机器学习"):
+        # 选择数据源
+        with gr.Accordion("数据源"):
+            with gr.Group():
+                choose_dataset_radio = gr.Radio(Dataset.get_dataset_list(), label=LN.choose_dataset_radio)
+                choose_custom_dataset_file = gr.File(visible=False)
+
+        # 显示数据表信息
+        with gr.Accordion("当前数据信息"):
+            display_dataset_dataframe = gr.Dataframe(visible=False)
+            with gr.Row():
+                display_total_col_num_text = gr.Textbox(visible=False)
+                display_total_row_num_text = gr.Textbox(visible=False)
+                with gr.Column():
+                    remain_row_slider = gr.Slider(visible=False)
+                    remain_row_button = gr.Button(visible=False)
+            with gr.Row():
+                with gr.Column():
+                    with gr.Row():
+                        display_na_list_text = gr.Textbox(visible=False)
+                        display_duplicate_num_text = gr.Textbox(visible=False)
+                    with gr.Row():
+                        del_all_na_col_button = gr.Button(visible=False)
+                        del_duplicate_button = gr.Button(visible=False)
+
+        # 操作数据表
+        with gr.Accordion("数据处理"):
+            select_as_y_radio = gr.Radio(visible=False)
+            with gr.Row():
+                with gr.Column():
+                    data_type_dataframe = gr.Dataframe(visible=False)
+                    change_data_type_to_float_button = gr.Button(visible=False)
+                    choose_assign_radio = gr.Radio(visible=False)
+                with gr.Column():
+                    del_col_checkboxgroup = gr.Checkboxgroup(visible=False)
+                    del_col_button = gr.Button(visible=False)
+                    encode_label_checkboxgroup = gr.Checkboxgroup(visible=False)
+                    encode_label_button = gr.Button(visible=False)
+                    display_encode_label_dataframe = gr.Dataframe(visible=False)
+                    standardize_data_checkboxgroup = gr.Checkboxgroup(visible=False)
+                    standardize_data_button = gr.Button(visible=False)
+
+        # 数据模型
+        with gr.Accordion("数据模型"):
+            select_as_model_radio = gr.Radio(visible=False)
+            linear_regression_model_radio = gr.Radio(visible=False)
+            model_optimize_radio = gr.Radio(visible=False)
+            model_train_button = gr.Button(visible=False)
+            model_train_checkbox = gr.Checkbox(visible=False)
+
+        # 可视化
+        with gr.Accordion("数据可视化"):
+            learning_curve_checkboxgroup = gr.Checkboxgroup(visible=False)
+            with gr.Row():
+                learning_curve_train_button = gr.Button(visible=False)
+                learning_curve_validation_button = gr.Button(visible=False)
+            learning_curve_train_plot = gr.Plot(visible=False)
+            learning_curve_validation_plot = gr.Plot(visible=False)
+            shap_beeswarm_radio = gr.Radio(visible=False)
+            shap_beeswarm_button = gr.Button(visible=False)
+            with gr.Group():
+                shap_beeswarm_plot = gr.Plot(visible=False)
+                shap_beeswarm_plot_file = gr.File(visible=False)
+
+    '''
+        监听事件
+    '''
+
+    # 选择数据源
+    choose_dataset_radio.change(fn=choose_dataset, inputs=[choose_dataset_radio], outputs=get_outputs())
+    choose_custom_dataset_file.upload(fn=choose_custom_dataset, inputs=[choose_custom_dataset_file], outputs=get_outputs())
+
+    # 操作数据表
+
+    # 删除所选列
+    del_col_button.click(fn=del_col, inputs=[del_col_checkboxgroup], outputs=get_outputs())
+    # 保留行
+    remain_row_button.click(fn=remain_row, inputs=[remain_row_slider], outputs=get_outputs())
+    # 删除所有存在缺失值的列
+    del_all_na_col_button.click(fn=del_all_na_col, outputs=get_outputs())
+    # 删除所有重复的行
+    del_duplicate_button.click(fn=del_duplicate, outputs=get_outputs())
+    # 字符型列转数值型列
+    encode_label_button.click(fn=encode_label, inputs=[encode_label_checkboxgroup], outputs=get_outputs())
+    # 将所有数据强制转换为浮点型(除第1列之外)
+    change_data_type_to_float_button.click(fn=change_data_type_to_float, outputs=get_outputs())
+    # 标准化数据
+    standardize_data_button.click(fn=standardize_data, inputs=[standardize_data_checkboxgroup], outputs=get_outputs())
+    # 选择因变量
+    select_as_y_radio.change(fn=select_as_y, inputs=[select_as_y_radio], outputs=get_outputs())
+    # 选择任务类型(强制转换第1列)
+    choose_assign_radio.change(fn=choose_assign, inputs=[choose_assign_radio], outputs=get_outputs())
+
+    # 数据模型
+    select_as_model_radio.change(fn=select_as_model, inputs=[select_as_model_radio], outputs=get_outputs())
+    model_train_button.click(fn=train_model, inputs=[model_optimize_radio, linear_regression_model_radio], outputs=get_outputs())
+
+    # 可视化
+    learning_curve_train_button.click(fn=draw_learning_curve_train_plot, inputs=[learning_curve_checkboxgroup], outputs=get_outputs())
+    learning_curve_validation_button.click(fn=draw_learning_curve_validation_plot, inputs=[learning_curve_checkboxgroup], outputs=get_outputs())
+    shap_beeswarm_button.click(fn=draw_shap_beeswarm_plot, inputs=[shap_beeswarm_radio], outputs=get_outputs())
+
+if __name__ == "__main__":
+    demo.launch()

metrics/calculate_classification_metrics.py

@@ -0,0 +1,35 @@
+import numpy as np
+from sklearn.metrics import *
+from sklearn.preprocessing import label_binarize
+
+from visualization.draw_line_graph import draw_line_graph
+
+
+def calculate_classification_metrics(pred_data, real_data, model_name):
+    info = {}
+
+    real_data = np.round(real_data, 0).astype(int)
+    pred_data = np.round(pred_data, 0).astype(int)
+
+    cur_confusion_matrix = confusion_matrix(real_data[:, 0], pred_data)
+    info["Confusion matrix of "+model_name] = cur_confusion_matrix
+
+    info["Accuracy of "+model_name] = np.sum(cur_confusion_matrix.diagonal()) / np.sum(cur_confusion_matrix)
+    info["Precision of "+model_name] = cur_confusion_matrix.diagonal() / np.sum(cur_confusion_matrix, axis=1)
+    info["Recall of "+model_name] = cur_confusion_matrix.diagonal() / np.sum(cur_confusion_matrix, axis=0)
+    info["F1-score of "+model_name] = np.mean(2 * np.multiply(info["Precision of "+model_name], info["Recall of "+model_name]) / \
+                                      (info["Precision of "+model_name] + info["Recall of "+model_name]))
+
+    max_class = max(real_data)[0]
+    min_class = min(real_data)[0]
+    pred_data_ = label_binarize(pred_data, classes=range(min_class, max_class+1))
+    real_data_ = label_binarize(real_data, classes=range(min_class, max_class+1))
+
+    for i in range(max_class - min_class):
+        fpr, tpr, thresholds = roc_curve(real_data_[:, i], pred_data_[:, i])
+        # draw_line_graph(fpr, tpr, "ROC curve with AUC={:.2f}".format(auc(fpr, tpr)))
+
+    info["AUC of "+model_name] = roc_auc_score(real_data_, pred_data_)
+
+    return info
+

metrics/calculate_regression_metrics.py

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

requirements.txt

@@ -0,0 +1,12 @@
+numpy~=1.23.5
+pandas~=1.5.3
+scikit-learn~=1.2.1
+hmmlearn~=0.3.0
+matplotlib~=3.7.0
+scikit-fuzzy~=0.4.2
+gradio~=4.17.0
+shap~=0.44.1
+networkx~=2.8.4
+scipy~=1.10.0
+xgboost~=2.0.3
+tqdm~=4.64.1

static/col.py

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

@@ -0,0 +1,51 @@
+class Config:
+    # 随机种子
+    RANDOM_STATE = 123
+    # 绘图颜色组
+    COLORS = [
+        "#8074C8",
+        "#7895C1",
+        "#A8CBDF",
+        "#992224",
+        "#B54764",
+        "#E3625D",
+        "#EF8B67",
+        "#F0C284"
+    ]
+    COLORS_1 = [
+        "#91CCC0",
+        "#7FABD1",
+        "#F7AC53",
+        "#EC6E66",
+        "#B5CE4E",
+        "#BD7795",
+        "#B55384",
+        "#474769",
+        "#257D88",
+        "#ED8D5A",
+        "#BFDFD2",
+        "#EFCE87"
+    ]
+
+    COLORS_2 = [
+        "#A21A54",
+        "#E7724F",
+        "#32183C"
+    ]
+
+    COLORS_3 = [
+        "#ABD1BC",
+        "#CCCC99",
+        "#E3BBED"
+    ]
+
+
+    COLORS_4 = [
+        "#CFCFD0",
+        "#B6B3D6",
+        "#F58F7A",
+        "#E9687A",
+    ]
+
+    # 预测图展示的点个数
+    DISPLAY_RANGE = 100

static/process.py

@@ -0,0 +1,313 @@
+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 sklearn.datasets import load_iris
+from sklearn.datasets import load_wine
+from sklearn.datasets import load_breast_cancer
+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):
+    if sort == "Iris Dataset":
+        sk_data = load_iris()
+    elif sort == "Wine Dataset":
+        sk_data = load_wine()
+    elif sort == "Breast Cancer Dataset":
+        sk_data = load_breast_cancer()
+
+    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)
+
+    sk_feature_names = sk_data.feature_names
+    sk_data = np.concatenate((target_data.reshape(-1, 1), sk_data.data), axis=1)
+    sk_feature_names = np.insert(sk_feature_names, 0, "species")
+
+    df = pd.DataFrame(data=sk_data, columns=sk_feature_names)
+
+    return df
+
+
+def load_custom_data(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 = {}
+
+    if scoring == "neg_mean_squared_error":
+        grid_search_model = GridSearchCV(model, params, cv=5, scoring="neg_mean_squared_error")
+    else:
+        grid_search_model = GridSearchCV(model, params, cv=5)
+
+    grid_search_model.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 = {}
+
+    if scoring == "neg_mean_squared_error":
+        bayes_search_model = BayesSearchCV(model, params, cv=5, n_iter=50, scoring="neg_mean_squared_error")
+    else:
+        bayes_search_model = BayesSearchCV(model, params, cv=5, n_iter=50)
+
+    bayes_search_model.fit(x_train, y_train)
+
+    info["Optimal hyperparameters"] = bayes_search_model.best_params_
+
+    best_model = bayes_search_model.best_estimator_
+
+    return best_model
+
+

visualization/draw_boxplot.py

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

visualization/draw_heat_map.py

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

visualization/draw_histogram.py

@@ -0,0 +1,40 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+from coding.llh.static.config import Config
+
+
+# Plot bar charts
+def draw_histogram(x_data, y_data, will_rotate, will_show_text, title):
+    fig, ax = plt.subplots(figsize=(10, 8))
+
+    bars = plt.bar(
+        np.arange(0, len(x_data)),
+        x_data,
+        align="center",
+        alpha=1,
+        color=Config.COLORS,
+        tick_label=y_data
+    )
+
+    # Bar annotation
+    if will_show_text:
+        for bar in bars:
+            ax.annotate(
+                str(bar.get_height()),
+                xy=(bar.get_x() + bar.get_width() / 2,
+                    bar.get_height()),
+                xytext=(0, 3),
+                textcoords="offset points",
+                va="bottom",
+                ha="center"
+            )
+
+    if will_rotate:
+        plt.xticks(rotation=-90)
+
+    plt.title(title)
+
+    plt.savefig("./diagram/{}.png".format(title), dpi=300)
+
+    plt.show()

visualization/draw_histogram_line_subgraph.py

@@ -0,0 +1,48 @@
+import numpy as np
+from matplotlib import pyplot as plt
+
+from coding.llh.static.config import Config
+
+
+def draw_histogram_line_subgraph(total_data_for_plot):
+    # Manually adjust based on the data
+    layout = """
+        ABC
+        DDE
+        FGH
+        IJK
+    """
+
+    fig, ax = plt.subplot_mosaic(layout, figsize=(16, 16))
+
+    for i, data in enumerate(total_data_for_plot):
+        if data[0] == "line_graph":
+            ax[str(chr(i+65))].grid()
+            ax[str(chr(i+65))].plot(
+                data[1],
+                data[2],
+                "-o",
+                color=Config.COLORS[0],
+                markersize=4
+            )
+            ax[str(chr(i+65))].set_title(data[3])
+        elif data[0] == "histogram":
+            ax[str(chr(i+65))].grid()
+            ax[str(chr(i+65))].bar(
+                np.arange(0, len(data[1])),
+                data[1],
+                align="center",
+                alpha=1,
+                color=Config.COLORS,
+                tick_label=data[2]
+            )
+
+            if data[3]:
+                ax[str(chr(i+65))].tick_params(axis='x', labelrotation=-90)
+
+            ax[str(chr(i+65))].set_title(data[5])
+
+    plt.tight_layout()
+    plt.savefig("./diagram/{}.png".format("total"), dpi=300)
+
+    plt.show()

visualization/draw_learning_curve.py

@@ -0,0 +1,44 @@
+import numpy as np
+from matplotlib import pyplot as plt
+
+from static.config import Config
+
+
+def draw_learning_curve(train_sizes, train_scores_mean, train_scores_std, test_scores_mean, test_scores_std):
+    plt.figure(figsize=(10, 6))
+
+    plt.fill_between(
+        train_sizes,
+        train_scores_mean - train_scores_std,
+        train_scores_mean + train_scores_std,
+        alpha=0.1,
+        color=Config.COLORS[0]
+    )
+    plt.plot(
+        train_sizes,
+        train_scores_mean,
+        "o-",
+        color=Config.COLORS[0],
+        label="Training score"
+    )
+
+    plt.fill_between(
+        train_sizes,
+        test_scores_mean - test_scores_std,
+        test_scores_mean + test_scores_std,
+        alpha=0.1,
+        color=Config.COLORS[1]
+    )
+    plt.plot(
+        train_sizes,
+        test_scores_mean,
+        "o-",
+        color=Config.COLORS[1],
+        label="Cross-validation score"
+    )
+
+    plt.title("Learning curve")
+    plt.xlabel("Sizes")
+    plt.ylabel("Accuracy")
+    plt.legend(loc="best")
+    plt.show()

visualization/draw_learning_curve_total.py

@@ -0,0 +1,76 @@
+import numpy as np
+from matplotlib import pyplot as plt
+
+from static.config import Config
+
+
+def draw_learning_curve_total(input_dict, type):
+    plt.figure(figsize=(10, 6), dpi=300)
+
+    if type == "train":
+        i = 0
+        for label_name, values in input_dict.items():
+            train_sizes = values[0]
+            train_scores_mean = values[1]
+            train_scores_std = values[2]
+            test_scores_mean = values[3]
+            test_scores_std = values[4]
+
+            plt.fill_between(
+                train_sizes,
+                train_scores_mean - train_scores_std,
+                train_scores_mean + train_scores_std,
+                alpha=0.1,
+                color=Config.COLORS[i]
+            )
+
+            plt.plot(
+                train_sizes,
+                train_scores_mean,
+                "o-",
+                color=Config.COLORS[i],
+                label=label_name
+            )
+
+            i += 1
+
+        title = "Training Learning curve"
+        # plt.title(title)
+
+    else:
+        i = 0
+        for label_name, values in input_dict.items():
+            train_sizes = values[0]
+            train_scores_mean = values[1]
+            train_scores_std = values[2]
+            test_scores_mean = values[3]
+            test_scores_std = values[4]
+
+            plt.fill_between(
+                train_sizes,
+                test_scores_mean - test_scores_std,
+                test_scores_mean + test_scores_std,
+                alpha=0.1,
+                color=Config.COLORS[i]
+            )
+            plt.plot(
+                train_sizes,
+                test_scores_mean,
+                "o-",
+                color=Config.COLORS[i],
+                label=label_name
+            )
+
+            i += 1
+
+        title = "Cross-validation Learning curve"
+        # plt.title(title)
+
+    plt.xlabel("Sizes")
+    plt.ylabel("Adjusted R-square")
+    plt.legend()
+
+    # plt.savefig("./diagram/{}.png".format(title), dpi=300)
+    # plt.show()
+    return plt
+

visualization/draw_line_graph.py

@@ -0,0 +1,40 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+from static.config import Config
+
+
+# draw line graph
+def draw_line_graph(x_data, y_data: list, title):
+    plt.figure(figsize=(10, 8))
+
+    plt.plot(
+        x_data,
+        y_data,
+        "-o",
+        color=Config.COLORS[0]
+    )
+
+    plt.title(title)
+    plt.savefig("./diagram/{}.png".format(title), dpi=300)
+
+    plt.show()
+
+
+def draw_line_graph_1(x_data, y_data: list, title, labels: list):
+    plt.figure(figsize=(10, 8))
+
+    for i, single_y_data in enumerate(y_data):
+        plt.plot(
+            x_data,
+            single_y_data,
+            "-o",
+            color=Config.COLORS[i],
+            label=labels[i]
+        )
+
+    plt.legend()
+    plt.title(title)
+    plt.savefig("./diagram/{}.png".format(title), dpi=300)
+
+    plt.show()

visualization/draw_momentum.py

@@ -0,0 +1,52 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.metrics import *
+from sklearn.preprocessing import label_binarize
+
+from coding.llh.static.config import Config
+
+
+def draw_momentum(df, p1_name, p2_name):
+    plt.figure(figsize=(10, 6))
+
+    plt.plot(
+        df.loc[:, "elapsed_time"].values,
+        df.loc[:, "p1_momentum_value"].values,
+        "-",
+        color=Config.COLORS_1[8],
+        alpha=0.5,
+        label=p1_name
+    )
+    plt.plot(
+        df.loc[:, "elapsed_time"].values,
+        df.loc[:, "p2_momentum_value"].values,
+        "-",
+        color=Config.COLORS_1[9],
+        alpha=0.5,
+        label=p2_name
+    )
+    plt.axhline(
+        y=0,
+        linestyle="--",
+        color="black",
+        alpha=0.5
+    )
+    plt.plot(
+        df.loc[:, "elapsed_time"].values,
+        df.loc[:, "p1_momentum_value_better"].values,
+        "-",
+        color=Config.COLORS_1[10],
+        alpha=0.7,
+        label="Degree of Superiority"
+    )
+
+    title = "Momentum"
+    # plt.title(title)
+
+    plt.xlabel("Elapsed time")
+    plt.ylabel("Momentum value")
+    plt.legend()
+
+    plt.savefig("./diagram/{}.png".format(title), dpi=300)
+
+    plt.show()

visualization/draw_parallel_coordinates.py

@@ -0,0 +1,46 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+
+from coding.llh.static.config import Config
+
+
+def draw_parallel_coordinates(df):
+    df.drop("match_id", axis=1, inplace=True)
+    df.drop("player1", axis=1, inplace=True)
+    df.drop("player2", axis=1, inplace=True)
+    df.drop("elapsed_time", axis=1, inplace=True)
+    df.drop("set_no", axis=1, inplace=True)
+    df.drop("game_no", axis=1, inplace=True)
+    df.drop("point_no", axis=1, inplace=True)
+    df.drop("p1_sets", axis=1, inplace=True)
+    df.drop("p2_sets", axis=1, inplace=True)
+    df.drop("p1_games", axis=1, inplace=True)
+    df.drop("p2_games", axis=1, inplace=True)
+    df.drop("p1_points_won", axis=1, inplace=True)
+    df.drop("p2_points_won", axis=1, inplace=True)
+    df.drop("p1_distance_run", axis=1, inplace=True)
+    df.drop("p2_distance_run", axis=1, inplace=True)
+    df.drop("speed_mph", axis=1, inplace=True)
+    df.drop("p1_score_normal", axis=1, inplace=True)
+    df.drop("p2_score_normal", axis=1, inplace=True)
+    df.drop("p1_score_tiebreak", axis=1, inplace=True)
+    df.drop("p2_score_tiebreak", axis=1, inplace=True)
+    df.drop("p1_game_victor", axis=1, inplace=True)
+    df.drop("p2_game_victor", axis=1, inplace=True)
+    df.drop("p1_set_victor", axis=1, inplace=True)
+    df.drop("p2_set_victor", axis=1, inplace=True)
+
+    plt.figure(figsize=(10, 6))
+
+    pd.plotting.parallel_coordinates(df, "point_victor", colormap="viridis")
+
+    title = "Parallel Coordinates Plot"
+    plt.title(title)
+
+    plt.xlabel("Attributes")
+    plt.ylabel("Values")
+    plt.legend()
+
+    plt.savefig("./diagram/{}.png".format(title), dpi=300)
+
+    plt.show()

visualization/draw_play_flow.py

@@ -0,0 +1,87 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.metrics import *
+from sklearn.preprocessing import label_binarize
+
+from coding.llh.static.config import Config
+
+
+def draw_play_flow(df, p1_name, p2_name, p1_ace, p2_ace, p1_net_pt_won, p2_net_pt_won, p1_break_pt_won, p2_break_pt_won):
+    plt.figure(figsize=(10, 6))
+
+    plt.plot(
+        df.loc[:, "elapsed_time"].values,
+        df.loc[:, "p1_points_won"].values,
+        "-",
+        color=Config.COLORS_1[6],
+        alpha=0.5,
+        label=p1_name
+    )
+    plt.plot(
+        df.loc[:, "elapsed_time"].values,
+        df.loc[:, "p2_points_won"].values,
+        "-",
+        color=Config.COLORS_1[7],
+        alpha=0.5,
+        label=p2_name
+    )
+
+    plt.scatter(
+        p1_ace.loc[:, "elapsed_time"].values,
+        p1_ace.loc[:, "p1_points_won"].values,
+        s=40,
+        c=Config.COLORS_1[0],
+        marker="v",
+        label="p1_ace"
+    )
+    plt.scatter(
+        p2_ace.loc[:, "elapsed_time"].values,
+        p2_ace.loc[:, "p2_points_won"].values,
+        s=40,
+        c=Config.COLORS_1[1],
+        marker="v",
+        label="p2_ace"
+    )
+    plt.scatter(
+        p1_net_pt_won.loc[:, "elapsed_time"].values,
+        p1_net_pt_won.loc[:, "p1_points_won"].values,
+        s=40,
+        c=Config.COLORS_1[2],
+        marker="*",
+        label="p1_net_pt_won"
+    )
+    plt.scatter(
+        p2_net_pt_won.loc[:, "elapsed_time"].values,
+        p2_net_pt_won.loc[:, "p2_points_won"].values,
+        s=40,
+        c=Config.COLORS_1[3],
+        marker="*",
+        label="p2_net_pt_won"
+    )
+    plt.scatter(
+        p1_break_pt_won.loc[:, "elapsed_time"].values,
+        p1_break_pt_won.loc[:, "p1_points_won"].values,
+        s=40,
+        c=Config.COLORS_1[4],
+        marker="+",
+        label="p1_break_pt_won"
+    )
+    plt.scatter(
+        p2_break_pt_won.loc[:, "elapsed_time"].values,
+        p2_break_pt_won.loc[:, "p2_points_won"].values,
+        s=40,
+        c=Config.COLORS_1[5],
+        marker="+",
+        label="p1_break_pt_won"
+    )
+
+    title = "Flow of play"
+    # plt.title(title)
+
+    plt.xlabel("Elapsed time")
+    plt.ylabel("Points")
+    plt.legend()
+
+    plt.savefig("./diagram/{}.png".format(title), dpi=300)
+
+    plt.show()

visualization/draw_pred_total.py

@@ -0,0 +1,42 @@
+import numpy as np
+from matplotlib import pyplot as plt
+
+from coding.llh.static.config import Config
+
+
+def draw_pred_total(input_dict):
+    plt.figure(figsize=(10, 6))
+
+    i = 0
+    for name, cur_list in input_dict.items():
+        mylist = cur_list
+        plt.plot(
+            np.array([x for x in range(len(cur_list[0]))]),
+            cur_list[0],
+            "-",
+            color=Config.COLORS_4[i],
+            alpha=0.9,
+            label=name
+        )
+        i += 1
+
+    plt.plot(
+        np.array([x for x in range(len(mylist[1]))]),
+        mylist[1],
+        "--",
+        color=Config.COLORS_4[1],
+        alpha=0.9,
+        label="actual data"
+    )
+
+    title = "pred curve"
+
+    plt.xlabel("Sizes")
+    plt.ylabel("Value")
+    plt.legend()
+
+    plt.savefig("./diagram/{}.png".format(title), dpi=300)
+
+    plt.show()
+
+

visualization/draw_roc_auc_curve_total.py

@@ -0,0 +1,58 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.metrics import *
+from sklearn.preprocessing import label_binarize
+
+from coding.llh.static.config import Config
+
+
+def draw_roc_auc_curve_total(input_dict, type):
+    plt.figure(figsize=(10, 6))
+
+    if type == "train":
+        i = 0
+        for label_name, values in input_dict.items():
+            fpr = values[0]
+            tpr = values[1]
+            thresholds = values[2]
+
+            plt.plot(
+                fpr,
+                tpr,
+                "o-",
+                color=Config.COLORS[i],
+                label=label_name+str(round(auc(fpr, tpr), 2))
+            )
+
+            i += 1
+
+        title = "Training roc-auc curve"
+        plt.title(title)
+
+    else:
+        i = 0
+        for label_name, values in input_dict.items():
+            fpr = values[0]
+            tpr = values[1]
+            thresholds = values[2]
+
+            plt.plot(
+                fpr,
+                tpr,
+                "o-",
+                color=Config.COLORS[i],
+                label=label_name + str(round(auc(fpr, tpr), 2))
+            )
+
+            i += 1
+
+        title = "Cross-validation roc-auc curve"
+        plt.title(title)
+
+    plt.xlabel("tpr")
+    plt.ylabel("fpr")
+    plt.legend()
+
+    plt.savefig("./diagram/{}.png".format(title), dpi=300)
+
+    plt.show()

visualization/draw_scatter.py

@@ -0,0 +1,70 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+
+from coding.llh.static.config import Config
+
+
+# Draw scatter
+def draw_scatter_2D(x_data, y_data, centers, title):
+    num_clusters = np.unique(y_data)
+
+    plt.figure(figsize=(10, 8))
+
+    for i in range(len(num_clusters)):
+        plt.scatter(x_data[y_data == i][:, 0], x_data[y_data == i][:, 1], s=1)
+    for i in range(len(num_clusters)):
+        plt.scatter(centers[i, 0], centers[i, 1], marker="*", s=50, c="black")
+
+    plt.title(title)
+
+    plt.savefig("./diagram/{}.png".format(title), dpi=300)
+
+    plt.show()
+
+
+def draw_scatter_2D_1(x_data, title):
+    plt.figure(figsize=(10, 8))
+
+    plt.scatter(x_data[:, 0], x_data[:, 1], s=1)
+
+    plt.title(title)
+
+    plt.savefig("./diagram/{}.png".format(title), dpi=300)
+
+    plt.show()
+
+
+def draw_scatter_3D(x_data, y_data, centers, title):
+    num_clusters = np.unique(y_data)
+
+    fig = plt.figure(figsize=(10, 8))
+
+    ax = Axes3D(fig)
+    fig.add_axes(ax)
+
+    for i in range(len(num_clusters)):
+        ax.scatter(x_data[y_data == i][:, 0], x_data[y_data == i][:, 1], x_data[y_data == i][:, 2], s=1)
+    for i in range(len(num_clusters)):
+        ax.scatter(centers[i, 0], centers[i, 1], centers[i, 2], marker="*", s=50, c="black")
+
+    plt.title(title)
+
+    plt.savefig("./diagram/{}.png".format(title), dpi=300)
+
+    plt.show()
+
+
+def draw_scatter_3D_1(x_data, title):
+    fig = plt.figure(figsize=(10, 8))
+
+    ax = Axes3D(fig)
+    fig.add_axes(ax)
+
+    ax.scatter(x_data[:, 0], x_data[:, 1], x_data[:, 2], s=1)
+
+    plt.title(title)
+
+    plt.savefig("./diagram/{}.png".format(title), dpi=300)
+
+    plt.show()

visualization/draw_scatter_line_graph.py

@@ -0,0 +1,27 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+from coding.llh.static.config import Config
+
+
+# draw scatter line graph
+def draw_scatter_line_graph(x_data, y_pred_data, y_real_data, coef, intercept, labels, title):
+    # Manually adjust based on the data
+    layout = """
+        ABCDE
+        FGHIJ
+    """
+
+    fig, ax = plt.subplot_mosaic(layout, figsize=(16, 16))
+
+    for i in range(np.size(x_data, 1)):
+        ax[str(chr(i+65))].scatter(x_data[:, i], y_pred_data.T, color=Config.COLORS[0], s=4, label=labels[0])
+        ax[str(chr(i+65))].scatter(x_data[:, i], y_real_data, color=Config.COLORS[1], s=4, label=labels[1])
+        ax[str(chr(i+65))].plot(x_data[:, i], x_data[:, i] * coef[i] + intercept, color=Config.COLORS[2], markersize=4)
+        ax[str(chr(i + 65))].legend()
+
+    plt.suptitle(title)
+
+    plt.savefig("./diagram/{}.png".format(title), dpi=300)
+
+    plt.show()

visualization/draw_swings_and_positives.py

@@ -0,0 +1,46 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.metrics import *
+from sklearn.preprocessing import label_binarize
+
+from coding.llh.static.config import Config
+
+
+def draw_swings_and_positives(df, p1_name, p2_name):
+    plt.figure(figsize=(10, 6))
+
+    plt.plot(
+        df.loc[:, "elapsed_time"].values,
+        df.loc[:, "swing"].values,
+        "-",
+        color=Config.COLORS_2[2],
+        alpha=0.7,
+        label="Swing of Play"
+    )
+    plt.plot(
+        df.loc[:, "elapsed_time"].values,
+        df.loc[:, "p1_remain_positive"].values,
+        "-.",
+        color=Config.COLORS_2[0],
+        alpha=0.7,
+        label=p1_name
+    )
+    plt.plot(
+        df.loc[:, "elapsed_time"].values,
+        df.loc[:, "p2_remain_positive"].values,
+        "-.",
+        color=Config.COLORS_2[1],
+        alpha=0.7,
+        label=p2_name
+    )
+
+    title = "Standard time interval"
+    # plt.title(title)
+
+    plt.xlabel("Elapsed time")
+    plt.ylabel("Standard time interval")
+    plt.legend()
+
+    plt.savefig("./diagram/{}.png".format(title), dpi=300)
+
+    plt.show()