--- comments: true --- # 印章文本识别产线使用教程 ## 1. 印章文本识别产线介绍 印章文本识别是一种自动从文档或图像中提取和识别印章内容的技术，印章文本的识别是文档处理的一部分，在很多场景都有用途，例如合同比对，出入库审核以及发票报销审核等场景。 印章文本识别产线用于识别印章的文本内容，提取印章图像中的文字信息以文本形式输出，本产线集成了业界知名的 PP-OCRv4 的端到端 OCR 串联系统，支持弯曲印章文本的检测和识别。同时，本产线集成了可选的版面区域定位模块，可以在整个文档中准确定位印章所在的版面位置。此外也增加可选的文档图像的方向矫正和扭曲矫正功能。基于本产线，可实现 CPU 上毫秒级的文本内容精准预测。本产线同时提供了灵活的服务化部署方式，支持在多种硬件上使用多种编程语言调用。不仅如此，本产线也提供了二次开发的能力，您可以基于本产线在您自己的数据集上训练调优，训练后的模型也可以无缝集成。 印章文本识别产线中包含印章印章文本检测模块和文本识别模块，以及可选的版面检测模块、文档图像方向分类模块、文本图像矫正模块。每个模块都包含多个模型，您可以根据下方的基准测试数据选择使用的模型。 ### 1.1 模型基准测试数据 如您更考虑模型精度，请选择精度较高的模型，如您更考虑模型推理速度，请选择推理速度较快的模型，如您更考虑模型存储大小，请选择存储大小较小的模型。 > 推理耗时仅包含模型推理耗时，不包含前后处理耗时。

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

* 版面检测模型，包含23个常见的类别：文档标题、段落标题、文本、页码、摘要、目录、参考文献、脚注、页眉、页脚、算法、公式、公式编号、图像、图表标题、表格、表格标题、印章、图表标题、图表、页眉图像、页脚图像、侧栏文本
模型模型下载链接 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在中英文论文、杂志、合同、书本、试卷和研报等场景上自建数据集训练的高效率版面区域定位模型
>❗ 以上列出的是版面检测模块重点支持的3个核心模型，该模块总共支持11个全量模型，包含多个预定义了不同类别的模型，其中包含印章类别的模型有9个，除上述3个核心模型外，其余模型列表如下：
👉模型列表详情 * 3类版面检测模型，包含表格、图像、印章
模型模型下载链接 mAP(0.5)（%） GPU推理耗时（ms）
[常规模式 / 高性能模式]		 CPU推理耗时（ms）
[常规模式 / 高性能模式]		 模型存储大小（MB） 介绍
PicoDet-S_layout_3cls 推理模型/训练模型 88.2 8.43 / 3.44 17.60 / 6.51 4.8 基于PicoDet-S轻量模型在中英文论文、杂志和研报等场景上自建数据集训练的高效率版面区域定位模型
PicoDet-L_layout_3cls 推理模型/训练模型 89.0 12.80 / 9.57 45.04 / 23.86 22.6 基于PicoDet-L在中英文论文、杂志和研报等场景上自建数据集训练的效率精度均衡版面区域定位模型
RT-DETR-H_layout_3cls 推理模型/训练模型 95.8 114.80 / 25.65 924.38 / 924.38 470.1 基于RT-DETR-H在中英文论文、杂志和研报等场景上自建数据集训练的高精度版面区域定位模型
* 17类区域检测模型，包含17个版面常见类别，分别是：段落标题、图片、文本、数字、摘要、内容、图表标题、公式、表格、表格标题、参考文献、文档标题、脚注、页眉、算法、页脚、印章
模型模型下载链接 mAP(0.5)（%） GPU推理耗时（ms）
[常规模式 / 高性能模式]		 CPU推理耗时（ms）
[常规模式 / 高性能模式]		 模型存储大小（MB） 介绍
PicoDet-S_layout_17cls 推理模型/训练模型 87.4 8.80 / 3.62 17.51 / 6.35 4.8 基于PicoDet-S轻量模型在中英文论文、杂志和研报等场景上自建数据集训练的高效率版面区域定位模型
PicoDet-L_layout_17cls 推理模型/训练模型 89.0 12.60 / 10.27 43.70 / 24.42 22.6 基于PicoDet-L在中英文论文、杂志和研报等场景上自建数据集训练的效率精度均衡版面区域定位模型
RT-DETR-H_layout_17cls 推理模型/训练模型 98.3 115.29 / 101.18 964.75 / 964.75 470.2 基于RT-DETR-H在中英文论文、杂志和研报等场景上自建数据集训练的高精度版面区域定位模型

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

模型模型下载链接 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 高精度文本图像矫正模型

文本检测模块：

模型模型下载链接 检测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的移动端印章文本检测模型，效率更高，适合在端侧部署

文本识别模块：

模型模型下载链接 识别 Avg Accuracy(%) GPU推理耗时（ms）
[常规模式 / 高性能模式]		 CPU推理耗时（ms）
[常规模式 / 高性能模式]		 模型存储大小（MB） 介绍
PP-OCRv5_server_rec 推理模型/训练模型 86.38 8.46 / 2.36 31.21 / 31.21 81 PP-OCRv5_rec 是新一代文本识别模型。该模型致力于以单一模型高效、精准地支持简体中文、繁体中文、英文、日文四种主要语言，以及手写、竖版、拼音、生僻字等复杂文本场景的识别。在保持识别效果的同时，兼顾推理速度和模型鲁棒性，为各种场景下的文档理解提供高效、精准的技术支撑。
PP-OCRv5_mobile_rec 推理模型/训练模型 81.29 5.43 / 1.46 21.20 / 5.32 16
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的服务器端模型，推理精度高，可以部署在多种不同的服务器上
en_PP-OCRv4_mobile_rec 推理模型/训练模型 70.39 4.81 / 1.23 17.20 / 4.18 7.5 基于PP-OCRv4识别模型训练得到的超轻量英文识别模型，支持英文、数字识别
> ❗ 以上列出的是文本识别模块重点支持的4个核心模型，该模块总共支持18个全量模型，包含多个多语言文本识别模型，完整的模型列表如下：
👉模型列表详情 * PP-OCRv5 多场景模型
模型模型下载链接 中文识别 Avg Accuracy(%) 英文识别 Avg Accuracy(%) 繁体中文识别 Avg Accuracy(%) 日文识别 Avg Accuracy(%) GPU推理耗时（ms）
[常规模式 / 高性能模式]		 CPU推理耗时（ms）
[常规模式 / 高性能模式]		 模型存储大小（MB） 介绍
PP-OCRv5_server_rec 推理模型/训练模型 86.38 64.70 93.29 60.35 8.46 / 2.36 31.21 / 31.21 81 PP-OCRv5_rec 是新一代文本识别模型。该模型致力于以单一模型高效、精准地支持简体中文、繁体中文、英文、日文四种主要语言，以及手写、竖版、拼音、生僻字等复杂文本场景的识别。在保持识别效果的同时，兼顾推理速度和模型鲁棒性，为各种场景下的文档理解提供高效、精准的技术支撑。
PP-OCRv5_mobile_rec 推理模型/训练模型 81.29 66.00 83.55 54.65 5.43 / 1.46 21.20 / 5.32 16
* 中文识别模型
模型模型下载链接 识别 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识别模型训练得到的超轻量梵文字母识别模型，支持梵文字母、数字识别
测试环境说明:
模式 GPU配置 CPU配置 加速技术组合
常规模式 FP32精度 / 无TRT加速 FP32精度 / 8线程 PaddleInference
高性能模式 选择先验精度类型和加速策略的最优组合 FP32精度 / 8线程 选择先验最优后端（Paddle/OpenVINO/TRT等）
### 1.2 产线基准测试数据
点击展开/折叠表格
流水线配置硬件平均推理时间 (ms)峰值CPU利用率 (%)平均CPU利用率 (%)峰值主机内存 (MB)平均主机内存 (MB)峰值GPU利用率 (%)平均GPU利用率 (%)峰值设备内存 (MB)平均设备内存 (MB)
seal_recognition-default Intel 6271C 1441.99 1013.50 1005.77 2850.27 2593.21 N/A N/A N/A N/A
Intel 8350C 1303.84 1010.40 970.29 2797.28 2550.80 N/A N/A N/A N/A
Hygon 7490 + P800 102.05 115.80 112.72 1647.39 1636.58 N/A N/A N/A N/A
Intel 8350C + A100 67.80 117.90 115.03 1519.09 1501.98 42 36.22 2508.00 2245.78
Intel 6271C + V100 115.01 117.80 115.16 1425.80 1402.56 49 40.27 1862.00 1700.93
Intel 8563C + H20 77.40 117.40 111.64 1721.26 1706.75 64 54.90 2502.00 2316.00
Intel 8350C + A10 79.64 125.80 118.96 1727.16 1711.59 60 48.55 2212.00 2042.91
M4 1543.47 104.70 101.57 4526.11 2082.03 N/A N/A N/A N/A
Intel 6271C + T4 155.57 110.20 108.01 1690.79 1667.58 82 70.95 1564.00 1397.90
seal_recognition-nopp Intel 6271C 1109.72 1014.70 1009.28 3062.18 2793.37 N/A N/A N/A N/A
Intel 8350C 1203.15 1012.60 1006.68 3079.39 2766.63 N/A N/A N/A N/A
Hygon 7490 + P800 119.58 116.90 115.51 1608.80 1608.61 N/A N/A N/A N/A
Intel 8350C + A100 76.98 118.90 117.49 1440.84 1433.75 51 45.50 2586.00 2302.80
Intel 6271C + V100 124.81 119.80 117.69 1451.77 1440.18 53 46.24 2078.00 1900.35
Intel 8563C + H20 102.76 117.90 111.53 1722.02 1711.42 72 67.92 2438.00 2247.23
Intel 8350C + A10 95.30 120.80 118.38 1642.00 1628.48 63 59.62 2430.00 2239.23
M4 2343.35 104.30 101.47 4436.23 2145.62 N/A N/A N/A N/A
Intel 6271C + T4 199.46 109.80 107.97 1628.87 1614.33 82 76.56 1844.00 1662.80
seal_recognition-nopp-nolayout Intel 6271C 662.30 1021.40 1014.05 2541.84 2317.52 N/A N/A N/A N/A
Intel 8350C 765.66 1013.70 1009.71 2558.11 2321.48 N/A N/A N/A N/A
Hygon 7490 + P800 102.32 113.90 112.78 1556.05 1555.78 N/A N/A N/A N/A
Intel 8350C + A100 63.93 122.90 120.53 1323.04 1314.25 51 44.89 1814.00 1814.00
Intel 6271C + V100 97.27 123.80 121.95 1349.10 1344.00 55 48.31 1208.00 1208.00
Intel 8563C + H20 97.39 116.90 113.28 1620.22 1601.19 74 65.77 1850.00 1850.00
Intel 8350C + A10 81.86 123.50 120.70 1477.95 1465.51 68 56.82 1570.00 1570.00
M4 2045.01 103.60 101.33 4115.47 2480.96 N/A N/A N/A N/A
Intel 6271C + T4 174.25 112.10 109.61 1477.02 1466.66 88 78.00 976.00 976.00
seal_recognition-nopp-lightweight Intel 6271C 647.56 1015.50 1010.90 1701.61 1682.21 N/A N/A N/A N/A
Intel 8350C 600.89 1011.70 1004.39 1794.69 1702.02 N/A N/A N/A N/A
Hygon 7490 + P800 71.31 120.90 118.70 1601.37 1592.34 N/A N/A N/A N/A
Intel 8350C + A100 61.25 123.90 121.47 1483.47 1471.42 25 22.38 926.00 926.00
Intel 6271C + V100 90.24 125.80 124.22 1410.70 1399.48 27 24.00 724.00 724.00
Intel 8563C + H20 49.11 131.90 124.07 1820.23 1809.12 29 25.00 940.00 940.00
Intel 8350C + A10 62.53 131.80 129.06 1668.08 1656.94 38 31.33 680.00 680.00
M4 696.42 106.60 104.71 1176.22 1155.02 N/A N/A N/A N/A
Intel 6271C + T4 89.92 120.80 117.79 1492.52 1481.60 49 44.25 490.00 490.00
seal_recognition-nopp-lightweightlayout Intel 6271C 256.55 1018.90 1012.30 2759.20 2417.41 N/A N/A N/A N/A
Intel 8350C 294.96 1017.60 1009.56 2718.50 2400.95 N/A N/A N/A N/A
Hygon 7490 + P800 55.61 136.30 128.47 1565.15 1564.68 N/A N/A N/A N/A
Intel 8350C + A100 39.48 115.90 115.12 1313.98 1305.40 42 31.33 2896.00 2896.00
Intel 6271C + V100 60.79 119.80 117.14 1268.04 1257.68 54 32.00 1956.00 1956.00
Intel 8563C + H20 48.73 119.00 111.67 1735.01 1709.83 66 55.43 2394.00 2394.00
Intel 8350C + A10 46.02 118.90 118.48 1596.27 1585.00 63 42.83 2376.00 2376.00
M4 789.23 112.40 102.80 6106.27 2249.03 N/A N/A N/A N/A
Intel 6271C + T4 79.36 111.90 108.66 1510.57 1502.12 83 53.82 1714.00 1714.00
seal_recognition-nopp-nolayout-lightweight Intel 6271C 149.97 1027.50 1022.43 1245.17 1206.22 N/A N/A N/A N/A
Intel 8350C 126.58 1024.70 1014.78 1211.13 1194.93 N/A N/A N/A N/A
Hygon 7490 + P800 57.79 131.70 128.79 1532.17 1513.78 N/A N/A N/A N/A
Intel 8350C + A100 42.42 133.00 129.92 1169.25 1167.00 13 12.17 610.00 610.00
Intel 6271C + V100 68.18 132.70 128.90 1269.38 1264.15 13 11.44 488.00 488.00
Intel 8563C + H20 39.22 134.90 128.48 1530.35 1520.96 12 11.00 690.00 681.67
Intel 8350C + A10 47.19 141.90 139.48 1458.07 1454.14 16 13.57 398.00 398.00
M4 275.15 110.30 109.19 1100.36 1097.53 N/A N/A N/A N/A
Intel 6271C + T4 68.63 125.90 123.15 1389.43 1379.54 32 30.44 254.00 254.00
Pipeline configurationdescription
seal_recognition-default 默认配置
seal_recognition-nopp 默认配置基础上，关闭文档图像预处理
seal_recognition-nopp-nolayout 默认配置基础上，关闭文档图像预处理
seal_recognition-nopp-lightweight 默认配置基础上，关闭文档图像预处理，使用轻量级的 PP-OCRv4_mobile_seal_det 和 PP-OCRv4_mobile_rec 模型
seal_recognition-nopp-lightweightlayout 默认配置基础上，关闭文档图像预处理，使用轻量级版面区域检测模型 PP-DocLayout-S
seal_recognition-nopp-nolayout-lightweight 默认配置基础上，关闭文档图像预处理，关闭版面区域检测，使用轻量级的 PP-OCRv4_mobile_seal_det 和 PP-OCRv4_mobile_rec 模型
* 测试环境： * PaddlePaddle 3.1.0、CUDA 11.8、cuDNN 8.9 * PaddleX @ develop (f1eb28e23cfa54ce3e9234d2e61fcb87c93cf407) * Docker image: ccr-2vdh3abv-pub.cnc.bj.baidubce.com/paddlepaddle/paddle:3.1.0-gpu-cuda11.8-cudnn8.9 * 备注： * 由于我们没有收集NPU和XPU的设备内存数据，因此表中相应位置的数据标记为N/A。 ## 2. 快速开始 PaddleX 所提供的模型产线均可以快速体验效果，你可以在星河社区线体验印章文本识别产线的效果，也可以在本地使用命令行或 Python 体验印章文本识别产线的效果。 ### 2.1 在线体验 您可以[在线体验](https://aistudio.baidu.com/community/app/387977/webUI?source=appCenter)印章文本识别产线的效果，用官方提供的 Demo 图片进行识别，例如： 如果您对产线运行的效果满意，可以直接进行集成部署。您可以选择从云端下载部署包，也可以参考[2.2节本地体验](#22-本地体验)中的方法进行本地部署。如果对效果不满意，您可以利用私有数据对产线中的模型进行微调训练。如果您具备本地训练的硬件资源，可以直接在本地开展训练；如果没有，星河零代码平台提供了一键式训练服务，无需编写代码，只需上传数据后，即可一键启动训练任务。 ### 2.2 本地体验 ❗ 在本地使用印章文本识别产线前，请确保您已经按照[PaddleX安装教程](../../../installation/installation.md)完成了PaddleX的wheel包安装。如果您希望选择性安装依赖，请参考安装教程中的相关说明。该产线对应的依赖分组为 `ocr`。 #### 2.2.1 命令行方式体验 一行命令即可快速体验印章文本识别产线效果，使用 [测试文件](https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/seal_text_det.png)，并将 `--input` 替换为本地路径，进行预测 ```bash paddlex --pipeline seal_recognition \ --input seal_text_det.png \ --use_doc_orientation_classify False \ --use_doc_unwarping False \ --device gpu:0 \ --save_path ./output ``` 注：PaddleX 官方模型默认从 HuggingFace 获取，如运行环境访问 HuggingFace 不便，可通过环境变量修改模型源为 BOS：`PADDLE_PDX_MODEL_SOURCE="BOS"`，未来将支持更多主流模型源； 相关的参数说明可以参考[2.1.2 Python脚本方式集成](#212-python脚本方式集成)中的参数说明。支持同时指定多个设备以进行并行推理，详情请参考 [产线并行推理](../../instructions/parallel_inference.md#指定多个推理设备)。 运行后，会将结果打印到终端上，结果如下：
👉点击展开 ```bash {'res': {'input_path': 'seal_text_det.png', 'model_settings': {'use_doc_preprocessor': False, 'use_layout_detection': True}, 'layout_det_res': {'input_path': None, 'page_index': None, 'boxes': [{'cls_id': 16, 'label': 'seal', 'score': 0.975531280040741, 'coordinate': [6.195526, 0.1579895, 634.3982, 628.84595]}]}, 'seal_res_list': [{'input_path': None, 'page_index': None, 'model_settings': {'use_doc_preprocessor': False, 'use_textline_orientation': False}, 'dt_polys': [array([[320, 38], ..., [315, 38]]), array([[461, 347], ..., [456, 346]]), array([[439, 445], ..., [434, 444]]), array([[158, 468], ..., [154, 466]])], 'text_det_params': {'limit_side_len': 736, 'limit_type': 'min', 'thresh': 0.2, 'box_thresh': 0.6, 'unclip_ratio': 0.5}, 'text_type': 'seal', 'textline_orientation_angles': array([-1, ..., -1]), 'text_rec_score_thresh': 0, 'rec_texts': ['天津君和缘商贸有限公司', '发票专用章', '吗繁物', '5263647368706'], 'rec_scores': array([0.9934051 , ..., 0.99139398]), 'rec_polys': [array([[320, 38], ..., [315, 38]]), array([[461, 347], ..., [456, 346]]), array([[439, 445], ..., [434, 444]]), array([[158, 468], ..., [154, 466]])], 'rec_boxes': array([], dtype=float64)}]}} ```
运行结果参数说明可以参考[2.1.2 Python脚本方式集成](#212-python脚本方式集成)中的结果解释。 可视化结果保存在`save_path`下，其中印章OCR的可视化结果如下： #### 2.2.2 Python脚本方式集成 * 上述命令行是为了快速体验查看效果，一般来说，在项目中，往往需要通过代码集成，您可以通过几行代码即可完成产线的快速推理，推理代码如下： ```python from paddlex import create_pipeline pipeline = create_pipeline(pipeline="seal_recognition") output = pipeline.predict( "seal_text_det.png", use_doc_orientation_classify=False, use_doc_unwarping=False, ) for res in output: res.print() ## 打印预测的结构化输出 res.save_to_img("./output/") ## 保存可视化结果 res.save_to_json("./output/") ## 保存可视化结果 ``` 在上述 Python 脚本中，执行了如下几个步骤： （1）通过 `create_pipeline()` 实例化 印章文本识别 产线对象，具体参数说明如下：
参数 参数说明 参数类型 默认值
pipeline 产线名称或是产线配置文件路径。如为产线名称，则必须为 PaddleX 所支持的产线。 str None
config 产线具体的配置信息（如果和pipeline同时设置，优先级高于pipeline，且要求产线名和pipeline一致）。 dict[str, Any] None
device 产线推理设备。支持指定GPU具体卡号，如“gpu:0”，其他硬件具体卡号，如“npu:0”，CPU如“cpu”。支持同时指定多个设备以进行并行推理，详情请参考产线并行推理文档。 str gpu:0
use_hpip 是否启用高性能推理插件。如果为 None，则使用配置文件或 config 中的配置。 bool | None 无 None
hpi_config 高性能推理配置 dict | None 无 None
（2）调用 印章文本识别 产线对象的 `predict()` 方法进行推理预测。该方法将返回一个 `generator`。以下是 `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_layout_detection 是否使用版面检测模块 bool|None
  • bool：True 或者 False；
  • None：如果设置为None, 将默认使用产线初始化的该参数值，初始化为True；
 None
layout_threshold 版面检测置信度阈值，得分大于该阈值才会被输出 float|dict|None
  • float：大于 0 的任意浮点数
  • dict：key是int类别id， value是大于 0 的任意浮点数
  • None：如果设置为 None, 将默认使用产线初始化的该参数值 0.5
 None
layout_nms 是否使用版面检测后处理NMS bool|None
  • bool：True 或者 False；
  • None：如果设置为None, 将默认使用产线初始化的该参数值，初始化为True；
 None
layout_unclip_ratio 检测框的边长缩放倍数；如果不指定，将默认使用PaddleX官方模型配置 float|list|None
  • float, 大于0的浮点数，如 1.1 , 表示将模型输出的检测框中心不变，宽和高都扩张1.1倍
  • 列表, 如 [1.2, 1.5] , 表示将模型输出的检测框中心不变，宽度扩张1.2倍，高度扩张1.5倍
  • None：如果设置为None, 将默认使用产线初始化的该参数值，初始化为1.0
layout_merge_bboxes_mode 模型输出的检测框的合并处理模式；如果不指定，将默认使用PaddleX官方模型配置 string|None
  • large, 设置为large时，表示在模型输出的检测框中，对于互相重叠包含的检测框，只保留外部最大的框，删除重叠的内部框。
  • small, 设置为small，表示在模型输出的检测框中，对于互相重叠包含的检测框，只保留内部被包含的小框，删除重叠的外部框。
  • union, 不进行框的过滤处理，内外框都保留
  • None：如果设置为None, 将默认使用产线初始化的该参数值，初始化为large
 None
seal_det_limit_side_len 印章文本检测的图像边长限制 int|None
  • int：大于 0 的任意整数；
  • None：如果设置为 None, 将默认使用产线初始化的该参数值，初始化为 736；
 None
seal_det_limit_type 印章文本检测的图像边长限制类型 str|None
  • str：支持 min 和 max，min 表示保证图像最短边不小于 det_limit_side_len，max 表示保证图像最长边不大于 limit_side_len
  • None：如果设置为 None, 将默认使用产线初始化的该参数值，初始化为 min；
 None
seal_det_thresh 检测像素阈值，输出的概率图中，得分大于该阈值的像素点才会被认为是文字像素点 float|None
  • float：大于 0 的任意浮点数
  • None：如果设置为 None, 将默认使用产线初始化的该参数值 0.2
 None
seal_det_box_thresh 检测框阈值，检测结果边框内，所有像素点的平均得分大于该阈值时，该结果会被认为是文字区域 float|None
  • float：大于 0 的任意浮点数
  • None：如果设置为 None, 将默认使用产线初始化的该参数值 0.6
 None
seal_det_unclip_ratio 文本检测扩张系数，使用该方法对文字区域进行扩张，该值越大，扩张的面积越大 float|None
  • float：大于 0 的任意浮点数
  • None：如果设置为 None, 将默认使用产线初始化的该参数值 0.5
 None
seal_rec_score_thresh 文本识别阈值，得分大于该阈值的文本结果会被保留 float|None
  • float：大于 0 的任意浮点数
  • None：如果设置为 None, 将默认使用产线初始化的该参数值 0.0。即不设阈值
 None
（3）对预测结果进行处理，每个样本的预测结果均为对应的Result对象，且支持打印、保存为图片、保存为`json`文件的操作:
方法 方法说明 参数 参数类型 参数说明 默认值
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() 将结果保存为图像格式的文件 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_layout_detection`: `(bool)` 控制是否启用版面检测子模块 - `layout_det_res`: `(Dict[str, Union[List[numpy.ndarray], List[float]]])` 版面检测子模块的输出结果。仅当`use_layout_detection=True`时存在 - `input_path`: `(Union[str, None])` 版面检测区域模块接受的图像路径，当输入为`numpy.ndarray`时，保存为`None` - `page_index`: `(Union[int, None])` 如果输入是PDF文件，则表示当前是PDF的第几页，否则为 `None` - `boxes`: `(List[Dict])` 版面印章区域的检测框列表，每个列表中的元素，包含以下字段 - `cls_id`: `(int)` 检测框的印章类别id - `score`: `(float)` 检测框的置信度 - `coordinate`: `(List[float])` 检测框的四个顶点坐标，顺序为x1,y1,x2,y2表示左上角的x坐标，左上角的y坐标，右下角x坐标，右下角的y坐标 - `seal_res_list`: `List[Dict]` 印章文本识别的结果列表，每个元素包含以下字段 - `input_path`: `(Union[str, None])` 印章文本识别产线接受的图像路径，当输入为`numpy.ndarray`时，保存为`None` - `page_index`: `(Union[int, None])` 如果输入是PDF文件，则表示当前是PDF的第几页，否则为 `None` - `model_settings`: `(Dict[str, bool])` 印章文本识别产线的模型配置参数 - `use_doc_preprocessor`: `(bool)` 控制是否启用文档预处理子产线 - `use_textline_orientation`: `(bool)` 控制是否启用文本行方向分类子模块 - `doc_preprocessor_res`: `(Dict[str, Union[str, Dict[str, bool], int]])` 文档预处理子产线的输出结果。仅当`use_doc_preprocessor=True`时存在 - `input_path`: `(Union[str, None])` 图像预处理子产线接受的图像路径，当输入为`numpy.ndarray`时，保存为`None` - `model_settings`: `(Dict)` 预处理子产线的模型配置参数 - `use_doc_orientation_classify`: `(bool)` 控制是否启用文档方向分类 - `use_doc_unwarping`: `(bool)` 控制是否启用文档扭曲矫正 - `angle`: `(int)` 文档方向分类的预测结果。启用时取值为[0,1,2,3]，分别对应[0°,90°,180°,270°]；未启用时为-1 - `dt_polys`: `(List[numpy.ndarray])` 印章文本检测的多边形框列表。每个检测框由多个顶点坐标构成的numpy数组表示，数组shape为(n, 2) - `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)` 印章文本检测的类型，当前固定为"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)` 检测框的矩形边界框数组，印章识别产线为空数组 - 调用`save_to_json()` 方法会将上述内容保存到指定的`save_path`中，如果指定为目录，则保存的路径为`save_path/{your_img_basename}_res.json`，如果指定为文件，则直接保存到该文件中。由于json文件不支持保存numpy数组，因此会将其中的`numpy.array`类型转换为列表形式。 - 调用`save_to_img()` 方法会将可视化结果保存到指定的`save_path`中，如果指定为目录，则保存的路径为`save_path/{your_img_basename}_seal_res_region1.{your_img_extension}`，如果指定为文件，则直接保存到该文件中。(产线通常包含较多结果图片，不建议直接指定为具体的文件路径，否则多张图会被覆盖，仅保留最后一张图) * 此外，也支持通过属性获取带结果的可视化图像和预测结果，具体如下：
属性 属性说明
json 获取预测的 json 格式的结果
img 获取格式为 dict 的可视化图像
- `json` 属性获取的预测结果为dict类型的数据，相关内容与调用 `save_to_json()` 方法保存的内容一致。 - `img` 属性返回的预测结果是一个字典类型的数据。其中，键分别为 `layout_det_res` 、 `seal_res_region1`和 `preprocessed_img`，对应的值是三个 `Image.Image` 对象：一个用于显示版面检测可视化，一个用于显示印章文本识别结果的可视化图像，另一个用于展示图像预处理的可视化图像。如果没有使用图像预处理子模块，则字典中不包含preprocessed_img，如果没有使用版面区域检测模块，则字典中不包含layout_det_res。 此外，您可以获取印章文本识别产线配置文件，并加载配置文件进行预测。可执行如下命令将结果保存在 `my_path` 中： ``` paddlex --get_pipeline_config seal_recognition --save_path ./my_path ``` 若您获取了配置文件，即可对印章文本识别产线各项配置进行自定义，只需要修改 `create_pipeline` 方法中的 `pipeline` 参数值为产线配置文件路径即可。示例如下： ```python from paddlex import create_pipeline pipeline = create_pipeline(pipeline="./my_path/seal_recognition.yaml") output = pipeline.predict("seal_text_det.png") for res in output: res.print() ## 打印预测的结构化输出 res.save_to_img("./output/") ## 保存可视化结果 res.save_to_json("./output/") ## 保存预测结果的json文件 ``` 注： 配置文件中的参数为产线初始化参数，如果希望更改印章文本识别产线初始化参数，可以直接修改配置文件中的参数，并加载配置文件进行预测。同时，CLI 预测也支持传入配置文件，`--pipeline` 指定配置文件的路径即可。 ## 3. 开发集成/部署 如果产线可以达到您对产线推理速度和精度的要求，您可以直接进行开发集成/部署。 若您需要将产线直接应用在您的Python项目中，可以参考 [2.2.2 Python脚本方式](#222-python脚本方式集成)中的示例代码。 此外，PaddleX 也提供了其他三种部署方式，详细说明如下： 🚀 高性能部署：在实际生产环境中，许多应用对部署策略的性能指标（尤其是响应速度）有着较严苛的标准，以确保系统的高效运行与用户体验的流畅性。为此，PaddleX 提供高性能推理插件，旨在对模型推理及前后处理进行深度性能优化，实现端到端流程的显著提速，详细的高性能部署流程请参考[PaddleX高性能部署指南](../../../pipeline_deploy/high_performance_inference.md)。 ☁️ 服务化部署：服务化部署是实际生产环境中常见的一种部署形式。通过将推理功能封装为服务，客户端可以通过网络请求来访问这些服务，以获取推理结果。PaddleX 支持多种产线服务化部署方案，详细的产线服务化部署流程请参考[PaddleX服务化部署指南](../../../pipeline_deploy/serving.md)。 以下是基础服务化部署的API参考与多语言服务调用示例：
API参考

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

名称 类型 含义
logId string 请求的UUID。
errorCode integer 错误码。固定为0。
errorMsg string 错误说明。固定为"Success"。
result object 操作结果。
名称 类型 含义
logId string 请求的UUID。
errorCode integer 错误码。与响应状态码相同。
errorMsg string 错误说明。

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

获取印章文本识别结果。

POST /seal-recognition

名称 类型 含义 是否必填
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 请参阅产线对象中 predict 方法的 use_doc_orientation_classify 参数相关说明。 否
useDocUnwarping boolean | null 请参阅产线对象中 predict 方法的 use_doc_unwarping 参数相关说明。 否
useLayoutDetection boolean | null 请参阅产线对象中 predict 方法的 use_layout_detection 参数相关说明。 否
layoutThreshold number | object | null 请参阅产线对象中 predict 方法的 layout_threshold 参数相关说明。 否
layoutNms boolean | null 请参阅产线对象中 predict 方法的 layout_nms 参数相关说明。 否
layoutUnclipRatio number | array | null 请参阅产线对象中 predict 方法的 layout_unclip_ratio 参数相关说明。 否
layoutMergeBboxesMode string | null 请参阅产线对象中 predict 方法的 layout_merge_bboxes_mode 参数相关说明。 否
sealDetLimitSideLen integer | null 请参阅产线对象中 predict 方法的 seal_det_limit_side_len 参数相关说明。 否
sealDetLimitType string | null 请参阅产线对象中 predict 方法的 seal_det_limit_type 参数相关说明。 否
sealDetThresh number | null 请参阅产线对象中 predict 方法的 seal_det_thresh 参数相关说明。 否
sealDetBoxThresh number | null 请参阅产线对象中 predict 方法的 seal_det_box_thresh 参数相关说明。 否
sealDetUnclipRatio number | null 请参阅产线对象中 predict 方法的 seal_det_unclip_ratio 参数相关说明。 否
sealRecScoreThresh number | null 请参阅产线对象中 predict 方法的 seal_rec_score_thresh 参数相关说明。 否
visualize boolean | null 是否返回可视化结果图以及处理过程中的中间图像等。
  • 传入 true：返回图像。
  • 传入 false：不返回图像。
  • 若请求体中未提供该参数或传入 null：遵循产线配置文件Serving.visualize 的设置。

例如，在产线配置文件中添加如下字段：
Serving:
  visualize: False
将默认不返回图像，通过请求体中的visualize参数可以覆盖默认行为。如果请求体和配置文件中均未设置（或请求体传入null、配置文件中未设置），则默认返回图像。 		否
名称 类型 含义
sealRecResults object 印章文本识别结果。数组长度为1（对于图像输入）或实际处理的文档页数（对于PDF输入）。对于PDF输入，数组中的每个元素依次表示PDF文件中实际处理的每一页的结果。
dataInfo object 输入数据信息。

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

名称 类型 含义
prunedResult object 产线对象的 predict 方法生成结果的 JSON 表示中 res 字段的简化版本，其中去除了 input_path 和 page_index 字段。
outputImages object | null 参见产线预测结果的 img 属性说明。图像为JPEG格式，使用Base64编码。
inputImage string | null 输入图像。图像为JPEG格式，使用Base64编码。
多语言调用服务示例
Python 
import base64
import requests

API_URL = "http://localhost:8080/seal-recognition"
file_path = "./demo.jpg"

with open(file_path, "rb") as file:
    file_bytes = file.read()
    file_data = base64.b64encode(file_bytes).decode("ascii")

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

response = requests.post(API_URL, json=payload)

assert response.status_code == 200
result = response.json()["result"]
for i, res in enumerate(result["sealRecResults"]):
    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}")
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

int main() {
    httplib::Client client("localhost", 8080);

    const std::string filePath = "./demo.jpg";

    std::ifstream file(filePath, std::ios::binary | std::ios::ate);
    if (!file) {
        std::cerr << "Error opening file: " << filePath << std::endl;
        return 1;
    }

    std::streamsize size = file.tellg();
    file.seekg(0, std::ios::beg);
    std::vector buffer(size);
    if (!file.read(buffer.data(), size)) {
        std::cerr << "Error reading file." << std::endl;
        return 1;
    }

    std::string bufferStr(buffer.data(), static_cast(size));
    std::string encodedFile = base64::to_base64(bufferStr);

    nlohmann::json jsonObj;
    jsonObj["file"] = encodedFile;
    jsonObj["fileType"] = 1;

    auto response = client.Post("/seal-recognition", jsonObj.dump(), "application/json");

    if (response && response->status == 200) {
        nlohmann::json jsonResponse = nlohmann::json::parse(response->body);
        auto result = jsonResponse["result"];

        if (!result.is_object() || !result["sealRecResults"].is_array()) {
            std::cerr << "Unexpected response format." << std::endl;
            return 1;
        }

        for (size_t i = 0; i < result["sealRecResults"].size(); ++i) {
            auto res = result["sealRecResults"][i];

            if (res.contains("prunedResult")) {
                std::cout << "Recognized seal result: " << res["prunedResult"].dump() << std::endl;
            }

            if (res.contains("outputImages") && res["outputImages"].is_object()) {
                for (auto& [imgName, imgData] : res["outputImages"].items()) {
                    std::string outputPath = imgName + "_" + std::to_string(i) + ".jpg";
                    std::string decodedImage = base64::from_base64(imgData.get());

                    std::ofstream outFile(outputPath, std::ios::binary);
                    if (outFile.is_open()) {
                        outFile.write(decodedImage.c_str(), decodedImage.size());
                        outFile.close();
                        std::cout << "Saved image: " << outputPath << std::endl;
                    } else {
                        std::cerr << "Failed to write image: " << outputPath << std::endl;
                    }
                }
            }
        }
    } else {
        std::cerr << "Request failed." << std::endl;
        if (response) {
            std::cerr << "HTTP status: " << response->status << std::endl;
            std::cerr << "Response body: " << response->body << std::endl;
        }
        return 1;
    }

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

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

public class Main {
    public static void main(String[] args) throws IOException {
        String API_URL = "http://localhost:8080/seal-recognition";
        String imagePath = "./demo.jpg";

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

        ObjectMapper objectMapper = new ObjectMapper();
        ObjectNode payload = objectMapper.createObjectNode();
        payload.put("file", base64Image);
        payload.put("fileType", 1);

        OkHttpClient client = new OkHttpClient();
        MediaType JSON = MediaType.get("application/json; charset=utf-8");
        RequestBody body = RequestBody.create(JSON, payload.toString());

        Request request = new Request.Builder()
                .url(API_URL)
                .post(body)
                .build();

        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                String responseBody = response.body().string();
                JsonNode root = objectMapper.readTree(responseBody);
                JsonNode result = root.get("result");

                JsonNode sealRecResults = result.get("sealRecResults");
                for (int i = 0; i < sealRecResults.size(); i++) {
                    JsonNode item = sealRecResults.get(i);
                    int finalI = i;

                    JsonNode prunedResult = item.get("prunedResult");
                    System.out.println("Pruned Result [" + i + "]: " + prunedResult.toString());

                    JsonNode outputImages = item.get("outputImages");
                    if (outputImages != null && outputImages.isObject()) {
                        outputImages.fieldNames().forEachRemaining(imgName -> {
                            try {
                                String imgBase64 = outputImages.get(imgName).asText();
                                byte[] imgBytes = Base64.getDecoder().decode(imgBase64);
                                String imgPath = imgName + "_" + finalI + ".jpg";
                                try (FileOutputStream fos = new FileOutputStream(imgPath)) {
                                    fos.write(imgBytes);
                                    System.out.println("Saved image: " + imgPath);
                                }
                            } catch (IOException e) {
                                System.err.println("Failed to save image: " + e.getMessage());
                            }
                        });
                    }
                }
            } else {
                System.err.println("Request failed with HTTP code: " + response.code());
            }
        }
    }
}
Go 
package main

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

func main() {
    API_URL := "http://localhost:8080/seal-recognition"
    filePath := "./demo.jpg"

    fileBytes, err := ioutil.ReadFile(filePath)
    if err != nil {
        fmt.Printf("Error reading file: %v\n", err)
        return
    }
    fileData := base64.StdEncoding.EncodeToString(fileBytes)

    payload := map[string]interface{}{
        "file":     fileData,
        "fileType": 1,
    }
    payloadBytes, err := json.Marshal(payload)
    if err != nil {
        fmt.Printf("Error marshaling payload: %v\n", err)
        return
    }

    client := &http.Client{}
    req, err := http.NewRequest("POST", API_URL, bytes.NewBuffer(payloadBytes))
    if err != nil {
        fmt.Printf("Error creating request: %v\n", err)
        return
    }
    req.Header.Set("Content-Type", "application/json")

    resp, err := client.Do(req)
    if err != nil {
        fmt.Printf("Error sending request: %v\n", err)
        return
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        fmt.Printf("Unexpected status code: %d\n", resp.StatusCode)
        return
    }

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Printf("Error reading response body: %v\n", err)
        return
    }

    type SealResult struct {
        PrunedResult map[string]interface{}   `json:"prunedResult"`
        OutputImages map[string]string        `json:"outputImages"`
        InputImage   *string                  `json:"inputImage"`
    }

    type Response struct {
        Result struct {
            SealRecResults []SealResult  `json:"sealRecResults"`
            DataInfo       interface{}   `json:"dataInfo"`
        } `json:"result"`
    }

    var respData Response
    if err := json.Unmarshal(body, &respData); err != nil {
        fmt.Printf("Error unmarshaling response: %v\n", err)
        return
    }

    for i, res := range respData.Result.SealRecResults {
        fmt.Printf("Pruned Result %d: %+v\n", i, res.PrunedResult)

        for name, imgBase64 := range res.OutputImages {
            imgBytes, err := base64.StdEncoding.DecodeString(imgBase64)
            if err != nil {
                fmt.Printf("Error decoding image %s: %v\n", name, err)
                continue
            }

            filename := fmt.Sprintf("%s_%d.jpg", name, i)
            if err := ioutil.WriteFile(filename, imgBytes, 0644); err != nil {
                fmt.Printf("Error saving image %s: %v\n", filename, err)
                continue
            }
            fmt.Printf("Output image saved at %s\n", filename)
        }
    }
}
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_URL = "http://localhost:8080/seal-recognition";
    static readonly string inputFilePath = "./demo.jpg";

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

        byte[] fileBytes = File.ReadAllBytes(inputFilePath);
        string fileData = Convert.ToBase64String(fileBytes);

        var payload = new JObject
        {
            { "file", fileData },
            { "fileType", 1 }
        };
        var content = new StringContent(payload.ToString(), Encoding.UTF8, "application/json");

        HttpResponseMessage response = await httpClient.PostAsync(API_URL, content);
        response.EnsureSuccessStatusCode();

        string responseBody = await response.Content.ReadAsStringAsync();
        JObject jsonResponse = JObject.Parse(responseBody);

        JArray sealRecResults = (JArray)jsonResponse["result"]["sealRecResults"];
        for (int i = 0; i < sealRecResults.Count; i++)
        {
            var res = sealRecResults[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";
                        byte[] imageBytes = Convert.FromBase64String(base64Img);
                        File.WriteAllBytes(imgPath, imageBytes);
                        Console.WriteLine($"Output image saved at {imgPath}");
                    }
                }
            }
        }
    }
}
Node.js 
const axios = require('axios');
const fs = require('fs');
const path = require('path');

const API_URL = 'http://localhost:8080/seal-recognition';
const imagePath = './demo.jpg';

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

const payload = {
  file: encodeImageToBase64(imagePath),
  fileType: 1
};

axios.post(API_URL, payload)
  .then((response) => {
    const result = response.data["result"];
    const sealRecResults = result["sealRecResults"];

    sealRecResults.forEach((res, i) => {
      console.log(`\n[${i}] prunedResult:\n`, res["prunedResult"]);

      const outputImages = res["outputImages"];
      if (outputImages) {
        for (const [imgName, base64Img] of Object.entries(outputImages)) {
          const imgBuffer = Buffer.from(base64Img, 'base64');
          const fileName = `${imgName}_${i}.jpg`;
          fs.writeFileSync(fileName, imgBuffer);
          console.log(`Output image saved at ${fileName}`);
        }
      } else {
        console.log(`[${i}] No outputImages found.`);
      }
    });
  })
  .catch((error) => {
    console.error('Error occurred while calling the API:', error.message);
  });
PHP 
<?php

$API_URL = "http://localhost:8080/seal-recognition";
$image_path = "./demo.jpg";

$image_data = base64_encode(file_get_contents($image_path));
$payload = array("file" => $image_data, "fileType" => 1);

$ch = curl_init($API_URL);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, array('Content-Type: application/json'));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response, true)["result"]["sealRecResults"];

foreach ($result as $i => $item) {
    echo "[$i] prunedResult:\n";
    print_r($item["prunedResult"]);

    if (!empty($item["outputImages"])) {
        foreach ($item["outputImages"] as $img_name => $base64_img) {
            if (!empty($base64_img)) {
                $output_path = "{$img_name}_{$i}.jpg";
                file_put_contents($output_path, base64_decode($base64_img));
                echo "Output image saved at $output_path\n";
            }
        }
    } else {
        echo "No outputImages found for item $i\n";
    }
}
?>

📱 端侧部署：端侧部署是一种将计算和数据处理功能放在用户设备本身上的方式，设备可以直接处理数据，而不需要依赖远程的服务器。PaddleX 支持将模型部署在 Android 等端侧设备上，详细的端侧部署流程请参考[PaddleX端侧部署指南](../../../pipeline_deploy/on_device_deployment.md)。 您可以根据需要选择合适的方式部署模型产线，进而进行后续的 AI 应用集成。 ## 4. 二次开发 如果印章文本识别产线提供的默认模型权重在您的场景中，精度或速度不满意，您可以尝试利用您自己拥有的特定领域或应用场景的数据对现有模型进行进一步的微调，以提升印章文本识别产线的在您的场景中的识别效果。 ### 4.1 模型微调 由于印章文本识别产线包含若干模块，模型产线的效果如果不及预期，可能来自于其中任何一个模块。您可以对识别效果差的图片进行分析，进而确定是哪个模块存在问题，并参考以下表格中对应的微调教程链接进行模型微调。
情形 微调模块 微调参考链接
印章位置检测不准或未检出 版面检测模块 链接
印章文本存在漏检 印章文本检测模块 链接
文本内容不准 文本识别模块 链接
整图旋转矫正不准 文档图像方向分类模块 链接
图像扭曲矫正不准 文本图像矫正模块 暂不支持微调
### 4.2 模型应用 当您使用私有数据集完成微调训练后，可获得本地模型权重文件。 若您需要使用微调后的模型权重，只需对产线配置文件做修改，将微调后模型权重的本地路径替换至产线配置文件中的对应位置即可： ```python ...... SubModules: LayoutDetection: module_name: layout_detection model_name: PP-DocLayout-L model_dir: null # 修改此处为微调后的版面检测模型权重的本地路径 ... SubPipelines: DocPreprocessor: ... SubModules: DocOrientationClassify: module_name: doc_text_orientation model_name: PP-LCNet_x1_0_doc_ori model_dir: null # 修改此处为微调后的文档图像方向分类模型权重的本地路径 ... SubModules: TextDetection: module_name: seal_text_detection model_name: PP-OCRv4_server_seal_det model_dir: null # 修改此处为微调后的文本检测模型权重的本地路径 ... TextRecognition: module_name: text_recognition model_name: PP-OCRv5_server_rec model_dir: null # 修改此处为微调后的文本识别模型权重的本地路径 ... ``` 随后， 参考[2. 快速开始](#2-快速开始)中的命令行方式或Python脚本方式，加载修改后的产线配置文件即可。 ## 5. 多硬件支持 PaddleX 支持英伟达 GPU、昆仑芯 XPU、昇腾 NPU和寒武纪 MLU 等多种主流硬件设备，仅需修改 `--device` 参数即可完成不同硬件之间的无缝切换。 例如，您使用昇腾 NPU 进行印章文本识别产线的推理，使用的 CLI 命令为： ```bash paddlex --pipeline seal_recognition \ --input seal_text_det.png \ --use_doc_orientation_classify False \ --use_doc_unwarping False \ --device npu:0 \ --save_path ./output ``` 当然，您也可以在 Python 脚本中 `create_pipeline()` 时或者 `predict()` 时指定硬件设备。 若您想在更多种类的硬件上使用印章文本识别产线，请参考[PaddleX多硬件使用指南](../../../other_devices_support/multi_devices_use_guide.md)。