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

paddlex/inference/models/3d_bev_detection/result.py

@@ -0,0 +1,65 @@
+# 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 ...common.result import BaseResult, StrMixin, JsonMixin
+import numpy as np
+import os
+from .visualizer_3d import Visualizer3D
+
+class BEV3DDetResult(BaseResult):
+    """Base class for computer vision results."""
+
+    def __init__(self, data: dict) -> None:
+        """
+        Initialize the BaseCVResult.
+
+        Args:
+            data (dict): The initial data.
+
+        Raises:
+            AssertionError: If the required key (`BaseCVResult.INPUT_IMG_KEY`) are not found in the data.
+        """
+
+        super().__init__(data)
+
+    def visualize(self, save_path: str, show: bool) -> None:
+        # input point cloud
+        assert 'input_path' in self.keys(), 'input_path is not found in the data'
+        points = np.fromfile(self['input_path'], dtype=np.float32)
+        points = points.reshape(-1, 5)
+        points = points[:, :4]
+
+        # detection result
+        result = dict()
+        assert 'boxes_3d' in self.keys(), 'boxes_3d is not found in the data'
+        result["bbox3d"] = self["boxes_3d"]
+        assert 'scores_3d' in self.keys(), 'scores_3d is not found in the data'
+        result["scores"] = self["scores_3d"]
+        assert 'labels_3d' in self.keys(), 'labels_3d is not found in the data'
+        result["labels"] = self["labels_3d"]
+
+        if save_path is not None:
+            # save result for local visualization
+            if not os.path.exists(save_path):
+                os.makedirs(save_path)
+            np.save(os.path.join(save_path, 'results.npy'), result)
+            np.save(os.path.join(save_path, 'points.npy'), points)
+        
+        if show:
+            # visualize
+            score_threshold = 0.25
+            vis = Visualizer3D()
+            vis.draw_results(points, result, score_threshold)
+
+        return

paddlex/inference/models/3d_bev_detection/visualizer_3d.py

@@ -0,0 +1,131 @@
+import os
+import numpy as np
+import argparse
+import importlib.util
+import sys
+
+class LazyLoader:
+    def __init__(self, module_name):
+        self.module_name = module_name
+        self._module = None
+
+    def __getattr__(self, item):
+        if self._module is None:
+            self._module = importlib.import_module(self.module_name)
+        return getattr(self._module, item)
+
+open3d = LazyLoader('open3d')
+
+class Visualizer3D:
+    def __init__(self):
+        self.vis = open3d.visualization.Visualizer() # initialize visualizer
+
+    def boxes_to_lines(self, box: np.ndarray):
+        """
+           4-------- 6
+         /|         /|
+        5 -------- 3 .
+        | |        | |
+        . 7 -------- 1
+        |/         |/
+        2 -------- 0
+        """
+        center = box[0:3]
+        lwh = box[3:6]
+        angles = np.array([0, 0, box[6] + 1e-10])
+        rot = open3d.geometry.get_rotation_matrix_from_axis_angle(angles)
+        box3d = open3d.geometry.OrientedBoundingBox(center, rot, lwh)
+        return open3d.geometry.LineSet.create_from_oriented_bounding_box(box3d)
+
+    def draw_results(self, points: np.ndarray, result: dict, score_threshold: float) -> None:
+        scores = result["scores"]
+        bbox3d = result["bbox3d"]
+        label_preds = result["labels"]
+
+        num_bbox3d, bbox3d_dims = bbox3d.shape
+        result_boxes = []
+        for box_idx in range(num_bbox3d):
+            if scores[box_idx] < score_threshold:
+                continue
+            if bbox3d_dims == 9:
+                print(
+                    "Score: {} Label: {} Box(x_c, y_c, z_c, w, l, h, vec_x, vec_y, -rot): {} {} {} {} {} {} {} {} {}"
+                    .format(scores[box_idx], label_preds[box_idx],
+                            bbox3d[box_idx, 0], bbox3d[box_idx, 1],
+                            bbox3d[box_idx, 2], bbox3d[box_idx, 3],
+                            bbox3d[box_idx, 4], bbox3d[box_idx, 5],
+                            bbox3d[box_idx, 6], bbox3d[box_idx, 7],
+                            bbox3d[box_idx, 8]))
+            elif bbox3d_dims == 7:
+                print(
+                    "Score: {} Label: {} Box(x_c, y_c, z_c, w, l, h, -rot): {} {} {} {} {} {} {}"
+                    .format(scores[box_idx], label_preds[box_idx],
+                            bbox3d[box_idx, 0], bbox3d[box_idx, 1],
+                            bbox3d[box_idx, 2], bbox3d[box_idx, 3],
+                            bbox3d[box_idx, 4], bbox3d[box_idx, 5],
+                            bbox3d[box_idx, 6]))
+            # draw result
+            result_boxes.append([
+                bbox3d[box_idx, 0], bbox3d[box_idx, 1],
+                bbox3d[box_idx, 2], bbox3d[box_idx, 3],
+                bbox3d[box_idx, 4], bbox3d[box_idx, 5],
+                bbox3d[box_idx, -1]
+            ])
+
+        # config
+        self.vis.create_window()
+        self.vis.get_render_option().point_size = 1.0
+        self.vis.get_render_option().background_color = [0, 0, 0]
+        pc_color = [1, 1, 1]
+        num_points = len(points)
+        pc_colors = np.tile(pc_color, (num_points, 1))
+
+        # raw point cloud
+        pts = open3d.geometry.PointCloud()
+        pts.points = open3d.utility.Vector3dVector(points[:, :3])
+        pts.colors = open3d.utility.Vector3dVector(pc_colors)
+        self.vis.add_geometry(pts)
+
+        # result_boxes
+        obs_color = [1, 0, 0]
+        result_boxes = np.array(result_boxes)
+        for i in range(result_boxes.shape[0]):
+            lines = self.boxes_to_lines(result_boxes[i])
+            # show different colors for different classes
+            if label_preds[i] <= 4:
+                obs_color = [0, 1, 0] # 'car', 'truck', 'trailer', 'bus', 'construction_vehicle',
+            elif (label_preds[i] <= 6):
+                obs_color = [0, 0, 1] # 'bicycle', 'motorcycle'
+            elif (label_preds[i] <= 7):
+                obs_color = [1, 0, 0] # 'pedestrian'
+            else:
+                obs_color = [1, 0, 1] # 'traffic_cone','barrier'
+            lines.paint_uniform_color(obs_color)
+            self.vis.add_geometry(lines)
+
+        self.vis.run()
+        self.vis.poll_events()
+        self.vis.update_renderer()
+        # self.vis.capture_screen_image("result.png")
+        self.vis.destroy_window()
+
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser(description='Visualizer 3d')
+    parser.add_argument(
+        '--save_path',
+        type=str,
+        default=None)
+    
+    args = parser.parse_args()
+    save_path = args.save_path
+    if save_path is None:
+        raise ValueError("Please specify the path to the saved results.")
+    
+    points = np.load(os.path.join(save_path, "points.npy"), allow_pickle=True)
+    result = np.load(os.path.join(save_path, "results.npy"), allow_pickle=True).item()
+    
+    score_threshold = 0.25
+    vis = Visualizer3D()
+    vis.draw_results(points, result, score_threshold)

paddlex/inference/models/__init__.py

@@ -0,0 +1,130 @@
+# 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
+from typing import Any, Dict, Optional
+from importlib import import_module
+from ...utils import errors
+from ..utils.official_models import official_models
+from .base import BasePredictor, BasicPredictor
+
+from .image_classification import ClasPredictor
+from .object_detection import DetPredictor
+from .keypoint_detection import KptPredictor
+from .text_detection import TextDetPredictor
+from .text_recognition import TextRecPredictor
+from .table_structure_recognition import TablePredictor
+from .formula_recognition import FormulaRecPredictor
+from .instance_segmentation import InstanceSegPredictor
+from .semantic_segmentation import SegPredictor
+from .image_feature import ImageFeaturePredictor
+from .ts_forecasting import TSFcPredictor
+from .ts_anomaly_detection import TSAdPredictor
+from .ts_classification import TSClsPredictor
+from .image_unwarping import WarpPredictor
+from .image_multilabel_classification import MLClasPredictor
+from .face_feature import FaceFeaturePredictor
+from .open_vocabulary_detection import OVDetPredictor
+from .open_vocabulary_segmentation import OVSegPredictor
+
+
+# from .table_recognition import TablePredictor
+# from .general_recognition import ShiTuRecPredictor
+from .anomaly_detection import UadPredictor
+
+# from .face_recognition import FaceRecPredictor
+from .multilingual_speech_recognition import WhisperPredictor
+from .video_classification import VideoClasPredictor
+from .video_detection import VideoDetPredictor
+
+module_3d_bev_detection = import_module(".3d_bev_detection", "paddlex.inference.models")
+BEVDet3DPredictor = getattr(module_3d_bev_detection, "BEVDet3DPredictor")
+
+
+def _create_hp_predictor(
+    model_name, model_dir, device, config, hpi_params, *args, **kwargs
+):
+    try:
+        from paddlex_hpi.models import HPPredictor
+    except ModuleNotFoundError:
+        raise RuntimeError(
+            "The PaddleX HPI plugin is not properly installed, and the high-performance model inference features are not available."
+        ) from None
+    try:
+        predictor = HPPredictor.get(model_name)(
+            model_dir=model_dir,
+            config=config,
+            device=device,
+            *args,
+            hpi_params=hpi_params,
+            **kwargs,
+        )
+    except errors.others.ClassNotFoundException:
+        raise ValueError(
+            f"{model_name} is not supported by the PaddleX HPI plugin."
+        ) from None
+    return predictor
+
+
+def create_predictor(
+    model_name: str,
+    model_dir: Optional[str] = None,
+    device=None,
+    pp_option=None,
+    use_hpip: bool = False,
+    hpi_params: Optional[Dict[str, Any]] = None,
+    *args,
+    **kwargs,
+) -> BasePredictor:
+    if model_dir is None:
+        model_dir = check_model(model_name)
+    else:
+        assert Path(model_dir).exists(), f"{model_dir} is not exists!"
+        model_dir = Path(model_dir)
+    config = BasePredictor.load_config(model_dir)
+    assert (
+        model_name == config["Global"]["model_name"]
+    ), f"Model name mismatch，please input the correct model dir."
+
+    if use_hpip:
+        return _create_hp_predictor(
+            model_name=model_name,
+            model_dir=model_dir,
+            config=config,
+            hpi_params=hpi_params,
+            device=device,
+            *args,
+            **kwargs,
+        )
+    else:
+        return BasicPredictor.get(model_name)(
+            model_dir=model_dir,
+            config=config,
+            device=device,
+            pp_option=pp_option,
+            *args,
+            **kwargs,
+        )
+
+
+def check_model(model):
+    if Path(model).exists():
+        return Path(model)
+    elif model in official_models:
+        return official_models[model]
+    else:
+        raise Exception(
+            f"The model ({model}) is no exists! Please using directory of local model files or model name supported by PaddleX!"
+        )

paddlex/inference/models/anomaly_detection/__init__.py

@@ -0,0 +1,15 @@
+# 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 .predictor import UadPredictor

paddlex/inference/models/anomaly_detection/predictor.py

@@ -0,0 +1,145 @@
+# 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 typing import Any, Union, Dict, List, Tuple
+import numpy as np
+
+from ....utils.func_register import FuncRegister
+from ....modules.anomaly_detection.model_list import MODELS
+from ...common.batch_sampler import ImageBatchSampler
+from ...common.reader import ReadImage
+from ..common import (
+    Resize,
+    ResizeByShort,
+    Normalize,
+    ToCHWImage,
+    ToBatch,
+    StaticInfer,
+)
+from .processors import MapToMask
+from ..base import BasicPredictor
+from .result import UadResult
+
+
+class UadPredictor(BasicPredictor):
+    """UadPredictor that inherits from BasicPredictor."""
+
+    entities = MODELS
+
+    _FUNC_MAP = {}
+    register = FuncRegister(_FUNC_MAP)
+
+    def __init__(self, *args: List, **kwargs: Dict) -> None:
+        """Initializes UadPredictor.
+
+        Args:
+            *args: Arbitrary positional arguments passed to the superclass.
+            **kwargs: Arbitrary keyword arguments passed to the superclass.
+        """
+        super().__init__(*args, **kwargs)
+        self.preprocessors, self.infer, self.postprocessors = self._build()
+
+    def _build_batch_sampler(self) -> ImageBatchSampler:
+        """Builds and returns an ImageBatchSampler instance.
+
+        Returns:
+            ImageBatchSampler: An instance of ImageBatchSampler.
+        """
+        return ImageBatchSampler()
+
+    def _get_result_class(self) -> type:
+        """Returns the result class, UadResult.
+
+        Returns:
+            type: The UadResult class.
+        """
+        return UadResult
+
+    def _build(self) -> Tuple:
+        """Build the preprocessors, inference engine, and postprocessors based on the configuration.
+
+        Returns:
+            tuple: A tuple containing the preprocessors, inference engine, and postprocessors.
+        """
+        preprocessors = {"Read": ReadImage(format="RGB")}
+        preprocessors["ToCHW"] = ToCHWImage()
+        for cfg in self.config["Deploy"]["transforms"]:
+            tf_key = cfg.pop("type")
+            func = self._FUNC_MAP[tf_key]
+            args = cfg
+            name, op = func(self, **args) if args else func(self)
+            preprocessors[name] = op
+        preprocessors["ToBatch"] = ToBatch()
+
+        infer = StaticInfer(
+            model_dir=self.model_dir,
+            model_prefix=self.MODEL_FILE_PREFIX,
+            option=self.pp_option,
+        )
+        postprocessors = {"Map_to_mask": MapToMask()}
+        return preprocessors, infer, postprocessors
+
+    def process(self, batch_data: List[Union[str, np.ndarray]]) -> Dict[str, Any]:
+        """
+        Process a batch of data through the preprocessing, inference, and postprocessing.
+
+        Args:
+            batch_data (List[Union[str, np.ndarray], ...]): A batch of input data (e.g., image file paths).
+
+        Returns:
+            dict: A dictionary containing the input path, raw image, and predicted segmentation maps for every instance of the batch. Keys include 'input_path', 'input_img', and 'pred'.
+        """
+        batch_raw_imgs = self.preprocessors["Read"](imgs=batch_data.instances)
+        batch_imgs = self.preprocessors["Resize"](imgs=batch_raw_imgs)
+        batch_imgs = self.preprocessors["Normalize"](imgs=batch_imgs)
+        batch_imgs = self.preprocessors["ToCHW"](imgs=batch_imgs)
+        x = self.preprocessors["ToBatch"](imgs=batch_imgs)
+        batch_preds = self.infer(x=x)
+        batch_preds = self.postprocessors["Map_to_mask"](preds=batch_preds)
+        if len(batch_data) > 1:
+            batch_preds = np.split(batch_preds[0], len(batch_data), axis=0)
+
+        return {
+            "input_path": batch_data.input_paths,
+            "page_index": batch_data.page_indexes,
+            "input_img": batch_raw_imgs,
+            "pred": batch_preds,
+        }
+
+    @register("Resize")
+    def build_resize(
+        self, target_size, keep_ratio=False, size_divisor=None, interp="LINEAR"
+    ):
+        assert target_size
+        op = Resize(
+            target_size=target_size,
+            keep_ratio=keep_ratio,
+            size_divisor=size_divisor,
+            interp=interp,
+        )
+        return "Resize", op
+
+    @register("Normalize")
+    def build_normalize(
+        self,
+        mean=0.5,
+        std=0.5,
+    ):
+        op = Normalize(mean=mean, std=std)
+        return "Normalize", op
+
+    @register("Map_to_mask")
+    def map_to_mask(self, mask_map):
+        op = MapToMask()
+        return "Map_to_mask", op

paddlex/inference/models/anomaly_detection/processors.py

@@ -0,0 +1,46 @@
+# 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 numpy as np
+from skimage import measure, morphology
+
+
+class MapToMask:
+    """Map_to_mask"""
+
+    def __init__(self):
+        """
+        Initialize the instance.
+        """
+        super().__init__()
+
+    def __call__(self, preds, *args):
+        """apply"""
+        return [self.apply(pred) for pred in preds]
+
+    def apply(
+        self,
+        pred,
+    ):
+        """apply"""
+        score_map = pred[0]
+        thred = 0.01
+        mask = score_map[0]
+        mask[mask > thred] = 255
+        mask[mask <= thred] = 0
+        kernel = morphology.disk(4)
+        mask = morphology.opening(mask, kernel)
+        mask = mask.astype(np.uint8)
+
+        return mask[None, :, :]

paddlex/inference/models/anomaly_detection/result.py

@@ -0,0 +1,70 @@
+# 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 copy
+import numpy as np
+from PIL import Image
+
+from ...common.result import BaseCVResult, StrMixin, JsonMixin
+
+
+class UadResult(BaseCVResult):
+    """Save Result Transform"""
+
+    def _to_img(self):
+        """apply"""
+        seg_map = self["pred"]
+        pc_map = self.get_pseudo_color_map(seg_map[0])
+        return {"res": pc_map}
+
+    def get_pseudo_color_map(self, pred):
+        """get_pseudo_color_map"""
+        if pred.min() < 0 or pred.max() > 255:
+            raise ValueError("`pred` cannot be cast to uint8.")
+        pred = pred.astype(np.uint8)
+        pred_mask = Image.fromarray(pred, mode="P")
+        color_map = self._get_color_map_list(256)
+        pred_mask.putpalette(color_map)
+        return pred_mask
+
+    @staticmethod
+    def _get_color_map_list(num_classes, custom_color=None):
+        """_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:]
+
+        if custom_color:
+            color_map[: len(custom_color)] = custom_color
+        return color_map
+
+    def _to_str(self, *args, **kwargs):
+        data = copy.deepcopy(self)
+        data.pop("input_img")
+        data["pred"] = "..."
+        return JsonMixin._to_str(data, *args, **kwargs)
+
+    def _to_json(self, *args, **kwargs):
+        data = copy.deepcopy(self)
+        data.pop("input_img")
+        return JsonMixin._to_json(data, *args, **kwargs)

paddlex/inference/models/base/__init__.py

@@ -0,0 +1,15 @@
+# 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 .predictor import BasePredictor, BasicPredictor

paddlex/inference/models/base/predictor/__init__.py

@@ -0,0 +1,16 @@
+# 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_predictor import BasePredictor
+from .basic_predictor import BasicPredictor