DeepSeek-OCR: Panduan Praktis dengan 7 Contoh Nyata

DeepSeek-OCR adalah model visi-bahasa berskala besar baru yang memahami struktur, mem-parsing tabel, mengekstrak bagan, dan bahkan dapat menangani matematika, meme, serta banyak bahasa.

Dalam panduan ini, saya menguji DeepSeek-OCR pada tugas dunia nyata secara end-to-end—mulai dari catatan tulisan tangan hingga bagan kompleks, meme, dan dokumen multibahasa. Kita akan membahas:

• Ekstraksi bagan dan tabel
• Parsing kimia dan rumus
• Pengenalan teks tulisan tangan
• Persamaan dan keluaran Markdown
• OCR untuk meme dan gambar sosial
• Pemahaman dokumen multibahasa

Pada akhirnya, Anda akan melihat di mana DeepSeek-OCR unggul dan di mana ia masih kesulitan. Jika Anda menjajaki OCR open-source, Anda akan ingin melihat eksperimen ini sebelum memilih pipeline Anda. Saya juga merekomendasikan untuk melihat tutorial DeepSeek V3.2-Speciale kami.

Apa Itu DeepSeek-OCR?

DeepSeek-OCR adalah model visi-bahasa terbuka berparameter 3B yang dilatih untuk pemahaman dokumen. Model ini memanfaatkan kompresi optik konteks dengan memetakan konteks visual 2D besar ke dalam token visi terkompresi, sehingga dapat memproses dokumen besar secara efisien.

Beberapa fitur kunci meliputi:

• Membaca dokumen hasil pindai berukuran besar, tanda terima, faktur, makalah riset, dll.
• Mem-parsing tabel, bagan, dan bangun geometri.
• Menangani teks multibahasa dan tulisan tangan.

Bagaimana Cara Kerja DeepSeek-OCR?

DeepSeek-OCR dirancang untuk menangani beragam citra dokumen, dari bagan dan tabel hingga tulisan tangan, matematika, dan teks multibahasa. Alih-alih memperlakukan gambar dan teks sebagai domain terpisah, ia memanfaatkan modalitas visual sebagai mesin kompresi untuk teks panjang, memungkinkan large language models (LLMs) memproses jauh lebih banyak informasi dengan jumlah token yang jauh lebih sedikit. Mari uraikan arsitekturnya dan apa yang membedakannya:

Pipeline end-to-end: Encoder ke decoder

Secara garis besar, DeepSeek-OCR terdiri dari dua komponen utama:

• DeepEncoder (Tokenizer & Kompresor Visi)
• Decoder DeepSeek-3B MoE (Generator Teks)

Sumber: DeepSeek-OCR: Contexts Optical Compression

1. Prapemrosesan citra masukan: Pipeline dimulai dengan citra dokumen, seperti kontrak hasil pindai, catatan tulisan tangan, tabel keuangan, dll. Citra ini dibagi menjadi kisi patch 16x16 piksel sebagai unit visual terkecil yang dipahami model.

2. DeepEncoder: DeepEncoder adalah mesin visi multistage yang dirancang untuk menyeimbangkan resolusi, penggunaan memori, dan kompresi informasi. Ia beroperasi dalam tiga tahap utama:

• SAM (Segment Anything Model, 80M parameter): Menangani atensi lokal dengan menganalisis patch kecil yang saling tumpang tindih untuk menangkap detail halus dan tata letak.
• Kompresor Konvolusional (Downsample 16x): Ini secara drastis mengurangi jumlah token visi dengan mengompresi fitur lokal, sehingga lebih sedikit token yang mencapai tahap atensi global yang mahal.
• CLIP ViT: Merupakan vision transformer (300M parameter) yang menerapkan atensi global untuk memahami struktur dan konteks keseluruhan dokumen, bertindak sebagai lapisan embedding untuk token terkompresi.

3. Token visi ke teks: Decoder MoE mengompresi token visi yang dikirim ke decoder DeepSeek-3B MoE (Mixture-of-Experts) untuk inferensi efisien dengan hanya mengaktifkan pakar yang paling relevan per sampel, mengurangi biaya komputasi tanpa mengorbankan akurasi.

4. Fleksibilitas berbasis prompt: Sistem mengarahkan format keluaran (Markdown, tabel HTML, rumus kimia SMILES, tata letak multibahasa, dll.) cukup dengan mengubah prompt, mirip seperti pada LLM.

DeepSeek-OCR menunjukkan bahwa satu citra dokumen dapat “dikompresi” menjadi hanya 1/10 jumlah token yang dibutuhkan untuk teks polos, tanpa kehilangan akurasi yang berarti. 

Demo DeepSeek OCR: Aplikasi Gradio

Pada bagian ini, kita akan menyiapkan aplikasi web Gradio lengkap untuk DeepSeek-OCR guna menjalankan OCR langsung di browser Anda atau Google Colab. Hanya dengan beberapa langkah, Anda dapat mengunggah gambar bagan, tabel, catatan tulisan tangan, meme, matematika, teks multibahasa, dan mendapatkan keluaran terstruktur dengan bounding box.

Langkah 1: Prasyarat

Sebelum memulai, pastikan prasyarat berikut sudah siap:

!pip install -q "transformers==4.46.3" "tokenizers==0.20.3" einops addict easydict pillow gradioDidukung oleh

Perintah di atas memasang semua pustaka Python yang diperlukan untuk DeepSeek-OCR dan Gradio, termasuk versi kompatibel terbaru dari transformers, tokenizers, pemrosesan gambar (pillow), dan toolkit UI Gradio. 

Catatan: Kode ini berjalan pada GPU L4 dengan RAM Tinggi di Google Colab.

Langkah 2: Impor

Sekarang semua dependensi telah terpasang. Selanjutnya, kita siapkan impor.

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

Kita mengimpor semua modul Python esensial untuk file I/O, inferensi model (torch), pembuatan UI (gradio), penanganan gambar (PIL), serta fungsi utilitas untuk mengelola path file dan ID run acak.

Langkah 3: Memuat model

Setelah semua pustaka yang diperlukan terpasang, Anda siap memuat model DeepSeek-OCR dari Hugging Face. Namun, mengakses model tertentu memerlukan autentikasi dengan access token Hugging Face.

Berikut cara menyiapkan access token Hugging Face Anda di Google Colab:

• Tambahkan secret di Colab: Di notebook Google Colab Anda, klik ikon berbentuk kunci (“Secrets”) di sidebar kiri dan pilih “Add a Secret.”
• Buat token di Hugging Face: Masuk ke akun Hugging Face Anda, buka pengaturan akun, dan temukan bagian “Access Tokens”. Klik “Create new token”, pilih peran yang sesuai (biasanya “Read”), dan buat token Anda.
• Salin dan tempel token: Salin access token baru Anda dan tempel ke kolom “Add a Secret” di Colab. Ini memungkinkan notebook Anda mengakses model DeepSeek-OCR secara aman.

Sekarang Anda siap melakukan autentikasi dan melanjutkan memuat 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()Didukung oleh

Kode di atas memuat model dan tokenizer resmi DeepSeek-OCR langsung dari Hugging Face. Lalu memastikan kompatibilitas tokenizer dengan menetapkan pad token dan memuat model dalam format bfloat16.

Langkah 4: Fungsi pembantu

Setelah model siap, berikutnya kita membuat direktori baru untuk setiap keluaran model agar setiap run OCR tertata rapi. Ini memastikan teks yang diekstrak, visualisasi bounding box, dan file log tersimpan dan tidak menimpa hasil sebelumnya.

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 pathDidukung oleh

Fungsi new_run_dir membuat direktori keluaran unik untuk setiap run pemrosesan gambar, berdasarkan stempel waktu saat ini dan akhiran acak. Ini memastikan hasil dari run berbeda tidak saling menimpa dan membantu menata file keluaran untuk inspeksi atau debugging.

Langkah 5: Handler OCR

Langkah ini adalah mesin utama untuk aplikasi Gradio DeepSeek-OCR. Proses dimulai dengan mengonversi gambar yang diunggah ke format yang tepat dan mengubah ukurannya jika file terlalu besar. Setiap kali kita menjalankan model, semua keluaran disimpan dalam folder baru.

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_imgDidukung oleh

Fungsi gr_ocr merangkum logika prapemrosesan, inferensi, dan pascapemrosesan untuk aplikasi Gradio DeepSeek-OCR. Fungsi ini melakukan langkah-langkah berikut:

• Standarisasi dan prapemrosesan gambar: Fungsi pertama-tama mengonversi gambar masukan ke ruang warna RGB untuk memastikan kompatibilitas dengan model. Jika gambar melebihi dimensi maksimum (2000px), ukurannya diubah secara proporsional untuk mencegah overflow memori GPU.
• Manajemen direktori run: Setiap run OCR diisolasikan dalam direktori unik. Ini memungkinkan keterlacakan yang penting untuk pemrosesan batch, debugging, dan reproduksibilitas.
• Inferensi model yang efisien: Model dipanggil dalam konteks torch.inference_mode() untuk memastikan tidak ada komputasi gradien, mengurangi penggunaan memori dan meningkatkan kecepatan inferensi.
• Penanganan kasus tepi dan galat: Fungsi juga menangani pengecualian seperti ZeroDivisionError pada kasus langka dalam kompresi token tanpa mengganggu pengalaman pengguna.
• Agregasi hasil dan visualisasi: Setelah inferensi, fungsi memuat keluaran teks yang diekstrak dan memuat gambar overlay visual yang menyoroti bounding box yang terdeteksi untuk inspeksi mudah.
• Integrasi UI: Fungsi akhirnya mengembalikan tuple berisi keluaran OCR, statistik pemrosesan, dan gambar beranotasi untuk integrasi antarmuka Gradio yang mulus.

Mari lanjut ke UI interaktif dan lihat DeepSeek-OCR beraksi.

Langkah 6: UI Gradio

Pada langkah terakhir, kita mendefinisikan antarmuka Gradio interaktif untuk DeepSeek-OCR, memungkinkan pengguna mengunggah gambar dengan mudah, memilih mode ekstraksi OCR yang berbeda, menyesuaikan pengaturan lanjutan, dan melihat keluaran dalam satu UI berbasis 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)Didukung oleh

Mari pahami kode ini dalam subbagian:

• Mode demo dan prompt: Kamus DEMO_MODES merangkum semua kapabilitas OCR utama yang didukung DeepSeek-OCR, seperti "Document to Markdown", "Chart Deep Parsing", "Chemical Formula Recognition", dan lainnya. Setiap mode mencakup prompt bawaan, deskripsi, serta parameter pemrosesan gambar yang direkomendasikan, memungkinkan pengguna beralih tugas ekstraksi secara cepat.
• Arsitektur blok: UI dibangun menggunakan API tingkat tinggi Blocks milik Gradio. Antarmuka dibagi menjadi dua kolom utama, panel input yang memungkinkan pengguna mengunggah gambar, memilih mode OCR, dan menyetel parameter lanjutan seperti ukuran gambar dan crop mode. Panel keluaran menampilkan konten OCR yang diekstrak, statistik inferensi, dan gambar beranotasi dengan bounding box di sekitar area yang terdeteksi.
• Kontrol UI dinamis: Aplikasi juga menyertakan tombol radio, slider, kotak centang, dan kotak teks yang terhubung untuk otomatis menyesuaikan berdasarkan masukan pengguna dan mode demo yang dipilih, meningkatkan kegunaan dan meminimalkan konfigurasi manual.
• Pemicu inferensi dan hasil: Saat mengklik tombol Process Image, aplikasi memanggil handler OCR utama gr_ocr dengan meneruskan semua pilihan UI saat ini sebagai argumen. Keluaran kemudian langsung dirender di panel hasil.

Catatan: Anda mungkin perlu memulai ulang sesi di Google Colab jika masih menampilkan keluaran dari masukan sebelumnya.

Kini aplikasi Gradio kita sudah siap, mari uji DeepSeek-OCR dengan serangkaian contoh praktis.

Contoh Aplikasi DeepSeek OCR 1: Chart Deep Parsing

Di dalam demo Gradio DeepSeek-OCR, saya ingin melihat seberapa baik model mengekstrak data tabel dari bagan. Ini masih menantang bagi sebagian besar model OCR dan visi.

Saya mencoba dua kasus uji klasik:

• Bagan batang gaya Statista dan
• Bagan analisis teknikal kompleks penuh sinyal “BUY/SELL” dan overlay numerik

DeepSeek-OCR mengembalikan tabel HTML untuk setiap bagan, dengan sel yang sesuai dengan kategori, nilai, dan label yang ditemukan pada gambar.

Yang berhasil: Model menangkap semua teks dan struktur yang terlihat pada bagan, dan keluarannya berupa tabel HTML, yang dapat digunakan mesin dan mempertahankan logika tabel. Model bahkan memproses bagan finansial kompleks, berupaya menabulasikan setiap angka dan label.

Di mana kesulitan muncul: Keluaran mentah sangat verbose, dengan banyak tag <td> dan <tr>, sehingga sulit diinterpretasi sekilas. Pada bagan kompleks, model kadang menduplikasi entri atau kehilangan struktur visual tingkat tinggi, menghasilkan tabel yang membanjiri dengan sinyal "BUY"/"SELL" dan nilai yang berulang.

Untuk alur kerja nyata, Anda perlu pascapemrosesan HTML agar lebih mudah dibaca atau mengimpornya ke Excel atau Pandas.

Parsing bagan DeepSeek-OCR merupakan fitur digitalisasi bagan yang cerdas, namun keluaran yang sarat HTML lebih cocok untuk pipeline data lanjutan atau parsing lebih lanjut, bukan untuk tinjauan cepat oleh manusia.

Contoh 2: Ekstraksi Rumus Kimia

Untuk uji berikutnya, saya ingin melihat seberapa baik DeepSeek-OCR menangani ekstraksi informasi kimia dari gambar terstruktur. Mode ekstraksi kimia model ini dirancang untuk mengonversi data kimia tabel maupun struktur molekul grafis ke format yang dapat dibaca mesin seperti tabel HTML dan notasi SMILES.

Saya mengunggah dua jenis gambar untuk eksperimen ini, dan berikut yang saya dapatkan:

• Ekstraksi rumus tekstual: Untuk contoh ini, model secara akurat mentranskripsi nama senyawa dan rumus molekulnya (seperti “Glucose: C₆H₁₂O₆”, “Butane: C₄H₁₀”). Namun, keluarannya diformat sebagai kode tabel HTML mentah yang, meski terstruktur, agak sulit dipahami sekilas. Konversi dari gambar ke tabel berlangsung cepat dan cukup akurat untuk teks polos.

• Pengenalan struktur molekul: Untuk gambar yang berisi diagram kimia, DeepSeek-OCR mencoba mengekstrak string SMILES yang sesuai. Misalnya, ia menghasilkan keluaran SMILES untuk etana dan propana. Meskipun berhasil mengenali bahwa itu adalah struktur kimia, string SMILES yang dihasilkan tidak selalu valid secara kimia, menunjukkan keterbatasan saat mem-parsing gambar molekul yang lebih kompleks.

Secara keseluruhan, kapabilitas ekstraksi rumus kimia menawarkan cara cepat untuk mendigitalkan data kimia dan mencoba pengenalan struktur molekul, namun penyempurnaan lebih lanjut diperlukan untuk parsing kimia yang andal, terutama pada struktur kompleks.

Contoh 3: OCR Teks Tulisan Tangan

Berikutnya, saya ingin melihat seberapa baik DeepSeek-OCR menangani catatan tulisan tangan, tantangan klasik bagi sistem OCR, terutama saat tulisan memiliki gaya atau ukuran yang bervariasi. 

Saya mengunggah gambar daftar kimia tulisan tangan berisi nama senyawa di kertas bergaris. Setelah diproses, mode Document to Markdown milik model mengekstrak teks dan mempertahankan strukturnya dengan mengejutkan. Ia mengenali header dan mencantumkan setiap senyawa pada barisnya masing-masing, persis seperti pada gambar asli. Bounding box mengonfirmasi secara visual bahwa model mengidentifikasi setiap baris dengan benar dan memisahkan blok teks individual.

Hasil ini menunjukkan kemampuan model untuk mentranskripsi konten tulisan tangan ke teks digital. Meskipun beberapa detail pemformatan kecil mungkin hilang, keseluruhan ekstraksi sangat akurat untuk contoh ini.

Contoh 4: Ekstraksi Persamaan

Uji standar lain untuk OCR adalah membaca dan menafsirkan persamaan matematika yang ditulis dalam notasi buku teks standar. Untuk eksperimen ini, saya mengunggah gambar berisi beberapa persamaan kompleks yang disetel dalam font matematika bergaya LaTeX untuk mengevaluasi apakah model tidak hanya dapat mendeteksi tetapi juga secara akurat mengekstrak dan memformat ekspresi tersebut.

DeepSeek-OCR berhasil mendeteksi keempat persamaan dalam gambar dan mengekstraknya sebagai string LaTeX. Keluaran yang dikenali terstruktur rapi, dengan setiap persamaan ditranskripsi pada baris terpisah dalam format LaTeX standar. 

Bounding box juga terhampar pada gambar asli dengan tepat (sekitar), menunjukkan bahwa model dapat melokalisasi dan mensegmentasi ekspresi matematika individual secara akurat.

Yang menonjol adalah konten yang diekstrak mempertahankan struktur matematis menggunakan perintah seperti \frac untuk pecahan dan pemformatan variabel yang tepat, sehingga hasilnya dapat langsung digunakan untuk dokumentasi. 

Contoh 5: Ekstraksi Tabel

Salah satu tugas OCR yang paling umum dan bernilai adalah mengekstrak data tabel dari gambar dokumen, terutama saat menangani laporan hasil pindai, makalah riset, atau kumpulan data. Untuk mengevaluasi kemampuan DeepSeek-OCR di area ini, saya mengunggah gambar berisi tabel perbandingan ekonomi terstruktur lintas beberapa negara.

Setelah memilih mode "Chart Deep Parsing" dan memproses gambar, DeepSeek-OCR berupaya mengonversi tabel visual menjadi struktur tabel HTML. Konten yang diekstrak (di sebelah kanan) berisi serangkaian tag <table> dan <td>, memetakan baris dan kolom tabel sebagai teks polos. Keluaran bounding box semakin menegaskan bahwa model mengidentifikasi dan mensegmentasi area tabel utama pada gambar dengan benar.

Model menunjukkan ekstraksi yang andal untuk tabel sederhana, meski pascapemrosesan mungkin diperlukan karena format keluaran (HTML mentah) kurang ramah untuk tinjauan cepat atau analisis data lanjutan.

Contoh 6: OCR pada Meme

Untuk contoh ini, saya ingin menguji bagaimana model menangani ekstraksi teks dari gambar meme populer. Ini adalah skenario dunia nyata di mana teks sering ditumpangkan pada latar belakang kompleks, menggunakan font bervariasi, dan mungkin tidak selalu mengikuti struktur dokumen tipikal.

Saya mengunggah gambar meme klasik dengan teks besar berwarna putih dan kapital menumpangi adegan dari film (Leonardo DiCaprio di Django Unchained) dan menjalankan mode ekstraksi Document to Markdown.

Sumber: Media.io

Hasil OCR untuk meme ini cukup tangguh. Model mampu menangkap semua kata yang relevan dalam urutan yang benar, tanpa salah eja atau melewatkan teks, bahkan dengan latar belakang yang kompleks. 

Walau tidak ada markup struktural, ekstraksi ini sangat berguna untuk tugas lanjutan seperti analisis sentimen meme, moderasi konten, atau pencarian meme berbasis teks.

Contoh 7: OCR Multibahasa

Salah satu kekuatan unik DeepSeek-OCR adalah dukungannya untuk ekstraksi teks multibahasa, yang sangat berguna bagi dokumen atau gambar yang memuat campuran bahasa global. 

Saya menguji kapabilitas ini dengan beragam sampel, termasuk foto rambu jalan nyata dengan teks bahasa Mandarin, dan sampel sintetis yang berisi campuran kalimat Mandarin, Jepang, dan Korea.

Sumber: DeepSeek OCR Hugging Face

Saat memproses sampel multibahasa ini, mode document-to-Markdown DeepSeek-OCR mampu mendeteksi dan mengekstrak aksara non-Inggris secara akurat. Untuk foto jalan, model mengidentifikasi dan mengembalikan seluruh paragraf teks Mandarin. 

Untuk contoh campuran bahasa, model memisahkan dan memberi label bagian Mandarin, Jepang, dan Korea dengan benar, mempertahankan pemformatan dan blok teksnya. Overlay bounding box juga menunjukkan deteksi yang presisi pada wilayah teks tiap bahasa.

Namun, ada dua catatan penting:

• Kecepatan pemrosesan: OCR multibahasa secara signifikan lebih lambat dibanding tugas bahasa tunggal Bahasa Inggris atau ekstraksi tabel. Uji saya menunjukkan waktu pemrosesan yang jauh lebih lama, kemungkinan karena kompleksitas tambahan dalam deteksi aksara dan decoding.
• Kesalahan sesekali: Terkadang, keluaran yang diekstrak menyertakan token berlebih atau teks yang diformat tidak tepat.

Terlepas dari masalah kecil ini, DeepSeek-OCR menghadirkan kapabilitas OCR multibahasa yang kuat dan andal menangani aksara campuran serta foto dunia nyata.

Catatan Akhir DeepSeek-OCR

DeepSeek-OCR menjembatani kesenjangan antara OCR klasik dan LLM multimodal modern. Kemenangan terbesarnya adalah versatilitas: Anda mendapatkan satu pipeline yang membaca dokumen hasil pindai, mengekstrak tabel dan bagan kompleks, memahami persamaan dan struktur kimia, serta bekerja dengan meme, tulisan tangan, dan puluhan bahasa.

Meski begitu, DeepSeek-OCR tidak sempurna. Keluaran bagan dan tabel bisa terlalu verbose, pengenalan struktur kimia terkadang kurang memadai, dan pemrosesan multibahasa terasa lebih lambat. Tata letak visual kompleks mungkin memerlukan pascapemrosesan untuk penggunaan langsung.

Namun untuk riset, alur kerja akademis, pembuatan prototipe cepat, dan siapa pun yang membutuhkan OCR tingkat lanjut di luar teks polos semata, DeepSeek-OCR sudah terasa seperti peningkatan signifikan dibandingkan alat warisan. 

Jika Anda ingin mempelajari lebih lanjut tentang ekosistem DeepSeek, saya sarankan melihat kursus Working with DeepSeek in Python.