"
+ "| ", " | "
)
- tabel_content = tabel_content.replace(" | ", " | ")
- tabel_content = tabel_content.replace(" | ", " | ")
+ tabel_content = tabel_content.replace(
+ " | ", " | "
+ )
+
return tabel_content
@@ -164,7 +208,7 @@ def build_handle_funcs_dict(
dict: A mapping from block label to handler function.
"""
return {
- "paragraph_title": format_title_func,
+ "paragraph_title": format_para_title_func,
"abstract_title": format_title_func,
"reference_title": format_title_func,
"content_title": format_title_func,
@@ -208,9 +252,18 @@ def build_handle_funcs_dict(
),
"algorithm": lambda block: block.content.strip("\n"),
"seal": seal_func,
+ "spotting": lambda block: block.content,
+ "number": format_text_plain_func,
+ "footnote": format_text_plain_func,
+ "header": format_text_plain_func,
+ "header_image": image_func,
+ "footer": format_text_plain_func,
+ "footer_image": image_func,
+ "aside_text": format_text_plain_func,
}
+@class_requires_deps("opencv-contrib-python")
class PaddleOCRVLResult(BaseCVResult, HtmlMixin, XlsxMixin, MarkdownMixin):
"""
PaddleOCRVLResult class for holding and formatting OCR/VL parsing results.
@@ -228,6 +281,12 @@ def __init__(self, data) -> None:
XlsxMixin.__init__(self)
MarkdownMixin.__init__(self)
JsonMixin.__init__(self)
+ markdown_ignore_labels = self["model_settings"].get(
+ "markdown_ignore_labels", []
+ )
+ self.skip_order_labels = [
+ label for label in SKIP_ORDER_LABELS + markdown_ignore_labels
+ ]
def _to_img(self) -> dict[str, np.ndarray]:
"""
@@ -236,39 +295,71 @@ def _to_img(self) -> dict[str, np.ndarray]:
Returns:
dict: Keys are names, values are numpy arrays (images).
"""
- from ..layout_parsing.utils import get_show_color
res_img_dict = {}
model_settings = self["model_settings"]
if model_settings["use_doc_preprocessor"]:
- for key, value in self["doc_preprocessor_res"].img.items():
- res_img_dict[key] = value
+ if isinstance(self["doc_preprocessor_res"], BaseResult):
+ for key, value in self["doc_preprocessor_res"].img.items():
+ res_img_dict[key] = value
+ if isinstance(self["doc_preprocessor_res"], list):
+ for idx, doc_preprocessor_res in enumerate(
+ self["doc_preprocessor_res"]
+ ):
+ if isinstance(doc_preprocessor_res, BaseResult):
+ for key, value in doc_preprocessor_res.img.items():
+ res_img_dict[f"{key}_{idx}"] = value
if self["model_settings"]["use_layout_detection"]:
- res_img_dict["layout_det_res"] = self["layout_det_res"].img["res"]
-
- # for layout ordering image
- image = Image.fromarray(self["doc_preprocessor_res"]["output_img"][:, :, ::-1])
- draw = ImageDraw.Draw(image, "RGBA")
- font_size = int(0.018 * int(image.width)) + 2
- font = ImageFont.truetype(PINGFANG_FONT.path, font_size, encoding="utf-8")
- parsing_result = self["parsing_res_list"]
- order_index = 0
- for block in parsing_result:
- bbox = block.bbox
- label = block.label
- fill_color = get_show_color(label, False)
- draw.rectangle(bbox, fill=fill_color)
- if label in VISUALIZE_INDEX_LABELS:
- text_position = (bbox[2] + 2, bbox[1] - font_size // 2)
- if int(image.width) - bbox[2] < font_size:
- text_position = (
- int(bbox[2] - font_size * 1.1),
- bbox[1] - font_size // 2,
+ if isinstance(self["layout_det_res"], BaseResult):
+ res_img_dict["layout_det_res"] = self["layout_det_res"].img["res"]
+ if isinstance(self["layout_det_res"], list):
+ for idx, layout_res in enumerate(self["layout_det_res"]):
+ if isinstance(layout_res, BaseResult):
+ res_img_dict[f"layout_det_res_{idx}"] = layout_res.img["res"]
+
+ if self.get("spotting_res") and not isinstance(self["spotting_res"], list):
+ boxes = self["spotting_res"]["rec_polys"]
+ txts = self["spotting_res"]["rec_texts"]
+ image = self["doc_preprocessor_res"]["output_img"][:, :, ::-1]
+ h, w = image.shape[0:2]
+ img_left = Image.fromarray(image)
+ img_right = np.ones((h, w, 3), dtype=np.uint8) * 255
+ random.seed(0)
+ draw_left = ImageDraw.Draw(img_left)
+ vis_font = SIMFANG_FONT
+ for idx, (box, txt) in enumerate(zip(boxes, txts)):
+ try:
+ color = (
+ random.randint(0, 255),
+ random.randint(0, 255),
+ random.randint(0, 255),
)
- draw.text(text_position, str(order_index + 1), font=font, fill="red")
- order_index += 1
-
- res_img_dict["layout_order_res"] = image
+ box = np.array(box)
+ if len(box) > 4:
+ pts = [(x, y) for x, y in box.tolist()]
+ draw_left.polygon(pts, outline=color, width=8, fill=color)
+ box = get_minarea_rect(box)
+ height = int(0.5 * (max(box[:, 1]) - min(box[:, 1])))
+ box[:2, 1] = np.mean(box[:, 1])
+ box[2:, 1] = np.mean(box[:, 1]) + min(20, height)
+ else:
+ box_pts = [(int(x), int(y)) for x, y in box.tolist()]
+ draw_left.polygon(box_pts, fill=color)
+ if isinstance(txt, tuple):
+ txt = txt[0]
+ img_right_text = draw_box_txt_fine((w, h), box, txt, vis_font.path)
+ pts = np.array(box, np.int32).reshape((-1, 1, 2))
+ cv2.polylines(img_right_text, [pts], True, color, 1)
+ img_right = cv2.bitwise_and(img_right, img_right_text)
+ except:
+ continue
+
+ img_left = Image.blend(Image.fromarray(image), img_left, 0.5)
+ img_show = Image.new("RGB", (w * 2, h), (255, 255, 255))
+ img_show.paste(img_left, (0, 0, w, h))
+ img_show.paste(Image.fromarray(img_right), (w, 0, w * 2, h))
+
+ res_img_dict["spotting_res_img"] = img_show
return res_img_dict
@@ -280,7 +371,7 @@ def _to_html(self) -> dict[str, str]:
dict: The str type HTML representation result.
"""
res_html_dict = {}
- if len(self["table_res_list"]) > 0:
+ if self.get("table_res_list") and len(self["table_res_list"]) > 0:
for sno in range(len(self["table_res_list"])):
table_res = self["table_res_list"][sno]
table_region_id = table_res["table_region_id"]
@@ -296,7 +387,7 @@ def _to_xlsx(self) -> dict[str, str]:
dict: The str type XLSX representation result.
"""
res_xlsx_dict = {}
- if len(self["table_res_list"]) > 0:
+ if self.get("table_res_list") and len(self["table_res_list"]) > 0:
for sno in range(len(self["table_res_list"])):
table_res = self["table_res_list"][sno]
table_region_id = table_res["table_region_id"]
@@ -318,6 +409,9 @@ def _to_str(self, *args, **kwargs) -> dict[str, str]:
data = {}
data["input_path"] = self["input_path"]
data["page_index"] = self["page_index"]
+ data["page_count"] = self["page_count"]
+ data["width"] = self["width"]
+ data["height"] = self["height"]
model_settings = self["model_settings"]
data["model_settings"] = model_settings
if self["model_settings"]["use_doc_preprocessor"]:
@@ -347,13 +441,22 @@ def _to_json(self, *args, **kwargs) -> dict[str, str]:
Returns:
dict: A dictionary containing the object's data in JSON format.
"""
+ _keep_img = kwargs.pop("keep_img", False)
+
data = {}
data["input_path"] = self["input_path"]
data["page_index"] = self["page_index"]
+ data["page_count"] = self["page_count"]
+ data["width"] = self["width"]
+ data["height"] = self["height"]
model_settings = self["model_settings"]
data["model_settings"] = model_settings
+ use_seal_recognition = self["model_settings"].get("use_seal_recognition", False)
if self["model_settings"].get("format_block_content", False):
- original_image_width = self["doc_preprocessor_res"]["output_img"].shape[1]
+ original_image_width = self["width"]
+ use_ocr_for_image_block = self["model_settings"].get(
+ "use_ocr_for_image_block", False
+ )
format_text_func = lambda block: format_centered_by_html(
format_text_plain_func(block)
)
@@ -361,7 +464,18 @@ def _to_json(self, *args, **kwargs) -> dict[str, str]:
format_image_scaled_by_html_func(
block,
original_image_width=original_image_width,
- )
+ show_ocr_content=use_ocr_for_image_block,
+ ),
+ remove_symbol=not use_ocr_for_image_block,
+ )
+
+ format_seal_func = lambda block: format_centered_by_html(
+ format_image_scaled_by_html_func(
+ block,
+ original_image_width=original_image_width,
+ show_ocr_content=True,
+ ),
+ remove_symbol=use_seal_recognition,
)
if self["model_settings"].get("use_chart_recognition", False):
@@ -369,10 +483,11 @@ def _to_json(self, *args, **kwargs) -> dict[str, str]:
else:
format_chart_func = format_image_func
- format_seal_func = format_image_func
+ if not self["model_settings"].get("use_layout_detection", False):
+ format_seal_func = format_text_func
format_table_func = lambda block: "\n" + format_table_center_func(block)
- format_formula_func = lambda block: block.content
+ format_formula_func = lambda block: clean_latex_delimiters(block.content)
handle_funcs_dict = build_handle_funcs_dict(
text_func=format_text_func,
@@ -388,7 +503,7 @@ def _to_json(self, *args, **kwargs) -> dict[str, str]:
order_index = 1
for idx, parsing_res in enumerate(parsing_res_list):
label = parsing_res.label
- if label in VISUALIZE_INDEX_LABELS:
+ if label not in self.skip_order_labels:
order = order_index
order_index += 1
else:
@@ -399,7 +514,26 @@ def _to_json(self, *args, **kwargs) -> dict[str, str]:
"block_bbox": parsing_res.bbox,
"block_id": idx,
"block_order": order,
+ "group_id": (
+ parsing_res.group_id if parsing_res.group_id is not None else idx
+ ),
}
+ if (
+ hasattr(parsing_res, "global_block_id")
+ and parsing_res.global_block_id is not None
+ ):
+ res_dict["global_block_id"] = parsing_res.global_block_id
+ if (
+ hasattr(parsing_res, "global_group_id")
+ and parsing_res.global_group_id is not None
+ ):
+ res_dict["global_group_id"] = parsing_res.global_group_id
+ if parsing_res.polygon_points is not None:
+ res_dict["block_polygon_points"] = parsing_res.polygon_points
+
+ if _keep_img and parsing_res.image is not None:
+ res_dict["image"] = parsing_res.image
+
if self["model_settings"].get("format_block_content", False):
if handle_funcs_dict.get(parsing_res.label):
res_dict["block_content"] = handle_funcs_dict[parsing_res.label](
@@ -410,10 +544,21 @@ def _to_json(self, *args, **kwargs) -> dict[str, str]:
parsing_res_list_json.append(res_dict)
data["parsing_res_list"] = parsing_res_list_json
+ if self.get("spotting_res"):
+ if isinstance(self["spotting_res"], list):
+ data["spotting_res"] = [res for res in self["spotting_res"]]
+ else:
+ data["spotting_res"] = self["spotting_res"]
if self["model_settings"]["use_doc_preprocessor"]:
- data["doc_preprocessor_res"] = self["doc_preprocessor_res"].json["res"]
+ if isinstance(self["doc_preprocessor_res"], BaseResult):
+ data["doc_preprocessor_res"] = self["doc_preprocessor_res"].json["res"]
+ else:
+ data["doc_preprocessor_res"] = self["doc_preprocessor_res"]
if self["model_settings"]["use_layout_detection"]:
- data["layout_det_res"] = self["layout_det_res"].json["res"]
+ if isinstance(self["layout_det_res"], BaseResult):
+ data["layout_det_res"] = self["layout_det_res"].json["res"]
+ else:
+ data["layout_det_res"] = self["layout_det_res"]
return JsonMixin._to_json(data, *args, **kwargs)
def _to_markdown(self, pretty=True, show_formula_number=False) -> dict:
@@ -427,7 +572,15 @@ def _to_markdown(self, pretty=True, show_formula_number=False) -> dict:
Returns:
dict: Markdown information with text and images.
"""
- original_image_width = self["doc_preprocessor_res"]["output_img"].shape[1]
+
+ use_ocr_for_image_block = self["model_settings"].get(
+ "use_ocr_for_image_block", False
+ )
+ use_seal_recognition = self["model_settings"].get("use_seal_recognition", False)
+ if isinstance(self["width"], list):
+ original_image_width = self["width"][0]
+ else:
+ original_image_width = self["width"]
if pretty:
format_text_func = lambda block: format_centered_by_html(
@@ -437,11 +590,159 @@ def _to_markdown(self, pretty=True, show_formula_number=False) -> dict:
format_image_scaled_by_html_func(
block,
original_image_width=original_image_width,
+ show_ocr_content=use_ocr_for_image_block,
+ ),
+ remove_symbol=not use_ocr_for_image_block,
+ )
+ format_seal_func = lambda block: format_centered_by_html(
+ format_image_scaled_by_html_func(
+ block,
+ original_image_width=original_image_width,
+ show_ocr_content=use_seal_recognition,
+ ),
+ remove_symbol=False,
+ )
+ else:
+ format_text_func = lambda block: block.content
+ format_image_func = lambda block: format_image_plain_func(
+ block, use_ocr_for_image_block
+ )
+ format_seal_func = lambda block: format_image_plain_func(
+ block, use_seal_recognition
+ )
+
+ format_chart_func = (
+ format_chart2table_func
+ if self["model_settings"]["use_chart_recognition"]
+ else format_image_func
+ )
+
+ if not self["model_settings"].get("use_layout_detection", False):
+ format_seal_func = format_text_func
+
+ if pretty:
+ format_table_func = lambda block: "\n" + format_table_center_func(block)
+ else:
+ format_table_func = lambda block: simplify_table_func("\n" + block.content)
+
+ format_formula_func = lambda block: clean_latex_delimiters(block.content)
+
+ handle_funcs_dict = build_handle_funcs_dict(
+ text_func=format_text_func,
+ image_func=format_image_func,
+ chart_func=format_chart_func,
+ table_func=format_table_func,
+ formula_func=format_formula_func,
+ seal_func=format_seal_func,
+ )
+ for label in self["model_settings"].get("markdown_ignore_labels", []):
+ handle_funcs_dict.pop(label, None)
+
+ markdown_content = ""
+ markdown_info = {}
+ markdown_info["markdown_images"] = {}
+ for idx, block in enumerate(self["parsing_res_list"]):
+ label = block.label
+ if block.image is not None:
+ markdown_info["markdown_images"][block.image["path"]] = block.image[
+ "img"
+ ]
+ handle_func = handle_funcs_dict.get(label, None)
+ if (
+ show_formula_number
+ and (label == "display_formula" or label == "formula")
+ and idx != len(self["parsing_res_list"]) - 1
+ ):
+ next_block = self["parsing_res_list"][idx + 1]
+ next_block_label = next_block.label
+ if next_block_label == "formula_number":
+ block.content = merge_formula_and_number(
+ block.content, next_block.content
+ )
+ if handle_func:
+ markdown_content += (
+ "\n\n" + handle_func(block)
+ if markdown_content
+ else handle_func(block)
)
+
+ markdown_info["page_index"] = self["page_index"]
+ markdown_info["input_path"] = self["input_path"]
+ markdown_info["markdown_texts"] = markdown_content
+ for img in self["imgs_in_doc"]:
+ markdown_info["markdown_images"][img["path"]] = img["img"]
+
+ return markdown_info
+
+
+class PaddleOCRVLPagesResult(PaddleOCRVLResult):
+ def save_to_img(self, *args, **kwargs):
+ logging.warning(
+ f"The result of multi-pages don't support to save as image format!"
+ )
+ return None
+
+ def save_to_html(self, *args, **kwargs):
+ logging.warning(
+ f"The result of multi-pages don't support to save as html format!"
+ )
+ return None
+
+ def save_to_xlsx(self, *args, **kwargs):
+ logging.warning(
+ f"The result of multi-pages don't support to save as xlsx format!"
+ )
+ return None
+
+ def _to_markdown(self, pretty=True, show_formula_number=False) -> dict:
+ """
+ Save the parsing result to a Markdown file.
+
+ Args:
+ pretty (Optional[bool]): whether to pretty markdown by HTML, default by True.
+ show_formula_number (bool): whether to show formula numbers.
+
+ Returns:
+ dict: Markdown information with text and images.
+ """
+
+ use_ocr_for_image_block = self["model_settings"].get(
+ "use_ocr_for_image_block", False
+ )
+ use_seal_recognition = self["model_settings"].get("use_seal_recognition", False)
+ if isinstance(self["width"], list):
+ original_image_width = self["width"][0]
+ else:
+ original_image_width = self["width"]
+
+ if pretty:
+ format_text_func = lambda block: format_centered_by_html(
+ format_text_plain_func(block)
+ )
+ format_image_func = lambda block: format_centered_by_html(
+ format_image_scaled_by_html_func(
+ block,
+ original_image_width=original_image_width,
+ show_ocr_content=use_ocr_for_image_block,
+ ),
+ remove_symbol=not use_ocr_for_image_block,
+ )
+ format_seal_func = lambda block: format_centered_by_html(
+ format_image_scaled_by_html_func(
+ block,
+ original_image_width=original_image_width,
+ show_ocr_content=use_seal_recognition,
+ ),
+ remove_symbol=False,
)
else:
format_text_func = lambda block: block.content
- format_image_func = format_image_plain_func
+ format_image_func = lambda block: format_image_plain_func(
+ block, use_ocr_for_image_block
+ )
+ format_seal_func = lambda block: format_image_plain_func(
+ block, use_seal_recognition
+ )
format_chart_func = (
format_chart2table_func
@@ -454,8 +755,7 @@ def _to_markdown(self, pretty=True, show_formula_number=False) -> dict:
else:
format_table_func = lambda block: simplify_table_func("\n" + block.content)
- format_formula_func = lambda block: block.content
- format_seal_func = format_image_func
+ format_formula_func = lambda block: clean_latex_delimiters(block.content)
handle_funcs_dict = build_handle_funcs_dict(
text_func=format_text_func,
@@ -465,6 +765,8 @@ def _to_markdown(self, pretty=True, show_formula_number=False) -> dict:
formula_func=format_formula_func,
seal_func=format_seal_func,
)
+ for label in self["model_settings"].get("markdown_ignore_labels", []):
+ handle_funcs_dict.pop(label, None)
markdown_content = ""
markdown_info = {}
diff --git a/paddlex/inference/pipelines/paddleocr_vl/uilts.py b/paddlex/inference/pipelines/paddleocr_vl/uilts.py
index 8cd650fd89..573dfaa152 100644
--- a/paddlex/inference/pipelines/paddleocr_vl/uilts.py
+++ b/paddlex/inference/pipelines/paddleocr_vl/uilts.py
@@ -31,8 +31,52 @@
)
+def make_valid(poly):
+ if not poly.is_valid:
+ poly = poly.buffer(0)
+ return poly
+
+
+def calculate_polygon_overlap_ratio(
+ polygon1: List[Tuple[int, int]],
+ polygon2: List[Tuple[int, int]],
+ mode: str = "union",
+) -> float:
+ """
+ Calculate the overlap ratio between two polygons.
+
+ Args:
+ polygon1 (List[Tuple[int, int]]): First polygon represented as a list of points.
+ polygon2 (List[Tuple[int, int]]): Second polygon represented as a list of points.
+ mode (str, optional): Overlap calculation mode. Defaults to "union".
+
+ Returns:
+ float: Overlap ratio value between 0 and 1.
+ """
+ try:
+ from shapely.geometry import Polygon
+ except ImportError:
+ raise ImportError("Please install Shapely library.")
+ poly1 = Polygon(polygon1)
+ poly2 = Polygon(polygon2)
+ poly1 = make_valid(poly1)
+ poly2 = make_valid(poly2)
+ intersection = poly1.intersection(poly2).area
+ union = poly1.union(poly2).area
+ if mode == "union":
+ return intersection / union
+ elif mode == "small":
+ small_area = min(poly1.area, poly2.area)
+ return intersection / small_area
+ elif mode == "large":
+ large_area = max(poly1.area, poly2.area)
+ return intersection / large_area
+ else:
+ raise ValueError(f"Unknown mode: {mode}")
+
+
def filter_overlap_boxes(
- layout_det_res: Dict[str, List[Dict]]
+ layout_det_res: Dict[str, List[Dict]], layout_shape_mode: str
) -> Dict[str, List[Dict]]:
"""
Remove overlapping boxes from layout detection results based on a given overlap ratio.
@@ -50,18 +94,41 @@ def filter_overlap_boxes(
dropped_indexes = set()
for i in range(len(boxes)):
+ x1, y1, x2, y2 = boxes[i]["coordinate"]
+ w, h = x2 - x1, y2 - y1
+ if w < 6 or h < 6:
+ dropped_indexes.add(i)
for j in range(i + 1, len(boxes)):
if i in dropped_indexes or j in dropped_indexes:
continue
overlap_ratio = calculate_overlap_ratio(
boxes[i]["coordinate"], boxes[j]["coordinate"], "small"
)
+ if (
+ boxes[i]["label"] == "inline_formula"
+ or boxes[j]["label"] == "inline_formula"
+ ):
+ if overlap_ratio > 0.5:
+ if boxes[i]["label"] == "inline_formula":
+ dropped_indexes.add(i)
+ if boxes[j]["label"] == "inline_formula":
+ dropped_indexes.add(j)
+ continue
if overlap_ratio > 0.7:
+ if layout_shape_mode != "rect" and "polygon_points" in boxes[i]:
+ poly_overlap_ratio = calculate_polygon_overlap_ratio(
+ boxes[i]["polygon_points"], boxes[j]["polygon_points"], "small"
+ )
+ if poly_overlap_ratio < 0.7:
+ continue
box_area_i = calculate_bbox_area(boxes[i]["coordinate"])
box_area_j = calculate_bbox_area(boxes[j]["coordinate"])
- if (
- boxes[i]["label"] == "image" or boxes[j]["label"] == "image"
- ) and boxes[i]["label"] != boxes[j]["label"]:
+ if {boxes[i]["label"], boxes[j]["label"]} & {
+ "image",
+ "table",
+ "seal",
+ "chart",
+ } and boxes[i]["label"] != boxes[j]["label"]:
continue
if box_area_i >= box_area_j:
dropped_indexes.add(j)
@@ -120,7 +187,7 @@ def calc_merged_wh(images):
return w, h
-def merge_images(images, aligns="center"):
+def merge_images(images, aligns="center", layout_shape_mode="auto"):
"""
Merge images vertically with given alignment.
@@ -139,6 +206,7 @@ def merge_images(images, aligns="center"):
aligns = [aligns] * (len(images) - 1)
if len(aligns) != len(images) - 1:
raise ValueError("The length of aligns must be len(images) - 1")
+ # TODO(changdazhou): need to support merge by polygon
merged = to_pil_image(images[0])
for i in range(1, len(images)):
img2 = to_pil_image(images[i])
@@ -160,7 +228,7 @@ def merge_images(images, aligns="center"):
return to_np_array(merged)
-def merge_blocks(blocks, non_merge_labels):
+def merge_blocks(blocks, non_merge_labels, layout_shape_mode="auto"):
"""
Merge blocks based on alignment and overlap logic, except for those with labels in non_merge_labels.
@@ -204,7 +272,10 @@ def overlapwith_other_box(block_idx, prev_idx, blocks):
y2 = max(prev_bbox[3], block_bbox[3])
min_box = [x1, y1, x2, y2]
for idx, other_block in enumerate(blocks):
- if idx in [block_idx, prev_idx]:
+ if (
+ idx in [block_idx, prev_idx]
+ or other_block["label"] not in non_merge_labels
+ ):
continue
other_bbox = other_block["box"]
if calculate_overlap_ratio(min_box, other_bbox) > 0:
@@ -259,15 +330,15 @@ def overlapwith_other_box(block_idx, prev_idx, blocks):
current_indices.append(idx)
current_aligns.append(align_mode)
else:
- merged_groups.append((current_indices, current_group, current_aligns))
+ merged_groups.append((current_indices, current_aligns))
current_group = [block]
current_indices = [idx]
current_aligns = []
if current_group:
- merged_groups.append((current_indices, current_group, current_aligns))
+ merged_groups.append((current_indices, current_aligns))
group_ranges = []
- for group_indices, group, aligns in merged_groups:
+ for group_indices, aligns in merged_groups:
start, end = min(group_indices), max(group_indices)
group_ranges.append((start, end, group_indices, aligns))
@@ -276,9 +347,7 @@ def overlapwith_other_box(block_idx, prev_idx, blocks):
idx = 0
while idx < len(blocks):
group_found = False
- for (start, end, group_indices, aligns), (g_indices, g_blocks, g_aligns) in zip(
- group_ranges, merged_groups
- ):
+ for start, end, group_indices, aligns in group_ranges:
if idx == start and all(i not in used_indices for i in group_indices):
group_found = True
imgs = [blocks[i]["img"] for i in group_indices]
@@ -293,11 +362,12 @@ def overlapwith_other_box(block_idx, prev_idx, blocks):
result_blocks.append(block)
used_indices.add(block_idx)
else:
- merged_img = merge_images(imgs, merge_aligns)
+ merged_img = merge_images(imgs, merge_aligns, layout_shape_mode)
for j, block_idx in enumerate(group_indices):
block = blocks[block_idx].copy()
block["img"] = merged_img if j == 0 else None
block["merge_aligns"] = merge_aligns if j == 0 else None
+ block["group_id"] = group_indices[0]
result_blocks.append(block)
used_indices.add(block_idx)
insert_list = []
@@ -434,12 +504,13 @@ def gen_random_map(num):
]
token_str = "[F" + str(random_map[figure_id]) + "]"
table_block_img = paint_token(table_block_img, draw_box, token_str)
- token_map[token_str] = f' '
+ # token_map[token_str] = f''
+ token_map[token_str] = figure["path"]
drop_figures = [f["path"] for i, f in enumerate(figures) if i in drop_idxes]
return table_block_img, token_map, drop_figures
-def untokenize_figure_of_table(table_res_str, figure_token_map):
+def untokenize_figure_of_table(table_res_str, figure_token_map, image_path_to_obj_map):
"""
Replace tokens in a string with their HTML image equivalents.
@@ -454,7 +525,22 @@ def untokenize_figure_of_table(table_res_str, figure_token_map):
def repl(match):
token_id = match.group(1)
token = f"[F{token_id}]"
- return figure_token_map.get(token, match.group(0))
+ img_path = figure_token_map.get(token, match.group(0))
+ img_block = image_path_to_obj_map.get(img_path, None)
+ if img_block is None:
+ return match.group(0)
+ else:
+ img_tags = []
+ img_tags.append(
+ ' '.format(
+ img_path.replace("-\n", "").replace("\n", " ")
+ ),
+ )
+ image_info = "\n".join(img_tags)
+ if img_block.content != "":
+ ocr_content = img_block.content
+ image_info += "\n\n" + ocr_content + "\n\n"
+ return image_info
pattern = r"\[F(\d+)\]"
return re.sub(pattern, repl, table_res_str)
@@ -876,7 +962,11 @@ def find_repeating_suffix(
def truncate_repetitive_content(
- content: str, line_threshold: int = 10, char_threshold: int = 10, min_len: int = 10
+ content: str,
+ line_threshold: int = 10,
+ char_threshold: int = 10,
+ min_len: int = 10,
+ min_count: int = 3000,
) -> str:
"""
Detect and truncate character-level, phrase-level, or line-level repetition in content.
@@ -890,6 +980,9 @@ def truncate_repetitive_content(
Returns:
Union[str, str]: (truncated_content, info_string)
"""
+ if len(content) < min_count:
+ return content
+
stripped_content = content.strip()
if not stripped_content:
return content
@@ -955,3 +1048,62 @@ def crop_margin(img):
cropped = img[y : y + h, x : x + w]
return cropped
+
+
+ANNOT_TEXT_RE = re.compile(r"<\|TEXT_START\|>(.*?)<\|TEXT_END\|>", re.S)
+LOC_BLOCK_RE = re.compile(r"<\|LOC_BEGIN\|>(.*?)<\|LOC_END\|>", re.S)
+LOC_ITEM_RE = re.compile(r"<\|LOC_(\d+)\|>")
+LOC_TOKEN_RE = re.compile(r"<\|LOC_(\d+)\|>")
+
+
+def post_process_for_spotting(
+ input_str: str, w: int, h: int
+) -> Tuple[str, Dict[str, List]]:
+ """
+ Post-process the input string to extract text and location blocks.
+ """
+ assert isinstance(input_str, str)
+
+ # Extract text and location blocks
+ texts = ANNOT_TEXT_RE.findall(input_str)
+ loc_blocks = LOC_BLOCK_RE.findall(input_str)
+
+ rec_polys = []
+ rec_texts = []
+
+ # Process the extracted text and location blocks
+ n = min(len(texts), len(loc_blocks))
+ for i in range(n):
+ txt = texts[i].strip()
+ loc_items = LOC_ITEM_RE.findall(loc_blocks[i])
+ if len(loc_items) < 8:
+ continue
+ # Take the first 8 items (4 points)
+ vals = list(map(int, loc_items[:8]))
+ pts = [(vals[j], vals[j + 1]) for j in range(0, 8, 2)]
+ pts = [(p[0] / 1000.0 * w, p[1] / 1000.0 * h) for p in pts]
+ rec_polys.append(pts)
+ rec_texts.append(txt)
+
+ # If no polys or texts are extracted, try an alternative parsing method
+ if not rec_polys or not rec_texts:
+ matches = list(LOC_TOKEN_RE.finditer(input_str))
+ last_end = 0
+ i = 0
+ while i + 7 < len(matches):
+ group = matches[i : i + 8]
+ vals = [int(m.group(1)) for m in group]
+ pts = [(vals[j], vals[j + 1]) for j in range(0, 8, 2)]
+ pts = [(p[0] / 1000.0 * w, p[1] / 1000.0 * h) for p in pts]
+ text_span = input_str[last_end : group[0].start()]
+ txt = text_span.strip()
+ rec_texts.append(txt)
+ rec_polys.append(pts)
+ last_end = group[-1].end()
+ i += 8
+
+ # Join the extracted texts into a single string separated by newlines
+ result_str = "\n\n".join(rec_texts)
+ spotting_res = {"rec_polys": rec_polys, "rec_texts": rec_texts}
+
+ return result_str, spotting_res
diff --git a/paddlex/inference/pipelines/pp_doctranslation/pipeline.py b/paddlex/inference/pipelines/pp_doctranslation/pipeline.py
index 91774244e3..8b81b52095 100644
--- a/paddlex/inference/pipelines/pp_doctranslation/pipeline.py
+++ b/paddlex/inference/pipelines/pp_doctranslation/pipeline.py
@@ -488,7 +488,6 @@ def translate_func(text):
"markdown_texts": target_language_texts,
}
)
-
def concatenate_markdown_pages(self, markdown_list: list) -> tuple:
"""
Concatenate Markdown content from multiple pages into a single document.
@@ -617,4 +616,4 @@ def concatenate_latex_pages(self, latex_info_list: list) -> tuple:
"images": merged_images,
"input_path": latex_info_list[0]["input_path"],
}
- )
+ )
\ No newline at end of file
diff --git a/paddlex/inference/pipelines/pp_doctranslation/utils.py b/paddlex/inference/pipelines/pp_doctranslation/utils.py
index a66522f4f1..e280be49ca 100644
--- a/paddlex/inference/pipelines/pp_doctranslation/utils.py
+++ b/paddlex/inference/pipelines/pp_doctranslation/utils.py
@@ -173,9 +173,10 @@ def translate_html_block(html_block, chunk_size, translate_func, results):
Returns:
None
"""
- from bs4 import BeautifulSoup
import copy
+ from bs4 import BeautifulSoup
+
# If the HTML is short and simple, translate directly
if (
html_block.count("<") < 5
@@ -203,7 +204,7 @@ def translate_html_block(html_block, chunk_size, translate_func, results):
td_batch_nodes.append(parent_td)
td_batch_texts.append(td_text)
td_seen.add(id(parent_td))
-
+
# Process | / | nodes in batches
batch_size = chunk_size
i = 0
@@ -212,12 +213,15 @@ def translate_html_block(html_block, chunk_size, translate_func, results):
batch_nodes = []
batch_texts = []
current_length = 0
- while i < len(td_batch_nodes) and current_length + len(td_batch_texts[i]) <= batch_size:
+ while (
+ i < len(td_batch_nodes)
+ and current_length + len(td_batch_texts[i]) <= batch_size
+ ):
batch_nodes.append(td_batch_nodes[i])
batch_texts.append(td_batch_texts[i])
current_length += len(td_batch_texts[i])
i += 1
-
+
# Translate the batch and reinsert translated content
placeholder = "__TD__"
batch_text = placeholder.join(batch_texts)
@@ -230,7 +234,6 @@ def translate_html_block(html_block, chunk_size, translate_func, results):
for child in frag.contents:
td_node.append(copy.deepcopy(child))
-
text_nodes = []
for node in soup.find_all(string=True, recursive=True):
if not node.find_parent(["td", "th"]) and node.strip():
@@ -245,7 +248,9 @@ def translate_html_block(html_block, chunk_size, translate_func, results):
while idx < total:
node_text = text_nodes[idx].strip()
if len(node_text) > chunk_size:
- translated_text = split_text_recursive(node_text, chunk_size, translate_func)
+ translated_text = split_text_recursive(
+ node_text, chunk_size, translate_func
+ )
text_nodes[idx].replace_with(translated_text)
idx += 1
continue
diff --git a/paddlex/inference/pipelines/table_recognition/pipeline_v2.py b/paddlex/inference/pipelines/table_recognition/pipeline_v2.py
index c7615d9a34..7da771a8ce 100644
--- a/paddlex/inference/pipelines/table_recognition/pipeline_v2.py
+++ b/paddlex/inference/pipelines/table_recognition/pipeline_v2.py
@@ -685,7 +685,12 @@ def split_box_by_cells(ocr_box, cell_indices, cells):
split_texts = []
for box in split_boxes:
x1, y1, x2, y2 = int(box[0]), int(box[1]), int(box[2]), int(box[3])
- if y2 - y1 > 1 and x2 - x1 > 1:
+ if (
+ y2 - y1 > 1
+ and x2 - x1 > 1
+ and y1 < ori_img.shape[0]
+ and x1 < ori_img.shape[1]
+ ):
ocr_result = list(
self.general_ocr_pipeline.text_rec_model(
ori_img[y1:y2, x1:x2, :]
diff --git a/paddlex/inference/pipelines/text_to_speech/__init__.py b/paddlex/inference/pipelines/text_to_speech/__init__.py
new file mode 100644
index 0000000000..5ea98f433c
--- /dev/null
+++ b/paddlex/inference/pipelines/text_to_speech/__init__.py
@@ -0,0 +1,15 @@
+# Copyright (c) 2025 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 TextToSpeechPipeline
diff --git a/paddlex/inference/pipelines/text_to_speech/pipeline.py b/paddlex/inference/pipelines/text_to_speech/pipeline.py
new file mode 100644
index 0000000000..7af9d83991
--- /dev/null
+++ b/paddlex/inference/pipelines/text_to_speech/pipeline.py
@@ -0,0 +1,164 @@
+# Copyright (c) 2025 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.
+
+import os
+from typing import Any, Dict, List, Optional, Union
+
+import numpy as np
+
+from ...models.text_to_pinyin.result import TextToPinyinResult
+from ...models.text_to_speech_acoustic.result import Fastspeech2Result
+from ...models.text_to_speech_vocoder.result import PwganResult
+from ...utils.benchmark import benchmark
+from ...utils.hpi import HPIConfig
+from ...utils.pp_option import PaddlePredictorOption
+from ..base import BasePipeline
+
+
+@benchmark.time_methods
+class TextToSpeechPipeline(BasePipeline):
+ """Text to Speech Pipeline Pipeline"""
+
+ entities = "text_to_speech"
+
+ 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
+ )
+
+ text_to_pinyin_model_config = config["SubModules"]["TextToPinyin"]
+ self.text_to_pinyin_model = self.create_model(text_to_pinyin_model_config)
+ text_to_speech_acoustic_model_config = config["SubModules"][
+ "TextToSpeechAcoustic"
+ ]
+ self.text_to_speech_acoustic_model = self.create_model(
+ text_to_speech_acoustic_model_config
+ )
+ text_to_speech_vocoder_model_config = config["SubModules"][
+ "TextToSpeechVocoder"
+ ]
+ self.text_to_speech_vocoder_model = self.create_model(
+ text_to_speech_vocoder_model_config
+ )
+
+ def predict(
+ self, input: Union[str, List[str], np.ndarray, List[np.ndarray]], **kwargs
+ ) -> PwganResult:
+ """Predicts speech recognition results for the given input.
+
+ Args:
+ input (Union[str, list[str], np.ndarray, list[np.ndarray]]): The input audio or path.
+ **kwargs: Additional keyword arguments that can be passed to the function.
+
+ Returns:
+ PwganResult: The predicted pwgan results, support str and json output.
+ """
+ sentences = []
+ if isinstance(input, str):
+ if input.endswith(".txt"):
+ if not os.path.exists(input):
+ raise FileNotFoundError(
+ f"The specified text file does not exist: {input}"
+ )
+ try:
+ with open(input, "r", encoding="utf-8") as f:
+ sentences = [line.strip() for line in f.readlines()]
+ except IOError as e:
+ raise IOError(
+ f"An error occurred while reading the file {input}: {e}"
+ )
+ else:
+ sentences = [input]
+ elif isinstance(input, list):
+ for item in input:
+ if isinstance(item, str):
+ if item.endswith(".txt"):
+ if not os.path.exists(item):
+ raise FileNotFoundError(
+ f"The specified text file in the list does not exist: {item}"
+ )
+ try:
+ with open(item, "r", encoding="utf-8") as f:
+ sentences.extend(
+ [line.strip() for line in f.readlines()]
+ )
+ except IOError as e:
+ raise IOError(
+ f"An error occurred while reading the file {item}: {e}"
+ )
+ else:
+ sentences.append(item)
+ else:
+ raise TypeError(
+ f"Unsupported input type: {type(input)}. Expected str, list, or np.ndarray."
+ )
+ if not sentences:
+ raise ValueError(
+ "The input resulted in an empty list of sentences to process."
+ )
+
+ for sentence in sentences:
+ text_to_pinyin_res = [
+ self.get_text_to_pinyin_result(sentence)["result"]["phone_ids"]
+ ]
+ text_to_speech_acoustic_res = [
+ self.get_text_to_speech_acoustic_result(text_to_pinyin_res)["result"]
+ ]
+ yield from self.text_to_speech_vocoder_model(text_to_speech_acoustic_res)
+
+ def get_text_to_pinyin_result(
+ self, input: Union[str, List[str]]
+ ) -> TextToPinyinResult:
+ """Get the result of text to pinyin conversion.
+
+ Args:
+ input (Union[str, list[str]]): The input text or list of texts.
+
+ Returns:
+ TextToPinyinResult: The result of text to pinyin conversion.
+ """
+ return next(self.text_to_pinyin_model(input))
+
+ def get_text_to_speech_acoustic_result(
+ self, input: Union[str, List[str]]
+ ) -> Fastspeech2Result:
+ """Get the result of text to speech acoustic conversion.
+
+ Args:
+ input (Union[str, list[str]]): The input text or list of texts.
+
+ Returns:
+ Fastspeech2Result: The result of text to speech acoustic conversion.
+ """
+ return next(self.text_to_speech_acoustic_model(input))
diff --git a/paddlex/inference/serving/basic_serving/_app.py b/paddlex/inference/serving/basic_serving/_app.py
index 0a28d029b1..6dcdfbc99e 100644
--- a/paddlex/inference/serving/basic_serving/_app.py
+++ b/paddlex/inference/serving/basic_serving/_app.py
@@ -30,6 +30,7 @@
TypeVar,
)
+import pydantic
from typing_extensions import ParamSpec, TypeGuard
from ....utils import logging
@@ -195,15 +196,55 @@ async def _check_health() -> AIStudioNoResultResponse:
logId=generate_log_id(), errorCode=0, errorMsg="Healthy"
)
+ async def _try_get_log_id(request: fastapi.Request) -> Optional[str]:
+ try:
+ body = await request.json()
+ except Exception:
+ return None
+ if isinstance(body, dict) and "logId" in body:
+ return body["logId"]
+ return None
+
+ # Circumvent FastAPI bug: https://github.com/fastapi/fastapi/discussions/11923
+ # adapted from the Pydantic docs:
+ # https://docs.pydantic.dev/latest/errors/errors/#custom-errors
+ def _loc_to_dot_sep(loc: Tuple[str | int, ...]) -> str:
+ path = ""
+ for i, x in enumerate(loc):
+ if isinstance(x, str):
+ if i > 0:
+ path += "."
+ path += x
+ elif isinstance(x, int):
+ path += f"[{x}]"
+ else:
+ raise TypeError("Unexpected type")
+ return path
+
+ def _convert_validation_errors(
+ validation_error: pydantic.ValidationError | RequestValidationError,
+ ) -> List[Dict[str, Any]]:
+ converted_errors = []
+ for error in validation_error.errors():
+ converted_error = {
+ "type": error["type"],
+ "loc": _loc_to_dot_sep(error["loc"]),
+ "msg": error["msg"],
+ }
+ converted_errors.append(converted_error)
+ return converted_errors
+
@app.exception_handler(RequestValidationError)
async def _validation_exception_handler(
request: fastapi.Request, exc: RequestValidationError
) -> JSONResponse:
+ log_id = await _try_get_log_id(request) or generate_log_id()
+ errors = _convert_validation_errors(exc)
json_compatible_data = jsonable_encoder(
AIStudioNoResultResponse(
- logId=generate_log_id(),
+ logId=log_id,
errorCode=422,
- errorMsg=json.dumps(exc.errors()),
+ errorMsg=json.dumps(errors),
)
)
return JSONResponse(content=json_compatible_data, status_code=422)
@@ -212,9 +253,10 @@ async def _validation_exception_handler(
async def _http_exception_handler(
request: fastapi.Request, exc: HTTPException
) -> JSONResponse:
+ log_id = await _try_get_log_id(request) or generate_log_id()
json_compatible_data = jsonable_encoder(
AIStudioNoResultResponse(
- logId=generate_log_id(), errorCode=exc.status_code, errorMsg=exc.detail
+ logId=log_id, errorCode=exc.status_code, errorMsg=exc.detail
)
)
return JSONResponse(content=json_compatible_data, status_code=exc.status_code)
@@ -223,12 +265,14 @@ async def _http_exception_handler(
async def _unexpected_exception_handler(
request: fastapi.Request, exc: Exception
) -> JSONResponse:
+ # FIXME: Request body is not available here, and the log ID cannot be retrieved.
+ log_id = await _try_get_log_id(request) or generate_log_id()
# XXX: The default server will duplicate the error message. Is it
# necessary to log the exception info here?
logging.exception("Unhandled exception")
json_compatible_data = jsonable_encoder(
AIStudioNoResultResponse(
- logId=generate_log_id(),
+ logId=log_id,
errorCode=500,
errorMsg="Internal server error",
)
diff --git a/paddlex/inference/serving/basic_serving/_pipeline_apps/__init__.py b/paddlex/inference/serving/basic_serving/_pipeline_apps/__init__.py
index f940933524..dea25cbe38 100644
--- a/paddlex/inference/serving/basic_serving/_pipeline_apps/__init__.py
+++ b/paddlex/inference/serving/basic_serving/_pipeline_apps/__init__.py
@@ -17,26 +17,18 @@
from .....utils.deps import function_requires_deps, is_dep_available
from ...infra.config import create_app_config
+from ...infra.name_mappings import pipeline_name_to_mod_name
if is_dep_available("fastapi"):
from fastapi import FastAPI
-def _pipeline_name_to_mod_name(pipeline_name: str) -> str:
- if not pipeline_name:
- raise ValueError("Empty pipeline name")
- mod_name = pipeline_name.lower().replace("-", "_")
- if mod_name[0].isdigit():
- return "m_" + mod_name
- return mod_name
-
-
# XXX: A dynamic approach is used here for writing fewer lines of code, at the
# cost of sacrificing some benefits of type hints.
@function_requires_deps("fastapi")
def create_pipeline_app(pipeline: Any, pipeline_config: Dict[str, Any]) -> "FastAPI":
pipeline_name = pipeline_config["pipeline_name"]
- mod_name = _pipeline_name_to_mod_name(pipeline_name)
+ mod_name = pipeline_name_to_mod_name(pipeline_name)
mod = importlib.import_module(f".{mod_name}", package=__package__)
app_config = create_app_config(pipeline_config)
app_creator = getattr(mod, "create_pipeline_app")
diff --git a/paddlex/inference/serving/basic_serving/_pipeline_apps/_common/ocr.py b/paddlex/inference/serving/basic_serving/_pipeline_apps/_common/ocr.py
index d176631f50..1d46eadb20 100644
--- a/paddlex/inference/serving/basic_serving/_pipeline_apps/_common/ocr.py
+++ b/paddlex/inference/serving/basic_serving/_pipeline_apps/_common/ocr.py
@@ -17,6 +17,7 @@
import numpy as np
from typing_extensions import Literal
+from ......utils import logging
from ......utils.deps import function_requires_deps, is_dep_available
from ....infra import utils as serving_utils
from ....infra.models import ImageInfo, PDFInfo
@@ -79,17 +80,19 @@ async def get_images(
request: BaseInferRequest, app_context: AppContext
) -> Tuple[List[np.ndarray], Union[ImageInfo, PDFInfo]]:
file_type = get_file_type(request)
- # XXX: Should we return 422?
-
- file_bytes = await serving_utils.get_raw_bytes_async(
- request.file,
- app_context.aiohttp_session,
- )
- images, data_info = await serving_utils.call_async(
- serving_utils.file_to_images,
- file_bytes,
- file_type,
- max_num_imgs=app_context.extra["max_num_input_imgs"],
- )
+ try:
+ file_bytes = await serving_utils.get_raw_bytes_async(
+ request.file,
+ app_context.aiohttp_session,
+ )
+ images, data_info = await serving_utils.call_async(
+ serving_utils.file_to_images,
+ file_bytes,
+ file_type,
+ max_num_imgs=app_context.extra["max_num_input_imgs"],
+ )
+ except Exception as e:
+ logging.error("Failed to read input file: %s", e)
+ raise HTTPException(status_code=422, detail="Invalid input file") from e
return images, data_info
diff --git a/paddlex/inference/serving/basic_serving/_pipeline_apps/object_detection.py b/paddlex/inference/serving/basic_serving/_pipeline_apps/object_detection.py
index 73c1ccffba..8aa40d4ae4 100644
--- a/paddlex/inference/serving/basic_serving/_pipeline_apps/object_detection.py
+++ b/paddlex/inference/serving/basic_serving/_pipeline_apps/object_detection.py
@@ -72,7 +72,7 @@ async def _infer(request: InferRequest) -> AIStudioResultResponse[InferResult]:
output_image_base64 = None
return AIStudioResultResponse[InferResult](
- logId=serving_utils.generate_log_id(),
+ logId=request.logId if request.logId else serving_utils.generate_log_id(),
result=InferResult(detectedObjects=objects, image=output_image_base64),
)
diff --git a/paddlex/inference/serving/basic_serving/_pipeline_apps/ocr.py b/paddlex/inference/serving/basic_serving/_pipeline_apps/ocr.py
index ef18f5b012..4020a4f48b 100644
--- a/paddlex/inference/serving/basic_serving/_pipeline_apps/ocr.py
+++ b/paddlex/inference/serving/basic_serving/_pipeline_apps/ocr.py
@@ -43,7 +43,7 @@ def create_pipeline_app(pipeline: Any, app_config: AppConfig) -> "FastAPI":
async def _infer(request: InferRequest) -> AIStudioResultResponse[InferResult]:
pipeline = ctx.pipeline
- log_id = serving_utils.generate_log_id()
+ log_id = request.logId if request.logId else serving_utils.generate_log_id()
visualize_enabled = (
request.visualize if request.visualize is not None else ctx.config.visualize
)
diff --git a/paddlex/inference/serving/basic_serving/_pipeline_apps/paddleocr_vl.py b/paddlex/inference/serving/basic_serving/_pipeline_apps/paddleocr_vl.py
index 05b4f0f5ee..1eaa219d86 100644
--- a/paddlex/inference/serving/basic_serving/_pipeline_apps/paddleocr_vl.py
+++ b/paddlex/inference/serving/basic_serving/_pipeline_apps/paddleocr_vl.py
@@ -18,7 +18,14 @@
from ...infra import utils as serving_utils
from ...infra.config import AppConfig
from ...infra.models import AIStudioResultResponse
-from ...schemas.paddleocr_vl import INFER_ENDPOINT, InferRequest, InferResult
+from ...schemas.paddleocr_vl import (
+ INFER_ENDPOINT,
+ RESTRUCTURE_PAGES_ENDPOINT,
+ InferRequest,
+ InferResult,
+ RestructurePagesRequest,
+ RestructurePagesResult,
+)
from .._app import create_app, primary_operation
from ._common import common
from ._common import ocr as ocr_common
@@ -45,7 +52,7 @@ async def _infer(
) -> AIStudioResultResponse[InferResult]:
pipeline = ctx.pipeline
- log_id = serving_utils.generate_log_id()
+ log_id = request.logId if request.logId else serving_utils.generate_log_id()
visualize_enabled = (
request.visualize if request.visualize is not None else ctx.config.visualize
)
@@ -57,10 +64,13 @@ async def _infer(
use_doc_unwarping=request.useDocUnwarping,
use_layout_detection=request.useLayoutDetection,
use_chart_recognition=request.useChartRecognition,
+ use_seal_recognition=request.useSealRecognition,
+ use_ocr_for_image_block=request.useOcrForImageBlock,
layout_threshold=request.layoutThreshold,
layout_nms=request.layoutNms,
layout_unclip_ratio=request.layoutUnclipRatio,
layout_merge_bboxes_mode=request.layoutMergeBboxesMode,
+ layout_shape_mode=request.layoutShapeMode,
prompt_label=request.promptLabel,
format_block_content=request.formatBlockContent,
repetition_penalty=request.repetitionPenalty,
@@ -68,8 +78,23 @@ async def _infer(
top_p=request.topP,
min_pixels=request.minPixels,
max_pixels=request.maxPixels,
+ max_new_tokens=request.maxNewTokens,
+ merge_layout_blocks=request.mergeLayoutBlocks,
+ markdown_ignore_labels=request.markdownIgnoreLabels,
+ vlm_extra_args=request.vlmExtraArgs,
)
+ orig_result = result
+ if request.restructurePages:
+ result = await serving_utils.call_async(
+ pipeline.pipeline.restructure_pages,
+ result,
+ merge_tables=request.mergeTables,
+ relevel_titles=request.relevelTitles,
+ concatenate_pages=False,
+ )
+ result = list(result)
+
layout_parsing_results: List[Dict[str, Any]] = []
for i, (img, item) in enumerate(zip(images, result)):
pruned_res = common.prune_result(item.json["res"])
@@ -128,4 +153,78 @@ async def _infer(
),
)
+ @primary_operation(
+ app,
+ RESTRUCTURE_PAGES_ENDPOINT,
+ "restructurePages",
+ )
+ async def _restructure_pages(
+ request: RestructurePagesRequest,
+ ) -> AIStudioResultResponse[RestructurePagesResult]:
+ def _to_original_result(pruned_res, page_index):
+ res = {**pruned_res, "input_path": "", "page_index": page_index}
+ orig_res = {"res": res}
+ return orig_res
+
+ pipeline = ctx.pipeline
+
+ log_id = request.logId if request.logId else serving_utils.generate_log_id()
+
+ original_results = []
+ markdown_images = {}
+ for i, page in enumerate(request.pages):
+ orig_res = _to_original_result(page.prunedResult, i)
+ original_results.append(orig_res)
+ if request.concatenatePages:
+ markdown_images.update(page.markdownImages)
+
+ restructured_results = await serving_utils.call_async(
+ pipeline.pipeline.restructure_pages,
+ original_results,
+ merge_tables=request.mergeTables,
+ relevel_titles=request.relevelTitles,
+ concatenate_pages=request.concatenatePages,
+ )
+ restructured_results = list(restructured_results)
+
+ layout_parsing_results = []
+ if request.concatenatePages:
+ layout_parsing_result = {}
+ layout_parsing_result["prunedResult"] = common.prune_result(
+ restructured_results[0].json["res"]
+ )
+ # XXX
+ md_data = restructured_results[0]._to_markdown(
+ pretty=request.prettifyMarkdown,
+ show_formula_number=request.showFormulaNumber,
+ )
+ layout_parsing_result["markdown"] = dict(
+ text=md_data["markdown_texts"],
+ images=markdown_images,
+ )
+ layout_parsing_results.append(layout_parsing_result)
+ else:
+ for new_res, old_page in zip(restructured_results, request.pages):
+ layout_parsing_result = {}
+ layout_parsing_result["prunedResult"] = common.prune_result(
+ new_res.json["res"]
+ )
+ # XXX
+ md_data = new_res._to_markdown(
+ pretty=request.prettifyMarkdown,
+ show_formula_number=request.showFormulaNumber,
+ )
+ layout_parsing_result["markdown"] = dict(
+ text=md_data["markdown_texts"],
+ images=old_page.markdownImages,
+ )
+ layout_parsing_results.append(layout_parsing_result)
+
+ return AIStudioResultResponse[RestructurePagesResult](
+ logId=log_id,
+ result=RestructurePagesResult(
+ layoutParsingResults=layout_parsing_results,
+ ),
+ )
+
return app
diff --git a/paddlex/inference/serving/basic_serving/_pipeline_apps/pp_structurev3.py b/paddlex/inference/serving/basic_serving/_pipeline_apps/pp_structurev3.py
index 3b3a9a660f..79e1e17ee6 100644
--- a/paddlex/inference/serving/basic_serving/_pipeline_apps/pp_structurev3.py
+++ b/paddlex/inference/serving/basic_serving/_pipeline_apps/pp_structurev3.py
@@ -45,7 +45,7 @@ async def _infer(
) -> AIStudioResultResponse[InferResult]:
pipeline = ctx.pipeline
- log_id = serving_utils.generate_log_id()
+ log_id = request.logId if request.logId else serving_utils.generate_log_id()
visualize_enabled = (
request.visualize if request.visualize is not None else ctx.config.visualize
)
@@ -84,12 +84,17 @@ async def _infer(
use_ocr_results_with_table_cells=request.useOcrResultsWithTableCells,
use_e2e_wired_table_rec_model=request.useE2eWiredTableRecModel,
use_e2e_wireless_table_rec_model=request.useE2eWirelessTableRecModel,
+ markdown_ignore_labels=request.markdownIgnoreLabels,
)
layout_parsing_results: List[Dict[str, Any]] = []
for i, (img, item) in enumerate(zip(images, result)):
pruned_res = common.prune_result(item.json["res"])
- md_data = item.markdown
+ # XXX
+ md_data = item._to_markdown(
+ pretty=request.prettifyMarkdown,
+ show_formula_number=request.showFormulaNumber,
+ )
md_text = md_data["markdown_texts"]
md_imgs = await serving_utils.call_async(
common.postprocess_images,
diff --git a/paddlex/inference/serving/infra/name_mappings.py b/paddlex/inference/serving/infra/name_mappings.py
new file mode 100644
index 0000000000..b8a6210968
--- /dev/null
+++ b/paddlex/inference/serving/infra/name_mappings.py
@@ -0,0 +1,28 @@
+# Copyright (c) 2026 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.
+
+PIPELINE_APP_ROUTER = {
+ "PaddleOCR-VL-1.5": "PaddleOCR-VL",
+}
+
+
+def pipeline_name_to_mod_name(pipeline_name: str) -> str:
+ if not pipeline_name:
+ raise ValueError("Empty pipeline name")
+ if pipeline_name in PIPELINE_APP_ROUTER:
+ pipeline_name = PIPELINE_APP_ROUTER[pipeline_name]
+ mod_name = pipeline_name.lower().replace("-", "_").replace(".", "")
+ if mod_name[0].isdigit():
+ return "m_" + mod_name
+ return mod_name
diff --git a/paddlex/inference/serving/infra/utils.py b/paddlex/inference/serving/infra/utils.py
index ab1d0def71..b6b0211f98 100644
--- a/paddlex/inference/serving/infra/utils.py
+++ b/paddlex/inference/serving/infra/utils.py
@@ -18,7 +18,6 @@
import mimetypes
import re
import tempfile
-import threading
import uuid
from functools import partial
from typing import Awaitable, Callable, List, Optional, Tuple, TypeVar, Union, overload
@@ -31,6 +30,7 @@
from typing_extensions import Literal, ParamSpec, TypeAlias, assert_never
from ....utils.deps import function_requires_deps, is_dep_available
+from ...utils.pdfium_lock import pdfium_lock
from .models import ImageInfo, PDFInfo, PDFPageInfo
if is_dep_available("aiohttp"):
@@ -177,20 +177,19 @@ def base64_encode(data: bytes) -> str:
return base64.b64encode(data).decode("ascii")
-_lock = threading.Lock()
-
-
@function_requires_deps("pypdfium2", "opencv-contrib-python")
def read_pdf(
bytes_: bytes, max_num_imgs: Optional[int] = None
) -> Tuple[List[np.ndarray], PDFInfo]:
images: List[np.ndarray] = []
page_info_list: List[PDFPageInfo] = []
- with _lock:
+ with pdfium_lock:
doc = pdfium.PdfDocument(bytes_)
+ doc.init_forms()
try:
for page in doc:
if max_num_imgs is not None and len(images) >= max_num_imgs:
+ page.close()
break
# TODO: Do not always use zoom=2.0
zoom = 2.0
@@ -202,6 +201,7 @@ def read_pdf(
height=image.shape[0],
)
page_info_list.append(page_info)
+ page.close()
finally:
doc.close()
pdf_info = PDFInfo(
diff --git a/paddlex/inference/serving/schemas/__init__.py b/paddlex/inference/serving/schemas/__init__.py
index 27de2e2d19..6537be3995 100644
--- a/paddlex/inference/serving/schemas/__init__.py
+++ b/paddlex/inference/serving/schemas/__init__.py
@@ -11,3 +11,14 @@
# 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 importlib
+from types import ModuleType
+
+from ..infra.name_mappings import pipeline_name_to_mod_name
+
+
+def get_pipeline_schema_mod(pipeline_name: str) -> ModuleType:
+ mod_name = pipeline_name_to_mod_name(pipeline_name)
+ mod = importlib.import_module(f".{mod_name}", package=__package__)
+ return mod
diff --git a/paddlex/inference/serving/schemas/object_detection.py b/paddlex/inference/serving/schemas/object_detection.py
index a5a93ef4bb..3d431cad36 100644
--- a/paddlex/inference/serving/schemas/object_detection.py
+++ b/paddlex/inference/serving/schemas/object_detection.py
@@ -34,6 +34,7 @@ class InferRequest(BaseModel):
image: str
threshold: Optional[Union[float, Dict[int, float]]] = None
visualize: Optional[bool] = None
+ logId: Optional[str] = None
class DetectedObject(BaseModel):
diff --git a/paddlex/inference/serving/schemas/ocr.py b/paddlex/inference/serving/schemas/ocr.py
index 3d0e34c108..143ee49b67 100644
--- a/paddlex/inference/serving/schemas/ocr.py
+++ b/paddlex/inference/serving/schemas/ocr.py
@@ -43,6 +43,7 @@ class InferRequest(ocr.BaseInferRequest):
textRecScoreThresh: Optional[float] = None
returnWordBox: Optional[bool] = None
visualize: Optional[bool] = None
+ logId: Optional[str] = None
class OCRResult(BaseModel):
diff --git a/paddlex/inference/serving/schemas/paddleocr_vl.py b/paddlex/inference/serving/schemas/paddleocr_vl.py
index 0839fd3094..9f439c2148 100644
--- a/paddlex/inference/serving/schemas/paddleocr_vl.py
+++ b/paddlex/inference/serving/schemas/paddleocr_vl.py
@@ -14,7 +14,8 @@
from typing import Dict, Final, List, Optional, Tuple, Union
-from pydantic import BaseModel
+from pydantic import BaseModel, Field, field_validator, model_validator
+from typing_extensions import Annotated, Literal
from ..infra.models import DataInfo, PrimaryOperations
from .shared import ocr
@@ -24,10 +25,16 @@
"InferRequest",
"LayoutParsingResult",
"InferResult",
+ "RESTRUCTURE_PAGES_ENDPOINT",
+ "RestructurePagesRequest",
+ "RestructurePagesResult",
"PRIMARY_OPERATIONS",
+ "MarkdownData",
+ "Page",
]
INFER_ENDPOINT: Final[str] = "/layout-parsing"
+RESTRUCTURE_PAGES_ENDPOINT: Final[str] = "/restructure-pages"
class InferRequest(ocr.BaseInferRequest):
@@ -35,20 +42,168 @@ class InferRequest(ocr.BaseInferRequest):
useDocUnwarping: Optional[bool] = None
useLayoutDetection: Optional[bool] = None
useChartRecognition: Optional[bool] = None
+ useSealRecognition: Optional[bool] = None
+ useOcrForImageBlock: Optional[bool] = None
layoutThreshold: Optional[Union[float, dict]] = None
layoutNms: Optional[bool] = None
layoutUnclipRatio: Optional[Union[float, Tuple[float, float], dict]] = None
layoutMergeBboxesMode: Optional[Union[str, dict]] = None
+ layoutShapeMode: Literal["rect", "quad", "poly", "auto"] = "auto"
promptLabel: Optional[str] = None
formatBlockContent: Optional[bool] = None
repetitionPenalty: Optional[float] = None
temperature: Optional[float] = None
topP: Optional[float] = None
- minPixels: Optional[int] = None
- maxPixels: Optional[int] = None
+ minPixels: Optional[Annotated[int, Field(gt=0)]] = None
+ maxPixels: Optional[Annotated[int, Field(gt=0)]] = None
+ maxNewTokens: Optional[Annotated[int, Field(gt=0)]] = None
+ mergeLayoutBlocks: Optional[bool] = None
+ markdownIgnoreLabels: Optional[List[str]] = None
+ vlmExtraArgs: Optional[dict] = None
prettifyMarkdown: bool = True
showFormulaNumber: bool = False
+ restructurePages: bool = False
+ mergeTables: bool = True
+ relevelTitles: bool = True
visualize: Optional[bool] = None
+ logId: Optional[str] = None
+
+ @field_validator("topP")
+ @classmethod
+ def validate_top_p(cls, v):
+ if v is not None and not (0 < v <= 1):
+ raise ValueError(f"`topP` must be > 0 and ≤ 1; got: {v}")
+ return v
+
+ @field_validator("temperature")
+ @classmethod
+ def validate_temperature(cls, v):
+ if v is not None and v < 0:
+ raise ValueError(f"`temperature` must be ≥ 0; got: {v}")
+ return v
+
+ @field_validator("repetitionPenalty")
+ @classmethod
+ def validate_repetition_penalty(cls, v):
+ if v is not None and v <= 0:
+ raise ValueError(f"`repetitionPenalty` must be > 0; got: {v}")
+ return v
+
+ @field_validator("promptLabel")
+ @classmethod
+ def validate_prompt_label(cls, v):
+ _ALLOWED_PROMPT_LABELS = (
+ "ocr",
+ "formula",
+ "table",
+ "chart",
+ "seal",
+ "spotting",
+ )
+ if v is not None and v not in _ALLOWED_PROMPT_LABELS:
+ valid_values = ", ".join(_ALLOWED_PROMPT_LABELS)
+ raise ValueError(f"`promptLabel` must be one of: {valid_values}; got: {v}")
+ return v
+
+ @field_validator("layoutMergeBboxesMode")
+ @classmethod
+ def validate_merge_bboxes_mode(cls, v):
+ _ALLOWED_MERGE_BBOXES_MODES = ("large", "small", "union")
+
+ if v is None:
+ return v
+
+ if isinstance(v, str):
+ if v not in _ALLOWED_MERGE_BBOXES_MODES:
+ raise ValueError(
+ f"`layoutMergeBboxesMode` must be one of: {', '.join(_ALLOWED_MERGE_BBOXES_MODES)}; got: {v}"
+ )
+ elif isinstance(v, dict):
+ for key, value in v.items():
+ if not isinstance(value, str):
+ raise ValueError(
+ f"`layoutMergeBboxesMode` dictionary values must be strings; got: {type(value).__name__}"
+ )
+ if value not in _ALLOWED_MERGE_BBOXES_MODES:
+ raise ValueError(
+ f"`layoutMergeBboxesMode` dictionary value must be one of: {', '.join(_ALLOWED_MERGE_BBOXES_MODES)}; got: {value}"
+ )
+ else:
+ raise ValueError("`layoutMergeBboxesMode` must be a string or dictionary")
+
+ return v
+
+ @field_validator("layoutUnclipRatio")
+ @classmethod
+ def validate_unclip_ratio(cls, v):
+ if v is None:
+ return v
+
+ def _validate_ratio_value(value, context=""):
+ if isinstance(value, (int, float)):
+ if value <= 0:
+ raise ValueError(
+ f"`layoutUnclipRatio`{context} must be > 0; got: {value}"
+ )
+ elif isinstance(value, list):
+ if len(value) != 2:
+ raise ValueError(
+ f"`layoutUnclipRatio`{context} must be two numbers; got: {len(value)} values"
+ )
+ for i, item in enumerate(value):
+ if not isinstance(item, (int, float)):
+ raise ValueError(
+ f"`layoutUnclipRatio`{context} values must be numbers; got: {type(item).__name__} at position {i}"
+ )
+ if item <= 0:
+ raise ValueError(
+ f"`layoutUnclipRatio`{context} values must be > 0; got: {item} at position {i}"
+ )
+ else:
+ raise ValueError(
+ f"`layoutUnclipRatio`{context} must be a number or two numbers; got: {type(value).__name__}"
+ )
+
+ if isinstance(v, dict):
+ for key, value in v.items():
+ _validate_ratio_value(value, f" value for key '{key}'")
+ else:
+ _validate_ratio_value(v)
+
+ return v
+
+ @field_validator("layoutThreshold")
+ @classmethod
+ def validate_threshold(cls, v):
+ if v is None:
+ return v
+
+ def _validate_threshold_value(value, context=""):
+ if not isinstance(value, (int, float)):
+ raise ValueError(
+ f"`layoutThreshold`{context} must be a number; got: {type(value).__name__}"
+ )
+ if value < 0 or value > 1:
+ raise ValueError(
+ f"`layoutThreshold`{context} must be between 0 and 1 inclusive; got: {value}"
+ )
+
+ if isinstance(v, dict):
+ for key, value in v.items():
+ _validate_threshold_value(value, f" value for key '{key}'")
+ else:
+ _validate_threshold_value(v)
+
+ return v
+
+ @model_validator(mode="after")
+ def validate_pixel_range(self):
+ if self.minPixels is not None and self.maxPixels is not None:
+ if self.minPixels > self.maxPixels:
+ raise ValueError(
+ f"`minPixels` ({self.minPixels}) cannot be greater than `maxPixels` ({self.maxPixels})"
+ )
+ return self
class MarkdownData(BaseModel):
@@ -68,6 +223,30 @@ class InferResult(BaseModel):
dataInfo: DataInfo
+class Page(BaseModel):
+ prunedResult: dict
+ markdownImages: Optional[Dict[str, str]] = None
+
+
+class RestructurePagesRequest(BaseModel):
+ pages: List[Page]
+ mergeTables: bool = True
+ relevelTitles: bool = True
+ concatenatePages: bool = False
+ prettifyMarkdown: bool = True
+ showFormulaNumber: bool = False
+ logId: Optional[str] = None
+
+
+class RestructurePagesResult(BaseModel):
+ layoutParsingResults: List[LayoutParsingResult]
+
+
PRIMARY_OPERATIONS: Final[PrimaryOperations] = {
"infer": (INFER_ENDPOINT, InferRequest, InferResult),
+ "restructure-pages": (
+ RESTRUCTURE_PAGES_ENDPOINT,
+ RestructurePagesRequest,
+ RestructurePagesResult,
+ ),
}
diff --git a/paddlex/inference/serving/schemas/pp_structurev3.py b/paddlex/inference/serving/schemas/pp_structurev3.py
index 9bf1134b49..b1dd9b08bb 100644
--- a/paddlex/inference/serving/schemas/pp_structurev3.py
+++ b/paddlex/inference/serving/schemas/pp_structurev3.py
@@ -62,7 +62,11 @@ class InferRequest(ocr.BaseInferRequest):
useOcrResultsWithTableCells: bool = True
useE2eWiredTableRecModel: bool = False
useE2eWirelessTableRecModel: bool = True
+ markdownIgnoreLabels: Optional[List[str]] = None
+ prettifyMarkdown: bool = True
+ showFormulaNumber: bool = False
visualize: Optional[bool] = None
+ logId: Optional[str] = None
class LayoutParsingResult(BaseModel):
diff --git a/paddlex/inference/utils/benchmark.py b/paddlex/inference/utils/benchmark.py
index 55f1eefc37..c1afa89b41 100644
--- a/paddlex/inference/utils/benchmark.py
+++ b/paddlex/inference/utils/benchmark.py
@@ -627,6 +627,10 @@ def set_inference_operations(val):
_inference_operations = val
+def add_inference_operations(*ops):
+ _inference_operations.extend(ops)
+
+
if INFER_BENCHMARK or PIPELINE_BENCHMARK:
benchmark = Benchmark(enabled=True)
else:
diff --git a/paddlex/inference/utils/hpi.py b/paddlex/inference/utils/hpi.py
index 613fe4a293..ec8e958654 100644
--- a/paddlex/inference/utils/hpi.py
+++ b/paddlex/inference/utils/hpi.py
@@ -24,6 +24,7 @@
from pydantic import BaseModel, Field
from typing_extensions import Annotated, TypeAlias
+from ...utils import logging
from ...utils.deps import function_requires_deps, is_paddle2onnx_plugin_available
from ...utils.env import get_paddle_cuda_version, get_paddle_version
from ...utils.flags import USE_PIR_TRT
@@ -156,6 +157,14 @@ def suggest_inference_backend_and_config(
return None, f"Inference backend {repr(hpi_config.backend)} is unavailable."
paddle_version = get_paddle_version()
+
+ if paddle_version[:3] >= (3, 1, 0):
+ logging.debug(
+ "Paddle version %s is not supported yet. The prior knowledge of Paddle 3.1.1 will be used.",
+ paddle_version,
+ )
+ paddle_version = (3, 1, 1, None)
+
if (3, 0) <= paddle_version[:2] <= (3, 1) and paddle_version[3] is None:
if paddle_version[2] == 0:
paddle_version = f"paddle{paddle_version[0]}{paddle_version[1]}"
diff --git a/paddlex/inference/utils/hpi_model_info_collection.json b/paddlex/inference/utils/hpi_model_info_collection.json
index 78835aa809..a9241ea6bf 100644
--- a/paddlex/inference/utils/hpi_model_info_collection.json
+++ b/paddlex/inference/utils/hpi_model_info_collection.json
@@ -5135,7 +5135,6 @@
"onnxruntime"
],
"PP-OCRv4_server_det": [
- "tensorrt",
"onnxruntime",
"paddle"
],
@@ -5822,7 +5821,6 @@
"paddle"
],
"PP-OCRv5_server_det": [
- "tensorrt",
"paddle"
],
"PP-OCRv5_mobile_det": [
@@ -6563,7 +6561,6 @@
"onnxruntime"
],
"PP-OCRv4_server_det": [
- "tensorrt",
"onnxruntime",
"paddle"
],
@@ -7258,7 +7255,6 @@
"paddle"
],
"PP-OCRv5_server_det": [
- "tensorrt",
"onnxruntime",
"paddle"
],
@@ -8005,7 +8001,6 @@
"onnxruntime"
],
"PP-OCRv4_server_det": [
- "tensorrt",
"onnxruntime",
"paddle"
],
@@ -8699,7 +8694,6 @@
"paddle"
],
"PP-OCRv5_server_det": [
- "tensorrt",
"onnxruntime",
"paddle"
],
@@ -11850,6 +11844,10 @@
"onnxruntime",
"paddle"
],
+ "eslav_PP-OCRv5_mobile_rec": [
+ "onnxruntime",
+ "paddle"
+ ],
"arabic_PP-OCRv5_mobile_rec": [
"onnxruntime",
"paddle"
diff --git a/paddlex/inference/utils/io/__init__.py b/paddlex/inference/utils/io/__init__.py
index 8b66633b00..2fa44ae29f 100644
--- a/paddlex/inference/utils/io/__init__.py
+++ b/paddlex/inference/utils/io/__init__.py
@@ -24,6 +24,7 @@
YAMLReader,
)
from .writers import (
+ AudioWriter,
CSVWriter,
HtmlWriter,
ImageWriter,
diff --git a/paddlex/inference/utils/io/readers.py b/paddlex/inference/utils/io/readers.py
index ec22d11d22..322fbfc233 100644
--- a/paddlex/inference/utils/io/readers.py
+++ b/paddlex/inference/utils/io/readers.py
@@ -28,6 +28,7 @@
import cv2
if is_dep_available("pypdfium2"):
import pypdfium2 as pdfium
+ from ..pdfium_lock import pdfium_lock
if is_dep_available("soundfile"):
import soundfile
@@ -102,7 +103,10 @@ def __init__(self, backend="pypdfium2", **bk_args):
super().__init__(backend, **bk_args)
def read(self, in_path):
- yield from self._backend.read_file(str(in_path))
+ yield from self._backend.read_file(in_path)
+
+ def load(self, in_path):
+ return self._backend.load_file(str(in_path))
def _init_backend(self, bk_type, bk_args):
return PDFReaderBackend(**bk_args)
@@ -291,13 +295,26 @@ def __init__(self, rotate=0, zoom=2.0):
self._rotation = rotate
self._scale = zoom
+ def load_file(self, in_path):
+ """load pdf file"""
+ with pdfium_lock:
+ doc = pdfium.PdfDocument(in_path)
+ doc.init_forms()
+ return doc
+
def read_file(self, in_path):
- doc = pdfium.PdfDocument(in_path)
- try:
- for page in doc:
- yield page.render(scale=self._scale, rotation=self._rotation).to_numpy()
- finally:
- doc.close()
+ with pdfium_lock:
+ if isinstance(in_path, pdfium.PdfDocument):
+ doc = in_path
+ else:
+ doc = self.load_file(str(in_path))
+ try:
+ for page in doc:
+ image = page.render(scale=self._scale, rotation=self._rotation).to_numpy()
+ page.close()
+ yield image
+ finally:
+ doc.close()
class TXTReaderBackend(_BaseReaderBackend):
diff --git a/paddlex/inference/utils/io/writers.py b/paddlex/inference/utils/io/writers.py
index 865e87ad56..824aea344c 100644
--- a/paddlex/inference/utils/io/writers.py
+++ b/paddlex/inference/utils/io/writers.py
@@ -28,6 +28,9 @@
if is_dep_available("opencv-contrib-python"):
import cv2
+if is_dep_available("soundfile"):
+ import soundfile as sf
+
__all__ = [
"WriterType",
@@ -56,6 +59,7 @@ class WriterType(enum.Enum):
YAML = 8
MARKDOWN = 9
TXT = 10
+ AUDIO = 11
class _BaseWriter(object):
@@ -261,6 +265,29 @@ def get_type(self):
return WriterType.MARKDOWN
+class AudioWriter(_BaseWriter):
+ """AudioWriter"""
+
+ def __init__(self, sample_rate=24000, backend="wav", **bk_args):
+ super().__init__(sample_rate=sample_rate, backend=backend, **bk_args)
+ self.sample_rate = sample_rate
+
+ def write(self, out_path, obj):
+ """write"""
+ return self._backend.write_obj(str(out_path), obj)
+
+ def _init_backend(self, bk_type, bk_args):
+ """init backend"""
+ if bk_type == "wav":
+ return AudioWriterBackend(**bk_args)
+ else:
+ raise ValueError("Unsupported backend type")
+
+ def get_type(self):
+ """get type"""
+ return WriterType.AUDIO
+
+
class _BaseWriterBackend(object):
"""_BaseWriterBackend"""
@@ -458,3 +485,16 @@ def _write_obj(self, out_path, obj):
"""write markdown obj"""
with open(out_path, mode="w", encoding="utf-8", errors="replace") as f:
f.write(obj)
+
+
+class AudioWriterBackend(_BaseWriterBackend):
+ """AudioWriterBackend"""
+
+ def __init__(self, sample_rate=24000):
+ super().__init__()
+ self.sample_rate = sample_rate
+
+ def _write_obj(self, out_path, obj):
+ """write audio obj"""
+ audio = obj["result"]
+ sf.write(out_path, audio, self.sample_rate)
diff --git a/paddlex/inference/utils/misc.py b/paddlex/inference/utils/misc.py
index bb6fe29ad2..4451098392 100644
--- a/paddlex/inference/utils/misc.py
+++ b/paddlex/inference/utils/misc.py
@@ -31,4 +31,23 @@ def is_bfloat16_available(device):
device_type, _ = parse_device(device)
return (
"npu" in get_device_type() or paddle.amp.is_bfloat16_supported()
- ) and device_type in ("gpu", "npu", "xpu", "mlu")
+ ) and device_type in ("gpu", "npu", "xpu", "mlu", "metax_gpu", "iluvatar_gpu")
+
+
+def is_float16_available(device):
+ import paddle.amp
+
+ if device is None:
+ device = get_default_device()
+ device_type, _ = parse_device(device)
+ return (
+ "npu" in get_device_type() or paddle.amp.is_float16_supported()
+ ) and device_type in (
+ "gpu",
+ "npu",
+ "xpu",
+ "mlu",
+ "dcu",
+ "metax_gpu",
+ "iluvatar_gpu",
+ )
diff --git a/paddlex/inference/utils/mkldnn_blocklist.py b/paddlex/inference/utils/mkldnn_blocklist.py
index 972a98f961..dfe4c8d72d 100644
--- a/paddlex/inference/utils/mkldnn_blocklist.py
+++ b/paddlex/inference/utils/mkldnn_blocklist.py
@@ -56,4 +56,6 @@
"PP-FormulaNet_plus-L",
"PP-FormulaNet_plus-M",
"PP-FormulaNet_plus-S",
+ "PP-DocLayoutV2",
+ "PP-DocLayoutV3",
]
diff --git a/paddlex/inference/utils/model_paths.py b/paddlex/inference/utils/model_paths.py
index aad436e0eb..891c563024 100644
--- a/paddlex/inference/utils/model_paths.py
+++ b/paddlex/inference/utils/model_paths.py
@@ -23,6 +23,8 @@ class ModelPaths(TypedDict, total=False):
paddle: Tuple[Path, Path]
onnx: Path
om: Path
+ paddle_dyn: Path
+ safetensors: Path
def get_model_paths(
@@ -45,4 +47,8 @@ def get_model_paths(
model_paths["onnx"] = model_dir / f"{model_file_prefix}.onnx"
if (model_dir / f"{model_file_prefix}.om").exists():
model_paths["om"] = model_dir / f"{model_file_prefix}.om"
+ if (model_dir / "model_state.pdparams").exists():
+ model_paths["paddle_dyn"] = model_dir / "model_state.pdparams"
+ if (model_dir / "model.safetensors").exists():
+ model_paths["safetensors"] = model_dir / "model.safetensors"
return model_paths
diff --git a/paddlex/inference/utils/official_models.py b/paddlex/inference/utils/official_models.py
index 98447af01d..efb0d3c29d 100644
--- a/paddlex/inference/utils/official_models.py
+++ b/paddlex/inference/utils/official_models.py
@@ -31,7 +31,7 @@
from ...utils import logging
from ...utils.cache import CACHE_DIR
from ...utils.download import download_and_extract
-from ...utils.flags import MODEL_SOURCE
+from ...utils.flags import DISABLE_MODEL_SOURCE_CHECK, MODEL_SOURCE, HUGGING_FACE_ENDPOINT
ALL_MODELS = [
"ResNet18",
@@ -322,6 +322,9 @@
"ta_PP-OCRv5_mobile_rec",
"devanagari_PP-OCRv5_mobile_rec",
"cyrillic_PP-OCRv5_mobile_rec",
+ "G2PWModel",
+ "fastspeech2_csmsc",
+ "pwgan_csmsc",
]
@@ -478,12 +481,12 @@ def _download(self, model_name, save_dir):
class _HuggingFaceModelHoster(_BaseModelHoster):
model_list = OCR_MODELS
alias = "huggingface"
- healthcheck_url = "https://huggingface.co"
+ healthcheck_url = HUGGING_FACE_ENDPOINT
def _download(self, model_name, save_dir):
def _clone(local_dir):
hf_hub.snapshot_download(
- repo_id=f"PaddlePaddle/{model_name}", local_dir=local_dir
+ repo_id=f"PaddlePaddle/{model_name}", local_dir=local_dir, endpoint=HUGGING_FACE_ENDPOINT
)
if os.path.exists(save_dir):
@@ -541,18 +544,35 @@ def _clone(local_dir):
class _ModelManager:
model_list = ALL_MODELS
_save_dir = Path(CACHE_DIR) / "official_models"
+ hoster_candidates = [
+ _HuggingFaceModelHoster,
+ _AIStudioModelHoster,
+ _ModelScopeModelHoster,
+ _BosModelHoster,
+ ]
def __init__(self) -> None:
self._hosters = self._build_hosters()
def _build_hosters(self):
+
+ if DISABLE_MODEL_SOURCE_CHECK:
+ logging.warning(
+ f"Connectivity check to the model hoster has been skipped because `PADDLE_PDX_DISABLE_MODEL_SOURCE_CHECK` is enabled."
+ )
+ hosters = []
+ for hoster_cls in self.hoster_candidates:
+ if hoster_cls.alias == MODEL_SOURCE:
+ hosters.insert(0, hoster_cls(self._save_dir))
+ else:
+ hosters.append(hoster_cls(self._save_dir))
+ return hosters
+
+ logging.warning(
+ f"Checking connectivity to the model hosters, this may take a while. To bypass this check, set `PADDLE_PDX_DISABLE_MODEL_SOURCE_CHECK` to `True`."
+ )
hosters = []
- for hoster_cls in [
- _HuggingFaceModelHoster,
- _AIStudioModelHoster,
- _ModelScopeModelHoster,
- _BosModelHoster,
- ]:
+ for hoster_cls in self.hoster_candidates:
if hoster_cls.alias == MODEL_SOURCE:
if hoster_cls.is_available():
hosters.insert(0, hoster_cls(self._save_dir))
@@ -561,7 +581,7 @@ def _build_hosters(self):
hosters.append(hoster_cls(self._save_dir))
if len(hosters) == 0:
logging.warning(
- f"No model hoster is available! Please check your network connection to one of the following model hosts: HuggingFace ({_HuggingFaceModelHoster.healthcheck_url}), ModelScope ({_ModelScopeModelHoster.healthcheck_url}), AIStudio ({_AIStudioModelHoster.healthcheck_url}), or BOS ({_BosModelHoster.healthcheck_url}). Otherwise, only local models can be used."
+ f"No model hoster is available! Please check your network connection to one of the following model hoster: HuggingFace ({_HuggingFaceModelHoster.healthcheck_url}), ModelScope ({_ModelScopeModelHoster.healthcheck_url}), AIStudio ({_AIStudioModelHoster.healthcheck_url}), or BOS ({_BosModelHoster.healthcheck_url}). Otherwise, only local models can be used."
)
return hosters
diff --git a/paddlex/inference/utils/pdfium_lock.py b/paddlex/inference/utils/pdfium_lock.py
new file mode 100644
index 0000000000..7e76d74a2a
--- /dev/null
+++ b/paddlex/inference/utils/pdfium_lock.py
@@ -0,0 +1,31 @@
+# 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.
+
+"""
+Global lock for pypdfium2 operations.
+
+PDFium is inherently not thread-safe. It is not allowed to call pdfium
+functions simultaneously across different threads, not even with different
+documents. Simultaneous pdfium calls across threads will crash or corrupt
+the process.
+
+See: https://pypdfium2.readthedocs.io/en/stable/python_api.html
+
+This module provides a global lock that must be used to serialize all
+pypdfium2 operations across the application.
+"""
+
+import threading
+
+pdfium_lock = threading.Lock()
diff --git a/paddlex/inference/utils/pp_option.py b/paddlex/inference/utils/pp_option.py
index 07c7a0b91e..366174c7c9 100644
--- a/paddlex/inference/utils/pp_option.py
+++ b/paddlex/inference/utils/pp_option.py
@@ -18,7 +18,7 @@
from ...utils import logging
from ...utils.device import get_default_device, parse_device, set_env_for_device_type
-from ...utils.flags import ENABLE_MKLDNN_BYDEFAULT, USE_PIR_TRT, DISABLE_DEVICE_FALLBACK
+from ...utils.flags import DISABLE_DEVICE_FALLBACK, ENABLE_MKLDNN_BYDEFAULT, USE_PIR_TRT
from .misc import is_mkldnn_available
from .mkldnn_blocklist import MKLDNN_BLOCKLIST
from .new_ir_blocklist import NEWIR_BLOCKLIST
@@ -54,7 +54,17 @@ class PaddlePredictorOption(object):
"mkldnn",
"mkldnn_bf16",
)
- SUPPORT_DEVICE = ("gpu", "cpu", "npu", "xpu", "mlu", "dcu", "gcu", "iluvatar_gpu")
+ SUPPORT_DEVICE = (
+ "gpu",
+ "cpu",
+ "npu",
+ "xpu",
+ "mlu",
+ "dcu",
+ "gcu",
+ "iluvatar_gpu",
+ "metax_gpu",
+ )
def __init__(self, **kwargs):
super().__init__()
@@ -84,7 +94,10 @@ def setdefault_by_model_name(self, model_name):
if self.device_type == "gpu":
import paddle
- if not (paddle.device.is_compiled_with_cuda() and paddle.device.cuda.device_count() > 0):
+ if not (
+ paddle.device.is_compiled_with_cuda()
+ and paddle.device.cuda.device_count() > 0
+ ):
if DISABLE_DEVICE_FALLBACK:
raise RuntimeError(
"Device fallback is disabled and the specified device (GPU) is not available. "
diff --git a/paddlex/inference/utils/trt_config.py b/paddlex/inference/utils/trt_config.py
index 2625c57f8c..4b04a95bfe 100644
--- a/paddlex/inference/utils/trt_config.py
+++ b/paddlex/inference/utils/trt_config.py
@@ -406,6 +406,9 @@ def _load(self):
"PP-YOLOE_plus-M": {
"ops_run_float": {"pd_op.conv2d", "pd_op.fused_conv2d_add_act"}
},
+ "RT-DETR-X": {
+ "disable_ops": ["pd_op.flip"],
+ },
}
diff --git a/paddlex/modules/__init__.py b/paddlex/modules/__init__.py
index ca3370d812..b7078283e9 100644
--- a/paddlex/modules/__init__.py
+++ b/paddlex/modules/__init__.py
@@ -88,6 +88,24 @@
TextRecExportor,
TextRecTrainer,
)
+from .text_to_pinyin import (
+ TextToPinyinDatasetChecker,
+ TextToPinyinEvaluator,
+ TextToPinyinExportor,
+ TextToPinyinTrainer,
+)
+from .text_to_speech_acoustic import (
+ TextToSpeechAcousticDatasetChecker,
+ TextToSpeechAcousticEvaluator,
+ TextToSpeechAcousticExportor,
+ TextToSpeechAcousticTrainer,
+)
+from .text_to_speech_vocoder import (
+ TextToSpeechVocoderDatasetChecker,
+ TextToSpeechVocoderEvaluator,
+ TextToSpeechVocoderExportor,
+ TextToSpeechVocoderTrainer,
+)
from .ts_anomaly_detection import (
TSADDatasetChecker,
TSADEvaluator,
diff --git a/paddlex/modules/base/build_model.py b/paddlex/modules/base/build_model.py
index 32b1b96e72..1e828a9815 100644
--- a/paddlex/modules/base/build_model.py
+++ b/paddlex/modules/base/build_model.py
@@ -21,7 +21,7 @@ def build_model(model_name: str, config_path: str = None) -> tuple:
Args:
model_name (str): model name
- device (str): device, such as gpu, cpu, npu, xpu, mlu, gcu
+ device (str): device, such as gpu, cpu, npu, xpu, mlu, gcu, metax_gpu
config_path (str, optional): path to the PaddleX config yaml file.
Defaults to None, i.e. using the default config file.
diff --git a/paddlex/modules/doc_vlm/model_list.py b/paddlex/modules/doc_vlm/model_list.py
index c09af0b36f..9475bec31b 100644
--- a/paddlex/modules/doc_vlm/model_list.py
+++ b/paddlex/modules/doc_vlm/model_list.py
@@ -19,4 +19,5 @@
"PP-Chart2Table",
"PP-DocBee2-3B",
"PaddleOCR-VL-0.9B",
+ "PaddleOCR-VL-1.5-0.9B",
]
diff --git a/paddlex/modules/object_detection/model_list.py b/paddlex/modules/object_detection/model_list.py
index 0df27337fb..08569877d0 100644
--- a/paddlex/modules/object_detection/model_list.py
+++ b/paddlex/modules/object_detection/model_list.py
@@ -83,5 +83,6 @@
"PP-DocLayout-S",
"PP-DocLayout_plus-L",
"PP-DocBlockLayout",
- "PP-DocLayoutV2",
]
+
+LAYOUTANALYSIS_MODELS = ["PP-DocLayoutV2", "PP-DocLayoutV3"]
diff --git a/paddlex/modules/text_recognition/model_list.py b/paddlex/modules/text_recognition/model_list.py
index 5976e4b5dd..3a6236871b 100644
--- a/paddlex/modules/text_recognition/model_list.py
+++ b/paddlex/modules/text_recognition/model_list.py
@@ -43,5 +43,5 @@
"cyrillic_PP-OCRv5_mobile_rec",
"devanagari_PP-OCRv5_mobile_rec",
"ta_PP-OCRv5_mobile_rec",
- "te_PP-OCRv5_mobile_rec"
+ "te_PP-OCRv5_mobile_rec",
]
diff --git a/paddlex/modules/text_to_pinyin/__init__.py b/paddlex/modules/text_to_pinyin/__init__.py
new file mode 100644
index 0000000000..18848cb9ed
--- /dev/null
+++ b/paddlex/modules/text_to_pinyin/__init__.py
@@ -0,0 +1,18 @@
+# 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 .dataset_checker import TextToPinyinDatasetChecker
+from .evaluator import TextToPinyinEvaluator
+from .exportor import TextToPinyinExportor
+from .trainer import TextToPinyinTrainer
diff --git a/paddlex/modules/text_to_pinyin/dataset_checker.py b/paddlex/modules/text_to_pinyin/dataset_checker.py
new file mode 100644
index 0000000000..d5f2b78d24
--- /dev/null
+++ b/paddlex/modules/text_to_pinyin/dataset_checker.py
@@ -0,0 +1,27 @@
+# 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 ...utils.errors import UnsupportedAPIError
+from ..base import BaseDatasetChecker
+from .model_list import MODELS
+
+
+class TextToPinyinDatasetChecker(BaseDatasetChecker):
+ """Dataset Checker for G2PWModel Model"""
+
+ entities = MODELS
+
+ def __init__(self, config):
+ # not support for now
+ raise UnsupportedAPIError("G2PWModel model not support data check for now.")
diff --git a/paddlex/modules/text_to_pinyin/evaluator.py b/paddlex/modules/text_to_pinyin/evaluator.py
new file mode 100644
index 0000000000..719bf3483e
--- /dev/null
+++ b/paddlex/modules/text_to_pinyin/evaluator.py
@@ -0,0 +1,27 @@
+# Copyright (c) 2025 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 ...utils.errors import UnsupportedAPIError
+from ..base import BaseEvaluator
+from .model_list import MODELS
+
+
+class TextToPinyinEvaluator(BaseEvaluator):
+ """Instance G2PWModel Model Evaluator"""
+
+ entities = MODELS
+
+ def __init__(self, config):
+ # not support for now
+ raise UnsupportedAPIError("G2PWModel model not support evaluate for now.")
diff --git a/paddlex/modules/text_to_pinyin/exportor.py b/paddlex/modules/text_to_pinyin/exportor.py
new file mode 100644
index 0000000000..cac6a15ec0
--- /dev/null
+++ b/paddlex/modules/text_to_pinyin/exportor.py
@@ -0,0 +1,27 @@
+# Copyright (c) 2025 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 ...utils.errors import UnsupportedAPIError
+from ..base import BaseExportor
+from .model_list import MODELS
+
+
+class TextToPinyinExportor(BaseExportor):
+ """Instance G2PWModel Model Exportor"""
+
+ entities = MODELS
+
+ def __init__(self, config):
+ # not support for now
+ raise UnsupportedAPIError("G2PWModel model not support export for now.")
diff --git a/paddlex/modules/text_to_pinyin/model_list.py b/paddlex/modules/text_to_pinyin/model_list.py
new file mode 100644
index 0000000000..0c4129180f
--- /dev/null
+++ b/paddlex/modules/text_to_pinyin/model_list.py
@@ -0,0 +1,18 @@
+# Copyright (c) 2025 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.
+
+
+MODELS = [
+ "G2PWModel",
+]
diff --git a/paddlex/modules/text_to_pinyin/trainer.py b/paddlex/modules/text_to_pinyin/trainer.py
new file mode 100644
index 0000000000..4102cb1f4a
--- /dev/null
+++ b/paddlex/modules/text_to_pinyin/trainer.py
@@ -0,0 +1,40 @@
+# Copyright (c) 2025 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 ...utils.errors import UnsupportedAPIError
+from ..base import BaseTrainer
+from .model_list import MODELS
+
+
+class TextToPinyinTrainer(BaseTrainer):
+ """Instance G2PWModel Model Trainer"""
+
+ entities = MODELS
+
+ def __init__(self, config):
+ # not support for now
+ raise UnsupportedAPIError("G2PWModel model not support train for now.")
+
+ def update_config(self):
+ """update training config"""
+ pass
+
+ def get_train_kwargs(self) -> dict:
+ """get key-value arguments of model training function
+
+ Returns:
+ dict: the arguments of training function.
+ """
+ train_args = {"device": self.get_device()}
+ return train_args
diff --git a/paddlex/modules/text_to_speech_acoustic/__init__.py b/paddlex/modules/text_to_speech_acoustic/__init__.py
new file mode 100644
index 0000000000..da3a8e49ac
--- /dev/null
+++ b/paddlex/modules/text_to_speech_acoustic/__init__.py
@@ -0,0 +1,18 @@
+# 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 .dataset_checker import TextToSpeechAcousticDatasetChecker
+from .evaluator import TextToSpeechAcousticEvaluator
+from .exportor import TextToSpeechAcousticExportor
+from .trainer import TextToSpeechAcousticTrainer
diff --git a/paddlex/modules/text_to_speech_acoustic/dataset_checker.py b/paddlex/modules/text_to_speech_acoustic/dataset_checker.py
new file mode 100644
index 0000000000..fc44b619ca
--- /dev/null
+++ b/paddlex/modules/text_to_speech_acoustic/dataset_checker.py
@@ -0,0 +1,29 @@
+# Copyright (c) 2025 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 ...utils.errors import UnsupportedAPIError
+from ..base import BaseDatasetChecker
+from .model_list import MODELS
+
+
+class TextToSpeechAcousticDatasetChecker(BaseDatasetChecker):
+ """Dataset Checker for Fastspeech2 Model"""
+
+ entities = MODELS
+
+ def __init__(self, config):
+ # not support for now
+ raise UnsupportedAPIError(
+ "Fastspeech2Model model not support data check for now."
+ )
diff --git a/paddlex/modules/text_to_speech_acoustic/evaluator.py b/paddlex/modules/text_to_speech_acoustic/evaluator.py
new file mode 100644
index 0000000000..de8956ca17
--- /dev/null
+++ b/paddlex/modules/text_to_speech_acoustic/evaluator.py
@@ -0,0 +1,27 @@
+# Copyright (c) 2025 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 ...utils.errors import UnsupportedAPIError
+from ..base import BaseEvaluator
+from .model_list import MODELS
+
+
+class TextToSpeechAcousticEvaluator(BaseEvaluator):
+ """Instance Fastspeech2 Model Evaluator"""
+
+ entities = MODELS
+
+ def __init__(self, config):
+ # not support for now
+ raise UnsupportedAPIError("Fastspeech2 model not support evaluate for now.")
diff --git a/paddlex/modules/text_to_speech_acoustic/exportor.py b/paddlex/modules/text_to_speech_acoustic/exportor.py
new file mode 100644
index 0000000000..c475f903dc
--- /dev/null
+++ b/paddlex/modules/text_to_speech_acoustic/exportor.py
@@ -0,0 +1,27 @@
+# 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 ...utils.errors import UnsupportedAPIError
+from ..base import BaseExportor
+from .model_list import MODELS
+
+
+class TextToSpeechAcousticExportor(BaseExportor):
+ """Instance Fastspeech2Model Model Exportor"""
+
+ entities = MODELS
+
+ def __init__(self, config):
+ # not support for now
+ raise UnsupportedAPIError("Fastspeech2Model model not support export for now.")
diff --git a/paddlex/modules/text_to_speech_acoustic/model_list.py b/paddlex/modules/text_to_speech_acoustic/model_list.py
new file mode 100644
index 0000000000..e3527df335
--- /dev/null
+++ b/paddlex/modules/text_to_speech_acoustic/model_list.py
@@ -0,0 +1,17 @@
+# Copyright (c) 2025 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.
+
+MODELS = [
+ "fastspeech2_csmsc",
+]
diff --git a/paddlex/modules/text_to_speech_acoustic/trainer.py b/paddlex/modules/text_to_speech_acoustic/trainer.py
new file mode 100644
index 0000000000..b47a2b8951
--- /dev/null
+++ b/paddlex/modules/text_to_speech_acoustic/trainer.py
@@ -0,0 +1,40 @@
+# Copyright (c) 2025 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 ...utils.errors import UnsupportedAPIError
+from ..base import BaseTrainer
+from .model_list import MODELS
+
+
+class TextToSpeechAcousticTrainer(BaseTrainer):
+ """Instance Fastspeech2Model Model Trainer"""
+
+ entities = MODELS
+
+ def __init__(self, config):
+ # not support for now
+ raise UnsupportedAPIError("Fastspeech2Model model not support train for now.")
+
+ def update_config(self):
+ """update training config"""
+ pass
+
+ def get_train_kwargs(self) -> dict:
+ """get key-value arguments of model training function
+
+ Returns:
+ dict: the arguments of training function.
+ """
+ train_args = {"device": self.get_device()}
+ return train_args
diff --git a/paddlex/modules/text_to_speech_vocoder/__init__.py b/paddlex/modules/text_to_speech_vocoder/__init__.py
new file mode 100644
index 0000000000..1c8d4fd93f
--- /dev/null
+++ b/paddlex/modules/text_to_speech_vocoder/__init__.py
@@ -0,0 +1,18 @@
+# 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 .dataset_checker import TextToSpeechVocoderDatasetChecker
+from .evaluator import TextToSpeechVocoderEvaluator
+from .exportor import TextToSpeechVocoderExportor
+from .trainer import TextToSpeechVocoderTrainer
diff --git a/paddlex/modules/text_to_speech_vocoder/dataset_checker.py b/paddlex/modules/text_to_speech_vocoder/dataset_checker.py
new file mode 100644
index 0000000000..30e4d1528d
--- /dev/null
+++ b/paddlex/modules/text_to_speech_vocoder/dataset_checker.py
@@ -0,0 +1,29 @@
+# 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 ...utils.errors import UnsupportedAPIError
+from ..base import BaseDatasetChecker
+from .model_list import MODELS
+
+
+class TextToSpeechVocoderDatasetChecker(BaseDatasetChecker):
+ """Dataset Checker for Fastspeech2 Model"""
+
+ entities = MODELS
+
+ def __init__(self, config):
+ # not support for now
+ raise UnsupportedAPIError(
+ "Fastspeech2Model model not support data check for now."
+ )
diff --git a/paddlex/modules/text_to_speech_vocoder/evaluator.py b/paddlex/modules/text_to_speech_vocoder/evaluator.py
new file mode 100644
index 0000000000..de073b815b
--- /dev/null
+++ b/paddlex/modules/text_to_speech_vocoder/evaluator.py
@@ -0,0 +1,27 @@
+# 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 ...utils.errors import UnsupportedAPIError
+from ..base import BaseEvaluator
+from .model_list import MODELS
+
+
+class TextToSpeechVocoderEvaluator(BaseEvaluator):
+ """Instance PWGan Model Model Evaluator"""
+
+ entities = MODELS
+
+ def __init__(self, config):
+ # not support for now
+ raise UnsupportedAPIError("PWGan model not support evaluate for now.")
diff --git a/paddlex/modules/text_to_speech_vocoder/exportor.py b/paddlex/modules/text_to_speech_vocoder/exportor.py
new file mode 100644
index 0000000000..8339fb5659
--- /dev/null
+++ b/paddlex/modules/text_to_speech_vocoder/exportor.py
@@ -0,0 +1,27 @@
+# Copyright (c) 2025 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 ...utils.errors import UnsupportedAPIError
+from ..base import BaseExportor
+from .model_list import MODELS
+
+
+class TextToSpeechVocoderExportor(BaseExportor):
+ """Instance PWGanModel Model Exportor"""
+
+ entities = MODELS
+
+ def __init__(self, config):
+ # not support for now
+ raise UnsupportedAPIError("PWGanModel model not support export for now.")
diff --git a/paddlex/modules/text_to_speech_vocoder/model_list.py b/paddlex/modules/text_to_speech_vocoder/model_list.py
new file mode 100644
index 0000000000..0f3eccef75
--- /dev/null
+++ b/paddlex/modules/text_to_speech_vocoder/model_list.py
@@ -0,0 +1,17 @@
+# Copyright (c) 2025 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.
+
+MODELS = [
+ "pwgan_csmsc",
+]
diff --git a/paddlex/modules/text_to_speech_vocoder/trainer.py b/paddlex/modules/text_to_speech_vocoder/trainer.py
new file mode 100644
index 0000000000..2833b61b00
--- /dev/null
+++ b/paddlex/modules/text_to_speech_vocoder/trainer.py
@@ -0,0 +1,40 @@
+# Copyright (c) 2025 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 ...utils.errors import UnsupportedAPIError
+from ..base import BaseTrainer
+from .model_list import MODELS
+
+
+class TextToSpeechVocoderTrainer(BaseTrainer):
+ """Instance PWGanModel Model Trainer"""
+
+ entities = MODELS
+
+ def __init__(self, config):
+ # not support for now
+ raise UnsupportedAPIError("PWGanModel model not support train for now.")
+
+ def update_config(self):
+ """update training config"""
+ pass
+
+ def get_train_kwargs(self) -> dict:
+ """get key-value arguments of model training function
+
+ Returns:
+ dict: the arguments of training function.
+ """
+ train_args = {"device": self.get_device()}
+ return train_args
diff --git a/paddlex/paddlex_cli.py b/paddlex/paddlex_cli.py
index e80c5e4e22..78222f32d3 100644
--- a/paddlex/paddlex_cli.py
+++ b/paddlex/paddlex_cli.py
@@ -324,9 +324,6 @@ def _install_hpi_deps(device_type):
)
def _install_genai_deps(plugin_types):
- if not is_cuda_available():
- sys.exit("Currently, only GPU devices are supported.")
-
fd_plugin_types = []
not_fd_plugin_types = []
for plugin_type in plugin_types:
@@ -372,21 +369,24 @@ def _install_genai_deps(plugin_types):
for plugin_type in plugin_types:
if "vllm" in plugin_type or "sglang" in plugin_type:
- try:
- install_packages(["wheel"], constraints="required")
- cap = get_gpu_compute_capability()
- if cap >= (12, 0):
- install_packages(
- ["xformers", "flash-attn == 2.8.3"], constraints="required"
- )
- else:
- install_packages(
- ["xformers", "flash-attn == 2.8.2"], constraints="required"
- )
- except Exception:
- logging.error("Installation failed", exc_info=True)
- sys.exit(1)
- break
+ install_packages(["xformers"], constraints="required")
+ if is_cuda_available():
+ try:
+ install_packages(["wheel"], constraints="required")
+ cap = get_gpu_compute_capability()
+ assert cap is not None
+ if cap >= (12, 0):
+ install_packages(
+ ["flash-attn == 2.8.3"], constraints="required"
+ )
+ else:
+ install_packages(
+ ["flash-attn == 2.8.2"], constraints="required"
+ )
+ except Exception:
+ logging.error("Installation failed", exc_info=True)
+ sys.exit(1)
+ break
logging.info(
"Successfully installed the generative AI plugin"
diff --git a/paddlex/repo_apis/PaddleDetection_api/instance_seg/config.py b/paddlex/repo_apis/PaddleDetection_api/instance_seg/config.py
index bd916fc1f6..700512f70b 100644
--- a/paddlex/repo_apis/PaddleDetection_api/instance_seg/config.py
+++ b/paddlex/repo_apis/PaddleDetection_api/instance_seg/config.py
@@ -273,6 +273,9 @@ def update_device(self, device_type: str):
elif device_type.lower() == "gcu":
self["use_gcu"] = True
self["use_gpu"] = False
+ elif device_type.lower() == "metax_gpu":
+ self["use_metax_gpu"] = True
+ self["use_gpu"] = False
else:
assert device_type.lower() == "cpu"
self["use_gpu"] = False
diff --git a/paddlex/repo_apis/PaddleDetection_api/object_det/config.py b/paddlex/repo_apis/PaddleDetection_api/object_det/config.py
index 026be3aa22..8285bda439 100644
--- a/paddlex/repo_apis/PaddleDetection_api/object_det/config.py
+++ b/paddlex/repo_apis/PaddleDetection_api/object_det/config.py
@@ -294,6 +294,9 @@ def update_device(self, device_type: str):
elif device_type.lower() == "gcu":
self["use_gcu"] = True
self["use_gpu"] = False
+ elif device_type.lower() == "metax_gpu":
+ self["use_metax_gpu"] = True
+ self["use_gpu"] = False
else:
assert device_type.lower() == "cpu"
self["use_gpu"] = False
diff --git a/paddlex/repo_apis/PaddleOCR_api/formula_rec/config.py b/paddlex/repo_apis/PaddleOCR_api/formula_rec/config.py
index 57e8e4f7b8..11d67d2393 100644
--- a/paddlex/repo_apis/PaddleOCR_api/formula_rec/config.py
+++ b/paddlex/repo_apis/PaddleOCR_api/formula_rec/config.py
@@ -238,6 +238,7 @@ def update_device(self, device: str):
"Global.use_npu": False,
"Global.use_mlu": False,
"Global.use_gcu": False,
+ "Global.use_metax_gpu": False,
}
device_cfg = {
@@ -247,6 +248,7 @@ def update_device(self, device: str):
"mlu": {"Global.use_mlu": True},
"npu": {"Global.use_npu": True},
"gcu": {"Global.use_gcu": True},
+ "metax_gpu": {"Global.use_metax_gpu": True},
}
default_cfg.update(device_cfg[device])
self.update(default_cfg)
diff --git a/paddlex/repo_apis/PaddleOCR_api/text_rec/config.py b/paddlex/repo_apis/PaddleOCR_api/text_rec/config.py
index 92dcc172d3..3c3fdb8c1a 100644
--- a/paddlex/repo_apis/PaddleOCR_api/text_rec/config.py
+++ b/paddlex/repo_apis/PaddleOCR_api/text_rec/config.py
@@ -250,6 +250,7 @@ def update_device(self, device: str):
"Global.use_mlu": False,
"Global.use_gcu": False,
"Global.use_iluvatar_gpu": False,
+ "Global.use_metax_gpu": False,
}
device_cfg = {
@@ -260,6 +261,7 @@ def update_device(self, device: str):
"npu": {"Global.use_npu": True},
"gcu": {"Global.use_gcu": True},
"iluvatar_gpu": {"Global.use_iluvatar_gpu": True},
+ "metax_gpu": {"Global.use_metax_gpu": True},
}
default_cfg.update(device_cfg[device])
self.update(default_cfg)
diff --git a/paddlex/repo_apis/base/runner.py b/paddlex/repo_apis/base/runner.py
index 11722c254b..f9e11079ad 100644
--- a/paddlex/repo_apis/base/runner.py
+++ b/paddlex/repo_apis/base/runner.py
@@ -205,6 +205,8 @@ def distributed(self, device, ips=None, log_dir=None):
new_env["MLU_VISIBLE_DEVICES"] = dev_ids
elif device == "gcu":
new_env["TOPS_VISIBLE_DEVICES"] = dev_ids
+ elif device == "metax_gpu":
+ new_env["MACA_VISIBLE_DEVICES"] = dev_ids
else:
new_env["CUDA_VISIBLE_DEVICES"] = dev_ids
return args, new_env
diff --git a/paddlex/utils/custom_device_list.py b/paddlex/utils/custom_device_list.py
old mode 100644
new mode 100755
index 88abe61db9..de06b0110e
--- a/paddlex/utils/custom_device_list.py
+++ b/paddlex/utils/custom_device_list.py
@@ -311,3 +311,131 @@
"PP-OCRv4_mobile_rec",
"PP-OCRv4_server_rec",
]
+
+METAX_GPU_WHITELIST = [
+ "ConvNeXt_base_224",
+ "ConvNeXt_base_384",
+ "ConvNeXt_large_224",
+ "ConvNeXt_large_384",
+ "ConvNeXt_small",
+ "ConvNeXt_tiny",
+ "FasterNet-L",
+ "FasterNet-M",
+ "FasterNet-S",
+ "FasterNet-T0",
+ "FasterNet-T1",
+ "FasterNet-T2",
+ "PP-LCNet_x1_0_doc_ori",
+ "UVDoc",
+ "PP-DocBlockLayout",
+ "PP-DocLayout_plus-L",
+ "PP-LCNet_x1_0_textline_ori",
+ "PP-LCNet_x1_0_table_cls",
+ "PP-OCRv5_server_rec",
+ "PP-OCRv5_server_det",
+ "SLANeXt_wired",
+ "SLANet_plus",
+ "RT-DETR-L_wired_table_cell_det",
+ "RT-DETR-L_wireless_table_cell_det",
+ "PP-FormulaNet_plus-L",
+ "MobileNetV1_x0_25",
+ "MobileNetV1_x0_5",
+ "MobileNetV1_x0_75",
+ "MobileNetV1_x1_0",
+ "MobileNetV2_x0_25",
+ "MobileNetV2_x0_5",
+ "MobileNetV2_x1_0",
+ "MobileNetV2_x1_5",
+ "MobileNetV2_x2_0",
+ "MobileNetV3_large_x0_35",
+ "MobileNetV3_large_x0_5",
+ "MobileNetV3_large_x0_75",
+ "MobileNetV3_large_x1_0",
+ "MobileNetV3_large_x1_25",
+ "MobileNetV3_small_x0_35",
+ "MobileNetV3_small_x0_5",
+ "MobileNetV3_small_x0_75",
+ "MobileNetV3_small_x1_0",
+ "MobileNetV3_small_x1_25",
+ "MobileNetV4_conv_large",
+ "MobileNetV4_conv_medium",
+ "MobileNetV4_conv_small",
+ "PP-HGNet_base",
+ "PP-HGNet_small",
+ "PP-HGNet_tiny",
+ "PP-HGNetV2-B0",
+ "PP-HGNetV2-B1",
+ "PP-HGNetV2-B2",
+ "PP-HGNetV2-B3",
+ "PP-HGNetV2-B4",
+ "PP-HGNetV2-B5",
+ "PP-HGNetV2-B6",
+ "PP-LCNet_x0_25",
+ "PP-LCNet_x0_35",
+ "PP-LCNet_x0_5",
+ "PP-LCNet_x0_75",
+ "PP-LCNet_x1_0",
+ "PP-LCNet_x1_5",
+ "PP-LCNet_x2_0",
+ "PP-LCNet_x2_5",
+ "PP-LCNetV2_base",
+ "PP-LCNetV2_large",
+ "PP-LCNetV2_small",
+ "ResNet18_vd",
+ "ResNet18",
+ "ResNet34_vd",
+ "ResNet34",
+ "ResNet50_vd",
+ "ResNet50",
+ "ResNet101_vd",
+ "ResNet101",
+ "ResNet152_vd",
+ "ResNet152",
+ "ResNet200_vd",
+ "StarNet-S1",
+ "StarNet-S2",
+ "StarNet-S3",
+ "StarNet-S4",
+ "FCOS-ResNet50",
+ "PicoDet-L",
+ "PicoDet-M",
+ "PicoDet-S",
+ "PicoDet-XS",
+ "PP-YOLOE_plus-L",
+ "PP-YOLOE_plus-M",
+ "PP-YOLOE_plus-S",
+ "PP-YOLOE_plus-X",
+ "RT-DETR-H",
+ "RT-DETR-L",
+ "RT-DETR-R18",
+ "RT-DETR-R50",
+ "RT-DETR-X",
+ "PP-YOLOE-L_human",
+ "PP-YOLOE-S_human",
+ "PP-OCRv4_mobile_det",
+ "PP-OCRv4_server_det",
+ "PP-OCRv4_mobile_rec",
+ "PP-OCRv4_server_rec",
+ "PP-DocLayoutV2",
+ "PP-ShiTuV2_rec",
+ "PP-ShiTuV2_det",
+ "PP-OCRv5_mobile_det",
+ "PP-OCRv4_server_seal_det",
+ "SLANet",
+ "MobileFaceNet",
+ "PP-LCNet_x0_25_textline_ori",
+ "PP-LCNet_x1_0_ML",
+ "PP-LCNet_x1_0_pedestrian_attribute",
+ "PP-LCNet_x1_0_vehicle_attribute",
+ "PP-FormulaNet_plus-M",
+ "PicoDet_LCNet_x2_5_face",
+ "PP-YOLOE_plus_SOD-S",
+ "PP-TinyPose_128x96",
+ "PP-LiteSeg-T",
+ "GroundingDINO-T",
+ "STFPM",
+ "DLinear",
+ "AutoEncoder_ad",
+ "SAM-H_box",
+ "PP-YOLOE-S_vehicle",
+]
diff --git a/paddlex/utils/deps.py b/paddlex/utils/deps.py
index c1781308b8..cef9ff80ea 100644
--- a/paddlex/utils/deps.py
+++ b/paddlex/utils/deps.py
@@ -107,6 +107,8 @@ def is_dep_available(dep, /, check_version=False):
return importlib.util.find_spec("ultra_infer") is not None
elif dep == "fastdeploy":
return importlib.util.find_spec("fastdeploy") is not None
+ elif dep == "onnxruntime":
+ return importlib.util.find_spec("onnxruntime") is not None
version = get_dep_version(dep)
if version is None:
return False
@@ -308,7 +310,7 @@ def get_genai_fastdeploy_spec(device_type):
if device_type not in SUPPORTED_DEVICE_TYPES:
raise ValueError(f"Unsupported device type: {device_type}")
if device_type == "gpu":
- return "fastdeploy-gpu == 2.3.0rc0"
+ return "fastdeploy-gpu == 2.3.0"
else:
raise AssertionError
diff --git a/paddlex/utils/device.py b/paddlex/utils/device.py
index 04fa0537b8..e065febed0 100644
--- a/paddlex/utils/device.py
+++ b/paddlex/utils/device.py
@@ -19,13 +19,24 @@
from .custom_device_list import (
DCU_WHITELIST,
GCU_WHITELIST,
+ METAX_GPU_WHITELIST,
MLU_WHITELIST,
NPU_BLACKLIST,
XPU_WHITELIST,
)
from .flags import DISABLE_DEV_MODEL_WL
-SUPPORTED_DEVICE_TYPE = ["cpu", "gpu", "xpu", "npu", "mlu", "gcu", "dcu", "iluvatar_gpu"]
+SUPPORTED_DEVICE_TYPE = [
+ "cpu",
+ "gpu",
+ "xpu",
+ "npu",
+ "mlu",
+ "gcu",
+ "dcu",
+ "iluvatar_gpu",
+ "metax_gpu",
+]
def constr_device(device_type, device_ids):
@@ -116,6 +127,9 @@ def _set(envs):
"XPU_BLACK_LIST": "pad3d",
}
_set(envs)
+ if device_type.lower() == "metax_gpu":
+ envs = {"FLAGS_use_stride_kernel": "0"}
+ _set(envs)
if device_type.lower() == "mlu":
envs = {
"FLAGS_use_stride_kernel": "0",
@@ -142,6 +156,11 @@ def check_supported_device_type(device_type, model_name):
assert model_name in MLU_WHITELIST, (
f"The MLU device does not yet support `{model_name}` model!" + tips
)
+ elif device_type == "metax_gpu":
+ assert model_name in METAX_GPU_WHITELIST, (
+ f"The METAX_GPU device does not yet support `{model_name}` model!" + tips
+ )
+
elif device_type == "npu":
assert model_name not in NPU_BLACKLIST, (
f"The NPU device does not yet support `{model_name}` model!" + tips
diff --git a/paddlex/utils/env.py b/paddlex/utils/env.py
index 1991d0ec51..f42b0130c5 100644
--- a/paddlex/utils/env.py
+++ b/paddlex/utils/env.py
@@ -65,13 +65,18 @@ def is_cuda_available():
import paddle.device
# TODO: Check runtime availability
- return paddle.device.is_compiled_with_cuda()
+ return (
+ paddle.device.is_compiled_with_cuda() and not paddle.is_compiled_with_rocm()
+ )
else:
# If Paddle is unavailable, check GPU availability using PyTorch API.
require_deps("torch")
+
import torch.cuda
+ import torch.version
- return torch.cuda.is_available()
+ # Distinguish GPUs and DCUs by checking `torch.version.cuda`
+ return torch.cuda.is_available() and torch.version.cuda
def get_gpu_compute_capability():
@@ -85,6 +90,7 @@ def get_gpu_compute_capability():
else:
# If Paddle is unavailable, retrieve GPU compute capability from PyTorch instead.
require_deps("torch")
+
import torch.cuda
cap = torch.cuda.get_device_capability()
diff --git a/paddlex/utils/flags.py b/paddlex/utils/flags.py
index b49b2160e2..1fcf547335 100644
--- a/paddlex/utils/flags.py
+++ b/paddlex/utils/flags.py
@@ -66,7 +66,11 @@ def get_flag_from_env_var(name, default, format_func=str):
)
MODEL_SOURCE = os.environ.get("PADDLE_PDX_MODEL_SOURCE", "huggingface").lower()
+DISABLE_MODEL_SOURCE_CHECK = os.environ.get(
+ "PADDLE_PDX_DISABLE_MODEL_SOURCE_CHECK", False
+)
+HUGGING_FACE_ENDPOINT = os.environ.get("PADDLE_PDX_HUGGING_FACE_ENDPOINT", "https://huggingface.co")
# Inference Benchmark
INFER_BENCHMARK = get_flag_from_env_var("PADDLE_PDX_INFER_BENCHMARK", False)
diff --git a/paddlex/utils/pipeline_arguments.py b/paddlex/utils/pipeline_arguments.py
index ff31dc1eec..386cb02e08 100644
--- a/paddlex/utils/pipeline_arguments.py
+++ b/paddlex/utils/pipeline_arguments.py
@@ -805,4 +805,5 @@ def validator(cli_input: str) -> cli_expected_type:
],
"3d_bev_detection": None,
"multilingual_speech_recognition": None,
+ "text_to_speech": None,
}
diff --git a/paddlex/version.py b/paddlex/version.py
index 28e2296990..63e81e1e4e 100644
--- a/paddlex/version.py
+++ b/paddlex/version.py
@@ -14,16 +14,30 @@
import os
+import sys
__all__ = ["get_pdx_version", "get_version_dict", "show_versions"]
+def _get_package_dir():
+ """Get the paddlex package directory, compatible with PyInstaller."""
+ # When running in a PyInstaller bundle, sys._MEIPASS points to the
+ # temporary folder where the bundled files are extracted
+ if getattr(sys, "frozen", False) and hasattr(sys, "_MEIPASS"):
+ return os.path.join(sys._MEIPASS, "paddlex")
+ return os.path.dirname(__file__)
+
+
def get_pdx_version():
"""get_pdx_version"""
- with open(
- os.path.join(os.path.dirname(__file__), ".version"), "r", encoding="ascii"
- ) as fv:
- ver = fv.read().rstrip()
+ version_file = os.path.join(_get_package_dir(), ".version")
+ try:
+ with open(version_file, "r", encoding="ascii") as fv:
+ ver = fv.read().rstrip()
+ except FileNotFoundError:
+ # Fallback version if .version file is not found (e.g., in some
+ # PyInstaller configurations where the file wasn't included)
+ ver = "unknown"
return ver
diff --git a/setup.py b/setup.py
index 4c1a69e7a0..c2401ff4c1 100644
--- a/setup.py
+++ b/setup.py
@@ -37,6 +37,7 @@
"GPUtil": ">= 1.4",
"huggingface-hub": "",
"imagesize": "",
+ "jieba": "",
"Jinja2": "",
"joblib": "",
"langchain": ">= 0.2, < 1.0",
@@ -48,6 +49,7 @@
"modelscope": ">=1.28.0",
"numpy": ">= 1.24",
"openai": ">= 1.63",
+ "OpenCC": "",
"opencv-contrib-python": "== 4.10.0.84",
"openpyxl": "",
"packaging": "",
@@ -60,14 +62,16 @@
"pycocotools": "<= 2.0.8", # pycocotools upgrade incompatible since 2.0.9
"pydantic": ">= 2",
"pypdfium2": ">= 4",
+ "pypinyin": "",
"python-bidi": "",
"PyYAML": "== 6.0.2",
"regex": "",
"requests": "",
"ruamel.yaml": "",
- "safetensors": "",
+ "safetensors": ">= 0.7.0",
"scikit-image": "",
"scikit-learn": "",
+ "scipy": "",
"sentencepiece": "",
"shapely": "",
"soundfile": "",
@@ -110,6 +114,7 @@
# Currently `pypdfium2` is required by the image batch sampler
"pypdfium2",
"scikit-image",
+ "scipy",
],
"multimodal": [
"einops",
@@ -139,6 +144,7 @@
"pyclipper",
"pypdfium2",
"scikit-learn",
+ "scipy",
"shapely",
"tokenizers",
],
@@ -155,6 +161,7 @@
"pyclipper",
"pypdfium2",
"scikit-learn",
+ "scipy",
"shapely",
"tokenizers",
],
@@ -181,14 +188,19 @@
"regex",
"safetensors",
"scikit-learn",
+ "scipy",
"sentencepiece",
"shapely",
"tiktoken",
"tokenizers",
+ "beautifulsoup4",
],
"speech": [
"ftfy",
+ "jieba",
"Jinja2",
+ "OpenCC",
+ "pypinyin",
"regex",
"soundfile",
"tqdm",
diff --git a/tests/run_xpu_ci.sh b/tests/run_xpu_ci.sh
new file mode 100644
index 0000000000..0e71b47c9c
--- /dev/null
+++ b/tests/run_xpu_ci.sh
@@ -0,0 +1,16 @@
+wget https://paddle-model-ecology.bj.bcebos.com/paddlex/tmp/PaddleTest.tar
+tar -xf PaddleTest.tar && rm -rf PaddleTest.tar
+xpu-smi
+python --version
+python -m pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
+python -m pip install https://paddle-qa.bj.bcebos.com/paddle-pipeline/Develop-TagBuild-Training-Linux-Xpu-P800-SelfBuiltPypiUse/latest/paddlepaddle_xpu-0.0.0-cp310-cp310-linux_x86_64.whl
+python -c "import paddle; paddle.version.show()"
+cp -r PaddleTest/models/PaddleX/ci ./
+export DEVICE_ID=6,7
+export PADDLE_PDX_DISABLE_DEV_MODEL_WL=true
+export MEM_SIZE=32
+export DEVICE_TYPE=xpu
+rm -rf ci/pr_list.txt
+mv ci/pr_list_xpu.txt ci/pr_list.txt
+export PIP_DEFAULT_RETRIES=1
+bash ci/ci_run.sh
|