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

paddlex/inference/utils/pp_option.py

@@ -0,0 +1,256 @@
+# 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 typing import Dict, List
+
+from ...utils.device import (
+    parse_device,
+    set_env_for_device,
+    get_default_device,
+    check_supported_device,
+)
+from ...utils import logging
+from .new_ir_blacklist import NEWIR_BLOCKLIST
+
+
+class PaddlePredictorOption(object):
+    """Paddle Inference Engine Option"""
+
+    # NOTE: TRT modes start with `trt_`
+    SUPPORT_RUN_MODE = (
+        "paddle",
+        "trt_fp32",
+        "trt_fp16",
+        "trt_int8",
+        "mkldnn",
+        "mkldnn_bf16",
+    )
+    SUPPORT_DEVICE = ("gpu", "cpu", "npu", "xpu", "mlu", "dcu", "gcu")
+
+    def __init__(self, model_name=None, **kwargs):
+        super().__init__()
+        self.model_name = model_name
+        self._cfg = {}
+        self._init_option(**kwargs)
+        self._changed = False
+
+    @property
+    def changed(self):
+        return self._changed
+
+    @changed.setter
+    def changed(self, v):
+        assert isinstance(v, bool)
+        self._changed = v
+
+    def _init_option(self, **kwargs):
+        for k, v in kwargs.items():
+            if self._has_setter(k):
+                setattr(self, k, v)
+            else:
+                raise Exception(
+                    f"{k} is not supported to set! The supported option is: {self._get_settable_attributes()}"
+                )
+        for k, v in self._get_default_config().items():
+            self._cfg.setdefault(k, v)
+
+    def _get_default_config(self):
+        """get default config"""
+        device_type, device_id = parse_device(get_default_device())
+        return {
+            "run_mode": "paddle",
+            "device": device_type,
+            "device_id": 0 if device_id is None else device_id[0],
+            "min_subgraph_size": 3,
+            "shape_info_filename": None,
+            "trt_calib_mode": False,
+            "cpu_threads": 8,
+            "trt_use_static": False,
+            "delete_pass": [],
+            "enable_new_ir": True if self.model_name not in NEWIR_BLOCKLIST else False,
+            "batch_size": 1,  # only for trt
+            "trt_dynamic_shapes": {},  # only for trt
+        }
+
+    def _update(self, k, v):
+        self._cfg[k] = v
+        self.changed = True
+
+    @property
+    def run_mode(self):
+        return self._cfg["run_mode"]
+
+    @run_mode.setter
+    def run_mode(self, run_mode: str):
+        """set run mode"""
+        if run_mode not in self.SUPPORT_RUN_MODE:
+            support_run_mode_str = ", ".join(self.SUPPORT_RUN_MODE)
+            raise ValueError(
+                f"`run_mode` must be {support_run_mode_str}, but received {repr(run_mode)}."
+            )
+        self._update("run_mode", run_mode)
+
+    @property
+    def device_type(self):
+        return self._cfg["device"]
+
+    @property
+    def device_id(self):
+        return self._cfg["device_id"]
+
+    @property
+    def device(self):
+        device = self._cfg["device"]
+        check_supported_device(device, self.model_name)
+        return device
+
+    @device.setter
+    def device(self, device: str):
+        """set device"""
+        if not device:
+            return
+        device_type, device_ids = parse_device(device)
+        if device_type not in self.SUPPORT_DEVICE:
+            support_run_mode_str = ", ".join(self.SUPPORT_DEVICE)
+            raise ValueError(
+                f"The device type must be one of {support_run_mode_str}, but received {repr(device_type)}."
+            )
+        self._update("device", device_type)
+        device_id = device_ids[0] if device_ids is not None else 0
+        self._update("device_id", device_id)
+        set_env_for_device(device)
+        if device_type not in ("cpu"):
+            if device_ids is None or len(device_ids) > 1:
+                logging.debug(f"The device ID has been set to {device_id}.")
+        # XXX(gaotingquan): set flag to accelerate inference in paddle 3.0b2
+        if device_type in ("gpu", "cpu"):
+            os.environ["FLAGS_enable_pir_api"] = "1"
+
+    @property
+    def min_subgraph_size(self):
+        return self._cfg["min_subgraph_size"]
+
+    @min_subgraph_size.setter
+    def min_subgraph_size(self, min_subgraph_size: int):
+        """set min subgraph size"""
+        if not isinstance(min_subgraph_size, int):
+            raise Exception()
+        self._update("min_subgraph_size", min_subgraph_size)
+
+    @property
+    def shape_info_filename(self):
+        return self._cfg["shape_info_filename"]
+
+    @shape_info_filename.setter
+    def shape_info_filename(self, shape_info_filename: str):
+        """set shape info filename"""
+        self._update("shape_info_filename", shape_info_filename)
+
+    @property
+    def trt_dynamic_shapes(self):
+        return self._cfg["trt_dynamic_shapes"]
+
+    @trt_dynamic_shapes.setter
+    def trt_dynamic_shapes(self, trt_dynamic_shapes: Dict[str, List[List[int]]]):
+        assert isinstance(trt_dynamic_shapes, dict)
+        for input_k in trt_dynamic_shapes:
+            assert isinstance(trt_dynamic_shapes[input_k], list)
+        self._update("trt_dynamic_shapes", trt_dynamic_shapes)
+
+    @property
+    def trt_calib_mode(self):
+        return self._cfg["trt_calib_mode"]
+
+    @trt_calib_mode.setter
+    def trt_calib_mode(self, trt_calib_mode):
+        """set trt calib mode"""
+        self._update("trt_calib_mode", trt_calib_mode)
+
+    @property
+    def cpu_threads(self):
+        return self._cfg["cpu_threads"]
+
+    @cpu_threads.setter
+    def cpu_threads(self, cpu_threads):
+        """set cpu threads"""
+        if not isinstance(cpu_threads, int) or cpu_threads < 1:
+            raise Exception()
+        self._update("cpu_threads", cpu_threads)
+
+    @property
+    def trt_use_static(self):
+        return self._cfg["trt_use_static"]
+
+    @trt_use_static.setter
+    def trt_use_static(self, trt_use_static):
+        """set trt use static"""
+        self._update("trt_use_static", trt_use_static)
+
+    @property
+    def delete_pass(self):
+        return self._cfg["delete_pass"]
+
+    @delete_pass.setter
+    def delete_pass(self, delete_pass):
+        self._update("delete_pass", delete_pass)
+
+    @property
+    def enable_new_ir(self):
+        return self._cfg["enable_new_ir"]
+
+    @enable_new_ir.setter
+    def enable_new_ir(self, enable_new_ir: bool):
+        """set run mode"""
+        self._update("enable_new_ir", enable_new_ir)
+
+    @property
+    def batch_size(self):
+        return self._cfg["batch_size"]
+
+    @batch_size.setter
+    def batch_size(self, batch_size):
+        self._update("batch_size", batch_size)
+
+    def get_support_run_mode(self):
+        """get supported run mode"""
+        return self.SUPPORT_RUN_MODE
+
+    def get_support_device(self):
+        """get supported device"""
+        return self.SUPPORT_DEVICE
+
+    def __str__(self):
+        return ",  ".join([f"{k}: {v}" for k, v in self._cfg.items()])
+
+    def __getattr__(self, key):
+        if key not in self._cfg:
+            raise Exception(f"The key ({key}) is not found in cfg: \n {self._cfg}")
+        return self._cfg.get(key)
+
+    def __eq__(self, obj):
+        if isinstance(obj, PaddlePredictorOption):
+            return obj._cfg == self._cfg
+        return False
+
+    def _has_setter(self, attr):
+        prop = getattr(self.__class__, attr, None)
+        return isinstance(prop, property) and prop.fset is not None
+
+    def _get_settable_attributes(self):
+        return [
+            name
+            for name, prop in vars(self.__class__).items()
+            if isinstance(prop, property) and prop.fset is not None
+        ]

paddlex/model.py

@@ -0,0 +1,113 @@
+# 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 abc import abstractmethod
+from copy import deepcopy
+
+from .inference import create_predictor, PaddlePredictorOption
+from .modules import (
+    build_dataset_checker,
+    build_trainer,
+    build_evaluater,
+    build_exportor,
+)
+
+
+# TODO(gaotingquan): support _ModelBasedConfig
+def create_model(model_name, model_dir=None, *args, **kwargs):
+    return _ModelBasedInference(
+        model_name=model_name, model_dir=model_dir, *args, **kwargs
+    )
+
+
+class _BaseModel:
+    def check_dataset(self, *args, **kwargs):
+        raise Exception("check_dataset is not supported!")
+
+    def train(self, *args, **kwargs):
+        raise Exception("train is not supported!")
+
+    def evaluate(self, *args, **kwargs):
+        raise Exception("evaluate is not supported!")
+
+    def export(self, *args, **kwargs):
+        raise Exception("export is not supported!")
+
+    def predict(self, *args, **kwargs):
+        raise Exception("predict is not supported!")
+
+    def set_predict(self, *args, **kwargs):
+        raise Exception("set_predict is not supported!")
+
+    def __call__(self, *args, **kwargs):
+        yield from self.predict(*args, **kwargs)
+
+
+class _ModelBasedInference(_BaseModel):
+    def __init__(self, *args, **kwargs):
+        self._predictor = create_predictor(*args, **kwargs)
+
+    def predict(self, *args, **kwargs):
+        yield from self._predictor(*args, **kwargs)
+
+    def set_predictor(self, **kwargs):
+        self._predictor.set_predictor(**kwargs)
+
+    def __getattr__(self, name):
+        if hasattr(self._predictor, name):
+            return getattr(self._predictor, name)
+        raise AttributeError(
+            f"'{self.__class__.__name__}' object has no attribute '{name}'"
+        )
+
+
+class _ModelBasedConfig(_BaseModel):
+    def __init__(self, config=None, *args, **kwargs):
+        super().__init__()
+        self._config = config
+        self._model_name = config.Global.model
+
+    def _build_predictor(self):
+        predict_kwargs = deepcopy(self._config.Predict)
+
+        model_dir = predict_kwargs.pop("model_dir", None)
+
+        device = self._config.Global.get("device")
+        kernel_option = predict_kwargs.pop("kernel_option", {})
+        kernel_option.update({"device": device})
+
+        pp_option = PaddlePredictorOption(self._model_name, **kernel_option)
+        predictor = create_predictor(self._model_name, model_dir, pp_option=pp_option)
+        assert "input" in predict_kwargs
+        return predict_kwargs, predictor
+
+    def check_dataset(self):
+        dataset_checker = build_dataset_checker(self._config)
+        return dataset_checker.check()
+
+    def train(self):
+        trainer = build_trainer(self._config)
+        trainer.train()
+
+    def evaluate(self):
+        evaluator = build_evaluater(self._config)
+        return evaluator.evaluate()
+
+    def export(self):
+        exportor = build_exportor(self._config)
+        return exportor.export()
+
+    def predict(self):
+        predict_kwargs, predictor = self._build_predictor()
+        yield from predictor(**predict_kwargs)

paddlex/modules/3d_bev_detection/__init__.py

@@ -0,0 +1,18 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .trainer import BEVFusionTrainer
+from .dataset_checker import BEVFusionDatasetChecker
+from .evaluator import BEVFusionEvaluator
+from .exportor import BEVFusionExportor

paddlex/modules/3d_bev_detection/dataset_checker/__init__.py

@@ -0,0 +1,95 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pathlib import Path
+import pickle
+
+from ...base import BaseDatasetChecker
+from .dataset_src import check, deep_analyse
+from ..model_list import MODELS
+
+
+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/3d_bev_detection/dataset_checker/dataset_src/__init__.py

@@ -0,0 +1,17 @@
+# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from .check_dataset import check
+from .analyse_dataset import deep_analyse

paddlex/modules/3d_bev_detection/dataset_checker/dataset_src/analyse_dataset.py

@@ -0,0 +1,106 @@
+# 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 json
+import platform
+import pickle
+
+from collections import defaultdict
+
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib import font_manager
+from matplotlib.backends.backend_agg import FigureCanvasAgg
+
+from paddlex.utils.fonts import PINGFANG_FONT_FILE_PATH
+
+
+def deep_analyse(dataset_dir, output):
+    """class analysis for dataset"""
+    tags = ["train", "val"]
+    all_instances = 0
+    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")}