¿Y si pudieras extraer texto de complejos PDF, tablas y fórmulas con un modelo más pequeño que la mayoría de las aplicaciones de smartphone? GLM-OCR logra una comprensión de documentos de vanguardia con solo 0.9 mil millones de parámetros. Es lo suficientemente ligero como para ejecutarse en hardware modesto, pero lo suficientemente preciso como para encabezar la tabla de clasificación de OmniDocBench V1.5 con 94.62 puntos.
Las herramientas OCR tradicionales tienen dificultades con la estructura de los documentos. Pierden el formato de las tablas, leen erróneamente las fórmulas matemáticas y fallan en los diseños de varias columnas. Las API en la nube resuelven estos problemas, pero cobran por solicitud y envían sus documentos sensibles a servidores de terceros. GLM-OCR elimina ambos problemas: maneja diseños complejos localmente con una precisión de grado de producción, todo bajo una licencia MIT que permite el uso comercial sin tarifas de licencia.
Comprensión de la arquitectura de GLM-OCR
GLM-OCR utiliza una arquitectura codificador-decodificador de tres componentes optimizada para la comprensión de documentos. El codificador visual CogViT procesa imágenes de documentos utilizando pesos preentrenados en miles de millones de pares imagen-texto. Extrae características visuales conservando las relaciones espaciales críticas para comprender el diseño.
Un conector intermodal ligero se sitúa entre el codificador y el decodificador. Este componente submuestrea los tokens visuales de manera eficiente, reduciendo la sobrecarga computacional sin sacrificar la precisión. El decodificador de lenguaje GLM-0.5B luego genera una salida de texto estructurado, manejando todo, desde párrafos simples hasta complejas tablas anidadas.
El modelo emplea un pipeline de inferencia de dos etapas. Primero, PP-DocLayout-V3 analiza la estructura del documento, identificando encabezados, párrafos, tablas y figuras. Segundo, el reconocimiento paralelo procesa cada región simultáneamente. Este enfoque mantiene la jerarquía del documento donde el OCR tradicional aplana todo en texto no estructurado.
Las innovaciones en el entrenamiento impulsan aún más el rendimiento. La pérdida de predicción de múltiples tokens mejora la eficiencia del entrenamiento al predecir varios tokens simultáneamente. El aprendizaje por refuerzo estable de tarea completa mejora la generalización a través de diversos tipos de documentos. El resultado: 96.5% de precisión en el reconocimiento de fórmulas, 86.0% en el reconocimiento de tablas y un rendimiento líder en tareas de extracción de información.
En la inferencia, GLM-OCR procesa 1.86 páginas PDF por segundo en una sola GPU, significativamente más rápido que modelos comparables. La cantidad de 0.9B parámetros significa que se implementa en hardware de consumo en lugar de clústeres empresariales.
Especificaciones del modelo
GLM-OCR maneja documentos de hasta 8K de resolución (7680×4320 píxeles). Reconoce 8 idiomas, incluyendo inglés, chino, japonés y coreano. El modelo procesa tanto imágenes rasterizadas (PNG, JPEG) como entradas vectoriales. La inferencia típica consume 4-6 GB de VRAM con precisión FP16, adaptándose a GPUs de consumo como la RTX 3060 o instancias en la nube como AWS g4dn.xlarge.
> | Hardware | VRAM Requerida | Páginas/seg | Caso de Uso |
--------------------------------------------------------------------
> | RTX 3060 | 4-6GB | ~1.5 | Desarrollo |
> | RTX 4090 | 4-6GB | ~2.5 | Producción |
> | AWS g4dn.xlarge | 16GB | ~1.8 | Despliegue en la nube |
> | 4x A100 (TPS=4) | 80GB | ~7.0 | Empresa |Opciones de despliegue local
GLM-OCR admite cuatro métodos de despliegue, según su infraestructura y requisitos de rendimiento. Cada uno utiliza los mismos pesos del modelo subyacente de Hugging Face, pero se optimiza para diferentes escenarios.
- vLLM ofrece el mejor equilibrio entre rendimiento y latencia para cargas de trabajo de producción. Implementa PagedAttention para una gestión eficiente de la memoria y admite el procesamiento por lotes continuo para escenarios de alta concurrencia.
- SGLang ofrece el máximo rendimiento a través de su optimización en tiempo de ejecución. Destaca en la decodificación especulativa y la generación estructurada, lo que lo hace ideal cuando se necesita la inferencia más rápida posible.
- Ollama ofrece la configuración más sencilla. Un comando descarga y ejecuta el modelo localmente, sin dependencias de Python ni archivos de configuración. Perfecto para prototipos y uso personal.
- Transformers permite la integración directa con Python. Utilícelo para el desarrollo, la depuración o cuando necesite un control preciso sobre el pipeline de inferencia.
Todos los métodos requieren los pesos de GLM-OCR de Hugging Face (zai-org/GLM-OCR). El modelo se ejecuta en GPUs NVIDIA con soporte CUDA. La inferencia solo con CPU funciona, pero a una velocidad significativamente reducida.
Configuración de vLLM para producción
vLLM proporciona inferencia lista para producción con puntos finales de API compatibles con OpenAI. Esto le permite intercambiar GLM-OCR en aplicaciones existentes que actualmente utilizan los modelos de visión de OpenAI.
Instalación
Instale vLLM con soporte CUDA:
pip install -U vllm --extra-index-url https://wheels.vllm.ai/nightly
Para despliegues en contenedores, use la imagen oficial de Docker:
docker pull vllm/vllm-openai:nightly
Instale Transformers compatibles—vLLM requiere la última versión de desarrollo para el soporte de GLM-OCR:
pip install git+https://github.com/huggingface/transformers.git
Iniciando el servicio
Inicie el servidor vLLM con GLM-OCR:
vllm serve zai-org/GLM-OCR \
--allowed-local-media-path / \
--port 8080 \
--speculative-config '{"method": "mtp", "num_speculative_tokens": 1}'
El flag --allowed-local-media-path permite que el modelo acceda a archivos de imagen locales. Establézcalo en su directorio de documentos o en / para un acceso sin restricciones (use con precaución en producción).
El --speculative-config habilita la Predicción Multi-Token, una característica de GLM-OCR que acelera la inferencia al predecir múltiples tokens simultáneamente.
Integración del cliente
Una vez en ejecución, interactúe con GLM-OCR a través de solicitudes HTTP estándar:
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": "Extraer todo el texto de este documento"}
]
}
]
}'
El formato de respuesta compatible con OpenAI significa que los SDK existentes funcionan sin modificaciones. Apunte su cliente de OpenAI a http://localhost:8080 y use zai-org/GLM-OCR como nombre del modelo.
Configuración de producción
Para despliegues de alto rendimiento, añada paralelismo tensorial a través de múltiples GPUs:
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
Ajuste --tensor-parallel-size para que coincida con el número de sus GPUs. Monitoree la utilización de la GPU y aumente los tamaños de lote para maximizar el rendimiento.
Monitoreo y escalado
Rastree el rendimiento de vLLM a través de su punto final de métricas incorporado en /metrics. Los datos compatibles con Prometheus incluyen latencia de solicitudes, profundidad de cola y utilización de GPU. Configure alertas cuando la profundidad de la cola exceda las 10 solicitudes o la memoria de la GPU alcance el 90%. Para el escalado horizontal, despliegue múltiples instancias de vLLM detrás de un balanceador de carga con sesiones persistentes para mantener el contexto entre solicitudes.
Considere usar las funciones de monitoreo de API de Apidog para rastrear las métricas de producción junto con el rendimiento de su modelo.
Inferencia de alto rendimiento con SGLang
SGLang proporciona optimizaciones avanzadas en tiempo de ejecución para una velocidad de inferencia máxima. Destaca en la decodificación especulativa y la generación estructurada, lo que lo hace ideal para aplicaciones sensibles a la latencia.
Instalación
Instale SGLang a través de Docker (recomendado para el aislamiento de dependencias):
docker pull lmsysorg/sglang:dev
O instale desde el código fuente:
pip install git+https://github.com/sgl-project/sglang.git#subdirectory=python
Instale Transformers compatibles:
pip install git+https://github.com/huggingface/transformers.git
Iniciando el servicio
Inicie SGLang con decodificación especulativa optimizada:
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
Los parámetros de decodificación especulativa aceleran la inferencia al redactar múltiples tokens simultáneamente y verificarlos en paralelo. Ajuste --speculative-num-steps según su hardware: valores más altos aumentan la velocidad, pero requieren más memoria.
Salida estructurada
La generación estructurada de SGLang asegura que GLM-OCR genere JSON válido u otros esquemas:
import sglang as sgl
@sgl.function
def extract_invoice(s, image_path):
s += sgl.user(sgl.image(image_path) + "Extraer datos de factura como 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"])
Esto garantiza una salida legible por máquina sin postprocesamiento ni lógica de reintento. Para los puntos finales de API que sirven respuestas estructuradas, la validación de esquemas de Apidog puede verificar automáticamente que sus formatos de salida coincidan con las estructuras JSON esperadas.
Cuándo elegir SGLang en lugar de vLLM
Seleccione SGLang cuando necesite salidas estructuradas o decodificación especulativa. Su generación restringida por expresiones regulares garantiza esquemas JSON válidos, eliminando la lógica de reintento. El algoritmo especulativo acelera la generación de tokens en un 30-40% en GPUs con suficiente memoria.
> | Característica | vLLM | SGLang |
---------------------------------------------------------------
> | Rendimiento | Alto | Muy Alto |
> | Latencia | Bueno | Excelente |
> | Compatible con OpenAI | Sí | No |
> | Salida Estructurada | Manual | Incorporado |
> | Soporte Comunitario | Excelente | En crecimiento |
> | Complejidad de Configuración | Media | Alta |
> | Mejor Para | API de Producción | Aplicaciones críticas por velocidad |Para OCR estándar sin requisitos estrictos de latencia, vLLM proporciona un rendimiento suficiente con una configuración más sencilla y un mejor soporte comunitario.
Integración directa con Transformers
Para desarrollo, depuración o pipelines personalizados, use la biblioteca Transformers directamente. Esto proporciona la máxima flexibilidad a costa de un menor rendimiento en comparación con vLLM o SGLang.
Instalación
Instale la última versión de Transformers desde el código fuente:
pip install git+https://github.com/huggingface/transformers.git
Inferencia básica
Cargue y ejecute GLM-OCR en 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": "Reconocimiento de texto:"}
],
}
]
# 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)
El device_map="auto" distribuye automáticamente las capas del modelo entre las GPUs disponibles. Para el despliegue con una sola GPU, esto carga el modelo completo en un solo dispositivo. Para la inferencia solo con CPU, cambie a device_map="cpu" — espere un rendimiento significativamente más lento.
Procesamiento por lotes
Procese múltiples documentos de manera eficiente:
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:
# Convertir PDF a imágenes si es necesario
if doc_path.suffix == ".pdf":
images = convert_pdf_to_images(doc_path)
else:
images = [doc_path]
for image in images:
text = extract_text(image) # Su función de extracción
results.append({
"file": str(doc_path),
"page": image.page_num if hasattr(image, 'page_num') else 1,
"text": text
})
# Guardar resultados
with open(output_file, 'w') as f:
json.dump(results, f, indent=2)
# Usage
batch_process("./invoices/", "extracted_data.json")
Al procesar documentos en producción, la gestión de espacios de trabajo de Apidog ayuda a organizar múltiples puntos finales de procesamiento de documentos en grupos lógicos, facilitando la prueba y el monitoreo de diferentes flujos de trabajo.
Optimización de memoria
Para GPUs con VRAM limitada, use la cuantificación:
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",
)
La cuantificación de 4 bits reduce el uso de memoria en un 75% con un impacto mínimo en la precisión para las tareas de comprensión de documentos.
Manejo de casos extremos
Los documentos con escritura manual abundante o ángulos de inclinación extremos reducen la precisión. Preprocese las imágenes con algoritmos de corrección de inclinación antes de enviarlas a GLM-OCR. Para PDFs de varias páginas, extraiga las páginas como imágenes separadas en lugar de pasar el archivo completo. Esto permite el procesamiento paralelo y simplifica el manejo de errores cuando fallan las páginas individuales. Los documentos con marcas de agua ocasionalmente disparan falsos positivos en las regiones de texto: experimente con ajustes de contraste si ve una salida ilegible en áreas específicas.
Casos de uso reales de GLM-OCR
Procesamiento de facturas
Los equipos financieros extraen partidas, fechas y totales de facturas escaneadas. El modelo mantiene la estructura de la tabla, asegurando un cálculo preciso de los totales sin revisión manual. Procese miles de facturas por día con despliegue local y cero costos de API.
Documentación técnica
Los equipos de ingeniería convierten manuales y especificaciones en PDF a texto con capacidad de búsqueda. El reconocimiento de fórmulas preserva las ecuaciones matemáticas, haciendo que el contenido técnico sea legible por máquina. Ideal para proyectos de modernización de documentación heredada.
Análisis de documentos legales
Los profesionales legales revisan contratos y acuerdos con OCR que respeta la jerarquía del documento. El manejo de diseños de varias columnas asegura que los párrafos no se fusionen incorrectamente. El enfoque de privacidad primero mantiene los datos sensibles en las instalaciones.
Registros de atención médica
Las consultas médicas digitalizan formularios de pacientes y recetas. Reconoce 8 idiomas, útil para entornos de atención médica multilingües. El despliegue local cumple con los requisitos de conformidad HIPAA al mantener los datos internamente.
Conclusión
GLM-OCR ofrece comprensión de documentos de grado de producción en un paquete de 0.9B parámetros. Lo despliega localmente, mantiene la privacidad de los datos y logra tasas de rendimiento que rivalizan con las API en la nube, todo sin precios por solicitud. La arquitectura maneja diseños complejos, tablas y fórmulas que el OCR tradicional no detecta, mientras que la licencia MIT permite el uso comercial sin restricciones.
Elija vLLM para despliegues de producción que requieran alto rendimiento y compatibilidad con OpenAI. Use SGLang cuando la máxima velocidad de inferencia sea importante. Seleccione Transformers para desarrollo y pipelines personalizados. Cada opción ejecuta el mismo modelo subyacente, por lo que puede cambiar los métodos de despliegue sin volver a entrenar ni reajustar.
Al construir pipelines de procesamiento de documentos—ya sea extrayendo datos de facturas, analizando documentación técnica o automatizando el procesamiento de formularios—agilice sus pruebas de API con Apidog. Proporciona creación visual de solicitudes, generación automatizada de documentación y herramientas de depuración colaborativas que complementan su flujo de trabajo de despliegue de GLM-OCR.