paddlex 2.0.0rc4__py3-none-any.whl → 3.0.0__py3-none-any.whl

paddlex/inference/common/batch_sampler/video_batch_sampler.py

@@ -0,0 +1,74 @@
+# 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 ....utils import logging
+from ....utils.cache import CACHE_DIR
+from ....utils.download import download
+from .base_batch_sampler import BaseBatchSampler
+
+
+class VideoBatchSampler(BaseBatchSampler):
+
+    SUFFIX = ["mp4", "avi", "mkv", "webm"]
+
+    # XXX: auto download for url
+    def _download_from_url(self, in_path):
+        file_name = Path(in_path).name
+        save_path = Path(CACHE_DIR) / "predict_input" / file_name
+        download(in_path, save_path, overwrite=True)
+        return save_path.as_posix()
+
+    def _get_files_list(self, fp):
+        file_list = []
+        if fp is None or not os.path.exists(fp):
+            raise Exception(f"Not found any video file in path: {fp}")
+        if os.path.isfile(fp) and fp.split(".")[-1] in self.SUFFIX:
+            file_list.append(fp)
+        elif os.path.isdir(fp):
+            for root, dirs, files in os.walk(fp):
+                for single_file in files:
+                    if single_file.split(".")[-1] in self.SUFFIX:
+                        file_list.append(os.path.join(root, single_file))
+        if len(file_list) == 0:
+            raise Exception("Not found any file in {}".format(fp))
+        file_list = sorted(file_list)
+        return file_list
+
+    def sample(self, inputs):
+        if not isinstance(inputs, list):
+            inputs = [inputs]
+
+        batch = []
+        for input in inputs:
+            if isinstance(input, str):
+                file_path = (
+                    self._download_from_url(input)
+                    if input.startswith("http")
+                    else input
+                )
+                file_list = self._get_files_list(file_path)
+                for file_path in file_list:
+                    batch.append(file_path)
+                    if len(batch) == self.batch_size:
+                        yield batch
+                        batch = []
+            else:
+                logging.warning(
+                    f"Not supported input data type! Only `str` are supported! So has been ignored: {input}."
+                )
+        if len(batch) > 0:
+            yield batch

paddlex/inference/common/reader/__init__.py

@@ -0,0 +1,19 @@
+# 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 .audio_reader import ReadAudio
+from .det_3d_reader import ReadNuscenesData
+from .image_reader import ReadImage
+from .ts_reader import ReadTS
+from .video_reader import ReadVideo

paddlex/inference/common/reader/audio_reader.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 ...utils.io import AudioReader
+
+
+class ReadAudio:
+    """Load audio from the file."""
+
+    def __init__(self):
+        """
+        Initialize the instance.
+
+        """
+        super().__init__()
+        self._audio_reader = AudioReader(backend="wav")
+
+    def read(self, input):
+        import paddle
+
+        if isinstance(input, str):
+            audio, sample_rate = self._audio_reader.read(input)
+            if sample_rate != 16000:
+                raise ValueError(
+                    f"ReadAudio only supports 16k pcm or wav file.\n"
+                    f"However, got: {sample_rate}."
+                )
+            audio = audio[:, 0]
+            audio = paddle.to_tensor(audio)
+            return audio, sample_rate
+        else:
+            raise TypeError(
+                f"ReadAudio only supports str, indicating an audio file path.\n"
+                f"However, got type: {type(input).__name__}."
+            )

paddlex/inference/common/reader/det_3d_reader.py

@@ -0,0 +1,241 @@
+# 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 typing import Generic
+
+import numpy as np
+
+from ...utils.benchmark import benchmark
+
+
+class _EasyDict(dict):
+    def __getattr__(self, key: str):
+        if key in self:
+            return self[key]
+        return super().__getattr__(self, key)
+
+    def __setattr__(self, key: str, value: Generic):
+        self[key] = value
+
+
+class SampleMeta(_EasyDict):
+
+    # yapf: disable
+    __slots__ = [
+        "camera_intrinsic",
+        # bgr or rgb
+        "image_format",
+        # pillow or cv2
+        "image_reader",
+        # chw or hwc
+        "channel_order",
+        # Unique ID of the sample
+        "id",
+        "time_lag",
+        "ref_from_curr"
+    ]
+    # yapf: enable
+
+    def __init__(self, **kwargs):
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+
+class Sample(_EasyDict):
+    """Data structure containing sample data information"""
+
+    _VALID_MODALITIES = ["image", "lidar", "radar", "multimodal", "multiview"]
+
+    def __init__(self, path: str, modality: str):
+        if modality not in self._VALID_MODALITIES:
+            raise ValueError(
+                "Only modality {} is supported, but got {}".format(
+                    self._VALID_MODALITIES, modality
+                )
+            )
+
+        self.meta = SampleMeta()
+
+        self.path = path
+        self.data = None
+        self.modality = modality.lower()
+
+        self.bboxes_2d = None
+        self.bboxes_3d = None
+        self.labels = None
+
+        self.sweeps = []
+        self.attrs = None
+
+
+@benchmark.timeit_with_options(name=None, is_read_operation=True)
+class ReadNuscenesData:
+
+    def __init__(
+        self,
+        dataset_root="",
+        load_interval=1,
+        noise_sensor_type="camera",
+        drop_frames=False,
+        drop_set=[0, "discrete"],
+        modality="multimodal",
+        extrinsics_noise=False,
+        extrinsics_noise_type="single",
+    ):
+
+        self.load_interval = load_interval
+        self.noise_data = None
+        self.noise_sensor_type = noise_sensor_type
+        self.drop_frames = drop_frames
+        self.drop_ratio = drop_set[0]
+        self.drop_type = drop_set[1]
+        self.modality = modality
+        self.extrinsics_noise = extrinsics_noise
+        self.extrinsics_noise_type = extrinsics_noise_type
+        self.dataset_root = dataset_root
+
+    def get_data_info(self, info):
+        """Get data info.
+
+        Returns:
+            dict: Data information that will be passed to the data \
+                preprocessing pipelines. It includes the following keys:
+
+                - sample_idx (str): Sample index.
+                - pts_filename (str): Filename of point clouds.
+                - sweeps (list[dict]): Infos of sweeps.
+                - timestamp (float): Sample timestamp.
+                - img_filename (str, optional): Image filename.
+                - lidar2img (list[np.ndarray], optional): Transformations \
+                    from lidar to different cameras.
+                - ann_info (dict): Annotation info.
+        """
+        sample = Sample(path=None, modality=self.modality)
+        sample.sample_idx = info["token"]
+        sample.meta.id = info["token"]
+        sample.pts_filename = os.path.join(self.dataset_root, info["lidar_path"])
+        sample.sweeps = info["sweeps"]
+        sample.timestamp = info["timestamp"] / 1e6
+
+        if self.noise_sensor_type == "lidar":
+            if self.drop_frames:
+                pts_filename = sample.pts_filename
+                file_name = pts_filename.split("/")[-1]
+
+                if self.noise_data[file_name]["noise"]["drop_frames"][self.drop_ratio][
+                    self.drop_type
+                ]["stuck"]:
+                    replace_file = self.noise_data[file_name]["noise"]["drop_frames"][
+                        self.drop_ratio
+                    ][self.drop_type]["replace"]
+                    if replace_file != "":
+                        pts_filename = pts_filename.replace(file_name, replace_file)
+
+                        sample.pts_filename = pts_filename
+                        sample.sweeps = self.noise_data[replace_file]["mmdet_info"][
+                            "sweeps"
+                        ]
+                        sample.timestamp = (
+                            self.noise_data[replace_file]["mmdet_info"]["timestamp"]
+                            / 1e6
+                        )
+
+        cam_orders = [
+            "CAM_FRONT_LEFT",
+            "CAM_FRONT",
+            "CAM_FRONT_RIGHT",
+            "CAM_BACK_RIGHT",
+            "CAM_BACK",
+            "CAM_BACK_LEFT",
+        ]
+        if self.modality == "multiview" or self.modality == "multimodal":
+            image_paths = []
+            lidar2img_rts = []
+            caminfos = []
+            for cam_type in cam_orders:
+                cam_info = info["cams"][cam_type]
+
+                cam_data_path = cam_info["data_path"]
+                cam_data_path = os.path.join(self.dataset_root, cam_data_path)
+                file_name = cam_data_path.split("/")[-1]
+                if self.noise_sensor_type == "camera":
+                    if self.drop_frames:
+                        if self.noise_data[file_name]["noise"]["drop_frames"][
+                            self.drop_ratio
+                        ][self.drop_type]["stuck"]:
+                            replace_file = self.noise_data[file_name]["noise"][
+                                "drop_frames"
+                            ][self.drop_ratio][self.drop_type]["replace"]
+                            if replace_file != "":
+                                cam_data_path = cam_data_path.replace(
+                                    file_name, replace_file
+                                )
+
+                image_paths.append(cam_data_path)
+                # obtain lidar to image transformation matrix
+                if self.extrinsics_noise:
+                    sensor2lidar_rotation = self.noise_data[file_name]["noise"][
+                        "extrinsics_noise"
+                    ][f"{self.extrinsics_noise_type}_noise_sensor2lidar_rotation"]
+                    sensor2lidar_translation = self.noise_data[file_name]["noise"][
+                        "extrinsics_noise"
+                    ][f"{self.extrinsics_noise_type}_noise_sensor2lidar_translation"]
+                else:
+                    sensor2lidar_rotation = cam_info["sensor2lidar_rotation"]
+                    sensor2lidar_translation = cam_info["sensor2lidar_translation"]
+
+                lidar2cam_r = np.linalg.inv(sensor2lidar_rotation)
+                lidar2cam_t = sensor2lidar_translation @ lidar2cam_r.T
+                lidar2cam_rt = np.eye(4)
+                lidar2cam_rt[:3, :3] = lidar2cam_r.T
+                lidar2cam_rt[3, :3] = -lidar2cam_t
+                intrinsic = cam_info["cam_intrinsic"]
+                viewpad = np.eye(4)
+                viewpad[: intrinsic.shape[0], : intrinsic.shape[1]] = intrinsic
+                lidar2img_rt = viewpad @ lidar2cam_rt.T
+                lidar2img_rts.append(lidar2img_rt)
+                caminfos.append(
+                    {
+                        "sensor2lidar_translation": sensor2lidar_translation,
+                        "sensor2lidar_rotation": sensor2lidar_rotation,
+                        "cam_intrinsic": cam_info["cam_intrinsic"],
+                    }
+                )
+
+            sample.update(
+                dict(
+                    img_filename=image_paths, lidar2img=lidar2img_rts, caminfo=caminfos
+                )
+            )
+
+        return sample
+
+    def prepare_test_data(self, info):
+        sample = self.get_data_info(info)
+        sample = self.add_new_fields(sample)
+        return sample
+
+    def add_new_fields(self, sample):
+        sample["img_fields"] = []
+        sample["bbox3d_fields"] = []
+        sample["pts_mask_fields"] = []
+        sample["pts_seg_fields"] = []
+        sample["bbox_fields"] = []
+        sample["mask_fields"] = []
+        sample["seg_fields"] = []
+        return sample
+
+    def __call__(self, batch_data):
+        return [self.prepare_test_data(data_info) for data_info in batch_data]

paddlex/inference/common/reader/image_reader.py

@@ -0,0 +1,73 @@
+# 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 numpy as np
+
+from ....utils.deps import class_requires_deps, is_dep_available
+from ...utils.benchmark import benchmark
+from ...utils.io import ImageReader
+
+if is_dep_available("opencv-contrib-python"):
+    import cv2
+
+
+@benchmark.timeit_with_options(name=None, is_read_operation=True)
+@class_requires_deps("opencv-contrib-python")
+class ReadImage:
+    """Load image from the file."""
+
+    def __init__(self, format="BGR"):
+        """
+        Initialize the instance.
+
+        Args:
+            format (str, optional): Target color format to convert the image to.
+                Choices are 'BGR', 'RGB', and 'GRAY'. Default: 'BGR'.
+        """
+        super().__init__()
+        self.format = format
+        flags = {
+            "BGR": cv2.IMREAD_COLOR,
+            "RGB": cv2.IMREAD_COLOR,
+            "GRAY": cv2.IMREAD_GRAYSCALE,
+        }[self.format]
+        self._img_reader = ImageReader(backend="opencv", flags=flags)
+
+    def __call__(self, imgs):
+        """apply"""
+        return [self.read(img) for img in imgs]
+
+    def read(self, img):
+        if isinstance(img, np.ndarray):
+            if self.format == "RGB":
+                img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+            return img
+        elif isinstance(img, str):
+            blob = self._img_reader.read(img)
+            if blob is None:
+                raise Exception(f"Image read Error: {img}")
+
+            if self.format == "RGB":
+                if blob.ndim != 3:
+                    raise RuntimeError("Array is not 3-dimensional.")
+                # BGR to RGB
+                blob = cv2.cvtColor(blob, cv2.COLOR_BGR2RGB)
+            return blob
+        else:
+            raise TypeError(
+                f"ReadImage only supports the following types:\n"
+                f"1. str, indicating a image file path or a directory containing image files.\n"
+                f"2. numpy.ndarray.\n"
+                f"However, got type: {type(img).__name__}."
+            )

paddlex/inference/common/reader/ts_reader.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.
+
+import pandas as pd
+
+from ...utils.benchmark import benchmark
+from ...utils.io import CSVReader
+
+
+@benchmark.timeit_with_options(name=None, is_read_operation=True)
+class ReadTS:
+
+    def __init__(self):
+        super().__init__()
+        self._reader = CSVReader(backend="pandas")
+
+    def __call__(self, ts_list):
+        """apply"""
+        return [self.read(ts) for ts in ts_list]
+
+    def read(self, ts):
+        if isinstance(ts, pd.DataFrame):
+            return ts
+        elif isinstance(ts, str):
+            ts_data = self._reader.read(ts)
+            if ts_data is None:
+                raise Exception(f"TS read Error: {ts}")
+            return ts_data
+        else:
+            raise TypeError(
+                f"ReadTS only supports the following types:\n"
+                f"1. str, indicating a CSV file path or a directory containing CSV files.\n"
+                f"2. pandas.DataFrame.\n"
+                f"However, got type: {type(ts).__name__}."
+            )

paddlex/inference/common/reader/video_reader.py

@@ -0,0 +1,42 @@
+# 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.benchmark import benchmark
+from ...utils.io import VideoReader
+
+
+@benchmark.timeit_with_options(name=None, is_read_operation=True)
+class ReadVideo:
+    """Load video from the file."""
+
+    def __init__(self, backend="opencv", num_seg=8, seg_len=1, sample_type=None):
+
+        super().__init__()
+        self._video_reader = VideoReader(
+            backend=backend, num_seg=num_seg, seg_len=seg_len, sample_type=sample_type
+        )
+
+    def __call__(self, videos):
+        """apply"""
+        return [self._read(video) for video in videos]
+
+    def _read(self, file_path):
+        return self._read_video(file_path)
+
+    def _read_video(self, video_path):
+        blob = list(self._video_reader.read(video_path))
+        if blob is None:
+            raise Exception("Video read Error")
+        return blob

paddlex/inference/common/result/__init__.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 .base_cv_result import BaseCVResult
+from .base_result import BaseResult
+from .base_ts_result import BaseTSResult
+from .base_video_result import BaseVideoResult
+from .mixin import (
+    Base64Mixin,
+    CSVMixin,
+    HtmlMixin,
+    ImgMixin,
+    JsonMixin,
+    MarkdownMixin,
+    StrMixin,
+    VideoMixin,
+    XlsxMixin,
+)

paddlex/inference/common/result/base_cv_result.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 pathlib import Path
+
+from .base_result import BaseResult
+from .mixin import ImgMixin
+
+
+class BaseCVResult(BaseResult, ImgMixin):
+    """Base class for computer vision results."""
+
+    def __init__(self, data: dict) -> None:
+        """
+        Initialize the BaseCVResult.
+
+        Args:
+            data (dict): The initial data.
+        """
+        super().__init__(data)
+        ImgMixin.__init__(self, "pillow")
+
+    def _get_input_fn(self):
+        fn = super()._get_input_fn()
+        if (page_idx := self.get("page_index", None)) is not None:
+            fp = Path(fn)
+            stem, suffix = fp.stem, fp.suffix
+            return f"{stem}_{page_idx}{suffix}"
+        else:
+            return fn

paddlex/inference/common/result/base_result.py

@@ -0,0 +1,72 @@
+# 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 inspect
+import random
+import time
+from pathlib import Path
+
+import numpy as np
+
+from ....utils import logging
+from .mixin import JsonMixin, StrMixin
+
+
+class BaseResult(dict, JsonMixin, StrMixin):
+    """Base class for result objects that can save themselves.
+
+    This class inherits from dict and provides properties and methods for handling result.
+    """
+
+    def __init__(self, data: dict) -> None:
+        """Initializes the BaseResult with the given data.
+
+        Args:
+            data (dict): The initial data.
+        """
+        super().__init__(data)
+        self._save_funcs = []
+        StrMixin.__init__(self)
+        JsonMixin.__init__(self)
+        np.set_printoptions(threshold=1, edgeitems=1)
+        self._rand_fn = None
+
+    def save_all(self, save_path: str) -> None:
+        """Calls all registered save methods with the given save path.
+
+        Args:
+            save_path (str): The path to save the result to.
+        """
+        for func in self._save_funcs:
+            signature = inspect.signature(func)
+            if "save_path" in signature.parameters:
+                func(save_path=save_path)
+            else:
+                func()
+
+    def _get_input_fn(self):
+        if self.get("input_path", None) is None:
+            if self._rand_fn:
+                return self._rand_fn
+
+            timestamp = int(time.time())
+            random_number = random.randint(1000, 9999)
+            fp = f"{timestamp}_{random_number}"
+            logging.warning(
+                f"There is not input file name as reference for name of saved result file. So the saved result file would be named with timestamp and random number: `{fp}`."
+            )
+            self._rand_fn = Path(fp).name
+            return self._rand_fn
+        fp = self["input_path"]
+        return Path(fp).name