paddlex 2.0.0rc4__py3-none-any.whl → 3.0.0b2__py3-none-any.whl

paddlex/modules/ts_anomaly_detection/trainer.py

@@ -0,0 +1,97 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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.
+
+import os
+import json
+import time
+from pathlib import Path
+import tarfile
+
+from ..base import BaseTrainer
+from ...utils.config import AttrDict
+from .model_list import MODELS
+
+
+class TSADTrainer(BaseTrainer):
+    """TS Anomaly Detection Model Trainer"""
+
+    entities = MODELS
+
+    def train(self):
+        """firstly, update and dump train config, then train model"""
+        # XXX: using super().train() instead when the train_hook() is supported.
+        os.makedirs(self.global_config.output, exist_ok=True)
+        self.update_config()
+        self.dump_config()
+        train_result = self.pdx_model.train(**self.get_train_kwargs())
+        assert (
+            train_result.returncode == 0
+        ), f"Encountered an unexpected error({train_result.returncode}) in \
+training!"
+
+        self.make_tar_file()
+
+    def make_tar_file(self):
+        """make tar file to package the training outputs"""
+        tar_path = Path(self.global_config.output) / "best_accuracy.pdparams.tar"
+        with tarfile.open(tar_path, "w") as tar:
+            tar.add(self.global_config.output, arcname="best_accuracy.pdparams")
+
+    def update_config(self):
+        """update training config"""
+        self.pdx_config.update_dataset(self.global_config.dataset_dir, "TSADDataset")
+        if self.train_config.input_len is not None:
+            self.pdx_config.update_input_len(self.train_config.input_len)
+
+        if self.train_config.time_col is not None:
+            self.pdx_config.update_basic_info({"time_col": self.train_config.time_col})
+        if self.train_config.feature_cols is not None:
+            if isinstance(self.train_config.feature_cols, tuple):
+                feature_cols = [str(item) for item in self.train_config.feature_cols]
+                self.pdx_config.update_basic_info({"feature_cols": feature_cols})
+            else:
+                self.pdx_config.update_basic_info(
+                    {"feature_cols": self.train_config.feature_cols.split(",")}
+                )
+        if self.train_config.label_col is not None:
+            self.pdx_config.update_basic_info(
+                {"label_col": self.train_config.label_col}
+            )
+        if self.train_config.freq is not None:
+            try:
+                self.train_config.freq = int(self.train_config.freq)
+            except ValueError:
+                pass
+            self.pdx_config.update_basic_info({"freq": self.train_config.freq})
+        if self.train_config.batch_size is not None:
+            self.pdx_config.update_batch_size(self.train_config.batch_size)
+        if self.train_config.learning_rate is not None:
+            self.pdx_config.update_learning_rate(self.train_config.learning_rate)
+        if self.train_config.epochs_iters is not None:
+            self.pdx_config.update_epochs(self.train_config.epochs_iters)
+        if self.train_config.log_interval is not None:
+            self.pdx_config.update_log_interval(self.train_config.log_interval)
+        if self.global_config.output is not None:
+            self.pdx_config.update_save_dir(self.global_config.output)
+
+    def get_train_kwargs(self) -> dict:
+        """get key-value arguments of model training function
+
+        Returns:
+            dict: the arguments of training function.
+        """
+        train_args = {"device": self.get_device(using_device_number=1)}
+        if self.global_config.output is not None:
+            train_args["save_dir"] = self.global_config.output
+        return train_args

paddlex/modules/ts_classification/__init__.py

@@ -0,0 +1,19 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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.
+
+
+from .dataset_checker import TSCLSDatasetChecker
+from .trainer import TSCLSTrainer
+from .evaluator import TSCLSEvaluator
+from .exportor import TSCLSExportor

paddlex/modules/ts_classification/dataset_checker/__init__.py

@@ -0,0 +1,97 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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.
+
+
+import os
+import os.path as osp
+from collections import defaultdict, Counter
+
+from PIL import Image
+import json
+
+from ...base import BaseDatasetChecker
+from .dataset_src import check, convert, split_dataset, deep_analyse
+
+from ..model_list import MODELS
+
+
+class TSCLSDatasetChecker(BaseDatasetChecker):
+    """Dataset Checker for TS Classification Model"""
+
+    entities = MODELS
+    sample_num = 10
+
+    def convert_dataset(self, src_dataset_dir: str) -> str:
+        """convert the dataset from other type to specified type
+
+        Args:
+            src_dataset_dir (str): the root directory of dataset.
+
+        Returns:
+            str: the root directory of converted dataset.
+        """
+        return convert(src_dataset_dir)
+
+    def split_dataset(self, src_dataset_dir: str) -> str:
+        """repartition the train and validation dataset
+
+        Args:
+            src_dataset_dir (str): the root directory of dataset.
+
+        Returns:
+            str: the root directory of splited dataset.
+        """
+        return split_dataset(
+            src_dataset_dir,
+            self.check_dataset_config.split.train_percent,
+            self.check_dataset_config.split.val_percent,
+        )
+
+    def check_dataset(self, dataset_dir: str, sample_num: int = sample_num) -> dict:
+        """check if the dataset meets the specifications and get dataset summary
+
+        Args:
+            dataset_dir (str): the root directory of dataset.
+            sample_num (int): the number to be sampled.
+        Returns:
+            dict: dataset summary.
+        """
+        return check(dataset_dir, self.output)
+
+    def analyse(self, dataset_dir: str) -> dict:
+        """deep analyse dataset
+
+        Args:
+            dataset_dir (str): the root directory of dataset.
+
+        Returns:
+            dict: the deep analysis results.
+        """
+        return deep_analyse(dataset_dir, self.output)
+
+    def get_show_type(self) -> str:
+        """get the show type of dataset
+
+        Returns:
+            str: show type
+        """
+        return "csv"
+
+    def get_dataset_type(self) -> str:
+        """return the dataset type
+
+        Returns:
+            str: dataset type
+        """
+        return "TSCLSDataset"

paddlex/modules/ts_classification/dataset_checker/dataset_src/__init__.py

@@ -0,0 +1,19 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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.
+
+
+from .check_dataset import check
+from .convert_dataset import convert
+from .split_dataset import split_dataset
+from .analyse_dataset import deep_analyse

paddlex/modules/ts_classification/dataset_checker/dataset_src/analyse_dataset.py

@@ -0,0 +1,74 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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.
+
+
+import os
+import platform
+from pathlib import Path
+
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib import font_manager
+
+from .....utils.fonts import PINGFANG_FONT_FILE_PATH
+
+
+def deep_analyse(dataset_dir, output, label_col="label"):
+    """class analysis for dataset"""
+    tags = ["train", "val"]
+    label_unique = None
+    for tag in tags:
+        csv_path = os.path.abspath(os.path.join(dataset_dir, tag + ".csv"))
+        df = pd.read_csv(csv_path)
+        if label_col not in df.columns:
+            raise ValueError(f"default label_col: {label_col} not in {tag} dataset")
+        if label_unique is None:
+            label_unique = df[label_col].unique()
+        cls_dict = {}
+        for label in label_unique:
+            vis_df = df[df[label_col].isin([label])]
+            cls_dict[label] = len(vis_df)
+        if tag == "train":
+            cls_train = [label_num for label_col, label_num in cls_dict.items()]
+        elif tag == "val":
+            cls_val = [label_num for label_col, label_num in cls_dict.items()]
+    sorted_id = sorted(range(len(cls_train)), key=lambda k: cls_train[k], reverse=True)
+    cls_train_sorted = sorted(cls_train, reverse=True)
+    cls_val_sorted = [cls_val[index] for index in sorted_id]
+    classes_sorted = [label_unique[index] for index in sorted_id]
+    x = np.arange(len(label_unique))
+    width = 0.5
+
+    # bar
+    os_system = platform.system().lower()
+    if os_system == "windows":
+        plt.rcParams["font.sans-serif"] = "FangSong"
+    else:
+        font = font_manager.FontProperties(fname=PINGFANG_FONT_FILE_PATH)
+    fig, ax = plt.subplots(figsize=(max(8, int(len(label_unique) / 5)), 5), dpi=120)
+    ax.bar(x, cls_train_sorted, width=0.5, label="train")
+    ax.bar(x + width, cls_val_sorted, width=0.5, label="val")
+    plt.xticks(
+        x + width / 2,
+        classes_sorted,
+        rotation=90,
+        fontproperties=None if os_system == "windows" else font,
+    )
+    ax.set_ylabel("Counts")
+    plt.legend()
+    fig.tight_layout()
+    fig_path = os.path.join(output, "histogram.png")
+    fig.savefig(fig_path)
+    return {"histogram": os.path.join("check_dataset", "histogram.png")}

paddlex/modules/ts_classification/dataset_checker/dataset_src/check_dataset.py

@@ -0,0 +1,64 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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.
+
+
+import os
+import os.path as osp
+from collections import defaultdict
+from pathlib import Path
+import pandas as pd
+
+from .....utils.errors import DatasetFileNotFoundError
+
+
+def check(dataset_dir, output, sample_num=10):
+    """check dataset"""
+    dataset_dir = osp.abspath(dataset_dir)
+    if not osp.exists(dataset_dir) or not osp.isdir(dataset_dir):
+        raise DatasetFileNotFoundError(file_path=dataset_dir)
+
+    sample_cnts = dict()
+    tables = defaultdict(list)
+    vis_save_dir = osp.join(output, "demo_data")
+
+    tags = ["train", "val"]
+    for _, tag in enumerate(tags):
+        file_list = osp.join(dataset_dir, f"{tag}.csv")
+        if not osp.exists(file_list):
+            if tag in ("train", "val"):
+                # train and val file lists must exist
+                raise DatasetFileNotFoundError(
+                    file_path=file_list,
+                    solution=f"Ensure that both `train.csv` and `val.csv` exist in \
+{dataset_dir}",
+                )
+            else:
+                continue
+        else:
+            df = pd.read_csv(file_list)
+            sample_cnts[tag] = len(df)
+            vis_path = osp.join(vis_save_dir, f"{tag}.csv")
+            Path(vis_path).parent.mkdir(parents=True, exist_ok=True)
+            vis_df = df.iloc[:sample_num, :]
+            vis_df.to_csv(vis_path, index=False)
+            header_list = df.columns.to_list()
+            data_list = df.head(10).values.tolist()
+            tables[tag] = [header_list] + data_list
+
+    attrs = {}
+    attrs["train_samples"] = sample_cnts["train"]
+    attrs["train_table"] = tables["train"]
+    attrs["val_samples"] = sample_cnts["val"]
+    attrs["val_table"] = tables["val"]
+    return attrs

paddlex/modules/ts_classification/dataset_checker/dataset_src/convert_dataset.py

@@ -0,0 +1,78 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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.
+
+
+import os
+import shutil
+import json
+import random
+import numpy as np
+import pandas as pd
+from tqdm import tqdm
+
+from .....utils.errors import ConvertFailedError
+
+
+def check_src_dataset(root_dir):
+    """check src dataset format validity"""
+
+    err_msg_prefix = f"数据格式转换失败！当前仅支持后续为'.xlsx/.xls'格式的数据转换。"
+
+    for dst_anno, src_anno in [("train.xlsx", "train.xls"), ("val.xlsx", "val.xls")]:
+        src_anno_path = os.path.join(root_dir, src_anno)
+        dst_anno_path = os.path.join(root_dir, dst_anno)
+        if not os.path.exists(src_anno_path) and not os.path.exists(dst_anno_path):
+            if "train" in dst_anno:
+                raise ConvertFailedError(
+                    message=f"{err_msg_prefix}保证{src_anno_path}或{dst_anno_path}文件存在。"
+                )
+            continue
+
+
+def convert_excel_dataset(input_dir):
+    """
+    将excel标注的数据集转换为PaddleX需要的格式
+
+    Args:
+        input_dir (str): 输入的目录，包含多个json格式的Labelme标注文件
+
+    Returns:
+        str: 返回一个字符串表示转换的结果，“转换成功”表示转换没有问题。
+
+    Raises:
+        该函数目前没有特定的异常抛出。
+
+    """
+
+    # read excel file
+    for dst_anno, src_anno in [("train.xlsx", "train.xls"), ("val.xlsx", "val.xls")]:
+        src_anno_path = os.path.join(input_dir, src_anno)
+        dst_anno_path = os.path.join(input_dir, dst_anno)
+
+        if os.path.exists(src_anno_path):
+            excel_file = pd.read_excel(src_anno_path)
+            output_csv_dir = os.path.join(input_dir, src_anno.replace(".xlsx", ".csv"))
+            excel_file.to_csv(output_csv_dir, index=False)
+        if os.path.exists(dst_anno_path):
+            excel_file = pd.read_excel(dst_anno_path)
+            output_csv_dir = os.path.join(input_dir, dst_anno.replace(".xlsx", ".csv"))
+            excel_file.to_csv(output_csv_dir, index=False)
+
+
+def convert(input_dir):
+    """convert dataset to coco format"""
+    # check format validity
+    check_src_dataset(input_dir)
+    convert_excel_dataset(input_dir)
+    return input_dir

paddlex/modules/ts_classification/dataset_checker/dataset_src/split_dataset.py

@@ -0,0 +1,88 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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.
+
+
+import os
+import os.path as osp
+import shutil
+import random
+import math
+import pandas as pd
+from tqdm import tqdm
+from .....utils.logging import info
+
+
+def split_dataset(root_dir, train_rate, val_rate, group_id="group_id"):
+    """split dataset"""
+    assert (
+        train_rate + val_rate == 100
+    ), f"The sum of train_rate({train_rate}) and val_rate({val_rate}) should equal 100!"
+    assert (
+        train_rate > 0 and val_rate > 0
+    ), f"The train_rate({train_rate}) and val_rate({val_rate}) should be greater than 0!"
+
+    tags = ["train.csv", "val.csv"]
+    df = pd.DataFrame()
+    group_unique = None
+    for tag in tags:
+        if os.path.exists(osp.join(root_dir, tag)):
+            df_one = pd.read_csv(osp.join(root_dir, tag))
+            cols = df_one.columns.values.tolist()
+            assert (
+                group_id in cols
+            ), f"The default group_id '{group_id}' is not found in the df columns."
+        if df.empty:
+            df = df_one
+            group_unique = sorted(df[group_id].unique())
+        else:
+            group_unique_one = sorted(df_one[group_id].unique())
+            for id in group_unique_one:
+                if id in group_unique:
+                    df_one[group_id].replace(id, str(id) + "_", inplace=True)
+                    group_unique.append(str(id) + "_")
+            df = pd.concat([df, df_one], axis=0)
+    df = df.drop_duplicates(keep="first")
+
+    group_unique = df[group_id].unique()
+    dfs = []  # seperate multiple group
+    for column in group_unique:
+        df_one = df[df[group_id].isin([column])]
+        df_one = df_one.drop_duplicates(subset=["time"], keep="first")
+        dfs.append(df_one)
+    group_len = len(dfs)
+    point_train = math.floor((group_len * train_rate / 100))
+    point_val = math.floor((group_len * (train_rate + val_rate) / 100))
+
+    assert point_train > 0, f"The train_len is 0, the train_percent should be greater ."
+    assert (
+        point_val - point_train > 0
+    ), f"The train_len is 0, the val_percent should be greater ."
+
+    train_df = pd.concat(dfs[:point_train], axis=0)
+    val_df = pd.concat(dfs[point_train:point_val], axis=0)
+    df_dict = {"train.csv": train_df, "val.csv": val_df}
+    if point_val < group_len - 1:
+        test_df = pd.concat(dfs[point_val:], axis=0)
+        df_dict.update({"test.csv": test_df})
+    for tag in df_dict.keys():
+        save_path = osp.join(root_dir, tag)
+        if os.path.exists(save_path):
+            bak_path = save_path + ".bak"
+            shutil.move(save_path, bak_path)
+            info(
+                f"The original annotation file {tag} has been backed up to {bak_path}."
+            )
+        df_dict[tag].to_csv(save_path, index=False)
+
+    return root_dir

paddlex/modules/ts_classification/evaluator.py

@@ -0,0 +1,66 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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.
+
+
+import tarfile
+from pathlib import Path
+
+from ..base import BaseEvaluator
+from .model_list import MODELS
+
+
+class TSCLSEvaluator(BaseEvaluator):
+    """TS Classification Model Evaluator"""
+
+    entities = MODELS
+
+    def get_config_path(self, weight_path):
+        """
+        get config path
+
+        Args:
+            weight_path (str): The path to the weight
+
+        Returns:
+            config_path (str): The path to the config
+
+        """
+        self.uncompress_tar_file()
+        config_path = Path(self.eval_config.weight_path).parent.parent / "config.yaml"
+        return config_path
+
+    def update_config(self):
+        """update evalution config"""
+        self.pdx_config.update_dataset(self.global_config.dataset_dir, "TSCLSDataset")
+
+    def get_eval_kwargs(self) -> dict:
+        """get key-value arguments of model evalution function
+
+        Returns:
+            dict: the arguments of evaluation function.
+        """
+        return {
+            "weight_path": self.eval_config.weight_path,
+            "device": self.get_device(using_device_number=1),
+        }
+
+    def uncompress_tar_file(self):
+        """unpackage the tar file containing training outputs and update weight path"""
+        if tarfile.is_tarfile(self.eval_config.weight_path):
+            dest_path = Path(self.eval_config.weight_path).parent
+            with tarfile.open(self.eval_config.weight_path, "r") as tar:
+                tar.extractall(path=dest_path)
+            self.eval_config.weight_path = dest_path.joinpath(
+                "best_accuracy.pdparams/best_model/model.pdparams"
+            )

paddlex/modules/ts_classification/exportor.py

@@ -0,0 +1,45 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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.
+
+import tarfile
+from pathlib import Path
+
+from ..base import BaseExportor
+from .model_list import MODELS
+from ...utils import logging
+
+
+class TSCLSExportor(BaseExportor):
+    """Image Classification Model Exportor"""
+
+    entities = MODELS
+
+    def get_config_path(self, weight_path):
+        """
+        get config path
+
+        Args:
+            weight_path (str): The path to the weight
+
+        Returns:
+            config_path (str): The path to the config
+
+        """
+        config_path = Path(self.export_config.weight_path).parent.parent / "config.yaml"
+        if not config_path.exists():
+            logging.warning(
+                f"The config file(`{config_path}`) related to weight file(`{weight_path}`) is not exist, use default instead."
+            )
+            config_path = None
+        return config_path

paddlex/modules/ts_classification/model_list.py

@@ -0,0 +1,18 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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.
+
+
+MODELS = [
+    "TimesNet_cls",
+]