Add 1000 files (ocr-tech/tests/test_audit_limbu_book_missed_line_review_coverage.py ...)
d82db76 verified Download ocr-tech/tools/deva_rec_torch/common.py from prosperious/ocr-projects-archive: direct link, hf CLI and curl.
- Browser
- Download file 6.02 kB
-
https://huggingface.co/prosperious/ocr-projects-archive/resolve/main/ocr-tech/tools/deva_rec_torch/common.py
- Command line
-
hf download hf://prosperious/ocr-projects-archive/ocr-tech/tools/deva_rec_torch/common.py
-
curl -L -o common.py https://huggingface.co/prosperious/ocr-projects-archive/resolve/main/ocr-tech/tools/deva_rec_torch/common.py
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) | |