Bagaimana jika Anda bisa mengekstrak teks dari PDF, tabel, dan rumus kompleks dengan model yang lebih kecil dari kebanyakan aplikasi ponsel pintar? GLM-OCR mencapai pemahaman dokumen canggih (state-of-the-art) hanya dengan 0,9 miliar parameter. Model ini cukup ringan untuk dijalankan pada perangkat keras sederhana namun cukup akurat untuk menduduki puncak papan peringkat OmniDocBench V1.5 dengan 94,62 poin.
Alat OCR tradisional kesulitan dengan struktur dokumen. Mereka kehilangan format tabel, salah membaca rumus matematika, dan gagal pada tata letak multi-kolom. API Cloud mengatasi masalah ini tetapi mengenakan biaya per permintaan dan mengirimkan dokumen sensitif Anda ke server pihak ketiga. GLM-OCR menghilangkan kedua masalah tersebut: ia menangani tata letak kompleks secara lokal dengan akurasi tingkat produksi, semuanya di bawah lisensi MIT yang mengizinkan penggunaan komersial tanpa biaya lisensi.
Memahami Arsitektur GLM-OCR
GLM-OCR menggunakan arsitektur encoder-decoder tiga komponen yang dioptimalkan untuk pemahaman dokumen. Encoder visual CogViT memproses gambar dokumen menggunakan bobot yang telah dilatih sebelumnya (pretrained) pada miliaran pasangan gambar-teks. Ini mengekstrak fitur visual sambil mempertahankan hubungan spasial yang krusial untuk memahami tata letak.
Konektor lintas-modal (cross-modal) yang ringan terletak di antara encoder dan decoder. Komponen ini mengurangi sampel token visual secara efisien, mengurangi overhead komputasi tanpa mengorbankan akurasi. Decoder bahasa GLM-0.5B kemudian menghasilkan keluaran teks terstruktur, menangani semuanya mulai dari paragraf biasa hingga tabel bertingkat yang kompleks.
Model ini menggunakan alur inferensi dua tahap. Pertama, PP-DocLayout-V3 menganalisis struktur dokumen—mengidentifikasi header, paragraf, tabel, dan gambar. Kedua, pengenalan paralel memproses setiap wilayah secara bersamaan. Pendekatan ini mempertahankan hierarki dokumen di mana OCR tradisional meratakan semuanya menjadi teks tidak terstruktur.
Inovasi pelatihan semakin meningkatkan kinerja. Kerugian prediksi multi-token meningkatkan efisiensi pelatihan dengan memprediksi beberapa token secara bersamaan. Pembelajaran penguatan (reinforcement learning) tugas penuh yang stabil meningkatkan generalisasi di berbagai jenis dokumen. Hasilnya: akurasi 96,5% pada pengenalan rumus, 86,0% pada pengenalan tabel, dan kinerja terdepan pada tugas ekstraksi informasi.
Pada saat inferensi, GLM-OCR memproses 1,86 halaman PDF per detik pada satu GPU—secara signifikan lebih cepat daripada model sejenis. Jumlah parameter 0,9 miliar berarti Anda melakukan deployment pada perangkat keras konsumen daripada kluster perusahaan.
Spesifikasi Model
GLM-OCR menangani dokumen hingga resolusi 8K (7680×4320 piksel). Ia mengenali 8 bahasa termasuk Inggris, Cina, Jepang, dan Korea. Model ini memproses gambar raster (PNG, JPEG) dan input vektor. Inferensi tipikal mengonsumsi 4-6GB VRAM pada presisi FP16, sesuai untuk GPU konsumen seperti RTX 3060 atau instans cloud seperti AWS g4dn.xlarge.
> | Perangkat Keras | VRAM yang Dibutuhkan | Halaman/dtk | Kasus Penggunaan |
--------------------------------------------------------------------
> | RTX 3060 | 4-6GB | ~1.5 | Pengembangan |
> | RTX 4090 | 4-6GB | ~2.5 | Produksi |
> | AWS g4dn.xlarge | 16GB | ~1.8 | Deployment Cloud |
> | 4x A100 (TPS=4) | 80GB | ~7.0 | Perusahaan |Opsi Deployment Lokal
GLM-OCR mendukung empat metode deployment tergantung pada infrastruktur dan persyaratan kinerja Anda. Masing-masing menggunakan bobot model dasar yang sama dari Hugging Face tetapi dioptimalkan untuk skenario yang berbeda.
- vLLM memberikan keseimbangan terbaik antara throughput dan latensi untuk beban kerja produksi. Ini mengimplementasikan PagedAttention untuk manajemen memori yang efisien dan mendukung batching berkelanjutan untuk skenario konkurensi tinggi.
- SGLang menawarkan kinerja maksimum melalui optimasi runtime-nya. Ini unggul dalam speculative decoding dan structured generation, menjadikannya ideal ketika Anda membutuhkan inferensi secepat mungkin.
- Ollama memberikan pengaturan paling sederhana. Satu perintah mengunduh dan menjalankan model secara lokal—tanpa dependensi Python atau file konfigurasi. Sempurna untuk prototyping dan penggunaan pribadi.
- Transformers memungkinkan integrasi Python secara langsung. Gunakan ini untuk pengembangan, debugging, atau ketika Anda membutuhkan kontrol yang sangat terperinci atas alur inferensi.
Semua metode memerlukan bobot GLM-OCR dari Hugging Face (zai-org/GLM-OCR). Model ini berjalan pada GPU NVIDIA dengan dukungan CUDA. Inferensi hanya CPU berfungsi tetapi dengan kecepatan yang jauh berkurang.
Menyiapkan vLLM untuk Produksi
vLLM menyediakan inferensi siap produksi dengan titik akhir API yang kompatibel dengan OpenAI. Ini memungkinkan Anda menukar GLM-OCR ke aplikasi yang ada yang saat ini menggunakan model visi OpenAI.
Instalasi
Instal vLLM dengan dukungan CUDA:
pip install -U vllm --extra-index-url https://wheels.vllm.ai/nightly
Untuk deployment dalam kontainer, gunakan citra Docker resmi:
docker pull vllm/vllm-openai:nightly
Instal Transformers yang kompatibel—vLLM memerlukan versi pengembangan terbaru untuk dukungan GLM-OCR:
pip install git+https://github.com/huggingface/transformers.git
Meluncurkan Layanan
Mulai server vLLM dengan GLM-OCR:
vllm serve zai-org/GLM-OCR \
--allowed-local-media-path / \
--port 8080 \
--speculative-config '{"method": "mtp", "num_speculative_tokens": 1}'
Flag --allowed-local-media-path memungkinkan model mengakses file gambar lokal. Atur ini ke direktori dokumen Anda atau / untuk akses tak terbatas (gunakan dengan hati-hati dalam produksi).
--speculative-config memungkinkan Prediksi Multi-Token (Multi-Token Prediction), fitur GLM-OCR yang mempercepat inferensi dengan memprediksi beberapa token secara bersamaan.
Integrasi Klien
Setelah berjalan, berinteraksi dengan GLM-OCR melalui permintaan HTTP standar:
curl --location --request POST 'http://localhost:8080/v1/chat/completions' \
--header 'Content-Type: application/json' \
--data-raw '{
"model": "zai-org/GLM-OCR",
"messages": [
{
"role": "user",
"content": [
{"type": "image_url", "image_url": {"url": "file:///path/to/document.png"}},
{"type": "text", "text": "Extract all text from this document"}
]
}
]
}'
Format respons yang kompatibel dengan OpenAI berarti SDK yang ada berfungsi tanpa modifikasi. Arahkan klien OpenAI Anda ke http://localhost:8080 dan gunakan zai-org/GLM-OCR sebagai nama model.
Konfigurasi Produksi
Untuk deployment dengan throughput tinggi, tambahkan paralelisme tensor di beberapa GPU:
vllm serve zai-org/GLM-OCR \
--tensor-parallel-size 4 \
--gpu-memory-utilization 0.95 \
--max-model-len 8192 \
--allowed-local-media-path / \
--port 8080
Sesuaikan --tensor-parallel-size agar sesuai dengan jumlah GPU Anda. Pantau pemanfaatan GPU dan tingkatkan ukuran batch untuk memaksimalkan throughput.
Pemantauan dan Skalabilitas
Lacak kinerja vLLM melalui titik akhir metrik bawaannya di /metrics. Data yang kompatibel dengan Prometheus mencakup latensi permintaan, kedalaman antrean (queue depth), dan pemanfaatan GPU. Atur peringatan ketika kedalaman antrean melebihi 10 permintaan atau memori GPU mencapai 90%. Untuk skalabilitas horizontal, deploy beberapa instans vLLM di belakang load balancer dengan sticky sessions untuk mempertahankan konteks di seluruh permintaan.
Pertimbangkan untuk menggunakan fitur pemantauan API Apidog untuk melacak metrik produksi bersama dengan kinerja model Anda.
Inferensi Berkinerja Tinggi SGLang
SGLang menyediakan optimasi runtime tingkat lanjut untuk kecepatan inferensi maksimum. Ini unggul dalam speculative decoding dan structured generation, menjadikannya ideal untuk aplikasi yang sensitif terhadap latensi.
Instalasi
Instal SGLang melalui Docker (direkomendasikan untuk isolasi dependensi):
docker pull lmsysorg/sglang:dev
Atau instal dari sumber:
pip install git+https://github.com/sgl-project/sglang.git#subdirectory=python
Instal Transformers yang kompatibel:
pip install git+https://github.com/huggingface/transformers.git
Meluncurkan Layanan
Mulai SGLang dengan speculative decoding yang dioptimalkan:
python -m sglang.launch_server \
--model zai-org/GLM-OCR \
--port 8080 \
--speculative-algorithm NEXTN \
--speculative-num-steps 3 \
--speculative-eagle-topk 1 \
--speculative-num-draft-tokens 4
Parameter speculative decoding mempercepat inferensi dengan membuat draf beberapa token secara bersamaan dan memverifikasinya secara paralel. Sesuaikan --speculative-num-steps berdasarkan perangkat keras Anda—nilai yang lebih tinggi meningkatkan kecepatan tetapi memerlukan lebih banyak memori.
Output Terstruktur
Structured generation SGLang memastikan GLM-OCR menghasilkan output JSON yang valid atau skema lainnya:
import sglang as sgl
@sgl.function
def extract_invoice(s, image_path):
s += sgl.user(sgl.image(image_path) + "Extract invoice data as JSON")
s += sgl.assistant(sgl.gen("json_output", json_schema={
"type": "object",
"properties": {
"invoice_number": {"type": "string"},
"date": {"type": "string"},
"total": {"type": "number"},
"items": {
"type": "array",
"items": {
"type": "object",
"properties": {
"description": {"type": "string"},
"quantity": {"type": "integer"},
"price": {"type": "number"}
}
}
}
}
}))
result = extract_invoice.run(image_path="invoice.png")
print(result["json_output"])
Ini menjamin keluaran yang dapat dibaca mesin tanpa pasca-pemrosesan atau logika coba ulang (retry logic). Untuk titik akhir API yang menyajikan respons terstruktur, validasi skema Apidog dapat secara otomatis memverifikasi format keluaran Anda cocok dengan struktur JSON yang diharapkan.
Kapan Memilih SGLang daripada vLLM
Pilih SGLang ketika Anda membutuhkan output terstruktur atau speculative decoding. Generasi yang dibatasi regex-nya menjamin skema JSON yang valid, menghilangkan logika coba ulang. Algoritma spekulatif mempercepat pembuatan token sebesar 30-40% pada GPU dengan memori yang cukup.
> | Fitur | vLLM | SGLang |
-----------------------------------------------------------------------
> | Throughput | Tinggi | Sangat Tinggi |
> | Latensi | Baik | Sangat Baik |
> | Kompatibel OpenAI | Ya | Tidak |
> | Output Terstruktur | Manual | Bawaan |
> | Dukungan Komunitas | Sangat Baik | Berkembang |
> | Kompleksitas Setup | Sedang | Tinggi |
> | Terbaik Untuk | API Produksi | Aplikasi Penting Kecepatan |Untuk OCR standar tanpa persyaratan latensi yang ketat, vLLM memberikan kinerja yang memadai dengan konfigurasi yang lebih sederhana dan dukungan komunitas yang lebih baik.
Integrasi Langsung Transformers
Untuk pengembangan, debugging, atau alur kerja kustom, gunakan pustaka Transformers secara langsung. Ini memberikan fleksibilitas maksimum dengan biaya throughput yang lebih rendah dibandingkan dengan vLLM atau SGLang.
Instalasi
Instal Transformers terbaru dari sumber:
pip install git+https://github.com/huggingface/transformers.git
Inferensi Dasar
Muat dan jalankan GLM-OCR di Python:
from transformers import AutoProcessor, AutoModelForImageTextToText
import torch
MODEL_PATH = "zai-org/GLM-OCR"
# Prepare input
messages = [
{
"role": "user",
"content": [
{"type": "image", "url": "document.png"},
{"type": "text", "text": "Text Recognition:"}
],
}
]
# Load model and processor
processor = AutoProcessor.from_pretrained(MODEL_PATH)
model = AutoModelForImageTextToText.from_pretrained(
MODEL_PATH,
torch_dtype="auto",
device_map="auto",
)
# Process input
inputs = processor.apply_chat_template(
messages,
tokenize=True,
add_generation_prompt=True,
return_dict=True,
return_tensors="pt"
).to(model.device)
inputs.pop("token_type_ids", None)
# Generate output
generated_ids = model.generate(**inputs, max_new_tokens=8192)
output_text = processor.decode(
generated_ids[0][inputs["input_ids"].shape[1]:],
skip_special_tokens=False
)
print(output_text)
device_map="auto" secara otomatis mendistribusikan lapisan model ke seluruh GPU yang tersedia. Untuk deployment satu GPU, ini memuat model penuh pada satu perangkat. Untuk inferensi hanya CPU, ubah ke device_map="cpu"—harap harapkan kinerja yang jauh lebih lambat.
Pemrosesan Batch
Proses beberapa dokumen secara efisien:
import os
from pathlib import Path
def batch_process(directory, output_file):
documents = list(Path(directory).glob("*.png")) + \
list(Path(directory).glob("*.pdf"))
results = []
for doc_path in documents:
# Konversi PDF ke gambar jika diperlukan
if doc_path.suffix == ".pdf":
images = convert_pdf_to_images(doc_path)
else:
images = [doc_path]
for image in images:
text = extract_text(image) # Fungsi ekstraksi Anda
results.append({
"file": str(doc_path),
"page": image.page_num if hasattr(image, 'page_num') else 1,
"text": text
})
# Simpan hasil
with open(output_file, 'w') as f:
json.dump(results, f, indent=2)
# Penggunaan
batch_process("./invoices/", "extracted_data.json")
Saat memproses dokumen dalam produksi, manajemen ruang kerja Apidog membantu mengatur beberapa titik akhir pemrosesan dokumen ke dalam grup logis, sehingga lebih mudah untuk menguji dan memantau alur kerja yang berbeda.
Optimasi Memori
Untuk GPU dengan VRAM terbatas, gunakan kuantisasi:
from transformers import BitsAndBytesConfig
quantization_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_compute_dtype=torch.float16
)
model = AutoModelForImageTextToText.from_pretrained(
MODEL_PATH,
quantization_config=quantization_config,
device_map="auto",
)
Kuantisasi 4-bit mengurangi penggunaan memori sebesar 75% dengan dampak akurasi minimal untuk tugas pemahaman dokumen.
Menangani Kasus Khusus
Dokumen dengan tulisan tangan yang banyak atau sudut kemiringan yang ekstrem mengurangi akurasi. Pra-proses gambar dengan algoritma deskewing sebelum dikirim ke GLM-OCR. Untuk PDF multi-halaman, ekstrak halaman sebagai gambar terpisah daripada meneruskan seluruh file. Ini memungkinkan pemrosesan paralel dan menyederhanakan penanganan kesalahan ketika halaman individual gagal. Dokumen ber-watermark kadang-kadang memicu positif palsu di wilayah teks—bereksperimenlah dengan penyesuaian kontras jika Anda melihat keluaran yang kacau di area tertentu.
Kasus Penggunaan GLM-OCR di Dunia Nyata
GLM-OCR unggul dalam beberapa skenario produksi:
Pemrosesan Faktur
Tim keuangan mengekstrak item baris, tanggal, dan total dari faktur yang dipindai. Model ini mempertahankan struktur tabel, memastikan perhitungan total yang akurat tanpa tinjauan manual. Proses ribuan faktur per hari dengan deployment lokal dan tanpa biaya API.
Dokumentasi Teknis
Tim teknik mengubah manual dan spesifikasi PDF menjadi teks yang dapat dicari. Pengenalan rumus mempertahankan persamaan matematika, membuat konten teknis dapat dibaca mesin. Ideal untuk proyek modernisasi dokumentasi lama.
Analisis Dokumen Hukum
Profesional hukum meninjau kontrak dan perjanjian dengan OCR yang menghormati hierarki dokumen. Penanganan tata letak multi-kolom memastikan paragraf tidak digabungkan secara salah. Pendekatan yang mengutamakan privasi menjaga data sensitif tetap berada di lokasi (on-premises).
Catatan Kesehatan
Kantor medis mendigitalisasi formulir pasien dan resep. Mengenali 8 bahasa, berguna untuk lingkungan perawatan kesehatan multibahasa. Deployment lokal memenuhi persyaratan kepatuhan HIPAA dengan menjaga data tetap internal.
Kesimpulan
GLM-OCR memberikan pemahaman dokumen tingkat produksi dalam paket parameter 0,9 miliar. Anda dapat melakukan deployment secara lokal, menjaga privasi data, dan mencapai tingkat throughput yang menyaingi API cloud—semuanya tanpa biaya per permintaan. Arsitekturnya menangani tata letak kompleks, tabel, dan rumus yang terlewatkan oleh OCR tradisional, sementara lisensi MIT mengizinkan penggunaan komersial tanpa batasan.
Pilih vLLM untuk deployment produksi yang membutuhkan throughput tinggi dan kompatibilitas OpenAI. Gunakan SGLang ketika kecepatan inferensi maksimum menjadi prioritas. Pilih Transformers untuk pengembangan dan alur kerja kustom. Setiap opsi menjalankan model dasar yang sama, jadi Anda dapat beralih metode deployment tanpa melatih ulang atau menyetel ulang.
Saat membangun alur pemrosesan dokumen—baik mengekstrak data dari faktur, mengurai dokumentasi teknis, atau mengotomatiskan pemrosesan formulir—sederhanakan pengujian API Anda dengan Apidog. Ini menyediakan pembangunan permintaan visual, pembuatan dokumentasi otomatis, dan alat debugging kolaboratif yang melengkapi alur kerja deployment GLM-OCR Anda.