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

paddlex/modules/face_recognition/dataset_checker/__init__.py

@@ -0,0 +1,71 @@
+# 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
+from pathlib import Path
+
+from ...base import BaseDatasetChecker
+from .dataset_src import check_train, check_val
+from ..model_list import MODELS
+
+
+class FaceRecDatasetChecker(BaseDatasetChecker):
+    """Dataset Checker for Image Classification Model"""
+
+    entities = MODELS
+    sample_num = 10
+
+    def get_dataset_root(self, dataset_dir: str) -> str:
+        """find the dataset root dir
+
+        Args:
+            dataset_dir (str): the directory that contain dataset.
+
+        Returns:
+            str: the root directory of dataset.
+        """
+        anno_dirs = list(Path(dataset_dir).glob("**/images"))
+        assert len(anno_dirs) == 2
+        dataset_dir = anno_dirs[0].parent.parent.as_posix()
+        return dataset_dir
+
+    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.
+        """
+        train_attr = check_train(os.path.join(dataset_dir, "train"), self.output)
+        val_attr = check_val(os.path.join(dataset_dir, "val"), self.output)
+        train_attr.update(val_attr)
+        return train_attr
+
+    def get_show_type(self) -> str:
+        """get the show type of dataset
+
+        Returns:
+            str: show type
+        """
+        return "image"
+
+    def get_dataset_type(self) -> str:
+        """return the dataset type
+
+        Returns:
+            str: dataset type
+        """
+        return "ClsDataset"

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

@@ -0,0 +1,16 @@
+# 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_train, check_val

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

@@ -0,0 +1,174 @@
+# 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 random
+import pickle
+from PIL import Image, ImageOps
+from collections import defaultdict
+from tqdm import tqdm
+
+from .....utils.errors import DatasetFileNotFoundError, CheckFailedError
+from .utils.visualizer import draw_label
+
+
+def check_train(dataset_dir, output, sample_num=10):
+    """check dataset"""
+    dataset_dir = osp.abspath(dataset_dir)
+    # Custom dataset
+    if not osp.exists(dataset_dir) or not osp.isdir(dataset_dir):
+        raise DatasetFileNotFoundError(file_path=dataset_dir)
+
+    delim = " "
+    valid_num_parts = 2
+
+    label_map_dict = dict()
+    sample_paths = []
+    labels = []
+
+    label_file = osp.join(dataset_dir, "label.txt")
+    if not osp.exists(label_file):
+        raise DatasetFileNotFoundError(
+            file_path=label_file,
+            solution=f"Ensure that `label.txt` exist in {dataset_dir}",
+        )
+    with open(label_file, "r", encoding="utf-8") as f:
+        all_lines = f.readlines()
+        random.seed(123)
+        random.shuffle(all_lines)
+        sample_cnts = len(all_lines)
+        for line in all_lines:
+            substr = line.strip("\n").split(delim)
+            if len(substr) != valid_num_parts:
+                raise CheckFailedError(
+                    f"The number of delimiter-separated items in each row in {label_file} \
+                            should be {valid_num_parts} (current delimiter is '{delim}')."
+                )
+            file_name = substr[0]
+            label = substr[1]
+
+            img_path = osp.join(dataset_dir, file_name)
+
+            if not osp.exists(img_path):
+                raise DatasetFileNotFoundError(file_path=img_path)
+
+            vis_save_dir = osp.join(output, "demo_img")
+            if not osp.exists(vis_save_dir):
+                os.makedirs(vis_save_dir)
+
+            try:
+                label = int(label)
+                label_map_dict[label] = str(label)
+            except (ValueError, TypeError) as e:
+                raise CheckFailedError(
+                    f"Ensure that the second number in each line in {label_file} should be int."
+                ) from e
+
+            if len(sample_paths) < sample_num:
+                img = Image.open(img_path)
+                img = ImageOps.exif_transpose(img)
+                vis_im = draw_label(img, label, label_map_dict)
+                vis_path = osp.join(vis_save_dir, osp.basename(file_name))
+                vis_im.save(vis_path)
+                sample_path = osp.join(
+                    "check_dataset", os.path.relpath(vis_path, output)
+                )
+                sample_paths.append(sample_path)
+            labels.append(label)
+    if min(labels) != 0:
+        raise CheckFailedError(
+            f"Ensure that the index starts from 0 in `{label_file}`."
+        )
+    num_classes = max(labels) + 1
+    attrs = {}
+    attrs["train_label_file"] = osp.relpath(label_file, output)
+    attrs["train_num_classes"] = num_classes
+    attrs["train_samples"] = sample_cnts
+    attrs["train_sample_paths"] = sample_paths
+    return attrs
+
+
+def check_val(dataset_dir, output, sample_num=10):
+    """check dataset"""
+    dataset_dir = osp.abspath(dataset_dir)
+    # Custom dataset
+    if not osp.exists(dataset_dir) or not osp.isdir(dataset_dir):
+        raise DatasetFileNotFoundError(file_path=dataset_dir)
+
+    delim = " "
+    valid_num_parts = 3
+
+    labels = []
+    sample_paths = []
+    label_file = osp.join(dataset_dir, "pair_label.txt")
+    if not osp.exists(label_file):
+        raise DatasetFileNotFoundError(
+            file_path=label_file,
+            solution=f"Ensure that `label.txt` exist in {dataset_dir}",
+        )
+    with open(label_file, "r", encoding="utf-8") as f:
+        all_lines = f.readlines()
+        random.seed(123)
+        random.shuffle(all_lines)
+        sample_cnts = len(all_lines)
+        for line in all_lines:
+            substr = line.strip("\n").split(delim)
+            if len(substr) != valid_num_parts:
+                raise CheckFailedError(
+                    f"The number of delimiter-separated items in each row in {label_file} \
+                            should be {valid_num_parts} (current delimiter is '{delim}')."
+                )
+            left_file_name = substr[0]
+            right_file_name = substr[1]
+            label = substr[2]
+
+            left_img_path = osp.join(dataset_dir, left_file_name)
+            if not osp.exists(left_img_path):
+                raise DatasetFileNotFoundError(file_path=left_img_path)
+
+            right_img_path = osp.join(dataset_dir, right_file_name)
+            if not osp.exists(right_img_path):
+                raise DatasetFileNotFoundError(file_path=right_img_path)
+
+            try:
+                label = int(label)
+                assert label in [0, 1], "Face eval dataset only support two classes"
+            except (ValueError, TypeError) as e:
+                raise CheckFailedError(
+                    f"Ensure that the second number in each line in {label_file} should be int."
+                ) from e
+
+            vis_save_dir = osp.join(output, "demo_img")
+            if not osp.exists(vis_save_dir):
+                os.makedirs(vis_save_dir)
+
+            if len(sample_paths) < sample_num:
+                img = Image.open(left_img_path)
+                img = ImageOps.exif_transpose(img)
+                vis_path = osp.join(vis_save_dir, osp.basename(left_file_name))
+                img.save(vis_path)
+                sample_path = osp.join(
+                    "check_dataset", os.path.relpath(vis_path, output)
+                )
+                sample_paths.append(sample_path)
+
+            labels.append(label)
+    num_classes = max(labels) + 1
+    attrs = {}
+    attrs["val_label_file"] = osp.relpath(label_file, output)
+    attrs["val_num_classes"] = num_classes
+    attrs["val_samples"] = sample_cnts
+    attrs["val_sample_paths"] = sample_paths
+    return attrs

paddlex/modules/face_recognition/dataset_checker/dataset_src/utils/__init__.py

@@ -0,0 +1,13 @@
+# 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.

paddlex/modules/face_recognition/dataset_checker/dataset_src/utils/visualizer.py

@@ -0,0 +1,156 @@
+# 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 numpy as np
+import json
+from pathlib import Path
+import PIL
+from PIL import Image, ImageDraw, ImageFont
+
+from ......utils.fonts import PINGFANG_FONT_FILE_PATH
+
+
+def colormap(rgb=False):
+    """
+    Get colormap
+    """
+    color_list = np.array(
+        [
+            0xFF,
+            0x00,
+            0x00,
+            0xCC,
+            0xFF,
+            0x00,
+            0x00,
+            0xFF,
+            0x66,
+            0x00,
+            0x66,
+            0xFF,
+            0xCC,
+            0x00,
+            0xFF,
+            0xFF,
+            0x4D,
+            0x00,
+            0x80,
+            0xFF,
+            0x00,
+            0x00,
+            0xFF,
+            0xB2,
+            0x00,
+            0x1A,
+            0xFF,
+            0xFF,
+            0x00,
+            0xE5,
+            0xFF,
+            0x99,
+            0x00,
+            0x33,
+            0xFF,
+            0x00,
+            0x00,
+            0xFF,
+            0xFF,
+            0x33,
+            0x00,
+            0xFF,
+            0xFF,
+            0x00,
+            0x99,
+            0xFF,
+            0xE5,
+            0x00,
+            0x00,
+            0xFF,
+            0x1A,
+            0x00,
+            0xB2,
+            0xFF,
+            0x80,
+            0x00,
+            0xFF,
+            0xFF,
+            0x00,
+            0x4D,
+        ]
+    ).astype(np.float32)
+    color_list = color_list.reshape((-1, 3))
+    if not rgb:
+        color_list = color_list[:, ::-1]
+    return color_list.astype("int32")
+
+
+def font_colormap(color_index):
+    """
+    Get font colormap
+    """
+    dark = np.array([0x14, 0x0E, 0x35])
+    light = np.array([0xFF, 0xFF, 0xFF])
+    light_indexs = [0, 3, 4, 8, 9, 13, 14, 18, 19]
+    if color_index in light_indexs:
+        return light.astype("int32")
+    else:
+        return dark.astype("int32")
+
+
+def draw_label(image, label, label_map_dict):
+    """Draw label on image"""
+    image = image.convert("RGB")
+    image_size = image.size
+    draw = ImageDraw.Draw(image)
+    min_font_size = int(image_size[0] * 0.02)
+    max_font_size = int(image_size[0] * 0.05)
+    for font_size in range(max_font_size, min_font_size - 1, -1):
+        font = ImageFont.truetype(PINGFANG_FONT_FILE_PATH, font_size, encoding="utf-8")
+        if tuple(map(int, PIL.__version__.split("."))) <= (10, 0, 0):
+            text_width_tmp, text_height_tmp = draw.textsize(
+                label_map_dict[int(label)], font
+            )
+        else:
+            left, top, right, bottom = draw.textbbox(
+                (0, 0), label_map_dict[int(label)], font
+            )
+            text_width_tmp, text_height_tmp = right - left, bottom - top
+        if text_width_tmp <= image_size[0]:
+            break
+        else:
+            font = ImageFont.truetype(PINGFANG_FONT_FILE_PATH, min_font_size)
+    color_list = colormap(rgb=True)
+    color = tuple(color_list[0])
+    font_color = tuple(font_colormap(3))
+    if tuple(map(int, PIL.__version__.split("."))) <= (10, 0, 0):
+        text_width, text_height = draw.textsize(label_map_dict[int(label)], font)
+    else:
+        left, top, right, bottom = draw.textbbox(
+            (0, 0), label_map_dict[int(label)], font
+        )
+        text_width, text_height = right - left, bottom - top
+
+    rect_left = 3
+    rect_top = 3
+    rect_right = rect_left + text_width + 3
+    rect_bottom = rect_top + text_height + 6
+
+    draw.rectangle([(rect_left, rect_top), (rect_right, rect_bottom)], fill=color)
+
+    text_x = rect_left + 3
+    text_y = rect_top
+    draw.text((text_x, text_y), label_map_dict[int(label)], fill=font_color, font=font)
+
+    return image

paddlex/modules/face_recognition/evaluator.py

@@ -0,0 +1,52 @@
+# 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
+
+from ...utils.misc import abspath
+from ..base import BaseEvaluator
+from .model_list import MODELS
+
+
+class FaceRecEvaluator(BaseEvaluator):
+    """Face Recognition Model Evaluator"""
+
+    entities = MODELS
+
+    def update_config(self):
+        """update evalution config"""
+        if self.eval_config.log_interval:
+            self.pdx_config.update_log_interval(self.eval_config.log_interval)
+        self.update_dataset_cfg()
+        self.pdx_config.update_pretrained_weights(self.eval_config.weight_path)
+
+    def update_dataset_cfg(self):
+        val_dataset_dir = abspath(os.path.join(self.global_config.dataset_dir, "val"))
+        val_list_path = abspath(os.path.join(val_dataset_dir, "pair_label.txt"))
+        ds_cfg = [
+            f"DataLoader.Eval.dataset.name=FaceEvalDataset",
+            f"DataLoader.Eval.dataset.dataset_root={val_dataset_dir}",
+            f"DataLoader.Eval.dataset.pair_label_path={val_list_path}",
+        ]
+        self.pdx_config.update(ds_cfg)
+
+    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),
+        }

paddlex/modules/face_recognition/exportor.py

@@ -0,0 +1,22 @@
+# 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 ..base import BaseExportor
+from .model_list import MODELS
+
+
+class FaceRecExportor(BaseExportor):
+    """Face Recognition Model Exportor"""
+
+    entities = MODELS

paddlex/modules/face_recognition/model_list.py

@@ -0,0 +1,15 @@
+# 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 = ["MobileFaceNet", "ResNet50_face"]

paddlex/modules/face_recognition/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
+from pathlib import Path
+
+from ...utils.misc import abspath
+from ..image_classification import ClsTrainer
+from .model_list import MODELS
+
+
+class FaceRecTrainer(ClsTrainer):
+    """Face Recognition Model Trainer"""
+
+    entities = MODELS
+
+    def update_config(self):
+        """update training config"""
+        if self.train_config.log_interval:
+            self.pdx_config.update_log_interval(self.train_config.log_interval)
+        if self.train_config.eval_interval:
+            self.pdx_config.update_eval_interval(self.train_config.eval_interval)
+        if self.train_config.save_interval:
+            self.pdx_config.update_save_interval(self.train_config.save_interval)
+
+        self.update_dataset_cfg()
+        if self.train_config.num_classes is not None:
+            self.update_num_classes(self.train_config.num_classes)
+        if self.train_config.pretrain_weight_path != "":
+            self.pdx_config.update_pretrained_weights(
+                self.train_config.pretrain_weight_path
+            )
+        
+        self.update_arcmargin_cfg(self.train_config.arcmargin_m, 
+                                  self.train_config.arcmargin_s,
+                                  self.train_config.feature_dim)
+
+        label_dict_path = Path(self.global_config.dataset_dir).joinpath("label.txt")
+        if label_dict_path.exists():
+            self.dump_label_dict(label_dict_path)
+        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.warmup_steps is not None:
+            self.pdx_config.update_warmup_epochs(self.train_config.warmup_steps)
+        if self.global_config.output is not None:
+            self.pdx_config._update_output_dir(self.global_config.output)
+
+    def update_dataset_cfg(self):
+        train_dataset_dir = abspath(
+            os.path.join(self.global_config.dataset_dir, "train")
+        )
+        val_dataset_dir = abspath(os.path.join(self.global_config.dataset_dir, "val"))
+        train_list_path = abspath(os.path.join(train_dataset_dir, "label.txt"))
+        val_list_path = abspath(os.path.join(val_dataset_dir, "pair_label.txt"))
+
+        ds_cfg = [
+            f"DataLoader.Train.dataset.name=ClsDataset",
+            f"DataLoader.Train.dataset.image_root={train_dataset_dir}",
+            f"DataLoader.Train.dataset.cls_label_path={train_list_path}",
+            f"DataLoader.Eval.dataset.name=FaceEvalDataset",
+            f"DataLoader.Eval.dataset.dataset_root={val_dataset_dir}",
+            f"DataLoader.Eval.dataset.pair_label_path={val_list_path}",
+        ]
+        self.pdx_config.update(ds_cfg)
+    
+    def update_arcmargin_cfg(self, m, s, dim):
+        mg_cfg = [
+            f"Arch.Head.margin={m}",
+            f"Arch.Head.scale={s}",
+        ]
+        if self.pdx_config.model_name == 'MobileFaceNet':
+            mg_cfg.append(f"Arch.Backbone.num_features={dim}")
+        elif self.pdx_config.model_name == 'ResNet50_face':
+            mg_cfg.append(f"Arch.Backbone.class_num={dim}")
+        mg_cfg.append(f"Arch.Head.embedding_size={dim}")
+
+        self.pdx_config.update(mg_cfg)
+
+    def update_num_classes(self, num_classes):
+        nc_cfg = [f"Arch.Head.class_num={num_classes}"]
+        self.pdx_config.update(nc_cfg)
+ 

paddlex/modules/formula_recognition/__init__.py

@@ -0,0 +1,13 @@
+# 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.

paddlex/modules/formula_recognition/model_list.py

@@ -0,0 +1,17 @@
+# 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 = [
+    "LaTeX_OCR_rec",
+]

paddlex/modules/general_recognition/__init__.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.
+
+from .trainer import ShiTuRecTrainer
+from .dataset_checker import ShiTuRecDatasetChecker
+from .evaluator import ShiTuRecEvaluator
+from .exportor import ShiTuRecExportor