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

paddlex/modules/base/utils/topk_eval.py

@@ -0,0 +1,118 @@
+# 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 argparse
+import json
+import os
+
+import paddle
+
+from ....utils import logging
+
+
+def parse_args():
+    """Parse all arguments"""
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--prediction_json_path", type=str, default="./pre_res.json")
+    parser.add_argument("--gt_val_path", type=str, default="./val.txt")
+    parser.add_argument("--image_dir", type=str)
+    parser.add_argument("--num_classes", type=int)
+
+    args = parser.parse_args()
+    return args
+
+
+class AvgMetrics(paddle.nn.Layer):
+    """Average metrics"""
+
+    def __init__(self):
+        super().__init__()
+        self.avg_meters = {}
+
+    @property
+    def avg(self):
+        """Return average value of each metric"""
+        if self.avg_meters:
+            for metric_key in self.avg_meters:
+                return self.avg_meters[metric_key].avg
+
+    @property
+    def avg_info(self):
+        """Return a formatted string of average values and names"""
+        return ", ".join([self.avg_meters[key].avg_info for key in self.avg_meters])
+
+
+class TopkAcc(AvgMetrics):
+    """Top-k accuracy metric"""
+
+    def __init__(self, topk=(1, 5)):
+        super().__init__()
+        assert isinstance(topk, (int, list, tuple))
+        if isinstance(topk, int):
+            topk = [topk]
+        self.topk = topk
+        self.warned = False
+
+    def forward(self, x, label):
+        """forward function"""
+        if isinstance(x, dict):
+            x = x["logits"]
+
+        output_dims = x.shape[-1]
+
+        metric_dict = dict()
+        for idx, k in enumerate(self.topk):
+            if output_dims < k:
+                if not self.warned:
+                    msg = f"The output dims({output_dims}) is less than k({k}), so the Top-{k} metric is meaningless."
+                    logging.info(msg)
+                    self.warned = True
+                metric_dict[f"top{k}"] = 1
+            else:
+                metric_dict[f"top{k}"] = paddle.metric.accuracy(x, label, k=k).item()
+        return metric_dict
+
+
+def prase_pt_info(pt_info, num_classes):
+    """Parse prediction information to probability vector"""
+    pre_list = [0.0] * num_classes
+    for idx, val in zip(pt_info["class_ids"], pt_info["scores"]):
+        pre_list[idx] = val
+    return pre_list
+
+
+def main(args):
+    """main function"""
+    with open(args.prediction_json_path, "r") as fp:
+        predication_result = json.load(fp)
+    gt_info = {}
+
+    pred = []
+    label = []
+    for line in open(args.gt_val_path):
+        img_file, gt_label = line.strip().split(" ")
+        img_file = img_file.split("/")[-1]
+        gt_info[img_file] = int(gt_label)
+    for pt_info in predication_result:
+        img_file = os.path.relpath(pt_info["file_name"], args.image_dir)
+        pred.append(prase_pt_info(pt_info, args.num_classes))
+        label.append([gt_info[img_file]])
+    metric_dict = TopkAcc()(paddle.to_tensor(pred), paddle.to_tensor(label))
+    logging.info(metric_dict)
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    main(args)

paddlex/modules/doc_vlm/__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 DocVLMDatasetChecker
+from .evaluator import DocVLMEvaluator
+from .exportor import DocVLMExportor
+from .trainer import DocVLMTrainer

paddlex/modules/doc_vlm/dataset_checker.py

@@ -0,0 +1,29 @@
+# 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 ...utils.errors import UnsupportedAPIError
+from ..base import BaseDatasetChecker
+from .model_list import MODELS
+
+
+class DocVLMDatasetChecker(BaseDatasetChecker):
+    """Dataset Checker for Document Vision Language Model"""
+
+    entities = MODELS
+
+    def __init__(self, config):
+        # not support for now
+        raise UnsupportedAPIError(
+            "document vision language models do not support data check for now."
+        )

paddlex/modules/doc_vlm/evaluator.py

@@ -0,0 +1,29 @@
+# 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 ...utils.errors import UnsupportedAPIError
+from ..base import BaseEvaluator
+from .model_list import MODELS
+
+
+class DocVLMEvaluator(BaseEvaluator):
+    """Document Vision Language Model Evaluator"""
+
+    entities = MODELS
+
+    def __init__(self, config):
+        # not support for now
+        raise UnsupportedAPIError(
+            "document vision language models do not support evaluate for now."
+        )

paddlex/modules/doc_vlm/exportor.py

@@ -0,0 +1,29 @@
+# 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 ...utils.errors import UnsupportedAPIError
+from ..base import BaseExportor
+from .model_list import MODELS
+
+
+class DocVLMExportor(BaseExportor):
+    """Document Vision Language Model Exportor"""
+
+    entities = MODELS
+
+    def __init__(self, config):
+        # not support for now
+        raise UnsupportedAPIError(
+            "document vision language models do not support export for now."
+        )

paddlex/modules/doc_vlm/model_list.py

@@ -0,0 +1,16 @@
+# 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 = ["PP-DocBee-2B", "PP-DocBee-7B", "PP-Chart2Table", "PP-DocBee2-3B"]

paddlex/modules/doc_vlm/trainer.py

@@ -0,0 +1,41 @@
+# 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 ...utils.errors import UnsupportedAPIError
+from ..base import BaseTrainer
+from .model_list import MODELS
+
+
+class DocVLMTrainer(BaseTrainer):
+    """Document Vision Language Model Trainer"""
+
+    entities = MODELS
+
+    def __init__(self, config):
+        # not support for now
+        raise UnsupportedAPIError(
+            "Document vision language models do not support train for now."
+        )
+
+    def update_config(self):
+        """update training config"""
+
+    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()}
+        return train_args

paddlex/modules/face_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 FaceRecDatasetChecker
+from .evaluator import FaceRecEvaluator
+from .exportor import FaceRecExportor
+from .trainer import FaceRecTrainer

paddlex/modules/face_recognition/dataset_checker/__init__.py

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

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

@@ -0,0 +1,16 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights 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 .check_dataset import check_train, check_val

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

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

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

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