feat: 删除统一模型框架到 PyTorch 的文档

zhch/模型统一框架.md

@@ -1,1339 +0,0 @@
-正在收集工作区信息正在筛选到最相关的信息根据您的需求，我给出一个**统一模型框架到 PyTorch** 的完整方案。
-
----
-
-## 🎯 统一框架方案：All-in-PyTorch
-
-### 1. 为什么选择 PyTorch？
-
-| 评估维度               | PyTorch                       | ONNX Runtime    | PaddlePaddle  |
-| ---------------------- | ----------------------------- | --------------- | ------------- |
-| **生态成熟度**   | ⭐⭐⭐⭐⭐                    | ⭐⭐⭐⭐        | ⭐⭐⭐        |
-| **VLM支持**      | ⭐⭐⭐⭐⭐ (Transformers原生) | ⭐⭐⭐ (需转换) | ⭐⭐ (生态小) |
-| **动态图灵活性** | ⭐⭐⭐⭐⭐                    | ⭐ (静态图)     | ⭐⭐⭐⭐      |
-| **部署便利性**   | ⭐⭐⭐⭐                      | ⭐⭐⭐⭐⭐      | ⭐⭐⭐        |
-| **GPU加速**      | ⭐⭐⭐⭐⭐ (CUDA完整)         | ⭐⭐⭐⭐        | ⭐⭐⭐⭐      |
-| **模型Zoo**      | ⭐⭐⭐⭐⭐ (HuggingFace)      | ⭐⭐⭐          | ⭐⭐⭐        |
-
-**决策理由**:
-
-1. ✅ **VLM原生支持**: MinerU-VLM、PaddleOCR-VL等都基于Transformers (PyTorch)
-2. ✅ **统一开发体验**: 无需在多个框架间切换
-3. ✅ **便于调试**: 动态图天然支持断点调试
-4. ✅ **社区资源丰富**: 99%的最新研究都是PyTorch实现
-5. ✅ **部署选项多样**: TorchScript、ONNX、TensorRT等多种导出方式
-
----
-
-## 📊 现状分析与转换路径
-
-```mermaid
-graph TB
-    subgraph "现状 (Mixed Frameworks)"
-        P1[PaddlePaddle Models<br/>OCR Det/Rec<br/>.pdparams]
-        P2[ONNX Models<br/>TableCls/OriCls<br/>.onnx]
-        P3[PyTorch Models<br/>Layout YOLO<br/>.pt]
-        P4[VLM Models<br/>MinerU-VLM<br/>.safetensors]
-    end
-  
-    subgraph "目标 (All-in-PyTorch)"
-        T1[Unified PyTorch Models<br/>.pt / .pth]
-    end
-  
-    P1 -->|Paddle->ONNX->PyTorch| T1
-    P2 -->|ONNX->PyTorch| T1
-    P3 -->|Already PyTorch| T1
-    P4 -->|Already PyTorch| T1
-  
-    style P1 fill:#ffe0b2
-    style P2 fill:#f3e5f5
-    style P3 fill:#c8e6c9
-    style P4 fill:#c8e6c9
-    style T1 fill:#bbdefb,stroke:#1976d2,stroke-width:3px
-```
-
----
-
-## 🔧 完整转换方案
-
-### 步骤1: PaddlePaddle模型转PyTorch
-
-#### 方法A: Paddle → ONNX → PyTorch (推荐)
-
-```python
-"""
-paddle_to_pytorch_converter.py
-完整的Paddle模型到PyTorch转换器
-"""
-import os
-import paddle
-import torch
-import torch.nn as nn
-from pathlib import Path
-import onnx
-import onnx.numpy_helper as numpy_helper
-from collections import OrderedDict
-
-
-class PaddleToPyTorchConverter:
-    """PaddlePaddle到PyTorch的统一转换器"""
-  
-    def __init__(self, paddle_model_dir: str, output_dir: str = "./pytorch_models"):
-        self.paddle_model_dir = Path(paddle_model_dir)
-        self.output_dir = Path(output_dir)
-        self.output_dir.mkdir(parents=True, exist_ok=True)
-      
-    def convert_via_onnx(self, model_name: str) -> str:
-        """
-        通过ONNX中间格式转换
-      
-        流程: PaddlePaddle → ONNX → PyTorch
-        """
-        print(f"🔄 开始转换: {model_name}")
-      
-        # Step 1: Paddle → ONNX
-        onnx_path = self._paddle_to_onnx(model_name)
-      
-        # Step 2: ONNX → PyTorch
-        pytorch_path = self._onnx_to_pytorch(onnx_path, model_name)
-      
-        return pytorch_path
-  
-    def _paddle_to_onnx(self, model_name: str) -> Path:
-        """Paddle模型转ONNX"""
-        import subprocess
-      
-        paddle_model_path = self.paddle_model_dir / f"{model_name}.pdmodel"
-        paddle_params_path = self.paddle_model_dir / f"{model_name}.pdiparams"
-        onnx_output_path = self.output_dir / f"{model_name}.onnx"
-      
-        # 使用paddle2onnx命令行工具
-        cmd = [
-            "paddle2onnx",
-            "--model_dir", str(self.paddle_model_dir),
-            "--model_filename", paddle_model_path.name,
-            "--params_filename", paddle_params_path.name,
-            "--save_file", str(onnx_output_path),
-            "--opset_version", "11",
-            "--enable_onnx_checker", "True"
-        ]
-      
-        print(f"   ⏳ Paddle → ONNX: {onnx_output_path.name}")
-        result = subprocess.run(cmd, capture_output=True, text=True)
-      
-        if result.returncode != 0:
-            raise RuntimeError(f"Paddle2ONNX转换失败:\n{result.stderr}")
-      
-        print(f"   ✅ ONNX模型已保存: {onnx_output_path}")
-        return onnx_output_path
-  
-    def _onnx_to_pytorch(self, onnx_path: Path, model_name: str) -> Path:
-        """ONNX模型转PyTorch"""
-        from onnx2pytorch import ConvertModel
-      
-        # 加载ONNX模型
-        onnx_model = onnx.load(str(onnx_path))
-      
-        # 转换为PyTorch
-        pytorch_model = ConvertModel(onnx_model)
-      
-        # 保存为.pth
-        pytorch_output_path = self.output_dir / f"{model_name}.pth"
-        torch.save({
-            'model_state_dict': pytorch_model.state_dict(),
-            'model': pytorch_model,
-            'source': 'converted_from_paddle_via_onnx'
-        }, pytorch_output_path)
-      
-        print(f"   ✅ PyTorch模型已保存: {pytorch_output_path}")
-        return pytorch_output_path
-
-
-# 批量转换脚本
-def batch_convert_paddle_models():
-    """批量转换所有PaddleOCR模型"""
-  
-    # 定义需要转换的模型列表
-    PADDLE_MODELS = [
-        # OCR检测模型
-        ("ch_PP-OCRv4_det_infer", "OCR/Det"),
-        ("en_PP-OCRv4_det_infer", "OCR/Det"),
-      
-        # OCR识别模型
-        ("ch_PP-OCRv4_rec_infer", "OCR/Rec"),
-        ("en_PP-OCRv4_rec_infer", "OCR/Rec"),
-      
-        # 方向分类
-        ("ch_ppocr_mobile_v2.0_cls_infer", "OCR/Cls"),
-      
-        # 表格分类
-        ("PP-LCNet_x1_0_table_cls", "Table/Cls"),
-    ]
-  
-    base_paddle_dir = Path("~/.paddlex/official_models").expanduser()
-    output_base = Path("./unified_pytorch_models")
-  
-    for model_name, category in PADDLE_MODELS:
-        paddle_model_dir = base_paddle_dir / model_name
-      
-        if not paddle_model_dir.exists():
-            print(f"⚠️  跳过 {model_name}: 模型目录不存在")
-            continue
-      
-        output_dir = output_base / category
-        converter = PaddleToPyTorchConverter(paddle_model_dir, output_dir)
-      
-        try:
-            pytorch_path = converter.convert_via_onnx(model_name)
-            print(f"✅ {model_name} 转换成功\n")
-        except Exception as e:
-            print(f"❌ {model_name} 转换失败: {e}\n")
-
-
-if __name__ == "__main__":
-    batch_convert_paddle_models()
-```
-
-#### 方法B: 直接权重映射 (更精确)
-
-```python
-"""
-paddle_direct_converter.py
-直接权重映射转换 (更精确但需要手动定义架构)
-"""
-import paddle
-import torch
-import torch.nn as nn
-from typing import Dict, OrderedDict
-
-
-class DBNetBackbone(nn.Module):
-    """DBNet检测模型的PyTorch实现"""
-    def __init__(self, in_channels=3, **kwargs):
-        super().__init__()
-        # 这里需要根据PaddleOCR的DBNet结构手动实现
-        # 参考: https://github.com/PaddlePaddle/PaddleOCR/blob/main/ppocr/modeling/backbones/rec_resnet_vd.py
-        pass
-  
-    def forward(self, x):
-        pass
-
-
-def convert_paddle_state_dict_to_pytorch(
-    paddle_params_path: str,
-    pytorch_model: nn.Module
-) -> OrderedDict:
-    """
-    直接转换Paddle权重到PyTorch
-  
-    Args:
-        paddle_params_path: Paddle权重文件路径
-        pytorch_model: 目标PyTorch模型
-  
-    Returns:
-        PyTorch state_dict
-    """
-    # 加载Paddle权重
-    paddle_state_dict = paddle.load(paddle_params_path)
-  
-    # 权重名称映射规则
-    NAME_MAPPING = {
-        # Paddle → PyTorch
-        'backbone.conv1.weights': 'backbone.conv1.weight',
-        'backbone.conv1._mean': 'backbone.bn1.running_mean',
-        'backbone.conv1._variance': 'backbone.bn1.running_var',
-        # ... 补全其他映射
-    }
-  
-    pytorch_state_dict = OrderedDict()
-  
-    for paddle_key, paddle_tensor in paddle_state_dict.items():
-        # 映射名称
-        pytorch_key = NAME_MAPPING.get(paddle_key, paddle_key)
-      
-        # 转换tensor
-        numpy_array = paddle_tensor.numpy()
-      
-        # 特殊处理卷积权重 (NCHW format一致)
-        if 'conv' in pytorch_key and 'weight' in pytorch_key:
-            if numpy_array.ndim == 4:
-                # Paddle和PyTorch的卷积权重格式一致: [out_channels, in_channels, kH, kW]
-                pass
-      
-        pytorch_tensor = torch.from_numpy(numpy_array)
-        pytorch_state_dict[pytorch_key] = pytorch_tensor
-  
-    return pytorch_state_dict
-
-
-# 使用示例
-def convert_specific_model():
-    """转换特定模型"""
-    # 1. 创建PyTorch模型架构
-    pytorch_model = DBNetBackbone(in_channels=3)
-  
-    # 2. 转换权重
-    paddle_params = "~/.paddlex/official_models/ch_PP-OCRv4_det_infer/inference.pdiparams"
-    pytorch_state_dict = convert_paddle_state_dict_to_pytorch(
-        paddle_params,
-        pytorch_model
-    )
-  
-    # 3. 加载权重
-    pytorch_model.load_state_dict(pytorch_state_dict)
-  
-    # 4. 保存
-    torch.save(pytorch_model.state_dict(), "ch_PP-OCRv4_det.pth")
-```
-
----
-
-### 步骤2: ONNX模型转PyTorch
-
-```python
-"""
-onnx_to_pytorch_converter.py
-ONNX模型到PyTorch的转换
-"""
-import torch
-import onnx
-from onnx2pytorch import ConvertModel
-from pathlib import Path
-
-
-class ONNXToPyTorchConverter:
-    """ONNX到PyTorch转换器"""
-  
-    def __init__(self, onnx_model_dir: str, output_dir: str = "./pytorch_models"):
-        self.onnx_model_dir = Path(onnx_model_dir)
-        self.output_dir = Path(output_dir)
-        self.output_dir.mkdir(parents=True, exist_ok=True)
-  
-    def convert(self, onnx_filename: str, output_name: str = None) -> str:
-        """
-        转换单个ONNX模型
-      
-        Args:
-            onnx_filename: ONNX文件名 (如 'model.onnx')
-            output_name: 输出文件名 (如 'model.pth')
-      
-        Returns:
-            转换后的PyTorch模型路径
-        """
-        onnx_path = self.onnx_model_dir / onnx_filename
-      
-        if output_name is None:
-            output_name = onnx_filename.replace('.onnx', '.pth')
-      
-        output_path = self.output_dir / output_name
-      
-        print(f"🔄 转换ONNX模型: {onnx_filename}")
-      
-        # 加载ONNX模型
-        onnx_model = onnx.load(str(onnx_path))
-        onnx.checker.check_model(onnx_model)
-      
-        # 转换为PyTorch
-        pytorch_model = ConvertModel(onnx_model, experimental=True)
-      
-        # 保存
-        torch.save({
-            'model_state_dict': pytorch_model.state_dict(),
-            'model': pytorch_model,
-            'source': 'converted_from_onnx',
-            'original_onnx': str(onnx_path)
-        }, output_path)
-      
-        print(f"   ✅ 已保存: {output_path}\n")
-        return str(output_path)
-  
-    def batch_convert(self, model_list: list[tuple[str, str]]):
-        """批量转换"""
-        for onnx_file, output_file in model_list:
-            try:
-                self.convert(onnx_file, output_file)
-            except Exception as e:
-                print(f"❌ {onnx_file} 转换失败: {e}\n")
-
-
-# 批量转换脚本
-def batch_convert_onnx_models():
-    """批量转换现有的ONNX模型"""
-  
-    ONNX_MODELS = [
-        # (ONNX文件, 输出文件)
-        ("PP-LCNet_x1_0_table_cls.onnx", "table_cls.pth"),
-        ("PP-LCNet_x1_0_doc_ori.onnx", "orientation_cls.pth"),
-        ("unet.onnx", "unet_table.pth"),
-        ("slanet-plus.onnx", "slanet_plus_table.pth"),
-    ]
-  
-    base_dir = Path("~/models/modelscope_cache/models/OpenDataLab/PDF-Extract-Kit-1___0/models").expanduser()
-  
-    # 表格分类
-    converter = ONNXToPyTorchConverter(
-        base_dir / "TabCls/paddle_table_cls",
-        "./unified_pytorch_models/Table/Cls"
-    )
-    converter.convert("PP-LCNet_x1_0_table_cls.onnx", "table_cls.pth")
-  
-    # 方向分类
-    converter = ONNXToPyTorchConverter(
-        base_dir / "OriCls/paddle_orientation_classification",
-        "./unified_pytorch_models/OCR/Cls"
-    )
-    converter.convert("PP-LCNet_x1_0_doc_ori.onnx", "orientation_cls.pth")
-  
-    # 表格识别
-    converter = ONNXToPyTorchConverter(
-        base_dir / "TabRec/UnetStructure",
-        "./unified_pytorch_models/Table/Rec"
-    )
-    converter.convert("unet.onnx", "unet_table.pth")
-  
-    converter = ONNXToPyTorchConverter(
-        base_dir / "TabRec/SlanetPlus",
-        "./unified_pytorch_models/Table/Rec"
-    )
-    converter.convert("slanet-plus.onnx", "slanet_plus.pth")
-
-
-if __name__ == "__main__":
-    batch_convert_onnx_models()
-```
-
----
-
-### 步骤3: 统一模型加载器
-
-```python
-"""
-unified_model_loader.py
-统一的PyTorch模型加载器
-"""
-import torch
-import torch.nn as nn
-from pathlib import Path
-from typing import Union, Dict, Any
-
-
-class UnifiedModelLoader:
-    """统一的PyTorch模型加载器"""
-  
-    def __init__(self, models_root: str = "./unified_pytorch_models"):
-        self.models_root = Path(models_root)
-      
-        # 模型注册表
-        self.model_registry = {
-            # OCR模型
-            'ocr_det_ch': 'OCR/Det/ch_PP-OCRv4_det_infer.pth',
-            'ocr_det_en': 'OCR/Det/en_PP-OCRv4_det_infer.pth',
-            'ocr_rec_ch': 'OCR/Rec/ch_PP-OCRv4_rec_infer.pth',
-            'ocr_rec_en': 'OCR/Rec/en_PP-OCRv4_rec_infer.pth',
-            'ocr_cls': 'OCR/Cls/orientation_cls.pth',
-          
-            # 表格模型
-            'table_cls': 'Table/Cls/table_cls.pth',
-            'table_rec_wired': 'Table/Rec/unet_table.pth',
-            'table_rec_wireless': 'Table/Rec/slanet_plus.pth',
-          
-            # Layout模型 (已是PyTorch)
-            'layout_yolo': 'Layout/YOLO/doclayout_yolo.pt',
-          
-            # 公式识别 (已是PyTorch)
-            'formula_rec': 'MFR/unimernet_small.safetensors',
-          
-            # VLM模型 (已是PyTorch)
-            'vlm_mineru': 'VLM/MinerU-VLM-1.2B.safetensors',
-            'vlm_paddleocr': 'VLM/PaddleOCR-VL-0.9B.safetensors',
-        }
-  
-    def load_model(
-        self, 
-        model_key: str, 
-        device: str = 'cpu',
-        **kwargs
-    ) -> nn.Module:
-        """
-        加载模型
-      
-        Args:
-            model_key: 模型键名 (如 'ocr_det_ch')
-            device: 设备 ('cpu', 'cuda', 'cuda:0')
-            **kwargs: 额外参数
-      
-        Returns:
-            PyTorch模型
-        """
-        if model_key not in self.model_registry:
-            raise ValueError(f"未知模型: {model_key}")
-      
-        model_path = self.models_root / self.model_registry[model_key]
-      
-        if not model_path.exists():
-            raise FileNotFoundError(f"模型文件不存在: {model_path}")
-      
-        print(f"📦 加载模型: {model_key} from {model_path.name}")
-      
-        # 加载模型
-        if model_path.suffix == '.safetensors':
-            model = self._load_safetensors(model_path, device)
-        elif model_path.suffix in ['.pt', '.pth']:
-            model = self._load_pytorch(model_path, device)
-        else:
-            raise ValueError(f"不支持的模型格式: {model_path.suffix}")
-      
-        return model
-  
-    def _load_pytorch(self, model_path: Path, device: str) -> nn.Module:
-        """加载标准PyTorch模型"""
-        checkpoint = torch.load(model_path, map_location=device)
-      
-        if 'model' in checkpoint:
-            # 完整模型
-            model = checkpoint['model']
-        elif 'model_state_dict' in checkpoint:
-            # 仅权重 - 需要先创建模型架构
-            raise NotImplementedError("需要提供模型架构")
-        else:
-            # 直接是state_dict
-            raise NotImplementedError("需要提供模型架构")
-      
-        model.eval()
-        return model.to(device)
-  
-    def _load_safetensors(self, model_path: Path, device: str) -> nn.Module:
-        """加载Safetensors格式模型 (通常用于HuggingFace)"""
-        from transformers import AutoModel
-      
-        model = AutoModel.from_pretrained(
-            model_path.parent,
-            torch_dtype=torch.float16 if 'cuda' in device else torch.float32,
-            device_map=device
-        )
-      
-        model.eval()
-        return model
-  
-    def list_available_models(self) -> Dict[str, str]:
-        """列出所有可用模型"""
-        available = {}
-        for key, rel_path in self.model_registry.items():
-            full_path = self.models_root / rel_path
-            available[key] = {
-                'path': str(rel_path),
-                'exists': full_path.exists(),
-                'size': full_path.stat().st_size if full_path.exists() else 0
-            }
-        return available
-
-
-# 使用示例
-def test_unified_loader():
-    """测试统一加载器"""
-    loader = UnifiedModelLoader("./unified_pytorch_models")
-  
-    # 列出所有模型
-    print("📋 可用模型:")
-    for key, info in loader.list_available_models().items():
-        status = "✅" if info['exists'] else "❌"
-        print(f"  {status} {key}: {info['path']}")
-  
-    # 加载OCR检测模型
-    try:
-        ocr_det_model = loader.load_model('ocr_det_ch', device='cuda:0')
-        print(f"\n✅ OCR检测模型加载成功: {type(ocr_det_model)}")
-    except Exception as e:
-        print(f"\n❌ 加载失败: {e}")
-
-
-if __name__ == "__main__":
-    test_unified_loader()
-```
-
----
-
-## 📦 统一后的目录结构
-
-```bash
-unified_pytorch_models/
-├── OCR/
-│   ├── Det/
-│   │   ├── ch_PP-OCRv4_det_infer.pth
-│   │   └── en_PP-OCRv4_det_infer.pth
-│   ├── Rec/
-│   │   ├── ch_PP-OCRv4_rec_infer.pth
-│   │   └── en_PP-OCRv4_rec_infer.pth
-│   └── Cls/
-│       └── orientation_cls.pth
-├── Table/
-│   ├── Cls/
-│   │   └── table_cls.pth
-│   └── Rec/
-│       ├── unet_table.pth
-│       └── slanet_plus.pth
-├── Layout/
-│   └── YOLO/
-│       └── doclayout_yolo.pt
-├── MFR/
-│   └── unimernet_small.safetensors
-└── VLM/
-    ├── MinerU-VLM-1.2B/
-    │   └── model.safetensors
-    └── PaddleOCR-VL-0.9B/
-        └── model.safetensors
-```
-
----
-
-## 🚀 完整转换流程
-
-```bash
-#!/bin/bash
-# convert_all_models.sh - 一键转换所有模型到PyTorch
-
-echo "🔄 开始统一模型转换..."
-
-# 1. 安装依赖
-pip install paddle2onnx onnx onnx2pytorch transformers safetensors
-
-# 2. 转换PaddlePaddle模型
-echo "📦 步骤1: 转换PaddlePaddle模型..."
-python paddle_to_pytorch_converter.py
-
-# 3. 转换ONNX模型
-echo "📦 步骤2: 转换ONNX模型..."
-python onnx_to_pytorch_converter.py
-
-# 4. 复制已有的PyTorch模型
-echo "📦 步骤3: 整理现有PyTorch模型..."
-mkdir -p unified_pytorch_models/{Layout,MFR,VLM}
-
-# Layout YOLO
-cp ~/models/.../Layout/YOLO/doclayout_yolo.pt \
-   unified_pytorch_models/Layout/YOLO/
-
-# 公式识别
-cp ~/models/.../MFR/unimernet_small.safetensors \
-   unified_pytorch_models/MFR/
-
-# VLM模型
-cp -r ~/models/.../VLM/* \
-      unified_pytorch_models/VLM/
-
-echo "✅ 所有模型已统一到PyTorch框架!"
-echo "📂 输出目录: unified_pytorch_models/"
-
-# 5. 验证
-python -c "
-from unified_model_loader import UnifiedModelLoader
-loader = UnifiedModelLoader('./unified_pytorch_models')
-for key, info in loader.list_available_models().items():
-    print(f\"{'✅' if info['exists'] else '❌'} {key}\")
-"
-```
-
----
-
-## ⚡ 性能对比
-
-| 指标                   | 混合框架 (现状)      | 统一PyTorch       |
-| ---------------------- | -------------------- | ----------------- |
-| **模型加载时间** | ~10s (多框架初始化)  | ~3s (单一框架)    |
-| **内存占用**     | ~8GB (重复依赖)      | ~5GB (共享依赖)   |
-| **推理延迟**     | 100ms + 框架切换开销 | 85ms (无切换)     |
-| **部署复杂度**   | ⭐⭐⭐⭐ (3个框架)   | ⭐⭐ (1个框架)    |
-| **调试便利性**   | ⭐⭐ (分散)          | ⭐⭐⭐⭐⭐ (统一) |
-
----
-
-## 🎯 实际应用示例
-
-```python
-"""
-使用统一的PyTorch模型进行推理
-"""
-from unified_model_loader import UnifiedModelLoader
-import torch
-from PIL import Image
-
-
-def unified_ocr_pipeline(image_path: str, device: str = 'cuda:0'):
-    """统一的OCR推理流程"""
-  
-    # 1. 初始化加载器
-    loader = UnifiedModelLoader('./unified_pytorch_models')
-  
-    # 2. 加载所有需要的模型 (全部PyTorch)
-    layout_model = loader.load_model('layout_yolo', device=device)
-    ocr_det_model = loader.load_model('ocr_det_ch', device=device)
-    ocr_rec_model = loader.load_model('ocr_rec_ch', device=device)
-    table_model = loader.load_model('table_rec_wired', device=device)
-  
-    # 3. 加载图像
-    image = Image.open(image_path)
-  
-    # 4. 推理 (全部使用PyTorch API)
-    with torch.no_grad():
-        # 版面检测
-        layout_results = layout_model(image)
-      
-        # 文本检测
-        text_boxes = ocr_det_model(image)
-      
-        # 文本识别
-        texts = [ocr_rec_model(crop) for crop in text_boxes]
-      
-        # 表格识别
-        tables = [table_model(crop) for crop in layout_results['tables']]
-  
-    return {
-        'texts': texts,
-        'tables': tables
-    }
-
-
-if __name__ == "__main__":
-    result = unified_ocr_pipeline("test.png", device='cuda:0')
-    print(result)
-```
-
----
-
-## 📊 转换进度追踪
-
-创建 `conversion_tracker.py`:
-
-```python
-"""转换进度追踪工具"""
-import json
-from pathlib import Path
-from datetime import datetime
-
-
-class ConversionTracker:
-    """模型转换进度追踪器"""
-  
-    def __init__(self, tracker_file: str = "conversion_progress.json"):
-        self.tracker_file = Path(tracker_file)
-        self.data = self._load()
-  
-    def _load(self):
-        if self.tracker_file.exists():
-            with open(self.tracker_file) as f:
-                return json.load(f)
-        return {'models': {}, 'summary': {}}
-  
-    def mark_converted(self, model_key: str, source_format: str, 
-                      output_path: str, notes: str = ""):
-        """标记模型已转换"""
-        self.data['models'][model_key] = {
-            'source_format': source_format,
-            'output_path': output_path,
-            'converted_at': datetime.now().isoformat(),
-            'notes': notes
-        }
-        self._save()
-  
-    def _save(self):
-        with open(self.tracker_file, 'w') as f:
-            json.dump(self.data, f, indent=2)
-  
-    def generate_report(self):
-        """生成转换报告"""
-        total = len(self.data['models'])
-        by_format = {}
-        for model_info in self.data['models'].values():
-            fmt = model_info['source_format']
-            by_format[fmt] = by_format.get(fmt, 0) + 1
-      
-        print("=" * 60)
-        print("模型转换进度报告")
-        print("=" * 60)
-        print(f"总计: {total} 个模型已转换")
-        print("\n按源格式分组:")
-        for fmt, count in by_format.items():
-            print(f"  {fmt}: {count} 个")
-        print("=" * 60)
-
-
-# 使用示例
-tracker = ConversionTracker()
-tracker.mark_converted('ocr_det_ch', 'PaddlePaddle', 
-                      'unified_pytorch_models/OCR/Det/ch_PP-OCRv4_det_infer.pth')
-tracker.generate_report()
-```
-
----
-
-## 🎉 最终方案总结
-
-### ✅ 优势
-
-1. **统一框架**: 所有模型都使用PyTorch，消除框架切换开销
-2. **简化部署**: 只需安装PyTorch及其依赖
-3. **便于维护**: 统一的加载器和推理API
-4. **性能提升**: 减少内存占用和推理延迟
-5. **兼容性好**: 支持多种导出格式 (TorchScript/ONNX/TensorRT)
-
-### 📋 实施步骤
-
-1. ✅ 安装转换工具: `pip install paddle2onnx onnx onnx2pytorch`
-2. ✅ 执行批量转换: `bash convert_all_models.sh`
-3. ✅ 验证模型: `python test_unified_loader.py`
-4. ✅ 更新代码: 替换为统一加载器
-5. ✅ 测试推理: 确保精度无损
-
----
-
-这个方案不仅统一了框架，还提供了完整的工具链和验证流程。您可以根据实际需求调整转换策略! 🚀
-
-# ONNX vs PyTorch 深度对比
-
-让我从**开发体验**、**部署场景**、**性能表现**三个维度全面对比：
-
----
-
-## 📊 核心差异总览
-
-| 维度 | PyTorch | ONNX + ONNX Runtime |
-|------|---------|---------------------|
-| **本质** | 深度学习框架 | 模型交换格式 + 推理引擎 |
-| **图类型** | 动态计算图 | 静态计算图 |
-| **主要用途** | 训练 + 研究 + 推理 | **仅推理**（部署） |
-| **灵活性** | ⭐⭐⭐⭐⭐ | ⭐⭐ |
-| **推理性能** | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
-| **跨平台** | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
-| **调试体验** | ⭐⭐⭐⭐⭐ | ⭐⭐ |
-
----
-
-## 🔍 1. 技术架构差异
-
-### PyTorch 架构
-
-```
-┌─────────────────────────────────────┐
-│         PyTorch 生态                │
-├─────────────────────────────────────┤
-│  Python API (torch.nn, torch.optim) │  ← 开发层
-├─────────────────────────────────────┤
-│  Autograd Engine (自动微分)         │  ← 训练层
-├─────────────────────────────────────┤
-│  ATen (C++ Tensor Library)          │  ← 计算层
-├─────────────────────────────────────┤
-│  Backends (CUDA, CPU, MPS...)       │  ← 硬件层
-└─────────────────────────────────────┘
-```
-
-**特点**:
-- ✅ **动态图**：每次前向传播都重新构建计算图
-- ✅ **Pythonic**：调试友好，断点可用
-- ✅ **完整生态**：训练 + 推理 + 部署一体化
-
----
-
-### ONNX Runtime 架构
-
-```
-┌─────────────────────────────────────┐
-│        ONNX Runtime 生态            │
-├─────────────────────────────────────┤
-│  ONNX Model (静态图 .onnx 文件)     │  ← 模型层
-├─────────────────────────────────────┤
-│  Graph Optimizer (图优化)           │  ← 优化层
-│  - Constant Folding                 │
-│  - Operator Fusion                  │
-│  - Memory Planning                  │
-├─────────────────────────────────────┤
-│  Execution Providers                │  ← 执行层
-│  - CPU (MLAS, oneDNN)               │
-│  - CUDA (cuDNN, TensorRT)           │
-│  - CoreML, DirectML...              │
-└─────────────────────────────────────┘
-```
-
-**特点**:
-- ✅ **静态图**：一次转换，到处运行
-- ✅ **高度优化**：算子融合、内存复用
-- ✅ **跨框架**：支持 PyTorch/TensorFlow/PaddlePaddle 等
-
----
-
-## 💻 2. 开发体验对比
-
-### 场景 1: 模型定义与调试
-
-#### PyTorch（优势）
-
-```python
-import torch
-import torch.nn as nn
-
-class MyModel(nn.Module):
-    def __init__(self):
-        super().__init__()
-        self.conv1 = nn.Conv2d(3, 64, 3)
-        self.bn1 = nn.BatchNorm2d(64)
-        self.relu = nn.ReLU()
-    
-    def forward(self, x):
-        # ✅ 可以在这里打断点
-        x = self.conv1(x)
-        
-        # ✅ 可以动态添加逻辑
-        if x.shape[0] > 1:
-            x = self.bn1(x)
-        
-        # ✅ 可以打印调试信息
-        print(f"Feature shape: {x.shape}")
-        
-        return self.relu(x)
-
-model = MyModel()
-input_data = torch.randn(2, 3, 224, 224)
-
-# ✅ 支持断点调试
-import pdb; pdb.set_trace()
-output = model(input_data)
-```
-
-**优势**:
-- ✅ **断点调试**：可以在任意位置打断点
-- ✅ **动态逻辑**：支持 if/for/while 等控制流
-- ✅ **实时查看**：可以打印中间结果
-- ✅ **快速迭代**：修改代码立即生效
-
----
-
-#### ONNX Runtime（局限）
-
-```python
-import onnxruntime as ort
-import numpy as np
-
-# ❌ 只能加载预先导出的 ONNX 模型
-session = ort.InferenceSession("model.onnx")
-
-# ❌ 无法修改模型结构
-# ❌ 无法打断点查看中间层
-# ❌ 无法动态添加逻辑
-
-# 只能执行推理
-input_data = np.random.randn(2, 3, 224, 224).astype(np.float32)
-outputs = session.run(None, {"input": input_data})
-
-# ⚠️ 调试困难：需要使用 Netron 可视化模型
-```
-
-**劣势**:
-- ❌ **无法断点调试**：只能整体执行
-- ❌ **静态图**：模型结构固定，无法修改
-- ❌ **调试困难**：需要额外工具（Netron）
-- ❌ **开发效率低**：每次修改都要重新导出
-
----
-
-### 场景 2: 模型训练
-
-#### PyTorch（完整支持）
-
-```python
-import torch.optim as optim
-
-model = MyModel()
-optimizer = optim.Adam(model.parameters(), lr=0.001)
-criterion = nn.CrossEntropyLoss()
-
-# ✅ 完整训练流程
-for epoch in range(100):
-    for batch in dataloader:
-        inputs, labels = batch
-        
-        # 前向传播
-        outputs = model(inputs)
-        loss = criterion(outputs, labels)
-        
-        # 反向传播
-        optimizer.zero_grad()
-        loss.backward()  # ✅ 自动微分
-        optimizer.step()
-        
-        # ✅ 动态调整学习率
-        if loss < 0.1:
-            for param_group in optimizer.param_groups:
-                param_group['lr'] *= 0.1
-```
-
-**优势**:
-- ✅ **完整训练支持**：自动微分、优化器、损失函数
-- ✅ **灵活调整**：动态学习率、早停、检查点
-- ✅ **分布式训练**：DDP、FSDP 等
-
----
-
-#### ONNX Runtime（不支持）
-
-```python
-# ❌ ONNX Runtime 不支持训练
-# ❌ 没有反向传播
-# ❌ 没有优化器
-# ❌ 只能推理
-```
-
-**结论**: **ONNX 只用于部署，不适合开发阶段**。
-
----
-
-## 🚀 3. 部署场景对比
-
-### 场景 1: 云端服务器部署
-
-#### PyTorch 部署
-
-```python
-# server.py
-import torch
-from flask import Flask, request
-
-app = Flask(__name__)
-
-# 加载模型
-model = torch.load("model.pth")
-model.eval()
-
-@app.route('/predict', methods=['POST'])
-def predict():
-    data = request.json
-    input_tensor = torch.tensor(data['input'])
-    
-    with torch.no_grad():
-        output = model(input_tensor)
-    
-    return {'result': output.tolist()}
-
-if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=5000)
-```
-
-**部署包大小**:
-```
-my_app/
-├── server.py           (5 KB)
-├── model.pth           (200 MB)
-└── requirements.txt
-    - torch (1.5 GB 😱)  ← 巨大！
-    - flask
-```
-
-**问题**:
-- ❌ **依赖巨大**：PyTorch 安装包 1-2 GB
-- ❌ **启动慢**：加载 PyTorch 需要 5-10 秒
-- ⚠️ **内存占用高**：PyTorch 运行时内存 500MB+
-
----
-
-#### ONNX Runtime 部署（优势）
-
-```python
-# server.py
-import onnxruntime as ort
-from flask import Flask, request
-import numpy as np
-
-app = Flask(__name__)
-
-# 加载模型
-session = ort.InferenceSession("model.onnx")
-
-@app.route('/predict', methods=['POST'])
-def predict():
-    data = request.json
-    input_array = np.array(data['input'], dtype=np.float32)
-    
-    outputs = session.run(None, {"input": input_array})
-    
-    return {'result': outputs[0].tolist()}
-
-if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=5000)
-```
-
-**部署包大小**:
-```
-my_app/
-├── server.py              (4 KB)
-├── model.onnx             (200 MB)
-└── requirements.txt
-    - onnxruntime (50 MB)  ← 小 30 倍！
-    - flask
-```
-
-**优势**:
-- ✅ **依赖小**：ONNX Runtime 仅 50-100 MB
-- ✅ **启动快**：1-2 秒即可加载
-- ✅ **内存少**：运行时内存 100MB 左右
-
----
-
-### 场景 2: 移动端/嵌入式部署
-
-| 平台 | PyTorch | ONNX Runtime |
-|------|---------|--------------|
-| **iOS** | PyTorch Mobile (200MB+) | CoreML via ONNX (10MB) ✅ |
-| **Android** | PyTorch Mobile (50MB+) | NNAPI via ONNX (5MB) ✅ |
-| **Raspberry Pi** | ⚠️ 可用但慢 | ✅ 优化良好 |
-| **嵌入式 (ARM)** | ❌ 不支持 | ✅ 支持 |
-
-**ONNX 完胜**，因为可以转换为平台原生格式。
-
----
-
-### 场景 3: Web 浏览器部署
-
-#### PyTorch
-
-```javascript
-// ❌ PyTorch 不支持浏览器
-// 需要使用 TorchScript → WASM（实验性）
-```
-
-#### ONNX Runtime Web
-
-```javascript
-// ✅ ONNX Runtime Web 原生支持
-import * as ort from 'onnxruntime-web';
-
-const session = await ort.InferenceSession.create('model.onnx');
-const input = new ort.Tensor('float32', inputData, [1, 3, 224, 224]);
-const outputs = await session.run({ input });
-console.log(outputs.output.data);
-```
-
-**结论**: **浏览器部署 ONNX 是唯一选择**。
-
----
-
-## ⚡ 4. 性能对比
-
-### 推理速度测试
-
-**测试模型**: ResNet50  
-**硬件**: NVIDIA RTX 4090  
-**输入**: Batch Size = 1
-
-| 框架 | 首次推理 | 平均延迟 | 吞吐量 (FPS) |
-|------|---------|---------|-------------|
-| **PyTorch (原生)** | 120ms | 12ms | 83 |
-| **PyTorch (JIT)** | 80ms | 8ms | 125 |
-| **ONNX Runtime** | 50ms | **5ms** | **200** ✅ |
-| **ONNX + TensorRT** | 30ms | **3ms** | **333** 🚀 |
-
-**结论**: ONNX Runtime **比 PyTorch 快 1.5-2 倍**。
-
----
-
-### 内存占用对比
-
-| 框架 | 模型加载内存 | 推理峰值内存 |
-|------|------------|-------------|
-| PyTorch | 500 MB | 1.2 GB |
-| ONNX Runtime | 200 MB | 400 MB ✅ |
-
-**ONNX 内存占用仅为 PyTorch 的 1/3**。
-
----
-
-## 🎯 5. 实际使用建议
-
-### 开发阶段（用 PyTorch）
-
-```python
-# 1. 模型开发与训练
-import torch
-import torch.nn as nn
-
-class MyModel(nn.Module):
-    def __init__(self):
-        super().__init__()
-        # ... 定义模型
-
-# 2. 训练
-model = MyModel()
-# ... 训练代码
-
-# 3. 调试优化
-# ✅ 使用 PyTorch 的所有工具
-# - TensorBoard
-# - Profiler
-# - Debugger
-
-# 4. 保存模型
-torch.save(model.state_dict(), "model.pth")
-```
-
----
-
-### 部署阶段（转 ONNX）
-
-```python
-# 1. 导出为 ONNX
-import torch
-
-model = MyModel()
-model.load_state_dict(torch.load("model.pth"))
-model.eval()
-
-dummy_input = torch.randn(1, 3, 224, 224)
-
-torch.onnx.export(
-    model,
-    dummy_input,
-    "model.onnx",
-    input_names=['input'],
-    output_names=['output'],
-    dynamic_axes={'input': {0: 'batch_size'}}
-)
-
-# 2. 验证 ONNX 模型
-import onnx
-onnx_model = onnx.load("model.onnx")
-onnx.checker.check_model(onnx_model)
-
-# 3. 部署
-import onnxruntime as ort
-session = ort.InferenceSession("model.onnx")
-# ... 推理代码
-```
-
----
-
-## 📋 6. 差异总结表
-
-| 需求场景 | 推荐框架 | 理由 |
-|---------|---------|------|
-| **模型研究与开发** | PyTorch ✅ | 灵活、调试友好、生态完整 |
-| **模型训练** | PyTorch ✅ | 唯一选择（ONNX 不支持训练） |
-| **快速原型验证** | PyTorch ✅ | 开发效率高 |
-| **云端高性能推理** | ONNX Runtime ✅ | 速度快、内存少、依赖小 |
-| **移动端部署** | ONNX → CoreML/NNAPI ✅ | 平台原生支持 |
-| **浏览器部署** | ONNX Runtime Web ✅ | 唯一选择 |
-| **嵌入式设备** | ONNX Runtime ✅ | 轻量级、跨平台 |
-| **跨框架兼容** | ONNX ✅ | 统一中间格式 |
-| **需要动态控制流** | PyTorch ✅ | ONNX 不支持复杂控制流 |
-| **需要最快推理速度** | ONNX + TensorRT 🚀 | 硬件加速到极致 |
-
----
-
-## 💡 7. 最佳实践流程
-
-### 完整工作流（推荐）
-
-```mermaid
-graph LR
-    A[开发阶段] -->|PyTorch| B[训练模型]
-    B --> C[验证精度]
-    C --> D[导出 ONNX]
-    D --> E[验证 ONNX 精度]
-    E --> F{部署环境?}
-    
-    F -->|云端| G[ONNX Runtime]
-    F -->|移动端| H[CoreML/NNAPI]
-    F -->|浏览器| I[ONNX Runtime Web]
-    F -->|嵌入式| J[ONNX Runtime Lite]
-    
-    G --> K[生产环境]
-    H --> K
-    I --> K
-    J --> K
-```
-
----
-
-### 示例：MinerU 的最佳部署方案
-
-```python
-"""
-MinerU 开发与部署最佳实践
-"""
-
-# ============ 开发阶段 (PyTorch) ============
-# 在 MinerU 项目中开发和训练
-from paddlex import create_model
-
-# 开发时使用 PaddleX/PyTorch
-model = create_model("PP-DocLayout_plus-L")
-
-# 训练、调试、优化...
-
-
-# ============ 导出阶段 (ONNX) ============
-# 训练完成后导出为 ONNX
-model.export(
-    save_dir="./models",
-    export_format="onnx",
-    opset_version=11
-)
-
-
-# ============ 部署阶段 (ONNX Runtime) ============
-# 生产环境使用 ONNX Runtime
-import onnxruntime as ort
-
-class MinerUONNXPipeline:
-    def __init__(self):
-        # 加载所有 ONNX 模型
-        self.layout_model = ort.InferenceSession("layout.onnx")
-        self.ocr_det_model = ort.InferenceSession("ocr_det.onnx")
-        self.ocr_rec_model = ort.InferenceSession("ocr_rec.onnx")
-        self.table_model = ort.InferenceSession("table.onnx")
-    
-    def process_document(self, image_path):
-        # 统一使用 ONNX Runtime 推理
-        # 速度快、内存少、跨平台
-        ...
-
-# 部署
-pipeline = MinerUONNXPipeline()
-result = pipeline.process_document("document.pdf")
-```
-
----
-
-## 🎯 最终结论
-
-### 对开发的影响
-
-| 阶段 | PyTorch | ONNX |
-|------|---------|------|
-| **研发阶段** | ⭐⭐⭐⭐⭐ 必需 | ❌ 不适用 |
-| **调试阶段** | ⭐⭐⭐⭐⭐ 友好 | ⭐ 困难 |
-| **迭代速度** | ⭐⭐⭐⭐⭐ 快速 | ⭐⭐ 慢（需重新导出） |
-
-**结论**: **开发必须用 PyTorch**（或 PaddlePaddle 等训练框架）。
-
----
-
-### 对部署的影响
-
-| 指标 | PyTorch | ONNX Runtime |
-|------|---------|--------------|
-| **推理速度** | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ 快 1.5-2 倍 |
-| **内存占用** | ⭐⭐ | ⭐⭐⭐⭐⭐ 少 2/3 |
-| **部署包大小** | ⭐ (1.5GB) | ⭐⭐⭐⭐⭐ (50MB) |
-| **跨平台兼容** | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
-| **移动端支持** | ⭐⭐ | ⭐⭐⭐⭐⭐ |
-
-**结论**: **生产部署推荐 ONNX Runtime**。
-
----
-
-### 推荐工作流
-
-```
-开发 → 训练 → 导出 → 部署
- ↓      ↓      ↓      ↓
-PyTorch → PyTorch → ONNX → ONNX Runtime
-```
-
-**最佳实践**: **开发用 PyTorch，部署用 ONNX**！🎉