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

paddlex/inference/common/batch_sampler/det_3d_batch_sampler.py

@@ -0,0 +1,144 @@
+# 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
+import pickle
+import tarfile
+from pathlib import Path
+from typing import Any, Dict, List, Union
+
+from ....utils import logging
+from ....utils.cache import CACHE_DIR
+from ....utils.download import download
+from .base_batch_sampler import BaseBatchSampler
+
+
+class Det3DBatchSampler(BaseBatchSampler):
+
+    def __init__(self, temp_dir) -> None:
+        super().__init__()
+        self.temp_dir = temp_dir
+
+    # XXX: auto download for url
+    def _download_from_url(self, in_path: str) -> str:
+        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()
+
+    @property
+    def batch_size(self) -> int:
+        """Gets the batch size."""
+        return self._batch_size
+
+    @batch_size.setter
+    def batch_size(self, batch_size: int) -> None:
+        """Sets the batch size.
+
+        Args:
+            batch_size (int): The batch size to set.
+        """
+        if batch_size != 1:
+            logging.warning(
+                "inference for 3D models only support batch_size equal to 1"
+            )
+        self._batch_size = batch_size
+
+    def load_annotations(self, ann_file: str, data_root_dir: str) -> List[Dict]:
+        """Load annotations from ann_file.
+
+        Args:
+            ann_file (str): Path of the annotation file.
+            data_root_dir: (str): Path of the data root directory.
+
+        Returns:
+            list[dict]: List of annotations sorted by timestamps.
+        """
+        data = pickle.load(open(ann_file, "rb"))
+        data_infos = list(sorted(data["infos"], key=lambda e: e["timestamp"]))
+        # append root_dir to image and lidar filepaths
+        for item in data_infos:
+            # lidar data
+            lidar_path = item["lidar_path"]
+            new_lidar_path = os.path.join(data_root_dir, lidar_path)
+            item["lidar_path"] = new_lidar_path
+            # camera data
+            cam_data = item["cams"]
+            for cam_data_item_key in cam_data:
+                cam_data_item = cam_data[cam_data_item_key]
+                cam_data_item_path = cam_data_item["data_path"]
+                new_cam_data_item_path = os.path.join(data_root_dir, cam_data_item_path)
+                cam_data_item["data_path"] = new_cam_data_item_path
+            # sweep data
+            sweeps = item["sweeps"]
+            for sweep_item in sweeps:
+                sweep_item_path = sweep_item["data_path"]
+                new_sweep_item_path = os.path.join(data_root_dir, sweep_item_path)
+                sweep_item["data_path"] = new_sweep_item_path
+        return data_infos
+
+    def sample(self, inputs: Union[List[str], str]):
+        if not isinstance(inputs, list):
+            inputs = [inputs]
+
+        sample_set = []
+        for input in inputs:
+            if isinstance(input, str):
+                ann_path = (
+                    self._download_from_url(input)
+                    if input.startswith("http")
+                    else input
+                )
+            else:
+                logging.warning(
+                    f"Not supported input data type! Only `str` is supported! So has been ignored: {input}."
+                )
+            # extract tar file to tempdir
+            dataset_name = self.extract_tar(ann_path, self.temp_dir)
+            data_root_dir = os.path.join(self.temp_dir, dataset_name)
+            ann_pkl_path = os.path.join(data_root_dir, "nuscenes_infos_val.pkl")
+            self.data_infos = self.load_annotations(ann_pkl_path, data_root_dir)
+            sample_set.extend(self.data_infos)
+
+        batch = []
+        for sample in sample_set:
+            batch.append(sample)
+            if len(batch) == self.batch_size:
+                yield batch
+                batch = []
+
+        if len(batch) > 0:
+            yield batch
+
+    def _rand_batch(self, data_size: int) -> List[Any]:
+        raise NotImplementedError(
+            "rand batch is not supported for 3D detection annotation data"
+        )
+
+    def extract_tar(self, tar_path, extract_path="."):
+        try:
+            memdirs = set()
+            with tarfile.open(tar_path, "r") as tar:
+                for member in tar.getmembers():
+                    memdir = member.name.split("/")[0]
+                    memdirs.add(memdir)
+                    tar.extract(member, path=extract_path)
+                logging.info(f"file extract to {extract_path}")
+            assert (
+                len(memdirs) == 1
+            ), "Only one base directory is allowed for 3d bev dataset!"
+            return list(memdirs)[0]
+        except Exception as e:
+            logging.error(f"error occurred while extracting tar file")
+            raise e

paddlex/inference/common/batch_sampler/doc_vlm_batch_sampler.py

@@ -0,0 +1,64 @@
+# 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 import logging
+from .base_batch_sampler import BaseBatchSampler
+
+
+class DocVLMBatchSampler(BaseBatchSampler):
+    def __init__(self):
+        """Initializes the BaseBatchSampler.
+
+        Args:
+            batch_size (int, optional): The size of each batch. Only support 1.
+        """
+        super().__init__()
+        self.batch_size = 1
+
+    def sample(self, inputs):
+        """Generate list of input file path.
+
+        Args:
+            inputs (str): file path.
+
+        Yields:
+            list: list of file path.
+        """
+        if isinstance(inputs, dict):
+            yield [inputs]
+        elif isinstance(inputs, list) and all(isinstance(i, dict) for i in inputs):
+            yield inputs
+        else:
+            raise TypeError(
+                f"Not supported input data type! Only `dict` are supported, but got: {type(inputs)}."
+            )
+
+    @BaseBatchSampler.batch_size.setter
+    def batch_size(self, batch_size):
+        """Sets the batch size.
+
+        Args:
+            batch_size (int): The batch size to set.
+
+        Raises:
+            Warning: If the batch size is not equal 1.
+        """
+        # only support batch size 1
+        if batch_size != 1:
+            logging.warning(
+                f"doc vlm batch sampler only support batch size 1, but got {batch_size}."
+            )
+        else:
+            self._batch_size = batch_size

paddlex/inference/common/batch_sampler/image_batch_sampler.py

@@ -0,0 +1,112 @@
+# 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
+
+import numpy as np
+
+from ....utils import logging
+from ....utils.cache import CACHE_DIR
+from ....utils.download import download
+from ...utils.io import PDFReader
+from .base_batch_sampler import BaseBatchSampler, Batch
+
+
+class ImgBatch(Batch):
+    def __init__(self):
+        super().__init__()
+        self.page_indexes = []
+
+    def append(self, instance, input_path, page_index):
+        super().append(instance, input_path)
+        self.page_indexes.append(page_index)
+
+    def reset(self):
+        super().reset()
+        self.page_indexes = []
+
+
+class ImageBatchSampler(BaseBatchSampler):
+
+    SUFFIX = ["jpg", "png", "jpeg", "JPEG", "JPG", "bmp"]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.pdf_reader = PDFReader()
+
+    # 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 img 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 = ImgBatch()
+        for input in inputs:
+            if isinstance(input, np.ndarray):
+                batch.append(input, None, None)
+                if len(batch) == self.batch_size:
+                    yield batch
+                    batch = ImgBatch()
+            elif isinstance(input, str) and input.split(".")[-1] in ("PDF", "pdf"):
+                file_path = (
+                    self._download_from_url(input)
+                    if input.startswith("http")
+                    else input
+                )
+                for page_idx, page_img in enumerate(self.pdf_reader.read(file_path)):
+                    batch.append(page_img, file_path, page_idx)
+                    if len(batch) == self.batch_size:
+                        yield batch
+                        batch = ImgBatch()
+            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, file_path, None)
+                    if len(batch) == self.batch_size:
+                        yield batch
+                        batch = ImgBatch()
+            else:
+                logging.warning(
+                    f"Not supported input data type! Only `numpy.ndarray` and `str` are supported! So has been ignored: {input}."
+                )
+        if len(batch) > 0:
+            yield batch

paddlex/inference/common/batch_sampler/ts_batch_sampler.py

@@ -0,0 +1,109 @@
+# 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
+
+import pandas as pd
+
+from ....utils import logging
+from ....utils.cache import CACHE_DIR
+from ....utils.download import download
+from .base_batch_sampler import BaseBatchSampler, Batch
+
+
+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 = Batch()
+        for input in inputs:
+            if isinstance(input, pd.DataFrame):
+                batch.append(input, None)
+                if len(batch) == self.batch_size:
+                    yield batch
+                    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, file_path)
+                    if len(batch) == self.batch_size:
+                        yield batch
+                        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,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__}."
+            )