DeepSeek-OCR: Ein praxisnaher Guide mit 7 Beispielen

DeepSeek-OCR ist ein neues großes Vision-Language-Modell, das Struktur versteht, Tabellen parst, Diagramme extrahiert und sogar Mathe, Memes und mehrere Sprachen meistert.

In diesem Guide teste ich DeepSeek-OCR Ende-zu-Ende an realen Aufgaben — von handschriftlichen Notizen bis hin zu komplexen Diagrammen, Memes und mehrsprachigen Dokumenten. Wir gehen durch:

• Diagramm- und Tabellenextraktion
• Chemie- und Formelauswertung
• Erkennung handschriftlicher Texte
• Gleichungen und Markdown-Ausgabe
• OCR für Memes und Social-Images
• Mehrsprachiges Dokumentverständnis

Am Ende siehst du, wo DeepSeek-OCR glänzt und wo es noch hakt. Wenn du Open-Source-OCR evaluierst, solltest du diese Experimente kennen, bevor du deine Pipeline festlegst. Schau dir dazu auch unser DeepSeek V3.2-Speciale Tutorial an.

Was ist DeepSeek-OCR?

DeepSeek-OCR ist ein Vision-Language-Modell mit 3B Parametern, trainiert für Dokumentverständnis. Es nutzt kontextuelle optische Kompression, indem große 2D-Visualkontexte in komprimierte Vision-Tokens abgebildet werden, sodass riesige Dokumente effizient verarbeitet werden können.

Zu den wichtigsten Features zählen:

• Lesen großer gescannter Dokumente, Quittungen, Rechnungen, Forschungsartikel usw.
• Parsen von Tabellen, Diagrammen und geometrischen Figuren.
• Verarbeitung mehrsprachiger und handschriftlicher Texte.

Wie funktioniert DeepSeek-OCR?

DeepSeek-OCR ist darauf ausgelegt, eine breite Vielfalt an Dokumentbildern zu verarbeiten — von Diagrammen und Tabellen bis hin zu Handschrift, Mathematik und mehrsprachigem Text. Anstatt Bilder und Text als getrennte Domänen zu behandeln, nutzt es die visuelle Modalität als Kompressions-Engine für lange Texte und ermöglicht es so Large Language Models (LLMs), deutlich mehr Informationen mit erheblich weniger Tokens zu verarbeiten. Schauen wir uns die Architektur und die Besonderheiten an:

Die End-to-End-Pipeline: Encoder bis Decoder

Auf hoher Ebene besteht DeepSeek-OCR aus zwei Hauptkomponenten:

• DeepEncoder (Vision-Tokenizer & -Kompressor)
• DeepSeek-3B MoE Decoder (Textgenerator)

Quelle: DeepSeek-OCR: Contexts Optical Compression

1. Vorverarbeitung des Eingabebilds: Die Pipeline startet mit einem Dokumentbild, z. B. einem gescannten Vertrag, einer handschriftlichen Notiz, einer Finanztabelle usw. Dieses Bild wird in ein Raster aus 16×16-Pixel-Patches aufgeteilt — die kleinsten visuellen „Wörter“, die das Modell versteht.

2. DeepEncoder: Der DeepEncoder ist eine mehrstufige Vision-Engine, die Auflösung, Speicherbedarf und Informationskompression ausbalanciert. Er arbeitet in drei Hauptphasen:

• SAM (Segment Anything Model, 80M Parameter): Sorgt für lokale Attention, indem kleine, überlappende Patches analysiert werden, um feine Details und Layout zu erfassen.
• Konvolutionaler Kompressor (16× Downsampling): Reduziert die Anzahl der Vision-Tokens drastisch, indem lokale Merkmale komprimiert werden, sodass weniger Tokens die teure globale Attention-Phase erreichen.
• CLIP ViT: Ein Vision-Transformer (300M Parameter), der globale Attention anwendet, um die Gesamtstruktur und den Kontext des Dokuments zu verstehen und als Embedding-Layer für die komprimierten Tokens dient.

3. Von Vision-Tokens zu Text: Der MoE-Decoder komprimiert Vision-Tokens, die in den DeepSeek-3B-MoE-Decoder (Mixture-of-Experts) eingespeist werden. Dabei werden pro Beispiel nur die relevantesten Experten aktiviert, was die Rechenkosten senkt, ohne Genauigkeit einzubüßen.

4. Prompt-gesteuerte Flexibilität: Das System steuert das Ausgabeformat (Markdown, HTML-Tabellen, SMILES-Chemieformeln, mehrsprachige Layouts usw.) einfach über den Prompt — ähnlich wie bei LLMs.

DeepSeek-OCR zeigt, dass sich ein einzelnes Dokumentbild auf bis zu ein Zehntel der Tokens gegenüber reinem Text „komprimieren“ lässt, ohne nennenswerte Genauigkeitseinbußen. 

DeepSeek OCR Demo: Gradio-Anwendung

In diesem Abschnitt richten wir eine vollständige Gradio Web-App für DeepSeek-OCR ein, um OCR direkt im Browser oder in Google Colab auszuführen. Mit nur wenigen Schritten lädst du Bilder von Diagrammen, Tabellen, Handschrift, Memes, Mathematik oder mehrsprachigem Text hoch und erhältst eine strukturierte Ausgabe mit Bounding Boxes.

Schritt 1: Voraussetzungen

Bevor du startest, stelle Folgendes sicher:

!pip install -q "transformers==4.46.3" "tokenizers==0.20.3" einops addict easydict pillow gradioBereitgestellt von

Der obige Befehl installiert alle benötigten Python-Bibliotheken für DeepSeek-OCR und Gradio, inklusive der neuesten kompatiblen Versionen von transformers, tokenizers, Bildverarbeitung (pillow) und dem Gradio-UI-Toolkit. 

Hinweis: Dieser Code läuft auf einer L4 GPU mit High RAM in Google Colab.

Schritt 2: Imports

Jetzt sind alle Abhängigkeiten installiert. Als Nächstes richten wir die Imports ein.

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

Wir importieren alle zentralen Python-Module für Datei-I/O, Modellinferenz (torch), UI-Aufbau (gradio), Bildverarbeitung (PIL) sowie Utility-Funktionen für Dateipfade und zufällige Run-IDs.

Schritt 3: Modell laden

Sobald alle Bibliotheken installiert sind, kannst du das DeepSeek-OCR-Modell von Hugging Face laden. Der Zugriff auf bestimmte Modelle erfordert jedoch eine Authentifizierung mit einem Hugging Face Access Token.

So richtest du dein Hugging Face Access Token in Google Colab ein:

• Secret in Colab hinzufügen: Klicke in deinem Colab-Notebook auf das Schlüsselsymbol („Secrets“) in der linken Seitenleiste und wähle „Add a Secret“.
• Token auf Hugging Face erstellen: Melde dich bei Hugging Face an, gehe zu den Kontoeinstellungen und finde den Bereich „Access Tokens“. Klicke auf „Create new token“, wähle die passende Rolle (meist „Read“) und generiere dein Token.
• Token kopieren und einfügen: Kopiere dein neues Access Token und füge es in das Colab-Feld „Add a Secret“ ein. So kann dein Notebook sicher auf das DeepSeek-OCR-Modell zugreifen.

Jetzt kannst du authentifizieren und mit dem Laden des Modells fortfahren!

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()Bereitgestellt von

Der obige Code lädt das offizielle DeepSeek-OCR-Modell und den Tokenizer direkt von Hugging Face. Anschließend wird die Tokenizer-Kompatibilität durch Setzen des Pad-Tokens sichergestellt und das Modell im bfloat16-Format geladen.

Schritt 4: Helper-Funktion

Jetzt ist das Modell einsatzbereit. Als Nächstes erstellen wir für jede Modellausgabe ein neues Verzeichnis, um jeden OCR-Lauf sauber zu organisieren. So werden extrahierter Text, Visualisierungen der Bounding Boxes und Logfiles gespeichert, ohne frühere Ergebnisse zu überschreiben.

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 pathBereitgestellt von

Die Funktion new_run_dir erzeugt für jeden Verarbeitungslauf ein eindeutiges Ausgabeverzeichnis, basierend auf Zeitstempel und zufälligem Suffix. So werden Ergebnisse nicht überschrieben und Ausgaben bleiben übersichtlich für Inspektion oder Debugging.

Schritt 5: OCR-Handler

Dieser Schritt ist der Motor der DeepSeek-OCR-Gradio-App. Er konvertiert das hochgeladene Bild ins richtige Format, skaliert es bei Bedarf herunter und speichert alle Ausgaben jedes Laufs in einem neuen Ordner.

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_imgBereitgestellt von

Die Funktion gr_ocr kapselt die Vorverarbeitung, Inferenz und Nachverarbeitung für die Gradio-Anwendung von DeepSeek-OCR. Sie übernimmt:

• Bildstandardisierung und -vorverarbeitung: Konvertiert Eingabebilder in den RGB-Farbraum. Überschreitet das Bild 2000px in einer Dimension, wird es proportional verkleinert, um GPU-Speicher zu schonen.
• Run-Verzeichnisverwaltung: Jeder OCR-Lauf ist in einem eindeutigen Verzeichnis isoliert. Das ermöglicht Nachvollziehbarkeit für Batch-Verarbeitung, Debugging und Reproduzierbarkeit.
• Effiziente Modellerkennung: Das Modell läuft in torch.inference_mode(), um Gradienten zu vermeiden, Speicher zu sparen und die Inferenz zu beschleunigen.
• Edge-Case- und Fehlerbehandlung: Fängt Ausnahmen wie ZeroDivisionError bei seltenen Fällen in der Token-Kompression ab, ohne das Nutzererlebnis zu stören.
• Aggregation und Visualisierung der Ergebnisse: Lädt nach der Inferenz den extrahierten Text und eine Bildüberlagerung mit Bounding Boxes zur schnellen Prüfung.
• UI-Integration: Gibt ein Tupel aus OCR-Ausgabe, Verarbeitungsstatistiken und annotiertem Bild zurück — perfekt integriert in die Gradio-Oberfläche.

Weiter geht’s mit der interaktiven UI — und DeepSeek-OCR in Aktion.

Schritt 6: Gradio-UI

Im letzten Schritt definieren wir eine interaktive Gradio-Oberfläche für DeepSeek-OCR. So können Nutzer Bilder hochladen, verschiedene OCR-Modi wählen, erweiterte Einstellungen anpassen und alle Ausgaben in einer webbasierten UI sehen.

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)Bereitgestellt von

Das gliedern wir wie folgt auf:

• Demo-Modi und Prompts: Das Dictionary DEMO_MODES bündelt alle wesentlichen OCR-Fähigkeiten von DeepSeek-OCR, z. B. „Document to Markdown“, „Chart Deep Parsing“, „Chemical Formula Recognition“ und mehr. Jeder Modus enthält einen Standard-Prompt, eine Beschreibung und empfohlene Bildparameter, damit sich Aufgaben flexibel umschalten lassen.
• Block-Architektur: Die UI wird mit der High-Level-API Blocks von Gradio aufgebaut. Die Oberfläche ist in zwei Spalten geteilt: ein Input-Panel zum Hochladen des Bilds, zur Moduswahl und zum Feintuning von Parametern wie Bildgröße und Crop-Mode. Das Output-Panel zeigt den extrahierten Inhalt, Inferenz-Statistiken und ein annotiertes Bild mit Bounding Boxes.
• Dynamische UI-Controls: Radio-Buttons, Slider, Checkboxen und Textfelder passen sich automatisch an Nutzerwahl und Demo-Modus an. Das erhöht die Usability und reduziert manuelle Konfiguration.
• Inferenz-Auslösung und Ergebnisse: Beim Klick auf Process Image wird der Haupt-Handler gr_ocr mit allen aktuellen UI-Einstellungen aufgerufen. Die Ausgaben werden direkt im Output-Panel dargestellt.

Hinweis: Eventuell musst du die Colab-Session neu starten, falls weiterhin Ausgaben vom vorherigen Input erscheinen.

Jetzt, da unsere Gradio-App steht, testen wir DeepSeek-OCR mit einer Reihe praktischer Beispiele.

DeepSeek OCR App Beispiel 1: Chart Deep Parsing

In der Gradio-Demo wollte ich prüfen, wie gut das Modell Tabellendaten aus Diagrammen extrahiert. Das ist für die meisten OCR- und Vision-Modelle noch immer anspruchsvoll.

Ich habe zwei klassische Testfälle gewählt:

• Ein Statista-ähnliches Balkendiagramm und
• Ein komplexes Technical-Analysis-Chart voller „BUY/SELL“-Signale und Zahl-Overlays

DeepSeek-OCR gab für jedes Diagramm eine HTML-Tabelle zurück, mit Zellen für Kategorien, Werte und Labels, die es im Bild gefunden hat.

Was gut funktionierte: Das Modell erfasste allen sichtbaren Text und die Struktur im Diagramm, und die Ausgabe war als HTML-Tabelle formatiert, maschinenlesbar und logisch konsistent. Es verarbeitete sogar komplexe Finanzcharts und versuchte, jede Zahl und jedes Label zu tabellieren.

Wobei es hakte: Die Rohausgabe war sehr ausführlich mit vielen <td>- und <tr>-Tags, was die schnelle Interpretation erschwert. In komplexen Charts kam es teils zu Duplikaten oder Verlust der übergeordneten visuellen Struktur — die Folge waren überbordende Tabellen mit wiederholten „BUY“/„SELL“-Signalen und Werten.

Für Produktions-Workflows solltest du das HTML nachbearbeiten oder in Excel bzw. Pandas importieren.

Das Chart-Parsing von DeepSeek-OCR ist ein smarter Schritt zur Diagrammdigitalisierung, doch die HTML-lastige Ausgabe eignet sich eher für nachgelagerte Datenpipelines oder weiteres Parsing als zur schnellen menschlichen Sichtprüfung.

Beispiel 2: Chemische Formelextraktion

Im nächsten Test wollte ich sehen, wie gut DeepSeek-OCR chemische Informationen aus strukturierten Bildern extrahiert. Der Chemie-Modus soll sowohl tabellarische Chemiedaten als auch grafische Molekülstrukturen in maschinenlesbare Formate wie HTML-Tabellen und SMILES umwandeln.

Ich habe zwei Bildtypen hochgeladen, und folgendes ergab sich:

• Textuelle Formelextraktion: Hier transkribierte das Modell chemische Namen und Summenformeln korrekt (z. B. „Glucose: C₆H₁₂O₆“, „Butan: C₄H₁₀“). Die Ausgabe war jedoch als Roh-HTML-Tabelle formatiert, was strukturiert, aber auf den ersten Blick schwerer zu lesen ist. Die Umwandlung von Bild zu Tabelle war für reinen Text schnell und recht genau.

• Erkennung von Molekülstrukturen: Bei chemischen Diagrammen versuchte DeepSeek-OCR, die entsprechenden SMILES-Strings zu extrahieren. So erzeugte es etwa SMILES-Ausgaben für Ethan und Propan. Obwohl es die Strukturen als solche erkannte, waren die SMILES nicht immer chemisch gültig — ein Hinweis auf Grenzen bei komplexeren Molekülbildern.

Unterm Strich ermöglicht die chemische Extraktion eine schnelle Digitalisierung von Chemiedaten und einen Versuch der Molekülstruktur-Erkennung, benötigt aber für zuverlässiges chemisches Parsing — gerade bei komplexen Strukturen — noch Feinschliff.

Beispiel 3: Handschrift-OCR

Als Nächstes habe ich geprüft, wie gut DeepSeek-OCR mit handschriftlichen Notizen zurechtkommt — eine klassische OCR-Herausforderung, vor allem bei stilisierter oder variierender Schrift.

Ich habe ein Bild einer handschriftlichen Chemie-Liste mit Substanznamen auf liniertem Papier hochgeladen. Im Modus Document to Markdown extrahierte das Modell den Text und bewahrte die Struktur überraschend gut. Überschrift und jede Verbindung wurden zeilenweise erkannt, wie im Originalbild. Die Bounding Boxes bestätigten visuell die korrekte Segmentierung.

Das Ergebnis zeigt die Fähigkeit des Modells, Handschrift in digitalen Text zu überführen. Einige kleinere Formatdetails können verloren gehen, insgesamt war die Extraktion in diesem Beispiel jedoch sehr genau.

Beispiel 4: Gleichungsextraktion

Ein weiterer Standardtest ist das Erkennen und korrekte Interpretieren mathematischer Gleichungen in typischer Lehrbuchnotation. Ich habe ein Bild mit komplexeren Gleichungen in LaTeX-ähnlicher Schrift hochgeladen, um zu prüfen, ob das Modell diese nicht nur erkennt, sondern auch korrekt extrahiert und formatiert.

DeepSeek-OCR erkannte alle vier Gleichungen im Bild und extrahierte sie als LaTeX-Strings. Die Ausgabe war sauber strukturiert, jede Gleichung stand in klassischem LaTeX-Format in einer eigenen Zeile. 

Die Bounding Boxes lagen (annähernd) korrekt über dem Original und zeigten, dass das Modell mathematische Ausdrücke genau lokalisieren und segmentieren kann.

Auffällig war, dass die mathematische Struktur mit Befehlen wie \frac für Brüche und sauberer Variablenformatierung erhalten blieb — ideal zur direkten Weiterverwendung in Dokumentationen. 

Beispiel 5: Tabellenextraktion

Eine der häufigsten und wertvollsten OCR-Aufgaben ist die Extraktion tabellarischer Daten aus Dokumentbildern, insbesondere bei gescannten Berichten, Papers oder Datensätzen. Zur Bewertung habe ich ein Bild mit einer strukturierten volkswirtschaftlichen Vergleichstabelle über mehrere Länder hochgeladen.

Im Modus „Chart Deep Parsing“ versuchte DeepSeek-OCR, die visuelle Tabelle in HTML zu überführen. Die extrahierten Inhalte (rechts) enthalten <table>- und <td>-Tags, die Zeilen und Spalten als Klartext abbilden. Die Bounding Boxes bestätigten die korrekte Identifikation und Segmentierung des Tabellenbereichs.

Für einfache Tabellen ist die Extraktion zuverlässig. Zur schnellen Sichtprüfung oder für Analysen ist jedoch oft Nachbearbeitung nötig, da das Roh-HTML wenig nutzerfreundlich ist.

Beispiel 6: OCR auf Memes

Hier wollte ich testen, wie das Modell Text aus gängigen Meme-Bildern extrahiert. Ein realitätsnahes Szenario, da Text oft auf komplexe Hintergründe gelegt wird, stark variiert und selten klassischen Dokumentstrukturen folgt.

Ich habe ein klassisches Meme mit großer weißer Versal-Schrift über einer Filmszene (Leonardo DiCaprio in Django Unchained) hochgeladen und den Modus Document to Markdown verwendet.

Quelle: Media.io

Das OCR-Ergebnis war überraschend robust. Alle relevanten Wörter wurden in korrekter Reihenfolge erfasst, ohne Rechtschreibfehler oder Auslassungen — trotz komplexem Hintergrund. 

Auch ohne strukturelles Markup ist die Extraktion sehr gut nutzbar für nachgelagerte Aufgaben wie Meme-Stimmungsanalyse, Content-Moderation oder textbasierte Meme-Suche.

Beispiel 7: Mehrsprachige OCR

Eine der Stärken von DeepSeek-OCR ist die Unterstützung für mehrsprachige Texterkennung — besonders nützlich für Dokumente oder Bilder mit gemischten Sprachen.

Ich habe das mit verschiedenen Beispielen getestet, darunter ein Straßenschild mit chinesischem Text sowie ein synthetisches Sample mit gemischtem Chinesisch, Japanisch und Koreanisch.

Quelle: DeepSeek OCR Hugging Face

Im Document-to-Markdown-Modus erkannte DeepSeek-OCR die nicht-lateinischen Schriften sehr zuverlässig. Beim Straßenfoto identifizierte das Modell den gesamten chinesischen Absatz und gab ihn zurück. 

Im gemischten Beispiel trennte und „labelte“ es die chinesischen, japanischen und koreanischen Abschnitte korrekt, inklusive Formatierung und Textblöcken. Die Bounding Boxes zeigten eine präzise Erkennung der jeweiligen Sprachregionen.

Zwei wichtige Hinweise gibt es jedoch:

• Verarbeitungsgeschwindigkeit: Mehrsprachige OCR ist deutlich langsamer als englische Einzelsprache oder Tabellenextraktion. In meinen Tests war die Laufzeit spürbar höher, vermutlich durch die zusätzliche Komplexität bei Skripterkennung und Decoding.
• Gelegentliche Fehler: Manchmal enthält die Ausgabe redundante Tokens oder fehlerhaft formatierten Text.

Trotz dieser kleineren Punkte liefert DeepSeek-OCR starke mehrsprachige OCR-Fähigkeiten, die gemischte Schriften und Realwelt-Fotos zuverlässig handhaben.

DeepSeek-OCR: Fazit

DeepSeek-OCR schlägt eine Brücke zwischen klassischer OCR und modernen multimodalen LLMs. Der größte Pluspunkt ist die Vielseitigkeit: Eine einzige Pipeline liest gescannte Dokumente, extrahiert komplexe Tabellen und Diagramme, versteht Gleichungen und chemische Strukturen und funktioniert sogar mit Memes, Handschrift und Dutzenden Sprachen.

Ganz ohne Schwächen ist es nicht. Diagramm- und Tabellenausgaben können zu wortreich sein, die Erkennung chemischer Strukturen trifft nicht immer ins Schwarze, und mehrsprachige Verarbeitung ist spürbar langsamer. Komplexe visuelle Layouts erfordern teils Nachbearbeitung für die direkte Nutzung.

Für Forschung, akademische Workflows, schnelle Prototypen und alle, die mehr als reine Text-OCR brauchen, fühlt sich DeepSeek-OCR jedoch schon jetzt wie ein deutlicher Sprung gegenüber Legacy-Tools an. 

Wenn du mehr über das DeepSeek-Ökosystem erfahren willst, empfehle ich den Kurs Working with DeepSeek in Python.