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

paddlex/inference/models/{3d_bev_detection → m_3d_bev_detection}/processors.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.
@@ -14,25 +14,18 @@
 
 
 import numbers
-import cv2
+
 import numpy as np
-from typing import Generic, List, Optional
-import lazy_paddle as paddle
 
-from ...utils.io import ImageReader
-from ....utils import logging
+from ....utils.deps import class_requires_deps, is_dep_available
 from ...common.reader.det_3d_reader import Sample
+from ...utils.benchmark import benchmark
 
-
-cv2_interp_codes = {
-    "nearest": cv2.INTER_NEAREST,
-    "bilinear": cv2.INTER_LINEAR,
-    "bicubic": cv2.INTER_CUBIC,
-    "area": cv2.INTER_AREA,
-    "lanczos": cv2.INTER_LANCZOS4,
-}
+if is_dep_available("opencv-contrib-python"):
+    import cv2
 
 
+@benchmark.timeit
 class LoadPointsFromFile:
     """Load points from a file and process them according to specified parameters."""
 
@@ -47,6 +40,7 @@ class LoadPointsFromFile:
             shift_height (bool): Whether to shift height values.
             use_color (bool): Whether to include color attributes in the loaded points.
         """
+
         self.shift_height = shift_height
         self.use_color = use_color
         if isinstance(use_dim, int):
@@ -112,6 +106,7 @@ class LoadPointsFromFile:
         return results
 
 
+@benchmark.timeit
 class LoadPointsFromMultiSweeps(object):
     """Load points from multiple sweeps.This is usually used for nuScenes dataset to utilize previous sweeps."""
 
@@ -275,6 +270,8 @@ class LoadPointsFromMultiSweeps(object):
         return results
 
 
+@benchmark.timeit
+@class_requires_deps("opencv-contrib-python")
 class LoadMultiViewImageFromFiles:
     """Load multi-view images from files."""
 
@@ -341,6 +338,8 @@ class LoadMultiViewImageFromFiles:
         return sample
 
 
+@benchmark.timeit
+@class_requires_deps("opencv-contrib-python")
 class ResizeImage:
     """Resize images & bbox & mask."""
 
@@ -594,6 +593,13 @@ class ResizeImage:
         Returns:
             numpy.ndarray or tuple: The resized image. If return_scale is True, returns a tuple containing the resized image and the scaling factors (w_scale, h_scale).
         """
+        cv2_interp_codes = {
+            "nearest": cv2.INTER_NEAREST,
+            "bilinear": cv2.INTER_LINEAR,
+            "bicubic": cv2.INTER_CUBIC,
+            "area": cv2.INTER_AREA,
+            "lanczos": cv2.INTER_LANCZOS4,
+        }
         h, w = img.shape[:2]
         if backend not in ["cv2", "pillow"]:
             raise ValueError(
@@ -671,6 +677,8 @@ class ResizeImage:
         return results
 
 
+@benchmark.timeit
+@class_requires_deps("opencv-contrib-python")
 class NormalizeImage:
     """Normalize the image."""
 
@@ -729,6 +737,8 @@ class NormalizeImage:
         return results
 
 
+@benchmark.timeit
+@class_requires_deps("opencv-contrib-python")
 class PadImage(object):
     """Pad the image & mask."""
 
@@ -859,6 +869,7 @@ class PadImage(object):
         return results
 
 
+@benchmark.timeit
 class SampleFilterByKey:
     """Collect data from the loader relevant to the specific task."""
 
@@ -914,6 +925,7 @@ class SampleFilterByKey:
         return filtered_sample
 
 
+@benchmark.timeit
 class GetInferInput:
     """Collect infer input data from transformed sample"""
 

paddlex/inference/models/{3d_bev_detection → m_3d_bev_detection}/result.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,11 +12,14 @@
 # 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
+
+import numpy as np
+
+from ...common.result import BaseResult
 from .visualizer_3d import Visualizer3D
 
+
 class BEV3DDetResult(BaseResult):
     """Base class for computer vision results."""
 
@@ -35,31 +38,31 @@ class BEV3DDetResult(BaseResult):
 
     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)
+        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'
+        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'
+        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'
+        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)
-        
+            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
+        return

paddlex/inference/models/{3d_bev_detection → m_3d_bev_detection}/visualizer_3d.py

@@ -1,8 +1,23 @@
-import os
-import numpy as np
+# 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 importlib.util
-import sys
+import os
+
+import numpy as np
+
 
 class LazyLoader:
     def __init__(self, module_name):
@@ -14,11 +29,13 @@ class LazyLoader:
             self._module = importlib.import_module(self.module_name)
         return getattr(self._module, item)
 
-open3d = LazyLoader('open3d')
+
+open3d = LazyLoader("open3d")
+
 
 class Visualizer3D:
     def __init__(self):
-        self.vis = open3d.visualization.Visualizer() # initialize visualizer
+        self.vis = open3d.visualization.Visualizer()  # initialize visualizer
 
     def boxes_to_lines(self, box: np.ndarray):
         """
@@ -37,7 +54,9 @@ class Visualizer3D:
         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:
+    def draw_results(
+        self, points: np.ndarray, result: dict, score_threshold: float
+    ) -> None:
         scores = result["scores"]
         bbox3d = result["bbox3d"]
         label_preds = result["labels"]
@@ -49,28 +68,46 @@ class Visualizer3D:
                 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]))
+                    "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]))
+                    "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]
-            ])
+            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()
@@ -93,13 +130,17 @@ class Visualizer3D:
             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'
+                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'
+                obs_color = [1, 0, 1]  # 'traffic_cone','barrier'
             lines.paint_uniform_color(obs_color)
             self.vis.add_geometry(lines)
 
@@ -112,20 +153,17 @@ class Visualizer3D:
 
 if __name__ == "__main__":
 
-    parser = argparse.ArgumentParser(description='Visualizer 3d')
-    parser.add_argument(
-        '--save_path',
-        type=str,
-        default=None)
-    
+    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/multilingual_speech_recognition/__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.

paddlex/inference/models/multilingual_speech_recognition/predictor.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,20 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import lazy_paddle as paddle
 import numpy as np
 
-from ....utils.func_register import FuncRegister
-from ...common.batch_sampler import AudioBatchSampler
-
-from ..base import BasicPredictor
-from .result import WhisperResult
-from ...utils.io import AudioReader
 from ....modules.multilingual_speech_recognition.model_list import MODELS
 from ....utils.download import download_and_extract
+from ...common.batch_sampler import AudioBatchSampler
+from ...utils.io import AudioReader
+from ..base import BasePredictor
+from .result import WhisperResult
 
 
-class WhisperPredictor(BasicPredictor):
+class WhisperPredictor(BasePredictor):
 
     entities = MODELS
 
@@ -62,12 +59,9 @@ class WhisperPredictor(BasicPredictor):
         Returns:
             AudioReader: An instance of AudioReader.
         """
-        from .processors import (
-            ModelDimensions,
-            Whisper,
-            LANGUAGES,
-            TO_LANGUAGE_CODE,
-        )
+        import paddle
+
+        from .processors import ModelDimensions, Whisper
 
         # build model
         model_file = (self.model_dir / f"{self.MODEL_FILE_PREFIX}.pdparams").as_posix()
@@ -91,6 +85,8 @@ class WhisperPredictor(BasicPredictor):
         Returns:
             dict: A dictionary containing the input path and result. The result include 'text', 'segments' and 'language'.
         """
+        import paddle
+
         from .processors import log_mel_spectrogram
 
         # load mel_filters from resource_dir and extract feature for audio