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

paddlex/inference/common/batch_sampler/audio_batch_sampler.py

@@ -0,0 +1,84 @@
+# 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.cache import CACHE_DIR
+from ....utils.download import download
+from .base_batch_sampler import BaseBatchSampler
+
+
+class AudioBatchSampler(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 _download_from_url(self, in_path):
+        """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 sample(self, inputs):
+        """Generate list of input file path.
+
+        Args:
+            inputs (str): file path.
+
+        Yields:
+            list: list of file path.
+        """
+        if isinstance(inputs, str):
+            if inputs.startswith("http"):
+                inputs = self._download_from_url(inputs)
+            yield [inputs]
+        else:
+            logging.warning(
+                f"Not supported input data type! Only `str` are supported, but got: {input}."
+            )
+
+    @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"audio batch sampler only support batch size 1, but got {batch_size}."
+            )
+        else:
+            self._batch_size = batch_size

paddlex/inference/common/batch_sampler/base_batch_sampler.py

@@ -0,0 +1,90 @@
+# 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 Union, Tuple, List, Dict, Any, Iterator
+from abc import ABC, abstractmethod
+
+from ....utils.flags import (
+    INFER_BENCHMARK,
+    INFER_BENCHMARK_ITER,
+    INFER_BENCHMARK_DATA_SIZE,
+)
+
+
+class BaseBatchSampler:
+    """BaseBatchSampler"""
+
+    def __init__(self, batch_size: int = 1) -> None:
+        """Initializes the BaseBatchSampler.
+
+        Args:
+            batch_size (int, optional): The size of each batch. Defaults to 1.
+        """
+        super().__init__()
+        self._batch_size = batch_size
+        self._benchmark = INFER_BENCHMARK
+        self._benchmark_iter = INFER_BENCHMARK_ITER
+        self._benchmark_data_size = INFER_BENCHMARK_DATA_SIZE
+
+    @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.
+
+        Raises:
+            AssertionError: If the batch size is not greater than 0.
+        """
+        assert batch_size > 0
+        self._batch_size = batch_size
+
+    def __call__(self, input: Any) -> Iterator[List[Any]]:
+        """
+        Sample batch data with the specified input.
+
+        If input is None and benchmarking is enabled, it will yield batches
+        of random data for the specified number of iterations.
+        Otherwise, it will yield from the apply() function.
+
+        Args:
+            input (Any): The input data to sampled.
+
+        Yields:
+            Iterator[List[Any]]: An iterator yielding the batch data.
+        """
+        if input is None and self._benchmark:
+            for _ in range(self._benchmark_iter):
+                yield self._rand_batch(self._benchmark_data_size)
+        else:
+            yield from self.sample(input)
+
+    @abstractmethod
+    def sample(self, *args: Tuple[Any], **kwargs: Dict[str, Any]) -> Iterator[list]:
+        """sample batch data"""
+        raise NotImplementedError
+
+    @abstractmethod
+    def _rand_batch(self, batch_size: int) -> List[Any]:
+        """rand batch data
+
+        Args:
+            batch_size (int): batch size
+        """
+        raise NotImplementedError

paddlex/inference/common/batch_sampler/det_3d_batch_sampler.py

@@ -0,0 +1,147 @@
+# 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, Dict, List, Optional, Union
+import os
+import ast
+from pathlib import Path
+import numpy as np
+import pickle
+import tarfile
+
+
+from ....utils import logging
+from ....utils.download import download
+from ....utils.cache import CACHE_DIR
+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/image_batch_sampler.py

@@ -0,0 +1,136 @@
+# 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 ...utils.io import PDFReader
+from .base_batch_sampler import BaseBatchSampler
+
+
+class ImgInstance:
+    def __init__(self):
+        self.instances = []
+        self.input_paths = []
+        self.page_indexes = []
+
+    def append(self, instance, input_path, page_index):
+        self.instances.append(instance)
+        self.input_paths.append(input_path)
+        self.page_indexes.append(page_index)
+
+    def reset(self):
+        self.instances = []
+        self.input_paths = []
+        self.page_indexes = []
+
+    def __len__(self):
+        return len(self.instances)
+
+
+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 = ImgInstance()
+        for input in inputs:
+            if isinstance(input, np.ndarray):
+                batch.append(input, None, None)
+                if len(batch) == self.batch_size:
+                    yield batch
+                    batch.reset()
+            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.reset()
+            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.reset()
+            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
+
+    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/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