paddlex 3.0.0rc0__py3-none-any.whl → 3.0.1__py3-none-any.whl

paddlex/inference/models/multilingual_speech_recognition/processors.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,19 +13,27 @@
 # limitations under the License.
 # Modified from OpenAI Whisper 2022 (https://github.com/openai/whisper/whisper)
 import os
-import tqdm
 import zlib
-import soundfile
-import numpy as np
-import lazy_paddle as paddle
-
-from dataclasses import dataclass
-from dataclasses import field
+from dataclasses import dataclass, field
 from functools import lru_cache
 from typing import Dict, Iterable, List, Optional, Sequence, Tuple, Union
 
+import numpy as np
+import paddle
+
+from ....utils.deps import function_requires_deps, is_dep_available
+from ...utils.benchmark import (
+    benchmark,
+    get_inference_operations,
+    set_inference_operations,
+)
 from ..common.tokenizer import GPTTokenizer
 
+if is_dep_available("soundfile"):
+    import soundfile
+if is_dep_available("tqdm"):
+    import tqdm
+
 __all__ = [
     "Whisper",
     "Tokenizer",
@@ -336,11 +344,9 @@ class Tokenizer:
         """
         Returns the list of tokens to suppress in order to avoid any speaker tags or non-speech
         annotations, to prevent sampling texts that are not actually spoken in the audio, e.g.
-
         - ♪♪♪
         - ( SPEAKING FOREIGN LANGUAGE )
         - [DAVID] Hey there,
-
         keeping basic punctuations like commas, periods, question marks, exclamation points, etc.
         """
         symbols = list('"#()*+/:;<=>@[\\]^_`{|}~「」『』')
@@ -706,7 +712,6 @@ class Inference:
 
     def cleanup_caching(self) -> None:
         """Clean up any resources or hooks after decoding is finished"""
-        pass
 
 
 class WhisperInference(Inference):
@@ -752,7 +757,6 @@ def detect_language(
     Detect the spoken language in the audio, and return them as list of strings, along with the ids
     of the most probable language tokens and the probability distribution over all language tokens.
     This is performed outside the main decode loop in order to not interfere with kv-caching.
-
     Returns
     -------
     language_tokens : Tensor, shape = (batch_size,)
@@ -804,6 +808,7 @@ def detect_language(
     return language_tokens, language_probs
 
 
+@function_requires_deps("tqdm")
 def transcribe(
     model: "Whisper",
     mel: paddle.Tensor,
@@ -819,41 +824,31 @@ def transcribe(
 ):
     """
     Transcribe an audio file using Whisper
-
     Parameters
     ----------
     model: Whisper
         The Whisper model instance
-
     mel: paddle.Tensor
         The audio feature
-
     verbose: bool
         Whether to display the text being decoded to the console. If True, displays all the details,
         If False, displays minimal details. If None, does not display anything
-
     temperature: Union[float, Tuple[float, ...]]
         Temperature for sampling. It can be a tuple of temperatures, which will be successfully used
         upon failures according to either `compression_ratio_threshold` or `logprob_threshold`.
-
     compression_ratio_threshold: float
         If the gzip compression ratio is above this value, treat as failed
-
     logprob_threshold: float
         If the average log probability over sampled tokens is below this value, treat as failed
-
     no_speech_threshold: float
         If the no_speech probability is higher than this value AND the average log probability
         over sampled tokens is below `logprob_threshold`, consider the segment as silent
-
     condition_on_previous_text: bool
         if True, the previous output of the model is provided as a prompt for the next window;
         disabling may make the text inconsistent across windows, but the model becomes less prone to
         getting stuck in a failure loop, such as repetition looping or timestamps going out of sync.
-
     decode_options: dict
         Keyword arguments to construct `DecodingOptions` instances
-
     Returns
     -------
     A dictionary containing the resulting text ("text") and segment-level details ("segments"), and
@@ -886,7 +881,10 @@ def transcribe(
     language = decode_options["language"]
     task = decode_options.get("task", "transcribe")
     tokenizer = get_tokenizer(
-        model.is_multilingual, resource_path=resource_path, language=language, task=task
+        model.is_multilingual,
+        resource_path=resource_path,
+        language=language,
+        task=task,
     )
 
     def decode_with_fallback(segment: paddle.Tensor) -> DecodingResult:
@@ -944,7 +942,11 @@ def transcribe(
         initial_prompt = []
 
     def add_segment(
-        *, start: float, end: float, text_tokens: paddle.Tensor, result: DecodingResult
+        *,
+        start: float,
+        end: float,
+        text_tokens: paddle.Tensor,
+        result: DecodingResult,
     ):
         text = tokenizer.decode(
             [token for token in text_tokens if token < tokenizer.eot]
@@ -1113,29 +1115,26 @@ class TokenDecoder:
         """Initialize any stateful variables for decoding a new sequence"""
 
     def update(
-        self, tokens: paddle.Tensor, logits: paddle.Tensor, sum_logprobs: paddle.Tensor
+        self,
+        tokens: paddle.Tensor,
+        logits: paddle.Tensor,
+        sum_logprobs: paddle.Tensor,
     ) -> Tuple[paddle.Tensor, bool]:
         """Specify how to select the next token, based on the current trace and logits
-
         Parameters
         ----------
         tokens : Tensor, shape = (n_batch, current_sequence_length)
             all tokens in the context so far, including the prefix and sot_sequence tokens
-
         logits : Tensor, shape = (n_batch, vocab_size)
             per-token logits of the probability distribution at the current step
-
         sum_logprobs : Tensor, shape = (n_batch)
             cumulative log probabilities for each sequence
-
         Returns
         -------
         tokens : Tensor, shape = (n_batch, current_sequence_length + 1)
             the tokens, appended with the selected next token
-
         completed : bool
             True if all sequences has reached the end of text
-
         """
         raise NotImplementedError
 
@@ -1143,23 +1142,18 @@ class TokenDecoder:
         self, tokens: paddle.Tensor, sum_logprobs: paddle.Tensor
     ) -> Tuple[Sequence[Sequence[paddle.Tensor]], List[List[float]]]:
         """Finalize search and return the final candidate sequences
-
         Parameters
         ----------
         tokens : Tensor, shape = (batch_size, beam_size, current_sequence_length)
             all tokens in the context so far, including the prefix and sot_sequence
-
         sum_logprobs : Tensor, shape = (batch_size, beam_size)
             cumulative log probabilities for each sequence
-
         Returns
         -------
         tokens : Sequence[Sequence[Tensor]], length = batch_size
             sequence of Tensors containing candidate token sequences, for each audio input
-
         sum_logprobs : List[List[float]], length = batch_size
             sequence of cumulative log probabilities corresponding to the above
-
         """
         raise NotImplementedError
 
@@ -1170,7 +1164,10 @@ class GreedyDecoder(TokenDecoder):
         self.eot = eot
 
     def update(
-        self, tokens: paddle.Tensor, logits: paddle.Tensor, sum_logprobs: paddle.Tensor
+        self,
+        tokens: paddle.Tensor,
+        logits: paddle.Tensor,
+        sum_logprobs: paddle.Tensor,
     ) -> Tuple[paddle.Tensor, bool]:
         temperature = self.temperature
         if temperature == 0:
@@ -1235,7 +1232,10 @@ class BeamSearchDecoder(TokenDecoder):
         self.finished_sequences = None
 
     def update(
-        self, tokens: paddle.Tensor, logits: paddle.Tensor, sum_logprobs: paddle.Tensor
+        self,
+        tokens: paddle.Tensor,
+        logits: paddle.Tensor,
+        sum_logprobs: paddle.Tensor,
     ) -> Tuple[paddle.Tensor, bool]:
         if tokens.shape[0] % self.beam_size != 0:
             raise ValueError(f"{tokens.shape}[0] % {self.beam_size} != 0")
@@ -1564,7 +1564,10 @@ class DecodingTask:
         return audio_features
 
     def _detect_language(
-        self, audio_features: paddle.Tensor, tokens: paddle.Tensor, resource_path: str
+        self,
+        audio_features: paddle.Tensor,
+        tokens: paddle.Tensor,
+        resource_path: str,
     ):
         languages = [self.options.language] * audio_features.shape[0]
         lang_probs = None
@@ -1656,20 +1659,16 @@ class DecodingTask:
             ]
 
         # repeat the audio & text tensors by the group size, for beam search or best-of-n sampling
-
         audio_features = paddle.repeat_interleave(
             audio_features, self.beam_size, axis=0
         )
         tokens = paddle.repeat_interleave(tokens, self.beam_size, axis=0)
-
         # call the main sampling loop
         tokens, sum_logprobs, no_speech_probs = self._main_loop(audio_features, tokens)
-
         # reshape the tensors to have (batch_size, beam_size) as the first two dimensions
         audio_features = audio_features[:: self.beam_size]
         no_speech_probs = no_speech_probs[:: self.beam_size]
         assert audio_features.shape[0] == len(no_speech_probs) == batch_size
-
         tokens = tokens.reshape([batch_size, self.beam_size, -1])
         sum_logprobs = sum_logprobs.reshape([batch_size, self.beam_size])
 
@@ -1727,18 +1726,14 @@ def decode(
 ) -> Union[DecodingResult, List[DecodingResult]]:
     """
     Performs decoding of 30-second audio segment(s), provided as Mel spectrogram(s).
-
     Parameters
     ----------
     model: Whisper
         the Whisper model instance
-
     mel: paddle.Tensor, shape = (80, 3000) or (*, 80, 3000)
         A tensor containing the Mel spectrogram(s)
-
     options: DecodingOptions
         A dataclass that contains all necessary options for decoding 30-second segments
-
     Returns
     -------
     result: Union[DecodingResult, List[DecodingResult]]
@@ -1804,7 +1799,6 @@ class Whisper(paddle.nn.Layer):
         tensors calculated for the previous positions. This method returns a dictionary that stores
         all caches, and the necessary hooks for the key and value projection modules that save the
         intermediate tensors to be reused during later calculations.
-
         Returns
         -------
         cache : Dict[nn.Layer, paddle.Tensor]
@@ -1836,7 +1830,8 @@ class Whisper(paddle.nn.Layer):
         return cache, hooks
 
     detect_language = detect_language
-    transcribe = transcribe
+    set_inference_operations(get_inference_operations() + ["speech_transcribe"])
+    transcribe = benchmark.timeit_with_options(name="speech_transcribe")(transcribe)
     decode = decode
 
 
@@ -1888,7 +1883,6 @@ def mel_filters(resource_path: str, n_mels: int = N_MELS) -> paddle.Tensor:
     """
     load the mel filterbank matrix for projecting STFT into a Mel spectrogram.
     Allows decoupling librosa dependency; saved using:
-
         np.savez_compressed(
             "mel_filters.npz",
             mel_80=librosa.filters.mel(sr=16000, n_fft=400, n_mels=80),
@@ -1899,6 +1893,7 @@ def mel_filters(resource_path: str, n_mels: int = N_MELS) -> paddle.Tensor:
         return paddle.to_tensor(f[f"mel_{n_mels}"])
 
 
+@function_requires_deps("soundfile")
 def log_mel_spectrogram(
     audio: Union[str, np.ndarray, paddle.Tensor],
     n_mels: int = N_MELS,
@@ -1906,15 +1901,12 @@ def log_mel_spectrogram(
 ):
     """
     Compute the log-Mel spectrogram of
-
     Parameters
     ----------
     audio: Union[str, np.ndarray, paddle.Tensor], shape = (*)
         The path to audio or either a NumPy array or Tensor containing the audio waveform in 16 kHz
-
     n_mels: int
         The number of Mel-frequency filters, only 80 is supported
-
     Returns
     -------
     paddle.Tensor, shape = (80, n_frames)

paddlex/inference/models/multilingual_speech_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.

paddlex/inference/models/object_detection/__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/models/object_detection/predictor.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,16 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, List, Sequence, Optional, Union, Tuple
+from typing import Any, List, Optional, Sequence, Tuple, Union
 
 import numpy as np
 
-from ....utils.func_register import FuncRegister
 from ....modules.object_detection.model_list import MODELS
+from ....utils.func_register import FuncRegister
 from ...common.batch_sampler import ImageBatchSampler
-
-from ..common import StaticInfer
-from ..base import BasicPredictor
+from ..base import BasePredictor
 from .processors import (
     DetPad,
     DetPostProcess,
@@ -37,7 +35,7 @@ from .result import DetResult
 from .utils import STATIC_SHAPE_MODEL_LIST
 
 
-class DetPredictor(BasicPredictor):
+class DetPredictor(BasePredictor):
 
     entities = MODELS
 
@@ -142,11 +140,7 @@ class DetPredictor(BasicPredictor):
             pre_ops.insert(1, self.build_resize(self.img_size, False, 2))
 
         # build infer
-        infer = StaticInfer(
-            model_dir=self.model_dir,
-            model_prefix=self.MODEL_FILE_PREFIX,
-            option=self.pp_option,
-        )
+        infer = self.create_static_infer()
 
         # build postprocess op
         post_op = self.build_postprocess()
@@ -322,6 +316,8 @@ class DetPredictor(BasicPredictor):
             "BlazeFace",
             "BlazeFace-FPN-SSH",
             "PP-DocLayout-L",
+            "PP-DocLayout_plus-L",
+            "PP-DocBlockLayout",
         ]
         if any(name in self.model_name for name in models_required_imgsize):
             ordered_required_keys = (

paddlex/inference/models/object_detection/processors.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,20 +12,26 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import List, Sequence, Tuple, Union, Optional
+from typing import List, Optional, Sequence, Tuple, Union
 
-import cv2
 import numpy as np
 from numpy import ndarray
 
-from ..common import Resize as CommonResize
-from ..common import Normalize as CommonNormalize
+from ....utils.deps import class_requires_deps, function_requires_deps, is_dep_available
 from ...common.reader import ReadImage as CommonReadImage
+from ...utils.benchmark import benchmark
+from ..common import Normalize as CommonNormalize
+from ..common import Resize as CommonResize
+
+if is_dep_available("opencv-contrib-python"):
+    import cv2
 
 Boxes = List[dict]
 Number = Union[int, float]
 
 
+@benchmark.timeit_with_options(name=None, is_read_operation=True)
+@class_requires_deps("opencv-contrib-python")
 class ReadImage(CommonReadImage):
     """Reads images from a list of raw image data or file paths."""
 
@@ -69,7 +75,7 @@ class ReadImage(CommonReadImage):
         if isinstance(img, np.ndarray):
             ori_img = img
             if self.format == "RGB":
-                img = img[:, :, ::-1]
+                img = cv2.cvtColor(ori_img, cv2.COLOR_BGR2RGB)
             return img, ori_img
         elif isinstance(img, str):
             blob = self._img_reader.read(img)
@@ -81,7 +87,7 @@ class ReadImage(CommonReadImage):
                 if blob.ndim != 3:
                     raise RuntimeError("Array is not 3-dimensional.")
                 # BGR to RGB
-                blob = blob[..., ::-1]
+                blob = cv2.cvtColor(blob, cv2.COLOR_BGR2RGB)
             return blob, ori_img
         else:
             raise TypeError(
@@ -92,6 +98,7 @@ class ReadImage(CommonReadImage):
             )
 
 
+@benchmark.timeit
 class Resize(CommonResize):
     def __call__(self, datas: List[dict]) -> List[dict]:
         """
@@ -122,31 +129,18 @@ class Resize(CommonResize):
         return datas
 
 
+@benchmark.timeit
 class Normalize(CommonNormalize):
-    """Normalizes images in a list of dictionaries containing image data"""
-
-    def apply(self, img: ndarray) -> ndarray:
-        """Applies normalization to a single image."""
-        old_type = img.dtype
-        # XXX: If `old_type` has higher precision than float32,
-        # we will lose some precision.
-        img = img.astype("float32", copy=False)
-        img *= self.scale
-        img -= self.mean
-        img /= self.std
-        if self.preserve_dtype:
-            img = img.astype(old_type, copy=False)
-        return img
-
     def __call__(self, datas: List[dict]) -> List[dict]:
         """Normalizes images in a list of dictionaries. Iterates over each dictionary,
         applies normalization to the 'img' key, and returns the modified list.
         """
         for data in datas:
-            data["img"] = self.apply(data["img"])
+            data["img"] = self.norm(data["img"])
         return datas
 
 
+@benchmark.timeit
 class ToCHWImage:
     """Converts images in a list of dictionaries from HWC to CHW format."""
 
@@ -164,6 +158,7 @@ class ToCHWImage:
         return datas
 
 
+@benchmark.timeit
 class ToBatch:
     """
     Class for batch processing of data dictionaries.
@@ -211,6 +206,7 @@ class ToBatch:
         return [self.apply(datas, key) for key in self.ordered_required_keys]
 
 
+@benchmark.timeit
 class DetPad:
     """
     Pad image to a specified size.
@@ -248,6 +244,7 @@ class DetPad:
         return datas
 
 
+@benchmark.timeit
 class PadStride:
     """padding image for model with FPN , instead PadBatch(pad_to_stride, pad_gt) in original config
     Args:
@@ -318,6 +315,7 @@ def _get_3rd_point(a: ndarray, b: ndarray) -> ndarray:
     return third_pt
 
 
+@function_requires_deps("opencv-contrib-python")
 def get_affine_transform(
     center: ndarray,
     input_size: Union[Number, Tuple[Number, Number], ndarray],
@@ -374,6 +372,8 @@ def get_affine_transform(
     return trans
 
 
+@benchmark.timeit
+@class_requires_deps("opencv-contrib-python")
 class WarpAffine:
     """Apply warp affine transformation to the image based on the given parameters.
 
@@ -434,7 +434,7 @@ class WarpAffine:
         if not self.keep_res:
             out_h = input_h // self.down_ratio
             out_w = input_w // self.down_ratio
-            trans_output = get_affine_transform(c, s, 0, [out_w, out_h])
+            get_affine_transform(c, s, 0, [out_w, out_h])
 
         return inp
 
@@ -474,6 +474,8 @@ def restructured_boxes(
         ymin = max(0, ymin)
         xmax = min(w, xmax)
         ymax = min(h, ymax)
+        if xmax <= xmin or ymax <= ymin:
+            continue
         box_list.append(
             {
                 "cls_id": int(box[0]),
@@ -621,7 +623,7 @@ def nms(boxes, iou_same=0.6, iou_diff=0.95):
         current = indices[0]
         current_box = boxes[current]
         current_class = current_box[0]
-        current_score = current_box[1]
+        current_box[1]
         current_coords = current_box[2:]
 
         selected_boxes.append(current)
@@ -675,7 +677,7 @@ def check_containment(boxes, formula_index=None, category_index=None, mode=None)
                 if mode == "large" and boxes[j][0] == category_index:
                     if is_contained(boxes[i], boxes[j]):
                         contained_by_other[i] = 1
-                        contains_other[j] = 1                   
+                        contains_other[j] = 1
                 if mode == "small" and boxes[i][0] == category_index:
                     if is_contained(boxes[i], boxes[j]):
                         contained_by_other[i] = 1
@@ -687,6 +689,7 @@ def check_containment(boxes, formula_index=None, category_index=None, mode=None)
     return contains_other, contained_by_other
 
 
+@benchmark.timeit
 class DetPostProcess:
     """Save Result Transform
 
@@ -743,14 +746,39 @@ class DetPostProcess:
             )
 
         if layout_nms:
-            filtered_boxes = []
-            ### Layout postprocess for NMS
             selected_indices = nms(boxes, iou_same=0.6, iou_diff=0.98)
             boxes = np.array(boxes[selected_indices])
 
+        filter_large_image = True
+        if filter_large_image and len(boxes) > 1 and boxes.shape[1] == 6:
+            if img_size[0] > img_size[1]:
+                area_thres = 0.82
+            else:
+                area_thres = 0.93
+            image_index = self.labels.index("image") if "image" in self.labels else None
+            img_area = img_size[0] * img_size[1]
+            filtered_boxes = []
+            for box in boxes:
+                label_index, score, xmin, ymin, xmax, ymax = box
+                if label_index == image_index:
+                    xmin = max(0, xmin)
+                    ymin = max(0, ymin)
+                    xmax = min(img_size[0], xmax)
+                    ymax = min(img_size[1], ymax)
+                    box_area = (xmax - xmin) * (ymax - ymin)
+                    if box_area <= area_thres * img_area:
+                        filtered_boxes.append(box)
+                else:
+                    filtered_boxes.append(box)
+            if len(filtered_boxes) == 0:
+                filtered_boxes = boxes
+            boxes = np.array(filtered_boxes)
+
         if layout_merge_bboxes_mode:
-            formula_index = (self.labels.index("formula") if "formula" in self.labels else None)
-            if isinstance(layout_merge_bboxes_mode, str): 
+            formula_index = (
+                self.labels.index("formula") if "formula" in self.labels else None
+            )
+            if isinstance(layout_merge_bboxes_mode, str):
                 assert layout_merge_bboxes_mode in [
                     "union",
                     "large",
@@ -783,17 +811,19 @@ class DetPostProcess:
                                 boxes, formula_index, category_index, mode=layout_mode
                             )
                             # Remove boxes that are contained by other boxes
-                            keep_mask &= (contained_by_other == 0)
+                            keep_mask &= contained_by_other == 0
                         elif layout_mode == "small":
                             contains_other, contained_by_other = check_containment(
                                 boxes, formula_index, category_index, mode=layout_mode
                             )
                             # Keep boxes that do not contain others or are contained by others
-                            keep_mask &= (contains_other == 0) | (contained_by_other == 1)
+                            keep_mask &= (contains_other == 0) | (
+                                contained_by_other == 1
+                            )
                 boxes = boxes[keep_mask]
 
         if boxes.size == 0:
-            return np.array([])
+            return []
 
         if layout_unclip_ratio:
             if isinstance(layout_unclip_ratio, float):

paddlex/inference/models/object_detection/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,14 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import List
 import copy
+from typing import List
+
 import PIL
 from PIL import Image, ImageDraw, ImageFont
 
 from ....utils.fonts import PINGFANG_FONT_FILE_PATH
-from ...utils.color_map import get_colormap, font_colormap
-from ...common.result import BaseCVResult, StrMixin, JsonMixin
+from ...common.result import BaseCVResult, JsonMixin
+from ...utils.color_map import font_colormap, get_colormap
 
 
 def draw_box(img: Image.Image, boxes: List[dict]) -> Image.Image:

paddlex/inference/models/object_detection/utils.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.
@@ -65,4 +65,6 @@ STATIC_SHAPE_MODEL_LIST = [
     "PP-DocLayout-L",
     "PP-DocLayout-M",
     "PP-DocLayout-S",
+    "PP-DocLayout_plus-L",
+    "PP-DocBlockLayout",
 ]

paddlex/inference/models/open_vocabulary_detection/__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.