DeepSeek-OCR: guida pratica con 7 esempi concreti

DeepSeek-OCR è un nuovo grande modello visione-linguaggio che comprende la struttura, analizza tabelle, estrae grafici e può persino affrontare matematica, meme e più lingue.

In questa guida metto DeepSeek-OCR alla prova su task reali end-to-end: da note scritte a mano a grafici complessi, meme e documenti multilingue. Vedremo insieme:

• Estrazione da grafici e tabelle
• Parsing di chimica e formule
• Riconoscimento di testo manoscritto
• Equazioni e output in Markdown
• OCR per meme e immagini social
• Comprensione di documenti multilingue

Alla fine, vedrai dove DeepSeek-OCR eccelle e dove fatica ancora. Se stai esplorando l’OCR open source, vorrai dare un’occhiata a questi esperimenti prima di scegliere la tua pipeline. Ti consiglio anche di consultare il nostro tutorial su DeepSeek V3.2-Speciale.

Che cos’è DeepSeek-OCR?

DeepSeek-OCR è un modello visione-linguaggio aperto da 3B parametri addestrato per la comprensione dei documenti. Sfrutta la compressione ottica del contesto mappando grandi contesti visivi 2D in token visivi compressi, consentendo di elaborare documenti enormi in modo efficiente.

Alcune caratteristiche chiave includono:

• Lettura di grandi documenti scansionati, ricevute, fatture, articoli di ricerca, ecc.
• Parsing di tabelle, grafici e figure geometriche.
• Gestione di testi multilingue e manoscritti.

Come funziona DeepSeek-OCR?

DeepSeek-OCR è progettato per gestire un’ampia varietà di immagini di documenti, da grafici e tabelle a scrittura a mano, matematica e testi multilingue. Invece di trattare immagini e testo come domini separati, sfrutta la modalità visiva come motore di compressione per testi lunghi, permettendo ai large language models (LLM) di processare molte più informazioni usando drasticamente meno token. Vediamo la sua architettura e cosa la distingue:

La pipeline end-to-end: dall’encoder al decoder

A grandi linee, DeepSeek-OCR è composto da due componenti principali:

• DeepEncoder (Tokenizer & Compressore Visivo)
• DeepSeek-3B MoE Decoder (Generatore di Testo)

Fonte: DeepSeek-OCR: Contexts Optical Compression

1. Preprocessamento dell’immagine in input: La pipeline parte da un’immagine di documento, come un contratto scansionato, una nota scritta a mano, una tabella finanziaria, ecc. L’immagine viene suddivisa in una griglia di patch da 16x16 pixel che rappresentano le unità visive minime comprese dal modello.

2. DeepEncoder: DeepEncoder è un motore visivo multi-stadio progettato per bilanciare risoluzione, uso di memoria e compressione dell’informazione. Opera in tre fasi principali:

• SAM (Segment Anything Model, 80M parametri): Gestisce l’attenzione locale analizzando piccole patch sovrapposte per catturare dettagli fini e layout.
• Compressore Convoluzionale (downsample 16x): Riduce drasticamente il numero di token visivi comprimendo le feature locali, così meno token raggiungono la costosa fase di attenzione globale.
• CLIP ViT: È un trasformatore visivo (300M parametri) che applica attenzione globale per comprendere la struttura e il contesto complessivi del documento, fungendo da livello di embedding per i token compressi.

3. Dai token visivi al testo: Il Decoder MoE comprime i token visivi che vengono passati al decoder DeepSeek-3B MoE (Mixture-of-Experts) per un’inferenza efficiente, attivando solo gli esperti più rilevanti per ogni campione, riducendo i costi computazionali senza sacrificare l’accuratezza.

4. Flessibilità guidata dal prompt: Il sistema guida il formato dell’output (Markdown, tabelle HTML, formule chimiche SMILES, layout multilingui, ecc.) semplicemente cambiando il prompt, come accade con gli LLM.

DeepSeek-OCR dimostra che una singola immagine di documento può essere “compressa” fino a 1/10 dei token necessari per il testo semplice, senza perdite sostanziali di accuratezza. 

Demo DeepSeek OCR: applicazione Gradio

In questa sezione configuriamo una completa applicazione web Gradio per DeepSeek-OCR per eseguire l’OCR direttamente nel tuo browser o in Google Colab. In pochi passaggi puoi caricare immagini di grafici, tabelle, note scritte a mano, meme, matematica, testo multilingue e ottenere un output strutturato con bounding box.

Passo 1: Prerequisiti

Prima di iniziare, assicurati di avere i seguenti prerequisiti:

!pip install -q "transformers==4.46.3" "tokenizers==0.20.3" einops addict easydict pillow gradioOfferto da

Il comando qui sopra installa tutte le librerie Python richieste per DeepSeek-OCR e Gradio, incluse le versioni compatibili più recenti di transformers, tokenizers, l’elaborazione immagini (pillow) e il toolkit UI Gradio. 

Nota: questo codice viene eseguito su una GPU L4 con High RAM su Google Colab.

Passo 2: Import

Ora che abbiamo installato tutte le dipendenze, impostiamo gli import.

import os, time, torch, gradio as gr
from PIL import Image
from transformers import AutoModel, AutoTokenizer
from datetime import datetime
import random
import stringOfferto da

Importiamo tutti i moduli Python essenziali per I/O su file, inferenza del modello (torch), costruzione della UI (gradio), gestione immagini (PIL) e funzioni di utilità per gestire percorsi di file e ID di esecuzione casuali.

Passo 3: Caricare il modello

Una volta installate tutte le librerie richieste, sei pronto a caricare il modello DeepSeek-OCR da Hugging Face. Tuttavia, per accedere a certi modelli è richiesta l’autenticazione con un access token di Hugging Face.

Ecco come impostare il tuo access token di Hugging Face in Google Colab:

• Aggiungi un secret in Colab: nel tuo notebook Google Colab, clicca sull’icona a forma di chiave (“Secrets”) nella barra laterale sinistra e seleziona “Add a Secret”.
• Crea un token su Hugging Face: accedi al tuo account Hugging Face, vai alle impostazioni dell’account e trova la sezione “Access Tokens”. Clicca su “Create new token”, scegli il ruolo appropriato (di solito “Read”) e genera il token.
• Copia e incolla il token: copia il tuo nuovo access token e incollalo nel campo “Add a Secret” di Colab. Questo consente al notebook di accedere in modo sicuro al modello DeepSeek-OCR.

Ora sei pronto per autenticarti e procedere con il caricamento del modello!

model_id = "deepseek-ai/DeepSeek-OCR"
tok = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
if tok.pad_token is None and tok.eos_token is not None:
    tok.pad_token = tok.eos_token
model = AutoModel.from_pretrained(
    model_id,
    trust_remote_code=True,
    use_safetensors=True,
    attn_implementation="eager"
).to(dtype=torch.bfloat16, device="cuda").eval()Offerto da

Il codice qui sopra carica il modello e il tokenizer ufficiali di DeepSeek-OCR direttamente da Hugging Face. Poi garantisce la compatibilità del tokenizer impostando il token di padding e carica il modello in formato bfloat16.

Passo 4: Funzione di supporto

Ora che il modello è pronto, creiamo una nuova directory per ogni output del modello per tenere organizzata ogni esecuzione OCR. Questo assicura che il testo estratto, le visualizzazioni con bounding box e i file di log vengano salvati e non sovrascrivano risultati precedenti.

def new_run_dir(base="/content/runs"):
    os.makedirs(base, exist_ok=True)
    ts = datetime.now().strftime("%Y%m%d-%H%M%S")
    rid = ''.join(random.choices(string.ascii_lowercase + string.digits, k=5))
    path = os.path.join(base, f"run_{ts}_{rid}")
    os.makedirs(path)
    return pathOfferto da

La funzione new_run_dir crea una directory di output univoca per ogni esecuzione di elaborazione immagine, basandosi su timestamp corrente e suffisso casuale. Questo evita sovrascritture tra esecuzioni diverse e aiuta a organizzare i file di output per ispezione o debugging.

Passo 5: Handler OCR

Questo passo è il nostro motore principale per l’app Gradio di DeepSeek-OCR. Inizia convertendo l’immagine caricata nel formato corretto e ridimensionandola se il file è troppo grande. Ogni volta che eseguiamo il modello, salva tutti gli output in una nuova cartella.

def gr_ocr(image, mode, custom_prompt, base_size, image_size, crop_mode):
    img = image.convert("RGB")
    if max(img.size) > 2000:
        s = 2000 / max(img.size)
        img = img.resize((int(img.width*s), int(img.height*s)), Image.LANCZOS)
    run_dir = new_run_dir()
    img_path_proc = os.path.join(run_dir, "input.png")
    img.save(img_path_proc, optimize=True)
    if mode == "Custom Prompt" and custom_prompt.strip():
        prompt = custom_prompt.strip()
    else:
        prompt = DEMO_MODES[mode]["prompt"]
    t0 = time.time()
    try:
        with torch.inference_mode():
            _ = model.infer(
                tok,
                prompt=prompt,
                image_file=img_path_proc,
                output_path=run_dir,
                base_size=base_size,
                image_size=image_size,
                crop_mode=crop_mode,
                save_results=True,
                test_compress=True
            )
    except ZeroDivisionError:
        print(" [Patched] Division by zero in compression ratio (valid_img_tokens==0). Ignored.")
    dt = time.time() - t0
    result_file = os.path.join(run_dir, "result.mmd")
    if not os.path.exists(result_file):
        result_file = os.path.join(run_dir, "result.txt")
    result = "[No text extracted]"
    if os.path.exists(result_file):
        with open(result_file, "r", encoding="utf-8") as f:
            result = f.read().strip() or "[No text extracted]"
    boxed_path = os.path.join(run_dir, "result_with_boxes.jpg")
    boxed_img = Image.open(boxed_path) if os.path.exists(boxed_path) else None
    stats = f"""
**{dt:.1f}s** | Image: {img.size[0]}×{img.size[1]} px  
**Output directory:** {run_dir}  
"""
    return result, stats, boxed_imgOfferto da

La funzione gr_ocr incapsula la logica di preprocessamento, inferenza e post-processamento per l’applicazione Gradio di DeepSeek-OCR. Esegue i seguenti passaggi:

• Standardizzazione e preprocessamento dell’immagine: converte l’immagine in input nello spazio colore RGB per garantire la compatibilità col modello. Se l’immagine supera la dimensione massima (2000px), viene ridimensionata proporzionalmente per evitare overflow di memoria GPU.
• Gestione della directory di esecuzione: ogni esecuzione OCR è isolata in una directory univoca. Questo abilita la tracciabilità fondamentale per batch processing, debugging e riproducibilità.
• Inferenza efficiente del modello: il modello viene invocato all’interno di torch.inference_mode() per evitare il calcolo dei gradienti, riducendo l’uso di memoria e aumentando la velocità di inferenza.
• Gestione dei casi limite e degli errori: gestisce eccezioni come ZeroDivisionError durante rari casi limite nella compressione dei token senza interrompere l’esperienza utente.
• Aggregazione dei risultati e visualizzazione: dopo l’inferenza, carica il testo estratto e un’immagine con overlay che evidenzia le bounding box rilevate per una facile ispezione.
• Integrazione con la UI: la funzione restituisce infine una tupla con output OCR, statistiche di elaborazione e immagine annotata per un’integrazione fluida nell’interfaccia Gradio.

Passiamo ora alla UI interattiva per vedere DeepSeek-OCR in azione.

Passo 6: UI Gradio

Nel passo finale definiamo un’interfaccia Gradio interattiva per DeepSeek-OCR, che permette agli utenti di caricare immagini, selezionare diverse modalità di estrazione OCR, regolare impostazioni avanzate e visualizzare gli output in un’unica UI web.

DEMO_MODES = {
    "Document ➔ Markdown": {
        "prompt": "<image>\n<|grounding|>Convert the document to markdown.",
        "desc": "Extracts full document text as Markdown, preserving structure (headings, tables, lists, etc.).",
        "base_size": 1024, "image_size": 640, "crop_mode": False
    },
    "Chart Deep Parsing": {
        "prompt": "<image>\nParse all charts and tables. Extract data as HTML tables.",
        "desc": "Extracts tabular/chart data into HTML tables.",
        "base_size": 1024, "image_size": 640, "crop_mode": False
    },
    "Chemical Formula Recognition": {
        "prompt": "<image>\nExtract all chemical formulas and SMILES.",
        "desc": "Extracts chemical structures and formulae.",
        "base_size": 1024, "image_size": 768, "crop_mode": False
    },
    "Geometry Parsing": {
        "prompt": "<image>\nExtract all geometric figures and their measurements.",
        "desc": "Parses diagrams and extracts geometric data.",
        "base_size": 1024, "image_size": 768, "crop_mode": False
    },
    "Plain Text Extraction": {
        "prompt": "<image>\nFree OCR.",
        "desc": "Fast, plain text OCR of the image.",
        "base_size": 768, "image_size": 512, "crop_mode": False
    },
    "Multilingual Document": {
        "prompt": "<image>\n<|grounding|>Extract text. Preserve all languages and structure.",
        "desc": "Extracts multi-language content, preserves structure.",
        "base_size": 1024, "image_size": 640, "crop_mode": False
    },
    "Custom Prompt": {
        "prompt": "",
        "desc": "Provide your own custom prompt for flexible OCR or parsing.",
        "base_size": 1024, "image_size": 640, "crop_mode": False
    }
}
with gr.Blocks(theme=gr.themes.Soft()) as demo:
    gr.Markdown("""
    <div style="text-align:center;">
        <h1>DeepSeek-OCR Demo</h1>
    </div>
    """)
    with gr.Row():
        with gr.Column():
            gr.Markdown("### Input")
            image_input = gr.Image(type="pil", label="Upload Document/Image", height=350)
            gr.Markdown("#### Demo Modes (From Paper)")
            mode = gr.Radio(
                choices=list(DEMO_MODES.keys()), value="Document to Markdown", label="Select Capability to Test"
            )
            desc = gr.Markdown(DEMO_MODES["Document to Markdown"]["desc"])
            custom_prompt = gr.Textbox(label="Custom Prompt", visible=False)
            with gr.Accordion("Advanced Settings", open=False):
                base_size = gr.Slider(512, 1280, value=DEMO_MODES["Document to Markdown"]["base_size"], step=64, label="Base Size")
                image_size = gr.Slider(512, 1280, value=DEMO_MODES["Document to Markdown"]["image_size"], step=64, label="Image Size")
                crop_mode = gr.Checkbox(value=DEMO_MODES["Document to Markdown"]["crop_mode"], label="Dynamic Resolution (Crop Mode)")
            process_btn = gr.Button("Process Image", variant="primary")
        with gr.Column():
            gr.Markdown("### Results")
            ocr_output = gr.Textbox(label="Extracted Content", lines=22, show_copy_button=True)
            status_out = gr.Markdown("_Process an image to see stats and output dir_")
            boxed_output = gr.Image(label="Result with Bounding Boxes", type="pil")
    def update_mode(selected):
        d = DEMO_MODES[selected]
        return d["desc"], gr.update(visible=selected=="Custom Prompt"), d["base_size"], d["image_size"], d["crop_mode"]
    mode.change(update_mode, inputs=mode,
                outputs=[desc, custom_prompt, base_size, image_size, crop_mode])
    process_btn.click(
        gr_ocr,
        inputs=[image_input, mode, custom_prompt, base_size, image_size, crop_mode],
        outputs=[ocr_output, status_out, boxed_output]
    )
demo.launch(share=True, debug=True)Offerto da

Capiremo questo codice in sottosezioni:

• Modalità demo e prompt: il dizionario DEMO_MODES racchiude tutte le principali capacità OCR supportate da DeepSeek-OCR, come "Document to Markdown", "Chart Deep Parsing", "Chemical Formula Recognition" e altro. Ogni modalità include un prompt predefinito, una descrizione e parametri consigliati di elaborazione immagine, permettendo agli utenti di cambiare al volo il task di estrazione.
• Architettura a blocchi: la UI è costruita usando l’API ad alto livello Blocks di Gradio. L’interfaccia è divisa in due colonne principali: un pannello di input che consente di caricare un’immagine, scegliere la modalità OCR e regolare parametri avanzati come dimensione immagine e crop mode. Il pannello di output mostra il contenuto OCR estratto, le statistiche di inferenza e un’immagine annotata con bounding box attorno alle aree rilevate.
• Controlli dinamici della UI: l’app include anche radio button, slider, checkbox e textbox che si aggiornano automaticamente in base all’input dell’utente e alla modalità demo selezionata, migliorando l’usabilità e riducendo la configurazione manuale.
• Trigger dell’inferenza e risultati: facendo clic sul pulsante Process Image, viene chiamato l’handler OCR principale gr_ocr passando tutte le selezioni correnti della UI come argomenti. Gli output vengono quindi renderizzati immediatamente nel pannello di output.

Nota: potresti dover riavviare la sessione su Google Colab se continua a restituire l’output dell’input precedente.

Ora che la nostra applicazione Gradio è pronta, mettiamo alla prova DeepSeek-OCR con una serie di esempi pratici.

Esempio app DeepSeek OCR 1: Chart Deep Parsing

All’interno della demo Gradio di DeepSeek-OCR, volevo vedere quanto bene il modello potesse estrarre dati tabellari dai grafici. Questo è ancora impegnativo per la maggior parte dei modelli OCR e di visione.

Ho provato due casi di test classici:

• Un grafico a barre in stile Statista e
• Un grafico di analisi tecnica complesso, pieno di segnali “BUY/SELL” e sovrapposizioni numeriche

DeepSeek-OCR ha restituito una tabella HTML per ciascun grafico, con celle corrispondenti a categorie, valori ed etichette trovati nell’immagine.

Cosa ha funzionato: il modello ha catturato tutto il testo visibile e la struttura del grafico, e l’output era in formato tabella HTML, utilizzabile dalle macchine e coerente con la logica tabellare. Ha persino elaborato grafici finanziari complessi, tentando di tabulare ogni numero ed etichetta.

Dove ha faticato: l’output grezzo era molto verboso, con molte tag <td> e <tr>, rendendo difficile l’interpretazione a colpo d’occhio. Nei grafici complessi, a volte il modello ha duplicato voci o perso la struttura visiva di alto livello, producendo una tabella travolgente di segnali “BUY”/“SELL” ripetuti e valori.

Per flussi di lavoro reali, conviene post-processare l’HTML per leggibilità o importarlo in Excel o Pandas.

Il parsing dei grafici di DeepSeek-OCR è una funzione intelligente di digitalizzazione dei grafici, ma l’output ricco di HTML è più adatto a pipeline di dati a valle o a ulteriore parsing, non a una rapida revisione umana.

Esempio 2: Estrazione di formule chimiche

Per il test successivo, volevo vedere quanto bene DeepSeek-OCR riuscisse a estrarre informazioni chimiche da immagini strutturate. La modalità di estrazione chimica del modello è progettata per convertire sia dati chimici tabellari sia strutture molecolari grafiche in formati leggibili dalle macchine come tabelle HTML e notazione SMILES.

Ho caricato due tipi di immagini per questo esperimento, e ecco cosa ho riscontrato:

• Estrazione di formule testuali: in questo esempio, il modello ha trascritto accuratamente i nomi chimici e le loro formule molecolari (come “Glucosio: C₆H₁₂O₆”, “Butano: C₄H₁₀”). Tuttavia, l’output era formattato come codice di tabella HTML grezzo che, sebbene strutturato, risultava un po’ difficile da interpretare a colpo d’occhio. La conversione da immagine a tabella è stata rapida e ragionevolmente accurata per il testo semplice.

• Riconoscimento di strutture molecolari: per immagini contenenti diagrammi chimici, DeepSeek-OCR ha tentato di estrarre le corrispondenti stringhe SMILES. Ad esempio, ha generato un output SMILES per etano e propano. Pur riconoscendo che si trattava di strutture chimiche, le stringhe SMILES generate non erano sempre chimicamente valide, indicando limiti nel parsing di immagini molecolari più complesse.

In generale, la capacità di estrazione di formule chimiche offre un modo rapido per digitalizzare dati chimici e tentare il riconoscimento di strutture molecolari, ma è necessario un ulteriore affinamento per un parsing chimico affidabile, soprattutto con strutture complesse.

Esempio 3: OCR su testo manoscritto

Successivamente, ho voluto verificare come DeepSeek-OCR gestisse le note scritte a mano, una sfida classica per i sistemi OCR, soprattutto quando la grafia è stilizzata o varia in dimensione. 

Ho caricato un’immagine di un elenco di chimica scritto a mano, con nomi di composti su carta a righe. Una volta elaborata, la modalità Document to Markdown del modello ha estratto il testo e ne ha preservato sorprendentemente bene la struttura. Ha riconosciuto l’intestazione e ha elencato ogni composto su una propria riga, esattamente come nell’immagine originale. Le bounding box hanno confermato visivamente che il modello ha identificato correttamente ogni riga e separato i singoli blocchi di testo.

Questo risultato dimostra la capacità del modello di trascrivere contenuti manoscritti in testo digitale. Alcuni piccoli dettagli di formattazione possono andare persi, ma l’estrazione complessiva è stata molto accurata in questo esempio.

Esempio 4: Estrazione di equazioni

Un altro test standard per l’OCR è leggere e interpretare correttamente equazioni matematiche scritte nella notazione tipica dei libri di testo. Per questo esperimento ho caricato un’immagine contenente alcune equazioni complesse impostate con font in stile LaTeX per valutare se il modello non solo le rilevi, ma anche le estragga e formatti accuratamente.

DeepSeek-OCR ha rilevato con successo tutte e quattro le equazioni nell’immagine ed è riuscito a estrarle come stringhe LaTeX. L’output riconosciuto era ben strutturato, con ogni equazione trascritta su una riga separata nel formato LaTeX standard. 

Le bounding box si sono sovrapposte correttamente (approssimativamente) all’immagine originale, dimostrando che il modello può localizzare e segmentare con precisione le singole espressioni matematiche.

Colpisce il fatto che il contenuto estratto abbia mantenuto la struttura matematica usando comandi come \frac per le frazioni e una corretta formattazione delle variabili, rendendo il risultato riutilizzabile direttamente nella documentazione. 

Esempio 5: Estrazione di tabelle

Uno dei task OCR più comuni e preziosi è l’estrazione di dati tabellari da immagini di documenti, soprattutto quando si lavora con report scansionati, articoli di ricerca o dataset. Per valutare la capacità di DeepSeek-OCR in quest’area, ho caricato un’immagine contenente una tabella economica strutturata di confronto tra più paesi.

Dopo aver selezionato la modalità "Chart Deep Parsing" ed elaborato l’immagine, DeepSeek-OCR ha tentato di convertire la tabella visiva in una struttura di tabella HTML. Il contenuto estratto (a destra) contiene una serie di tag <table> e <td>, che mappano le righe e le colonne della tabella come testo semplice. L’output con bounding box ha inoltre confermato che il modello ha identificato e segmentato correttamente la regione principale della tabella nell’immagine.

Il modello mostra un’estrazione affidabile per tabelle semplici, sebbene possa essere necessario del post-processing poiché il formato di output (HTML grezzo) è meno adatto a una rapida revisione o ad analisi dati a valle.

Esempio 6: OCR sui meme

Per questo esempio, ho voluto testare come il modello gestisce l’estrazione di testo da immagini di meme popolari. È uno scenario reale in cui il testo è spesso sovrapposto a sfondi complessi, usa font variabili e può non seguire le strutture tipiche dei documenti.

Ho caricato un classico meme con grande testo bianco maiuscolo sovrapposto a una scena di un film (Leonardo DiCaprio in Django Unchained) ed eseguito la modalità di estrazione Document to Markdown.

Fonte: Media.io

Il risultato OCR per questo meme è stato sorprendentemente solido. È riuscito a catturare tutte le parole rilevanti nel giusto ordine, senza introdurre errori ortografici o saltare testo, nonostante lo sfondo complesso. 

Sebbene non ci sia markup strutturale, l’estrazione è altamente utilizzabile per attività a valle come sentiment analysis dei meme, moderazione dei contenuti o ricerca testuale dei meme.

Esempio 7: OCR multilingue

Uno dei punti di forza unici di DeepSeek-OCR è il supporto per l’estrazione di testo multilingue, particolarmente utile per documenti o immagini che contengono un mix di lingue.

Ho testato questa capacità con una varietà di campioni, tra cui un’insegna stradale reale con testo cinese e un esempio sintetico contenente un mix di frasi in cinese, giapponese e coreano.

Fonte: DeepSeek OCR Hugging Face

Elaborando questi campioni multilingue, la modalità document-to-Markdown di DeepSeek-OCR ha rilevato ed estratto accuratamente scritture non inglesi. Per la foto di strada, il modello ha identificato e restituito l’intero paragrafo di testo cinese. 

Per l’esempio multilingue, ha separato e etichettato correttamente le sezioni in cinese, giapponese e coreano, preservandone formattazione e blocchi di testo. Le overlay delle bounding box hanno inoltre mostrato un rilevamento preciso di ciascuna regione di testo per lingua.

Ci sono però due avvertenze importanti:

• Velocità di elaborazione: l’OCR multilingue è significativamente più lento rispetto a quello monolingue in inglese o ai task di estrazione di tabelle. I miei test hanno mostrato tempi di elaborazione molto più lunghi, probabilmente a causa della maggiore complessità nel rilevamento degli script e nella decodifica.
• Errori occasionali: talvolta l’output estratto include token ridondanti o testo formattato in modo errato.

Nonostante questi piccoli problemi, DeepSeek-OCR offre solide capacità OCR multilingue che possono gestire in modo affidabile script misti e foto del mondo reale.

Considerazioni finali su DeepSeek-OCR

DeepSeek-OCR colma il divario tra l’OCR classico e i moderni LLM multimodali. Il suo punto di forza è la versatilità: ottieni una singola pipeline che legge documenti scansionati, estrae tabelle e grafici complessi, comprende equazioni e strutture chimiche e funziona persino con meme, scrittura a mano e decine di lingue.

Detto ciò, DeepSeek-OCR non è perfetto. Gli output di grafici e tabelle possono essere eccessivamente verbosi, il riconoscimento di strutture chimiche a volte non è all’altezza e l’elaborazione multilingue può essere sensibilmente lenta. I layout visivi complessi possono richiedere post-processing per l’uso diretto.

Ma per ricerca, flussi di lavoro accademici, prototipazione rapida e per chiunque abbia bisogno di un OCR avanzato oltre il semplice testo, DeepSeek-OCR sembra già un notevole passo avanti rispetto agli strumenti legacy. 

Se vuoi saperne di più sull’ecosistema DeepSeek, ti consiglio di dare un’occhiata al corso Working with DeepSeek in Python.