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

paddlex/modules/keypoint_detection/trainer.py

@@ -0,0 +1,39 @@
+# 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 ..object_detection import DetTrainer
+from .model_list import MODELS
+
+
+class KeypointTrainer(DetTrainer):
+    """Human Pose Estimation Model Trainer"""
+
+    entities = MODELS
+
+    def _update_dataset(self):
+        """update dataset settings"""
+        metric = self.pdx_config.metric
+        data_fields = (
+            self.pdx_config.TrainDataset["data_fields"]
+            if "data_fields" in self.pdx_config.TrainDataset
+            else None
+        )
+
+        self.pdx_config.update_dataset(
+            self.global_config.dataset_dir,
+            "KeypointTopDownCocoDataset",
+            data_fields=data_fields,
+            metric=metric,
+        )

paddlex/modules/m_3d_bev_detection/__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 BEVFusionDatasetChecker
+from .evaluator import BEVFusionEvaluator
+from .exportor import BEVFusionExportor
+from .trainer import BEVFusionTrainer

paddlex/modules/m_3d_bev_detection/dataset_checker/__init__.py

@@ -0,0 +1,95 @@
+# 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 pickle
+from pathlib import Path
+
+from ...base import BaseDatasetChecker
+from ..model_list import MODELS
+from .dataset_src import check, deep_analyse
+
+
+class BEVFusionDatasetChecker(BaseDatasetChecker):
+    entities = MODELS
+
+    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.
+            sample_num (int): the number to be sampled.
+        Returns:
+            dict: dataset summary.
+        """
+        return check(dataset_dir)
+
+    def analyse(self, dataset_dir: str) -> dict:
+        """deep analyse dataset
+
+        Args:
+            dataset_dir (str): the root directory of dataset.
+
+        Returns:
+            dict: the deep analysis results.
+        """
+        return deep_analyse(dataset_dir, self.output)
+
+    def get_data(self, ann_file, max_sample_num):
+        infos = self.data_infos(ann_file, max_sample_num)
+        meta = []
+        for info in infos:
+            image_paths = []
+            cam_orders = [
+                "CAM_FRONT_LEFT",
+                "CAM_FRONT",
+                "CAM_FRONT_RIGHT",
+                "CAM_BACK_RIGHT",
+                "CAM_BACK",
+                "CAM_BACK_LEFT",
+            ]
+            for cam_type in cam_orders:
+                cam_info = info["cams"][cam_type]
+                cam_data_path = cam_info["data_path"]
+                image_paths.append(cam_data_path)
+
+            meta.append(
+                {
+                    "sample_idx": info["token"],
+                    "lidar_path": info["lidar_path"],
+                    "image_paths": image_paths,
+                }
+            )
+        return meta
+
+    def data_infos(self, ann_file, max_sample_num):
+        data = pickle.load(open(ann_file, "rb"))
+        data_infos = list(sorted(data["infos"], key=lambda e: e["timestamp"]))
+        data_infos = data_infos[:max_sample_num]
+        return data_infos
+
+    def get_show_type(self) -> str:
+        """get the show type of dataset
+
+        Returns:
+            str: show type
+        """
+        return "txt"
+
+    def get_dataset_type(self) -> str:
+        """return the dataset type
+
+        Returns:
+            str: dataset type
+        """
+        return "NuscenesMMDataset"

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

@@ -0,0 +1,17 @@
+# 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

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

@@ -0,0 +1,106 @@
+# 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 pickle
+import platform
+from collections import defaultdict
+
+import numpy as np
+
+from paddlex.utils.deps import function_requires_deps, is_dep_available
+from paddlex.utils.fonts import PINGFANG_FONT_FILE_PATH
+
+if is_dep_available("matplotlib"):
+    import matplotlib.pyplot as plt
+    from matplotlib import font_manager
+
+
+@function_requires_deps("matplotlib")
+def deep_analyse(dataset_dir, output):
+    """class analysis for dataset"""
+    tags = ["train", "val"]
+    class_name_train = defaultdict(int)
+    class_name_val = defaultdict(int)
+    for tag in tags:
+        anno_file = os.path.join(dataset_dir, f"nuscenes_infos_{tag}.pkl")
+        with open(anno_file, "rb") as f:
+            datas = pickle.load(f)
+        data_infos = datas["infos"]
+        for item in data_infos:
+            gts = item["gt_names"]
+            for gt_name in gts:
+                if tag == "train":
+                    class_name_train[gt_name] = (
+                        0
+                        if gt_name not in class_name_train
+                        else class_name_train[gt_name] + 1
+                    )
+                elif tag == "val":
+                    class_name_val[gt_name] = (
+                        0
+                        if gt_name not in class_name_val
+                        else class_name_val[gt_name] + 1
+                    )
+
+    classes = set()
+    for key in class_name_train:
+        classes.add(key)
+    for key in class_name_val:
+        classes.add(key)
+
+    # set cnt to 0 if class not in cnt dict
+    for key in classes:
+        if key not in class_name_train:
+            class_name_train[key] = 0
+        if key not in class_name_val:
+            class_name_val[key] = 0
+
+    cnts_train = [cat_ids for cat_name, cat_ids in class_name_train.items()]
+    cnts_val = [cat_ids for cat_name, cat_ids in class_name_val.items()]
+
+    # sort class name
+    classes = [cat_name for cat_name, cat_ids in class_name_train.items()]
+    sorted_id = sorted(
+        range(len(cnts_train)), key=lambda k: cnts_train[k], reverse=True
+    )
+    cnts_train_sorted = [cnts_train[index] for index in sorted_id]
+    cnts_val_sorted = [cnts_val[index] for index in sorted_id]
+    classes_sorted = [classes[index] for index in sorted_id]
+
+    x = np.arange(len(classes))
+    width = 0.5
+
+    # bar
+    os_system = platform.system().lower()
+    if os_system == "windows":
+        plt.rcParams["font.sans-serif"] = "FangSong"
+    else:
+        font = font_manager.FontProperties(fname=PINGFANG_FONT_FILE_PATH)
+    fig, ax = plt.subplots(figsize=(max(8, int(len(classes) / 5)), 5), dpi=120)
+    ax.bar(x, cnts_train_sorted, width=0.5, label="train")
+    ax.bar(x + width, cnts_val_sorted, width=0.5, label="val")
+    plt.xticks(
+        x + width / 2,
+        classes_sorted,
+        rotation=90,
+        fontproperties=None if os_system == "windows" else font,
+    )
+    ax.set_ylabel("Counts")
+    plt.legend()
+    fig.tight_layout()
+    fig_path = os.path.join(output, "histogram.png")
+    fig.savefig(fig_path)
+    return {"histogram": os.path.join("check_dataset", "histogram.png")}

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

@@ -0,0 +1,101 @@
+# 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.path as osp
+import pickle
+
+from .....utils.errors import DatasetFileNotFoundError
+from .....utils.misc import abspath
+
+
+def check(dataset_dir):
+    dataset_dir = abspath(dataset_dir)
+    max_sample_num = 5
+
+    if not osp.exists(dataset_dir) or not osp.isdir(dataset_dir):
+        raise DatasetFileNotFoundError(file_path=dataset_dir)
+
+    anno_file = osp.join(dataset_dir, "nuscenes_infos_train.pkl")
+    if not osp.exists(anno_file):
+        raise DatasetFileNotFoundError(file_path=anno_file)
+    train_mate, train_classes = get_data(anno_file, max_sample_num)
+
+    anno_file = osp.join(dataset_dir, "nuscenes_infos_val.pkl")
+    if not osp.exists(anno_file):
+        raise DatasetFileNotFoundError(file_path=anno_file)
+    val_mate, val_classes = get_data(anno_file, max_sample_num)
+    train_sample_paths = []
+    val_sample_paths = []
+
+    for item in train_mate:
+        train_sample_paths.append(item["lidar_path"])
+
+    for item in val_mate:
+        val_sample_paths.append(item["lidar_path"])
+
+    all_classes = set()
+    for tc in train_classes:
+        all_classes.add(tc)
+    for vc in val_classes:
+        all_classes.add(vc)
+    num_classes = len(all_classes)
+    meta = {
+        "num_classes": num_classes,
+        "train_meta": train_mate,
+        "val_meta": val_mate,
+        "train_sample_paths": train_sample_paths,
+        "val_sample_paths": val_sample_paths,
+    }
+    return meta
+
+
+def get_data(ann_file, max_sample_num):
+    infos = data_infos(ann_file, max_sample_num)
+    meta = []
+    gt_class = set()
+    for info in infos:
+        image_paths = []
+        cam_orders = [
+            "CAM_FRONT_LEFT",
+            "CAM_FRONT",
+            "CAM_FRONT_RIGHT",
+            "CAM_BACK_RIGHT",
+            "CAM_BACK",
+            "CAM_BACK_LEFT",
+        ]
+        for cam_type in cam_orders:
+            cam_info = info["cams"][cam_type]
+            cam_data_path = cam_info["data_path"]
+            image_paths.append(cam_data_path)
+
+        meta.append(
+            {
+                "sample_idx": info["token"],
+                "lidar_path": info["lidar_path"],
+                "image_paths": image_paths,
+            }
+        )
+        class_names = info["gt_names"]
+
+        for cls_name in class_names:
+            gt_class.add(cls_name)
+
+    return meta, gt_class
+
+
+def data_infos(ann_file, max_sample_num):
+    data = pickle.load(open(ann_file, "rb"))
+    data_infos = list(sorted(data["infos"], key=lambda e: e["timestamp"]))
+    data_infos = data_infos[:max_sample_num]
+    return data_infos

paddlex/modules/m_3d_bev_detection/evaluator.py

@@ -0,0 +1,46 @@
+# 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 BaseEvaluator
+from .model_list import MODELS
+
+
+class BEVFusionEvaluator(BaseEvaluator):
+    """Object Detection Model Evaluator"""
+
+    entities = MODELS
+
+    def update_config(self):
+        """update evalution config"""
+        if self.eval_config.batch_size is not None:
+            self.pdx_config.update_batch_size(self.eval_config.batch_size)
+        self.pdx_config.update_dataset(
+            self.global_config.dataset_dir,
+            self.global_config.datart_prefix,
+            "NuscenesMMDataset",
+            version=self.global_config.version,
+        )
+        self.pdx_config.update_weights(self.eval_config.weight_path)
+
+    def get_eval_kwargs(self) -> dict:
+        """get key-value arguments of model evalution function
+
+        Returns:
+            dict: the arguments of evaluation function.
+        """
+        return {
+            "weight_path": self.eval_config.weight_path,
+            "device": self.get_device(using_device_number=1),
+        }

paddlex/modules/m_3d_bev_detection/exportor.py

@@ -0,0 +1,22 @@
+# 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 BEVFusionExportor(BaseExportor):
+    """3D BEV Detection Model Exportor"""
+
+    entities = MODELS

paddlex/modules/m_3d_bev_detection/model_list.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.
+
+
+MODELS = [
+    "BEVFusion",
+]

paddlex/modules/m_3d_bev_detection/trainer.py

@@ -0,0 +1,68 @@
+# 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 BaseTrainer
+from .model_list import MODELS
+
+
+class BEVFusionTrainer(BaseTrainer):
+    """3D BEV Detection Model Trainer"""
+
+    entities = MODELS
+
+    def _update_dataset(self):
+        """update dataset settings"""
+        self.pdx_config.update_dataset(
+            self.global_config.dataset_dir,
+            self.global_config.get("datart_prefix", True),
+            "NuscenesMMDataset",
+            version=self.global_config.get("version", "mini"),
+        )
+
+    def _update_pretrained_model(self):
+        self.pdx_config.update_pretrained_model(
+            self.global_config.load_cam_from, self.global_config.load_lidar_from
+        )
+
+    def update_config(self):
+        """update training config"""
+        self._update_dataset()
+        self._update_pretrained_model()
+
+        if self.train_config.batch_size is not None:
+            self.pdx_config.update_batch_size(self.train_config.batch_size)
+        if self.train_config.learning_rate is not None:
+            self.pdx_config.update_learning_rate(self.train_config.learning_rate)
+        if self.train_config.epochs_iters is not None:
+            self.pdx_config.update_epochs(self.train_config.epochs_iters)
+            self.train_config.epochs_iters
+        else:
+            self.pdx_config.get_epochs_iters()
+        if self.global_config.output is not None:
+            self.pdx_config.update_save_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.
+        """
+        train_args = {"device": self.get_device()}
+        train_args["dy2st"] = self.train_config.get("dy2st", False)
+        # amp support 'O1', 'O2', 'OFF'
+        train_args["amp"] = self.train_config.get("amp", "OFF")
+        if self.global_config.output is not None:
+            train_args["save_dir"] = self.global_config.output
+        return train_args

paddlex/modules/multilabel_classification/__init__.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# 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.
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .trainer import MLClsTrainer
 from .dataset_checker import MLClsDatasetChecker
 from .evaluator import MLClsEvaluator
 from .exportor import MLClsExportor
+from .trainer import MLClsTrainer

paddlex/modules/multilabel_classification/dataset_checker/__init__.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# 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.
@@ -15,8 +15,8 @@
 from pathlib import Path
 
 from ...base import BaseDatasetChecker
-from .dataset_src import check, convert, split_dataset, deep_analyse
 from ..model_list import MODELS
+from .dataset_src import check, convert, deep_analyse, split_dataset
 
 
 class MLClsDatasetChecker(BaseDatasetChecker):

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

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# 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.
@@ -13,7 +13,7 @@
 # limitations under the License.
 
 
+from .analyse_dataset import deep_analyse
 from .check_dataset import check
 from .convert_dataset import convert
 from .split_dataset import split_dataset
-from .analyse_dataset import deep_analyse

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

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# 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.
@@ -13,22 +13,21 @@
 # limitations under the License.
 
 import os
-import json
-import math
 import platform
-from pathlib import Path
-
 from collections import defaultdict
-from PIL import Image
+
 import numpy as np
-import matplotlib.pyplot as plt
-from matplotlib import font_manager
-from matplotlib.backends.backend_agg import FigureCanvasAgg
 
+from .....utils.deps import function_requires_deps, is_dep_available
 from .....utils.file_interface import custom_open
 from .....utils.fonts import PINGFANG_FONT_FILE_PATH
 
+if is_dep_available("matplotlib"):
+    import matplotlib.pyplot as plt
+    from matplotlib import font_manager
+
 
+@function_requires_deps("matplotlib")
 def deep_analyse(dataset_path, output):
     """class analysis for dataset"""
     tags = ["train", "val"]

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

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# 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.
@@ -15,10 +15,11 @@
 import os
 import os.path as osp
 import random
-from PIL import Image, ImageOps
 from collections import defaultdict
 
-from .....utils.errors import DatasetFileNotFoundError, CheckFailedError
+from PIL import Image, ImageOps
+
+from .....utils.errors import CheckFailedError, DatasetFileNotFoundError
 from .utils.visualizer import draw_multi_label