👉Model List Details
Table Recognition Module Models:
| Model | Model Download Link |
Accuracy (%) |
CPU Inference Time (ms)
[Normal Mode / High-Performance Mode] |
CPU Inference Time (ms)
[Normal Mode / High-Performance Mode] |
Model Storage Size (M) |
Description |
| SLANeXt_wired |
Inference Model/Training Model |
69.65 |
-- |
-- |
351M |
The SLANeXt series is a new generation of table structure recognition models developed by the Baidu PaddlePaddle Vision Team. Compared to SLANet and SLANet_plus, SLANeXt focuses on recognizing table structures and has trained dedicated weights for both wired and wireless tables, significantly improving the recognition capabilities for all types of tables, especially for wired tables. |
| SLANeXt_wireless |
Inference Model/Training Model |
63.69 |
522.536 |
1845.37 |
6.9 M |
Note: The above accuracy metrics are measured from the high-difficulty Chinese table recognition dataset internally built by PaddleX. The GPU inference time for all models is based on an NVIDIA Tesla T4 machine with FP32 precision type. The CPU inference speed is based on an Intel(R) Xeon(R) Gold 5117 CPU @ 2.00GHz with 8 threads and FP32 precision type.
Table Classification Module Models:
| Model | Model Download Link |
Top1 Acc(%) |
GPU Inference Time (ms)
[Normal Mode / High-Performance Mode] |
CPU Inference Time (ms)
[Normal Mode / High-Performance Mode] |
Model Storage Size (M) |
| PP-LCNet_x1_0_table_cls | Inference Model/Training Model |
94.2 |
2.35 / 0.47 |
4.03 / 1.35 |
6.6M |
Note: The above accuracy metrics are measured from the internal table classification dataset built by PaddleX. All models' GPU inference time is based on an NVIDIA Tesla T4 machine, with a precision type of FP32. The CPU inference speed is based on an Intel(R) Xeon(R) Gold 5117 CPU @ 2.00GHz, with 8 threads and a precision type of FP32.
Table Cell Detection Module Models:
| Model | Model Download Link |
mAP(%) |
GPU Inference Time (ms)
[Normal Mode / High-Performance Mode] |
CPU Inference Time (ms)
[Normal Mode / High-Performance Mode] |
Model Storage Size (M) |
Introduction |
| RT-DETR-L_wired_table_cell_det |
Inference Model/Training Model |
82.7 |
35.00 / 10.45 |
495.51 / 495.51 |
124M |
RT-DETR is the first real-time end-to-end object detection model. The Baidu PaddlePaddle Vision Team, based on RT-DETR-L as the base model, has completed pretraining on a self-built table cell detection dataset, achieving good performance for both wired and wireless table cell detection.
|
| RT-DETR-L_wireless_table_cell_det |
Inference Model/Training Model |
Note: The above accuracy metrics are measured from the internal table cell detection dataset of PaddleX. All model GPU inference times are based on an NVIDIA Tesla T4 machine, with precision type FP32. CPU inference speed is based on an Intel(R) Xeon(R) Gold 5117 CPU @ 2.00GHz, with 8 threads and precision type FP32. Considering that the table cell detection module needs to be integrated into the table recognition production line v2 for practical applications, the table cell detection results output from the table recognition production line v2 are used to calculate the mAP accuracy.
Text Detection Module Models:
| Model | Model Download Link |
Detection Hmean (%) |
CPU Inference Time (ms)
[Normal Mode / High-Performance Mode] |
CPU Inference Time (ms)
[Normal Mode / High-Performance Mode] |
Model Storage Size (M) |
Introduction |
| PP-OCRv4_server_det | Inference Model/Training Model |
82.69 |
83.34 / 80.91 |
442.58 / 442.58 |
109 |
The server-side text detection model of PP-OCRv4, with higher accuracy, suitable for deployment on high-performance servers. |
| PP-OCRv4_mobile_det | Inference Model/Training Model |
77.79 |
8.79 / 3.13 |
51.00 / 28.58 |
4.7 |
The mobile text detection model of PP-OCRv4, with higher efficiency, suitable for deployment on edge devices. |
Note: The evaluation set for the above accuracy metrics is a self-built Chinese dataset by PaddleOCR, covering multiple scenarios such as street view, web images, documents, and handwriting, with 500 images for detection. All models' GPU inference time is based on an NVIDIA Tesla T4 machine with FP32 precision. The CPU inference speed is based on an Intel(R) Xeon(R) Gold 5117 CPU @ 2.00GHz with 8 threads and FP32 precision.
Text Recognition Module Models:
| Model | Model Download Link |
Recognition Avg Accuracy(%) |
CPU Inference Time (ms)
[Normal Mode / High-Performance Mode] |
CPU Inference Time (ms)
[Normal Mode / High-Performance Mode] |
Model Storage Size (M) |
Introduction |
| PP-OCRv4_mobile_rec | Inference Model/Training Model |
78.20 |
4.82 / 4.82 |
16.74 / 4.64 |
10.6 M |
PP-OCRv4 is the next version of the self-developed text recognition model PP-OCRv3 by Baidu PaddlePaddle Vision Team. By introducing data augmentation schemes and GTC-NRTR guidance branches, it further improves text recognition accuracy without changing the model inference speed. This model provides both server and mobile versions to meet industrial needs in different scenarios. |
| PP-OCRv4_server_rec | Inference Model/Training Model |
79.20 |
6.58 / 6.58 |
33.17 / 33.17 |
71.2 M |
Note: The evaluation set for the above accuracy metrics is a self-built Chinese dataset by PaddleOCR, covering multiple scenarios such as street view, web images, documents, and handwriting, with 11,000 images for text recognition. All models' GPU inference time is based on an NVIDIA Tesla T4 machine with FP32 precision. The CPU inference speed is based on an Intel(R) Xeon(R) Gold 5117 CPU @ 2.00GHz with 8 threads and FP32 precision.
| Model | Model Download Link |
Recognition Avg Accuracy(%) |
CPU Inference Time (ms)
[Normal Mode / High-Performance Mode] |
CPU Inference Time (ms)
[Normal Mode / High-Performance Mode] |
Model Storage Size (M) |
Introduction |
| ch_SVTRv2_rec | Inference Model/Training Model |
68.81 |
8.08 / 8.08 |
50.17 / 42.50 |
73.9 M |
SVTRv2 is a server-side text recognition model developed by the OpenOCR team from Fudan University's Vision and Learning Laboratory (FVL). It won the first prize in the PaddleOCR Algorithm Model Challenge - Task 1: OCR End-to-End Recognition Task, with a 6% improvement in end-to-end recognition accuracy compared to PP-OCRv4.
|
Note: The evaluation set for the above accuracy metrics is the PaddleOCR Algorithm Model Challenge - Task 1: OCR End-to-End Recognition Task leaderboard A. All models' GPU inference time is based on an NVIDIA Tesla T4 machine with FP32 precision. The CPU inference speed is based on an Intel(R) Xeon(R) Gold 5117 CPU @ 2.00GHz with 8 threads and FP32 precision.
| Model | Model Download Link |
Recognition Avg Accuracy(%) |
CPU Inference Time (ms)
[Normal Mode / High-Performance Mode] |
CPU Inference Time (ms)
[Normal Mode / High-Performance Mode] |
Model Storage Size (M) |
Introduction |
| ch_RepSVTR_rec | Inference Model/Training Model |
65.07 |
5.93 / 5.93 |
20.73 / 7.32 |
22.1 M |
RepSVTR is a mobile text recognition model based on SVTRv2. It won the first prize in the PaddleOCR Algorithm Model Challenge - Task 1: OCR End-to-End Recognition Task, with a 2.5% improvement in end-to-end recognition accuracy compared to PP-OCRv4 and comparable inference speed. |
Note: The evaluation set for the above accuracy metrics is the PaddleOCR Algorithm Model Challenge - Task 1: OCR End-to-End Recognition Task leaderboard B. All models' GPU inference time is based on an NVIDIA Tesla T4 machine with FP32 precision. The CPU inference speed is based on an Intel(R) Xeon(R) Gold 5117 CPU @ 2.00GHz with 8 threads and FP32 precision.
Layout Region Detection Module Models (Optional):
| Model | Model Download Link |
mAP(0.5) (%) |
CPU Inference Time (ms)
[Normal Mode / High-Performance Mode] |
CPU Inference Time (ms)
[Normal Mode / High-Performance Mode] |
Model Storage Size (M) |
Description |
| PP-DocLayout-L | Inference Model/Training Model |
90.4 |
34.5252 |
1454.27 |
123.76 M |
A high-precision layout region localization model trained on a self-built dataset containing Chinese and English papers, magazines, contracts, books, exams, and research reports, based on RT-DETR-L. |
| PP-DocLayout-M | Inference Model/Training Model |
75.2 |
15.9 |
160.1 |
22.578 |
A balanced precision and efficiency layout region localization model trained on a self-built dataset containing Chinese and English papers, magazines, contracts, books, exams, and research reports, based on PicoDet-L. |
| PP-DocLayout-S | Inference Model/Training Model |
70.9 |
13.8 |
46.7 |
4.834 |
A high-efficiency layout region localization model trained on a self-built dataset containing Chinese and English papers, magazines, contracts, books, exams, and research reports, based on PicoDet-S. |
Note: The evaluation dataset for the above accuracy metrics is the layout region detection dataset built by PaddleOCR, containing 500 common document-type images of Chinese and English papers, magazines, contracts, books, exams, and research reports. The GPU inference time is based on an NVIDIA Tesla T4 machine with FP32 precision type. The CPU inference speed is based on an Intel(R) Xeon(R) Gold 5117 CPU @ 2.00GHz with 8 threads and FP32 precision type.
> ❗ The above list includes the 3 core models that are the focus of the layout detection module. The module supports a total of 11 full models, including multiple predefined models with different categories. The complete list of models is as follows:
* Table Layout Detection Models
| Model | Model Download Link |
mAP(0.5) (%) |
CPU Inference Time (ms)
[Normal Mode / High-Performance Mode] |
CPU Inference Time (ms)
[Normal Mode / High-Performance Mode] |
Model Size (M) |
Description |
| PicoDet_layout_1x_table | Inference Model/Training Model |
97.5 |
8.02 / 3.09 |
23.70 / 20.41 |
7.4 M |
A high-efficiency layout region localization model trained on a self-built dataset using PicoDet-1x, capable of locating 1 type of region: tables |
Note: The evaluation dataset for the above accuracy metrics is the layout table region detection dataset built by PaddleOCR, containing 7,835 document-type images of Chinese and English papers with tables. The GPU inference time is based on an NVIDIA Tesla T4 machine with FP32 precision type. The CPU inference speed is based on an Intel(R) Xeon(R) Gold 5117 CPU @ 2.00GHz with 8 threads and FP32 precision type.
* 3-category layout detection model, including tables, images, and seals
| Model | Model Download Link |
mAP(0.5) (%) |
CPU Inference Time (ms)
[Normal Mode / High-Performance Mode] |
CPU Inference Time (ms)
[Normal Mode / High-Performance Mode] |
Model Size (M) |
Description |
| PicoDet-S_layout_3cls | Inference Model/Training Model |
88.2 |
8.99 / 2.22 |
16.11 / 8.73 |
4.8 |
A high-efficiency layout region localization model trained on a self-built dataset of Chinese and English papers, magazines, and research reports using the lightweight PicoDet-S model |
| PicoDet-L_layout_3cls | Inference Model/Training Model |
89.0 |
13.05 / 4.50 |
41.30 / 41.30 |
22.6 |
A layout region localization model with balanced efficiency and accuracy, trained on a self-built dataset of Chinese and English papers, magazines, and research reports using PicoDet-L |
| RT-DETR-H_layout_3cls | Inference Model/Training Model |
95.8 |
114.93 / 27.71 |
947.56 / 947.56 |
470.1 |
A high-precision layout region localization model trained on a self-built dataset of Chinese and English papers, magazines, and research reports using RT-DETR-H |
Note: The evaluation dataset for the above accuracy metrics is the layout region detection dataset built by PaddleOCR, containing 1,154 common document-type images of Chinese and English papers, magazines, and research reports. The GPU inference time is based on an NVIDIA Tesla T4 machine with FP32 precision type. The CPU inference speed is based on an Intel(R) Xeon(R) Gold 5117 CPU @ 2.00GHz with 8 threads and FP32 precision type.
* 5-category English document region detection model, including text, title, table, image, and list
| Model | Model Download Link |
mAP(0.5) (%) |
CPU Inference Time (ms)
[Normal Mode / High-Performance Mode] |
CPU Inference Time (ms)
[Normal Mode / High-Performance Mode] |
Model Size (M) |
Description |
| PicoDet_layout_1x | Inference Model/Training Model |
97.8 |
9.03 / 3.10 |
25.82 / 20.70 |
7.4 |
A high-efficiency English document layout region localization model trained on the PubLayNet dataset using PicoDet-1x |
Note: The evaluation dataset for the above accuracy metrics is the [PubLayNet](https://developer.ibm.com/exchanges/data/all/publaynet/) evaluation dataset, containing 11,245 images of English documents. The GPU inference time is based on an NVIDIA Tesla T4 machine with FP32 precision type. The CPU inference speed is based on an Intel(R) Xeon(R) Gold 5117 CPU @ 2.00GHz with 8 threads and FP32 precision type.
* 17-category region detection model, including 17 common layout categories: paragraph title, image, text, number, abstract, content, figure title, formula, table, table title, reference, document title, footnote, header, algorithm, footer, seal
| Model | Model Download Link |
mAP(0.5) (%) |
CPU Inference Time (ms)
[Normal Mode / High-Performance Mode] |
CPU Inference Time (ms)
[Normal Mode / High-Performance Mode] |
Model Size (M) |
Description |
| PicoDet-S_layout_17cls | Inference Model/Training Model |
87.4 |
9.11 / 2.12 |
15.42 / 9.12 |
4.8 |
A high-efficiency layout region localization model trained on a self-built dataset of Chinese and English papers, magazines, and research reports using the lightweight PicoDet-S model |
| PicoDet-L_layout_17cls | Inference Model/Training Model |
89.0 |
13.50 / 4.69 |
43.32 / 43.32 |
22.6 |
A layout region localization model with balanced efficiency and accuracy, trained on a self-built dataset of Chinese and English papers, magazines, and research reports using PicoDet-L |
| RT-DETR-H_layout_17cls | Inference Model/Training Model |
98.3 |
115.29 / 104.09 |
995.27 / 995.27 |
470.2 |
A high-precision layout region localization model trained on a self-built dataset of Chinese and English papers, magazines, and research reports using RT-DETR-H |
Note: The evaluation dataset for the above accuracy metrics is the layout region detection dataset built by PaddleOCR, containing 892 common document-type images of Chinese and English papers, magazines, and research reports. The GPU inference time is based on an NVIDIA Tesla T4 machine with FP32 precision type. The CPU inference speed is based on an Intel(R) Xeon(R) Gold 5117 CPU @ 2.00GHz with 8 threads and FP32 precision type.
Text Image Correction Module Model (Optional):
| Model | Model Download Link |
MS-SSIM (%) |
Model Storage Size (M) |
Description |
| UVDoc | Inference Model/Training Model |
54.40 |
30.3 M |
High-precision text image correction model |
The accuracy metrics of the model are measured from the DocUNet benchmark.
Document Image Orientation Classification Module Model (Optional):
| Model | Model Download Link |
Top-1 Acc (%) |
CPU Inference Time (ms)
[Normal Mode / High-Performance Mode] |
CPU Inference Time (ms)
[Normal Mode / High-Performance Mode] |
Model Storage Size (M) |
Description |
| PP-LCNet_x1_0_doc_ori | Inference Model/Training Model |
99.06 |
2.31 / 0.43 |
3.37 / 1.27 |
7 |
Document image classification model based on PP-LCNet_x1_0, containing four categories: 0 degrees, 90 degrees, 180 degrees, 270 degrees |
Note: The accuracy metrics above are evaluated on a self-built dataset covering multiple scenarios such as documents and certificates, including 1000 images. GPU inference time is based on NVIDIA Tesla T4 machines with FP32 precision, and CPU inference speed is based on Intel(R) Xeon(R) Gold 5117 CPU @ 2.00GHz with 8 threads and FP32 precision.
| Parameter |
Description |
Type |
Options |
Default Value |
input |
Data to be predicted, supports multiple input types, required |
Python Var|str|list |
- Python Var: Such as
numpy.ndarray representing image data
- str: Such as the local path of an image file or PDF file:
/root/data/img.jpg; such as URL link, such as the network URL of an image file or PDF file: Example; such as local directory, the directory must contain the images to be predicted, such as the local path: /root/data/ (currently does not support prediction of PDF files in the directory, PDF files need to be specified to a specific file path)
- List: The list elements must be the above types of data, such as
[numpy.ndarray, numpy.ndarray], ["/root/data/img1.jpg", "/root/data/img2.jpg"], ["/root/data1", "/root/data2"]
|
None |
device |
Pipeline inference device |
str|None |
- CPU: Such as
cpu indicating using CPU for inference;
- GPU: Such as
gpu:0 indicating using the 1st GPU for inference;
- NPU: Such as
npu:0 indicating using the 1st NPU for inference;
- XPU: Such as
xpu:0 indicating using the 1st XPU for inference;
- MLU: Such as
mlu:0 indicating using the 1st MLU for inference;
- DCU: Such as
dcu:0 indicating using the 1st DCU for inference;
- None: If set to
None, it will default to using the parameter value initialized by the pipeline. During initialization, it will preferentially use the local GPU 0 device, if not available, it will use the CPU device;
|
None |
use_doc_orientation_classify |
Whether to use the document orientation classification module |
bool|None |
- bool:
True or False;
- None: If set to
None, it will default to using the parameter value initialized by the pipeline, initialized to True;
|
None |
use_doc_unwarping |
Whether to use the document unwarping module |
bool|None |
- bool:
True or False;
- None: If set to
None, it will default to using the parameter value initialized by the pipeline, initialized to True;
|
None |
text_det_limit_side_len |
Image side length limit for text detection |
int|None |
- int: Any integer greater than
0;
- None: If set to
None, it will default to using the parameter value initialized by the pipeline, initialized to 960;
|
None |
text_det_limit_type |
Image side length limit type for text detection |
str|None |
- str: Supports
min and max, min indicates ensuring the shortest side of the image is not less than det_limit_side_len, max indicates ensuring the longest side of the image is not greater than limit_side_len
- None: If set to
None, it will default to using the parameter value initialized by the pipeline, initialized to max;
|
None |
text_det_thresh |
Detection pixel threshold, only pixels with scores greater than this threshold in the output probability map will be considered as text pixels |
float|None |
- float: Any floating-point number greater than
0
- None: If set to
None, it will default to using the parameter value initialized by the pipeline 0.3
|
None |
text_det_box_thresh |
Detection box threshold, the result will be considered as a text region if the average score of all pixels within the detection box is greater than this threshold |
float|None |
- float: Any floating-point number greater than
0
- None: If set to
None, it will default to using the parameter value initialized by the pipeline 0.6
|
None |
text_det_unclip_ratio |
Text detection expansion ratio, this method is used to expand the text region, the larger the value, the larger the expanded area |
float|None |
- float: Any floating-point number greater than
0
- None: If set to
None, it will default to using the parameter value initialized by the pipeline 2.0
|
None |
text_rec_score_thresh |
Text recognition threshold, text results with scores greater than this threshold will be retained |
float|None |
- float: Any floating-point number greater than
0
- None: If set to
None, it will default to using the parameter value initialized by the pipeline 0.0, meaning no threshold
|
None |
use_layout_detection |
Whether to use the layout detection module |
bool|None |
- bool:
True or False;
- None: If set to
None, the default value initialized by the production line will be used, initialized as True;
|
None |
layout_threshold |
Confidence threshold for layout detection; only scores above this threshold will be output |
float|dict|None |
- float: Any floating-point number greater than
0
- dict: Key is an integer category ID, value is any floating-point number greater than
0
- None: If set to
None, the default value initialized by the production line will be used, initialized as 0.5
|
None |
layout_nms |
Whether to use NMS post-processing for layout detection |
bool|None |
- bool:
True or False;
- None: If set to
None, the default value initialized by the production line will be used, initialized as True;
|
None |
layout_unclip_ratio |
Scale factor for the side length of detection boxes; if not specified, the default PaddleX official model configuration will be used |
float|list|None |
- float: A floating-point number greater than 0, e.g., 1.1, indicating that the center of the detection box remains unchanged, and both the width and height are scaled by 1.1 times
- list: e.g., [1.2, 1.5], indicating that the center of the detection box remains unchanged, the width is scaled by 1.2 times, and the height is scaled by 1.5 times
- None: If set to
None, the default value initialized by the production line will be used, initialized as 1.0
|
layout_merge_bboxes_mode |
Merging mode for detection boxes output by the model; if not specified, the default PaddleX official model configuration will be used |
string|None |
- large: When set to large, only the outermost box will be retained for overlapping detection boxes, and the inner overlapping boxes will be removed.
- small: When set to small, only the innermost boxes will be retained for overlapping detection boxes, and the outer overlapping boxes will be removed.
- union: No filtering of boxes will be performed; both inner and outer boxes will be retained.
- None: If set to
None, the default value initialized by the production line will be used, initialized as large
|
None |
(3) Process the prediction results. The prediction result for each sample is of type `dict`, and supports operations such as printing, saving as an image, saving as an `xlsx` file, saving as an `HTML` file, and saving as a `json` file:
| Method |
Description |
Parameter |
Type |
Parameter Description |
Default Value |
print() |
Print the result to the terminal |
format_json |
bool |
Whether to format the output content using JSON indentation |
True |
indent |
int |
Specify the indentation level to beautify the output JSON data, making it more readable. This is only effective when format_json is True |
4 |
ensure_ascii |
bool |
Control whether non-ASCII characters are escaped to Unicode. When set to True, all non-ASCII characters will be escaped; False retains the original characters. This is only effective when format_json is True |
False |
save_to_json() |
Save the result as a JSON file |
save_path |
str |
The file path for saving. When it is a directory, the saved file name will match the input file name |
N/A |
indent |
int |
Specify the indentation level to beautify the output JSON data, making it more readable. This is only effective when format_json is True |
4 |
ensure_ascii |
bool |
Control whether non-ASCII characters are escaped to Unicode. When set to True, all non-ASCII characters will be escaped; False retains the original characters. This is only effective when format_json is True |
False |
save_to_img() |
Save the result as an image file |
save_path |
str |
The file path for saving, supporting both directory and file paths |
N/A |
save_to_xlsx() |
Save the result as an xlsx file |
save_path |
str |
The file path for saving, supporting both directory and file paths |
N/A |
save_to_html() |
Save the result as an HTML file |
save_path |
str |
The file path for saving, supporting both directory and file paths |
N/A |
- Calling the `print()` method will print the result to the terminal, with the printed content explained as follows:
- `input_path`: `(str)` The input path of the image to be predicted
- `model_settings`: `(Dict[str, bool])` Configuration parameters required for the production line model
- `use_doc_preprocessor`: `(bool)` Controls whether to enable the document preprocessing sub-production line
- `use_layout_detection`: `(bool)` Controls whether to enable the layout detection sub-production line
- `use_ocr_model`: `(bool)` Controls whether to enable the OCR sub-production line
- `layout_det_res`: `(Dict[str, Union[List[numpy.ndarray], List[float]]])` Output result of the layout detection sub-module. Only exists when `use_layout_detection=True`
- `input_path`: `(Union[str, None])` The image path accepted by the layout detection module, saved as `None` when the input is a `numpy.ndarray`
- `page_index`: `(Union[int, None])` If the input is a PDF file, it indicates the current page number of the PDF, otherwise it is `None`
- `boxes`: `(List[Dict])` List of detection boxes for layout seal regions, each element in the list contains the following fields
- `cls_id`: `(int)` The class ID of the detection box
- `score`: `(float)` The confidence score of the detection box
- `coordinate`: `(List[float])` The coordinates of the four corners of the detection box, in the order of x1, y1, x2, y2, representing the x-coordinate of the top-left corner, the y-coordinate of the top-left corner, the x-coordinate of the bottom-right corner, and the y-coordinate of the bottom-right corner
- `doc_preprocessor_res`: `(Dict[str, Union[str, Dict[str, bool], int]])` The output result of the document preprocessing sub-production line. Exists only when `use_doc_preprocessor=True`
- `input_path`: `(Union[str, None])` The image path accepted by the image preprocessing sub-production line, saved as `None` when the input is `numpy.ndarray`
- `model_settings`: `(Dict)` Model configuration parameters for the preprocessing sub-production line
- `use_doc_orientation_classify`: `(bool)` Controls whether to enable document orientation classification
- `use_doc_unwarping`: `(bool)` Controls whether to enable document unwarping
- `angle`: `(int)` The prediction result of document orientation classification. When enabled, the values are [0,1,2,3], corresponding to [0°,90°,180°,270°] respectively; when not enabled, it is -1
- `dt_polys`: `(List[numpy.ndarray])` List of polygons for text detection. Each detection box is represented by a numpy array of 4 vertex coordinates, with the array shape being (4, 2) and the data type being int16
- `dt_scores`: `(List[float])` List of confidence scores for text detection boxes
- `text_det_params`: `(Dict[str, Dict[str, int, float]])` Configuration parameters for the text detection module
- `limit_side_len`: `(int)` The side length limit value during image preprocessing
- `limit_type`: `(str)` The processing method for the side length limit
- `thresh`: `(float)` Confidence threshold for text pixel classification
- `box_thresh`: `(float)` Confidence threshold for text detection boxes
- `unclip_ratio`: `(float)` Expansion coefficient for text detection boxes
- `text_type`: `(str)` Type of text detection, currently fixed as "general"
- `text_rec_score_thresh`: `(float)` Filtering threshold for text recognition results
- `rec_texts`: `(List[str])` List of text recognition results, only includes texts with confidence scores exceeding `text_rec_score_thresh`
- `rec_scores`: `(List[float])` List of confidence scores for text recognition, filtered by `text_rec_score_thresh`
- `rec_polys`: `(List[numpy.ndarray])` List of text detection boxes after confidence filtering, same format as `dt_polys`
- `rec_boxes`: `(numpy.ndarray)` Array of rectangular bounding boxes for detection boxes, with shape (n, 4) and dtype int16. Each row represents the [x_min, y_min, x_max, y_max] coordinates of a rectangle, where (x_min, y_min) is the top-left coordinate and (x_max, y_max) is the bottom-right coordinate
- Calling the `save_to_json()` method will save the above content to the specified `save_path`. If specified as a directory, the saved path will be `save_path/{your_img_basename}.json`; if specified as a file, it will be saved directly to that file. Since JSON files do not support saving numpy arrays, the `numpy.array` types will be converted to lists.
- Calling the `save_to_img()` method will save the visualization results to the specified `save_path`. If specified as a directory, the saved path will be `save_path/{your_img_basename}_ocr_res_img.{your_img_extension}`; if specified as a file, it will be saved directly to that file. (The production line usually contains many result images, it is not recommended to specify a specific file path directly, otherwise multiple images will be overwritten, leaving only the last image)
- Calling the `save_to_html()` method will save the above content to the specified `save_path`. If specified as a directory, the saved path will be `save_path/{your_img_basename}.html`; if specified as a file, it will be saved directly to that file. In the general table recognition production line v2, the HTML form of the table in the image will be written to the specified HTML file.
- Calling the `save_to_xlsx()` method will save the above content to the specified `save_path`. If specified as a directory, the saved path will be `save_path/{your_img_basename}.xlsx`; if specified as a file, it will be saved directly to that file. In the general table recognition production line v2, the Excel form of the table in the image will be written to the specified XLSX file.
* Additionally, it also supports obtaining visualized images and prediction results through attributes, as follows:
The General Table Recognition Pipeline v2 includes mandatory modules such as table structure recognition, table classification, table cell localization, text detection, and text recognition, as well as optional modules like layout area detection, document image orientation classification, and text image correction.
If you prioritize model accuracy, choose a model with higher accuracy; if you care more about inference speed, choose a model with faster inference speed; if you are concerned about model storage size, choose a model with a smaller storage size.
