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

paddlex/configs/pipelines/table_recognition_v2.yaml

@@ -0,0 +1,76 @@
+
+pipeline_name: table_recognition_v2
+
+use_doc_preprocessor: True
+use_layout_detection: True
+use_ocr_model: True
+
+SubModules:
+  LayoutDetection:
+    module_name: layout_detection
+    model_name: PP-DocLayout-L
+    model_dir: null
+  
+  TableClassification:
+    module_name: table_classification
+    model_name: PP-LCNet_x1_0_table_cls
+    model_dir: null
+
+  WiredTableStructureRecognition:
+    module_name: table_structure_recognition
+    model_name: SLANeXt_wired
+    model_dir: null
+  
+  WirelessTableStructureRecognition:
+    module_name: table_structure_recognition
+    model_name: SLANeXt_wireless
+    model_dir: null
+  
+  WiredTableCellsDetection:
+    module_name: table_cells_detection
+    model_name: RT-DETR-L_wired_table_cell_det
+    model_dir: null
+  
+  WirelessTableCellsDetection:
+    module_name: table_cells_detection
+    model_name: RT-DETR-L_wireless_table_cell_det
+    model_dir: null
+
+SubPipelines:
+  DocPreprocessor:
+    pipeline_name: doc_preprocessor
+    use_doc_orientation_classify: True
+    use_doc_unwarping: True
+    SubModules:
+      DocOrientationClassify:
+        module_name: doc_text_orientation
+        model_name: PP-LCNet_x1_0_doc_ori
+        model_dir: null
+
+      DocUnwarping:
+        module_name: image_unwarping
+        model_name: UVDoc
+        model_dir: null
+
+  GeneralOCR:
+    pipeline_name: OCR
+    text_type: general
+    use_doc_preprocessor: False
+    use_textline_orientation: False
+    SubModules:
+      TextDetection:
+        module_name: text_detection
+        model_name: PP-OCRv4_server_det
+        model_dir: null
+        limit_side_len: 960
+        limit_type: max
+        thresh: 0.3
+        box_thresh: 0.4
+        unclip_ratio: 2.0
+        
+      TextRecognition:
+        module_name: text_recognition
+        model_name: PP-OCRv4_server_rec_doc
+        model_dir: null
+        batch_size: 1
+        score_thresh: 0

paddlex/configs/pipelines/ts_anomaly_detection.yaml

@@ -0,0 +1,8 @@
+pipeline_name: ts_anomaly_detection
+
+SubModules:
+  TSAnomalyDetection:
+    module_name: ts_anomaly_detection
+    model_name: DLinear_ad
+    model_dir: null
+    batch_size: 1   

paddlex/configs/pipelines/ts_classification.yaml

@@ -0,0 +1,8 @@
+pipeline_name: ts_classification
+
+SubModules:
+  TSClassification:
+    module_name: ts_classification
+    model_name: TimesNet_cls
+    model_dir: null
+    batch_size: 1   

paddlex/configs/pipelines/ts_forecast.yaml

@@ -0,0 +1,8 @@
+pipeline_name: ts_forecast
+
+SubModules:
+  TSForecast:
+    module_name: ts_forecast
+    model_name: DLinear
+    model_dir: null
+    batch_size: 1   

paddlex/configs/pipelines/vehicle_attribute_recognition.yaml

@@ -0,0 +1,15 @@
+pipeline_name: vehicle_attribute_recognition
+
+SubModules:
+  Detection:
+    module_name: object_detection
+    model_name: PP-YOLOE-L_vehicle
+    model_dir: null
+    batch_size: 1  
+    threshold: 0.5  
+  Classification:
+    module_name: multilabel_classification
+    model_name: PP-LCNet_x1_0_vehicle_attribute
+    model_dir: null
+    batch_size: 1
+    threshold: 0.7

paddlex/configs/pipelines/video_classification.yaml

@@ -0,0 +1,9 @@
+pipeline_name: video_classification
+
+SubModules:
+  VideoClassification:
+    module_name: video_classification
+    model_name: PP-TSMv2-LCNetV2_8frames_uniform
+    model_dir: null
+    batch_size: 1    
+    topk: 1

paddlex/configs/pipelines/video_detection.yaml

@@ -0,0 +1,10 @@
+pipeline_name: video_detection
+
+SubModules:
+  VideoDetection:
+    module_name: video_detection
+    model_name: YOWO
+    model_dir: null
+    batch_size: 1    
+    nms_thresh: 0.5
+    score_thresh: 0.8

paddlex/engine.py

@@ -47,7 +47,7 @@ class Engine(object):
             return self._model.export()
         elif self._mode == "predict":
             for res in self._model.predict():
-                res.print(json_format=False)
+                res.print()
                 if self._output:
                     res.save_all(save_path=self._output)
         else:

paddlex/hpip_links.html

@@ -0,0 +1,19 @@
+<!doctype html>
+<html>
+    <head>
+        <title>PaddleX HPIP Links</title>
+    </head>
+    <body>
+        <a href="https://paddle-model-ecology.bj.bcebos.com/paddlex/PaddleX3.0/deploy/hpi/ultra_infer/releases/3.0.0rc0/ultra_infer_python-1.0.0.3.0.0rc0-cp38-cp38-linux_x86_64.whl"></a>
+        <a href="https://paddle-model-ecology.bj.bcebos.com/paddlex/PaddleX3.0/deploy/hpi/ultra_infer/releases/3.0.0rc0/ultra_infer_python-1.0.0.3.0.0rc0-cp39-cp39-linux_x86_64.whl"></a>
+        <a href="https://paddle-model-ecology.bj.bcebos.com/paddlex/PaddleX3.0/deploy/hpi/ultra_infer/releases/3.0.0rc0/ultra_infer_python-1.0.0.3.0.0rc0-cp310-cp310-linux_x86_64.whl"></a>
+        <a href="https://paddle-model-ecology.bj.bcebos.com/paddlex/PaddleX3.0/deploy/hpi/ultra_infer/releases/3.0.0rc0/ultra_infer_python-1.0.0.3.0.0rc0-cp311-cp311-linux_x86_64.whl"></a>
+        <a href="https://paddle-model-ecology.bj.bcebos.com/paddlex/PaddleX3.0/deploy/hpi/ultra_infer/releases/3.0.0rc0/ultra_infer_python-1.0.0.3.0.0rc0-cp312-cp312-linux_x86_64.whl"></a>
+        <a href="https://paddle-model-ecology.bj.bcebos.com/paddlex/PaddleX3.0/deploy/hpi/ultra_infer/releases/3.0.0rc0/ultra_infer_gpu_python-1.0.0.3.0.0rc0-cp38-cp38-linux_x86_64.whl"></a>
+        <a href="https://paddle-model-ecology.bj.bcebos.com/paddlex/PaddleX3.0/deploy/hpi/ultra_infer/releases/3.0.0rc0/ultra_infer_gpu_python-1.0.0.3.0.0rc0-cp39-cp39-linux_x86_64.whl"></a>
+        <a href="https://paddle-model-ecology.bj.bcebos.com/paddlex/PaddleX3.0/deploy/hpi/ultra_infer/releases/3.0.0rc0/ultra_infer_gpu_python-1.0.0.3.0.0rc0-cp310-cp310-linux_x86_64.whl"></a>
+        <a href="https://paddle-model-ecology.bj.bcebos.com/paddlex/PaddleX3.0/deploy/hpi/ultra_infer/releases/3.0.0rc0/ultra_infer_gpu_python-1.0.0.3.0.0rc0-cp311-cp311-linux_x86_64.whl"></a>
+        <a href="https://paddle-model-ecology.bj.bcebos.com/paddlex/PaddleX3.0/deploy/hpi/ultra_infer/releases/3.0.0rc0/ultra_infer_gpu_python-1.0.0.3.0.0rc0-cp312-cp312-linux_x86_64.whl"></a>
+        <a href="https://paddle-model-ecology.bj.bcebos.com/paddlex/PaddleX3.0/deploy/hpi/ultra_infer/releases/3.0.0rc0/paddlex_hpi-3.0.0rc0-py3-none-any.whl"></a>
+    </body>
+</html>

paddlex/inference/__init__.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from ..utils import logging
+
+from .pipelines import create_pipeline, load_pipeline_config
 from .models import create_predictor
-from .pipelines import create_pipeline
 from .utils.pp_option import PaddlePredictorOption

paddlex/inference/common/batch_sampler/__init__.py

@@ -0,0 +1,20 @@
+# 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 .base_batch_sampler import BaseBatchSampler
+from .image_batch_sampler import ImageBatchSampler
+from .video_batch_sampler import VideoBatchSampler
+from .ts_batch_sampler import TSBatchSampler
+from .det_3d_batch_sampler import Det3DBatchSampler
+from .audio_batch_sampler import AudioBatchSampler

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