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

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

@@ -0,0 +1,80 @@
+# 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 numpy as np
+from PIL import Image, ImageOps
+
+from .utils.visualizer import visualize
+from .....utils.errors import DatasetFileNotFoundError
+from .....utils.file_interface import custom_open
+from .....utils.logging import info
+
+
+def check_dataset(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)
+    vis_save_dir = osp.join(output, "demo_img")
+    if not osp.exists(vis_save_dir):
+        os.makedirs(vis_save_dir)
+    split_tags = ["train", "val"]
+    attrs = dict()
+    class_ids = set()
+    for tag in split_tags:
+        mapping_file = osp.join(dataset_dir, f"{tag}.txt")
+        if not osp.exists(mapping_file):
+            info(f"The mapping file ({mapping_file}) doesn't exist, ignored.")
+            continue
+        with custom_open(mapping_file, "r") as fp:
+            lines = filter(None, (line.strip() for line in fp.readlines()))
+            for i, line in enumerate(lines):
+                img_file, ann_file = line.split(" ")
+                img_file = osp.join(dataset_dir, img_file)
+                ann_file = osp.join(dataset_dir, ann_file)
+                assert osp.exists(img_file), FileNotFoundError(
+                    f"{img_file} not exist, please check!"
+                )
+                assert osp.exists(ann_file), FileNotFoundError(
+                    f"{ann_file} not exist, please check!"
+                )
+                img = np.array(ImageOps.exif_transpose(Image.open(img_file)), "uint8")
+                ann = np.array(ImageOps.exif_transpose(Image.open(ann_file)), "uint8")
+                assert img.shape[:2] == ann.shape, ValueError(
+                    f"The shape of {img_file}:{img.shape[:2]} and "
+                    f"{ann_file}:{ann.shape} must be the same!"
+                )
+                class_ids = class_ids | set(ann.reshape([-1]).tolist())
+                if i < sample_num:
+                    vis_img = visualize(img, ann)
+                    vis_img = Image.fromarray(vis_img)
+                    vis_save_path = osp.join(vis_save_dir, osp.basename(img_file))
+                    vis_img.save(vis_save_path)
+                    vis_save_path = osp.join(
+                        "check_dataset", os.path.relpath(vis_save_path, output)
+                    )
+                    if f"{tag}_sample_paths" not in attrs:
+                        attrs[f"{tag}_sample_paths"] = [vis_save_path]
+                    else:
+                        attrs[f"{tag}_sample_paths"].append(vis_save_path)
+            if f"{tag}_samples" not in attrs:
+                attrs[f"{tag}_samples"] = i + 1
+    if 255 in class_ids:
+        class_ids.remove(255)
+    attrs["num_classes"] = len(class_ids)
+    return attrs

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

@@ -0,0 +1,162 @@
+# 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 glob
+import json
+import os
+import os.path as osp
+import shutil
+
+import cv2
+import numpy as np
+from PIL import Image, ImageDraw
+
+from .....utils.file_interface import custom_open
+from .....utils import logging
+
+
+def convert_dataset(dataset_type, input_dir):
+    """convert to paddlex official format"""
+    if dataset_type == "LabelMe":
+        return convert_labelme_dataset(input_dir)
+    else:
+        raise NotImplementedError(dataset_type)
+
+
+def convert_labelme_dataset(input_dir):
+    """convert labelme format to paddlex official format"""
+    bg_name = "_background_"
+    ignore_name = "__ignore__"
+
+    # prepare dir
+    output_img_dir = osp.join(input_dir, "images")
+    output_annot_dir = osp.join(input_dir, "annotations")
+    if not osp.exists(output_img_dir):
+        os.makedirs(output_img_dir)
+    if not osp.exists(output_annot_dir):
+        os.makedirs(output_annot_dir)
+
+    # collect class_names and set class_name_to_id
+    class_names = []
+    class_name_to_id = {}
+    split_tags = ["train", "val"]
+    for tag in split_tags:
+        mapping_file = osp.join(input_dir, f"{tag}_anno_list.txt")
+        with open(mapping_file, "r") as f:
+            label_files = [
+                osp.join(input_dir, line.strip("\n")) for line in f.readlines()
+            ]
+        for label_file in label_files:
+            with custom_open(label_file, "r") as fp:
+                data = json.load(fp)
+                for shape in data["shapes"]:
+                    cls_name = shape["label"]
+                    if cls_name not in class_names:
+                        class_names.append(cls_name)
+
+        if ignore_name in class_names:
+            class_name_to_id[ignore_name] = 255
+            class_names.remove(ignore_name)
+        if bg_name in class_names:
+            class_names.remove(bg_name)
+        class_name_to_id[bg_name] = 0
+        for i, name in enumerate(class_names):
+            class_name_to_id[name] = i + 1
+
+        if len(class_names) > 256:
+            raise ValueError(
+                f"There are {len(class_names)} categories in the annotation file, "
+                f"exceeding 256, Not compliant with paddlex official format!"
+            )
+
+        # create annotated images and copy origin images
+        color_map = get_color_map_list(256)
+        img_file_list = []
+        label_file_list = []
+        for i, label_file in enumerate(label_files):
+            filename = osp.splitext(osp.basename(label_file))[0]
+            annotated_img_path = osp.join(output_annot_dir, filename + ".png")
+            with custom_open(label_file, "r") as f:
+                data = json.load(f)
+                img_path = osp.join(osp.dirname(label_file), data["imagePath"])
+                if not os.path.exists(img_path):
+                    logging.info("%s is not existed, skip this image" % img_path)
+                    continue
+                img_name = img_path.split("/")[-1]
+                img_file_list.append(f"images/{img_name}")
+                label_img_name = annotated_img_path.split("/")[-1]
+                label_file_list.append(f"annotations/{label_img_name}")
+
+                img = np.asarray(cv2.imread(img_path))
+                lbl = shape2label(
+                    img_size=img.shape,
+                    shapes=data["shapes"],
+                    class_name_mapping=class_name_to_id,
+                )
+                lbl_pil = Image.fromarray(lbl.astype(np.uint8), mode="P")
+                lbl_pil.putpalette(color_map)
+                lbl_pil.save(annotated_img_path)
+
+                shutil.copy(img_path, output_img_dir)
+        with custom_open(osp.join(input_dir, f"{tag}.txt"), "w") as fp:
+            for img_path, lbl_path in zip(img_file_list, label_file_list):
+                fp.write(f"{img_path} {lbl_path}\n")
+
+    with custom_open(osp.join(input_dir, "class_name.txt"), "w") as fp:
+        for name in class_names:
+            fp.write(f"{name}{os.linesep}")
+    with custom_open(osp.join(input_dir, "class_name_to_id.txt"), "w") as fp:
+        for key, val in class_name_to_id.items():
+            fp.write(f"{val}: {key}{os.linesep}")
+
+    return input_dir
+
+
+def get_color_map_list(num_classes):
+    """get color map list"""
+    num_classes += 1
+    color_map = num_classes * [0, 0, 0]
+    for i in range(0, num_classes):
+        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
+
+
+def shape2label(img_size, shapes, class_name_mapping):
+    """根据输入的形状列表，将图像的标签矩阵填充为对应形状的类别编号"""
+    label = np.zeros(img_size[:2], dtype=np.int32)
+    for shape in shapes:
+        points = shape["points"]
+        class_name = shape["label"]
+        label_mask = polygon2mask(img_size[:2], points)
+        label[label_mask] = class_name_mapping[class_name]
+    return label
+
+
+def polygon2mask(img_size, points):
+    """将给定形状的点转换成对应的掩膜"""
+    label_mask = Image.fromarray(np.zeros(img_size[:2], dtype=np.uint8))
+    image_draw = ImageDraw.Draw(label_mask)
+    points_list = [tuple(point) for point in points]
+    assert len(points_list) > 2, ValueError("Polygon must have points more than 2")
+    image_draw.polygon(xy=points_list, outline=1, fill=1)
+    return np.array(label_mask, dtype=bool)

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

@@ -0,0 +1,87 @@
+# 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 shutil
+
+from .....utils.file_interface import custom_open
+from .....utils import logging
+
+
+def split_dataset(root_dir, train_percent, val_percent):
+    """split dataset"""
+    assert train_percent > 0, ValueError(
+        f"The train_percent({train_percent}) must greater than 0!"
+    )
+    assert val_percent > 0, ValueError(
+        f"The val_percent({val_percent}) must greater than 0!"
+    )
+    if train_percent + val_percent != 100:
+        raise ValueError(
+            f"The sum of train_percent({train_percent})and val_percent({val_percent}) should be 100!"
+        )
+
+    img_dir = osp.join(root_dir, "images")
+    assert osp.exists(img_dir), FileNotFoundError(
+        f"The dir of images ({img_dir}) doesn't exist, please check!"
+    )
+    ann_dir = osp.join(root_dir, "annotations")
+    assert osp.exists(ann_dir), FileNotFoundError(
+        f"The dir of annotations ({ann_dir}) doesn't exist, please check!"
+    )
+
+    img_file_list = [osp.join("images", img_name) for img_name in os.listdir(img_dir)]
+    img_num = len(img_file_list)
+    ann_file_list = [
+        osp.join("annotations", ann_name) for ann_name in os.listdir(ann_dir)
+    ]
+    ann_num = len(ann_file_list)
+    assert img_num == ann_num, ValueError(
+        "The number of images and annotations must be equal!"
+    )
+
+    split_tags = ["train", "val"]
+    mapping_line_list = []
+    for tag in split_tags:
+        mapping_file = osp.join(root_dir, f"{tag}.txt")
+        if not osp.exists(mapping_file):
+            logging.info(f"The mapping file ({mapping_file}) doesn't exist, ignored.")
+            continue
+        with custom_open(mapping_file, "r") as fp:
+            lines = filter(None, (line.strip() for line in fp.readlines()))
+            mapping_line_list.extend(lines)
+
+    sample_num = len(mapping_line_list)
+    random.shuffle(mapping_line_list)
+    split_percents = [train_percent, val_percent]
+    start_idx = 0
+    for tag, percent in zip(split_tags, split_percents):
+        if tag == "test" and percent == 0:
+            continue
+        end_idx = start_idx + round(sample_num * percent / 100)
+        end_idx = min(end_idx, sample_num)
+        mapping_file = osp.join(root_dir, f"{tag}.txt")
+        if os.path.exists(mapping_file):
+            shutil.move(mapping_file, mapping_file + ".bak")
+            logging.info(
+                f"The original mapping file ({mapping_file}) "
+                f"has been backed up to ({mapping_file}.bak)"
+            )
+        with custom_open(mapping_file, "w") as fp:
+            fp.write("\n".join(mapping_line_list[start_idx:end_idx]))
+        start_idx = end_idx
+    return root_dir

paddlex/modules/semantic_segmentation/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/semantic_segmentation/dataset_checker/dataset_src/utils/visualizer.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 cv2
+import numpy as np
+
+
+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
+
+
+def visualize(image, result, weight=0.6, use_multilabel=False):
+    """Convert predict result to color image, and save added image."""
+    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 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 BaseEvaluator
+from .model_list import MODELS
+
+
+class SegEvaluator(BaseEvaluator):
+    """Semantic Segmentation Model Evaluator"""
+
+    entities = MODELS
+
+    def update_config(self):
+        """update evalution 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 evalution 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,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 SegExportor(BaseExportor):
+    """Semantic Segmentation Model Exportor"""
+
+    entities = MODELS

paddlex/modules/semantic_segmentation/model_list.py

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

paddlex/modules/semantic_segmentation/trainer.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
+import glob
+from pathlib import Path
+
+from ..base import BaseTrainer
+from ...utils.config import AttrDict
+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)
+        return train_args

paddlex/modules/table_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 .dataset_checker import TableRecDatasetChecker
+from .trainer import TableRecTrainer
+from .evaluator import TableRecEvaluator
+from .exportor import TableRecExportor