Présentation détaillée du projet DeepSeek-OCR

Aperçu du projet

DeepSeek-OCR est un modèle innovant de reconnaissance optique de caractères (OCR) open source développé par l'équipe DeepSeek AI, qui se concentre sur l'exploration des limites de la compression visuelle de texte. Ce projet étudie le rôle des encodeurs visuels sous l'angle des grands modèles linguistiques, en utilisant la perception visuelle comme un médium de compression d'informations, ce qui permet de traiter des documents volumineux et complexes avec un nombre de tokens significativement réduit.

Caractéristiques principales

• Compression efficace : Atteint un taux de compression de tokens de 7 à 20 fois, maintenant une précision de décodage d'environ 97 % avec une compression de 10 fois.
• Prise en charge multi-résolution : Prend en charge plusieurs résolutions natives, de 512×512 à 1280×1280.
• Traitement haute performance : Un seul GPU A100-40G peut générer plus de 200 000 pages de données d'entraînement par jour.
• Prise en charge multilingue : Prend en charge la reconnaissance de texte pour environ 100 langues.
• Polyvalence : Prend en charge non seulement l'extraction de texte, mais aussi la compréhension de graphiques, de formules chimiques et de graphiques simples.

Architecture technique

Composition du modèle

DeepSeek-OCR est composé de deux composants principaux :

1. DeepEncoder (encodeur visuel)

   • Nombre de paramètres : environ 380 millions
   • Combinaison d'architectures :
     • SAM-ViTDet (modèle de segmentation de 80 millions de paramètres de Meta) pour la perception d'images locales.
     • Compresseur convolutif à 2 couches, réalisant un sous-échantillonnage de tokens de 16×.
     • CLIP ViT-300M (modèle de 300 millions de paramètres d'OpenAI) pour l'agrégation de connaissances visuelles globales.

2. Décodeur DeepSeek3B-MoE

   • Paramètres actifs : environ 570 millions
   • Paramètres totaux : 3B (architecture de modèle à experts mixtes)
   • Fonction : Génère des résultats basés sur les tokens d'image et les informations d'invite.

Principe de fonctionnement

1. Flux de traitement d'image :

   • Une image de 1024×1024 pixels génère initialement 4096 tokens.
   • Le module SAM effectue un traitement d'attention par fenêtre.
   • Le compresseur réduit les tokens à 256 (compression 16×).
   • Le module CLIP effectue un traitement d'attention globale.
   • Sortie finale de tokens visuels compressés.

2. Modes de résolution :

   • Mode résolution native :

     • Tiny : 512×512 (64 tokens visuels)
     • Small : 640×640 (100 tokens visuels)
     • Base : 1024×1024 (256 tokens visuels)
     • Large : 1280×1280 (400 tokens visuels)

   • Mode résolution dynamique :

     • Gundam : n×640×640 + 1×1024×1024 (combinant vision globale et locale)

Performances

Résultats des tests de référence

• Test de référence Fox : Avec un taux de compression de 10 fois, la précision de décodage atteint environ 97 %.
• Test de référence OmniDocBench :
  • Utilisant seulement 100 tokens visuels, il surpasse GOT-OCR2.0 (256 tokens/page).
  • Utilisant moins de 800 tokens visuels, il surpasse MinerU2.0 (en moyenne plus de 6000 tokens par page).

Performances d'entraînement et d'inférence

• Vitesse d'entraînement :
  • Données textuelles pures : 90B tokens par jour
  • Données multimodales : 70B tokens par jour
• Performance en production : Un seul nœud A100-40G peut traiter plus de 200 000 pages par jour.
• Performance concurrente : Traitement PDF d'environ 2500 tokens/s (A100-40G).

Scénarios d'application

Fonctions principales

DeepSeek-OCR prend en charge plusieurs modes d'invite :

# Convertir un document en Markdown
prompt = "<image>\n<|grounding|>Convert the document to markdown."

# OCR générique
prompt = "<image>\n<|grounding|>OCR this image."

# OCR libre (sans mise en page)
prompt = "<image>\nFree OCR."

# Analyse de figure
prompt = "<image>\nParse the figure."

# Description détaillée de l'image
prompt = "<image>\nDescribe this image in detail."

# Localisation de texte
prompt = "<image>\nLocate <|ref|>xxxx<|/ref|> in the image."

Applications pratiques

1. Numérisation de documents : Traitement efficace de documents tels que des articles universitaires, des livres, des rapports.
2. Génération de jeux de données : Génération de vastes quantités de données d'entraînement pour les grands modèles linguistiques et les modèles visuels-linguistiques.
3. Compression de contexte pour chatbots : Stockage d'anciens historiques de conversation avec une résolution réduite (similaire à la dégradation de la mémoire humaine).
4. Extraction de données structurées :
   • Conversion de graphiques financiers en données structurées.
   • Génération automatique de tableaux et de graphiques Markdown.
   • Prise en charge de la reconnaissance de formules chimiques (format SMILES).

Installation et utilisation

Exigences environnementales

• Python 3.12.9
• CUDA 11.8
• PyTorch 2.6.0
• Transformers 4.46.3

Étapes d'installation

# Cloner le dépôt
git clone https://github.com/deepseek-ai/DeepSeek-OCR.git
cd DeepSeek-OCR

# Créer un environnement Conda
conda create -n deepseek-ocr python=3.12.9 -y
conda activate deepseek-ocr

# Installer les dépendances
pip install torch==2.6.0 torchvision==0.21.0 torchaudio==2.6.0 --index-url https://download.pytorch.org/whl/cu118
pip install vllm-0.8.5+cu118-cp38-abi3-manylinux1_x86_64.whl
pip install -r requirements.txt
pip install flash-attn==2.7.3 --no-build-isolation

Exemples d'utilisation

Méthode 1 : Utilisation de Transformers

from transformers import AutoModel, AutoTokenizer
import torch
import os

os.environ["CUDA_VISIBLE_DEVICES"] = '0'

model_name = 'deepseek-ai/DeepSeek-OCR'
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
model = AutoModel.from_pretrained(
    model_name, 
    _attn_implementation='flash_attention_2', 
    trust_remote_code=True, 
    use_safetensors=True
)
model = model.eval().cuda().to(torch.bfloat16)

# Configurer les paramètres d'inférence
prompt = "<image>\n<|grounding|>Convert the document to markdown."
image_file = 'your_image.jpg'
output_path = 'your/output/dir'

# Exécuter l'inférence
res = model.infer(
    tokenizer, 
    prompt=prompt, 
    image_file=image_file, 
    output_path=output_path, 
    base_size=1024, 
    image_size=640, 
    crop_mode=True, 
    save_results=True, 
    test_compress=True
)

Méthode 2 : Utilisation de vLLM (inférence haute performance)

# Modifier le fichier de configuration
cd DeepSeek-OCR-master/DeepSeek-OCR-vllm
# Éditer config.py pour définir INPUT_PATH/OUTPUT_PATH

# Exécuter l'OCR d'image (sortie en flux)
python run_dpsk_ocr_image.py

# Exécuter l'OCR PDF (haute concurrence)
python run_dpsk_ocr_pdf.py

# Évaluation par lots
python run_dpsk_ocr_eval_batch.py

Innovations techniques

Paradigme de compression visuelle de texte

DeepSeek-OCR propose un nouveau paradigme de compression visuelle de texte :

• Idée centrale : Convertir le texte en image et le traiter via un encodeur visuel, sans stocker la sémantique sous forme de tokens textuels.
• Avantages :
  • Moins de consommation de mémoire : les tokens visuels sont plus compacts.
  • Vitesse d'inférence plus rapide : moins de tokens = moins de calculs.
  • Mécanisme d'oubli naturel : l'ancien contexte peut être sous-échantillonné.
  • Fusion multimodale plus facile : le modèle considère déjà le texte comme une image.

Différence avec l'OCR traditionnel

L'OCR traditionnel utilise une architecture en pipeline (détection → reconnaissance → post-traitement), tandis que DeepSeek-OCR adopte une architecture de modèle visuel-linguistique de bout en bout, simplifiant fondamentalement le système OCR.

Liens vers les ressources

• Dépôt GitHub : https://github.com/deepseek-ai/DeepSeek-OCR
• Modèle Hugging Face : https://huggingface.co/deepseek-ai/DeepSeek-OCR
• Article technique : DeepSeek_OCR_paper.pdf
• Licence : Licence MIT

Remerciements

Le projet DeepSeek-OCR remercie les projets open source suivants pour leurs contributions :

• Vary
• GOT-OCR2.0
• MinerU
• PaddleOCR
• OneChart
• Slow Perception

Ainsi que les jeux de données de référence : Fox et OmniDocBench.

Résumé

DeepSeek-OCR représente une innovation majeure dans la technologie OCR, résolvant les défis du traitement de longs contextes des grands modèles linguistiques grâce au paradigme de compression visuelle. Sa capacité de compression de tokens efficace (7-20 fois), son excellente précision (97 % de précision avec une compression de 10 fois) et sa puissante capacité de traitement (200 000 pages par jour sur un seul GPU) en font un choix idéal pour la numérisation de documents, la génération de données d'entraînement pour l'IA et les applications multimodales.

La nature open source du projet et sa documentation complète facilitent son intégration dans divers scénarios d'application, offrant aux chercheurs et aux développeurs un outil puissant pour explorer les limites de la compression visuelle de texte.