paddlex 3.0.0b2__py3-none-any.whl → 3.0.0rc0__py3-none-any.whl

paddlex/modules/formula_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 ("FormulaRecDataset"):
+        anno_suffix = ".txt"
+    else:
+        raise ConvertFailedError(
+            message=f"数据格式转换失败！不支持{dataset_type}格式数据集。当前仅支持 FormulaRecDataset 格式。"
+        )
+
+    err_msg_prefix = f"数据格式转换失败！请参考上述`{dataset_type}格式数据集示例`检查待转换数据集格式。"
+
+    for anno in ["train.txt", "val.txt"]:
+        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 ("FormulaRecDataset"):
+        convert_pkl_dataset(input_dir)
+    else:
+        raise ConvertFailedError(
+            message=f"数据格式转换失败！不支持{dataset_type}格式数据集。当前仅支持 FormulaRecDataset 格式。"
+        )
+
+
+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/formula_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/formula_recognition/evaluator.py

@@ -0,0 +1,77 @@
+# 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
+
+
+class FormulaRecEvaluator(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"
+            )
+        elif self.global_config["model"] in (
+            "UniMERNet",
+            "PP-FormulaNet-L",
+            "PP-FormulaNet-S",
+        ):
+            self.pdx_config.update_dataset(
+                self.global_config.dataset_dir, "SimpleDataSet"
+            )
+        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)
+
+        if self.eval_config.batch_size is not None:
+            if self.global_config["model"] == "LaTeX_OCR_rec":
+                self.pdx_config.update_batch_size_pair(
+                    self.eval_config.batch_size, mode="eval"
+                )
+            else:
+                self.pdx_config.update_batch_size(
+                    self.eval_config.batch_size, mode="eval"
+                )
+
+        if self.eval_config.get("delimiter", None) is not None:
+            self.pdx_config.update_delimiter(self.eval_config.delimiter, mode="eval")
+
+    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/formula_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 FormulaRecExportor(BaseExportor):
+    """Text Recognition Model Exportor"""
+
+    entities = MODELS

paddlex/modules/formula_recognition/model_list.py

@@ -14,4 +14,7 @@
 
 MODELS = [
     "LaTeX_OCR_rec",
+    "UniMERNet",
+    "PP-FormulaNet-S",
+    "PP-FormulaNet-L",
 ]

paddlex/modules/formula_recognition/trainer.py

@@ -0,0 +1,121 @@
+# 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 pathlib import Path
+
+from ..base import BaseTrainer
+from ...utils.config import AttrDict
+from .model_list import MODELS
+
+
+class FormulaRecTrainer(BaseTrainer):
+    """Text Recognition Model Trainer"""
+
+    entities = MODELS
+
+    def dump_label_dict(self, src_label_dict_path: str):
+        """dump label dict config
+
+        Args:
+            src_label_dict_path (str): path to label dict file to be saved.
+        """
+        dst_label_dict_path = Path(self.global_config.output).joinpath("label_dict.txt")
+        shutil.copyfile(src_label_dict_path, dst_label_dict_path)
+
+    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_by_epoch(
+                self.train_config.eval_interval
+            )
+        if self.train_config.save_interval:
+            self.pdx_config.update_save_interval(self.train_config.save_interval)
+
+        if self.global_config["model"] == "LaTeX_OCR_rec":
+            self.pdx_config.update_dataset(
+                self.global_config.dataset_dir, "LaTeXOCRDataSet"
+            )
+        elif self.global_config["model"] in (
+            "UniMERNet",
+            "PP-FormulaNet-L",
+            "PP-FormulaNet-S",
+        ):
+            self.pdx_config.update_dataset(
+                self.global_config.dataset_dir, "SimpleDataSet"
+            )
+
+        label_dict_path = Path(self.global_config.dataset_dir).joinpath("dict.txt")
+        if label_dict_path.exists():
+            self.pdx_config.update_label_dict_path(label_dict_path)
+            self.dump_label_dict(label_dict_path)
+
+        if self.train_config.pretrain_weight_path:
+            self.pdx_config.update_pretrained_weights(
+                self.train_config.pretrain_weight_path
+            )
+
+        if self.train_config.batch_size is not None:
+            if self.global_config["model"] == "LaTeX_OCR_rec":
+                self.pdx_config.update_batch_size_pair(
+                    self.train_config.batch_size, mode="train"
+                )
+            else:
+                self.pdx_config.update_batch_size(
+                    self.train_config.batch_size, mode="train"
+                )
+
+        if self.eval_config.batch_size is not None:
+            if self.global_config["model"] == "LaTeX_OCR_rec":
+                self.pdx_config.update_batch_size_pair(
+                    self.eval_config.batch_size, mode="eval"
+                )
+            else:
+                self.pdx_config.update_batch_size(
+                    self.eval_config.batch_size, mode="eval"
+                )
+
+        if self.train_config.learning_rate is not None:
+            self.pdx_config.update_learning_rate(self.train_config.learning_rate)
+
+        if self.train_config.get("delimiter", None) is not None:
+            self.pdx_config.update_delimiter(self.train_config.delimiter, mode="train")
+
+        if self.eval_config.get("delimiter", None) is not None:
+            self.pdx_config.update_delimiter(self.eval_config.delimiter, mode="eval")
+
+        if self.train_config.epochs_iters is not None:
+            self.pdx_config._update_epochs(self.train_config.epochs_iters)
+        if (
+            self.train_config.resume_path is not None
+            and self.train_config.resume_path != ""
+        ):
+            self.pdx_config._update_checkpoints(self.train_config.resume_path)
+        if self.global_config.output is not None:
+            self.pdx_config._update_output_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.
+        """
+        return {
+            "device": self.get_device(),
+            "dy2st": self.train_config.get("dy2st", False),
+        }

paddlex/modules/image_classification/model_list.py

@@ -56,6 +56,7 @@ MODELS = [
     "PP-HGNetV2-B5",
     "PP-HGNetV2-B6",
     "PP-LCNet_x0_25",
+    "PP-LCNet_x0_25_textline_ori",
     "PP-LCNet_x0_35",
     "PP-LCNet_x0_5",
     "PP-LCNet_x0_75",
@@ -94,4 +95,5 @@ MODELS = [
     "FasterNet-T0",
     "FasterNet-T1",
     "FasterNet-T2",
+    "PP-LCNet_x1_0_table_cls",
 ]

paddlex/modules/instance_segmentation/dataset_checker/__init__.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import os
+from pathlib import Path
 
 from .dataset_src import check, convert, split_dataset, deep_analyse
 from ...base import BaseDatasetChecker
@@ -26,6 +27,20 @@ class COCOInstSegDatasetChecker(BaseDatasetChecker):
     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) == 1
+        dataset_dir = anno_dirs[0].parent.as_posix()
+        return dataset_dir
+
     def convert_dataset(self, src_dataset_dir: str) -> str:
         """convert the dataset from other type to specified type
 

paddlex/modules/keypoint_detection/__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 KeypointTrainer
+from .dataset_checker import KeypointDatasetChecker
+from .evaluator import KeypointEvaluator
+from .exportor import KeypointExportor

paddlex/modules/keypoint_detection/dataset_checker/__init__.py

@@ -0,0 +1,56 @@
+# 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 ...object_detection.dataset_checker import COCODatasetChecker
+from .dataset_src import check
+from ..model_list import MODELS
+
+
+class KeypointDatasetChecker(COCODatasetChecker):
+    """Dataset Checker for Object Detection Model"""
+
+    entities = MODELS
+    sample_num = 10
+
+    def get_dataset_type(self) -> str:
+        """return the dataset type
+
+        Returns:
+            str: dataset type
+        """
+        return "KeypointTopDownCocoDetDataset"
+
+    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 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.
+        """
+        dst_dataset_dir = src_dataset_dir
+        return dst_dataset_dir

paddlex/modules/keypoint_detection/dataset_checker/dataset_src/__init__.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.
+
+from .check_dataset import check

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

@@ -0,0 +1,86 @@
+# 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 pathlib import Path
+from PIL import Image, ImageOps
+import json
+from pycocotools.coco import COCO
+
+from .....utils.errors import DatasetFileNotFoundError
+from .utils.visualizer import draw_keypoint
+
+
+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()
+    sample_paths = defaultdict(list)
+    im_sizes = defaultdict(Counter)
+    tags = ["instance_train", "instance_val"]
+    for _, tag in enumerate(tags):
+        file_list = osp.join(dataset_dir, f"annotations/{tag}.json")
+        if not osp.exists(file_list):
+            if tag in ("instance_train", "instance_val"):
+                # train and val file lists must exist
+                raise DatasetFileNotFoundError(
+                    file_path=file_list,
+                    solution=f"Ensure that both `instance_train.json` and `instance_val.json` exist in \
+{dataset_dir}/annotations",
+                )
+            else:
+                continue
+        else:
+            with open(file_list, "r", encoding="utf-8") as f:
+                jsondata = json.load(f)
+
+            coco = COCO(file_list)
+            num_class = len(coco.getCatIds())
+
+            vis_save_dir = osp.join(output, "demo_img")
+
+            image_info = jsondata["images"]
+            sample_cnts[tag] = len(image_info)
+            sample_num = min(sample_num, len(image_info))
+            for i in range(sample_num):
+                file_name = image_info[i]["file_name"]
+                img_id = image_info[i]["id"]
+                img_path = osp.join(dataset_dir, "images", file_name)
+                if not osp.exists(img_path):
+                    raise DatasetFileNotFoundError(file_path=img_path)
+                img = Image.open(img_path)
+                img = ImageOps.exif_transpose(img)
+                vis_im = draw_keypoint(img, coco, img_id)
+                vis_path = osp.join(vis_save_dir, file_name)
+                Path(vis_path).parent.mkdir(parents=True, exist_ok=True)
+                vis_im.save(vis_path)
+                sample_path = osp.join(
+                    "check_dataset", os.path.relpath(vis_path, output)
+                )
+                sample_paths[tag].append(sample_path)
+
+    attrs = {}
+    attrs["num_classes"] = num_class
+    attrs["train_samples"] = sample_cnts["instance_train"]
+    attrs["train_sample_paths"] = sample_paths["instance_train"]
+
+    attrs["val_samples"] = sample_cnts["instance_val"]
+    attrs["val_sample_paths"] = sample_paths["instance_val"]
+    return attrs

paddlex/modules/keypoint_detection/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.