DeepSeek-OCR: Een praktische gids met 7 voorbeelden uit de praktijk

DeepSeek-OCR is een nieuw groot vision-language model dat structuur begrijpt, tabellen parseert, grafieken extraheert en zelfs wiskunde, memes en meerdere talen aankan.

In deze gids test ik DeepSeek-OCR end-to-end op taken uit de echte wereld—van handgeschreven notities tot complexe grafieken, memes en meertalige documenten. We lopen langs:

• Extractie van grafieken en tabellen
• Chemie en formule-parsing
• Herkenning van handgeschreven tekst
• Vergelijkingen en Markdown-uitvoer
• OCR voor memes en sociale afbeeldingen
• Meertalig documentbegrip

Aan het eind zie je waar DeepSeek-OCR uitblinkt en waar het nog moeite mee heeft. Als je open-source OCR verkent, wil je deze experimenten zien voordat je je pipeline kiest. Bekijk ook zeker onze DeepSeek V3.2-Speciale tutorial.

Wat is DeepSeek-OCR?

DeepSeek-OCR is een open vision-language model met 3B parameters, getraind voor documentbegrip. Het benut contextuele optische compressie door grote 2D visuele contexten te mappen naar gecomprimeerde vision-tokens, waardoor het enorme documenten efficiënt kan verwerken.

Enkele belangrijke features zijn:

• Lezen van grote gescande documenten, bonnetjes, facturen, onderzoeksartikelen, enz.
• Parsing van tabellen, grafieken en geometrische figuren.
• Omgaan met meertalige en handgeschreven tekst.

Hoe werkt DeepSeek-OCR?

DeepSeek-OCR is ontworpen om een breed scala aan documentafbeeldingen aan te kunnen, van grafieken en tabellen tot handschrift, wiskunde en meertalige tekst. In plaats van afbeeldingen en tekst als gescheiden domeinen te zien, gebruikt het de visuele modaliteit als compressiemotor voor lange tekst, waardoor large language models (LLM’s) veel meer informatie kunnen verwerken met drastisch minder tokens. Laten we de architectuur en de onderscheidende punten uitsplitsen:

De end-to-end pipeline: Encoder naar decoder

Op hoofdlijnen bestaat DeepSeek-OCR uit twee hoofdcomponenten:

• DeepEncoder (Vision Tokenizer & Compressor)
• DeepSeek-3B MoE Decoder (Tekstgenerator)

Bron: DeepSeek-OCR: Contexts Optical Compression

1. Voorbewerking van invoerafbeelding: De pipeline begint met een documentafbeelding, zoals een gescand contract, handgeschreven notitie, financiële tabel, enz. Deze afbeelding wordt opgesplitst in een raster van 16x16 pixel patches als de kleinste visuele woorden die het model begrijpt.

2. DeepEncoder: DeepEncoder is een meertraps visie-engine die is ontworpen om resolutie, geheugengebruik en informatiecompressie in balans te brengen. Het werkt in drie hoofd fasen:

• SAM (Segment Anything Model, 80M params): Verzorgt lokale attentie door kleine, overlappende patches te analyseren om fijne details en lay-out vast te leggen.
• Convolutionele compressor (16x downsample): Dit vermindert het aantal vision-tokens drastisch door lokale features te comprimeren, zodat er minder tokens de dure globale attentiefase bereiken.
• CLIP ViT: Een vision transformer (300M params) die globale attentie toepast om de algemene structuur en context van het document te begrijpen, en fungeert als embedding-laag voor de gecomprimeerde tokens.

3. Van vision-tokens naar tekst: De MoE-decoder comprimeert vision-tokens die worden doorgegeven aan de DeepSeek-3B MoE (Mixture-of-Experts) decoder voor efficiënte inferentie, waarbij per sample alleen de meest relevante experts worden geactiveerd. Dit verlaagt de rekencapaciteit zonder in te boeten op nauwkeurigheid.

4. Prompt-gestuurde flexibiliteit: Het systeem stuurt het uitvoerformaat (Markdown, HTML-tabellen, SMILES-chemische formules, meertalige lay-outs, enz.) aan door simpelweg de prompt te wijzigen, net als bij LLM’s.

DeepSeek-OCR laat zien dat een enkele documentafbeelding kan worden “gecomprimeerd” tot slechts 1/10e van de tokens die voor platte tekst nodig zijn, zonder noemenswaardig verlies aan nauwkeurigheid. 

DeepSeek OCR-demo: Gradio-applicatie

In deze sectie zetten we een complete Gradio webapp op voor DeepSeek-OCR om OCR direct in je browser of Google Colab te draaien. Met een paar stappen kun je afbeeldingen van grafieken, tabellen, handgeschreven notities, memes, wiskunde en meertalige tekst uploaden en een gestructureerde output met bounding boxes krijgen.

Stap 1: Vereisten

Zorg voordat je begint dat de volgende vereisten aanwezig zijn:

!pip install -q "transformers==4.46.3" "tokenizers==0.20.3" einops addict easydict pillow gradioMogelijk gemaakt door

Bovenstaand commando installeert alle benodigde Python-bibliotheken voor DeepSeek-OCR en Gradio, inclusief de nieuwste compatibele versies van transformers, tokenizers, beeldverwerking (pillow) en de Gradio UI-toolkit. 

Let op: Deze code draait op een L4 GPU met High RAM op Google Colab.

Stap 2: Imports

Nu hebben we alle dependencies geïnstalleerd. Vervolgens zetten we onze imports klaar.

import os, time, torch, gradio as gr
from PIL import Image
from transformers import AutoModel, AutoTokenizer
from datetime import datetime
import random
import stringMogelijk gemaakt door

We importeren alle essentiële Python-modules voor file I/O, modelinference (torch), UI-bouw (gradio), beeldverwerking (PIL) en hulpfuncties voor het beheren van paden en willekeurige run-ID’s.

Stap 3: Laad het model

Zodra alle vereiste bibliotheken zijn geïnstalleerd, kun je het DeepSeek-OCR-model van Hugging Face laden. Voor toegang tot bepaalde modellen is echter authenticatie met een Hugging Face access token nodig.

Zo stel je je Hugging Face access token in op Google Colab:

• Voeg een secret toe in Colab: Klik in je Google Colab-notebook op het sleutelpictogram (“Secrets”) in de linkerzijbalk en kies “Add a Secret.”
• Maak een token aan op Hugging Face: Log in op je Hugging Face-account, ga naar je accountinstellingen en zoek de sectie “Access Tokens”. Klik op “Create new token”, kies de juiste rol (meestal “Read”) en genereer je token.
• Kopieer en plak het token: Kopieer je nieuwe access token en plak dit in het Colab-veld “Add a Secret”. Zo kan je notebook veilig toegang krijgen tot het DeepSeek-OCR-model.

Nu ben je klaar om te authenticeren en verder te gaan met het laden van het model!

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()Mogelijk gemaakt door

De bovenstaande code laadt het officiële DeepSeek-OCR-model en de tokenizer rechtstreeks van Hugging Face. Vervolgens wordt de compatibiliteit van de tokenizer gewaarborgd door de pad-token in te stellen en wordt het model geladen in bfloat16-formaat.

Stap 4: Helferfunctie

Nu het model klaar is, maken we voor elke modeloutput een nieuwe map om elke OCR-run geordend te houden. Zo worden de geëxtraheerde tekst, bounding box-visualisaties en logbestanden opgeslagen en worden eerdere resultaten nooit overschreven.

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 pathMogelijk gemaakt door

De functie new_run_dir maakt voor elke verwerkingsrun van een afbeelding een unieke outputmap aan, gebaseerd op de huidige timestamp en een willekeurig achtervoegsel. Dit voorkomt overschrijven tussen runs en helpt de outputbestanden te organiseren voor inspectie of debugging.

Stap 5: OCR-handler

Deze stap is onze hoofdmotor voor de DeepSeek-OCR Gradio-app. Het begint met het converteren van de geüploade afbeelding naar het juiste formaat en het resizen als het bestand te groot is. Elke keer dat we het model draaien, worden alle outputs in een nieuwe map opgeslagen.

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_imgMogelijk gemaakt door

De functie gr_ocr omvat de voorbewerking, inferentie en nabewerking voor de Gradio-applicatie van DeepSeek-OCR. Ze voert het volgende uit:

• Standaardisatie en voorbewerking van afbeeldingen: De functie converteert eerst elke invoerafbeelding naar de RGB-kleurruimte om compatibiliteit met het model te garanderen. Als de afbeelding een maximale afmeting (2000px) overschrijdt, wordt deze proportioneel verkleind om GPU-geheugentekort te voorkomen.
• Run-directorybeheer: Elke OCR-run is geïsoleerd in een unieke map. Dit maakt traceerbaarheid mogelijk, cruciaal voor batchverwerking, debugging en reproduceerbaarheid.
• Efficiënte modelinference: Het model wordt aangeroepen binnen een torch.inference_mode()-context om te garanderen dat er geen gradiëntberekeningen plaatsvinden, wat het geheugenverbruik vermindert en de snelheid verhoogt.
• Randgevallen en foutafhandeling: De functie behandelt ook uitzonderingen zoals ZeroDivisionError bij zeldzame randgevallen in tokencompressie zonder de gebruikerservaring te verstoren.
• Resultaataggregatie en visualisatie: Na de inferentie laadt de functie de geëxtraheerde tekst en een visuele overlay-afbeelding met gemarkeerde bounding boxes voor eenvoudige inspectie.
• UI-integratie: De functie retourneert ten slotte een tuple met de OCR-uitvoer, verwerkingsstatistieken en de geannoteerde afbeelding voor naadloze integratie in de Gradio-interface.

Laten we doorgaan naar onze interactieve UI en DeepSeek-OCR in actie zien.

Stap 6: Gradio-UI

In de laatste stap definiëren we een interactieve Gradio-interface voor DeepSeek-OCR, waarmee gebruikers eenvoudig afbeeldingen kunnen uploaden, verschillende OCR-modi kunnen kiezen, geavanceerde instellingen kunnen aanpassen en de uitvoer kunnen bekijken binnen één webgebaseerde UI.

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)Mogelijk gemaakt door

Laten we deze code in subsecties begrijpen:

• Demomodi en prompts: De DEMO_MODES-dictionary omvat alle belangrijke OCR-mogelijkheden die DeepSeek-OCR ondersteunt, zoals "Document to Markdown", "Chart Deep Parsing", "Chemical Formula Recognition" en meer. Elke modus bevat een standaardprompt, beschrijving en aanbevolen beeldverwerkingsparameters, zodat gebruikers on-the-fly van extractietaak kunnen wisselen.
• Blokarchitectuur: De UI is opgebouwd met Gradio’s high-level Blocks-API. De interface is verdeeld in twee hoofdkolommen: een invoerpaneel waarmee gebruikers een afbeelding kunnen uploaden, de OCR-modus kiezen en geavanceerde parameters zoals afbeeldingsgrootte en crop-modus fijn afstellen. Het uitvoerpaneel toont de geëxtraheerde OCR-inhoud, inferentiestatistieken en een geannoteerde afbeelding met bounding boxes rond gedetecteerde regio’s.
• Dynamische UI-besturingselementen: De app bevat ook radioknoppen, sliders, selectievakjes en tekstvakken die automatisch worden aangepast op basis van gebruikersinvoer en de gekozen demomodus, wat de bruikbaarheid verbetert en handmatige configuratie minimaliseert.
• Inferentietrigger en resultaten: Bij het klikken op de knop Process Image wordt de hoofdhandler gr_ocr aangeroepen met alle huidige UI-selecties als argumenten. De output wordt daarna direct getoond in het uitvoerpaneel.

Let op: Mogelijk moet je de sessie in Google Colab herstarten als er nog steeds output van de vorige invoer wordt teruggegeven.

Nu onze Gradio-applicatie staat, laten we DeepSeek-OCR testen met een reeks praktische voorbeelden.

DeepSeek OCR App Voorbeeld 1: Chart Deep Parsing

Binnen de DeepSeek-OCR Gradio-demo wilde ik zien hoe goed het model tabeldata uit grafieken kan extraheren. Dit blijft uitdagend voor de meeste OCR- en visiemodellen.

Ik probeerde twee klassieke testcases:

• Een Statista-achtige staafgrafiek en
• Een complexe technische analysegrafiek vol “BUY/SELL”-signalen en numerieke overlays

DeepSeek-OCR gaf voor elke grafiek een HTML-tabel terug, met cellen die overeenkwamen met categorieën, waarden en labels die het in de afbeelding vond.

Wat goed werkte: Het model ving alle zichtbare tekst en structuur in de grafiek, en de output was in HTML-tabelindeling, wat machine-leesbaar is en de tabellogica bewaart. Het verwerkte zelfs complexe financiële grafieken en probeerde elk getal en label te tabeleren.

Waar het moeite mee had: De ruwe output was erg uitvoerig, met veel <td>- en <tr>-tags, wat het lastig maakte om in één oogopslag te interpreteren. In complexe grafieken dubbelde het model soms items of raakte het de hogere visuele structuur kwijt, met als resultaat een overweldigende tabel vol herhaalde "BUY"/"SELL"-signalen en waarden.

Voor praktijkscenario’s wil je de HTML nabewerken voor leesbaarheid of importeren in Excel of Pandas.

De grafiekparsing van DeepSeek-OCR is een slimme functie voor grafiekdigitalisering, maar de HTML-zware output is het meest geschikt voor downstream datapijplijnen of verdere parsing, niet voor snelle menselijke beoordeling.

Voorbeeld 2: Extractie van chemische formules

Voor mijn volgende test wilde ik zien hoe goed DeepSeek-OCR chemische informatie uit gestructureerde afbeeldingen kan halen. De chemische-extractiemodus van het model is ontworpen om zowel tabelvormige chemische data als grafische molecuulstructuren om te zetten naar machineleesbare formaten zoals HTML-tabellen en SMILES-notatie.

Ik uploadde twee soorten afbeeldingen voor dit experiment, en dit is wat ik samenvatte:

• Extractie van tekstuele formules: In dit voorbeeld transcribeerde het model chemische namen en hun molecuulformules (zoals “Glucose: C₆H₁₂O₆”, “Butaan: C₄H₁₀”) accuraat. De output werd echter geformatteerd als ruwe HTML-tabelcode, wat, hoewel gestructureerd, wat lastig was om snel te lezen. De conversie van afbeelding naar tabel was snel en redelijk nauwkeurig voor platte tekst.

• Herkenning van molecuulstructuren: Voor afbeeldingen met chemische diagrammen probeerde DeepSeek-OCR de bijbehorende SMILES-strings te extraheren. Zo genereerde het een SMILES-uitvoer voor ethaan en propaan. Hoewel het herkende dat dit chemische structuren waren, waren de gegenereerde SMILES-strings niet altijd chemisch geldig, wat wijst op beperkingen bij het parsen van complexere moleculaire afbeeldingen.

Al met al biedt de chemische formule-extractie een snelle manier om chemische data te digitaliseren en molecuulherkenning te proberen, maar verdere verfijning is nodig voor betrouwbare chemische parsing, vooral bij complexe structuren.

Voorbeeld 3: Handgeschreven tekst OCR

Vervolgens wilde ik zien hoe goed DeepSeek-OCR handgeschreven notities aankan, een klassieke uitdaging voor OCR-systemen, zeker wanneer het handschrift gestileerd is of van grootte varieert. 

Ik uploadde een afbeelding van een handgeschreven chemielijst met verbindingnamen op gelinieerd papier. Na verwerking extraheerde de modus Document to Markdown de tekst en behield de structuur verrassend goed. Het herkende de kop en zette elke verbinding op een eigen regel, precies zoals in de originele afbeelding. De bounding boxes bevestigden visueel dat het model elke regel correct identificeerde en de afzonderlijke tekstblokken scheidde.

Dit resultaat laat zien dat het model handgeschreven content kan transcriberen naar digitale tekst. Hoewel enkele kleine opmaakdetails verloren kunnen gaan, was de algehele extractie in dit voorbeeld zeer nauwkeurig.

Voorbeeld 4: Extractie van vergelijkingen

Een andere standaardtest voor OCR is het lezen en correct interpreteren van wiskundige vergelijkingen in gangbare leerboeknotatie. Voor dit experiment uploadde ik een afbeelding met enkele complexe vergelijkingen in LaTeX-achtige lettertypes om te beoordelen of het model deze niet alleen kan detecteren, maar ook accuraat kan extraheren en formatteren.

DeepSeek-OCR detecteerde met succes alle vier de vergelijkingen in de afbeelding en extraheerde ze als LaTeX-strings. De herkende uitvoer was netjes gestructureerd, met elke vergelijking op een eigen regel in standaard LaTeX-formaat. 

De bounding boxes lagen ook (ongeveer) correct over de originele afbeelding, wat aantoont dat het model individuele wiskundige expressies nauwkeurig kan lokaliseren en segmenteren.

Opvallend was dat de geëxtraheerde content de wiskundige structuur behield met commando’s zoals \frac voor breuken en correcte variabeleopmaak, waardoor het resultaat direct herbruikbaar is voor documentatie. 

Voorbeeld 5: Tabelextractie

Een van de meest voorkomende en waardevolle OCR-taken is het extraheren van tabeldata uit documentafbeeldingen, vooral bij gescande rapporten, papers of datasets. Om het vermogen van DeepSeek-OCR op dit vlak te beoordelen, uploadde ik een afbeelding met een gestructureerde economische vergelijkende tabel over meerdere landen.

Na het kiezen van de modus "Chart Deep Parsing" en het verwerken van de afbeelding, probeerde DeepSeek-OCR de visuele tabel om te zetten naar een HTML-tabelstructuur. De geëxtraheerde content (rechts) bevat een reeks <table>- en <td>-tags die de tabelrijen en -kolommen als platte tekst weergeven. De bounding box-uitvoer bevestigde bovendien dat het model het hoofdtablgebied in de afbeelding correct identificeerde en segmenteerde.

Het model toont betrouwbare extractie voor eenvoudige tabellen, al kan nabewerking nodig zijn omdat het uitvoerformaat (ruwe HTML) minder gebruiksvriendelijk is voor snelle beoordeling of verdere data-analyse.

Voorbeeld 6: OCR op memes

Voor dit voorbeeld wilde ik testen hoe het model tekstextractie uit populaire meme-afbeeldingen afhandelt. Dit is een praktijkscenario waarin tekst vaak over complexe achtergronden staat, verschillende lettertypes gebruikt en niet altijd typische documentstructuren volgt.

Ik uploadde een klassieke meme met grote, witte, gecapitonneerde tekst over een filmscène (Leonardo DiCaprio in Django Unchained) en draaide de Document to Markdown-extractiemodus.

Bron: Media.io

De OCR-resultaten voor deze meme waren opvallend robuust. Het wist alle relevante woorden in de juiste volgorde vast te leggen, zonder spelfouten te introduceren of tekst over te slaan, zelfs met de complexe achtergrond. 

Hoewel er geen structurele markup is, is de extractie zeer bruikbaar voor downstream taken zoals meme-sentimentanalyse, contentmoderatie of tekstgebaseerde memesearch.

Voorbeeld 7: Meertalige OCR

Een van de unieke krachten van DeepSeek-OCR is de ondersteuning voor meertalige tekstextractie, wat vooral nuttig is voor documenten of afbeeldingen met een mix van wereldtalen. 

Ik testte deze capaciteit met verschillende samples, waaronder een echte straatfoto met Chinese tekst en een synthetisch voorbeeld met een mix van Chinese, Japanse en Koreaanse zinnen.

Bron: DeepSeek OCR Hugging Face

Bij het verwerken van deze meertalige samples kon de document-naar-Markdown-modus van DeepSeek-OCR niet-Engelse schriften accuraat detecteren en extraheren. Voor de straatfoto identificeerde en gaf het model de volledige alinea Chinese tekst terug. 

Voor het gemengde taalvoorbeeld scheidde en labelde het correct de Chinese, Japanse en Koreaanse secties, met behoud van hun opmaak en tekstblokken. De bounding box-overlays toonden ook een nauwkeurige detectie van de tekstdelen per taal.

Er zijn echter twee belangrijke kanttekeningen:

• Verwerkingssnelheid: Meertalige OCR is aanzienlijk trager dan eentalige Engelse of tabelextractietaken. Mijn tests lieten een veel langere verwerkingstijd zien, waarschijnlijk door de extra complexiteit in schrift-detectie en decodering.
• Af en toe fouten: Soms bevat de geëxtraheerde output redundante tokens of onjuist geformatteerde tekst.

Ondanks deze kleine issues levert DeepSeek-OCR sterke meertalige OCR-capaciteiten die gemengde schriften en foto’s uit de echte wereld betrouwbaar aankunnen.

DeepSeek-OCR: slotgedachten

DeepSeek-OCR overbrugt de kloof tussen klassieke OCR en moderne multimodale LLM’s. De grootste winst is veelzijdigheid: je krijgt één pipeline die gescande documenten leest, complexe tabellen en grafieken extraheert, vergelijkingen en chemische structuren begrijpt en zelfs werkt met memes, handschrift en tientallen talen.

Dat gezegd hebbende, DeepSeek-OCR is niet foutloos. Grafiek- en tabelexporten kunnen overdreven uitvoerig zijn, herkenning van chemische structuren schiet soms tekort en meertalige verwerking kan merkbaar traag zijn. Complexe visuele lay-outs vergen mogelijk nabewerking voor direct gebruik.

Maar voor onderzoek, academische workflows, snelle prototyping en iedereen die geavanceerde OCR nodig heeft voorbij platte tekst, voelt DeepSeek-OCR nu al als een serieuze upgrade ten opzichte van legacytools. 

Als je meer wilt leren over het DeepSeek-ecosysteem, raad ik aan om de cursus Working with DeepSeek in Python te bekijken.