Spaces:
Paused
Paused
File size: 3,490 Bytes
37d841f e07bad8 37d841f bad00cc 37d841f | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 | """Inferencia TrOCR optimizada para CPU (Intel Iris Xe y similares).
Mejoras vs versión original:
- Inferencia en BATCH: una sola pasada por N celdas en lugar de N pasadas.
- Cuantización INT8 dinámica en CPU (3-4x más rápido, <1% pérdida de accuracy).
- Greedy decoding (num_beams=1, do_sample=False) → mucho menos cómputo que beam search.
En GPU (CUDA) se desactiva la cuantización automáticamente, ya que solo aporta en CPU.
"""
import os
import numpy as np
import torch
from PIL import Image
from transformers import TrOCRProcessor, VisionEncoderDecoderModel
_processor = None
_model = None
_device = None
_FALLBACK_MODEL = "gcruzl3/trocr-checkscan"
def _should_quantize() -> bool:
from config import TROCR_QUANTIZE
if TROCR_QUANTIZE == "true":
return True
if TROCR_QUANTIZE == "false":
return False
# "auto" → cuantizar solo en CPU
return not torch.cuda.is_available()
def _load():
global _processor, _model, _device
if _model is not None:
return
from config import TROCR_MODEL_PATH
_device = "cuda" if torch.cuda.is_available() else "cpu"
model_id = TROCR_MODEL_PATH if os.path.isdir(TROCR_MODEL_PATH) else _FALLBACK_MODEL
print(f"[TrOCR] Cargando modelo '{model_id}' en {_device}...")
_processor = TrOCRProcessor.from_pretrained(model_id)
model = VisionEncoderDecoderModel.from_pretrained(model_id)
model.eval()
if _device == "cpu" and _should_quantize():
print("[TrOCR] Aplicando cuantización INT8 dinámica (Linear layers)...")
model = torch.quantization.quantize_dynamic(
model, {torch.nn.Linear}, dtype=torch.qint8
)
# Threads de CPU: usa todos los cores físicos.
try:
# os.cpu_count() en contenedores devuelve el total del host, no los vCPUs asignados
container_cpus = int(os.getenv("TROCR_NUM_THREADS", "0")) or min(os.cpu_count() or 4, 8)
torch.set_num_threads(max(1, container_cpus - 1))
except Exception:
pass
print(f"[TrOCR] Cuantizado. Threads CPU = {torch.get_num_threads()}")
_model = model.to(_device)
print("[TrOCR] Modelo listo.")
def _to_pil_rgb(cell_gray: np.ndarray) -> Image.Image:
return Image.fromarray(cell_gray).convert("RGB")
def transcribe_batch(cells: list[np.ndarray], batch_size: int | None = None) -> list[str]:
"""Transcribe una lista de celdas preprocesadas en batches.
Args:
cells: lista de arrays gris 64x384 (salida de preprocess_for_trocr).
batch_size: tamaño de batch. None → usa config.TROCR_BATCH_SIZE.
Returns:
Lista de strings transcritos, mismo orden que `cells`.
"""
if not cells:
return []
_load()
from config import TROCR_BATCH_SIZE
bs = batch_size or TROCR_BATCH_SIZE
images = [_to_pil_rgb(c) for c in cells]
results: list[str] = []
for i in range(0, len(images), bs):
chunk = images[i:i + bs]
pixel_values = _processor(chunk, return_tensors="pt").pixel_values.to(_device)
with torch.no_grad():
ids = _model.generate(pixel_values, num_beams=1, do_sample=False)
results.extend(t.strip() for t in _processor.batch_decode(ids, skip_special_tokens=True))
return results
def transcribe_cell(cell_gray: np.ndarray) -> str:
"""Compat: transcribe una sola celda. Internamente usa el path de batch."""
return transcribe_batch([cell_gray], batch_size=1)[0]
|