万字深度解析百度 Unlimited OCR：当 R-SWA 遇见 MoE——3B 参数如何碾压端到端 OCR 全场（2026）

2026年6月22日，百度发布并开源 Unlimited OCR。5天 GitHub Star 破万，同时登顶 GitHub Daily Trending、Python榜、HuggingFace 全球模型总趋势榜、多模态模型趋势榜四榜第一。OmniDocBench v1.6 综合成绩 93.92%，刷新端到端 OCR SOTA。本文从 R-SWA 机制、MoE 架构、视觉压缩、工程部署四个维度，万字深度解析这款「一次扫描整本书」的 OCR 新王者。

目录

1. 端到端 OCR 的长文档困境：为什么 AI 越生成越慢？
2. Unlimited OCR 核心架构：DeepEncoder + MoE Decoder
3. R-SWA 深度拆解：参考滑动窗口注意力如何把 KV Cache 压成常数
4. 视觉编码与 Token 压缩：1024×1024 图像→256 个视觉 Token
5. 代码实战：从安装部署到批量推理的完整流程
6. 性能基准与对比：93.92% SOTA 背后的数据
7. R-SWA 的通用性：不止 OCR，ASR、翻译同样受益
8. 生产环境部署指南：显存、并发、量化的实战建议
9. 总结与展望：OCR 的长文档时代才刚刚开始

1. 端到端 OCR 的长文档困境：为什么 AI 越生成越慢？

1.1 传统 OCR 的两阶段之痛

传统 OCR 流程分为两个独立阶段：

图像 → 文本检测（Detection）→ 文本识别（Recognition）→ 拼接输出

这种「先检测文字框，再逐个识别」的流水线存在两个根本问题：

1. 信息丢失：检测框的边界误差会直接传递到识别阶段，无法回溯修正
2. 计算冗余：每个文字框独立推理，无法共享视觉特征，大量重复计算

1.2 端到端 OCR 的突破与代价

以 DeepSeek OCR 为代表的端到端方案，用统一的神经网络架构直接完成「图像→文本序列」的映射：

# 端到端 OCR 的核心思路（概念代码）
image = load_image("document.png")          # [H, W, 3]
visual_tokens = vision_encoder(image)        # [N, D] 视觉特征
text_sequence = language_decoder(visual_tokens)  # 直接输出文本

优势明显：单次前向传播完成全部工作，信息无损传递。

代价同样明显：语言解码器（通常是 Transformer Decoder）采用自回归生成，每生成一个新 token，就需要将此前所有 token 的 KV Cache 保留在显存中。

1.3 KV Cache 线性增长的数学本质

标准 Transformer Decoder 的注意力计算：

Attention(Q, K, V) = softmax(QK^T / √d_k) V

生成第 t 个 token 时，KV Cache 的大小为：

KV_Cache_Size(t) = t × (d_k + d_v) × num_layers × num_heads × precision_bytes

当 t 从 10 增长到 10,000（约 40 页文档），KV Cache 占用显存 线性增长 1000 倍。

这就是用户感知中「AI 解析多页文档后越生成越慢」的根本原因。

1.4 人类的启示：抄书员的工作记忆

有趣的是，人类抄写员在处理上百页文档时，效率并不会明显下降。关键在于：

人类不会在每一步都重新读取之前写下的每一个字，而是只保留「当前工作需要的信息和进度」。

百度 Unlimited OCR 的 R-SWA 机制，正是对这种人类工作记忆的数学建模。

2. Unlimited OCR 核心架构：DeepEncoder + MoE Decoder

2.1 整体架构图

输入：多页文档图像（1024×1024 × N页）
         │
         ▼
┌─────────────────────────────────────────┐
│         DeepEncoder（编码器）            │
│  ┌─────────────────────────────────┐   │
│  │  两级视觉编码（2-level Vision）   │   │
│  │  Low-level: CNN 提取局部纹理     │   │
│  │  High-level: Transformer 全局   │   │
│  └─────────────────────────────────┘   │
│                  │                      │
│                  ▼                      │
│        16× Token 压缩层                 │
│   1024×1024 → 256 个视觉 Token        │
└─────────────────────────────────────────┘
         │ 256 个 visual tokens
         ▼
┌─────────────────────────────────────────┐
│      MoE Decoder（MoE 解码器）          │
│  ┌─────────────────────────────────┐   │
│  │  R-SWA 注意力层（核心创新）      │   │
│  │  参考 Token：全量可见            │   │
│  │  输出 Token：滑动窗口            │   │
│  └─────────────────────────────────┘   │
│                  │                      │
│                  ▼                      │
│    MoE FFN：仅激活 570M 参数           │
│    (总参数 3B，激活率 ~19%)            │
└─────────────────────────────────────────┘
         │
         ▼
输出：完整文本序列（最长 32K tokens）

2.2 DeepEncoder：16 倍 Token 压缩的数学细节

DeepEncoder 延续 DeepSeek OCR 的编码架构，核心创新在连接阶段的 16× Token 压缩：

# 概念代码：Token 压缩层
class TokenCompressor(nn.Module):
    def __init__(self, input_dim, compress_ratio=16):
        super().__init__()
        self.ratio = compress_ratio
        self.proj = nn.Linear(input_dim * compress_ratio, input_dim)
    
    def forward(self, x):
        # x: [batch, num_patches, dim]
        # num_patches = 4096 (原始 patch 数)
        b, n, d = x.shape
        # 每 16 个相邻 patch 合并为一个压缩 Token
        x = x.view(b, n // self.ratio, self.ratio, d)
        x = x.mean(dim=2)  # 平均池化合并
        # 或者用更精细的跨 patch 注意力：
        # x = self.cross_attn(x)  
        return x  # [batch, 256, dim]

压缩效果：

• 输入：1024×1024 图像，按 16×16 patch 划分 → 4096 个视觉 token
• 输出：4096 / 16 = 256 个压缩视觉 token
• 预填充（prefill）阶段的计算量降低 16 倍

2.3 MoE Decoder：3B 总参数，570M 激活参数的奥秘

Mixture-of-Experts（混合专家）架构的核心思想：每次推理只激活部分参数。

标准 FFN：每个 token 都经过完全相同的全连接层
MoE FFN：每个 token 路由到 top-K 个专家（K=2），其余专家不参与计算

# MoE FFN 概念代码
class MoEFFN(nn.Module):
    def __init__(self, dim, num_experts=8, top_k=2):
        super().__init__()
        self.experts = nn.ModuleList([FFN(dim) for _ in range(num_experts)])
        self.gate = nn.Linear(dim, num_experts)
        self.top_k = top_k
    
    def forward(self, x):
        # x: [batch, seq_len, dim]
        gate_scores = self.gate(x)  # [batch, seq_len, num_experts]
        top_k_scores, top_k_indices = gate_scores.topk(self.top_k, dim=-1)
        # 每个 token 只激活 top-2 专家
        output = torch.zeros_like(x)
        for i in range(self.top_k):
            expert_idx = top_k_indices[..., i]
            expert_weight = top_k_scores[..., i:i+1]
            # 调用对应专家
            expert_out = self.experts[expert_idx](x)
            output += expert_weight * expert_out
        return output

参数效率对比：

3. R-SWA 深度拆解：参考滑动窗口注意力如何把 KV Cache 压成常数

3.1 标准自注意力的 KV Cache 困境

标准 Transformer Decoder 中，每个生成步骤 t 的注意力计算都需要访问 0 到 t-1 所有位置的 KV Cache：

# 标准自注意力（简化）
def standard_attention(q, k_cache, v_cache):
    # k_cache: [t, d_k] 随 t 线性增长
    # v_cache: [t, d_v] 随 t 线性增长
    scores = q @ k_cache.T / sqrt(d_k)   # [1, t]
    attn = softmax(scores)                # [1, t]
    output = attn @ v_cache               # [1, d_v]
    return output

t = 32000（32K 上下文）时，KV Cache 占用显存约为：

32000 × (128 + 128) × 24层 × 16头 × 2字节(FP16) ≈ 6.3 GB

这还只是一个请求。并发 4 个请求，光 KV Cache 就吃掉 25GB 显存。

3.2 R-SWA 的核心设计：两类 Token 的分离处理

R-SWA（Reference Sliding Window Attention）将注意力计算中的 token 分为两类：

① 参考 Token（Reference Tokens）

• 来源：图像编码后的视觉 token、系统 prompt
• 特点：每一步都全量可见，不参与滑动窗口
• KV Cache：一次性编码，全程复用，不随生成长度增长

② 输出 Token（Output Tokens）

• 来源：模型自回归生成的历史文本
• 特点：仅保留滑动窗口内的近期 token
• KV Cache：滑动窗口大小固定，超出窗口的旧 token 的 KV Cache 被丢弃

# R-SWA 概念代码
def r_swa_attention(q, ref_kv, out_kv_cache, window_size=512):
    """
    q: 当前 query [1, d]
    ref_kv: 参考 token 的 KV，形状 [ref_len, d]（固定不变）
    out_kv_cache: 输出 token 的 KV Cache，最多保留 window_size 个
    """
    # 参考 token：全量计算
    ref_scores = q @ ref_kv[0].T / sqrt(d_k)   # [1, ref_len]
    ref_attn = softmax(ref_scores)
    ref_out = ref_attn @ ref_kv[1]              # [1, d_v]
    
    # 输出 token：仅滑动窗口内的计算
    window_kv = out_kv_cache[-window_size:]      # 取最近 512 个
    out_scores = q @ window_kv[0].T / sqrt(d_k)  # [1, window_size]
    out_attn = softmax(out_scores)
    out_out = out_attn @ window_kv[1]            # [1, d_v]
    
    # 合并两类注意力的输出
    output = ref_out + out_out
    return output

3.3 为什么 R-SWA 不会丢失长程依赖？

一个关键问题：丢弃滑动窗口外的输出 token 的 KV Cache，会不会导致模型「忘记」前面生成的内容？

答案藏在参考 Token 里。

在 OCR 场景中，模型生成的每一个字，都可以通过视觉 Token（参考 Token）来「回忆」上下文。即使 out_kv_cache 只保留最近 512 个 token，模型仍然可以通过关注图像中的对应区域来「看到」更早的上下文。

这正是对人类抄写员行为的数学模拟：

人类抄写员：
  眼睛（参考） → 盯着原文（全程可见）
  手写（输出） → 只记得最近几行的进度
  
R-SWA：
  参考 Token  → 图像编码（全程可见）
  输出 Token  → 滑动窗口（最近 512 个）

3.4 KV Cache 占用对比：从线性增长到常数

关键结论：R-SWA 将解码器的 KV Cache 从 O(L)（L = 生成长度）压到了 O(1)（常数）。

4. 视觉编码与 Token 压缩：1024×1024 图像→256 个视觉 Token

4.1 两级视觉编码架构

Unlimited OCR 的编码器采用「CNN + Transformer」混合架构：

第一级：CNN 局部特征提取

# 第一级：CNN 提取局部纹理特征
class CNNStem(nn.Module):
    def __init__(self):
        super().__init__()
        # 类似 Swin Transformer 的 patch partition
        self.patch_embed = nn.Conv2d(3, 96, kernel_size=4, stride=4)
        # 输出：256×256×96（1024×1024 输入时）
    
    def forward(self, x):
        x = self.patch_embed(x)
        return x  # [batch, 96, 256, 256]

第二级：Transformer 全局语义建模

# 第二级：Transformer 捕捉全局依赖
class VisionTransformer(nn.Module):
    def __init__(self, img_size=1024, patch_size=16, dim=768):
        super().__init__()
        num_patches = (img_size // patch_size) ** 2  # 4096
        self.pos_embed = nn.Parameter(torch.zeros(1, num_patches, dim))
        self.blocks = nn.ModuleList([TransformerBlock(dim) for _ in range(12)])
    
    def forward(self, x):
        # x: [batch, 4096, 768]
        x = x + self.pos_embed
        for block in self.blocks:
            x = block(x)
        return x  # [batch, 4096, 768]

4.2 16× 压缩层的工程实现

压缩层的核心挑战：如何在将 4096 个 patch token 压缩为 256 个的同时，最大程度保留文字信息？

百度团队采用了 可学习的跨 patch 注意力压缩：

class LearnableCompressor(nn.Module):
    """可学习的 16× Token 压缩层"""
    def __init__(self, in_dim=768, out_dim=768, ratio=16):
        super().__init__()
        self.ratio = ratio
        # 可学习的「压缩查询向量」
        self.compact_queries = nn.Parameter(
            torch.randn(1, 256, out_dim)  # 256 个压缩 token
        )
        self.attn = nn.MultiheadAttention(out_dim, num_heads=12)
    
    def forward(self, x):
        # x: [batch, 4096, 768]
        batch_size = x.shape[0]
        # 将可学习查询扩展到 batch 维度
        q = self.compact_queries.expand(batch_size, -1, -1)  # [B, 256, 768]
        # 跨 patch 注意力：256 个查询 对 4096 个键 做注意力
        compressed = self.attn(q, x, x)  # [B, 256, 768]
        return compressed

与简单平均池化的对比：

5. 代码实战：从安装部署到批量推理的完整流程

5.1 环境准备与安装

# 克隆仓库
git clone https://github.com/baidu/Unlimited-OCR.git
cd Unlimited-OCR

# 创建虚拟环境（推荐）
conda create -n unlimited-ocr python=3.10
conda activate unlimited-ocr

# 安装依赖
pip install -r requirements.txt

# 下载模型权重（约 6.8 GB）
huggingface-cli download baidu/Unlimited-OCR --local-dir ./checkpoints

5.2 单张图像推理

import torch
from PIL import Image
from model.unlimited_ocr import UnlimitedOCR

# 加载模型
model = UnlimitedOCR.from_pretrained("./checkpoints")
model.eval()

if torch.cuda.is_available():
    model = model.cuda()

# 推理
image = Image.open("document_page.png").convert("RGB")
result = model.predict(image)

print(f"识别结果：\n{result['text']}")
print(f"耗时：{result['inference_time_ms']} ms")
print(f"显存占用：{result['gpu_memory_mb']} MB")

5.3 多页文档批量推理（核心场景）

import os
from PIL import Image
from model.unlimited_ocr import UnlimitedOCR
from utils.batch_processor import BatchProcessor

# 初始化模型和批量处理器
model = UnlimitedOCR.from_pretrained("./checkpoints").cuda()
processor = BatchProcessor(model, max_length=32768)

# 批量加载多页文档
image_dir = "./documents/contract_v1/"
image_files = sorted([
    os.path.join(image_dir, f) 
    for f in os.listdir(image_dir) 
    if f.endswith(('.png', '.jpg', '.jpeg'))
])

# 单次前向传播处理全部页面（核心优势！）
images = [Image.open(f).convert("RGB") for f in image_files]
full_text = processor.process_multi_page(images)

# 输出结果
print(f"共处理 {len(images)} 页")
print(f"全文识别结果：\n{full_text}")

# 保存为文件
with open("contract_v1_transcribed.txt", "w", encoding="utf-8") as f:
    f.write(full_text)

5.4 API 服务部署（生产环境）

# api_server.py
from flask import Flask, request, jsonify
from model.unlimited_ocr import UnlimitedOCR
import torch
from PIL import Image
import io

app = Flask(__name__)

# 全局加载模型（避免每次请求重复加载）
model = UnlimitedOCR.from_pretrained("./checkpoints").cuda()
model.eval()

@app.route("/ocr", methods=["POST"])
def ocr_endpoint():
    # 接收上传的图像
    file_bytes = request.files["image"].read()
    image = Image.open(io.BytesIO(file_bytes)).convert("RGB")
    
    # 推理
    with torch.no_grad():
        result = model.predict(image)
    
    return jsonify({
        "text": result["text"],
        "inference_time_ms": result["inference_time_ms"],
        "token_count": result["token_count"]
    })

@app.route("/ocr/batch", methods=["POST"])
def ocr_batch_endpoint():
    # 批量接口：接收多张图像，单次前向推理
    files = request.files.getlist("images")
    images = [Image.open(f).read()).convert("RGB") for f in files]
    
    with torch.no_grad():
        full_text = model.predict_batch(images)
    
    return jsonify({"text": full_text})

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8000, threaded=True)

# 启动服务
python api_server.py

# 测试请求
curl -X POST http://localhost:8000/ocr \
  -F "image=@document_page.png" \
  -H "Content-Type: multipart/form-data"

6. 性能基准与对比：93.92% SOTA 背后的数据

6.1 OmniDocBench v1.6 基准测试结果

OmniDocBench 是端到端 OCR 最权威的基准测试，涵盖 5 大类、37 小类文档类型：

综合得分：Unlimited OCR 93.92% vs DeepSeek OCR 90.17%，提升 3.75 个百分点。

6.2 推理速度对比（NVIDIA A100 80GB）

测试条件：单张 1024×1024 图像，输出约 500 个 token

速度提升 35%，显存占用降低 62%。

6.3 长文档扩展能力

核心优势：文档越长，Unlimited OCR 的性价比越高。40 页文档的识别速度是对手的 3.6 倍。

7. R-SWA 的通用性：不止 OCR，ASR、翻译同样受益

7.1 R-SWA 作为一种通用注意力机制

R-SWA 的设计是任务无关的。只要满足以下条件，任何编码器-解码器架构都能受益：

1. 解码器需要关注「固定的参考输入」（图像、音频、源语言文本）
2. 生成序列可能很长，KV Cache 成为瓶颈

7.2 应用于自动语音识别（ASR）

# R-SWA 用于 ASR 的概念代码
class ASRDecoderWithRSWA(nn.Module):
    def __init__(self, audio_encoder, r_swa_decoder):
        super().__init__()
        self.audio_encoder = audio_encoder      # 编码音频为参考 Token
        self.decoder = r_swa_decoder           # R-SWA 解码器
    
    def forward(self, audio_waveform):
        # 音频编码：参考 Token（固定长度，不随生成增长）
        ref_tokens = self.audio_encoder(audio_waveform)  # [T_audio, D]
        
        # R-SWA 解码：参考 Token 全量可见，输出 Token 滑动窗口
        transcript = self.decoder.generate(
            ref_tokens=ref_tokens,
            max_length=32000
        )
        return transcript

实验数据（内部测试）：

• 传统 Attention ASR（LibriSpeech test-clean）：WER 3.2%
• R-SWA ASR：WER 3.1%（精度持平，显存降低 70%）

7.3 应用于机器翻译

长文档翻译是传统 Transformer 的另一个痛点：翻译一篇 10,000 词的论文，KV Cache 占用极高。

R-SWA 的应用方式：

源语言文本 → Encoder → 参考 Token（固定）
                     ↓
               R-SWA Decoder → 目标语言文本（输出 Token 滑动窗口）

8. 生产环境部署指南：显存、并发、量化的实战建议

8.1 显存需求估算

推荐硬件配置：

• 开发测试：NVIDIA RTX 4090（24GB）→ 支持 batch=2
• 生产部署：NVIDIA A100（40GB/80GB）→ 支持 batch=8~16
• 低成本方案：NVIDIA L4（24GB，云实例约 $0.5/小时）

8.2 量化部署（INT8）

# 使用 GPTQ 或 AWQ 量化模型（显存再降 50%）
from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer

# 量化
model = AutoAWQForCausalLM.from_pretrained("./checkpoints")
model.quantize(
    tokenizer=None,
    quant_config={"zero_point": True, "q_group_size": 128, "w_bit": 8}
)
model.save_quantized("./checkpoints_int8")

# 量化后加载（显存占用 ~3.2 GB）
model_int8 = AutoAWQForCausalLM.from_quantized("./checkpoints_int8").cuda()

量化后精度损失：< 0.5%（OmniDocBench 得分从 93.92% 降至 93.48%）。

8.3 高并发部署架构

┌─────────────────────────────────────────────────┐
│            Nginx / Load Balancer               │
└──────────────┬──────────────────────────────────┘
               │
    ┌──────────┼──────────┐
    ▼          ▼          ▼
┌───────┐  ┌───────┐  ┌───────┐
│Worker1│  │Worker2│  │Worker3│  ← 每个 Worker 加载一个模型实例
│:8001  │  │:8002  │  │:8003  │
└───────┘  └───────┘  └───────┘
   A100        A100        A100

# 使用 gunicorn 启动多 Worker
gunicorn -w 3 -b 0.0.0.0:8000 \
  --timeout 300 \
  --access-logfile access.log \
  api_server:app

9. 总结与展望：OCR 的长文档时代才刚刚开始

9.1 核心贡献总结

百度 Unlimited OCR 的三个核心技术突破：

1. R-SWA 注意力机制：将解码器 KV Cache 从 O(L) 压到 O(1)，长文档推理速度提升 35~360%
2. 16× 视觉 Token 压缩：1024×1024 图像仅需 256 个视觉 token，预填充阶段计算量降低 16 倍
3. MoE Decoder：3B 总参数，推理时仅激活 570M，显存占用降低 62%

9.2 与竞品对比总表

9.3 未来展望

1. R-SWA 迁移到 LLM：让 GPT/Claude 等长上下文 LLM 的推理成本降低一个数量级
2. 多模态 R-SWA：图像+音频混合输入的统一 R-SWA 机制
3. 端侧部署：MoE 架构 + INT4 量化，让 Unlimited OCR 在手机端实时运行

参考资源

• 论文：Unlimited OCR Works（arXiv:2606.23050，2026年6月22日）
• GitHub：baidu/Unlimited-OCR（5天 10K+ Stars）
• HuggingFace：baidu/Unlimited-OCR
• 基准测试：OmniDocBench v1.6

作者：程序员茄子 | 发布时间：2026年7月1日 | 转载请注明出处

技术交流请访问 程序员茄子