百度 Unlimited OCR 深度解析：R-SWA 如何把 KV Cache 从线性增长压成常数，端到端 OCR 的长文档革命

引言：OCR 3.0 时代的"失忆"困境

2026年6月，百度开源的端到端 OCR 模型 Unlimited OCR 在 GitHub 上演了一场现象级爆发——发布次日登顶 GitHub Daily Trending 榜和 Python 榜，仅 5 天 Star 破万，同时在 HuggingFace 全球模型总趋势榜和多模态模型趋势榜均排名第一，实现 GitHub、HuggingFace 四榜第一。

这个数据在 OCR 领域堪称"核爆级"。为什么？

因为 Unlimited OCR 解决了一个困扰长文档 OCR 多年的核心痛点：传统 OCR 模型处理长文档时"越生成越慢、越生成越忘"的问题。它通过一种名为 Reference Sliding Window Attention（R-SWA，参考滑动窗口注意力） 的创新机制，把解码器的 KV Cache 从线性增长压成了常数级别，在 OmniDocBench v1.6 基准测试中以 93.92% 的综合得分刷新了端到端 OCR 的 SOTA 记录。

本文将从技术原理、架构设计、源码实现、性能对比、部署实践等多个维度，深度解析 Unlimited OCR 如何用"操作系统思维"颠覆了传统 OCR 的长文档处理范式。

一、传统 OCR 的长文档困境：为什么机器会"失忆"？

1.1 端到端 OCR 的基本原理

要理解 Unlimited OCR 的创新，首先要理解传统端到端 OCR 模型的工作机制。

传统 OCR 采用的是"先检测后识别"的两阶段流程：

1. 文本检测：在图像中定位文本区域（检测框）
2. 文字识别：对每个检测框内的文字进行识别

这种方式存在明显缺陷：信息丢失严重、计算冗余大、版面结构难以保持。

端到端 OCR 则采用统一的神经网络架构，直接从输入图像映射到文本序列输出，摒弃了繁琐的两阶段流程。主流架构通常采用 Vision Encoder + Text Decoder 的设计：

输入图像 → Vision Encoder（视觉编码器）→ 视觉 Token 序列 → Text Decoder（文本解码器）→ 输出文本

解码器在生成文本时，需要通过注意力机制"回头看"之前生成的内容，这就需要存储 KV Cache（Key-Value Cache）。

1.2 KV Cache 的线性增长陷阱

问题就出在这里。

假设我们要处理一份 40 页的长文档 PDF。传统端到端 OCR 模型在解码时，每生成一个新的 token，都需要：

1. 计算当前 token 与所有已生成 token 的注意力
2. 存储当前 token 的 Key 和 Value 到 KV Cache

这意味着：

• 生成第 1 个 token：KV Cache 存储 1 个 token 的 K/V
• 生成第 100 个 token：KV Cache 存储 100 个 token 的 K/V
• 生成第 10000 个 token：KV Cache 存储 10000 个 token 的 K/V

KV Cache 的大小与生成长度呈线性增长关系。

对于一份 40 页的长文档，可能需要生成数万个 token。这不仅意味着：

• 显存爆炸：KV Cache 占用的显存随生成长度线性增长
• 速度衰减：注意力计算复杂度 O(n²)，越长越慢
• 信息淹没：早期生成的关键信息被大量冗余信息淹没

这就像一个人在抄书时，每写一个字都要把之前写过的所有字都"背"在脑子里。写到第 100 页时，脑子里塞满了前 99 页的内容，效率必然崩塌。

人类抄书是怎么做的？只记住当前正在抄的那一行，以及偶尔回头看一眼刚写的几个字。不会把整本书都背下来。

Unlimited OCR 的 R-SWA 机制，正是模仿了人类的这种"工作记忆"模式。

二、R-SWA 机制：把 KV Cache 压成常数的核心原理

2.1 R-SWA 的核心思想

Reference Sliding Window Attention（R-SWA） 的核心思想非常简单，却极其有效：

在解码生成时，始终能看到完整的图像信息（Reference），但只"回顾"最近生成的 N 个 token（Sliding Window）。

这包含两个关键组件：

（1）Reference Attention：保持对完整图像的访问

传统端到端 OCR 中，图像经过视觉编码器后变成一系列视觉 Token。解码器在生成文本时，始终可以通过 Cross-Attention 访问这些视觉 Token。

这部分是不受限的。无论生成多长的文本，模型始终能"看到"完整的原始图像。

这就像人类抄书时，眼睛始终能看着原始文本——不需要把原文背下来，只需要"看到"即可。

（2）Sliding Window Attention：限制对已生成文本的回顾

R-SWA 的创新在于：对已生成的文本 token，只保留最近 N 个 token 的 KV Cache。

Unlimited OCR 默认设置 N=128。即：

• 生成第 129 个 token 时，丢弃第 1 个 token 的 K/V
• 生成第 130 个 token 时，丢弃第 2 个 token 的 K/V
• ...

KV Cache 的大小恒定为 128 个 token 的 K/V，与生成长度无关。

这就像人类抄书时，只"回头看"刚写的最近几个字，不会把整本书都背下来。

2.2 为什么这样做有效？

你可能会问：丢弃了早期生成的信息，不会影响生成质量吗？

答案是：对于 OCR 任务，大部分情况下不需要回顾很远的已生成文本。

OCR 的本质是把图像中的文字"转录"出来。这个过程具有局部性：

• 当前要识别的字，通常只与图像中的对应区域相关
• 与远处已识别的文字，关联性较弱

当然，某些场景下确实需要长距离依赖，比如：

• 表格结构：识别单元格内容时需要知道表头
• 公式编号：识别公式时需要知道章节编号
• 跨页引用：识别"如图3所示"时需要找到图3

但 R-SWA 的设计是：

• Reference Attention 始终完整：模型始终能看到原始图像，可以随时"回到"图像的任意位置
• Sliding Window 只限制文本生成历史：不限制对图像的访问

这就像人类抄书时：

• 眼睛始终能看到原始文本（Reference Attention）
• 只需要记住刚写的几个字（Sliding Window）
• 需要查看远处的表格时，直接看原图（Reference）而不是翻已抄的内容

2.3 数学原理：从 O(n) 到 O(1)

让我们从数学角度量化 R-SWA 带来的改进。

假设：

• 生成长度：L 个 token
• 每个 token 的 KV Cache 大小：d 维
• 滑动窗口大小：W（Unlimited OCR 默认 W=128）

传统 Attention 的 KV Cache 开销

KV Cache 总大小 = L × d × 2（Key 和 Value）

生成长度 L 越长，KV Cache 越大，线性增长。

R-SWA 的 KV Cache 开销

KV Cache 总大小 = W × d × 2

与生成长度 L 无关，是常数。

对于一份 40 页的长文档，假设生成 50000 个 token：

• 传统方法：需要存储 50000 × d × 2 的 KV Cache
• R-SWA：只需要存储 128 × d × 2 的 KV Cache

差距近 400 倍。

更重要的是注意力计算的复杂度：

• 传统 Self-Attention：O(L²)
• R-SWA Self-Attention：O(L × W) = O(L × 128) = O(L)

从平方复杂度降到线性复杂度，这对长文档处理至关重要。

三、Unlimited OCR 的完整架构：不只是 R-SWA

R-SWA 是 Unlimited OCR 的核心创新，但不是全部。让我们看看完整的架构设计。

3.1 整体架构：Vision Encoder + Text Decoder

┌─────────────────────────────────────────────────────────────┐
│                    Unlimited OCR 架构                        │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  ┌──────────────┐      ┌──────────────┐                     │
│  │  输入图像    │ ──→  │ DeepEncoder  │  16× 视觉压缩       │
│  │  (任意尺寸)  │      │  (ViT架构)   │                     │
│  └──────────────┘      └──────┬───────┘                     │
│                               │                              │
│                               ↓                              │
│                    ┌──────────────────┐                     │
│                    │   视觉 Token 序列  │                    │
│                    │  (高度压缩后)      │                    │
│                    └────────┬─────────┘                     │
│                             │                                │
│                             ↓                                │
│                    ┌──────────────────┐                     │
│                    │  Text Decoder    │                     │
│                    │  (LLM架构)       │                     │
│                    │                  │                     │
│                    │  ┌────────────┐  │                     │
│                    │  │ R-SWA 机制  │  │  ← 核心创新        │
│                    │  └────────────┘  │                     │
│                    │                  │                     │
│                    │  ┌────────────┐  │                     │
│                    │  │ Reference  │  │  ← 完整图像访问     │
│                    │  │ Attention  │  │                     │
│                    │  └────────────┘  │                     │
│                    └────────┬─────────┘                     │
│                             │                                │
│                             ↓                                │
│                    ┌──────────────────┐                     │
│                    │   输出文本序列    │                    │
│                    │  (Markdown格式)  │                     │
│                    └──────────────────┘                     │
│                                                              │
└─────────────────────────────────────────────────────────────┘

3.2 DeepEncoder：16× 视觉压缩

处理长文档图像的另一个挑战是图像 Token 爆炸。

一份 40 页的 PDF，每一页都是一张高清图像。如果直接把所有像素都编码成 Token，数量会非常庞大。

Unlimited OCR 采用了 DeepEncoder 架构，实现了 16× 的视觉压缩：

• 输入：原始图像（任意分辨率）
• 输出：高度压缩的视觉 Token 序列

这意味着：

• 原本需要 16000 个视觉 Token 的图像，压缩后只需要 1000 个
• 大幅降低了解码器的计算负担
• 同时保留了足够的视觉信息用于文本识别

3.3 模型规模：3B 参数，500M 激活

Unlimited OCR 的模型规模设计非常精妙：

• 总参数量：3B（30亿参数）
• 实际激活参数：约 500M（5亿参数）

这体现了"小参数，大能耐"的设计理念：

• 3B 的模型规模在 LLM 领域不算大，但在 OCR 领域已经属于"重型武器"
• 通过 MoE（Mixture of Experts）或其他稀疏激活技术，实际推理时只激活部分参数
• 既保证了性能，又控制了推理成本

对于本地部署来说，这个规模非常友好：

• 单张 RTX 3090（24GB 显存）即可运行
• 推理速度在实际测试中表现出色

四、性能表现：OmniDocBench v1.6 刷新 SOTA

4.1 OmniDocBench 基准测试介绍

OmniDocBench 是一个全面的文档解析与评估基准，支持对 OCR 模型进行多维度性能测评。其核心特点：

• 多维度评估：涵盖文本检测、识别、表格提取、公式识别等
• 标准化指标：TEDS、BLEU、METEOR、CDM 等
• 真实场景数据：包含复杂的实际文档样本

OmniDocBench v1.6 是 2026 年发布的最新版本，对评估标准进行了全面升级。

4.2 Unlimited OCR 的测试成绩

Unlimited OCR 在 OmniDocBench v1.6 上取得了 93.92% 的综合得分，刷新了端到端 OCR 的 SOTA（State-of-the-Art）记录。

这个成绩意味着什么？

从公开的对比数据来看：

• 相比传统 OCR 方案（Tesseract、PaddleOCR 等），提升幅度显著
• 在长文档处理场景下，优势尤为明显
• 表格结构还原、公式识别等复杂任务表现出色

4.3 长文档处理的"不失忆、不降速"

Unlimited OCR 最核心的优势体现在长文档处理上：

（1）显存占用恒定

传统 OCR 处理长文档时，显存占用随页数线性增长：

• 10 页文档：显存占用 ~8GB
• 20 页文档：显存占用 ~16GB
• 40 页文档：显存占用 ~32GB

Unlimited OCR 处理 40 页文档的显存占用与处理 1 页文档几乎相同。

（2）推理速度稳定

传统 OCR 在长文档处理时会出现明显的速度衰减：

• 前 10 页：平均每页 2 秒
• 第 11-20 页：平均每页 3 秒
• 第 21-40 页：平均每页 5 秒

Unlimited OCR 在整个处理过程中速度保持稳定，不会出现衰减。

（3）质量不下降

传统 OCR 在长文档处理时，可能出现：

• 后半部分识别准确率下降
• 表格结构错乱
• 跨页内容关联错误

Unlimited OCR 通过 Reference Attention 机制，确保模型始终能访问完整的图像信息，避免了"遗忘"问题。

五、代码实战：本地部署 Unlimited OCR

5.1 环境准备

Unlimited OCR 已在 GitHub 开源，项目地址：

https://github.com/baidu/Unlimited-OCR

基础环境要求：

• Python 3.8+
• CUDA 11.0+
• GPU 显存 ≥16GB（推荐 RTX 3090 或更高）

安装依赖：

# 克隆仓库
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

# 安装 PyTorch（根据你的 CUDA 版本选择）
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

5.2 下载模型权重

模型权重已发布在 HuggingFace：

# 使用 huggingface-cli 下载
pip install huggingface_hub
huggingface-cli download baidu/Unlimited-OCR --local-dir ./weights

或者手动下载：

https://huggingface.co/baidu/Unlimited-OCR

5.3 基础推理代码

import torch
from PIL import Image
from unlimited_ocr import UnlimitedOCR

# 初始化模型
model = UnlimitedOCR.from_pretrained("./weights")
model.eval()
if torch.cuda.is_available():
    model = model.cuda()

# 加载图像
image = Image.open("document.pdf")  # 支持 PDF、PNG、JPG 等

# 执行 OCR
with torch.no_grad():
    result = model(image)

# 输出结果（Markdown 格式）
print(result.text)

# 获取详细的结构化信息
print(result.structured_data)

5.4 处理长文档 PDF

from unlimited_ocr import UnlimitedOCR
from unlimited_ocr.utils import PDFProcessor

# 初始化
model = UnlimitedOCR.from_pretrained("./weights")
model.eval().cuda()

# 加载 40 页 PDF
pdf_processor = PDFProcessor("long_document.pdf")

# 一次性处理整个 PDF（Unlimited OCR 的核心优势）
result = model(pdf_processor.get_all_pages())

print(f"总页数: {result.page_count}")
print(f"总字数: {result.char_count}")
print(f"处理时间: {result.processing_time:.2f}s")

# 输出 Markdown 格式
with open("output.md", "w", encoding="utf-8") as f:
    f.write(result.markdown)

5.5 关键参数调优

# 调整滑动窗口大小（默认 128）
model = UnlimitedOCR.from_pretrained(
    "./weights",
    sliding_window_size=256  # 增加窗口大小可提升质量，但显存占用增加
)

# 调整视觉压缩率
model = UnlimitedOCR.from_pretrained(
    "./weights",
    vision_compression_ratio=8  # 默认 16，降低可保留更多视觉细节
)

# 启用 GPU 加速
model = UnlimitedOCR.from_pretrained(
    "./weights",
    device="cuda",
    precision="fp16"  # 使用半精度推理，减少显存占用
)

六、技术对比：Unlimited OCR vs 传统方案

6.1 与传统 OCR 方案的对比

6.2 与其他端到端 OCR 模型的对比

6.3 实际测试对比

以下是基于真实文档的测试对比（RTX 3090，24GB 显存）：

测试文档：40 页财报 PDF（含表格、图表、公式）

七、源码剖析：R-SWA 的实现细节

7.1 R-SWA 的核心代码

Unlimited OCR 的 R-SWA 实现位于 model/attention.py：

import torch
import torch.nn as nn
from typing import Optional, Tuple

class ReferenceSlidingWindowAttention(nn.Module):
    """
    Reference Sliding Window Attention (R-SWA)
    
    核心思想：
    1. Reference Attention: 对完整图像的注意力（不受限）
    2. Sliding Window Attention: 对已生成文本的注意力（限制窗口大小）
    """
    
    def __init__(
        self,
        embed_dim: int,
        num_heads: int,
        sliding_window_size: int = 128,
        dropout: float = 0.0,
    ):
        super().__init__()
        self.embed_dim = embed_dim
        self.num_heads = num_heads
        self.sliding_window_size = sliding_window_size
        
        # Q, K, V 投影
        self.q_proj = nn.Linear(embed_dim, embed_dim)
        self.k_proj = nn.Linear(embed_dim, embed_dim)
        self.v_proj = nn.Linear(embed_dim, embed_dim)
        self.out_proj = nn.Linear(embed_dim, embed_dim)
        
        # Reference Attention 的 K, V 投影（用于图像）
        self.ref_k_proj = nn.Linear(embed_dim, embed_dim)
        self.ref_v_proj = nn.Linear(embed_dim, embed_dim)
        
        self.dropout = nn.Dropout(dropout)
        
    def forward(
        self,
        query: torch.Tensor,
        key_value: torch.Tensor,
        reference: torch.Tensor,  # 图像的视觉 Token
        kv_cache: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
        use_cache: bool = True,
    ) -> Tuple[torch.Tensor, Optional[Tuple[torch.Tensor, torch.Tensor]]]:
        """
        Args:
            query: [batch, seq_len, embed_dim] - 当前查询
            key_value: [batch, seq_len, embed_dim] - 已生成的文本
            reference: [batch, ref_len, embed_dim] - 图像视觉 Token
            kv_cache: 可选的 KV Cache
            use_cache: 是否使用 KV Cache
        """
        batch_size, seq_len, _ = query.shape
        
        # 1. 计算 Query
        q = self.q_proj(query)
        q = q.view(batch_size, seq_len, self.num_heads, -1).transpose(1, 2)
        
        # 2. 计算 Key, Value（文本部分）
        k = self.k_proj(key_value)
        v = self.v_proj(key_value)
        k = k.view(batch_size, -1, self.num_heads, -1).transpose(1, 2)
        v = v.view(batch_size, -1, self.num_heads, -1).transpose(1, 2)
        
        # 3. 更新 KV Cache（滑动窗口）
        if kv_cache is not None:
            k_cache, v_cache = kv_cache
            # 拼接新的 K, V
            k = torch.cat([k_cache, k], dim=2)
            v = torch.cat([v_cache, v], dim=2)
            # 滑动窗口：只保留最近的 sliding_window_size 个 token
            if k.size(2) > self.sliding_window_size:
                k = k[:, :, -self.sliding_window_size:, :]
                v = v[:, :, -self.sliding_window_size:, :]
        
        # 4. 计算 Reference Attention（对完整图像）
        ref_k = self.ref_k_proj(reference)
        ref_v = self.ref_v_proj(reference)
        ref_k = ref_k.view(batch_size, -1, self.num_heads, -1).transpose(1, 2)
        ref_v = ref_v.view(batch_size, -1, self.num_heads, -1).transpose(1, 2)
        
        # 5. 合并文本和图像的 Key, Value
        combined_k = torch.cat([ref_k, k], dim=2)  # [batch, heads, ref_len+text_len, head_dim]
        combined_v = torch.cat([ref_v, v], dim=2)
        
        # 6. 计算注意力
        attn_weights = torch.matmul(q, combined_k.transpose(-2, -1))
        attn_weights = attn_weights / (self.embed_dim ** 0.5)
        attn_weights = torch.softmax(attn_weights, dim=-1)
        attn_weights = self.dropout(attn_weights)
        
        # 7. 加权求和
        attn_output = torch.matmul(attn_weights, combined_v)
        attn_output = attn_output.transpose(1, 2).contiguous()
        attn_output = attn_output.view(batch_size, seq_len, self.embed_dim)
        
        # 8. 输出投影
        output = self.out_proj(attn_output)
        
        # 9. 返回更新后的 KV Cache
        new_kv_cache = (k, v) if use_cache else None
        
        return output, new_kv_cache

7.2 关键设计点解析

（1）分离的 Reference 和 Text KV Cache

代码中最关键的设计是：

• ref_k 和 ref_v：图像的 Key 和 Value，始终完整保留
• k 和 v：文本的 Key 和 Value，应用滑动窗口

# 图像的 KV Cache 不受限制
ref_k = self.ref_k_proj(reference)  # 始终是完整的图像 Token

# 文本的 KV Cache 应用滑动窗口
if k.size(2) > self.sliding_window_size:
    k = k[:, :, -self.sliding_window_size:, :]  # 只保留最近的 N 个

（2）注意力计算的合并

Reference Attention 和 Sliding Window Attention 不是分开计算的，而是合并到同一个注意力矩阵中：

combined_k = torch.cat([ref_k, k], dim=2)  # 图像 + 文本
combined_v = torch.cat([ref_v, v], dim=2)

# 一次矩阵乘法完成两种注意力
attn_weights = torch.matmul(q, combined_k.transpose(-2, -1))

这种设计的优势是：

• 计算效率高：一次计算完成两种注意力
• 信息融合：文本和图像信息在注意力层面自然融合
• 梯度流动：两部分信息共享梯度，训练更稳定

八、实际应用场景与最佳实践

8.1 适用场景

Unlimited OCR 特别适合以下场景：

（1）长文档批量处理

• 财报、合同、论文等数十页的 PDF
• 一次性处理，无需逐页分割

（2）复杂版面还原

• 多栏排版、混合图文
• 表格、公式、代码块混合

（3）结构化数据提取

• 从文档中提取表格、列表、键值对
• 直接输出 Markdown 或 JSON

（4）本地化部署

• 数据安全要求高的场景
• 无法使用云端 API 的环境

8.2 性能优化建议

（1）GPU 配置

推荐配置：

• 最低：RTX 3090（24GB 显存）
• 推荐：RTX 4090（24GB 显存，推理更快）
• 生产环境：A100（40GB/80GB，支持更大批量）

（2）推理精度

# FP16 半精度推理（推荐，显存占用减半）
model = UnlimitedOCR.from_pretrained("./weights", precision="fp16")

# FP32 全精度（精度最高，显存占用翻倍）
model = UnlimitedOCR.from_pretrained("./weights", precision="fp32")

# INT8 量化（显存占用最低，精度略降）
model = UnlimitedOCR.from_pretrained("./weights", precision="int8")

（3）批量处理

# 批量处理多个文档
documents = ["doc1.pdf", "doc2.pdf", "doc3.pdf"]
results = model.batch_process(documents, batch_size=4)

for doc, result in zip(documents, results):
    print(f"{doc}: {result.char_count} chars")

8.3 常见问题与解决方案

问题 1：显存不足

# 解决方案 1：降低视觉压缩率
model = UnlimitedOCR.from_pretrained(
    "./weights",
    vision_compression_ratio=32  # 默认 16，增大可节省显存
)

# 解决方案 2：减少滑动窗口大小
model = UnlimitedOCR.from_pretrained(
    "./weights",
    sliding_window_size=64  # 默认 128，减小可节省显存
)

# 解决方案 3：分段处理
from unlimited_ocr.utils import split_pdf
pages = split_pdf("huge_document.pdf", pages_per_chunk=20)
for chunk in pages:
    result = model(chunk)

问题 2：表格还原不完整

# 启用表格增强模式
result = model(
    image,
    table_enhancement=True,  # 表格增强
    table_structure_aware=True  # 结构感知
)

问题 3：公式识别错误

# 启用 LaTeX 公式识别
result = model(
    image,
    latex_mode=True,  # LaTeX 模式
    formula_enhancement=True
)

九、生态与未来展望

9.1 开源生态

Unlimited OCR 的开源具有重要的行业意义：

（1）降低 OCR 技术门槛

• 3B 参数模型可在消费级 GPU 上运行
• 无需云端 API 调用，数据隐私有保障

（2）推动端到端 OCR 发展

• R-SWA 机制可复用到其他长序列生成任务
• 为学术界提供了新的研究方向

（3）促进产业应用

• 文档数字化、知识管理等场景直接受益
• 与 RAG（检索增强生成）结合潜力巨大

9.2 与 RAG 的结合

Unlimited OCR + RAG 的典型流程：

PDF 文档 → Unlimited OCR → Markdown → 文本切分 → 向量化 → 向量数据库 → LLM 检索回答

这种组合的优势：

• 质量高：OCR 输出准确，减少 RAG 的噪音
• 结构保留：Markdown 格式保留了文档结构，便于精准切分
• 长文档友好：一次性处理整个文档，避免跨页语义割裂

9.3 未来发展方向

从技术趋势看，Unlimited OCR 代表的方向可能包括：

（1）多模态统一

• OCR → 文档理解 → 多模态推理的统一模型
• 不只是"读"文档，还能"理解"文档

（2）更强的小模型

• 3B 参数已达到 SOTA，未来可能出现 1B 甚至更小的高性能模型
• 在移动端、边缘设备上运行

（3）领域微调

• 基于 Unlimited OCR 进行领域微调（法律、医疗、财务等）
• 构建垂直场景的专用 OCR 模型

十、总结：端到端 OCR 的长文档时代

百度 Unlimited OCR 的开源，标志着端到端 OCR 正式进入"长文档时代"。

核心创新 R-SWA（Reference Sliding Window Attention） 通过简单而优雅的设计，解决了长文档 OCR 的"失忆"问题：

• 把 KV Cache 从线性增长压成常数
• 保持推理速度稳定，无速度衰减
• 显存占用恒定，支持处理任意长度文档

结合 DeepEncoder 的 16× 视觉压缩 和 3B 参数的高效架构，Unlimited OCR 在 OmniDocBench v1.6 上取得了 93.92% 的 SOTA 成绩，同时在 GitHub 和 HuggingFace 上引发现象级关注。

对于开发者而言，Unlimited OCR 提供了一个生产可用的长文档 OCR 解决方案：

• 开源免费，无 API 调用成本
• 本地部署，数据安全可控
• 性能优异，超越多数商业方案

对于行业而言，Unlimited OCR 的开源推动了 OCR 技术的普及和创新：

• 降低了技术门槛，让更多开发者能够使用先进 OCR 技术
• 提供了新的技术思路（R-SWA），可复用到其他长序列任务
• 促进了文档智能、知识管理等下游应用的发展

如果你正在寻找一个能够处理长文档、性能优异、可本地部署的 OCR 方案，Unlimited OCR 无疑是 2026 年最值得关注的选择。

参考资料

1. Unlimited OCR GitHub: https://github.com/baidu/Unlimited-OCR
2. Unlimited OCR HuggingFace: https://huggingface.co/baidu/Unlimited-OCR
3. OmniDocBench: https://github.com/omnidocbench/OmniDocBench
4. 百度官方技术博客：Unlimited OCR 技术解析
5. 知乎专栏：长文档 OCR 的新突破