"""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)