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

paddlex/inference/pipelines/ppchatocrv3/utils.py

@@ -0,0 +1,168 @@
+# 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 re
+from scipy.ndimage import rotate
+
+
+def get_ocr_res(pipeline, input):
+    """get ocr res"""
+    ocr_res_list = []
+    if isinstance(input, list):
+        img = [im["img"] for im in input]
+    elif isinstance(input, dict):
+        img = input["img"]
+    else:
+        img = input
+    for ocr_res in pipeline(img):
+        ocr_res_list.append(ocr_res)
+    if len(ocr_res_list) == 1:
+        return ocr_res_list[0]
+    else:
+        return ocr_res_list
+
+
+def get_oriclas_results(inputs, predictor):
+    results = []
+    img_list = [img_info["img"] for img_info in inputs]
+    for input, pred in zip(inputs, predictor(img_list)):
+        results.append(pred)
+        angle = int(pred["label_names"][0])
+        input["img"] = rotate_image(input["img"], angle)
+    return results
+
+
+def get_unwarp_results(inputs, predictor):
+    results = []
+    img_list = [img_info["img"] for img_info in inputs]
+    for input, pred in zip(inputs, predictor(img_list)):
+        results.append(pred)
+        input["img"] = pred["doctr_img"]
+    return results
+
+
+def get_predictor_res(predictor, input):
+    """get ocr res"""
+    result_list = []
+    if isinstance(input, list):
+        img = [im["img"] for im in input]
+    elif isinstance(input, dict):
+        img = input["img"]
+    else:
+        img = input
+    for res in predictor(img):
+        result_list.append(res)
+    if len(result_list) == 1:
+        return result_list[0]
+    else:
+        return result_list
+
+
+def rotate_image(image_array, rotate_angle):
+    """rotate image"""
+    assert (
+        rotate_angle >= 0 and rotate_angle < 360
+    ), "rotate_angle must in [0-360), but get {rotate_angle}."
+    return rotate(image_array, rotate_angle, reshape=True)
+
+
+def get_table_text_from_html(all_table_res):
+    all_table_ocr_res = []
+    structure_res = []
+    for table_res in all_table_res:
+        table_list = []
+        table_lines = re.findall("<tr>(.*?)</tr>", table_res["html"])
+        single_table_ocr_res = []
+        for td_line in table_lines:
+            table_list.extend(re.findall("<td.*?>(.*?)</td>", td_line))
+        for text in table_list:
+            text = text.replace(" ", "")
+            single_table_ocr_res.append(text)
+        all_table_ocr_res.append(" ".join(single_table_ocr_res))
+        structure_res.append(
+            {
+                "layout_bbox": table_res["layout_bbox"],
+                "table": table_res["html"],
+            }
+        )
+    return structure_res, all_table_ocr_res
+
+
+def format_key(key_list):
+    """format key"""
+    if key_list == "":
+        return "未内置默认字段，请输入确定的key"
+    if isinstance(key_list, list):
+        return key_list
+    key_list = re.sub(r"[\t\n\r\f\v]", "", key_list)
+    key_list = key_list.replace("，", ",").split(",")
+    return key_list
+
+
+def sorted_layout_boxes(res, w):
+    """
+    Sort text boxes in order from top to bottom, left to right
+    args:
+        res(list):ppstructure results
+        w(int):image width
+    return:
+        sorted results(list)
+    """
+    num_boxes = len(res)
+    if num_boxes == 1:
+        res[0]["layout"] = "single"
+        return res
+
+    # Sort on the y axis first or sort it on the x axis
+    sorted_boxes = sorted(res, key=lambda x: (x["layout_bbox"][1], x["layout_bbox"][0]))
+    _boxes = list(sorted_boxes)
+
+    new_res = []
+    res_left = []
+    res_right = []
+    i = 0
+
+    while True:
+        if i >= num_boxes:
+            break
+        # Check that the bbox is on the left
+        elif (
+            _boxes[i]["layout_bbox"][0] < w / 4
+            and _boxes[i]["layout_bbox"][2] < 3 * w / 5
+        ):
+            _boxes[i]["layout"] = "double"
+            res_left.append(_boxes[i])
+            i += 1
+        elif _boxes[i]["layout_bbox"][0] > 2 * w / 5:
+            _boxes[i]["layout"] = "double"
+            res_right.append(_boxes[i])
+            i += 1
+        else:
+            new_res += res_left
+            new_res += res_right
+            _boxes[i]["layout"] = "single"
+            new_res.append(_boxes[i])
+            res_left = []
+            res_right = []
+            i += 1
+
+    res_left = sorted(res_left, key=lambda x: (x["layout_bbox"][1]))
+    res_right = sorted(res_right, key=lambda x: (x["layout_bbox"][1]))
+
+    if res_left:
+        new_res += res_left
+    if res_right:
+        new_res += res_right
+
+    return new_res

paddlex/inference/pipelines/seal_recognition.py

@@ -0,0 +1,152 @@
+# 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 .base import BasePipeline
+from .ocr import OCRPipeline
+from ..components import CropByBoxes, ReadImage
+from ..results import SealOCRResult, OCRResult
+from ...utils import logging
+
+
+def get_ocr_res(pipeline, input):
+    """get ocr res"""
+    ocr_res_list = []
+    if isinstance(input, list):
+        img = [im["img"] for im in input]
+    elif isinstance(input, dict):
+        img = input["img"]
+    else:
+        img = input
+    for ocr_res in pipeline(img):
+        ocr_res_list.append(ocr_res)
+    return ocr_res_list
+
+
+class SealOCRPipeline(BasePipeline):
+    """Seal Recognition Pipeline"""
+
+    entities = "seal_recognition"
+
+    def __init__(
+        self,
+        layout_model,
+        text_det_model,
+        text_rec_model,
+        layout_batch_size=1,
+        text_det_batch_size=1,
+        text_rec_batch_size=1,
+        device=None,
+        predictor_kwargs=None,
+    ):
+        super().__init__(device, predictor_kwargs)
+        self._build_predictor(
+            layout_model=layout_model,
+            text_det_model=text_det_model,
+            text_rec_model=text_rec_model,
+            layout_batch_size=layout_batch_size,
+            text_det_batch_size=text_det_batch_size,
+            text_rec_batch_size=text_rec_batch_size,
+        )
+        self.set_predictor(
+            layout_batch_size=layout_batch_size,
+            text_det_batch_size=text_det_batch_size,
+            text_rec_batch_size=text_rec_batch_size,
+        )
+        self.img_reader = ReadImage(format="BGR")
+
+    def _build_predictor(
+        self,
+        layout_model,
+        text_det_model,
+        text_rec_model,
+        layout_batch_size,
+        text_det_batch_size,
+        text_rec_batch_size,
+    ):
+        self.layout_predictor = self._create(model=layout_model)
+        self.ocr_pipeline = self._create(
+            pipeline=OCRPipeline,
+            text_det_model=text_det_model,
+            text_rec_model=text_rec_model,
+        )
+        self._crop_by_boxes = CropByBoxes()
+
+    def set_predictor(
+        self,
+        layout_batch_size=None,
+        text_det_batch_size=None,
+        text_rec_batch_size=None,
+        device=None,
+    ):
+        if text_det_batch_size and text_det_batch_size > 1:
+            logging.warning(
+                f"text det model only support batch_size=1 now,the setting of text_det_batch_size={text_det_batch_size} will not using! "
+            )
+        if layout_batch_size:
+            self.layout_predictor.set_predictor(batch_size=layout_batch_size)
+        if text_rec_batch_size:
+            self.ocr_pipeline.text_rec_model.set_predictor(
+                batch_size=text_rec_batch_size
+            )
+        if device:
+            self.layout_predictor.set_predictor(device=device)
+            self.ocr_pipeline.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": {},
+            }
+            # update layout result
+            single_img_res["input_path"] = layout_pred["input_path"]
+            single_img_res["layout_result"] = layout_pred
+
+            seal_subs = []
+            if len(layout_pred["boxes"]) > 0:
+                subs_of_img = list(self._crop_by_boxes(layout_pred))
+                # get cropped images with label "seal"
+                for sub in subs_of_img:
+                    box = sub["box"]
+                    if sub["label"].lower() == "seal":
+                        seal_subs.append(sub)
+            all_seal_ocr_res = get_ocr_res(self.ocr_pipeline, seal_subs)
+            seal_res = {
+                "dt_polys": [],
+                "dt_scores": [],
+                "rec_text": [],
+                "rec_score": [],
+            }
+            for sub, seal_ocr_res in zip(seal_subs, all_seal_ocr_res):
+                if len(seal_ocr_res["dt_polys"]) > 0:
+                    box = sub["box"]
+                    ori_bbox_list = [
+                        dt + np.array(box[:2]).astype(np.int32)
+                        for dt in seal_ocr_res["dt_polys"]
+                    ]
+                    seal_res["dt_polys"].extend(ori_bbox_list)
+                    seal_res["dt_scores"].extend(seal_ocr_res["dt_scores"])
+                    seal_res["rec_text"].extend(seal_ocr_res["rec_text"])
+                    seal_res["rec_score"].extend(seal_ocr_res["rec_score"])
+            seal_res["input_path"] = single_img_res["input_path"]
+            single_img_res["src_file_name"] = inputs
+            single_img_res["ocr_result"] = OCRResult(seal_res)
+            single_img_res["page_id"] = page_id
+
+            yield SealOCRResult(single_img_res)

paddlex/inference/pipelines/serving/__init__.py

@@ -0,0 +1,17 @@
+# 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 ._pipeline_apps import create_pipeline_app
+from .app import create_app_config
+from .server import run_server

paddlex/inference/pipelines/serving/_pipeline_apps/__init__.py

@@ -0,0 +1,205 @@
+# 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
+
+from fastapi import FastAPI
+
+from ...attribute_recognition import (
+    PedestrianAttributeRecPipeline,
+    VehicleAttributeRecPipeline,
+)
+from ...base import BasePipeline
+from ...face_recognition import FaceRecPipeline
+from ...formula_recognition import FormulaRecognitionPipeline
+from ...layout_parsing import LayoutParsingPipeline
+from ...ocr import OCRPipeline
+from ...pp_shitu_v2 import ShiTuV2Pipeline
+from ...ppchatocrv3 import PPChatOCRPipeline
+from ...seal_recognition import SealOCRPipeline
+from ...single_model_pipeline import (
+    AnomalyDetection,
+    ImageClassification,
+    InstanceSegmentation,
+    MultiLableImageClas,
+    ObjectDetection,
+    SemanticSegmentation,
+    SmallObjDet,
+    TSAd,
+    TSCls,
+    TSFc,
+)
+from ...table_recognition import TableRecPipeline
+from ..app import create_app_config
+from .anomaly_detection import create_pipeline_app as create_anomaly_detection_app
+from .face_recognition import create_pipeline_app as create_face_recognition_app
+from .formula_recognition import create_pipeline_app as create_formula_recognition_app
+from .layout_parsing import create_pipeline_app as create_layout_parsing_app
+from .image_classification import create_pipeline_app as create_image_classification_app
+from .instance_segmentation import (
+    create_pipeline_app as create_instance_segmentation_app,
+)
+from .multi_label_image_classification import (
+    create_pipeline_app as create_multi_label_image_classification_app,
+)
+from .object_detection import create_pipeline_app as create_object_detection_app
+from .ocr import create_pipeline_app as create_ocr_app
+from .pedestrian_attribute_recognition import (
+    create_pipeline_app as create_pedestrian_attribute_recognition_app,
+)
+from .vehicle_attribute_recognition import (
+    create_pipeline_app as create_vehicle_attribute_recognition_app,
+)
+from .pp_shitu_v2 import create_pipeline_app as create_pp_shitu_v2_app
+from .ppchatocrv3 import create_pipeline_app as create_ppchatocrv3_app
+from .seal_recognition import create_pipeline_app as create_seal_recognition_app
+from .semantic_segmentation import (
+    create_pipeline_app as create_semantic_segmentation_app,
+)
+from .small_object_detection import (
+    create_pipeline_app as create_small_object_detection_app,
+)
+from .table_recognition import create_pipeline_app as create_table_recognition_app
+from .ts_ad import create_pipeline_app as create_ts_ad_app
+from .ts_cls import create_pipeline_app as create_ts_cls_app
+from .ts_fc import create_pipeline_app as create_ts_fc_app
+
+
+# XXX (Bobholamovic): This is tightly coupled to the name-pipeline mapping,
+# which is dirty but necessary. I want to keep the pipeline definition code
+# untouched while adding the pipeline serving feature. Each pipeline app depends
+# on a specific pipeline class, and a pipeline name must be provided (in the
+# pipeline config) to specify the type of the pipeline.
+def create_pipeline_app(
+    pipeline: BasePipeline, pipeline_config: Dict[str, Any]
+) -> FastAPI:
+    pipeline_name = pipeline_config["Global"]["pipeline_name"]
+    app_config = create_app_config(pipeline_config)
+    if pipeline_name == "image_classification":
+        if not isinstance(pipeline, ImageClassification):
+            raise TypeError(
+                "Expected `pipeline` to be an instance of `ImageClassification`."
+            )
+        return create_image_classification_app(pipeline, app_config)
+    elif pipeline_name == "instance_segmentation":
+        if not isinstance(pipeline, InstanceSegmentation):
+            raise TypeError(
+                "Expected `pipeline` to be an instance of `InstanceSegmentation`."
+            )
+        return create_instance_segmentation_app(pipeline, app_config)
+    elif pipeline_name == "object_detection":
+        if not isinstance(pipeline, ObjectDetection):
+            raise TypeError(
+                "Expected `pipeline` to be an instance of `ObjectDetection`."
+            )
+        return create_object_detection_app(pipeline, app_config)
+    elif pipeline_name == "OCR":
+        if not isinstance(pipeline, OCRPipeline):
+            raise TypeError("Expected `pipeline` to be an instance of `OCRPipeline`.")
+        return create_ocr_app(pipeline, app_config)
+    elif pipeline_name == "semantic_segmentation":
+        if not isinstance(pipeline, SemanticSegmentation):
+            raise TypeError(
+                "Expected `pipeline` to be an instance of `SemanticSegmentation`."
+            )
+        return create_semantic_segmentation_app(pipeline, app_config)
+    elif pipeline_name == "table_recognition":
+        if not isinstance(pipeline, TableRecPipeline):
+            raise TypeError(
+                "Expected `pipeline` to be an instance of `TableRecPipeline`."
+            )
+        return create_table_recognition_app(pipeline, app_config)
+    elif pipeline_name == "ts_ad":
+        if not isinstance(pipeline, TSAd):
+            raise TypeError("Expected `pipeline` to be an instance of `TSAd`.")
+        return create_ts_ad_app(pipeline, app_config)
+    elif pipeline_name == "ts_cls":
+        if not isinstance(pipeline, TSCls):
+            raise TypeError("Expected `pipeline` to be an instance of `TSCls`.")
+        return create_ts_cls_app(pipeline, app_config)
+    elif pipeline_name == "ts_fc":
+        if not isinstance(pipeline, TSFc):
+            raise TypeError("Expected `pipeline` to be an instance of `TSFc`.")
+        return create_ts_fc_app(pipeline, app_config)
+    elif pipeline_name == "multi_label_image_classification":
+        if not isinstance(pipeline, MultiLableImageClas):
+            raise TypeError(
+                "Expected `pipeline` to be an instance of `MultiLableImageClas`."
+            )
+        return create_multi_label_image_classification_app(pipeline, app_config)
+    elif pipeline_name == "small_object_detection":
+        if not isinstance(pipeline, SmallObjDet):
+            raise TypeError("Expected `pipeline` to be an instance of `SmallObjDet`.")
+        return create_small_object_detection_app(pipeline, app_config)
+    elif pipeline_name == "anomaly_detection":
+        if not isinstance(pipeline, AnomalyDetection):
+            raise TypeError(
+                "Expected `pipeline` to be an instance of `AnomalyDetection`."
+            )
+        return create_anomaly_detection_app(pipeline, app_config)
+    elif pipeline_name == "PP-ChatOCRv3-doc":
+        if not isinstance(pipeline, PPChatOCRPipeline):
+            raise TypeError(
+                "Expected `pipeline` to be an instance of `PPChatOCRPipeline`."
+            )
+        return create_ppchatocrv3_app(pipeline, app_config)
+    elif pipeline_name == "seal_recognition":
+        if not isinstance(pipeline, SealOCRPipeline):
+            raise TypeError(
+                "Expected `pipeline` to be an instance of `SealOCRPipeline`."
+            )
+        return create_seal_recognition_app(pipeline, app_config)
+    elif pipeline_name == "formula_recognition":
+        if not isinstance(pipeline, FormulaRecognitionPipeline):
+            raise TypeError(
+                "Expected `pipeline` to be an instance of `FormulaRecognitionPipeline`."
+            )
+        return create_formula_recognition_app(pipeline, app_config)
+    elif pipeline_name == "layout_parsing":
+        if not isinstance(pipeline, LayoutParsingPipeline):
+            raise TypeError(
+                "Expected `pipeline` to be an instance of `LayoutParsingPipeline`."
+            )
+        return create_layout_parsing_app(pipeline, app_config)
+    elif pipeline_name == "pedestrian_attribute_recognition":
+        if not isinstance(pipeline, PedestrianAttributeRecPipeline):
+            raise TypeError(
+                "Expected `pipeline` to be an instance of `PedestrianAttributeRecPipeline`."
+            )
+        return create_pedestrian_attribute_recognition_app(pipeline, app_config)
+    elif pipeline_name == "vehicle_attribute_recognition":
+        if not isinstance(pipeline, VehicleAttributeRecPipeline):
+            raise TypeError(
+                "Expected `pipeline` to be an instance of `VehicleAttributeRecPipeline`."
+            )
+        return create_vehicle_attribute_recognition_app(pipeline, app_config)
+    elif pipeline_name == "PP-ShiTuV2":
+        if not isinstance(pipeline, ShiTuV2Pipeline):
+            raise TypeError(
+                "Expected `pipeline` to be an instance of `ShiTuV2Pipeline`."
+            )
+        return create_pp_shitu_v2_app(pipeline, app_config)
+    elif pipeline_name == "face_recognition":
+        if not isinstance(pipeline, FaceRecPipeline):
+            raise TypeError(
+                "Expected `pipeline` to be an instance of `FaceRecPipeline`."
+            )
+        return create_face_recognition_app(pipeline, app_config)
+    else:
+        if BasePipeline.get(pipeline_name):
+            raise ValueError(
+                f"The {pipeline_name} pipeline does not support pipeline serving."
+            )
+        else:
+            raise ValueError("Unknown pipeline name")

paddlex/inference/pipelines/serving/_pipeline_apps/anomaly_detection.py

@@ -0,0 +1,80 @@
+# 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 List
+
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel, Field
+from typing_extensions import Annotated
+
+from .....utils import logging
+from ...single_model_pipeline import AnomalyDetection
+from .. import utils as serving_utils
+from ..app import AppConfig, create_app
+from ..models import Response, ResultResponse
+
+
+class InferRequest(BaseModel):
+    image: str
+
+
+class InferResult(BaseModel):
+    labelMap: List[int]
+    size: Annotated[List[int], Field(min_length=2, max_length=2)]
+    image: str
+
+
+def create_pipeline_app(pipeline: AnomalyDetection, app_config: AppConfig) -> FastAPI:
+    app, ctx = create_app(
+        pipeline=pipeline, app_config=app_config, app_aiohttp_session=True
+    )
+
+    @app.post(
+        "/image-anomaly-detection",
+        operation_id="infer",
+        responses={422: {"model": Response}},
+    )
+    async def _infer(request: InferRequest) -> ResultResponse[InferResult]:
+        pipeline = ctx.pipeline
+        aiohttp_session = ctx.aiohttp_session
+
+        try:
+            file_bytes = await serving_utils.get_raw_bytes(
+                request.image, aiohttp_session
+            )
+            image = serving_utils.image_bytes_to_array(file_bytes)
+
+            result = (await pipeline.infer(image))[0]
+
+            pred = result["pred"][0].tolist()
+            size = [len(pred), len(pred[0])]
+            label_map = [item for sublist in pred for item in sublist]
+            output_image_base64 = serving_utils.base64_encode(
+                serving_utils.image_to_bytes(result.img.convert("RGB"))
+            )
+
+            return ResultResponse(
+                logId=serving_utils.generate_log_id(),
+                errorCode=0,
+                errorMsg="Success",
+                result=InferResult(
+                    labelMap=label_map, size=size, image=output_image_base64
+                ),
+            )
+
+        except Exception as e:
+            logging.exception(e)
+            raise HTTPException(status_code=500, detail="Internal server error")
+
+    return app