基于reComputer AI盒子与TensorRT优化的实时OCR边缘计算方案实践

1. 项目概述：当AI盒子遇上实时OCR

最近在折腾一个项目，需要从摄像头视频流里实时提取文字信息。传统的方案要么是把视频流推到云端服务器处理，延迟和隐私都是问题；要么是在本地PC上跑一个模型，功耗和便携性又成了瓶颈。直到我上手试了试reComputer AI盒子，配合一个轻量级的OCR模型，才算是找到了一个比较理想的平衡点。这个方案的核心，就是把一个专门为边缘AI设计的硬件，和一个优化过的识别算法结合起来，实现低延迟、高隐私、可移动的实时文字识别。

简单来说，reComputer AI盒子是一个搭载了高性能AI加速芯片（比如NVIDIA Jetson系列或类似架构）的嵌入式设备，它体积小巧、功耗低，但具备强大的并行计算能力，非常适合运行像目标检测、图像分类、当然也包括OCR这样的深度学习模型。而“实时OCR”意味着，我们不是处理一张静态图片，而是连续不断地处理视频帧，从中识别并提取文字，并且整个过程要在极短的时间内完成（比如几十毫秒内），才能保证“实时”的体验，没有明显的卡顿感。

这个组合能解决什么实际问题呢？想象一下这些场景：在工厂流水线上，实时读取产品包装上的批次号或生产日期进行自动分拣和记录；在零售门店，通过摄像头自动识别货架上的价签，辅助盘货或价格稽核；在停车场，自动识别临时车辆的入场凭证号码；甚至是在一些教育或展示场景，实时翻译或识别白板、屏幕上的文字。它的价值在于将“看见文字”和“理解文字”的能力，部署到了离数据产生源头最近的地方，反应快、数据不出本地、部署灵活。

如果你正在寻找一种能在本地、离线环境下稳定运行实时文字识别的方案，并且对设备的体积、功耗和成本有一定要求，那么基于reComputer AI盒子搭建的这套系统，值得你花时间深入了解。接下来，我会详细拆解从设计思路、环境配置、模型选型与优化，到最终实现和问题排查的完整过程。

2. 核心思路与方案选型

要实现“使用reComputer AI盒子进行实时OCR”，并不是简单地把一个现成的OCR软件装上去就行。我们需要从硬件特性、软件生态、模型效率和实时性要求等多个维度进行通盘考虑。我的核心思路是：利用AI盒子的专用计算单元加速模型推理，采用高效的流水线处理视频帧，并选择或训练一个在精度和速度上达到最佳平衡的OCR模型。

2.1 为什么是reComputer AI盒子？

首先得明白我们为什么选这个硬件。市面上类似的边缘计算盒子不少，reComputer系列（通常基于Jetson平台）的优势在于其统一的软件栈和活跃的社区支持。

1. 异构计算架构：以Jetson为例，它集成了CPU、GPU以及专门用于深度学习推理的NVIDIA Tensor Cores。对于OCR模型中的卷积神经网络计算，Tensor Cores能提供数十倍于CPU的吞吐量，这是实现实时处理的关键。
2. 完整的AI软件栈：NVIDIA提供了JetPack SDK，包含了操作系统（基于Ubuntu）、CUDA、cuDNN、TensorRT等核心组件。特别是TensorRT，它是一个高性能的深度学习推理优化器和运行时，能将训练好的模型（如PyTorch或TensorFlow格式）进行量化、层融合、内核自动调优等优化，显著提升在Jetson上的推理速度并降低延迟。
3. 丰富的IO接口与低功耗：具备多个USB、CSI摄像头接口、GPIO等，方便连接摄像头、传感器。功耗通常在5W到30W之间，可以长时间稳定运行，甚至支持PoE供电，部署非常方便。
4. 容器化与生产就绪：支持Docker容器，便于封装和分发整个OCR应用，保持环境一致性，简化部署流程。

注意：不同型号的reComputer（如Jetson Nano, TX2 NX, Xavier NX, Orin Nano）算力差异巨大。对于实时OCR，如果视频分辨率高（如1080p）或需要识别的文本区域多，建议至少选择Jetson Xavier NX或Jetson Orin Nano级别，以确保稳定的帧率。

2.2 OCR模型选型：在精度与速度间走钢丝

OCR模型通常分为两步：文本检测（Text Detection）和文本识别（Text Recognition）。检测负责找出图像中文字的区域（包围框），识别则负责将裁剪出的文字区域转换成文本字符。实时场景下，我们必须选用轻量级模型。

1. 文本检测模型选型：

   • DB (Differentiable Binarization)：这是当前在精度和速度上平衡得非常好的场景文本检测模型。它通过预测每个像素属于文本区域的概率以及该像素到文本边界框四边的距离，可以高效地检测出任意形状的文本。其后续的实时版本（如PP-OCRv3中的检测部分）经过了大量优化，非常适合边缘设备。
   • EAST或CRAFT：这些是较早期的优秀检测模型，但在某些复杂背景或弯曲文本上可能不如DB鲁棒，且未经深度优化时在边缘设备上的速度可能不占优。
   • 我的选择：我优先测试了PaddleOCR提供的PP-OCRv3检测模型。PaddleOCR对移动端和边缘设备做了大量优化，提供了预训练的轻量级模型，并且有详细的在Jetson上使用TensorRT加速的文档。

2. 文本识别模型选型：

   • CRNN (CNN+RNN+CTC)：经典序列识别模型，兼容性好，但RNN部分在并行计算上效率相对较低。
   • SVTR或ABINet：一些较新的识别架构，可能精度更高，但模型通常更复杂。
   • 我的选择：同样选择了PP-OCRv3的识别模型。它与检测模型同属一个套件，集成部署方便，且同样经过了轻量化设计和优化，在英文、数字及常见中文字符上表现足够好。

3. 端到端模型考量：也有一些端到端的OCR模型（如Mask TextSpotter），一步完成检测和识别。但它们通常模型更大，更耗资源，在边缘设备上难以满足实时性要求，因此本次方案不予采用。

最终技术栈确定：

• 硬件：reComputer Jeston Xavier NX（16GB版本）
• 操作系统：JetPack 5.1 (Ubuntu 20.04 LTS)
• 深度学习框架：PaddlePaddle (用于模型加载和预处理)
• 推理加速引擎：TensorRT 8.5
• OCR套件：PaddleOCR (PP-OCRv3 轻量级中英文识别模型)
• 视频流处理：OpenCV with GStreamer backend（在Jetson上，GStreamer处理CSI或USB摄像头流效率更高）
• 应用封装：Docker（可选，但强烈推荐用于环境隔离）

3. 环境搭建与核心工具链配置

工欲善其事，必先利其器。在reComputer上搭建一个高效的AI开发环境，是项目成功的第一步。这里我会跳过基础的JetPack刷机过程（官方有详细指南），重点讲几个关键配置和容易踩坑的地方。

3.1 基础系统优化

刷完JetPack后，第一件事不是急着装Python包，而是进行一些系统级优化，充分释放硬件潜力。

1. 调整运行模式：Jetson设备有不同的运行模式（nvpmodel），对应不同的CPU/GPU/内存频率上限，以平衡性能和功耗。对于实时OCR，我们需要最大性能。

   # 查看当前模式 sudo nvpmodel -q # 设置为最大性能模式（模式0，具体模式号因设备而异，请查手册） sudo nvpmodel -m 0 # 配合开启最大时钟频率 sudo jetson_clocks

   实操心得：jetson_clocks命令会让风扇全速运转，确保散热良好。在生产环境中，可能需要根据实际温控情况选择一个平衡的模式（如nvpmodel -m 2），以避免过热降频。

2. 增加Swap空间：即使内存有16GB，在编译一些大型库（如OpenCV）或处理大批量数据时，仍可能内存不足。增加Swap文件可以避免系统卡死。

   sudo fallocate -l 8G /swapfile sudo chmod 600 /swapfile sudo mkswap /swapfile sudo swapon /swapfile # 为了永久生效，需要写入/etc/fstab echo '/swapfile swap swap defaults 0 0' | sudo tee -a /etc/fstab

3.2 关键软件安装：OpenCV与TensorRT

JetPack自带了CUDA、cuDNN和TensorRT，但OpenCV可能需要重新编译以支持GStreamer和Python绑定。

1. 编译安装OpenCV：虽然JetPack预装了OpenCV，但有时版本或功能不全。我选择从源码编译，确保支持GStreamer（用于高效摄像头采集）和Python3。

   # 安装依赖 sudo apt-get update sudo apt-get install -y build-essential cmake git libgtk2.0-dev pkg-config libavcodec-dev libavformat-dev libswscale-dev libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev python3-dev python3-numpy # 下载OpenCV源码（以4.8.0为例） wget -O opencv.zip https://github.com/opencv/opencv/archive/4.8.0.zip unzip opencv.zip cd opencv-4.8.0 mkdir build && cd build # 关键配置：开启CUDA、GStreamer，关闭无关功能以减少编译时间和体积 cmake -D CMAKE_BUILD_TYPE=RELEASE \ -D CMAKE_INSTALL_PREFIX=/usr/local \ -D WITH_CUDA=ON \ -D WITH_CUDNN=ON \ -D OPENCV_DNN_CUDA=ON \ -D WITH_GSTREAMER=ON \ -D WITH_GSTREAMER_0_10=OFF \ -D WITH_FFMPEG=OFF \ -D WITH_IPP=OFF \ -D BUILD_opencv_python3=ON \ -D BUILD_EXAMPLES=OFF \ -D BUILD_TESTS=OFF \ -D BUILD_PERF_TESTS=OFF \ .. # 开始编译，使用所有核心 make -j$(nproc) sudo make install sudo ldconfig

   这个过程可能需要1-2小时。编译完成后，在Python中import cv2并检查cv2.getBuildInformation()是否包含CUDA和GStreamer。

2. 验证TensorRT：TensorRT通常已预装。检查版本并安装Python绑定。

   dpkg -l | grep tensorrt # 安装Python接口 sudo apt-get install python3-libnvinfer python3-libnvinfer-dev

   在Python中import tensorrt应该可以成功。

3.3 PaddlePaddle与PaddleOCR安装

这是我们的核心AI套件。务必安装与JetPack CUDA版本匹配的PaddlePaddle。

1. 安装PaddlePaddle：前往PaddlePaddle官网，根据你的JetPack版本（CUDA 11.4？）选择对应的安装命令。例如，对于JetPack 5.1 (CUDA 11.4)：

   python3 -m pip install paddlepaddle-gpu==2.5.1.post114 -f https://www.paddlepaddle.org.cn/whl/linux/mkl/avx/stable.html

   安装后，运行python3 -c "import paddle; paddle.utils.run_check()"，确认输出显示有GPU设备，并且测试通过。

2. 安装PaddleOCR：建议使用pip安装最新版，同时我们可能需要其源码中的一些工具和脚本。

   pip install paddleocr # 也可以克隆仓库，方便使用工具脚本 git clone https://github.com/PaddlePaddle/PaddleOCR.git cd PaddleOCR pip install -r requirements.txt

   注意事项：直接pip install paddleocr会安装其所有依赖，包括一些视觉相关的库（如opencv-python）。如果你已经编译了系统级的OpenCV，可能会存在冲突。一个干净的方案是使用虚拟环境（venv）或在Docker容器内安装。

4. 模型获取、优化与TensorRT加速

直接使用PaddleOCR的预训练模型可以快速验证，但要达到极致的实时性能，必须通过TensorRT进行推理优化。这个过程是将通用模型转化为高度特化、硬件友好的引擎文件。

4.1 下载预训练模型

PaddleOCR提供了丰富的预训练模型。我们关注PP-OCRv3的轻量级系列。

# 进入PaddleOCR目录 cd PaddleOCR # 下载检测和识别模型 wget -P ./inference https://paddleocr.bj.bcebos.com/PP-OCRv3/english/en_PP-OCRv3_det_infer.tar wget -P ./inference https://paddleocr.bj.bcebos.com/PP-OCRv3/english/en_PP-OCRv3_rec_infer.tar # 解压 cd inference tar xf en_PP-OCRv3_det_infer.tar tar xf en_PP-OCRv3_rec_infer.tar

解压后，你会得到两个目录，里面包含.pdmodel（模型结构）和.pdiparams（模型权重）文件。

4.2 模型转ONNX

TensorRT并不直接支持PaddlePaddle的模型格式。通常的路径是：PaddlePaddle -> ONNX -> TensorRT。ONNX是一个开放的模型交换格式。

PaddleOCR提供了转换工具tools/export_model.py，但更直接的方式是使用Paddle2ONNX工具。

# 安装paddle2onnx pip install paddle2onnx # 转换检测模型 paddle2onnx --model_dir en_PP-OCRv3_det_infer \ --model_filename inference.pdmodel \ --params_filename inference.pdiparams \ --save_file det_model.onnx \ --opset_version 11 \ --enable_onnx_checker True # 转换识别模型 paddle2onnx --model_dir en_PP-OCRv3_rec_infer \ --model_filename inference.pdmodel \ --params_filename inference.pdiparams \ --save_file rec_model.onnx \ --opset_version 11 \ --enable_onnx_checker True \ --input_shape_dict="{'x':[-1,3,48,320]}"

关键参数解析：

• --opset_version：指定ONNX算子集版本，版本越高支持的算子越多，但需要与TensorRT版本兼容。版本11是一个广泛兼容的选择。
• --input_shape_dict：对于识别模型，需要指定动态输入维度。[-1,3,48,320]表示批处理维度为-1（动态），通道3，高度48，宽度320。宽度320是PP-OCR识别网络的标准输入宽度，高度是动态的，但推理时会被填充或缩放至32的倍数。

4.3 ONNX模型转TensorRT引擎

这是最核心的优化步骤。我们将使用TensorRT的trtexec命令行工具（推荐，方便）或Python API进行转换。

1. 使用trtexec转换：

   # 查找trtexec路径，通常在/usr/src/tensorrt/bin/下 which trtexec # 转换检测模型引擎，指定动态尺寸范围 /usr/src/tensorrt/bin/trtexec --onnx=det_model.onnx \ --saveEngine=det_model.engine \ --workspace=2048 \ --minShapes=input:1x3x640x640 \ --optShapes=input:4x3x640x640 \ --maxShapes=input:8x3x640x640 \ --fp16 # 转换识别模型引擎，注意动态宽度 /usr/src/tensorrt/bin/trtexec --onnx=rec_model.onnx \ --saveEngine=rec_model.engine \ --workspace=1024 \ --minShapes=x:1x3x48x320 \ --optShapes=x:4x3x48x320 \ --maxShapes=x:8x3x48x320 \ --fp16

   参数详解：

   • --workspace: 分配的GPU临时内存大小（MB），复杂模型需要更大空间。
   • --minShapes/optShapes/maxShapes: 定义动态尺寸的最小、最优、最大值。TensorRT会根据这些信息优化内核。optShapes是最常见的输入尺寸，用于引导优化。
   • --fp16: 启用FP16（半精度）计算，能大幅提升速度且精度损失通常可接受，是边缘设备的必选项。如果模型非常敏感，可以尝试--fp32，但速度会慢。

2. 验证引擎文件：生成.engine文件后，可以用trtexec简单测试一下性能。

   /usr/src/tensorrt/bin/trtexec --loadEngine=det_model.engine --shapes=input:1x3x640x640

   输出会显示平均延迟、吞吐量等信息。确保延迟在可接受范围内（例如，检测模型单帧<10ms）。

实操心得：动态形状的坑。OCR检测模型的输入尺寸通常是固定的（如640x640），但识别模型的输入高度是变化的。在转换识别模型时，必须正确设置动态维度。如果设置不当，在推理时输入非最优形状的图片，TensorRT可能会回退到效率极低的通用内核，导致识别步骤耗时激增。务必根据你实际处理文本行的高度分布，设置合理的optShapes。

5. 实时OCR流水线设计与实现

有了优化好的模型引擎，接下来就是设计一个高效的流水线，将摄像头视频流、模型推理和后处理串联起来，并保证帧率稳定。

5.1 流水线架构设计

一个健壮的实时OCR流水线应该包含以下模块，并且它们最好运行在不同的线程中，以避免阻塞：

1. 视频采集线程：负责从摄像头（CSI或USB）或RTSP流中读取帧。使用GStreamer管道（通过OpenCV的CAP_GSTREAMER后端）在Jetson上通常能获得比默认V4L2后端更低的延迟和更高的稳定性。
2. 预处理线程：对采集到的帧进行缩放、颜色空间转换（BGR2RGB）、归一化等操作，准备成模型需要的输入张量。这里可以考虑一个队列（buffer），视频线程放入原始帧，预处理线程取出处理。
3. 推理线程：这是核心计算线程。它从预处理队列中获取张量，分别送入检测引擎和识别引擎进行推理。
   • 检测推理：输入一张图像，输出文本框的坐标和置信度。
   • 识别推理：根据检测出的文本框，从原图中裁剪出每个文本区域，进行仿射变换（摆正）、缩放至模型输入尺寸（如高32，宽等比缩放后填充至320），然后送入识别引擎，得到文本内容。
4. 后处理与输出线程：对识别结果进行过滤（如根据置信度阈值过滤）、整理（如按行排序），然后通过某种方式输出，例如在图像上绘制文本框和识别文字（可视化），或者通过MQTT/HTTP发送到其他系统，亦或保存到本地文件。

我选择的线程模型：由于Python的GIL限制，纯Python多线程对计算密集型任务提升有限。因此，我将视频采集和预处理放在主线程，而将检测推理和识别推理这两个最耗时的部分，分别交给两个独立的进程（使用multiprocessing模块）来处理，进程间通过multiprocessing.Queue传递数据。这样可以真正利用多核CPU，并且避免GIL对长时间推理的影响。

5.2 核心代码实现拆解

下面给出关键部分的代码片段和解释。

1. 视频采集（GStreamer管道）

import cv2 def gstreamer_pipeline(capture_width=1280, capture_height=720, display_width=960, display_height=540, framerate=30): """构建用于CSI摄像头的GStreamer管道字符串""" return ( f"nvarguscamerasrc ! " f"video/x-raw(memory:NVMM), width=(int){capture_width}, height=(int){capture_height}, " f"format=(string)NV12, framerate=(fraction){framerate}/1 ! " f"nvvidconv flip-method=0 ! " f"video/x-raw, width=(int){display_width}, height=(int){display_height}, format=(string)BGRx ! " f"videoconvert ! " f"video/x-raw, format=(string)BGR ! appsink" ) # 对于USB摄像头，也可以尝试GStreamer，但简单的cv2.VideoCapture(0)也可能够用。 # 使用CSI摄像头 cap = cv2.VideoCapture(gstreamer_pipeline(), cv2.CAP_GSTREAMER) if not cap.isOpened(): print("无法打开摄像头") exit()

2. TensorRT推理引擎封装我们需要写一个类来加载.engine文件并执行推理。

import tensorrt as trt import pycuda.driver as cuda import pycuda.autoinit import numpy as np class TrtEngine: def __init__(self, engine_path): self.logger = trt.Logger(trt.Logger.WARNING) with open(engine_path, 'rb') as f, trt.Runtime(self.logger) as runtime: self.engine = runtime.deserialize_cuda_engine(f.read()) self.context = self.engine.create_execution_context() # 分配输入输出缓冲区 self.bindings = [] self.inputs = [] self.outputs = [] for binding in self.engine: size = trt.volume(self.engine.get_binding_shape(binding)) dtype = trt.nptype(self.engine.get_binding_dtype(binding)) host_mem = cuda.pagelocked_empty(size, dtype) device_mem = cuda.mem_alloc(host_mem.nbytes) self.bindings.append(int(device_mem)) if self.engine.binding_is_input(binding): self.inputs.append({'host': host_mem, 'device': device_mem}) else: self.outputs.append({'host': host_mem, 'device': device_mem}) self.stream = cuda.Stream() def infer(self, input_data): # 将输入数据复制到主机缓冲区 np.copyto(self.inputs[0]['host'], input_data.ravel()) # 将主机数据拷贝到设备 cuda.memcpy_htod_async(self.inputs[0]['device'], self.inputs[0]['host'], self.stream) # 执行推理 self.context.execute_async_v2(bindings=self.bindings, stream_handle=self.stream.handle) # 将结果从设备拷贝回主机 cuda.memcpy_dtoh_async(self.outputs[0]['host'], self.outputs[0]['device'], self.stream) # 同步流 self.stream.synchronize() # 返回输出数据（可能需要根据模型输出结构reshape） return self.outputs[0]['host'].copy()

3. 检测后处理（DB模型输出解析）DB模型的输出通常是概率图和阈值图，需要解码成文本框。

import cv2 import numpy as np def db_postprocess(binary_map, score_map, box_thresh=0.3, max_candidates=1000): """ binary_map: 二值化后的概率图 score_map: 得分图 """ height, width = binary_map.shape # 寻找轮廓 contours, _ = cv2.findContours((binary_map * 255).astype(np.uint8), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE) boxes = [] scores = [] for contour in contours[:max_candidates]: points = contour.squeeze(1) if points.shape[0] < 4: continue score = score_map[points[:, 1], points[:, 0]].mean() if score < box_thresh: continue rect = cv2.minAreaRect(points) box = cv2.boxPoints(rect).astype(np.int32) boxes.append(box) scores.append(score) return boxes, scores

4. 识别预处理（文本区域矫正）检测出的文本框可能是倾斜的，直接裁剪送入识别模型效果差。需要进行透视变换矫正。

def four_point_transform(image, box): """将任意四边形文本框区域矫正为水平矩形""" # 将box的四个点排序：左上、右上、右下、左下 rect = order_points(box) # 需要实现一个排序函数 (tl, tr, br, bl) = rect # 计算新矩形的宽度和高度 widthA = np.linalg.norm(br - bl) widthB = np.linalg.norm(tr - tl) maxWidth = max(int(widthA), int(widthB)) heightA = np.linalg.norm(tr - br) heightB = np.linalg.norm(tl - bl) maxHeight = max(int(heightA), int(heightB)) # 目标点坐标 dst = np.array([ [0, 0], [maxWidth - 1, 0], [maxWidth - 1, maxHeight - 1], [0, maxHeight - 1]], dtype="float32") # 计算透视变换矩阵并应用 M = cv2.getPerspectiveTransform(rect, dst) warped = cv2.warpPerspective(image, M, (maxWidth, maxHeight)) return warped

矫正后，再将warped图像缩放至识别模型输入尺寸（如高32，宽等比缩放并填充至320），并进行归一化。

5.3 主循环与性能统计

将上述模块整合进主循环，并添加帧率（FPS）统计，是评估实时性的关键。

import time # 初始化引擎 det_engine = TrtEngine('det_model.engine') rec_engine = TrtEngine('rec_model.engine') frame_count = 0 start_time = time.time() while True: ret, frame = cap.read() if not ret: break # 1. 预处理 inp_img, ratio_h, ratio_w = preprocess(frame) # 缩放至640x640，记录缩放比例 # 2. 检测推理 det_output = det_engine.infer(inp_img) # 3. 检测后处理，得到原始图像坐标下的boxes boxes, scores = db_postprocess(det_output[0], det_output[1]) # 将boxes坐标根据预处理时的缩放比例映射回原图 boxes = boxes / np.array([ratio_w, ratio_h]) text_results = [] for box in boxes: # 4. 识别预处理：裁剪+矫正+缩放 text_roi = four_point_transform(frame, box) rec_input = rec_preprocess(text_roi) # 缩放至32x320等 # 5. 识别推理 rec_output = rec_engine.infer(rec_input) # 6. 识别后处理：将网络输出（如CTC路径）解码为字符串 text = ctc_decode(rec_output) # 需要实现解码函数 text_results.append((box, text)) # 7. 可视化：在原图上画框和文字 for box, text in text_results: cv2.polylines(frame, [box.astype(np.int32)], True, (0, 255, 0), 2) cv2.putText(frame, text, (int(box[0][0]), int(box[0][1])-10), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 255), 2) # 计算并显示FPS frame_count += 1 if frame_count % 30 == 0: fps = frame_count / (time.time() - start_time) print(f"Processing FPS: {fps:.2f}") frame_count = 0 start_time = time.time() cv2.imshow('Real-time OCR', frame) if cv2.waitKey(1) & 0xFF == ord('q'): break cap.release() cv2.destroyAllWindows()

6. 性能调优与常见问题排查

即使代码跑通了，离“稳定实时”还有距离。下面是我在调优过程中遇到的一些典型问题和解决方案。

6.1 性能瓶颈分析与优化

1. 瓶颈定位：使用jetson_stats工具（sudo pip install jetson-stats，然后运行jtop）实时监控CPU、GPU、内存、Tensor Cores的使用率以及功耗和温度。通常，瓶颈在GPU上。

   • GPU利用率低：可能原因是CPU预处理太慢，喂给GPU的数据不够快。考虑用多线程/进程并行处理。
   • GPU利用率高但FPS低：模型太大或TensorRT优化不够。尝试更激进的量化（如INT8量化），但INT8需要校准数据集，过程复杂。FP16通常是性价比最高的选择。

2. 推理批次优化：上面的示例是单张图片推理。TensorRT在处理批次（Batch）数据时效率更高。可以积累几帧（比如4帧）的预处理结果，一次性送入检测模型进行推理，能显著提升吞吐量。但这会引入额外的延迟（需要等批次数凑满），在实时系统中需要权衡。对于识别模型，将多个文本区域拼成一个批次送入识别引擎，收益非常明显。

3. 内存复用：在循环中避免频繁申请和释放大块内存（如图像数组、CUDA缓冲区）。在初始化阶段就分配好所需内存，在循环中重复使用。

4. 预处理加速：图像缩放、颜色转换等操作，可以考虑使用CUDA加速的库，如cv2.cuda模块，或者使用TensorRT的插件在GPU上直接完成预处理。

6.2 常见问题与解决方案速查表

6.3 精度与速度的权衡实战

在真实场景中，你需要根据具体需求调整参数，在“识别准”和“识别快”之间找到最佳点。

1. 检测阈值（box_thresh）：调高它（如从0.3到0.5），可以过滤掉更多假阳性文本框，减少后续识别工作量，提升整体速度，但可能会漏掉一些模糊文字。
2. 输入图像分辨率：检测模型输入默认是640x640。如果摄像头原始分辨率是1080p，缩放至此会损失细节，可能影响小文字检测。可以尝试增大输入尺寸（如960x960），但会显著增加计算量。一个折中方案是，先以较低分辨率做快速检测，对检测到的区域，再在原高分辨率图上裁剪进行识别。
3. 识别模型字典：如果场景中只出现数字和少量字母（如车牌、产品编码），可以自定义一个小的字典文件，这样识别时的搜索空间变小，能略微提升速度，并可能减少类似字符误识。
4. 非极大值抑制（NMS）：在检测后处理中，NMS用于合并重叠的文本框。调整NMS的阈值（nms_thresh），可以控制框的合并程度，影响最终框的数量和位置。

经过上述的系统性搭建、模型优化、流水线设计和精细调优，我最终在Jetson Xavier NX上，处理720p的视频流，对于中等文本密度的场景，实现了平均超过25 FPS的稳定实时OCR识别，延迟控制在100毫秒以内，完全满足了项目初期设定的目标。整个过程犹如在有限的资源下进行一场精密的“手术”，每一个环节的优化都直接关系到最终的体验。