[Feat] Support serving pedestrian attribute recognition pipeline (#2437)

* Extract common functions

* Add pedestrian attribute recognition serving app

Author: Bobholamovic

docs/pipeline_usage/tutorials/cv_pipelines/pedestrian_attribute_recognition.en.md

@@ -39,7 +39,10 @@
 from .ppchatocrv3 import PPChatOCRPipeline
 from .layout_parsing import LayoutParsingPipeline
 from .pp_shitu_v2 import ShiTuV2Pipeline
-from .attribute_recognition import AttributeRecPipeline
+from .attribute_recognition import (
+    PedestrianAttributeRecPipeline,
+    VehicleAttributeRecPipeline,
+)
 
 
 def load_pipeline_config(pipeline: str) -> Dict[str, Any]:

docs/pipeline_usage/tutorials/cv_pipelines/pedestrian_attribute_recognition.md

@@ -24,8 +24,6 @@
 class AttributeRecPipeline(BasePipeline):
     """Attribute Rec Pipeline"""
 
-    entities = ["pedestrian_attribute_recognition", "vehicle_attribute_recognition"]
-
     def __init__(
         self,
         det_model,
@@ -84,3 +82,11 @@ def get_final_result(self, det_res, cls_res):
                 }
             )
         return AttributeRecResult(single_img_res)
+
+
+class PedestrianAttributeRecPipeline(AttributeRecPipeline):
+    entities = "pedestrian_attribute_recognition"
+
+
+class VehicleAttributeRecPipeline(AttributeRecPipeline):
+    entities = "vehicle_attribute_recognition"

paddlex/inference/pipelines/__init__.py

@@ -16,6 +16,7 @@
 
 from fastapi import FastAPI
 
+from ...attribute_recognition import PedestrianAttributeRecPipeline
 from ...base import BasePipeline
 from ...formula_recognition import FormulaRecognitionPipeline
 from ...layout_parsing import LayoutParsingPipeline
@@ -48,6 +49,9 @@
 )
 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 .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 (
@@ -158,6 +162,12 @@ def create_pipeline_app(
                 "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)
     else:
         if BasePipeline.get(pipeline_name):
             raise ValueError(

paddlex/inference/pipelines/attribute_recognition.py

@@ -13,17 +13,14 @@
 # limitations under the License.
 
 import os
-import re
-import uuid
 from typing import Final, List, Literal, Optional, Tuple
-from urllib.parse import parse_qs, urlparse
 
 import cv2
 import numpy as np
 from fastapi import FastAPI, HTTPException
 from numpy.typing import ArrayLike
 from pydantic import BaseModel, Field
-from typing_extensions import Annotated, TypeAlias, assert_never
+from typing_extensions import Annotated, TypeAlias
 
 from .....utils import logging
 from ...layout_parsing import LayoutParsingPipeline
@@ -71,71 +68,6 @@ class InferResult(BaseModel):
     layoutParsingResults: List[LayoutParsingResult]
 
 
-def _generate_request_id() -> str:
-    return str(uuid.uuid4())
-
-
-def _infer_file_type(url: str) -> FileType:
-    # Is it more reliable to guess the file type based on the response headers?
-    SUPPORTED_IMG_EXTS: Final[List[str]] = [".jpg", ".jpeg", ".png"]
-
-    url_parts = urlparse(url)
-    ext = os.path.splitext(url_parts.path)[1]
-    # HACK: The support for BOS URLs with query params is implementation-based,
-    # not interface-based.
-    is_bos_url = (
-        re.fullmatch(r"(?:bj|bd|su|gz|cd|hkg|fwh|fsh)\.bcebos\.com", url_parts.netloc)
-        is not None
-    )
-    if is_bos_url and url_parts.query:
-        params = parse_qs(url_parts.query)
-        if (
-            "responseContentDisposition" not in params
-            or len(params["responseContentDisposition"]) != 1
-        ):
-            raise ValueError("`responseContentDisposition` not found")
-        match_ = re.match(
-            r"attachment;filename=(.*)", params["responseContentDisposition"][0]
-        )
-        if not match_ or not match_.groups()[0] is not None:
-            raise ValueError(
-                "Failed to extract the filename from `responseContentDisposition`"
-            )
-        ext = os.path.splitext(match_.groups()[0])[1]
-    ext = ext.lower()
-    if ext == ".pdf":
-        return 0
-    elif ext in SUPPORTED_IMG_EXTS:
-        return 1
-    else:
-        raise ValueError("Unsupported file type")
-
-
-def _bytes_to_arrays(
-    file_bytes: bytes,
-    file_type: FileType,
-    *,
-    max_img_size: Tuple[int, int],
-    max_num_imgs: int,
-) -> List[np.ndarray]:
-    if file_type == 0:
-        images = serving_utils.read_pdf(
-            file_bytes, resize=True, max_num_imgs=max_num_imgs
-        )
-    elif file_type == 1:
-        images = [serving_utils.image_bytes_to_array(file_bytes)]
-    else:
-        assert_never(file_type)
-    h, w = images[0].shape[0:2]
-    if w > max_img_size[1] or h > max_img_size[0]:
-        if w / h > max_img_size[0] / max_img_size[1]:
-            factor = max_img_size[0] / w
-        else:
-            factor = max_img_size[1] / h
-        images = [cv2.resize(img, (int(factor * w), int(factor * h))) for img in images]
-    return images
-
-
 def _postprocess_image(
     img: ArrayLike,
     request_id: str,
@@ -180,12 +112,12 @@ async def _infer(
         pipeline = ctx.pipeline
         aiohttp_session = ctx.aiohttp_session
 
-        request_id = _generate_request_id()
+        request_id = serving_utils.generate_request_id()
 
         if request.fileType is None:
             if serving_utils.is_url(request.file):
                 try:
-                    file_type = _infer_file_type(request.file)
+                    file_type = serving_utils.infer_file_type(request.file)
                 except Exception as e:
                     logging.exception(e)
                     raise HTTPException(
@@ -195,7 +127,7 @@ async def _infer(
             else:
                 raise HTTPException(status_code=422, detail="Unknown file type")
         else:
-            file_type = request.fileType
+            file_type = "PDF" if request.fileType == 0 else "IMAGE"
 
         if request.inferenceParams:
             max_long_side = request.inferenceParams.maxLongSide
@@ -210,7 +142,7 @@ async def _infer(
                 request.file, aiohttp_session
             )
             images = await serving_utils.call_async(
-                _bytes_to_arrays,
+                serving_utils.file_to_images,
                 file_bytes,
                 file_type,
                 max_img_size=ctx.extra["max_img_size"],

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

@@ -0,0 +1,100 @@
+# 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, TypeAlias
+
+from .....utils import logging
+from ...attribute_recognition import PedestrianAttributeRecPipeline
+from .. import utils as serving_utils
+from ..app import AppConfig, create_app
+from ..models import Response, ResultResponse
+
+
+class InferRequest(BaseModel):
+    image: str
+
+
+BoundingBox: TypeAlias = Annotated[List[float], Field(min_length=4, max_length=4)]
+
+
+class Attribute(BaseModel):
+    label: str
+    score: float
+
+
+class Pedestrian(BaseModel):
+    bbox: BoundingBox
+    attributes: List[Attribute]
+    score: float
+
+
+class InferResult(BaseModel):
+    pedestrians: List[Pedestrian]
+    image: str
+
+
+def create_pipeline_app(
+    pipeline: PedestrianAttributeRecPipeline, app_config: AppConfig
+) -> FastAPI:
+    app, ctx = create_app(
+        pipeline=pipeline, app_config=app_config, app_aiohttp_session=True
+    )
+
+    @app.post(
+        "/pedestrian-attribute-recognition",
+        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]
+
+            pedestrians: List[Pedestrian] = []
+            for obj in result["boxes"]:
+                pedestrians.append(
+                    Pedestrian(
+                        bbox=obj["coordinate"],
+                        attributes=[
+                            Attribute(label=l, score=s)
+                            for l, s in zip(obj["labels"], obj["cls_scores"])
+                        ],
+                        score=obj["det_score"],
+                    )
+                )
+            output_image_base64 = serving_utils.image_to_base64(result.img)
+
+            return ResultResponse(
+                logId=serving_utils.generate_log_id(),
+                errorCode=0,
+                errorMsg="Success",
+                result=InferResult(pedestrians=pedestrians, image=output_image_base64),
+            )
+
+        except Exception as e:
+            logging.exception(e)
+            raise HTTPException(status_code=500, detail="Internal server error")
+
+    return app