真实场景：一个让我加了两周班的发票识别需求

2023年Q2，公司接到一个财务系统需求：自动识别增值税发票上的关键字段（发票号、金额、日期）。测试环境跑Tesseract 5.3.3，识别率只有62%。客户要求98%以上。我花了2周调研、对比、调优，最终用PaddleOCR + CRNN + CTC方案把准确率干到99.2%。这篇文章就是这次选型的完整复盘。

问题：传统OCR为什么不够用？

传统OCR（如Tesseract）基于图像处理和模板匹配，对以下场景无能为力：

• 倾斜、扭曲的文字（发票拍照角度不固定）
• 模糊、低分辨率（手机拍摄的发票）
• 复杂背景（发票上有水印、印章）
• 多语言混合（中文+英文+数字）

深度学习OCR通过CNN提取特征、RNN序列建模、CTC损失函数解决变长序列对齐，能处理上述问题。

方案对比：传统 vs 深度学习

我测试了两种主流方案：

• 方案A：Tesseract 5.3.3 + 图像预处理（传统OCR代表）
• 方案B：PaddleOCR 2.7 + CRNN + CTC（深度学习OCR代表）

测试环境：Ubuntu 22.04, Python 3.10, NVIDIA RTX 3090 (24GB), Intel i9-13900K, 64GB RAM。

方案A：Tesseract 5.3.3 实现

安装和配置：

# 安装Tesseract 5.3.3
sudo apt-get install tesseract-ocr=5.3.3-1
# 安装中文语言包
sudo apt-get install tesseract-ocr-chi-sim
# 验证版本
tesseract --version
# 输出：tesseract 5.3.3

Python调用代码：

import pytesseract
from PIL import Image, ImageFilter, ImageEnhance
import cv2
import numpy as np

def preprocess_image(image_path):
    """图像预处理：灰度化、二值化、去噪、倾斜校正"""
    img = cv2.imread(image_path)
    # 灰度化
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    # 高斯去噪
    denoised = cv2.GaussianBlur(gray, (5, 5), 0)
    # 自适应二值化
    binary = cv2.adaptiveThreshold(denoised, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
                                   cv2.THRESH_BINARY, 11, 2)
    # 倾斜校正（霍夫变换）
    edges = cv2.Canny(binary, 50, 150, apertureSize=3)
    lines = cv2.HoughLines(edges, 1, np.pi/180, 200)
    if lines is not None:
        angle = np.median([line[0][1] for line in lines])
        angle = np.degrees(angle) - 90
        (h, w) = binary.shape[:2]
        center = (w // 2, h // 2)
        M = cv2.getRotationMatrix2D(center, angle, 1.0)
        binary = cv2.warpAffine(binary, M, (w, h), flags=cv2.INTER_CUBIC, 
                                borderMode=cv2.BORDER_REPLICATE)
    return binary

def tesseract_ocr(image_path):
    """使用Tesseract进行OCR识别"""
    processed_img = preprocess_image(image_path)
    # 保存预处理后的图像（可选）
    cv2.imwrite('processed.jpg', processed_img)
    # 调用Tesseract
    config = '--oem 3 --psm 6 -l chi_sim+eng'
    text = pytesseract.image_to_string(processed_img, config=config)
    return text

# 测试
result = tesseract_ocr('invoice.jpg')
print(result)

方案B：PaddleOCR 2.7 + CRNN + CTC 实现

安装和配置：

# 创建虚拟环境
python3 -m venv ocr_env
source ocr_env/bin/activate
# 安装PaddlePaddle GPU版（2.5.2）
pip install paddlepaddle-gpu==2.5.2 -f https://www.paddlepaddle.org.cn/whl/linux/mkl/avx/stable.html
# 安装PaddleOCR 2.7
pip install paddleocr==2.7.0
# 验证版本
python -c "import paddleocr; print(paddleocr.__version__)"
# 输出：2.7.0

Python调用代码：

from paddleocr import PaddleOCR
import time

def paddleocr_inference(image_path):
    """使用PaddleOCR进行端到端OCR识别"""
    # 初始化OCR引擎
    ocr = PaddleOCR(
        use_angle_cls=True,  # 启用文本方向分类
        lang='ch',           # 中文模型
        use_gpu=True,        # 使用GPU加速
        gpu_mem=4000,        # 分配4GB显存
        det_db_thresh=0.3,   # 检测阈值
        rec_batch_num=6      # 批量识别数量
    )
    # 执行OCR
    start = time.time()
    result = ocr.ocr(image_path, cls=True)
    end = time.time()
    # 解析结果
    texts = []
    for line in result[0]:
        bbox, (text, confidence) = line
        texts.append({'text': text, 'confidence': confidence, 'bbox': bbox})
    return texts, end - start

# 测试
texts, elapsed = paddleocr_inference('invoice.jpg')
for item in texts:
    print(f"文本: {item['text']}, 置信度: {item['confidence']:.4f}")
print(f"耗时: {elapsed:.3f}秒")

自定义CRNN + CTC模型训练（用于微调）

当PaddleOCR预训练模型不够用时，需要微调。以下是完整的训练代码：

import paddle
import paddle.nn as nn
import paddle.nn.functional as F
from paddle.io import Dataset, DataLoader
import numpy as np
from PIL import Image
import os

# 自定义数据集
class OCRDataset(Dataset):
    def __init__(self, data_root, label_file, img_height=32, img_width=320):
        self.data_root = data_root
        self.img_height = img_height
        self.img_width = img_width
        self.samples = []
        with open(label_file, 'r', encoding='utf-8') as f:
            for line in f:
                img_name, label = line.strip().split('\t')
                self.samples.append((img_name, label))
        # 构建字符映射表
        self.char_list = self._build_char_list()
        self.char_to_idx = {c: i for i, c in enumerate(self.char_list)}
        self.idx_to_char = {i: c for i, c in enumerate(self.char_list)}
    
    def _build_char_list(self):
        chars = set()
        for _, label in self.samples:
            chars.update(label)
        # 添加特殊字符：blank用于CTC
        return [''] + sorted(list(chars))
    
    def __len__(self):
        return len(self.samples)
    
    def __getitem__(self, idx):
        img_name, label = self.samples[idx]
        img_path = os.path.join(self.data_root, img_name)
        # 加载图像并预处理
        img = Image.open(img_path).convert('L')  # 灰度图
        img = img.resize((self.img_width, self.img_height))
        img = np.array(img, dtype=np.float32) / 255.0
        img = (img - 0.5) / 0.5  # 归一化到[-1, 1]
        img = np.expand_dims(img, axis=0)  # 添加通道维度
        # 标签转索引
        label_indices = [self.char_to_idx[c] for c in label]
        return img, np.array(label_indices, dtype=np.int64)

# CRNN模型定义
class CRNN(nn.Layer):
    def __init__(self, num_classes, input_channels=1, hidden_size=256):
        super(CRNN, self).__init__()
        # CNN部分：提取特征
        self.cnn = nn.Sequential(
            nn.Conv2D(input_channels, 64, 3, padding=1),
            nn.BatchNorm2D(64),
            nn.ReLU(),
            nn.MaxPool2D(2, 2),  # 16x160
            
            nn.Conv2D(64, 128, 3, padding=1),
            nn.BatchNorm2D(128),
            nn.ReLU(),
            nn.MaxPool2D(2, 2),  # 8x80
            
            nn.Conv2D(128, 256, 3, padding=1),
            nn.BatchNorm2D(256),
            nn.ReLU(),
            nn.MaxPool2D(2, 2),  # 4x40
            
            nn.Conv2D(256, 512, 3, padding=1),
            nn.BatchNorm2D(512),
            nn.ReLU(),
            nn.MaxPool2D(2, (2, 1)),  # 2x40
            
            nn.Conv2D(512, 512, 3, padding=1),
            nn.BatchNorm2D(512),
            nn.ReLU(),
            nn.MaxPool2D(2, (2, 1)),  # 1x40
        )
        # RNN部分：序列建模
        self.rnn = nn.Sequential(
            nn.LSTM(512, hidden_size, num_layers=2, direction='bidirectional'),
            nn.LSTM(hidden_size * 2, hidden_size, num_layers=2, direction='bidirectional')
        )
        # 全连接层：输出字符概率
        self.fc = nn.Linear(hidden_size * 2, num_classes)
    
    def forward(self, x):
        # x: [batch, 1, 32, 320]
        x = self.cnn(x)  # [batch, 512, 1, 40]
        x = x.squeeze(2)  # [batch, 512, 40]
        x = x.transpose([0, 2, 1])  # [batch, 40, 512]
        x, _ = self.rnn(x)  # [batch, 40, 512]
        x = self.fc(x)  # [batch, 40, num_classes]
        return x

# CTC损失函数
def ctc_loss(logits, labels, input_lengths, label_lengths):
    # logits: [batch, time, num_classes]
    # labels: [batch, label_len]
    # input_lengths: [batch]
    # label_lengths: [batch]
    log_probs = F.log_softmax(logits, axis=2)
    loss = paddle.nn.functional.ctc_loss(
        log_probs.transpose([1, 0, 2]),  # [time, batch, num_classes]
        labels,
        input_lengths,
        label_lengths,
        blank=0  # blank索引为0
    )
    return loss

# 训练循环
def train(model, train_loader, epochs=50, lr=0.001):
    optimizer = paddle.optimizer.Adam(learning_rate=lr, parameters=model.parameters())
    for epoch in range(epochs):
        total_loss = 0.0
        for batch_idx, (images, labels) in enumerate(train_loader):
            # images: [batch, 1, 32, 320]
            # labels: [batch, label_len]
            batch_size = images.shape[0]
            # 前向传播
            logits = model(images)  # [batch, time, num_classes]
            # 计算输入长度（时间步数）
            input_lengths = paddle.full([batch_size], logits.shape[1], dtype='int64')
            # 计算标签长度
            label_lengths = paddle.to_tensor([len(l) for l in labels], dtype='int64')
            # 计算损失
            loss = ctc_loss(logits, labels, input_lengths, label_lengths)
            # 反向传播
            loss.backward()
            optimizer.step()
            optimizer.clear_grad()
            total_loss += loss.numpy()[0]
            if batch_idx % 10 == 0:
                print(f"Epoch {epoch+1}, Batch {batch_idx}, Loss: {loss.numpy()[0]:.4f}")
        print(f"Epoch {epoch+1} Average Loss: {total_loss/len(train_loader):.4f}")

# 推理函数
def predict(model, image, char_list):
    model.eval()
    with paddle.no_grad():
        logits = model(image)  # [1, time, num_classes]
        # 贪心解码
        probs = F.softmax(logits, axis=2)
        pred_indices = paddle.argmax(probs, axis=2).numpy()[0]  # [time]
        # 去重并移除blank
        prev = -1
        text = ''
        for idx in pred_indices:
            if idx != prev and idx != 0:  # 0是blank
                text += char_list[idx]
            prev = idx
        return text

# 使用示例
if __name__ == '__main__':
    # 创建数据集
    dataset = OCRDataset('data/images', 'data/labels.txt')
    train_loader = DataLoader(dataset, batch_size=32, shuffle=True)
    # 创建模型
    model = CRNN(num_classes=len(dataset.char_list))
    # 训练
    train(model, train_loader, epochs=50)
    # 保存模型
    paddle.save(model.state_dict(), 'crnn_model.pdparams')

效果数据对比

测试集：500张增值税发票图像（包含倾斜、模糊、水印等复杂场景）。

结论：PaddleOCR在准确率上碾压Tesseract，但推理耗时和资源占用更高。自定义CRNN+CTC在微调后准确率最高，适合特定场景。

避坑指南（我踩过的5个坑）

坑1：PaddleOCR版本兼容性问题

PaddleOCR 2.7要求PaddlePaddle 2.5.x，但pip默认安装2.6.0。我花了半天排查ImportError。解决方案：指定版本安装。

pip install paddlepaddle-gpu==2.5.2

坑2：CTC损失函数中的blank索引

CTC要求blank索引为0，但我的字符映射表中''在索引0。如果忘记设置，训练时loss不下降。检查方法：打印logits的shape和blank索引。

# 验证blank索引
print(f"Blank index: {dataset.char_to_idx['']}")  # 必须为0

坑3：图像预处理过度导致信息丢失

对模糊图像使用过强的二值化（阈值过低）会丢失文字笔画。我改用自适应阈值后准确率提升12%。

# 错误：固定阈值
_, binary = cv2.threshold(gray, 128, 255, cv2.THRESH_BINARY)
# 正确：自适应阈值
binary = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
                               cv2.THRESH_BINARY, 11, 2)

坑4：批量推理时显存溢出

PaddleOCR默认rec_batch_num=6，但发票图像分辨率高（4000x3000），batch_size=6时显存飙到8GB。调低到2后稳定在2.1GB。

ocr = PaddleOCR(rec_batch_num=2, gpu_mem=4000)

坑5：CRNN输入尺寸不一致

训练时图像resize到32x320，但推理时输入尺寸不同导致错误。解决方案：统一输入尺寸，或在模型前加自适应池化层。

# 在CRNN的CNN部分最后加自适应池化
self.adaptive_pool = nn.AdaptiveAvgPool2D((1, 40))

总结

选型建议：

• 简单场景（清晰扫描件、标准字体）：Tesseract 5.3.3 + 预处理，准确率80%+，零成本
• 复杂场景（自然场景、多语言）：PaddleOCR 2.7，开箱即用，准确率95%+
• 特定场景（发票、车牌）：自定义CRNN+CTC微调，准确率99%+，但需要标注数据

代码都在上面，直接复制跑。有问题评论区见。