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

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

@@ -0,0 +1,13 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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/semantic_segmentation/dataset_checker/dataset_src/utils/visualizer.py

@@ -0,0 +1,75 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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 numpy as np
+
+from ......utils.deps import function_requires_deps
+
+
+def get_color_map_list(length):
+    """Returns the color map for visualizing the segmentation mask"""
+    length += 1
+    color_map = length * [0, 0, 0]
+    for i in range(0, length):
+        j = 0
+        lab = i
+        while lab:
+            color_map[i * 3] |= ((lab >> 0) & 1) << (7 - j)
+            color_map[i * 3 + 1] |= ((lab >> 1) & 1) << (7 - j)
+            color_map[i * 3 + 2] |= ((lab >> 2) & 1) << (7 - j)
+            j += 1
+            lab >>= 3
+    color_map = color_map[3:]
+    return color_map
+
+
+@function_requires_deps("opencv-contrib-python")
+def visualize(image, result, weight=0.6, use_multilabel=False):
+    """Convert predict result to color image, and save added image."""
+    import cv2
+
+    color_map = get_color_map_list(256)
+    color_map = [color_map[i : i + 3] for i in range(0, len(color_map), 3)]
+    color_map = np.array(color_map).astype("uint8")
+
+    if not use_multilabel:
+        # Use OpenCV LUT for color mapping
+        c1 = cv2.LUT(result, color_map[:, 0])
+        c2 = cv2.LUT(result, color_map[:, 1])
+        c3 = cv2.LUT(result, color_map[:, 2])
+        pseudo_img = np.dstack((c3, c2, c1))
+
+        vis_result = cv2.addWeighted(image, weight, pseudo_img, 1 - weight, 0)
+    else:
+        vis_result = image.copy()
+        for i in range(result.shape[0]):
+            mask = result[i]
+            c1 = np.where(mask, color_map[i, 0], vis_result[..., 0])
+            c2 = np.where(mask, color_map[i, 1], vis_result[..., 1])
+            c3 = np.where(mask, color_map[i, 2], vis_result[..., 2])
+            pseudo_img = np.dstack((c3, c2, c1)).astype("uint8")
+
+            contour, _ = cv2.findContours(
+                mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
+            )
+            vis_result = cv2.addWeighted(vis_result, weight, pseudo_img, 1 - weight, 0)
+            contour_color = (
+                int(color_map[i, 0]),
+                int(color_map[i, 1]),
+                int(color_map[i, 2]),
+            )
+            vis_result = cv2.drawContours(vis_result, contour, -1, contour_color, 1)
+
+    return vis_result

paddlex/modules/semantic_segmentation/evaluator.py

@@ -0,0 +1,58 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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 BaseEvaluator
+from .model_list import MODELS
+
+
+class SegEvaluator(BaseEvaluator):
+    """Semantic Segmentation Model Evaluator"""
+
+    entities = MODELS
+
+    def update_config(self):
+        """update evaluation config"""
+        self.pdx_config.update_dataset(self.global_config.dataset_dir, "SegDataset")
+        self.pdx_config.update_pretrained_weights(None, is_backbone=True)
+
+    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(weight_path).parent.parent / "config.yaml"
+
+        return config_path
+
+    def get_eval_kwargs(self) -> dict:
+        """get key-value arguments of model evaluation function
+
+        Returns:
+            dict: the arguments of evaluation function.
+        """
+        device = self.get_device()
+        # XXX:
+        os.environ.pop("FLAGS_npu_jit_compile", None)
+        return {"weight_path": self.eval_config.weight_path, "device": device}

paddlex/modules/semantic_segmentation/exportor.py

@@ -0,0 +1,31 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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 SegExportor(BaseExportor):
+    """Semantic Segmentation Model Exportor"""
+
+    entities = MODELS
+
+    def get_export_kwargs(self):
+        """get key-value arguments of model export function"""
+        kwargs = super().get_export_kwargs()
+
+        input_shape = self.export_config.get("input_shape")
+        if input_shape is not None:
+            kwargs["input_shape"] = input_shape
+        return kwargs

paddlex/modules/semantic_segmentation/model_list.py

@@ -0,0 +1,37 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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 = [
+    "Deeplabv3_Plus-R101",
+    "Deeplabv3_Plus-R50",
+    "Deeplabv3-R101",
+    "Deeplabv3-R50",
+    "OCRNet_HRNet-W48",
+    "OCRNet_HRNet-W18",
+    "PP-LiteSeg-T",
+    "PP-LiteSeg-B",
+    "SegFormer-B0",
+    "SegFormer-B1",
+    "SegFormer-B2",
+    "SegFormer-B3",
+    "SegFormer-B4",
+    "SegFormer-B5",
+    "SeaFormer_base",
+    "SeaFormer_tiny",
+    "SeaFormer_small",
+    "SeaFormer_large",
+    "MaskFormer_tiny",
+    "MaskFormer_small",
+]

paddlex/modules/semantic_segmentation/trainer.py

@@ -0,0 +1,72 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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 ..base import BaseTrainer
+from .model_list import MODELS
+
+
+class SegTrainer(BaseTrainer):
+    """Semantic Segmentation Model Trainer"""
+
+    entities = MODELS
+
+    def update_config(self):
+        """update training config"""
+        self.pdx_config.update_dataset(self.global_config.dataset_dir, "SegDataset")
+        if self.train_config.num_classes is not None:
+            self.pdx_config.update_num_classes(self.train_config.num_classes)
+        if (
+            self.train_config.pretrain_weight_path
+            and self.train_config.pretrain_weight_path != ""
+        ):
+            self.pdx_config.update_pretrained_weights(
+                self.train_config.pretrain_weight_path, is_backbone=True
+            )
+
+    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()}
+        # XXX:
+        os.environ.pop("FLAGS_npu_jit_compile", None)
+        if self.train_config.batch_size is not None:
+            train_args["batch_size"] = self.train_config.batch_size
+        if self.train_config.learning_rate is not None:
+            train_args["learning_rate"] = self.train_config.learning_rate
+        if self.train_config.epochs_iters is not None:
+            train_args["epochs_iters"] = self.train_config.epochs_iters
+        if (
+            self.train_config.resume_path is not None
+            and self.train_config.resume_path != ""
+        ):
+            train_args["resume_path"] = self.train_config.resume_path
+        if self.global_config.output is not None:
+            train_args["save_dir"] = self.global_config.output
+        if self.train_config.log_interval:
+            train_args["log_iters"] = self.train_config.log_interval
+        if self.train_config.eval_interval:
+            train_args["do_eval"] = True
+            train_args["save_interval"] = self.train_config.eval_interval
+        train_args["dy2st"] = self.train_config.get("dy2st", False)
+        if self.train_config.get("input_shape") is not None:
+            train_args["input_shape"] = self.train_config.input_shape
+        # amp support 'O1', 'O2', 'OFF'
+        train_args["amp"] = self.train_config.get("amp", "OFF")
+        return train_args

paddlex/modules/table_recognition/__init__.py

@@ -0,0 +1,18 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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 TableRecDatasetChecker
+from .evaluator import TableRecEvaluator
+from .exportor import TableRecExportor
+from .trainer import TableRecTrainer

paddlex/modules/table_recognition/dataset_checker/__init__.py

@@ -0,0 +1,98 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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 json
+import os
+import os.path as osp
+from collections import Counter, defaultdict
+from pathlib import Path
+
+from PIL import Image
+
+from ...base import BaseDatasetChecker
+from ..model_list import MODELS
+from .dataset_src import check, deep_analyse, split_dataset
+
+
+class TableRecDatasetChecker(BaseDatasetChecker):
+    """Dataset Checker for Table Recognition Model"""
+
+    entities = MODELS
+
+    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("**/train.txt"))
+        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
+
+        Args:
+            src_dataset_dir (str): the root directory of dataset.
+
+        Returns:
+            str: the root directory of converted dataset.
+        """
+        return 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) -> dict:
+        """check if the dataset meets the specifications and get dataset summary
+
+        Args:
+            dataset_dir (str): the root directory of dataset.
+        Returns:
+            dict: dataset summary.
+        """
+        return check(dataset_dir, self.output, sample_num=10)
+
+    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 "PubTabTableRecDataset"

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

@@ -0,0 +1,18 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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 .analyse_dataset import deep_analyse
+from .check_dataset import check
+from .split_dataset import split_dataset

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

@@ -0,0 +1,59 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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 collections import defaultdict
+
+from .....utils.file_interface import custom_open
+
+
+def simple_analyse(dataset_path):
+    """
+    Analyse the dataset samples by return image path and label path
+
+    Args:
+        dataset_path (str): dataset 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)
+    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 f"训练数据样本数: {sample_cnts[tags[0]]}\t评估数据样本数: {sample_cnts[tags[1]]}"
+
+
+def deep_analyse(dataset_path, output=None):
+    """class analysis for dataset"""
+    return simple_analyse(dataset_path)

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

@@ -0,0 +1,87 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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 json
+import os
+import os.path as osp
+from collections import defaultdict
+
+from PIL import Image, ImageOps
+
+from .....utils.errors import DatasetFileNotFoundError
+
+
+def check(dataset_dir, output, dataset_type="PubTabTableRecDataset", sample_num=10):
+    """
+    Check whether the dataset is valid.
+    """
+
+    if dataset_type == "PubTabTableRecDataset":
+        # Custom dataset
+        if not osp.exists(dataset_dir) or not osp.isdir(dataset_dir):
+            raise DatasetFileNotFoundError(file_path=dataset_dir)
+
+        tags = ["train", "val"]
+        sample_cnts = dict()
+        sample_paths = defaultdict(list)
+
+        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:
+                        info = json.loads(line.strip("\n"))
+                        file_name = info["filename"]
+                        info["html"]["cells"].copy()
+                        info["html"]["structure"]["tokens"].copy()
+
+                        img_path = osp.join(dataset_dir, file_name)
+
+                        if not os.path.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)
+                        if len(sample_paths[tag]) < sample_num:
+                            img = Image.open(img_path)
+                            img = ImageOps.exif_transpose(img)
+                            vis_path = osp.join(vis_save_dir, osp.basename(file_name))
+                            img.save(vis_path)
+                            sample_path = osp.join(
+                                "check_dataset", os.path.relpath(vis_path, output)
+                            )
+                            sample_paths[tag].append(sample_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]
+
+        return meta

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

@@ -0,0 +1,80 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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 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