prosperious's picture
Add 1000 files (ocr-tech/tests/test_audit_limbu_book_missed_line_review_coverage.py ...)
d82db76 verified
Raw History Blame Contribute Delete
6.02 kB
"""Shared PyTorch helpers for fine-tuning the official devanagari_PP-OCRv5_mobile_rec.
The model is the Hugging Face ``transformers`` port (``PPOCRV5MobileRecForTextRecognition``)
initialised from ``PaddlePaddle/devanagari_PP-OCRv5_mobile_rec_safetensors``. Preprocessing
mirrors PaddleX ``OCRReisizeNormImg`` (the path the k2 OCR worker serves): BGR input,
height 48, aspect-preserving width ``ceil(48 * w / h)``, ``(x / 255 - 0.5) / 0.5``,
zero padding on the right. Class 0 is the CTC blank, 1..568 the dictionary, 569 space.
"""
from __future__ import annotations
import json
import math
from pathlib import Path
import cv2
import numpy as np
import torch
import torch.nn.functional as F
from transformers import PPOCRV5MobileRecForTextRecognition
IMG_H = 48
MIN_W = 320
MAX_W = 3200
def load_character_list(model_dir: Path) -> list[str]:
cfg = json.loads((model_dir / "preprocessor_config.json").read_text(encoding="utf-8"))
chars = cfg["character_list"]
if chars[0] != "blank" or chars[-1] != " ":
raise ValueError(f"unexpected character_list layout in {model_dir}: {chars[:2]} ... {chars[-2:]}")
return chars
DEVICE_CHOICES = ("auto", "cuda", "mps", "cpu")
def pick_device(name: str = "auto") -> torch.device:
"""``auto`` prefers CUDA (T4), then MPS (k2), then CPU; an explicit device must be available."""
if name not in DEVICE_CHOICES:
raise ValueError(f"device must be one of {DEVICE_CHOICES}, got {name!r}")
if name == "auto":
if torch.cuda.is_available():
return torch.device("cuda")
return torch.device("mps" if torch.backends.mps.is_available() else "cpu")
if name == "cuda" and not torch.cuda.is_available():
raise RuntimeError("device cuda requested but torch.cuda.is_available() is False")
if name == "mps" and not torch.backends.mps.is_available():
raise RuntimeError("device mps requested but torch.backends.mps.is_available() is False")
return torch.device(name)
def load_model(model_dir: Path, device: torch.device) -> PPOCRV5MobileRecForTextRecognition:
model = PPOCRV5MobileRecForTextRecognition.from_pretrained(str(model_dir))
return model.to(device)
def read_bgr(path: Path) -> np.ndarray:
image = cv2.imread(str(path), cv2.IMREAD_COLOR)
if image is None:
raise FileNotFoundError(f"cannot decode image {path}")
return image
def resized_width(image: np.ndarray) -> int:
"""Resized width exactly as PaddleX ``OCRReisizeNormImg.resize`` computes it.
PaddleX pads to ``int(48 * max(320/48, w/h))`` (floor) and caps the aspect-preserving
``ceil(48 * w / h)`` at that value, so wide crops end up floor-width; above 3200 px the
crop is squeezed to 3200. A 1-px mismatch here changes SVTR attention and flips
low-confidence characters, so this must stay bit-identical to serving.
"""
h, w = image.shape[:2]
ratio = w / float(h)
padded = int(IMG_H * max(MIN_W / IMG_H, ratio))
if padded > MAX_W:
return MAX_W
wanted = int(math.ceil(IMG_H * ratio))
return padded if wanted > padded else max(1, wanted)
def padded_width(resized: int) -> int:
"""PaddleX single-image pad target for a crop of the given resized width."""
return max(MIN_W, resized)
def normalize(image: np.ndarray, width: int) -> np.ndarray:
"""PaddleX-identical resize + normalise into a (3, 48, width) float32 array (unpadded)."""
resized = cv2.resize(image, (width, IMG_H)).astype(np.float32)
return (resized.transpose(2, 0, 1) / 255.0 - 0.5) / 0.5
def batch_tensor(images: list[np.ndarray], widths: list[int]) -> torch.Tensor:
"""Pad a list of normalised images to one width (at least MIN_W), like PaddleX."""
target = max(MIN_W, max(widths))
out = np.zeros((len(images), 3, IMG_H, target), dtype=np.float32)
for index, (image, width) in enumerate(zip(images, widths, strict=True)):
out[index, :, :, :width] = normalize(image, width)
return torch.from_numpy(out)
def logits(model: PPOCRV5MobileRecForTextRecognition, pixel_values: torch.Tensor) -> torch.Tensor:
"""Raw pre-softmax logits (batch, T, classes); the HF head applies softmax itself."""
features = model.model(pixel_values).last_hidden_state
encoded = model.head.encoder(features).last_hidden_state
return model.head.head(encoded)
def ctc_greedy_decode(probs: torch.Tensor, chars: list[str]) -> list[tuple[str, float]]:
"""PaddleX CTCLabelDecode equivalent: argmax, collapse repeats, drop blanks."""
scores, indices = probs.max(dim=2)
results: list[tuple[str, float]] = []
for seq, conf in zip(indices.tolist(), scores.tolist(), strict=True):
text, kept = [], []
prev = -1
for position, idx in enumerate(seq):
if idx != prev and idx != 0:
text.append(chars[idx])
kept.append(conf[position])
prev = idx
results.append(("".join(text), float(np.mean(kept)) if kept else 0.0))
return results
def encode_label(text: str, char_to_index: dict[str, int]) -> list[int] | None:
ids = []
for ch in text:
idx = char_to_index.get(ch)
if idx is None:
return None
ids.append(idx)
return ids
def ctc_loss(raw_logits: torch.Tensor, targets: list[list[int]]) -> torch.Tensor:
log_probs = F.log_softmax(raw_logits.float(), dim=2).transpose(0, 1) # (T, B, C)
if log_probs.device.type == "mps": # MPS has no CTC kernel; CUDA and CPU compute in place
log_probs = log_probs.cpu()
device = log_probs.device
t = log_probs.shape[0]
input_lengths = torch.full((log_probs.shape[1],), t, dtype=torch.long, device=device)
target_lengths = torch.tensor([len(x) for x in targets], dtype=torch.long, device=device)
flat = torch.tensor([i for x in targets for i in x], dtype=torch.long, device=device)
return F.ctc_loss(log_probs, flat, input_lengths, target_lengths, blank=0,
reduction="mean", zero_infinity=True)