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

paddlex/inference/common/batch_sampler/ts_batch_sampler.py

@@ -0,0 +1,110 @@
+# 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 ast
+from pathlib import Path
+import numpy as np
+import pandas as pd
+
+from ....utils import logging
+from ....utils.download import download
+from ....utils.cache import CACHE_DIR
+from .base_batch_sampler import BaseBatchSampler
+
+
+class TSBatchSampler(BaseBatchSampler):
+    """Batch sampler for time series data, supporting CSV file inputs."""
+
+    SUFFIX = ["csv"]
+
+    def _download_from_url(self, in_path: str) -> str:
+        """Download a file from a URL to a cache directory.
+
+        Args:
+            in_path (str): URL of the file to be downloaded.
+
+        Returns:
+            str: Path to the downloaded file.
+        """
+        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: str) -> list:
+        """Get a list of CSV files from a directory or a single file path.
+
+        Args:
+            fp (str): Path to a directory or a single CSV file.
+
+        Returns:
+            list: Sorted list of CSV file paths.
+
+        Raises:
+            Exception: If no CSV file is found in the path.
+        """
+        file_list = []
+        if fp is None or not os.path.exists(fp):
+            raise Exception(f"Not found any csv 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: list) -> list:
+        """Generate batches of data from inputs, which can be DataFrames or file paths.
+
+        Args:
+            inputs (list): List of DataFrames or file paths.
+
+        Yields:
+            list: A batch of data which is either DataFrames or file paths.
+        """
+        if not isinstance(inputs, list):
+            inputs = [inputs]
+
+        batch = []
+        for input in inputs:
+            if isinstance(input, pd.DataFrame):
+                batch.append(input)
+                if len(batch) == self.batch_size:
+                    yield batch
+                    batch = []
+            elif 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 `pd.DataFrame` and `str` are supported! So has been ignored: {input}."
+                )
+        if len(batch) > 0:
+            yield batch

paddlex/inference/common/batch_sampler/video_batch_sampler.py

@@ -0,0 +1,94 @@
+# 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 ast
+from pathlib import Path
+import numpy as np
+
+from ....utils import logging
+from ....utils.download import download
+from ....utils.cache import CACHE_DIR
+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
+
+    def _rand_batch(self, data_size):
+        def parse_size(s):
+            res = ast.literal_eval(s)
+            if isinstance(res, int):
+                return (res, res)
+            else:
+                assert isinstance(res, (tuple, list))
+                assert len(res) == 2
+                assert all(isinstance(item, int) for item in res)
+                return res
+
+        size = parse_size(data_size)
+        rand_batch = [
+            np.random.randint(0, 256, (*size, 3), dtype=np.uint8)
+            for _ in range(self.batch_size)
+        ]
+        return rand_batch

paddlex/inference/common/reader/__init__.py

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

paddlex/inference/common/reader/audio_reader.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
+import lazy_paddle as paddle
+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):
+        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,239 @@
+# 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
+import cv2
+import os
+from typing import Generic, List, Optional, Any, Dict
+import pickle
+
+
+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
+
+
+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,69 @@
+# 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
+import cv2
+
+from ...utils.io import ImageReader, PDFReader
+
+
+class ReadImage:
+    """Load image from the file."""
+
+    _FLAGS_DICT = {
+        "BGR": cv2.IMREAD_COLOR,
+        "RGB": cv2.IMREAD_COLOR,
+        "GRAY": cv2.IMREAD_GRAYSCALE,
+    }
+
+    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 = self._FLAGS_DICT[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 = img[:, :, ::-1]
+            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 = blob[..., ::-1]
+            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,45 @@
+# 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
+import pandas as pd
+
+from ...utils.io import CSVReader
+
+
+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 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
+import cv2
+
+from ...utils.io import VideoReader
+
+
+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