跳转至

文档场景信息抽取v4产线使用教程

1. 文档场景信息抽取v4产线介绍

文档场景信息抽取v4（PP-ChatOCRv4）是飞桨特色的文档和图像智能分析解决方案，结合了 LLM、MLLM 和 OCR 技术，一站式解决版面分析、生僻字、多页 pdf、表格、印章识别等常见的复杂文档信息抽取难点问题，结合文心大模型将海量数据和知识相融合，准确率高且应用广泛。本产线同时提供了灵活的服务化部署方式，支持在多种硬件上部署。不仅如此，本产线也提供了二次开发的能力，您可以基于本产线在您自己的数据集上训练调优，训练后的模型也可以无缝集成。

文档场景信息抽取v4产线中包含版面区域检测模块、表格结构识别模块、表格分类模块、表格单元格定位模块、文本检测模块、文本识别模块、印章文本检测模块、文本图像矫正模块、文档图像方向分类模块。其中相关的模型是以子产线的方式集成，您可以通过产线配置来查看不同模块的模型配置。

如您更考虑模型精度，请选择精度较高的模型，如您更考虑模型推理速度，请选择推理速度较快的模型，如您更考虑模型存储大小，请选择存储大小较小的模型。其中部分模型的 benchmark 如下：

👉模型列表详情

文档图像方向分类模块（可选）：

模型模型下载链接 Top-1 Acc（%） GPU推理耗时（ms）
[常规模式 / 高性能模式]		 CPU推理耗时（ms）
[常规模式 / 高性能模式]		 模型存储大小（MB） 介绍
PP-LCNet_x1_0_doc_ori 推理模型/训练模型 99.06 2.62 / 0.59 3.24 / 1.19 7 基于PP-LCNet_x1_0的文档图像分类模型，含有四个类别，即0度，90度，180度，270度

文本图像矫正模块（可选）：

模型模型下载链接 CER GPU推理耗时（ms）
[常规模式 / 高性能模式]		 CPU推理耗时（ms）
[常规模式 / 高性能模式]		 模型存储大小（MB） 介绍
UVDoc 推理模型/训练模型 0.179 19.05 / 19.05 - / 869.82 30.3 高精度文本图像矫正模型

版面区域检测模块模型（必选）：

模型模型下载链接 mAP(0.5)（%） GPU推理耗时（ms）
[常规模式 / 高性能模式]		 CPU推理耗时（ms）
[常规模式 / 高性能模式]		 模型存储大小（MB） 介绍
PP-DocLayout-L 推理模型/训练模型 90.4 33.59 / 33.59 503.01 / 251.08 123.76 基于RT-DETR-L在包含中英文论文、杂志、合同、书本、试卷和研报等场景的自建数据集训练的高精度版面区域定位模型
PP-DocLayout-M 推理模型/训练模型 75.2 13.03 / 4.72 43.39 / 24.44 22.578 基于PicoDet-L在包含中英文论文、杂志、合同、书本、试卷和研报等场景的自建数据集训练的精度效率平衡的版面区域定位模型
PP-DocLayout-S 推理模型/训练模型 70.9 11.54 / 3.86 18.53 / 6.29 4.834 基于PicoDet-S在中英文论文、杂志、合同、书本、试卷和研报等场景上自建数据集训练的高效率版面区域定位模型
PicoDet_layout_1x 推理模型/训练模型 97.8 9.62 / 6.75 26.96 / 12.77 7.4 基于PicoDet-1x在PubLayNet数据集训练的高效率版面区域定位模型，可定位包含文字、标题、表格、图片以及列表这5类区域
PicoDet_layout_1x_table 推理模型/训练模型 97.5 9.57 / 6.63 27.66 / 16.75 7.4 基于PicoDet-1x在自建数据集训练的高效率版面区域定位模型，可定位包含表格这1类区域
PicoDet-S_layout_3cls 推理模型/训练模型 88.2 8.43 / 3.44 17.60 / 6.51 4.8 基于PicoDet-S轻量模型在中英文论文、杂志和研报等场景上自建数据集训练的高效率版面区域定位模型，包含3个类别：表格，图像和印章
PicoDet-S_layout_17cls 推理模型/训练模型 87.4 8.80 / 3.62 17.51 / 6.35 4.8 基于PicoDet-S轻量模型在中英文论文、杂志和研报等场景上自建数据集训练的高效率版面区域定位模型，包含17个版面常见类别，分别是：段落标题、图片、文本、数字、摘要、内容、图表标题、公式、表格、表格标题、参考文献、文档标题、脚注、页眉、算法、页脚、印章
PicoDet-L_layout_3cls 推理模型/训练模型 89.0 12.80 / 9.57 45.04 / 23.86 22.6 基于PicoDet-L在中英文论文、杂志和研报等场景上自建数据集训练的高效率版面区域定位模型，包含3个类别：表格，图像和印章
PicoDet-L_layout_17cls 推理模型/训练模型 89.0 12.60 / 10.27 43.70 / 24.42 22.6 基于PicoDet-L在中英文论文、杂志和研报等场景上自建数据集训练的高效率版面区域定位模型，包含17个版面常见类别，分别是：段落标题、图片、文本、数字、摘要、内容、图表标题、公式、表格、表格标题、参考文献、文档标题、脚注、页眉、算法、页脚、印章
RT-DETR-H_layout_3cls 推理模型/训练模型 95.8 114.80 / 25.65 924.38 / 924.38 470.1 基于RT-DETR-H在中英文论文、杂志和研报等场景上自建数据集训练的高精度版面区域定位模型，包含3个类别：表格，图像和印章
RT-DETR-H_layout_17cls 推理模型/训练模型 92.6 115.29 / 101.18 964.75 / 964.75 470.2 基于RT-DETR-H在中英文论文、杂志和研报等场景上自建数据集训练的高精度版面区域定位模型，包含17个版面常见类别，分别是：段落标题、图片、文本、数字、摘要、内容、图表标题、公式、表格、表格标题、参考文献、文档标题、脚注、页眉、算法、页脚、印章

表格结构识别模块（可选）：

模型模型下载链接 精度（%） GPU推理耗时（ms）
[常规模式 / 高性能模式]		 CPU推理耗时（ms）
[常规模式 / 高性能模式]		 模型存储大小（MB） 介绍
SLANet 推理模型/训练模型 59.52 23.96 / 21.75 - / 43.12 6.9 SLANet 是百度飞桨视觉团队自研的表格结构识别模型。该模型通过采用CPU 友好型轻量级骨干网络PP-LCNet、高低层特征融合模块CSP-PAN、结构与位置信息对齐的特征解码模块SLA Head，大幅提升了表格结构识别的精度和推理速度。
SLANet_plus 推理模型/训练模型 63.69 23.43 / 22.16 - / 41.80 6.9 SLANet_plus 是百度飞桨视觉团队自研的表格结构识别模型SLANet的增强版。相较于SLANet，SLANet_plus 对无线表、复杂表格的识别能力得到了大幅提升，并降低了模型对表格定位准确性的敏感度，即使表格定位出现偏移，也能够较准确地进行识别。

文本检测模块（必选）：

模型模型下载链接 检测Hmean（%） GPU推理耗时（ms）
[常规模式 / 高性能模式]		 CPU推理耗时（ms）
[常规模式 / 高性能模式]		 模型存储大小（MB） 介绍
PP-OCRv5_server_det 推理模型/训练模型 83.8 89.55 / 70.19 383.15 / 383.15 84.3 PP-OCRv5 的服务端文本检测模型，精度更高，适合在性能较好的服务器上部署
PP-OCRv5_mobile_det 推理模型/训练模型 79.0 10.67 / 6.36 57.77 / 28.15 4.7 PP-OCRv5 的移动端文本检测模型，效率更高，适合在端侧设备部署
PP-OCRv4_server_det 推理模型/训练模型 69.2 127.82 / 98.87 585.95 / 489.77 109 PP-OCRv4 的服务端文本检测模型，精度更高，适合在性能较好的服务器上部署
PP-OCRv4_mobile_det 推理模型/训练模型 63.8 9.87 / 4.17 56.60 / 20.79 4.7 PP-OCRv4 的移动端文本检测模型，效率更高，适合在端侧设备部署
PP-OCRv3_mobile_det 推理模型/训练模型 精度接近 PP-OCRv4_mobile_det 9.90 / 3.60 41.93 / 20.76 2.1 PP-OCRv3 的移动端文本检测模型，效率更高，适合在端侧设备部署
PP-OCRv3_server_det 推理模型/训练模型 精度接近 PP-OCRv4_server_det 119.50 / 75.00 379.35 / 318.35 102.1 PP-OCRv3 的服务端文本检测模型，精度更高，适合在性能较好的服务器上部署
* 中文识别模型
模型模型下载链接 识别 Avg Accuracy(%) GPU推理耗时（ms）
[常规模式 / 高性能模式]		 CPU推理耗时（ms）
[常规模式 / 高性能模式]		 模型存储大小（MB） 介绍
PP-OCRv4_server_rec_doc 推理模型/训练模型 86.58 8.69 / 2.78 37.93 / 37.93 182 PP-OCRv4_server_rec_doc是在PP-OCRv4_server_rec的基础上，在更多中文文档数据和PP-OCR训练数据的混合数据训练而成，增加了部分繁体字、日文、特殊字符的识别能力，可支持识别的字符为1.5万+，除文档相关的文字识别能力提升外，也同时提升了通用文字的识别能力
PP-OCRv4_mobile_rec 推理模型/训练模型 78.74 5.26 / 1.12 17.48 / 3.61 10.5 PP-OCRv4的轻量级识别模型，推理效率高，可以部署在包含端侧设备的多种硬件设备中
PP-OCRv4_server_rec 推理模型/训练模型 85.19 8.75 / 2.49 36.93 / 36.93 173 PP-OCRv4的服务器端模型，推理精度高，可以部署在多种不同的服务器上
PP-OCRv3_mobile_rec 推理模型/训练模型 72.96 3.89 / 1.16 8.72 / 3.56 10.3 PP-OCRv3的轻量级识别模型，推理效率高，可以部署在包含端侧设备的多种硬件设备中
模型模型下载链接 识别 Avg Accuracy(%) GPU推理耗时（ms）
[常规模式 / 高性能模式]		 CPU推理耗时（ms）
[常规模式 / 高性能模式]		 模型存储大小（MB） 介绍
ch_SVTRv2_rec 推理模型/训练模型 68.81 10.38 / 8.31 66.52 / 30.83 80.5 SVTRv2 是一种由复旦大学视觉与学习实验室（FVL）的OpenOCR团队研发的服务端文本识别模型，其在PaddleOCR算法模型挑战赛 - 赛题一：OCR端到端识别任务中荣获一等奖，A榜端到端识别精度相比PP-OCRv4提升6%。
模型模型下载链接 识别 Avg Accuracy(%) GPU推理耗时（ms）
[常规模式 / 高性能模式]		 CPU推理耗时（ms）
[常规模式 / 高性能模式]		 模型存储大小（MB） 介绍
ch_RepSVTR_rec 推理模型/训练模型 65.07 6.29 / 1.57 20.64 / 5.40 48.8 RepSVTR 文本识别模型是一种基于SVTRv2 的移动端文本识别模型，其在PaddleOCR算法模型挑战赛 - 赛题一：OCR端到端识别任务中荣获一等奖，B榜端到端识别精度相比PP-OCRv4提升2.5%，推理速度持平。
* 英文识别模型
模型模型下载链接 识别 Avg Accuracy(%) GPU推理耗时（ms）
[常规模式 / 高性能模式]		 CPU推理耗时（ms）
[常规模式 / 高性能模式]		 模型存储大小（MB） 介绍
en_PP-OCRv4_mobile_rec 推理模型/训练模型 70.39 4.81 / 1.23 17.20 / 4.18 7.5 基于PP-OCRv4识别模型训练得到的超轻量英文识别模型，支持英文、数字识别
en_PP-OCRv3_mobile_rec 推理模型/训练模型 70.69 3.56 / 0.78 8.44 / 5.78 17.3 基于PP-OCRv3识别模型训练得到的超轻量英文识别模型，支持英文、数字识别
* 多语言识别模型
模型模型下载链接 识别 Avg Accuracy(%) GPU推理耗时（ms）
[常规模式 / 高性能模式]		 CPU推理耗时（ms）
[常规模式 / 高性能模式]		 模型存储大小（MB） 介绍
korean_PP-OCRv3_mobile_rec 推理模型/训练模型 60.21 3.73 / 0.98 8.76 / 2.91 9.6 基于PP-OCRv3识别模型训练得到的超轻量韩文识别模型，支持韩文、数字识别
japan_PP-OCRv3_mobile_rec 推理模型/训练模型 45.69 3.86 / 1.01 8.62 / 2.92 9.8 基于PP-OCRv3识别模型训练得到的超轻量日文识别模型，支持日文、数字识别
chinese_cht_PP-OCRv3_mobile_rec 推理模型/训练模型 82.06 3.90 / 1.16 9.24 / 3.18 10.8 基于PP-OCRv3识别模型训练得到的超轻量繁体中文识别模型，支持繁体中文、数字识别
te_PP-OCRv3_mobile_rec 推理模型/训练模型 95.88 3.59 / 0.81 8.28 / 6.21 8.7 基于PP-OCRv3识别模型训练得到的超轻量泰卢固文识别模型，支持泰卢固文、数字识别
ka_PP-OCRv3_mobile_rec 推理模型/训练模型 96.96 3.49 / 0.89 8.63 / 2.77 17.4 基于PP-OCRv3识别模型训练得到的超轻量卡纳达文识别模型，支持卡纳达文、数字识别
ta_PP-OCRv3_mobile_rec 推理模型/训练模型 76.83 3.49 / 0.86 8.35 / 3.41 8.7 基于PP-OCRv3识别模型训练得到的超轻量泰米尔文识别模型，支持泰米尔文、数字识别
latin_PP-OCRv3_mobile_rec 推理模型/训练模型 76.93 3.53 / 0.78 8.50 / 6.83 8.7 基于PP-OCRv3识别模型训练得到的超轻量拉丁文识别模型，支持拉丁文、数字识别
arabic_PP-OCRv3_mobile_rec 推理模型/训练模型 73.55 3.60 / 0.83 8.44 / 4.69 17.3 基于PP-OCRv3识别模型训练得到的超轻量阿拉伯字母识别模型，支持阿拉伯字母、数字识别
cyrillic_PP-OCRv3_mobile_rec 推理模型/训练模型 94.28 3.56 / 0.79 8.22 / 2.76 8.7 基于PP-OCRv3识别模型训练得到的超轻量斯拉夫字母识别模型，支持斯拉夫字母、数字识别
devanagari_PP-OCRv3_mobile_rec 推理模型/训练模型 96.44 3.60 / 0.78 6.95 / 2.87 8.7 基于PP-OCRv3识别模型训练得到的超轻量梵文字母识别模型，支持梵文字母、数字识别

文本行方向分类模块（可选）：

模型 模型下载链接 Top-1 Acc（%） GPU推理耗时（ms）
[常规模式 / 高性能模式]		 CPU推理耗时（ms）
[常规模式 / 高性能模式]		 模型存储大小（MB） 介绍
PP-LCNet_x0_25_textline_ori 推理模型/训练模型 87.4 2.16 / 0.41 2.37 / 0.73 0.96 基于PP-LCNet_x0_25的文本行分类模型，含有两个类别，即0度，180度
PP-LCNet_x1_0_textline_ori 推理模型/训练模型 99.42 - / - 2.98 / 2.98 6.5 基于PP-LCNet_x1_0的文本行分类模型，含有两个类别，即0度，180度

公式识别模块（可选）：

模型模型下载链接 BLEU score normed edit distance ExpRate （%） GPU推理耗时（ms）
[常规模式 / 高性能模式]		 CPU推理耗时（ms）
[常规模式 / 高性能模式]		 模型存储大小（MB）
LaTeX_OCR_rec 推理模型/训练模型 0.8821 0.0823 40.01 1088.89 / 1088.89 - / - 99

印章文本检测模块（可选）：

模型模型下载链接 检测Hmean（%） GPU推理耗时（ms）
[常规模式 / 高性能模式]		 CPU推理耗时（ms）
[常规模式 / 高性能模式]		 模型存储大小（MB） 介绍
PP-OCRv4_server_seal_det 推理模型/训练模型 98.40 124.64 / 91.57 545.68 / 439.86 109 PP-OCRv4的服务端印章文本检测模型，精度更高，适合在较好的服务器上部署
PP-OCRv4_mobile_seal_det 推理模型/训练模型 96.36 9.70 / 3.56 50.38 / 19.64 4.7 PP-OCRv4的移动端印章文本检测模型，效率更高，适合在端侧部署
测试环境说明:
  • 性能测试环境
    • 测试数据集：
      • 文档图像方向分类模型：PaddleX 自建的数据集，覆盖证件和文档等多个场景，包含 1000 张图片。
      • 文本图像矫正模型：DocUNet。
      • 版面区域检测模型：PaddleOCR 自建的版面区域分析数据集，包含中英文论文、杂志和研报等常见的 1w 张文档类型图片。
      • 表格结构识别模型：PaddleX 内部自建英文表格识别数据集。
      • 文本检测模型：PaddleOCR 自建的中文数据集，覆盖街景、网图、文档、手写多个场景，其中检测包含 500 张图片。
      • 中文识别模型： PaddleOCR 自建的中文数据集，覆盖街景、网图、文档、手写多个场景，其中文本识别包含 1.1w 张图片。
      • ch_SVTRv2_rec：PaddleOCR算法模型挑战赛 - 赛题一：OCR端到端识别任务A榜评估集。
      • ch_RepSVTR_rec：PaddleOCR算法模型挑战赛 - 赛题一：OCR端到端识别任务B榜评估集。
      • 英文识别模型：PaddleX 自建的英文数据集。
      • 多语言识别模型：PaddleX 自建的多语种数据集。
      • 文本行方向分类模型：PaddleX 自建的数据集，覆盖证件和文档等多个场景，包含 1000 张图片。
      • 印章文本检测模型：PaddleX 自建的数据集，包含500张圆形印章图像。
    • 硬件配置：
      • GPU：NVIDIA Tesla T4
      • CPU：Intel Xeon Gold 6271C @ 2.60GHz
    • 软件环境：
      • Ubuntu 20.04 / CUDA 11.8 / cuDNN 8.9 / TensorRT 8.6.1.6
      • paddlepaddle 3.0.0 / paddlex 3.0.3
  • 推理模式说明
模式 GPU配置 CPU配置 加速技术组合
常规模式 FP32精度 / 无TRT加速 FP32精度 / 8线程 PaddleInference
高性能模式 选择先验精度类型和加速策略的最优组合 FP32精度 / 8线程 选择先验最优后端（Paddle/OpenVINO/TRT等）

2. 快速开始

PaddleX 所提供的预训练的模型产线均可以快速体验效果，你可以在本地使用 Python 体验文档场景信息抽取v4产线的效果。

2.1 本地体验

在本地使用文档场景信息抽取v4产线前，请确保您已经按照PaddleX本地安装教程完成了PaddleX的wheel包安装。如果您希望选择性安装依赖，请参考安装教程中的相关说明。该产线对应的依赖分组为 ie。

在进行模型推理之前，首先需要准备大语言模型的 api_key，PP-ChatOCRv4 支持在百度云千帆平台或者本地部署的标准 OpenAI 接口大模型服务。如果使用百度云千帆平台，可以参考认证鉴权 获取 api_key。如果使用本地部署的大模型服务，可以参考PaddleNLP大模型部署文档进行大模型部署对话接口部署和向量化接口部署，并填写对应的 base_url 和 api_key 即可。如果需要使用多模态大模型进行数据融合，可以参考PaddleMIX模型文档中的OpenAI服务部署进行多模态大模型部署，并填写对应的 base_url 和 api_key 即可。

更新配置文件后，即可使用几行Python代码完成快速推理，可以使用 测试文件测试：

注: 如果因本地环境限制无法在本地部署多模态大模型，可以将代码中的含有“mllm”变量的行注释掉，仅使用大语言模型完成信息抽取。

from paddlex import create_pipeline

chat_bot_config = {
    "module_name": "chat_bot",
    "model_name": "ernie-3.5-8k",
    "base_url": "https://qianfan.baidubce.com/v2",
    "api_type": "openai",
    "api_key": "api_key",  # your api_key
}

retriever_config = {
    "module_name": "retriever",
    "model_name": "embedding-v1",
    "base_url": "https://qianfan.baidubce.com/v2",
    "api_type": "qianfan",
    "api_key": "api_key",  # your api_key
}

mllm_chat_bot_config = {
    "module_name": "chat_bot",
    "model_name": "PP-DocBee2",
    "base_url": "http://172.0.0.1:8080/v1/chat/completions",  # your local mllm service url
    "api_type": "openai",
    "api_key": "api_key",  # your api_key
}

pipeline = create_pipeline(pipeline="PP-ChatOCRv4-doc", initial_predictor=False)

visual_predict_res = pipeline.visual_predict(
    input="vehicle_certificate-1.png",
    use_doc_orientation_classify=False,
    use_doc_unwarping=False,
    use_common_ocr=True,
    use_seal_recognition=True,
    use_table_recognition=True,
)

visual_info_list = []
for res in visual_predict_res:
    visual_info_list.append(res["visual_info"])
    layout_parsing_result = res["layout_parsing_result"]

vector_info = pipeline.build_vector(
    visual_info_list, flag_save_bytes_vector=True, retriever_config=retriever_config
)
mllm_predict_res = pipeline.mllm_pred(
    input="vehicle_certificate-1.png",
    key_list=["驾驶室准乘人数"],
    mllm_chat_bot_config=mllm_chat_bot_config,
)
mllm_predict_info = mllm_predict_res["mllm_res"]
chat_result = pipeline.chat(
    key_list=["驾驶室准乘人数"],
    visual_info=visual_info_list,
    vector_info=vector_info,
    mllm_predict_info=mllm_predict_info,
    chat_bot_config=chat_bot_config,
    retriever_config=retriever_config,
)
print(chat_result)

运行后，输出结果如下：

{'chat_res': {'驾驶室准乘人数': '2'}}

PP-ChatOCRv4 预测的流程、API说明、产出说明如下：

（1）调用 create_pipeline 方法实例化PP-ChatOCRv4产线对象。 相关参数说明如下：
参数 参数说明 参数类型 默认值
pipeline 产线名称或是产线配置文件路径。如为产线名称，则必须为 PaddleX 所支持的产线。 str 无
device 产线推理设备。支持指定GPU具体卡号，如“gpu:0”，其他硬件具体卡号，如“npu:0”，CPU如“cpu”。 str gpu
use_hpip 是否启用高性能推理插件。如果为 None，则使用配置文件或 config 中的配置。 bool | None 无 None
hpi_config 高性能推理配置 dict | None 无 None
initial_predictor 是否初始化推理模块（如果为False则在首次使用相关推理模块的时候进行初始化） bool True
（2）调用 PP-ChatOCRv4 产线对象的 visual_predict() 方法获取视觉预测结果。 该方法将返回一个 generator。 以下是 `visual_predict()` 方法的参数及其说明：
参数 参数说明 参数类型 可选项 默认值
input 待预测数据，支持多种输入类型，必填 Python Var|str|list
  • Python Var：如 numpy.ndarray 表示的图像数据
  • str：如图像文件或者PDF文件的本地路径：/root/data/img.jpg；如URL链接，如图像文件或PDF文件的网络URL：示例；如本地目录，该目录下需包含待预测图像，如本地路径：/root/data/(当前不支持目录中包含PDF文件的预测，PDF文件需要指定到具体文件路径)
  • List：列表元素需为上述类型数据，如[numpy.ndarray, numpy.ndarray]，[\"/root/data/img1.jpg\", \"/root/data/img2.jpg\"]，[\"/root/data1\", \"/root/data2\"]
 None
use_doc_orientation_classify 是否使用文档方向分类模块 bool|None
  • bool：True 或者 False；
  • None：如果设置为None, 将默认使用产线初始化的该参数值，初始化为True；
 None
use_doc_unwarping 是否使用文档扭曲矫正模块 bool|None
  • bool：True 或者 False；
  • None：如果设置为None, 将默认使用产线初始化的该参数值，初始化为True；
 None
use_textline_orientation 是否使用文本行方向分类模块 bool|None
  • bool：True 或者 False；
  • None：如果设置为None, 将默认使用产线初始化的该参数值，初始化为True；
 None
use_general_ocr 是否使用 OCR 子产线 bool|None
  • bool：True 或者 False；
  • None：如果设置为None, 将默认使用产线初始化的该参数值，初始化为True；
 None
use_seal_recognition 是否使用印章识别子产线 bool|None
  • bool：True 或者 False；
  • None：如果设置为None, 将默认使用产线初始化的该参数值，初始化为True；
 None
use_table_recognition 是否使用表格识别子产线 bool|None
  • bool：True 或者 False；
  • None：如果设置为None, 将默认使用产线初始化的该参数值，初始化为True；
 None
layout_threshold 版面模型得分阈值 float|dict|None
  • float：0-1 之间的任意浮点数；
  • dict： {0:0.1} key为类别ID，value为该类别的阈值；
  • None：如果设置为 None, 将默认使用产线初始化的该参数值，初始化为 0.5；
 None
layout_nms 是否使用NMS bool|None
  • bool：True 或者 False；
  • None：如果设置为None, 将默认使用产线初始化的该参数值，初始化为True；
 None
layout_unclip_ratio 版面检测扩张系数 float|Tuple[float,float]|dict|None
  • float：任意大于 0 浮点数；
  • Tuple[float,float]：在横纵两个方向各自的扩张系数；
  • 字典, 字典的key为int类型，代表cls_id, value为tuple类型，如{0: (1.1, 2.0)}, 表示将模型输出的第0类别检测框中心不变，宽度扩张1.1倍，高度扩张2.0倍
  • None：如果设置为 None, 将默认使用产线初始化的该参数值，初始化为 1.0；
 None
layout_merge_bboxes_mode 重叠框过滤方式 str|dict|None
  • str：large，small, union.分别表示重叠框过滤时选择保留大框，小框还是同时保留
    • 字典的key为int类型，代表cls_id, value为str类型, 如{0: "large", 2: "small"}, 表示对第0类别检测框使用large模式，对第2类别检测框使用small模式
  • None：如果设置为 None, 将默认使用产线初始化的该参数值，初始化为 large；
 None
text_det_limit_side_len 文本检测的图像边长限制 int|None
  • int：大于 0 的任意整数；
  • None：如果设置为 None, 将默认使用产线初始化的该参数值，初始化为 960；
 None
text_det_limit_type 文本检测的图像边长限制类型 str|None
  • str：支持 min 和 max，min 表示保证图像最短边不小于 det_limit_side_len，max 表示保证图像最长边不大于 limit_side_len
  • None：如果设置为 None, 将默认使用产线初始化的该参数值，初始化为 max；
 None
text_det_thresh 检测像素阈值，输出的概率图中，得分大于该阈值的像素点才会被认为是文字像素点 float|None
  • float：大于 0 的任意浮点数
  • None：如果设置为 None, 将默认使用产线初始化的该参数值 0.3
 None
text_det_box_thresh 检测框阈值，检测结果边框内，所有像素点的平均得分大于该阈值时，该结果会被认为是文字区域 float|None
  • float：大于 0 的任意浮点数
  • None：如果设置为 None, 将默认使用产线初始化的该参数值 0.6
 None
text_det_unclip_ratio 文本检测扩张系数，使用该方法对文字区域进行扩张，该值越大，扩张的面积越大 float|None
  • float：大于 0 的任意浮点数
  • None：如果设置为 None, 将默认使用产线初始化的该参数值 2.0
 None
text_rec_score_thresh 文本识别阈值，得分大于该阈值的文本结果会被保留 float|None
  • float：大于 0 的任意浮点数
  • None：如果设置为 None, 将默认使用产线初始化的该参数值 0.0。即不设阈值
 None
seal_det_limit_side_len 印章检测的图像边长限制 int|None
  • int：大于 0 的任意整数；
  • None：如果设置为 None, 将默认使用产线初始化的该参数值，初始化为 960；
 None
seal_det_limit_type 印章检测的图像边长限制类型 str|None
  • str：支持 min 和 max，min 表示保证图像最短边不小于 det_limit_side_len，max 表示保证图像最长边不大于 limit_side_len
  • None：如果设置为 None, 将默认使用产线初始化的该参数值，初始化为 max；
 None
seal_det_thresh 检测像素阈值，输出的概率图中，得分大于该阈值的像素点才会被认为是印章像素点 float|None
  • float：大于 0 的任意浮点数
  • None：如果设置为 None, 将默认使用产线初始化的该参数值 0.3
 None
seal_det_box_thresh 检测框阈值，检测结果边框内，所有像素点的平均得分大于该阈值时，该结果会被认为是印章区域 float|None
  • float：大于 0 的任意浮点数
  • None：如果设置为 None, 将默认使用产线初始化的该参数值 0.6
 None
seal_det_unclip_ratio 印章检测扩张系数，使用该方法对文字区域进行扩张，该值越大，扩张的面积越大 float|None
  • float：大于 0 的任意浮点数
  • None：如果设置为 None, 将默认使用产线初始化的该参数值 2.0
 None
seal_rec_score_thresh 印章识别阈值，得分大于该阈值的文本结果会被保留 float|None
  • float：大于 0 的任意浮点数
  • None：如果设置为 None, 将默认使用产线初始化的该参数值 0.0。即不设阈值
 None
（3）对视觉预测结果进行处理。 每个样本的预测结果均为 `dict` 类型，包含 `visual_info` 和 `layout_parsing_result` 两个字段。通过 `visual_info` 得到视觉信息（包含 `normal_text_dict`、`table_text_list`、`table_html_list` 等信息），并将每个样本的信息放到 `visual_info_list` 列表中，该列表的内容会在之后送入大语言模型中。 当然，您也可以通过 `layout_parsing_result` 获取版面解析的结果，该结果包含文件或图片中包含的表格、文字、图片等内容，且支持打印、保存为图片、保存为`json`文件的操作: 
......
for res in visual_predict_res:
    visual_info_list.append(res["visual_info"])
    layout_parsing_result = res["layout_parsing_result"]
    layout_parsing_result.print()
    layout_parsing_result.save_to_img("./output")
    layout_parsing_result.save_to_json("./output")
    layout_parsing_result.save_to_xlsx("./output")
    layout_parsing_result.save_to_html("./output")
......
方法 方法说明 参数 参数类型 参数说明 默认值
print() 打印结果到终端 format_json bool 是否对输出内容进行使用 JSON 缩进格式化 True
indent int 指定缩进级别，以美化输出的 JSON 数据，使其更具可读性，仅当 format_json 为 True 时有效 4
ensure_ascii bool 控制是否将非 ASCII 字符转义为 Unicode。设置为 True 时，所有非 ASCII 字符将被转义；False 则保留原始字符，仅当format_json为True时有效 False
save_to_json() 将结果保存为json格式的文件 save_path str 保存的文件路径，当为目录时，保存文件命名与输入文件类型命名一致 无
indent int 指定缩进级别，以美化输出的 JSON 数据，使其更具可读性，仅当 format_json 为 True 时有效 4
ensure_ascii bool 控制是否将非 ASCII 字符转义为 Unicode。设置为 True 时，所有非 ASCII 字符将被转义；False 则保留原始字符，仅当format_json为True时有效 False
save_to_img() 将中间各个模块的可视化图像保存在png格式的图像 save_path str 保存的文件路径，支持目录或文件路径 无
save_to_html() 将文件中的表格保存为html格式的文件 save_path str 保存的文件路径，支持目录或文件路径 无
save_to_xlsx() 将文件中的表格保存为xlsx格式的文件 save_path str 保存的文件路径，支持目录或文件路径 无
- 调用`print()` 方法会将结果打印到终端，打印到终端的内容解释如下： - `input_path`: `(str)` 待预测图像的输入路径 - `page_index`: `(Union[int, None])` 如果输入是PDF文件，则表示当前是PDF的第几页，否则为 `None` - `model_settings`: `(Dict[str, bool])` 配置产线所需的模型参数 - `use_doc_preprocessor`: `(bool)` 控制是否启用文档预处理子产线 - `use_general_ocr`: `(bool)` 控制是否启用 OCR 子产线 - `use_seal_recognition`: `(bool)` 控制是否启用印章识别子产线 - `use_table_recognition`: `(bool)` 控制是否启用表格识别子产线 - `use_formula_recognition`: `(bool)` 控制是否启用公式识别子产线 - `parsing_res_list`: `(List[Dict])` 解析结果的列表，每个元素为一个字典，列表顺序为解析后的阅读顺序。 - `block_bbox`: `(np.ndarray)` 版面区域的边界框。 - `block_label`: `(str)` 版面区域的标签，例如`text`, `table`等。 - `block_content`: `(str)` 内容为版面区域内的内容。 - `overall_ocr_res`: `(Dict[str, Union[List[str], List[float], numpy.ndarray]])` 全局 OCR 结果的字典 - `input_path`: `(Union[str, None])` 图像OCR子产线接受的图像路径，当输入为`numpy.ndarray`时，保存为`None` - `model_settings`: `(Dict)` OCR子产线的模型配置参数 - `dt_polys`: `(List[numpy.ndarray])` 文本检测的多边形框列表。每个检测框由4个顶点坐标构成的numpy数组表示，数组shape为(4, 2)，数据类型为int16 - `dt_scores`: `(List[float])` 文本检测框的置信度列表 - `text_det_params`: `(Dict[str, Dict[str, int, float]])` 文本检测模块的配置参数 - `limit_side_len`: `(int)` 图像预处理时的边长限制值 - `limit_type`: `(str)` 边长限制的处理方式 - `thresh`: `(float)` 文本像素分类的置信度阈值 - `box_thresh`: `(float)` 文本检测框的置信度阈值 - `unclip_ratio`: `(float)` 文本检测框的膨胀系数 - `text_type`: `(str)` 文本检测的类型，当前固定为"general" - `text_type`: `(str)` 文本检测的类型，当前固定为"general" - `textline_orientation_angles`: `(List[int])` 文本行方向分类的预测结果。启用时返回实际角度值（如[0,0,1] - `text_rec_score_thresh`: `(float)` 文本识别结果的过滤阈值 - `rec_texts`: `(List[str])` 文本识别结果列表，仅包含置信度超过`text_rec_score_thresh`的文本 - `rec_scores`: `(List[float])` 文本识别的置信度列表，已按`text_rec_score_thresh`过滤 - `rec_polys`: `(List[numpy.ndarray])` 经过置信度过滤的文本检测框列表，格式同`dt_polys` - `formula_res_list`: `(List[Dict[str, Union[numpy.ndarray, List[float], str]]])` 公式识别结果列表，每个元素为一个字典 - `rec_formula`: `(str)` 公式识别结果 - `rec_polys`: `(numpy.ndarray)` 公式检测框，shape为(4, 2)，dtype为int16 - `formula_region_id`: `(int)` 公式所在的区域编号 - `seal_res_list`: `(List[Dict[str, Union[numpy.ndarray, List[float], str]]])` 印章识别结果列表，每个元素为一个字典 - `input_path`: `(str)` 印章图像的输入路径 - `model_settings`: `(Dict)` 印章识别子产线的模型配置参数 - `dt_polys`: `(List[numpy.ndarray])` 印章检测框列表，格式同`dt_polys` - `text_det_params`: `(Dict[str, Dict[str, int, float]])` 印章检测模块的配置参数, 具体参数含义同上 - `text_type`: `(str)` 印章检测的类型，当前固定为"seal" - `text_rec_score_thresh`: `(float)` 印章识别结果的过滤阈值 - `rec_texts`: `(List[str])` 印章识别结果列表，仅包含置信度超过`text_rec_score_thresh`的文本 - `rec_scores`: `(List[float])` 印章识别的置信度列表，已按`text_rec_score_thresh`过滤 - `rec_polys`: `(List[numpy.ndarray])` 经过置信度过滤的印章检测框列表，格式同`dt_polys` - `rec_boxes`: `(numpy.ndarray)` 检测框的矩形边界框数组，shape为(n, 4)，dtype为int16。每一行表示一个矩形 - `table_res_list`: `(List[Dict[str, Union[numpy.ndarray, List[float], str]]])` 表格识别结果列表，每个元素为一个字典 - `cell_box_list`: `(List[numpy.ndarray])` 表格单元格的边界框列表 - `pred_html`: `(str)` 表格的HTML格式字符串 - `table_ocr_pred`: `(dict)` 表格的OCR识别结果 - `rec_polys`: `(List[numpy.ndarray])` 单元格的检测框列表 - `rec_texts`: `(List[str])` 单元格的识别结果 - `rec_scores`: `(List[float])` 单元格的识别置信度 - `rec_boxes`: `(numpy.ndarray)` 检测框的矩形边界框数组，shape为(n, 4)，dtype为int16。每一行表示一个矩形 - 调用`save_to_json()` 方法会将上述内容保存到指定的`save_path`中，如果指定为目录，则保存的路径为`save_path/{your_img_basename}.json`，如果指定为文件，则直接保存到该文件中。由于json文件不支持保存numpy数组，因此会将其中的`numpy.array`类型转换为列表形式。 - 调用`save_to_img()` 方法会将可视化结果保存到指定的`save_path`中，如果指定为目录，则保存的路径为`save_path/{your_img_basename}_ocr_res_img.{your_img_extension}`，如果指定为文件，则直接保存到该文件中。(产线通常包含较多结果图片，不建议直接指定为具体的文件路径，否则多张图会被覆盖，仅保留最后一张图) 此外，也支持通过属性获取带结果的可视化图像和预测结果，具体如下：
属性 属性说明
json 获取预测的 json 格式的结果
img 获取格式为 dict 的可视化图像
- `json` 属性获取的预测结果为dict类型的数据，相关内容与调用 `save_to_json()` 方法保存的内容一致。 - `img` 属性返回的预测结果是一个字典类型的数据。其中，键分别为 `layout_det_res`、`overall_ocr_res`、`text_paragraphs_ocr_res`、`formula_res_region1`、`table_cell_img` 和 `seal_res_region1`，对应的值是 `Image.Image` 对象：分别用于显示版面区域检测、OCR、OCR文本段落、公式、表格和印章结果的可视化图像。如果没有使用可选模块，则字典中只包含 `layout_det_res`。
（4）调用PP-ChatOCRv4的产线对象的 build_vector() 方法，对文本内容进行向量构建。 以下是 `build_vector()` 方法的参数及其说明：
参数 参数说明 参数类型 可选项 默认值
visual_info 视觉信息，可以是包含视觉信息的字典，或者由这些字典组成的列表 list|dict None None
min_characters 最小字符数量 int 大于0的正整数，可以根据大语言模型支持的token长度来决定 3500
block_size 长文本建立向量库时分块大小 int 大于0的正整数，可以根据大语言模型支持的token长度来决定 300
flag_save_bytes_vector 文字是否保存为二进制文件 bool True|False False
retriever_config 向量检索大模型配置参数,内容参考配置文件中的“LLM_Retriever”字段 dict None None
该方法会返回一个包含视觉文本信息的字典，字典的内容如下： - `flag_save_bytes_vector`：`(bool)`是否将结果保存为二进制文件 - `flag_too_short_text`：`(bool)`是否文本长度小于最小字符数量 - `vector`: `(str|list)` 文本的二进制内容或者文本内容，取决于`flag_save_bytes_vector`和`min_characters`的值，如果`flag_save_bytes_vector=True`且文本长度大于等于最小字符数量，则返回二进制内容；否则返回原始的文本。
（5）调用PP-ChatOCRv4的产线对象的 mllm_pred() 方法，获取多模态大模型抽取结果。 以下是 `mllm_pred()` 方法的参数及其说明：
参数 参数说明 参数类型 可选项 默认值
input 待预测数据，支持多种输入类型，必填 Python Var|str
  • Python Var：如 numpy.ndarray 表示的图像数据
  • str：如图像文件或者单页PDF文件的本地路径：/root/data/img.jpg；如URL链接，如图像文件或单页PDF文件的网络URL：示例；
 None
key_list 用于提取信息的单个键或键列表 Union[str, List[str]] None None
mllm_chat_bot_config 多模态大模型配置参数,内容参考配置文件中的“MLLM_Chat”字段 dict None None
（6）调用PP-ChatOCRv4的产线对象的 chat() 方法，对关键信息进行抽取。 以下是 `chat()` 方法的参数及其说明：
参数 参数说明 参数类型 可选项 默认值
key_list 用于提取信息的单个键或键列表 Union[str, List[str]] None None
visual_info 视觉信息结果 List[dict] None None
use_vector_retrieval 是否使用向量检索 bool True|False True
vector_info 用于检索的向量信息 dict None None
min_characters 所需的最小字符数 int 大于0的正整数 3500
text_task_description 文本任务的描述 str None None
text_output_format 文本结果的输出格式 str None None
text_rules_str 生成文本结果的规则 str None None
text_few_shot_demo_text_content 用于少样本演示的文本内容 str None None
text_few_shot_demo_key_value_list 用于少样本演示的键值列表 str None None
table_task_description 表任务的描述 str None None
table_output_format 表结果的输出格式 str None None
table_rules_str 生成表结果的规则 str None None
table_few_shot_demo_text_content 表少样本演示的文本内容 str None None
table_few_shot_demo_key_value_list 表少样本演示的键值列表 str None None
mllm_predict_info 多模态大模型结果 dict None None
mllm_integration_strategy 多模态大模型和大语言模型数据融合策略，支持单独使用其中一个或者融合两者结果 str "integration" "integration", "llm_only" and "mllm_only"
chat_bot_config 大语言模型配置信息，内容参考产线配置文件“LLM_Chat”字段 dict None None
retriever_config 向量检索大模型配置参数,内容参考配置文件中的“LLM_Retriever”字段 dict None None
该方法会将结果打印到终端，打印到终端的内容解释如下： - `chat_res`: `(dict)` 提取信息的结果，是一个字典，包含了待抽取的键和对应的值。

3. 开发集成/部署

如果产线可以达到您对产线推理速度和精度的要求，您可以直接进行开发集成/部署。

若您需要将产线直接应用在您的Python项目中，可以参考 2.2 本地体验中的示例代码。

此外，PaddleX 也提供了其他三种部署方式，详细说明如下：

🚀 高性能推理：在实际生产环境中，许多应用对部署策略的性能指标（尤其是响应速度）有着较严苛的标准，以确保系统的高效运行与用户体验的流畅性。为此，PaddleX 提供高性能推理插件，旨在对模型推理及前后处理进行深度性能优化，实现端到端流程的显著提速，详细的高性能推理流程请参考PaddleX高性能推理指南。

☁️ 服务化部署：服务化部署是实际生产环境中常见的一种部署形式。通过将推理功能封装为服务，客户端可以通过网络请求来访问这些服务，以获取推理结果。PaddleX 支持多种产线服务化部署方案，详细的产线服务化部署流程请参考PaddleX服务化部署指南。

以下是基础服务化部署的API参考与多语言服务调用示例：

API参考

对于服务提供的主要操作：

  • HTTP请求方法为POST。
  • 请求体和响应体均为JSON数据（JSON对象）。
  • 当请求处理成功时，响应状态码为200，响应体的属性如下：
名称 类型 含义
logId string 请求的UUID。
errorCode integer 错误码。固定为0。
errorMsg string 错误说明。固定为"Success"。
result object 操作结果。
  • 当请求处理未成功时，响应体的属性如下：
名称 类型 含义
logId string 请求的UUID。
errorCode integer 错误码。与响应状态码相同。
errorMsg string 错误说明。

服务提供的主要操作如下：

  • analyzeImages

使用计算机视觉模型对图像进行分析，获得OCR、表格识别结果等，并提取图像中的关键信息。

POST /chatocr-visual

  • 请求体的属性如下：
名称 类型 含义 是否必填
file string 服务器可访问的图像文件或PDF文件的URL，或上述类型文件内容的Base64编码结果。默认对于超过10页的PDF文件，只有前10页的内容会被处理。
要解除页数限制，请在产线配置文件中添加以下配置： 
Serving:
  extra:
    max_num_input_imgs: null
是
fileType integer | null 文件类型。0表示PDF文件，1表示图像文件。若请求体无此属性，则将根据URL推断文件类型。 否
useDocOrientationClassify boolean | null 请参阅产线对象中 visual_predict 方法的 use_doc_orientation_classify 参数相关说明。 否
useDocUnwarping boolean | null 请参阅产线对象中 visual_predict 方法的 use_doc_unwarping 参数相关说明。 否
useTextlineOrientation boolean | null 请参阅产线对象中 visual_predict 方法的 use_textline_orientation 参数相关说明。 否
useSealRecognition boolean | null 请参阅产线对象中 visual_predict 方法的 use_seal_recognition 参数相关说明。 否
useTableRecognition boolean | null 请参阅产线对象中 visual_predict 方法的 use_table_recognition 参数相关说明。 否
layoutThreshold number | object | null 请参阅产线对象中 visual_predict 方法的 layout_threshold 参数相关说明。 否
layoutNms boolean | null 请参阅产线对象中 visual_predict 方法的 layout_nms 参数相关说明。 否
layoutUnclipRatio number | array | object | null 请参阅产线对象中 visual_predict 方法的 layout_unclip_ratio 参数相关说明。 否
layoutMergeBboxesMode string | object | null 请参阅产线对象中 visual_predict 方法的 layout_merge_bboxes_mode 参数相关说明。 否
textDetLimitSideLen integer | null 请参阅产线对象中 visual_predict 方法的 text_det_limit_side_len 参数相关说明。 否
textDetLimitType string | null 请参阅产线对象中 visual_predict 方法的 text_det_limit_type 参数相关说明。 否
textDetThresh number | null 请参阅产线对象中 visual_predict 方法的 text_det_thresh 参数相关说明。 否
textDetBoxThresh number | null 请参阅产线对象中 visual_predict 方法的 text_det_box_thresh 参数相关说明。 否
textDetUnclipRatio number | null 请参阅产线对象中 visual_predict 方法的 text_det_unclip_ratio 参数相关说明。 否
textRecScoreThresh number | null 请参阅产线对象中 visual_predict 方法的 text_rec_score_thresh 参数相关说明。 否
sealDetLimitSideLen integer | null 请参阅产线对象中 visual_predict 方法的 seal_det_limit_side_len 参数相关说明。 否
sealDetLimitType string | null 请参阅产线对象中 visual_predict 方法的 seal_det_limit_type 参数相关说明。 否
sealDetThresh number | null 请参阅产线对象中 visual_predict 方法的 seal_det_thresh 参数相关说明。 否
sealDetBoxThresh number | null 请参阅产线对象中 visual_predict 方法的 seal_det_box_thresh 参数相关说明。 否
sealDetUnclipRatio number | null 请参阅产线对象中 visual_predict 方法的 seal_det_unclip_ratio 参数相关说明。 否
sealRecScoreThresh number | null 请参阅产线对象中 visual_predict 方法的 seal_rec_score_thresh 参数相关说明。 否
visualize boolean | null 是否返回可视化结果图以及处理过程中的中间图像等。
  • 传入 true：返回图像。
  • 传入 false：不返回图像。
  • 若请求体中未提供该参数或传入 null：遵循产线配置文件Serving.visualize 的设置。

例如，在产线配置文件中添加如下字段：
Serving:
  visualize: False
将默认不返回图像，通过请求体中的visualize参数可以覆盖默认行为。如果请求体和配置文件中均未设置（或请求体传入null、配置文件中未设置），则默认返回图像。 		否
  • 请求处理成功时，响应体的result具有如下属性：
名称 类型 含义
layoutParsingResults array 使用计算机视觉模型得到的分析结果。数组长度为1（对于图像输入）或实际处理的文档页数（对于PDF输入）。对于PDF输入，数组中的每个元素依次表示PDF文件中实际处理的每一页的结果。
visualInfo array 图像中的关键信息，可用作其他操作的输入。
dataInfo object 输入数据信息。

layoutParsingResults中的每个元素为一个object，具有如下属性：

名称 类型 含义
prunedResult object 产线对象的 visual_predict 方法生成的 layout_parsing_result 的 JSON 表示中 res 字段的简化版本，其中去除了 input_path 和 page_index 字段。
outputImages object | null 参见产线视觉预测结果的 img 属性说明。
inputImage string | null 输入图像。图像为JPEG格式，使用Base64编码。
  • buildVectorStore

构建向量数据库。

POST /chatocr-vector

  • 请求体的属性如下：
名称 类型 含义 是否必填
visualInfo array 图像中的关键信息。由analyzeImages操作提供。 是
minCharacters integer 请参阅产线对象中 build_vector 方法的 min_characters 参数相关说明。 否
blockSize integer 请参阅产线对象中 build_vector 方法的 block_size 参数相关说明。 否
retrieverConfig object | null 请参阅产线对象中 build_vector 方法的 retriever_config 参数相关说明。 否
  • 请求处理成功时，响应体的result具有如下属性：
名称 类型 含义
vectorInfo object 向量数据库序列化结果，可用作其他操作的输入。
  • invokeMLLM

调用多模态大模型。

POST /chatocr-mllm

  • 请求体的属性如下：
名称 类型 含义 是否必填
image string 服务器可访问的图像文件的URL或图像文件内容的Base64编码结果。 是
keyList array 键列表。 是
mllmChatBotConfig object | null 请参阅产线对象中 mllm_pred 方法的 mllm_chat_bot_config 参数相关说明。 否
  • 请求处理成功时，响应体的result具有如下属性：
名称 类型 含义
mllmPredictInfo object 多模态大模型调用结果。
  • chat

与大语言模型交互，利用大语言模型提炼关键信息。

POST /chatocr-chat

  • 请求体的属性如下：
名称 类型 含义 是否必填
keyList array 键列表。 是
visualInfo object 图像中的关键信息。由analyzeImages操作提供。 是
useVectorRetrieval boolean 请参阅产线对象中 chat 方法的 use_vector_retrieval 参数相关说明。 否
vectorInfo object | null 向量数据库序列化结果。由buildVectorStore操作提供。请注意，反序列化过程需要进行 unpickle 操作，为了防止恶意攻击，请确保使用可信任来源的数据。 否
minCharacters integer 请参阅产线对象中 chat 方法的 min_characters 参数相关说明。 否
textTaskDescription string | null 请参阅产线对象中 chat 方法的 text_task_description 参数相关说明。 否
textOutputFormat string | null 请参阅产线对象中 chat 方法的 text_output_format 参数相关说明。 否
textRulesStr string | null 请参阅产线对象中 chat 方法的 text_rules_str 参数相关说明。 否
textFewShotDemoTextContent string | null 请参阅产线对象中 chat 方法的 text_few_shot_demo_text_content 参数相关说明。 否
textFewShotDemoKeyValueList string | null 请参阅产线对象中 chat 方法的 text_few_shot_demo_key_value_list 参数相关说明。 否
tableTaskDescription string | null 请参阅产线对象中 chat 方法的 table_task_description 参数相关说明。 否
tableOutputFormat string | null 请参阅产线对象中 chat 方法的 table_output_format 参数相关说明。 否
tableRulesStr string | null 请参阅产线对象中 chat 方法的 table_rules_str 参数相关说明。 否
tableFewShotDemoTextContent string | null 请参阅产线对象中 chat 方法的 table_few_shot_demo_text_content 参数相关说明。
tableFewShotDemoKeyValueList string | null 请参阅产线对象中 chat 方法的 table_few_shot_demo_key_value_list 参数相关说明。 否
mllmPredictInfo object | null 多模态大模型调用结果。由invokeMllm操作提供。 否
mllmIntegrationStrategy string 请参阅产线对象中 chat 方法的 mllm_integration_strategy 参数相关说明。 否
chatBotConfig object | null 请参阅产线对象中 chat 方法的 chat_bot_config 参数相关说明。 否
retrieverConfig object | null 请参阅产线对象中 chat 方法的 retriever_config 参数相关说明。 否
  • 请求处理成功时，响应体的result具有如下属性：
名称 类型 含义
chatResult object 关键信息抽取结果。
  • 注意：
    • 在请求体中包含大模型调用的API key等敏感参数可能存在安全风险。如无必要，请在配置文件中设置这些参数，在请求时不传递。

    多语言调用服务示例
    Python 
    
# 此脚本只展示了图片的用例，其他文件类型的调用请查看API参考来调整

import base64
import pprint
import sys
import requests


API_BASE_URL = "http://127.0.0.1:8080"

image_path = "./demo.jpg"
keys = ["姓名"]

with open(image_path, "rb") as file:
    image_bytes = file.read()
    image_data = base64.b64encode(image_bytes).decode("ascii")

payload = {
    "file": image_data,
    "fileType": 1,
}

resp_visual = requests.post(url=f"{API_BASE_URL}/chatocr-visual", json=payload)
if resp_visual.status_code != 200:
    print(
        f"Request to chatocr-visual failed with status code {resp_visual.status_code}."
    )
    pprint.pp(resp_visual.json())
    sys.exit(1)
result_visual = resp_visual.json()["result"]

for i, res in enumerate(result_visual["layoutParsingResults"]):
    print(res["prunedResult"])
    for img_name, img in res["outputImages"].items():
        img_path = f"{img_name}_{i}.jpg"
        with open(img_path, "wb") as f:
            f.write(base64.b64decode(img))
        print(f"Output image saved at {img_path}")

payload = {
    "visualInfo": result_visual["visualInfo"],
}
resp_vector = requests.post(url=f"{API_BASE_URL}/chatocr-vector", json=payload)
if resp_vector.status_code != 200:
    print(
        f"Request to chatocr-vector failed with status code {resp_vector.status_code}."
    )
    pprint.pp(resp_vector.json())
    sys.exit(1)
result_vector = resp_vector.json()["result"]

payload = {
    "image": image_data,
    "keyList": keys,
}
resp_mllm = requests.post(url=f"{API_BASE_URL}/chatocr-mllm", json=payload)
if resp_mllm.status_code != 200:
    print(
        f"Request to chatocr-mllm failed with status code {resp_mllm.status_code}."
    )
    pprint.pp(resp_mllm.json())
    sys.exit(1)
result_mllm = resp_mllm.json()["result"]

payload = {
    "keyList": keys,
    "visualInfo": result_visual["visualInfo"],
    "useVectorRetrieval": True,
    "vectorInfo": result_vector["vectorInfo"],
    "mllmPredictInfo": result_mllm["mllmPredictInfo"],
}
resp_chat = requests.post(url=f"{API_BASE_URL}/chatocr-chat", json=payload)
if resp_chat.status_code != 200:
    print(
        f"Request to chatocr-chat failed with status code {resp_chat.status_code}."
    )
    pprint.pp(resp_chat.json())
    sys.exit(1)
result_chat = resp_chat.json()["result"]
print("Final result:")
print(result_chat["chatResult"])
    C++ 
    #include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include "cpp-httplib/httplib.h" // https://github.com/Huiyicc/cpp-httplib
#include "nlohmann/json.hpp" // https://github.com/nlohmann/json
#include "base64.hpp" // https://github.com/tobiaslocker/base64

using json = nlohmann::json;

std::string encode_image(const std::string& path) {
    std::ifstream file(path, std::ios::binary | std::ios::ate);
    if (!file) throw std::runtime_error("File open error.");
    std::streamsize size = file.tellg();
    file.seekg(0, std::ios::beg);
    std::vector buf(size);
    file.read(buf.data(), size);
    return base64::to_base64(std::string(buf.data(), buf.size()));
}

int main() {
    httplib::Client client("localhost", 8080);
    std::string imagePath = "./demo.jpg";
    std::string imageData = encode_image(imagePath);
    json keys = { "合格证编号" };

    json payload_visual = { {"file", imageData}, {"fileType", 1} };
    auto resp1 = client.Post("/chatocr-visual", payload_visual.dump(), "application/json");
    if (!resp1 || resp1->status != 200) {
        std::cerr << "chatocr-visual failed.\n"; return 1;
    }
    json result_visual = json::parse(resp1->body)["result"];

    for (size_t i = 0; i < result_visual["layoutParsingResults"].size(); ++i) {
        auto& res = result_visual["layoutParsingResults"][i];
        std::cout << "prunedResult: " << res["prunedResult"].dump() << "\n";
        if (res.contains("outputImages")) {
            for (auto& [name, b64] : res["outputImages"].items()) {
                std::string outPath = name + "_" + std::to_string(i) + ".jpg";
                std::string decoded = base64::from_base64(b64.get());
                std::ofstream out(outPath, std::ios::binary);
                out.write(decoded.data(), decoded.size());
                out.close();
                std::cout << "Saved: " << outPath << "\n";
            }
        }
    }

    json payload_vector = { {"visualInfo", result_visual["visualInfo"]} };
    auto resp2 = client.Post("/chatocr-vector", payload_vector.dump(), "application/json");
    if (!resp2 || resp2->status != 200) {
        std::cerr << "chatocr-vector failed.\n"; return 1;
    }
    json result_vector = json::parse(resp2->body)["result"];

    json payload_mllm = { {"image", imageData}, {"keyList", keys} };
    auto resp3 = client.Post("/chatocr-mllm", payload_mllm.dump(), "application/json");
    if (!resp3 || resp3->status != 200) {
        std::cerr << "chatocr-mllm failed.\n"; return 1;
    }
    json result_mllm = json::parse(resp3->body)["result"];

    json payload_chat = {
        {"keyList", keys},
        {"visualInfo", result_visual["visualInfo"]},
        {"useVectorRetrieval", true},
        {"vectorInfo", result_vector["vectorInfo"]},
        {"mllmPredictInfo", result_mllm["mllmPredictInfo"]}
    };
    auto resp4 = client.Post("/chatocr-chat", payload_chat.dump(), "application/json");
    if (!resp4 || resp4->status != 200) {
        std::cerr << "chatocr-chat failed.\n"; return 1;
    }

    json result_chat = json::parse(resp4->body)["result"];
    std::cout << "Final chat result: " << result_chat["chatResult"] << std::endl;

    return 0;
}
    Java 
    import okhttp3.*;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Base64;
import java.util.Iterator;

public class Main {
    public static void main(String[] args) throws IOException {
        String API_BASE_URL = "http://localhost:8080";
        String imagePath = "./demo.jpg";
        String[] keys = {"合格证编号"};

        OkHttpClient client = new OkHttpClient();
        ObjectMapper objectMapper = new ObjectMapper();
        MediaType JSON = MediaType.parse("application/json; charset=utf-8");

        byte[] imageBytes = java.nio.file.Files.readAllBytes(new File(imagePath).toPath());
        String base64Image = Base64.getEncoder().encodeToString(imageBytes);

        ObjectNode visualPayload = objectMapper.createObjectNode();
        visualPayload.put("file", base64Image);
        visualPayload.put("fileType", 1);

        Request requestVisual = new Request.Builder()
                .url(API_BASE_URL + "/chatocr-visual")
                .post(RequestBody.create(JSON, visualPayload.toString()))
                .build();

        Response responseVisual = client.newCall(requestVisual).execute();
        if (!responseVisual.isSuccessful()) {
            System.err.println("chatocr-visual failed: " + responseVisual.code());
            return;
        }

        JsonNode resultVisual = objectMapper.readTree(responseVisual.body().string()).get("result");

        JsonNode layoutResults = resultVisual.get("layoutParsingResults");
        for (int i = 0; i < layoutResults.size(); i++) {
            JsonNode res = layoutResults.get(i);
            System.out.println("prunedResult [" + i + "]: " + res.get("prunedResult").toString());

            JsonNode outputImages = res.get("outputImages");
            if (outputImages != null && outputImages.isObject()) {
                Iterator names = outputImages.fieldNames();
                while (names.hasNext()) {
                    String imgName = names.next();
                    String imgBase64 = outputImages.get(imgName).asText();
                    byte[] imgBytes = Base64.getDecoder().decode(imgBase64);
                    String imgPath = imgName + "_" + i + ".jpg";
                    try (FileOutputStream fos = new FileOutputStream(imgPath)) {
                        fos.write(imgBytes);
                        System.out.println("Saved image: " + imgPath);
                    }
                }
            }
        }

        ObjectNode vectorPayload = objectMapper.createObjectNode();
        vectorPayload.set("visualInfo", resultVisual.get("visualInfo"));

        Request requestVector = new Request.Builder()
                .url(API_BASE_URL + "/chatocr-vector")
                .post(RequestBody.create(JSON, vectorPayload.toString()))
                .build();

        Response responseVector = client.newCall(requestVector).execute();
        if (!responseVector.isSuccessful()) {
            System.err.println("chatocr-vector failed: " + responseVector.code());
            return;
        }

        JsonNode resultVector = objectMapper.readTree(responseVector.body().string()).get("result");

        ObjectNode mllmPayload = objectMapper.createObjectNode();
        mllmPayload.put("image", base64Image);
        mllmPayload.putArray("keyList").add(keys[0]);

        Request requestMllm = new Request.Builder()
                .url(API_BASE_URL + "/chatocr-mllm")
                .post(RequestBody.create(JSON, mllmPayload.toString()))
                .build();

        Response responseMllm = client.newCall(requestMllm).execute();
        if (!responseMllm.isSuccessful()) {
            System.err.println("chatocr-mllm failed: " + responseMllm.code());
            return;
        }

        JsonNode resultMllm = objectMapper.readTree(responseMllm.body().string()).get("result");

        ObjectNode chatPayload = objectMapper.createObjectNode();
        chatPayload.putArray("keyList").add(keys[0]);
        chatPayload.set("visualInfo", resultVisual.get("visualInfo"));
        chatPayload.put("useVectorRetrieval", true);
        chatPayload.set("vectorInfo", resultVector.get("vectorInfo"));
        chatPayload.set("mllmPredictInfo", resultMllm.get("mllmPredictInfo"));

        Request requestChat = new Request.Builder()
                .url(API_BASE_URL + "/chatocr-chat")
                .post(RequestBody.create(JSON, chatPayload.toString()))
                .build();

        Response responseChat = client.newCall(requestChat).execute();
        if (!responseChat.isSuccessful()) {
            System.err.println("chatocr-chat failed: " + responseChat.code());
            return;
        }

        JsonNode resultChat = objectMapper.readTree(responseChat.body().string()).get("result");
        System.out.println("Final result:");
        System.out.println(resultChat.get("chatResult").toString());
    }
}
    Go 
    package main

import (
    "bytes"
    "encoding/base64"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "os"
)

func sendPostRequest(url string, payload map[string]interface{}) (map[string]interface{}, error) {
    bodyBytes, err := json.Marshal(payload)
    if err != nil {
        return nil, fmt.Errorf("error marshaling payload: %v", err)
    }

    req, err := http.NewRequest("POST", url, bytes.NewBuffer(bodyBytes))
    if err != nil {
        return nil, fmt.Errorf("error creating request: %v", err)
    }
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, fmt.Errorf("error sending request: %v", err)
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("status code error: %d", resp.StatusCode)
    }

    respBytes, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, fmt.Errorf("error reading response: %v", err)
    }

    var result map[string]interface{}
    if err := json.Unmarshal(respBytes, &result); err != nil {
        return nil, fmt.Errorf("error unmarshaling response: %v", err)
    }
    return result["result"].(map[string]interface{}), nil
}

func main() {
    apiBase := "http://localhost:8080"
    imagePath := "./demo.jpg"
    keys := []string{"合格证编号"}

    imageBytes, err := ioutil.ReadFile(imagePath)
    if err != nil {
        fmt.Printf("read image failed : %v\n", err)
        return
    }
    imageData := base64.StdEncoding.EncodeToString(imageBytes)

    visualPayload := map[string]interface{}{
        "file":     imageData,
        "fileType": 1,
    }
    visualResult, err := sendPostRequest(apiBase+"/chatocr-visual", visualPayload)
    if err != nil {
        fmt.Printf("chatocr-visual request error: %v\n", err)
        return
    }

    layoutResults := visualResult["layoutParsingResults"].([]interface{})
    for i, res := range layoutResults {
        layout := res.(map[string]interface{})
        fmt.Println("PrunedResult:", layout["prunedResult"])
        outputImages := layout["outputImages"].(map[string]interface{})
        for name, img := range outputImages {
            imgBytes, _ := base64.StdEncoding.DecodeString(img.(string))
            filename := fmt.Sprintf("%s_%d.jpg", name, i)
            if err := os.WriteFile(filename, imgBytes, 0644); err == nil {
                fmt.Printf("save image：%s\n", filename)
            }
        }
    }

    vectorPayload := map[string]interface{}{
        "visualInfo": visualResult["visualInfo"],
    }
    vectorResult, err := sendPostRequest(apiBase+"/chatocr-vector", vectorPayload)
    if err != nil {
        fmt.Printf("chatocr-vector request error: %v\n", err)
        return
    }

    mllmPayload := map[string]interface{}{
        "image":   imageData,
        "keyList": keys,
    }
    mllmResult, err := sendPostRequest(apiBase+"/chatocr-mllm", mllmPayload)
    if err != nil {
        fmt.Printf("chatocr-mllm request error: %v\n", err)
        return
    }

    chatPayload := map[string]interface{}{
        "keyList":           keys,
        "visualInfo":        visualResult["visualInfo"],
        "useVectorRetrieval": true,
        "vectorInfo":        vectorResult["vectorInfo"],
        "mllmPredictInfo":   mllmResult["mllmPredictInfo"],
    }
    chatResult, err := sendPostRequest(apiBase+"/chatocr-chat", chatPayload)
    if err != nil {
        fmt.Printf("chatocr-chat request error: %v\n", err)
        return
    }

    fmt.Println("final result：", chatResult["chatResult"])
}
    C# 
    using System;
using System.IO;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json.Linq;

class Program
{
    static readonly string API_BASE_URL = "http://localhost:8080";
    static readonly string inputFilePath = "./demo.jpg";
    static readonly string[] keys = { "合格证编号" };

    static async Task Main(string[] args)
    {
        var httpClient = new HttpClient();

        byte[] imageBytes = File.ReadAllBytes(inputFilePath);
        string imageData = Convert.ToBase64String(imageBytes);

        var payloadVisual = new JObject
        {
            { "file", imageData },
            { "fileType", 1 }
        };

        var respVisual = await httpClient.PostAsync($"{API_BASE_URL}/chatocr-visual",
            new StringContent(payloadVisual.ToString(), Encoding.UTF8, "application/json"));

        if (!respVisual.IsSuccessStatusCode)
        {
            Console.Error.WriteLine($"Request to chatocr-visual failed: {respVisual.StatusCode}");
            Console.Error.WriteLine(await respVisual.Content.ReadAsStringAsync());
            return;
        }

        JObject resultVisual = JObject.Parse(await respVisual.Content.ReadAsStringAsync())["result"] as JObject;

        var layoutParsingResults = (JArray)resultVisual["layoutParsingResults"];
        for (int i = 0; i < layoutParsingResults.Count; i++)
        {
            var res = layoutParsingResults[i];
            Console.WriteLine($"[{i}] prunedResult:\n{res["prunedResult"]}");

            JObject outputImages = res["outputImages"] as JObject;
            if (outputImages != null)
            {
                foreach (var img in outputImages)
                {
                    string imgName = img.Key;
                    string base64Img = img.Value?.ToString();
                    if (!string.IsNullOrEmpty(base64Img))
                    {
                        string imgPath = $"{imgName}_{i}.jpg";
                        File.WriteAllBytes(imgPath, Convert.FromBase64String(base64Img));
                        Console.WriteLine($"Output image saved at {imgPath}");
                    }
                }
            }
        }

        var payloadVector = new JObject
        {
            { "visualInfo", resultVisual["visualInfo"] }
        };

        var respVector = await httpClient.PostAsync($"{API_BASE_URL}/chatocr-vector",
            new StringContent(payloadVector.ToString(), Encoding.UTF8, "application/json"));

        if (!respVector.IsSuccessStatusCode)
        {
            Console.Error.WriteLine($"Request to chatocr-vector failed: {respVector.StatusCode}");
            Console.Error.WriteLine(await respVector.Content.ReadAsStringAsync());
            return;
        }

        JObject resultVector = JObject.Parse(await respVector.Content.ReadAsStringAsync())["result"] as JObject;

        var payloadMllm = new JObject
        {
            { "image", imageData },
            { "keyList", new JArray(keys) }
        };

        var respMllm = await httpClient.PostAsync($"{API_BASE_URL}/chatocr-mllm",
            new StringContent(payloadMllm.ToString(), Encoding.UTF8, "application/json"));

        if (!respMllm.IsSuccessStatusCode)
        {
            Console.Error.WriteLine($"Request to chatocr-mllm failed: {respMllm.StatusCode}");
            Console.Error.WriteLine(await respMllm.Content.ReadAsStringAsync());
            return;
        }

        JObject resultMllm = JObject.Parse(await respMllm.Content.ReadAsStringAsync())["result"] as JObject;

        var payloadChat = new JObject
        {
            { "keyList", new JArray(keys) },
            { "visualInfo", resultVisual["visualInfo"] },
            { "useVectorRetrieval", true },
            { "vectorInfo", resultVector["vectorInfo"] },
            { "mllmPredictInfo", resultMllm["mllmPredictInfo"] }
        };

        var respChat = await httpClient.PostAsync($"{API_BASE_URL}/chatocr-chat",
            new StringContent(payloadChat.ToString(), Encoding.UTF8, "application/json"));

        if (!respChat.IsSuccessStatusCode)
        {
            Console.Error.WriteLine($"Request to chatocr-chat failed: {respChat.StatusCode}");
            Console.Error.WriteLine(await respChat.Content.ReadAsStringAsync());
            return;
        }

        JObject resultChat = JObject.Parse(await respChat.Content.ReadAsStringAsync())["result"] as JObject;
        Console.WriteLine("Final result:");
        Console.WriteLine(resultChat["chatResult"]);
    }
}
    Node.js 
    const axios = require('axios');
const fs = require('fs');
const path = require('path');

const API_BASE_URL = 'http://localhost:8080';
const imagePath = './demo.jpg';
const keys = ['合格证编号'];

function encodeImageToBase64(filePath) {
  const bitmap = fs.readFileSync(filePath);
  return Buffer.from(bitmap).toString('base64');
}

(async () => {
  try {
    const imageData = encodeImageToBase64(imagePath);

    const respVisual = await axios.post(`${API_BASE_URL}/chatocr-visual`, {
      file: imageData,
      fileType: 1
    });

    const resultVisual = respVisual.data.result;
    resultVisual.layoutParsingResults.forEach((res, i) => {
      console.log(`\n[${i}] prunedResult:\n`, res.prunedResult);
      const outputImages = res.outputImages || {};
      for (const [imgName, base64Img] of Object.entries(outputImages)) {
        const fileName = `${imgName}_${i}.jpg`;
        fs.writeFileSync(fileName, Buffer.from(base64Img, 'base64'));
        console.log(`Output image saved at ${fileName}`);
      }
    });

    const respVector = await axios.post(`${API_BASE_URL}/chatocr-vector`, {
      visualInfo: resultVisual.visualInfo
    });
    const resultVector = respVector.data.result;

    const respMllm = await axios.post(`${API_BASE_URL}/chatocr-mllm`, {
      image: imageData,
      keyList: keys
    });
    const resultMllm = respMllm.data.result;

    const respChat = await axios.post(`${API_BASE_URL}/chatocr-chat`, {
      keyList: keys,
      visualInfo: resultVisual.visualInfo,
      useVectorRetrieval: true,
      vectorInfo: resultVector.vectorInfo,
      mllmPredictInfo: resultMllm.mllmPredictInfo
    });

    const resultChat = respChat.data.result;
    console.log('\nFinal result:\n', resultChat.chatResult);

  } catch (error) {
    if (error.response) {
      console.error(`❌ Request failed: ${error.response.status}`);
      console.error(error.response.data);
    } else {
      console.error('❌ Error occurred:', error.message);
    }
  }
})();
    PHP 
    <?php

$API_BASE_URL = "http://localhost:8080";
$image_path = "./demo.jpg";
$keys = ["合格证编号"];

$image_data = base64_encode(file_get_contents($image_path));

$payload_visual = [
    "file" => $image_data,
    "fileType" => 1
];
$response_visual_raw = send_post_raw("$API_BASE_URL/chatocr-visual", $payload_visual);
$response_visual = json_decode($response_visual_raw, true);
if (!isset($response_visual["result"])) {
    echo "chatocr-visual request error\n";
    print_r($response_visual);
    exit(1);
}
$result_visual_raw = json_decode($response_visual_raw, false)->result;
$result_visual_arr = $response_visual["result"];

foreach ($result_visual_arr["layoutParsingResults"] as $i => $res) {
    echo "[$i] prunedResult:\n";
    print_r($res["prunedResult"]);
    if (!empty($res["outputImages"])) {
        foreach ($res["outputImages"] as $img_name => $base64_img) {
            $img_path = "{$img_name}_{$i}.jpg";
            file_put_contents($img_path, base64_decode($base64_img));
            echo "Output image saved at $img_path\n";
        }
    }
}

$payload_vector = [
    "visualInfo" => $result_visual_raw->visualInfo
];
$response_vector_raw = send_post_raw("$API_BASE_URL/chatocr-vector", $payload_vector);
$response_vector = json_decode($response_vector_raw, true);
if (!isset($response_vector["result"])) {
    echo "chatocr-vector request error\n";
    print_r($response_vector);
    exit(1);
}
$result_vector_raw = json_decode($response_vector_raw, false)->result;

$payload_mllm = [
    "image" => $image_data,
    "keyList" => $keys
];
$response_mllm_raw = send_post_raw("$API_BASE_URL/chatocr-mllm", $payload_mllm);
$response_mllm = json_decode($response_mllm_raw, true);
if (!isset($response_mllm["result"])) {
    echo "chatocr-mllm request error\n";
    print_r($response_mllm);
    exit(1);
}
$result_mllm_raw = json_decode($response_mllm_raw, false)->result;

$payload_chat = [
    "keyList" => $keys,
    "visualInfo" => $result_visual_raw->visualInfo,
    "useVectorRetrieval" => true,
    "vectorInfo" => $result_vector_raw->vectorInfo,
    "mllmPredictInfo" => $result_mllm_raw->mllmPredictInfo
];
$response_chat_raw = send_post_raw("$API_BASE_URL/chatocr-chat", $payload_chat);
$response_chat = json_decode($response_chat_raw, true);
if (!isset($response_chat["result"])) {
    echo "chatocr-chat request error\n";
    print_r($response_chat);
    exit(1);
}

echo "Final result:\n";
echo json_encode($response_chat["result"]["chatResult"], JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT) . "\n";


function send_post_raw($url, $data) {
    $json_str = json_encode($data, JSON_UNESCAPED_UNICODE);
    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, $json_str);
    curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $response = curl_exec($ch);
    if ($response === false) {
        echo "cURL error: " . curl_error($ch) . "\n";
    }
    curl_close($ch);
    return $response;
}
?>


    📱 端侧部署：端侧部署是一种将计算和数据处理功能放在用户设备本身上的方式，设备可以直接处理数据，而不需要依赖远程的服务器。PaddleX 支持将模型部署在 Android 等端侧设备上，详细的端侧部署流程请参考PaddleX端侧部署指南。 您可以根据需要选择合适的方式部署模型产线，进而进行后续的 AI 应用集成。

    4. 二次开发

    如果文档场景信息抽取v4产线提供的默认模型权重在您的场景中，精度或速度不满意，您可以尝试利用您自己拥有的特定领域或应用场景的数据对现有模型进行进一步的微调，以提升在您的场景中的识别效果。

    4.1 模型微调

    由于文档场景信息抽取v4产线包含若干模块，模型产线的效果如果不及预期，可能来自于其中任何一个模块。您可以对提取效果差的 case 进行分析，通过可视化图像，确定是哪个模块存在问题，并参考以下表格中对应的微调教程链接进行模型微调。

    情形 微调模块 微调参考链接
    版面区域检测不准，如印章、表格未检出等 版面区域检测模块 链接
    表格结构识别不准 表格结构识别 链接
    印章文本存在漏检 印章文本检测模块 链接
    文本存在漏检 文本检测模块 链接
    文本内容都不准 文本识别模块 链接
    垂直或者旋转文本行矫正不准 文本行方向分类模块 链接
    整图旋转矫正不准 文档图像方向分类模块 链接
    图像扭曲矫正不准 文本图像矫正模块 暂不支持微调

    4.2 模型应用

    当您使用私有数据集完成微调训练后，可获得本地模型权重文件。

    若您需要使用微调后的模型权重，只需对产线配置文件做修改，将微调后模型权重的本地路径替换至产线配置文件中的对应位置即可：

    ......
SubModules:
    TextDetection:
    module_name: text_detection
    model_name: PP-OCRv5_server_det
    model_dir: null # 替换为微调后的文本检测模型权重路径
    limit_side_len: 960
    limit_type: max
    thresh: 0.3
    box_thresh: 0.6
    unclip_ratio: 1.5

    TextRecognition:
    module_name: text_recognition
    model_name: PP-OCRv5_server_rec
    model_dir: null # 替换为微调后的文本检测模型权重路径
    batch_size: 1
            score_thresh: 0
......

    随后， 参考2.2 本地体验中的命令行方式或Python脚本方式，加载修改后的产线配置文件即可。

    5. 多硬件支持

    PaddleX 支持英伟达 GPU、昆仑芯 XPU、昇腾 NPU 和寒武纪 MLU 等多种主流硬件设备，仅需设置 device 参数即可完成不同硬件之间的无缝切换。

    例如，使用文档场景信息抽取v4产线时，将运行设备从英伟达 GPU 更改为昇腾 NPU，仅需将脚本中的 device 修改为 npu 即可：

    from paddlex import create_pipeline
pipeline = create_pipeline(
    pipeline="PP-ChatOCRv4-doc",
    device="npu:0" # gpu:0 --> npu:0
    )
    若您想在更多种类的硬件上使用通用文档场景信息抽取v4产线，请参考PaddleX多硬件使用指南。

    评论