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

paddlex/inference/pipelines/__init__.py

@@ -0,0 +1,127 @@
+# 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 pathlib import Path
+from typing import Any, Dict, Optional
+
+from ...utils.config import parse_config
+from ..utils.get_pipeline_path import get_pipeline_path
+from .base import BasePipeline
+from .single_model_pipeline import (
+    _SingleModelPipeline,
+    ImageClassification,
+    ObjectDetection,
+    InstanceSegmentation,
+    SemanticSegmentation,
+    TSFc,
+    TSAd,
+    TSCls,
+    MultiLableImageClas,
+    SmallObjDet,
+    AnomalyDetection,
+)
+from .ocr import OCRPipeline
+from .formula_recognition import FormulaRecognitionPipeline
+from .table_recognition import TableRecPipeline
+from .face_recognition import FaceRecPipeline
+from .seal_recognition import SealOCRPipeline
+from .ppchatocrv3 import PPChatOCRPipeline
+from .layout_parsing import LayoutParsingPipeline
+from .pp_shitu_v2 import ShiTuV2Pipeline
+from .attribute_recognition import (
+    PedestrianAttributeRecPipeline,
+    VehicleAttributeRecPipeline,
+)
+
+
+def load_pipeline_config(pipeline: str) -> Dict[str, Any]:
+    if not Path(pipeline).exists():
+        pipeline_path = get_pipeline_path(pipeline)
+        if pipeline_path is None:
+            raise Exception(
+                f"The pipeline ({pipeline}) does not exist! Please use a pipeline name or a config file path!"
+            )
+    else:
+        pipeline_path = pipeline
+    config = parse_config(pipeline_path)
+    return config
+
+
+def create_pipeline_from_config(
+    config: Dict[str, Any],
+    device=None,
+    pp_option=None,
+    use_hpip: bool = False,
+    hpi_params: Optional[Dict[str, Any]] = None,
+    *args,
+    **kwargs,
+) -> BasePipeline:
+    pipeline_name = config["Global"]["pipeline_name"]
+    pipeline_setting = config["Pipeline"]
+
+    predictor_kwargs = {"use_hpip": use_hpip}
+    if "use_hpip" in pipeline_setting:
+        predictor_kwargs["use_hpip"] = use_hpip
+    if hpi_params is not None:
+        predictor_kwargs["hpi_params"] = hpi_params
+        pipeline_setting.pop("hpi_params", None)
+    elif "hpi_params" in pipeline_setting:
+        predictor_kwargs["hpi_params"] = pipeline_setting.pop("hpi_params")
+
+    if pp_option is not None:
+        predictor_kwargs["pp_option"] = pp_option
+        pipeline_setting.pop("pp_option", None)
+    elif "pp_option" in pipeline_setting:
+        predictor_kwargs["pp_option"] = pipeline_setting.pop("pp_option")
+
+    if device:
+        pipeline_setting.pop("device", None)
+    else:
+        device = pipeline_setting.pop("device", None)
+
+    pipeline_setting.update(kwargs)
+    pipeline = BasePipeline.get(pipeline_name)(
+        device=device, predictor_kwargs=predictor_kwargs, *args, **pipeline_setting
+    )
+
+    return pipeline
+
+
+def create_pipeline(
+    pipeline: str,
+    device=None,
+    pp_option=None,
+    use_hpip: bool = False,
+    hpi_params: Optional[Dict[str, Any]] = None,
+    *args,
+    **kwargs,
+) -> BasePipeline:
+    """build model evaluater
+
+    Args:
+        pipeline (str): the pipeline name, that is name of pipeline class
+
+    Returns:
+        BasePipeline: the pipeline, which is subclass of BasePipeline.
+    """
+    config = load_pipeline_config(pipeline)
+    return create_pipeline_from_config(
+        config,
+        device=device,
+        pp_option=pp_option,
+        use_hpip=use_hpip,
+        hpi_params=hpi_params,
+        *args,
+        **kwargs,
+    )

paddlex/inference/pipelines/attribute_recognition.py

@@ -0,0 +1,92 @@
+# 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 pathlib import Path
+import numpy as np
+
+from ..utils.io import ImageReader
+from ..components import CropByBoxes
+from ..results import AttributeRecResult
+from .base import BasePipeline
+
+
+class AttributeRecPipeline(BasePipeline):
+    """Attribute Rec Pipeline"""
+
+    def __init__(
+        self,
+        det_model,
+        cls_model,
+        det_batch_size=1,
+        cls_batch_size=1,
+        device=None,
+        predictor_kwargs=None,
+    ):
+        super().__init__(device, predictor_kwargs)
+        self._build_predictor(det_model, cls_model)
+        self.set_predictor(det_batch_size, cls_batch_size, device)
+
+    def _build_predictor(self, det_model, cls_model):
+        self.det_model = self._create(model=det_model)
+        self.cls_model = self._create(model=cls_model)
+        self._crop_by_boxes = CropByBoxes()
+        self._img_reader = ImageReader(backend="opencv")
+
+    def set_predictor(self, det_batch_size=None, cls_batch_size=None, device=None):
+        if det_batch_size:
+            self.det_model.set_predictor(batch_size=det_batch_size)
+        if cls_batch_size:
+            self.cls_model.set_predictor(batch_size=cls_batch_size)
+        if device:
+            self.det_model.set_predictor(device=device)
+            self.cls_model.set_predictor(device=device)
+
+    def predict(self, input, **kwargs):
+        self.set_predictor(**kwargs)
+        for det_res in self.det_model(input):
+            cls_res = self.get_cls_result(det_res)
+            yield self.get_final_result(det_res, cls_res)
+
+    def get_cls_result(self, det_res):
+        subs_of_img = list(self._crop_by_boxes(det_res))
+        img_list = [img["img"] for img in subs_of_img]
+        all_cls_res = list(self.cls_model(img_list))
+        output = {"label": [], "score": []}
+        for res in all_cls_res:
+            output["label"].append(res["label_names"])
+            output["score"].append(res["scores"])
+        return output
+
+    def get_final_result(self, det_res, cls_res):
+        single_img_res = {"input_path": det_res["input_path"], "boxes": []}
+        for i, obj in enumerate(det_res["boxes"]):
+            cls_scores = cls_res["score"][i]
+            labels = cls_res["label"][i]
+            single_img_res["boxes"].append(
+                {
+                    "labels": labels,
+                    "cls_scores": cls_scores,
+                    "det_score": obj["score"],
+                    "coordinate": obj["coordinate"],
+                }
+            )
+        return AttributeRecResult(single_img_res)
+
+
+class PedestrianAttributeRecPipeline(AttributeRecPipeline):
+    entities = "pedestrian_attribute_recognition"
+
+
+class VehicleAttributeRecPipeline(AttributeRecPipeline):
+    entities = "vehicle_attribute_recognition"

paddlex/inference/pipelines/base.py

@@ -0,0 +1,86 @@
+# 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 abc import ABC, abstractmethod
+from contextvars import ContextVar, copy_context
+from typing import TypedDict, Type
+
+from ...utils.subclass_register import AutoRegisterABCMetaClass
+from ..models import create_predictor
+
+pipeline_info_list_var = ContextVar("pipeline_info_list", default=None)
+
+
+class _PipelineInfo(TypedDict):
+    cls: Type["BasePipeline"]
+
+
+class _PipelineMetaClass(AutoRegisterABCMetaClass):
+    def __new__(mcs, name, bases, attrs):
+        def _patch_init_func(init_func):
+            def _patched___init__(self, *args, **kwargs):
+                ctx = copy_context()
+                pipeline_info_list = [
+                    *ctx.get(pipeline_info_list_var, []),
+                    _PipelineInfo(cls=type(self)),
+                ]
+                ctx.run(pipeline_info_list_var.set, pipeline_info_list)
+                ret = ctx.run(init_func, self, *args, **kwargs)
+                return ret
+
+            return _patched___init__
+
+        cls = super().__new__(mcs, name, bases, attrs)
+        cls.__init__ = _patch_init_func(cls.__init__)
+        return cls
+
+
+class BasePipeline(ABC, metaclass=_PipelineMetaClass):
+    """Base Pipeline"""
+
+    __is_base = True
+
+    def __init__(self, device, predictor_kwargs={}) -> None:
+        super().__init__()
+        self._predictor_kwargs = predictor_kwargs
+        self._device = device
+
+    @abstractmethod
+    def set_predictor():
+        raise NotImplementedError(
+            "The method `set_predictor` has not been implemented yet."
+        )
+
+    # alias the __call__() to predict()
+    def __call__(self, *args, **kwargs):
+        yield from self.predict(*args, **kwargs)
+
+    def _create(self, model=None, pipeline=None, *args, **kwargs):
+        if model:
+            return create_predictor(
+                *args,
+                model=model,
+                device=self._device,
+                **kwargs,
+                **self._predictor_kwargs
+            )
+        elif pipeline:
+            return pipeline(
+                *args,
+                device=self._device,
+                predictor_kwargs=self._predictor_kwargs,
+                **kwargs
+            )
+        else:
+            raise Exception()

paddlex/inference/pipelines/face_recognition.py

@@ -0,0 +1,49 @@
+# 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 .pp_shitu_v2 import ShiTuV2Pipeline
+from ..results import FaceRecResult
+
+
+class FaceRecPipeline(ShiTuV2Pipeline):
+    """Face Recognition Pipeline"""
+
+    entities = "face_recognition"
+
+    def get_rec_result(self, det_res, indexer):
+        if len(det_res["boxes"]) == 0:
+            return {"label": [], "score": []}
+        subs_of_img = list(self._crop_by_boxes(det_res))
+        img_list = [img["img"] for img in subs_of_img]
+        all_rec_res = list(self.rec_model(img_list))
+        all_rec_res = next(indexer(all_rec_res))
+        output = {"label": [], "score": []}
+        for res in all_rec_res:
+            output["label"].append(res["label"])
+            output["score"].append(res["score"])
+        return output
+
+    def get_final_result(self, det_res, rec_res):
+        single_img_res = {"input_path": det_res["input_path"], "boxes": []}
+        for i, obj in enumerate(det_res["boxes"]):
+            rec_scores = rec_res["score"][i]
+            labels = rec_res["label"][i]
+            single_img_res["boxes"].append(
+                {
+                    "labels": labels,
+                    "rec_scores": rec_scores,
+                    "det_score": obj["score"],
+                    "coordinate": obj["coordinate"],
+                }
+            )
+        return FaceRecResult(single_img_res)

paddlex/inference/pipelines/formula_recognition.py

@@ -0,0 +1,102 @@
+# 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
+from ..components import CropByBoxes, ReadImage
+from ..results import FormulaResult, FormulaVisualResult
+from .base import BasePipeline
+from ...utils import logging
+
+
+class FormulaRecognitionPipeline(BasePipeline):
+    """Formula Recognition Pipeline"""
+
+    entities = "formula_recognition"
+
+    def __init__(
+        self,
+        layout_model,
+        formula_rec_model,
+        layout_batch_size=1,
+        formula_rec_batch_size=1,
+        device=None,
+        predictor_kwargs=None,
+    ):
+        super().__init__(device, predictor_kwargs)
+        self._build_predictor(layout_model, formula_rec_model)
+        self.set_predictor(
+            layout_batch_size=layout_batch_size,
+            formula_rec_batch_size=formula_rec_batch_size,
+        )
+        self.img_reader = ReadImage(format="BGR")
+
+    def _build_predictor(self, layout_model, formula_rec_model):
+        self.layout_predictor = self._create(model=layout_model)
+        self.formula_predictor = self._create(model=formula_rec_model)
+        self._crop_by_boxes = CropByBoxes()
+
+    def set_predictor(
+        self, layout_batch_size=None, formula_rec_batch_size=None, device=None
+    ):
+        if layout_batch_size:
+            self.layout_predictor.set_predictor(batch_size=layout_batch_size)
+        if formula_rec_batch_size:
+            self.formula_predictor.set_predictor(batch_size=formula_rec_batch_size)
+        if device:
+            self.layout_predictor.set_predictor(device=device)
+            self.formula_predictor.set_predictor(device=device)
+
+    def predict(self, inputs, **kwargs):
+        self.set_predictor(**kwargs)
+        img_info_list = list(self.img_reader(inputs))[0]
+        img_list = [img_info["img"] for img_info in img_info_list]
+        for page_id, layout_pred in enumerate(self.layout_predictor(img_list)):
+            single_img_res = {
+                "input_path": "",
+                "layout_result": {},
+                "ocr_result": {},
+                "table_result": [],
+            }
+            # update layout result
+            single_img_res["input_path"] = layout_pred["input_path"]
+            single_img_res["layout_result"] = layout_pred
+            single_img_res["dt_polys"] = []
+            single_img_res["rec_formula"] = []
+            all_subs_of_formula_img = []
+            layout_pred["boxes"] = sorted(
+                layout_pred["boxes"], key=lambda x: self.sorted_formula_box(x)
+            )
+            if len(layout_pred["boxes"]) > 0:
+                subs_of_img = list(self._crop_by_boxes(layout_pred))
+                # get cropped images with label "formula"
+                for sub in subs_of_img:
+                    if sub["label"].lower() == "formula":
+                        boxes = sub["box"]
+                        x1, y1, x2, y2 = list(boxes)
+                        poly = np.array([[x1, y1], [x2, y1], [x2, y2], [x1, y2]])
+                        all_subs_of_formula_img.append(sub["img"])
+                        single_img_res["dt_polys"].append(poly)
+                if len(all_subs_of_formula_img) > 0:
+                    for formula_res in self.formula_predictor(all_subs_of_formula_img):
+                        single_img_res["rec_formula"].append(
+                            str(formula_res["rec_text"])
+                        )
+            single_img_res["formula_result"] = FormulaResult(single_img_res)
+            single_img_res["page_id"] = page_id + 1
+            yield FormulaVisualResult(single_img_res, page_id, inputs)
+
+    def sorted_formula_box(self, x):
+        coordinate = x["coordinate"]
+        x1, y1, x2, y2 = list(coordinate)
+        return (y1 + y2) / 2

paddlex/inference/pipelines/layout_parsing/__init__.py

@@ -0,0 +1,15 @@
+# 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 .layout_parsing import LayoutParsingPipeline