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

paddlex/inference/pipelines/ppchatocrv3/utils.py

@@ -1,168 +0,0 @@
-# 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

@@ -1,152 +0,0 @@
-# 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

@@ -1,17 +0,0 @@
-# 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

@@ -1,205 +0,0 @@
-# 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

@@ -1,80 +0,0 @@
-# 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