paddlex 2.1.0__py3-none-any.whl → 3.0.0b2__py3-none-any.whl

paddlex/modules/text_recognition/dataset_checker/__init__.py

@@ -0,0 +1,114 @@
+# 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, split_dataset, deep_analyse, convert
+
+from ..model_list import MODELS
+from ...formula_recognition.model_list import MODELS as MODELS_LaTeX
+
+MODELS = MODELS + MODELS_LaTeX
+
+
+class TextRecDatasetChecker(BaseDatasetChecker):
+    """Dataset Checker for Text Recognition 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(
+            self.check_dataset_config.convert.src_dataset_type, 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.global_config.output,
+            sample_num=10,
+            dataset_type=self.get_dataset_type(),
+        )
+
+    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.
+        """
+        if self.global_config["model"] in ["LaTeX_OCR_rec"]:
+            datatype = "LaTeXOCRDataset"
+        else:
+            datatype = "MSTextRecDataset"
+        return deep_analyse(dataset_dir, self.output, datatype=datatype)
+
+    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
+        """
+        if self.global_config["model"] in ["LaTeX_OCR_rec"]:
+            return "LaTeXOCRDataset"
+        else:
+            return "MSTextRecDataset"

paddlex/modules/text_recognition/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/text_recognition/dataset_checker/dataset_src/analyse_dataset.py

@@ -0,0 +1,161 @@
+# 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 math
+import platform
+from pathlib import Path
+
+from collections import defaultdict
+from PIL import Image
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.backends.backend_agg import FigureCanvasAgg
+from matplotlib import font_manager
+
+from .....utils.file_interface import custom_open
+from .....utils.logging import warning
+from .....utils.fonts import PINGFANG_FONT_FILE_PATH
+
+
+def simple_analyse(dataset_path, images_dict):
+    """
+    Analyse the dataset samples by return image path and label path
+
+    Args:
+        dataset_path (str): dataset path
+        ds_meta (dict): dataset meta
+        images_dict (dict): train, val and test image path
+
+    Returns:
+        tuple: tuple of sample number, image path and label path for train, val and text subdataset.
+
+    """
+    tags = ["train", "val", "test"]
+    sample_cnts = defaultdict(int)
+    img_paths = defaultdict(list)
+    res = [None] * 6
+
+    for tag in tags:
+        file_list = os.path.join(dataset_path, f"{tag}.txt")
+        if not os.path.exists(file_list):
+            if tag in ("train", "val"):
+                res.insert(0, "数据集不符合规范，请先通过数据校准")
+                return res
+            else:
+                continue
+        else:
+            with custom_open(file_list, "r") as f:
+                all_lines = f.readlines()
+
+            # Each line corresponds to a sample
+            sample_cnts[tag] = len(all_lines)
+            img_paths[tag] = images_dict[tag]
+
+    return (
+        "完成数据分析",
+        sample_cnts[tags[0]],
+        sample_cnts[tags[1]],
+        sample_cnts[tags[2]],
+        img_paths[tags[0]],
+        img_paths[tags[1]],
+        img_paths[tags[2]],
+    )
+
+
+def deep_analyse(dataset_path, output, datatype="MSTextRecDataset"):
+    """class analysis for dataset"""
+    tags = ["train", "val"]
+    all_instances = 0
+    labels_cnt = {}
+    x_max = []
+    classes_max = []
+    for tag in tags:
+        image_path = os.path.join(dataset_path, f"{tag}.txt")
+        str_nums = []
+        with custom_open(image_path, "r") as f:
+            lines = f.readlines()
+        for line in lines:
+            line = line.strip().split("\t")
+            if len(line) != 2:
+                warning(f"Error in {line}.")
+                continue
+            str_nums.append(len(line[1]))
+        if datatype == "LaTeXOCRDataset":
+            max_length = min(768, max(str_nums))
+            interval = 20
+        else:
+            max_length = min(100, max(str_nums))
+            interval = 5
+        start = 0
+        for i in range(1, math.ceil((max_length / interval))):
+            stop = i * interval
+            num_str = sum(start < i <= stop for i in str_nums)
+            labels_cnt[f"{start}-{stop}"] = num_str
+            start = stop
+        if sum(max_length < i for i in str_nums) != 0:
+            labels_cnt[f"> {max_length}"] = sum(max_length < i for i in str_nums)
+        if tag == "train":
+            cnts_train = [cat_ids for cat_name, cat_ids in labels_cnt.items()]
+            x_train = np.arange(len(cnts_train))
+            if len(x_train) > len(x_max):
+                x_max = x_train
+                classes_max = [cat_name for cat_name, cat_ids in labels_cnt.items()]
+        elif tag == "val":
+            cnts_val = [cat_ids for cat_name, cat_ids in labels_cnt.items()]
+            x_val = np.arange(len(cnts_val))
+            if len(x_val) > len(x_max):
+                x_max = x_val
+                classes_max = [cat_name for cat_name, cat_ids in labels_cnt.items()]
+
+    width = 0.3
+
+    # 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, size=15)
+    if datatype == "LaTeXOCRDataset":
+        fig, ax = plt.subplots(figsize=(15, 9), dpi=120)
+        xlabel_name = "公式长度区间"
+    else:
+        fig, ax = plt.subplots(figsize=(10, 5), dpi=120)
+        xlabel_name = "文本字长度区间"
+    ax.bar(x_train, cnts_train, width=0.3, label="train")
+    ax.bar(x_val + width, cnts_val, width=0.3, label="val")
+    plt.xticks(x_max + width / 2, classes_max, rotation=90)
+    plt.legend(prop={"size": 18})
+    ax.set_xlabel(
+        xlabel_name,
+        fontproperties=None if os_system == "windows" else font,
+        fontsize=12,
+    )
+    ax.set_ylabel(
+        "图片数量", fontproperties=None if os_system == "windows" else font, fontsize=12
+    )
+
+    canvas = FigureCanvasAgg(fig)
+    canvas.draw()
+    width, height = fig.get_size_inches() * fig.get_dpi()
+    pie_array = np.frombuffer(canvas.tostring_rgb(), dtype="uint8").reshape(
+        int(height), int(width), 3
+    )
+    fig1_path = os.path.join(output, "histogram.png")
+    cv2.imwrite(fig1_path, pie_array)
+
+    return {"histogram": os.path.join("check_dataset", "histogram.png")}

paddlex/modules/text_recognition/dataset_checker/dataset_src/check_dataset.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
+
+from PIL import Image
+import json
+import numpy as np
+
+from .....utils.errors import DatasetFileNotFoundError, CheckFailedError
+
+
+def check(
+    dataset_dir, output, dataset_type="MSTextRecDataset", mode="fast", sample_num=10
+):
+    """check dataset"""
+    if dataset_type == "SimpleDataSet" or "MSTextRecDataset" or "LaTeXOCRDataset":
+        # Custom dataset
+        if not osp.exists(dataset_dir) or not osp.isdir(dataset_dir):
+            raise DatasetFileNotFoundError(file_path=dataset_dir)
+        tags = ["train", "val"]
+        delim = "\t"
+        valid_num_parts = 2
+        max_recorded_sample_cnts = 50
+        sample_cnts = dict()
+        sample_paths = defaultdict(list)
+        if dataset_type == "LaTeXOCRDataset":
+            dict_file = osp.join(dataset_dir, "latex_ocr_tokenizer.json")
+            if not osp.exists(dict_file):
+                raise DatasetFileNotFoundError(
+                    file_path=dict_file,
+                    solution=f"Ensure that `latex_ocr_tokenizer.json` exist in {dataset_dir}",
+                )
+        else:
+            dict_file = osp.join(dataset_dir, "dict.txt")
+            if not osp.exists(dict_file):
+                raise DatasetFileNotFoundError(
+                    file_path=dict_file,
+                    solution=f"Ensure that `dict.txt` exist in {dataset_dir}",
+                )
+        for tag in tags:
+            file_list = osp.join(dataset_dir, f"{tag}.txt")
+            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.txt` and `val.txt` exist in {dataset_dir}",
+                    )
+                else:
+                    # tag == 'test'
+                    continue
+            else:
+                with open(file_list, "r", encoding="utf-8") as f:
+                    all_lines = f.readlines()
+                    sample_cnts[tag] = len(all_lines)
+                    for line in all_lines:
+                        substr = line.strip("\n").split(delim)
+                        if len(line.strip("\n")) < 1:
+                            continue
+                        if len(substr) != valid_num_parts and len(line.strip("\n")) > 1:
+                            raise CheckFailedError(
+                                f"Error in {line}, The number of delimiter-separated items in each row "
+                                "in {file_list} should be {valid_num_parts} (current delimiter is '{delim}')."
+                            )
+                        file_name = substr[0]
+                        img_path = osp.join(dataset_dir, file_name)
+                        if len(sample_paths[tag]) < max_recorded_sample_cnts:
+                            sample_paths[tag].append(os.path.relpath(img_path, output))
+
+                        if not os.path.exists(img_path):
+                            raise DatasetFileNotFoundError(file_path=img_path)
+
+        meta = {}
+        meta["train_samples"] = sample_cnts["train"]
+        meta["train_sample_paths"] = sample_paths["train"][:sample_num]
+
+        meta["val_samples"] = sample_cnts["val"]
+        meta["val_sample_paths"] = sample_paths["val"][:sample_num]
+
+        # meta['dict_file'] = dict_file
+
+        return meta

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

@@ -0,0 +1,94 @@
+# 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 math
+import pickle
+from tqdm import tqdm
+from collections import defaultdict
+import imagesize
+from .....utils.errors import ConvertFailedError
+from .....utils.logging import info, warning
+
+
+def check_src_dataset(root_dir, dataset_type):
+    """check src dataset format validity"""
+    if dataset_type in ("MSTextRecDataset"):
+        anno_suffix = ".txt"
+    else:
+        raise ConvertFailedError(
+            message=f"数据格式转换失败！不支持{dataset_type}格式数据集。当前仅支持 MSTextRecDataset 格式。"
+        )
+
+    err_msg_prefix = f"数据格式转换失败！请参考上述`{dataset_type}格式数据集示例`检查待转换数据集格式。"
+
+    for anno in ["train.txt", "val.txt", "latex_ocr_tokenizer.json"]:
+        src_anno_path = os.path.join(root_dir, anno)
+        if not os.path.exists(src_anno_path):
+            raise ConvertFailedError(
+                message=f"{err_msg_prefix}保证{src_anno_path}文件存在。"
+            )
+    return None
+
+
+def convert(dataset_type, input_dir):
+    """convert dataset to pkl format"""
+    # check format validity
+    check_src_dataset(input_dir, dataset_type)
+    if dataset_type in ("MSTextRecDataset"):
+        convert_pkl_dataset(input_dir)
+    else:
+        raise ConvertFailedError(
+            message=f"数据格式转换失败！不支持{dataset_type}格式数据集。当前仅支持 MSTextRecDataset 格式。"
+        )
+
+
+def convert_pkl_dataset(root_dir):
+    for anno in ["train.txt", "val.txt"]:
+        src_img_dir = root_dir
+        src_anno_path = os.path.join(root_dir, anno)
+        txt2pickle(src_img_dir, src_anno_path, root_dir)
+
+
+def txt2pickle(images, equations, save_dir):
+    phase = os.path.basename(equations).replace(".txt", "")
+    save_p = os.path.join(save_dir, "latexocr_{}.pkl".format(phase))
+    min_dimensions = (32, 32)
+    max_dimensions = (672, 192)
+    max_length = 512
+    data = defaultdict(lambda: [])
+    pic_num = 0
+    if images is not None and equations is not None:
+        with open(equations, "r") as f:
+            lines = f.readlines()
+            for l in tqdm(lines, total=len(lines)):
+                l = l.strip()
+                img_name, equation = l.split("\t")
+                img_path = os.path.join(images, img_name)
+                width, height = imagesize.get(img_path)
+                if (
+                    min_dimensions[0] <= width <= max_dimensions[0]
+                    and min_dimensions[1] <= height <= max_dimensions[1]
+                ):
+                    divide_h = math.ceil(height / 16) * 16
+                    divide_w = math.ceil(width / 16) * 16
+                    data[(divide_w, divide_h)].append((equation, img_name))
+                    pic_num += 1
+        data = dict(data)
+        with open(save_p, "wb") as file:
+            pickle.dump(data, file)

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

@@ -0,0 +1,81 @@
+# 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
+from random import shuffle
+
+from .....utils.file_interface import custom_open
+
+
+def split_dataset(dataset_root, train_rate, val_rate):
+    """
+    将图像数据集按照比例分成训练集、验证集和测试集，并生成对应的.txt文件。
+
+    Args:
+        dataset_root (str): 数据集根目录路径。
+        train_rate (int): 训练集占总数据集的比例（%）。
+        val_rate (int): 验证集占总数据集的比例（%）。
+
+    Returns:
+        str: 数据划分结果信息。
+    """
+    sum_rate = train_rate + val_rate
+    if sum_rate != 100:
+        return "训练集、验证集比例之和需要等于100，请修改后重试"
+    tags = ["train", "val"]
+
+    valid_path = False
+    image_files = []
+    for tag in tags:
+        split_image_list = os.path.abspath(os.path.join(dataset_root, f"{tag}.txt"))
+        rename_image_list = os.path.abspath(
+            os.path.join(dataset_root, f"{tag}.txt.bak")
+        )
+        if os.path.exists(split_image_list):
+            with custom_open(split_image_list, "r") as f:
+                lines = f.readlines()
+            image_files = image_files + lines
+            valid_path = True
+            if not os.path.exists(rename_image_list):
+                os.rename(split_image_list, rename_image_list)
+
+    if not valid_path:
+        return f"数据集目录下保存待划分文件{tags[0]}.txt或{tags[1]}.txt不存在，请检查后重试"
+
+    shuffle(image_files)
+    start = 0
+    image_num = len(image_files)
+    rate_list = [train_rate, val_rate]
+    for i, tag in enumerate(tags):
+
+        rate = rate_list[i]
+        if rate == 0:
+            continue
+        if rate > 100 or rate < 0:
+            return f"{tag} 数据集的比例应该在0~100之间."
+
+        end = start + round(image_num * rate / 100)
+        if sum(rate_list[i + 1 :]) == 0:
+            end = image_num
+
+        txt_file = os.path.abspath(os.path.join(dataset_root, tag + ".txt"))
+        with custom_open(txt_file, "w") as f:
+            m = 0
+            for id in range(start, end):
+                m += 1
+                f.write(image_files[id])
+        start = end
+    return dataset_root

paddlex/modules/text_recognition/evaluator.py

@@ -0,0 +1,63 @@
+# 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 pathlib import Path
+
+from ..base import BaseEvaluator
+from .model_list import MODELS
+from ..formula_recognition.model_list import MODELS as MODELS_LaTeX
+
+MODELS = MODELS + MODELS_LaTeX
+
+
+class TextRecEvaluator(BaseEvaluator):
+    """Text 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)
+        if self.global_config["model"] == "LaTeX_OCR_rec":
+            self.pdx_config.update_dataset(
+                self.global_config.dataset_dir, "LaTeXOCRDataSet"
+            )
+        else:
+            self.pdx_config.update_dataset(
+                self.global_config.dataset_dir, "MSTextRecDataset"
+            )
+        label_dict_path = None
+        if self.eval_config.get("label_dict_path"):
+            label_dict_path = self.eval_config.label_dict_path
+        else:
+            label_dict_path = (
+                Path(self.eval_config.weight_path).parent / "label_dict.txt"
+            )
+            if not label_dict_path.exists():
+                label_dict_path = None
+        if label_dict_path is not None:
+            self.pdx_config.update_label_dict_path(label_dict_path)
+
+    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(),
+        }

paddlex/modules/text_recognition/exportor.py

@@ -0,0 +1,25 @@
+# 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
+from ..formula_recognition.model_list import MODELS as MODELS_LaTeX
+
+MODELS = MODELS + MODELS_LaTeX
+
+
+class TextRecExportor(BaseExportor):
+    """Text Recognition Model Exportor"""
+
+    entities = MODELS

paddlex/modules/text_recognition/model_list.py

@@ -0,0 +1,20 @@
+# 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 = [
+    "PP-OCRv4_mobile_rec",
+    "PP-OCRv4_server_rec",
+    "ch_SVTRv2_rec",
+    "ch_RepSVTR_rec",
+]