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

paddlex/inference/pipelines/components/retriever/qianfan_bot_retriever.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,14 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from operator import le
+import json
 from typing import Dict, List
 
-import json
 import requests
-from langchain_core.embeddings import Embeddings
 
 from paddlex.utils import logging
+
+from .....utils.deps import is_dep_available
 from .base import BaseRetriever
 
 
@@ -80,84 +80,87 @@ class QianFanBotRetriever(BaseRetriever):
         self.config = config
 
 
-class QianfanEmbeddings(Embeddings):
-    """`Baidu Qianfan Embeddings` embedding models."""
-
-    def __init__(
-        self,
-        api_key: str,
-        base_url: str = "https://qianfan.baidubce.com/v2",
-        model: str = "embedding-v1",
-        **kwargs,
-    ):
-        """
-        Initialize the Baidu Qianfan Embeddings class.
-
-        Args:
-            api_key (str): The Qianfan API key.
-            base_url (str): The base URL for 'qianfan' API.
-            model (str): Model name. Default is "embedding-v1",select in ["tao-8k","embedding-v1","bge-large-en","bge-large-zh"].
-            kwargs (dict): Additional keyword arguments passed to the base Embeddings class.
-        """
-        super().__init__(**kwargs)
-        chunk_size_map = {
-            "tao-8k": 1,
-            "embedding-v1": 16,
-            "bge-large-en": 16,
-            "bge-large-zh": 16,
-        }
-        self.api_key = api_key
-        self.base_url = base_url
-        self.model = model
-        self.chunk_size = chunk_size_map.get(model, 1)
-
-    def embed(self, texts: str, **kwargs) -> List[float]:
-        url = f"{self.base_url}/embeddings"
-        payload = json.dumps(
-            {"model": kwargs.get("model", self.model), "input": [f"{texts}"]}
-        )
-        headers = {
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {self.api_key}",
-        }
-
-        response = requests.request("POST", url, headers=headers, data=payload)
-        if response.status_code != 200:
-            logging.error(
-                f"Failed to call Qianfan API. Status code: {response.status_code}, Response content: {response}"
+if is_dep_available("langchain-core"):
+    from langchain_core.embeddings import Embeddings
+
+    class QianfanEmbeddings(Embeddings):
+        """`Baidu Qianfan Embeddings` embedding models."""
+
+        def __init__(
+            self,
+            api_key: str,
+            base_url: str = "https://qianfan.baidubce.com/v2",
+            model: str = "embedding-v1",
+            **kwargs,
+        ):
+            """
+            Initialize the Baidu Qianfan Embeddings class.
+
+            Args:
+                api_key (str): The Qianfan API key.
+                base_url (str): The base URL for 'qianfan' API.
+                model (str): Model name. Default is "embedding-v1",select in ["tao-8k","embedding-v1","bge-large-en","bge-large-zh"].
+                kwargs (dict): Additional keyword arguments passed to the base Embeddings class.
+            """
+            super().__init__(**kwargs)
+            chunk_size_map = {
+                "tao-8k": 1,
+                "embedding-v1": 16,
+                "bge-large-en": 16,
+                "bge-large-zh": 16,
+            }
+            self.api_key = api_key
+            self.base_url = base_url
+            self.model = model
+            self.chunk_size = chunk_size_map.get(model, 1)
+
+        def embed(self, texts: str, **kwargs) -> List[float]:
+            url = f"{self.base_url}/embeddings"
+            payload = json.dumps(
+                {"model": kwargs.get("model", self.model), "input": [f"{texts}"]}
             )
-
-        return response.json()
-
-    def embed_query(self, text: str) -> List[float]:
-        resp = self.embed_documents([text])
-        return resp[0]
-
-    def embed_documents(self, texts: List[str]) -> List[List[float]]:
-        """
-        Embeds a list of text documents using the AutoVOT algorithm.
-
-        Args:
-            texts (List[str]): A list of text documents to embed.
-
-        Returns:
-            List[List[float]]: A list of embeddings for each document in the input list.
-                            Each embedding is represented as a list of float values.
-        """
-        lst = []
-        for chunk in texts:
-            resp = self.embed(texts=chunk)
-            lst.extend([res["embedding"] for res in resp["data"]])
-        return lst
-
-    async def aembed_query(self, text: str) -> List[float]:
-        embeddings = await self.aembed_documents([text])
-        return embeddings[0]
-
-    async def aembed_documents(self, texts: List[str]) -> List[List[float]]:
-        lst = []
-        for chunk in texts:
-            resp = await self.embed(texts=chunk)
-            for res in resp["data"]:
-                lst.extend([res["embedding"]])
-        return lst
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {self.api_key}",
+            }
+
+            response = requests.request("POST", url, headers=headers, data=payload)
+            if response.status_code != 200:
+                logging.error(
+                    f"Failed to call Qianfan API. Status code: {response.status_code}, Response content: {response}"
+                )
+
+            return response.json()
+
+        def embed_query(self, text: str) -> List[float]:
+            resp = self.embed_documents([text])
+            return resp[0]
+
+        def embed_documents(self, texts: List[str]) -> List[List[float]]:
+            """
+            Embeds a list of text documents using the AutoVOT algorithm.
+
+            Args:
+                texts (List[str]): A list of text documents to embed.
+
+            Returns:
+                List[List[float]]: A list of embeddings for each document in the input list.
+                                Each embedding is represented as a list of float values.
+            """
+            lst = []
+            for chunk in texts:
+                resp = self.embed(texts=chunk)
+                lst.extend([res["embedding"] for res in resp["data"]])
+            return lst
+
+        async def aembed_query(self, text: str) -> List[float]:
+            embeddings = await self.aembed_documents([text])
+            return embeddings[0]
+
+        async def aembed_documents(self, texts: List[str]) -> List[List[float]]:
+            lst = []
+            for chunk in texts:
+                resp = await self.embed(texts=chunk)
+                for res in resp["data"]:
+                    lst.extend([res["embedding"]])
+            return lst

paddlex/inference/pipelines/components/utils/__init__.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

paddlex/inference/pipelines/components/utils/mixin.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,22 +12,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from abc import abstractmethod
 import json
+from abc import abstractmethod
 from pathlib import Path
+
 import numpy as np
-from PIL import Image
 import pandas as pd
+from PIL import Image
 
 from .....utils import logging
 from ....utils.io import (
-    JsonWriter,
-    ImageReader,
-    ImageWriter,
     CSVWriter,
     HtmlWriter,
-    XlsxWriter,
+    ImageWriter,
+    JsonWriter,
     TextWriter,
+    XlsxWriter,
 )
 
 #### [TODO] need tingquan to add explanatory notes

paddlex/inference/pipelines/doc_preprocessor/__init__.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

paddlex/inference/pipelines/doc_preprocessor/pipeline.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,17 +12,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Dict, Optional, Union, List
-from scipy.ndimage import rotate
+from typing import Any, Dict, List, Optional, Union
+
 import numpy as np
-from ..base import BasePipeline
-from .result import DocPreprocessorResult
+
 from ....utils import logging
-from ...common.reader import ReadImage
+from ....utils.deps import pipeline_requires_extra
 from ...common.batch_sampler import ImageBatchSampler
+from ...common.reader import ReadImage
+from ...utils.hpi import HPIConfig
 from ...utils.pp_option import PaddlePredictorOption
+from ..base import BasePipeline
+from ..components import rotate_image
+from .result import DocPreprocessorResult
 
 
+@pipeline_requires_extra("ocr")
 class DocPreprocessorPipeline(BasePipeline):
     """Doc Preprocessor Pipeline"""
 
@@ -34,6 +39,7 @@ class DocPreprocessorPipeline(BasePipeline):
         device: Optional[str] = None,
         pp_option: Optional[PaddlePredictorOption] = None,
         use_hpip: bool = False,
+        hpi_config: Optional[Union[Dict[str, Any], HPIConfig]] = None,
     ) -> None:
         """Initializes the doc preprocessor pipeline.
 
@@ -41,10 +47,16 @@ class DocPreprocessorPipeline(BasePipeline):
             config (Dict): Configuration dictionary containing various settings.
             device (str, optional): Device to run the predictions on. Defaults to None.
             pp_option (PaddlePredictorOption, optional): PaddlePredictor options. Defaults to None.
-            use_hpip (bool, optional): Whether to use high-performance inference (hpip) for prediction. Defaults to False.
+            use_hpip (bool, optional): Whether to use the high-performance
+                inference plugin (HPIP). Defaults to False.
+            hpi_config (Optional[Union[Dict[str, Any], HPIConfig]], optional):
+                The high-performance inference configuration dictionary.
+                Defaults to None.
         """
 
-        super().__init__(device=device, pp_option=pp_option, use_hpip=use_hpip)
+        super().__init__(
+            device=device, pp_option=pp_option, use_hpip=use_hpip, hpi_config=hpi_config
+        )
 
         self.use_doc_orientation_classify = config.get(
             "use_doc_orientation_classify", True
@@ -67,25 +79,6 @@ class DocPreprocessorPipeline(BasePipeline):
         self.batch_sampler = ImageBatchSampler(batch_size=1)
         self.img_reader = ReadImage(format="BGR")
 
-    def rotate_image(self, image_array: np.ndarray, rotate_angle: float) -> np.ndarray:
-        """
-        Rotate the given image array by the specified angle.
-
-        Args:
-            image_array (np.ndarray): The input image array to be rotated.
-            rotate_angle (float): The angle in degrees by which to rotate the image.
-
-        Returns:
-            np.ndarray: The rotated image array.
-
-        Raises:
-            AssertionError: If rotate_angle is not in the range [0, 360).
-        """
-        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 check_model_settings_valid(self, model_settings: Dict) -> bool:
         """
         Check if the the input params for model settings are valid based on the initialized models.
@@ -168,7 +161,7 @@ class DocPreprocessorPipeline(BasePipeline):
             if model_settings["use_doc_orientation_classify"]:
                 pred = next(self.doc_ori_classify_model(image_array))
                 angle = int(pred["label_names"][0])
-                rot_img = self.rotate_image(image_array, angle)
+                rot_img = rotate_image(image_array, angle)
             else:
                 angle = -1
                 rot_img = image_array

paddlex/inference/pipelines/doc_preprocessor/result.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,16 +13,11 @@
 # limitations under the License.
 
 from typing import Dict
-import math
-import random
-from pathlib import Path
-import copy
-import numpy as np
-import cv2
-import PIL
-from PIL import Image, ImageDraw, ImageFont
+
+from PIL import Image, ImageDraw
+
 from ....utils.fonts import PINGFANG_FONT_FILE_PATH, create_font
-from ...common.result import BaseCVResult, StrMixin, JsonMixin
+from ...common.result import BaseCVResult, JsonMixin
 
 
 class DocPreprocessorResult(BaseCVResult):

paddlex/inference/pipelines/doc_understanding/__init__.py

@@ -0,0 +1,15 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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 import DocUnderstandingPipeline

paddlex/inference/pipelines/doc_understanding/pipeline.py

@@ -0,0 +1,71 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
+#
+# 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, Optional, Union
+
+from ....utils.deps import pipeline_requires_extra
+from ...models.doc_vlm.result import DocVLMResult
+from ...utils.hpi import HPIConfig
+from ...utils.pp_option import PaddlePredictorOption
+from ..base import BasePipeline
+
+
+@pipeline_requires_extra("multimodal")
+class DocUnderstandingPipeline(BasePipeline):
+    """Doc Understanding Pipeline"""
+
+    entities = "doc_understanding"
+
+    def __init__(
+        self,
+        config: Dict,
+        device: str = None,
+        pp_option: PaddlePredictorOption = None,
+        use_hpip: bool = False,
+        hpi_config: Optional[Union[Dict[str, Any], HPIConfig]] = None,
+    ) -> None:
+        """
+        Initializes the class with given configurations and options.
+
+        Args:
+            config (Dict): Configuration dictionary containing model and other parameters.
+            device (str): The device to run the prediction on. Default is None.
+            pp_option (PaddlePredictorOption): Options for PaddlePaddle predictor. Default is None.
+            use_hpip (bool, optional): Whether to use the high-performance
+                inference plugin (HPIP) by default. Defaults to False.
+            hpi_config (Optional[Union[Dict[str, Any], HPIConfig]], optional):
+                The default high-performance inference configuration dictionary.
+                Defaults to None.
+        """
+        super().__init__(
+            device=device, pp_option=pp_option, use_hpip=use_hpip, hpi_config=hpi_config
+        )
+
+        doc_understanding_model_config = config.get("SubModules", {}).get(
+            "DocUnderstanding",
+            {"model_config_error": "config error for doc_understanding_model!"},
+        )
+        self.doc_understanding_model = self.create_model(doc_understanding_model_config)
+
+    def predict(self, input: Dict, **kwargs) -> DocVLMResult:
+        """Predicts doc understanding results for the given input.
+
+        Args:
+            input (dict): The input image and query.
+            **kwargs: Additional keyword arguments that can be passed to the function.
+
+        Returns:
+            DocVLMResult: The predicted doc understanding results.
+        """
+        yield from self.doc_understanding_model(input, **kwargs)

paddlex/inference/pipelines/face_recognition/__init__.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

paddlex/inference/pipelines/face_recognition/pipeline.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -14,10 +14,12 @@
 
 import numpy as np
 
+from ....utils.deps import pipeline_requires_extra
 from ..pp_shitu_v2 import ShiTuV2Pipeline
 from .result import FaceRecResult
 
 
+@pipeline_requires_extra("cv")
 class FaceRecPipeline(ShiTuV2Pipeline):
     """Face Recognition Pipeline"""
 

paddlex/inference/pipelines/face_recognition/result.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,7 +13,8 @@
 # limitations under the License.
 
 import copy
-from ...common.result import BaseCVResult, JsonMixin, StrMixin
+
+from ...common.result import BaseCVResult, JsonMixin
 from ..pp_shitu_v2.result import draw_box
 
 

paddlex/inference/pipelines/formula_recognition/__init__.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

paddlex/inference/pipelines/formula_recognition/pipeline.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,27 +12,26 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os, sys
-from typing import Any, Dict, Optional, Union, List, Tuple
+from typing import Any, Dict, List, Optional, Tuple, Union
+
 import numpy as np
-import cv2
-from ..base import BasePipeline
-from ..components import CropByBoxes, convert_points_to_boxes
 
-from .result import FormulaRecognitionResult
+from ....utils import logging
+from ....utils.deps import pipeline_requires_extra
+from ...common.batch_sampler import ImageBatchSampler
+from ...common.reader import ReadImage
 from ...models.formula_recognition.result import (
     FormulaRecResult as SingleFormulaRecognitionResult,
 )
-from ....utils import logging
-from ...utils.pp_option import PaddlePredictorOption
-from ...common.reader import ReadImage
-from ...common.batch_sampler import ImageBatchSampler
-from ..ocr.result import OCRResult
-from ..doc_preprocessor.result import DocPreprocessorResult
-
 from ...models.object_detection.result import DetResult
+from ...utils.hpi import HPIConfig
+from ...utils.pp_option import PaddlePredictorOption
+from ..base import BasePipeline
+from ..components import CropByBoxes
+from .result import FormulaRecognitionResult
 
 
+@pipeline_requires_extra("ocr")
 class FormulaRecognitionPipeline(BasePipeline):
     """Formula Recognition Pipeline"""
 
@@ -44,6 +43,7 @@ class FormulaRecognitionPipeline(BasePipeline):
         device: str = None,
         pp_option: PaddlePredictorOption = None,
         use_hpip: bool = False,
+        hpi_config: Optional[Union[Dict[str, Any], HPIConfig]] = None,
     ) -> None:
         """Initializes the formula recognition pipeline.
 
@@ -51,10 +51,16 @@ class FormulaRecognitionPipeline(BasePipeline):
             config (Dict): Configuration dictionary containing various settings.
             device (str, optional): Device to run the predictions on. Defaults to None.
             pp_option (PaddlePredictorOption, optional): PaddlePredictor options. Defaults to None.
-            use_hpip (bool, optional): Whether to use high-performance inference (hpip) for prediction. Defaults to False.
+            use_hpip (bool, optional): Whether to use the high-performance
+                inference plugin (HPIP). Defaults to False.
+            hpi_config (Optional[Union[Dict[str, Any], HPIConfig]], optional):
+                The high-performance inference configuration dictionary.
+                Defaults to None.
         """
 
-        super().__init__(device=device, pp_option=pp_option, use_hpip=use_hpip)
+        super().__init__(
+            device=device, pp_option=pp_option, use_hpip=use_hpip, hpi_config=hpi_config
+        )
 
         self.use_doc_preprocessor = config.get("use_doc_preprocessor", True)
         if self.use_doc_preprocessor:

paddlex/inference/pipelines/formula_recognition/result.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,36 +12,36 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os, sys
-from typing import Tuple, List, Dict, Any
-import cv2
-import PIL
 import math
-import copy
+import os
 import random
-import tempfile
 import subprocess
-import numpy as np
+import tempfile
 from pathlib import Path
-import PIL
-from PIL import Image, ImageDraw, ImageFont
+from typing import Dict, Tuple
+
+import numpy as np
+from PIL import Image, ImageDraw
 
-from ...common.result import BaseCVResult, JsonMixin, ImgMixin, StrMixin
 from ....utils import logging
+from ....utils.deps import class_requires_deps, function_requires_deps, is_dep_available
 from ....utils.fonts import PINGFANG_FONT_FILE_PATH
+from ...common.result import BaseCVResult, JsonMixin
 from ...models.formula_recognition.result import (
-    get_align_equation,
-    generate_tex_file,
-    generate_pdf_file,
-    env_valid,
-    pdf2img,
-    create_font,
     crop_white_area,
     draw_box_txt_fine,
     draw_formula_module,
+    env_valid,
+    generate_pdf_file,
+    generate_tex_file,
+    pdf2img,
 )
 
+if is_dep_available("opencv-contrib-python"):
+    import cv2
+
 
+@class_requires_deps("opencv-contrib-python")
 class FormulaRecognitionResult(BaseCVResult):
     """Formula Recognition Result"""
 
@@ -123,10 +123,10 @@ class FormulaRecognitionResult(BaseCVResult):
         random.seed(0)
         draw_left = ImageDraw.Draw(img_left)
 
-        formula_res_list = self["formula_res_list"]
+        self["formula_res_list"]
         for tno in range(len(self["formula_res_list"])):
             formula_res = self["formula_res_list"][tno]
-            formula_region_id = formula_res["formula_region_id"]
+            formula_res["formula_region_id"]
             formula = str(formula_res["rec_formula"])
             dt_polys = formula_res["dt_polys"]
             x1, y1, x2, y2 = list(dt_polys)
@@ -226,6 +226,7 @@ class FormulaRecognitionResult(BaseCVResult):
         return JsonMixin._to_json(data, *args, **kwargs)
 
 
+@function_requires_deps("opencv-contrib-python")
 def draw_box_formula_fine(
     img_size: Tuple[int, int], box: np.ndarray, formula: str, is_debug: bool = False
 ) -> np.ndarray:

paddlex/inference/pipelines/image_classification/__init__.py

@@ -1,4 +1,4 @@
-# copyright (c) 2024 PaddlePaddle Authors. All Rights Reserve.
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.