--- comments: true --- # Table Classification Module Usage Tutorial ## 1. Overview The Table Classification Module is a key component in computer vision systems, responsible for classifying input table images. The performance of this module directly affects the accuracy and efficiency of the entire table recognition process. The Table Classification Module typically receives table images as input and, using deep learning algorithms, classifies them into predefined categories based on the characteristics and content of the images, such as wired and wireless tables. The classification results from the Table Classification Module serve as output for use in table recognition pipelines. ## 2. Supported Model List
ModelModel Download Link Top1 Acc(%) GPU Inference Time (ms)
[Regular Mode / High-Performance Mode]		 CPU Inference Time (ms)
[Regular Mode / High-Performance Mode]		 Model Storage Size (MB)
PP-LCNet_x1_0_table_cls Inference Model/Training Model 94.2 2.62 / 0.60 3.17 / 1.14 6.6
Test Environment Description:
Mode GPU Configuration CPU Configuration Acceleration Technology Combination
Regular Mode FP32 Precision / No TRT Acceleration FP32 Precision / 8 Threads PaddleInference
High-Performance Mode Optimal combination of prior precision type and acceleration strategy FP32 Precision / 8 Threads Choose the optimal prior backend (Paddle/OpenVINO/TRT, etc.)
## 3. Quick Start > ❗ Before starting quickly, please first install the PaddleOCR wheel package. For details, please refer to the [installation tutorial](../installation.en.md). You can quickly experience it with one command: ```bash paddleocr table_classification -i https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/table_recognition.jpg ``` Note: The official models would be download from HuggingFace by default. If can't access to HuggingFace, please set the environment variable `PADDLE_PDX_MODEL_SOURCE="BOS"` to change the model source to BOS. In the future, more model sources will be supported. You can also integrate model inference from the table classification module into your project. Before running the following code, please download the [sample image](https://paddle-model-ecology.bj.bcebos.com/paddlex/imgs/demo_image/table_recognition.jpg) locally. ```python from paddleocr import TableClassification model = TableClassification(model_name="PP-LCNet_x1_0_table_cls") output = model.predict("table_recognition.jpg", batch_size=1) for res in output: res.print(json_format=False) res.save_to_json("./output/res.json") ``` After running, the result obtained is: ``` {'res': {'input_path': 'table_recognition.jpg', 'page_index': None, 'class_ids': array([0, 1], dtype=int32), 'scores': array([0.84421, 0.15579], dtype=float32), 'label_names': ['wired_table', 'wireless_table']}} ``` The parameter meanings are as follows: - `input_path`: Path of the input image - `page_index`: If the input is a PDF file, it indicates which page of the PDF it is; otherwise, it is `None` - `class_ids`: Class IDs of the prediction results - `scores`: Confidence scores of the prediction results - `label_names`: Class names of the prediction results The visualized image is as follows: The relevant methods, parameters, etc., are described as follows: * `TableClassification` instantiates the table classification model (taking `PP-LCNet_x1_0_table_cls` as an example here), with specific explanations as follows:
Parameter Description Type Default
model_name Model name. If set to None, PP-LCNet_x1_0_table_cls will be used. str|None None
model_dir Model storage path. str|None None
device Device for inference.
For example: "cpu", "gpu", "npu", "gpu:0", "gpu:0,1".
If multiple devices are specified, parallel inference will be performed.
By default, GPU 0 is used if available; otherwise, CPU is used.		 str|None None
enable_hpi Whether to enable high-performance inference. bool False
use_tensorrt Whether to use the Paddle Inference TensorRT subgraph engine. If the model does not support acceleration through TensorRT, setting this flag will not enable acceleration.
For Paddle with CUDA version 11.8, the compatible TensorRT version is 8.x (x>=6), and it is recommended to install TensorRT 8.6.1.6.
For Paddle with CUDA version 12.6, the compatible TensorRT version is 10.x (x>=5), and it is recommended to install TensorRT 10.5.0.18.		 bool False
precision Computation precision when using the Paddle Inference TensorRT subgraph engine.
Options: "fp32", "fp16".		 str "fp32"
enable_mkldnn Whether to enable MKL-DNN acceleration for inference. If MKL-DNN is unavailable or the model does not support it, acceleration will not be used even if this flag is set. bool True
mkldnn_cache_capacity MKL-DNN cache capacity. int 10
cpu_threads Number of threads to use for inference on CPUs. int 10
* Call the `predict()` method of the table classification model for inference prediction. This method will return a result list. Additionally, this module also provides a `predict_iter()` method. Both methods are consistent in terms of parameter acceptance and result return. The difference is that `predict_iter()` returns a `generator`, which can process and obtain prediction results step by step, suitable for handling large datasets or scenarios where memory saving is desired. You can choose to use either of these methods according to your actual needs. The `predict()` method has parameters `input` and `batch_size`, with specific explanations as follows:
Parameter Description Type Default
input Input data to be predicted. Required. Supports multiple input types:
  • Python Var: e.g., numpy.ndarray representing image data
  • str: Local image file or PDF file path: /root/data/img.jpg; URL: Image or PDF file network URL: Example; Directory: Should contain images for prediction, e.g., /root/data/ (currently, PDF files in directories are not supported, PDF files need to be specified by file path)
  • list: List elements should be of the above types, e.g., [numpy.ndarray, numpy.ndarray], ["/root/data/img1.jpg", "/root/data/img2.jpg"], ["/root/data1", "/root/data2"]
 Python Var|str|list
batch_size Batch size, positive integer. int 1
* Process the prediction results. The prediction result for each sample is a corresponding Result object, which supports printing, saving as an image, and saving as a `json` file:
Method Description Parameter Type Parameter Description Default Value
print() Print result to terminal format_json bool Whether to format the output content using JSON indentation True
indent int Specifies the indentation level to beautify the output JSON data, making it more readable, effective only when format_json is True 4
ensure_ascii bool Controls whether to escape non-ASCII characters into Unicode. When set to True, all non-ASCII characters will be escaped; False will retain the original characters, effective only when format_json is True False
save_to_json() Save the result as a json format file save_path str The path to save the file. When specified as a directory, the saved file is named consistent with the input file type. None
indent int Specifies the indentation level to beautify the output JSON data, making it more readable, effective only when format_json is True 4
ensure_ascii bool Controls whether to escape non-ASCII characters into Unicode. When set to True, all non-ASCII characters will be escaped; False will retain the original characters, effective only when format_json is True False
* Additionally, the result can be obtained through attributes that provide the visualized images with results and the prediction results, as follows:
Attribute Description
json Get the prediction result in json format
img Get the visualized image
## 4. Secondary Development Since PaddleOCR does not directly provide training for the table classification module, if you need to train a table classification model, you can refer to the [PaddleX Table Classification Module Secondary Development](https://paddlepaddle.github.io/PaddleX/latest/en/module_usage/tutorials/ocr_modules/table_classification.html#iv-secondary-development) section for training. The trained model can be seamlessly integrated into the PaddleOCR API for inference. ## 5. FAQ