diff --git a/.gitattributes b/.gitattributes index d50ecf1aa8d86ff31aae00f0cae80b7eeceb37dd..6c02b1e99218ff05457c82c9a720a98011eaf29c 100644 --- a/.gitattributes +++ b/.gitattributes @@ -92,3 +92,7 @@ ocr-tech/paper/figures/limbu-recognizer-results.png filter=lfs diff=lfs merge=lf ocr-tech/paper/figures/limbu-source-evidence.png filter=lfs diff=lfs merge=lfs -text ocr-tech/paper/figures/research-program.png filter=lfs diff=lfs merge=lfs -text ocr-tech/paper/figures/system-architecture.png filter=lfs diff=lfs merge=lfs -text +k2-ampixa-demo-ocr/models/space/models/deva-v2/artifacts/inference.pdiparams filter=lfs diff=lfs merge=lfs -text +k2-ampixa-demo-ocr/models/space/models/devanagari-ppocrv5/artifacts/inference.pdiparams filter=lfs diff=lfs merge=lfs -text +k2-ampixa-demo-ocr/models/space/models/limbu-sirijonga-ft-v2/artifacts/inference.pdiparams filter=lfs diff=lfs merge=lfs -text +indra_nepali_exp.bundle filter=lfs diff=lfs merge=lfs -text diff --git a/indra_nepali_exp.bundle b/indra_nepali_exp.bundle new file mode 100644 index 0000000000000000000000000000000000000000..bf1695ba953fabd96316131996b98624a9f7a645 --- /dev/null +++ b/indra_nepali_exp.bundle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2865b1a55390019d82d1880abb90e16776e2edc0af591f50a0906860860b935d +size 43116997 diff --git a/jobs/eval_v4_last.sh b/jobs/eval_v4_last.sh new file mode 100644 index 0000000000000000000000000000000000000000..2e9ef3f2fa654b6a5bc8a19902ca9d349bcc217c --- /dev/null +++ b/jobs/eval_v4_last.sh @@ -0,0 +1,19 @@ +#!/bin/bash +# Served-path scoring of v4's final checkpoint against v3 and the official model, CPU only +# (both T4 GPUs are busy with other projects as of 2026-10-04). +set -euo pipefail +R=$HOME/ocr/ocr-tech/tools/deva_rec_torch/recipes/t4 +source "$R/env.sh" +source "$R/evalsets.sh" +export CUDA_VISIBLE_DEVICES="" +OUT=$FT/export/v4-last-onnx +if [ ! -f "$OUT/inference.onnx" ]; then + nice -n 10 "$TORCH_PY" "$CODE/export_onnx.py" "$FT/runs/deva-ft-v4-hw/last" "$FT/hf/devanagari_PP-OCRv5_mobile_rec_onnx" "$OUT" +fi +H4="h4_dhcd_digits_test:$D/hw-eval/h4_dhcd_digits_test:$D/hw-eval/h4_dhcd_digits_test/labels.txt" +nice -n 10 "$SERVE_PY" "$CODE/serve_predict.py" "$OUT" onnxruntime "$FT/preds/v4-last" "${EVALSETS[@]}" "${HWSETS[@]}" +nice -n 10 "$SERVE_PY" "$CODE/serve_predict.py" "$FT/export/v3-final-onnx" onnxruntime "$FT/preds/v3-final" "$H4" +nice -n 10 "$SERVE_PY" "$CODE/serve_predict.py" "$OCR_ROOT/k2-ampixa-demo-ocr/models/space/models/devanagari-ppocrv5/artifacts" paddle_static "$FT/preds/paddle-official" "$H4" +"$TORCH_PY" "$CODE/score.py" "$FT/preds/v4last_vs_v3_vs_official.json" \ + "official=$FT/preds/paddle-official" "v3=$FT/preds/v3-final" "v4last=$FT/preds/v4-last" -- "${EVALSETS[@]}" "${HWSETS[@]}" +echo EVAL_V4_DONE diff --git a/jobs/route_by_conf.py b/jobs/route_by_conf.py new file mode 100644 index 0000000000000000000000000000000000000000..7d65d12d7b42fc6a728a1868bb99d9894cf07758 --- /dev/null +++ b/jobs/route_by_conf.py @@ -0,0 +1,39 @@ +"""Would 'run v3 and v4-final, keep the more confident reading' get the best of both?""" +import sys +from pathlib import Path + +sys.path.insert(0, str(Path.home() / "ocr" / "ocr-tech" / "tools")) +from eval_metrics import evaluate # noqa: E402 + +FT = Path.home() / "ocr" / "ocr-deva-ft" +SETS = {} +for line in sys.stdin.read().split(): + name, root, labels = line.split(":") + SETS[name] = Path(labels) + + +def preds(system, name): + out = {} + for row in (FT / "preds" / system / f"{name}.tsv").read_text(encoding="utf-8").splitlines(): + parts = row.split("\t") + out[parts[0]] = (parts[1] if len(parts) > 1 else "", float(parts[2]) if len(parts) > 2 and parts[2] not in ("", "None") else 0.0) + return out + + +print("%-22s %8s %8s %8s %8s %s" % ("set", "v3", "v4last", "router", "oracle", "router picks v4")) +for name, labels in SETS.items(): + gold = dict(line.split("\t", 1) for line in labels.read_text(encoding="utf-8").splitlines() if "\t" in line) + a, b = preds("v3-final", name), preds("v4-last", name) + routed, oracle, picks = [], [], 0 + for rel, text in gold.items(): + (ta, sa), (tb, sb) = a[rel], b[rel] + pick_b = sb > sa + picks += pick_b + routed.append(((tb if pick_b else ta), text)) + ea = evaluate([(ta, text)])["cer_codepoint"] + eb = evaluate([(tb, text)])["cer_codepoint"] + oracle.append(((tb if eb < ea else ta), text)) + r = lambda pairs: evaluate(pairs)["cer_codepoint"] * 100 + print("%-22s %7.2f%% %7.2f%% %7.2f%% %7.2f%% %d/%d" % ( + name, r([(a[k][0], v) for k, v in gold.items()]), r([(b[k][0], v) for k, v in gold.items()]), + r(routed), r(oracle), picks, len(gold))) diff --git a/jobs/show_scores.py b/jobs/show_scores.py new file mode 100644 index 0000000000000000000000000000000000000000..20a0e1871cae2183f20263fe1d0f968f71fb53e1 --- /dev/null +++ b/jobs/show_scores.py @@ -0,0 +1,7 @@ +import json +import sys +d = json.load(open(sys.argv[1])) +for name, systems in d.items(): + n = next(iter(systems.values()))["n_lines"] + cells = " ".join("%s=%6.2f%%/%.2f" % (k, v["cer_codepoint"] * 100, v["exact_line_acc"]) for k, v in systems.items()) + print("%-22s n=%5d %s" % (name, n, cells)) diff --git a/k2-ampixa-demo-ocr/models/space/README.md b/k2-ampixa-demo-ocr/models/space/README.md new file mode 100644 index 0000000000000000000000000000000000000000..e662375bec3e905b1eec47c15cf22f1c4d6ea669 --- /dev/null +++ b/k2-ampixa-demo-ocr/models/space/README.md @@ -0,0 +1,59 @@ +--- +title: Limbu OCR +emoji: 📄 +colorFrom: blue +colorTo: green +sdk: docker +app_port: 7860 +pinned: false +license: apache-2.0 +--- + +# Limbu OCR + +Limbu-specific OCR for cropped lines, full page images, and small book/PDF batches. +It supports Sirijonga Limbu and Devanagari-written Limbu. + +This Space bundles: + +- Sirijonga line recognizer: `models/limbu-sirijonga-real-heavy/` +- Devanagari-written Limbu line recognizer: `models/limbu-devanagari-ppocrv5/` +- PaddleOCR full-page text detection for primary page and book OCR. +- Deterministic image-line segmentation as a fallback page/book path. +- Optional YOLO probe: `models/line-detector/best.pt` + +The operational page/book path does not depend on YOLO. The primary route uses +PaddleOCR's full-page detector, orders the detected text lines, routes each crop +through the bundled Sirijonga/Devanagari Paddle recognizers, and returns editable +Unicode text with crop and overlay evidence. The Paddle Book OCR tab accepts page +images or PDFs and returns a ZIP with `book.txt`, `book.json`, annotated pages, and +line crops. + +This is an operational OCR system for producing text and review evidence. It is not +yet a claim-safe benchmark result. + +## Local Run + +```bash +cd spaces/limbu-ocr +docker build -t limbu-ocr-space . +docker run --rm -p 7860:7860 limbu-ocr-space +``` + +Open `http://127.0.0.1:7860`. + +## Deploy To Hugging Face + +This Space has been uploaded to `https://huggingface.co/spaces/ampixa/limbu-ocr`. +See `DEPLOY.md` for the repeatable `uvx` upload command. + +```bash +cd spaces/limbu-ocr +git init +git add . +git commit -m "Add Limbu OCR Space" +git remote add origin https://huggingface.co/spaces/ampixa/limbu-ocr +git push origin main +``` + +Use a CPU Space for basic demos. Upgrade hardware if page OCR latency is too high. diff --git a/k2-ampixa-demo-ocr/models/space/app.py b/k2-ampixa-demo-ocr/models/space/app.py new file mode 100644 index 0000000000000000000000000000000000000000..8155b65fa4b7666508601b07fee74f4c256a0694 --- /dev/null +++ b/k2-ampixa-demo-ocr/models/space/app.py @@ -0,0 +1,1373 @@ +from __future__ import annotations + +import json +import math +import os +import re +import shutil +import tempfile +import zipfile +from dataclasses import dataclass +from datetime import UTC, datetime +from functools import lru_cache +from pathlib import Path +from typing import Any + +import gradio as gr +import numpy as np +from PIL import Image, ImageDraw, ImageOps + + +APP_ROOT = Path(__file__).resolve().parent +SIRIJONGA_MODEL_DIR = APP_ROOT / "models" / "limbu-sirijonga-ft-v2" / "artifacts" +DEVANAGARI_MODEL_DIR = APP_ROOT / "models" / "deva-v2" / "artifacts" +DETECTOR_MODEL_PATH = APP_ROOT / "models" / "line-detector" / "best.pt" + +LIMBU_RE = re.compile(r"[\u1900-\u194F]") +DEVANAGARI_RE = re.compile(r"[\u0900-\u097F]") + + +@dataclass(slots=True) +class Recognition: + text: str + confidence: float | None + engine: str + + def as_dict(self) -> dict[str, Any]: + return { + "text": self.text, + "confidence": self.confidence, + "engine": self.engine, + } + + +@dataclass(slots=True) +class Box: + left: int + top: int + right: int + bottom: int + confidence: float + + @property + def width(self) -> int: + return max(0, self.right - self.left) + + @property + def height(self) -> int: + return max(0, self.bottom - self.top) + + @property + def x_center(self) -> float: + return (self.left + self.right) / 2.0 + + @property + def y_center(self) -> float: + return (self.top + self.bottom) / 2.0 + + def as_dict(self) -> dict[str, Any]: + return { + "left": self.left, + "top": self.top, + "right": self.right, + "bottom": self.bottom, + "confidence": self.confidence, + } + + +@dataclass(slots=True) +class PaddleDetection: + box: Box + seed_text: str + seed_confidence: float | None + + def as_dict(self) -> dict[str, Any]: + return { + "box": self.box.as_dict(), + "seed_text": self.seed_text, + "seed_confidence": self.seed_confidence, + } + + +def _ensure_models_present(*, include_detector: bool = False) -> None: + required = [ + SIRIJONGA_MODEL_DIR / "inference.json", + SIRIJONGA_MODEL_DIR / "inference.pdiparams", + SIRIJONGA_MODEL_DIR / "inference.yml", + SIRIJONGA_MODEL_DIR / "limbu-sirijonga-v2.txt", + DEVANAGARI_MODEL_DIR / "inference.json", + DEVANAGARI_MODEL_DIR / "inference.pdiparams", + DEVANAGARI_MODEL_DIR / "inference.yml", + DEVANAGARI_MODEL_DIR / "nep_eng_dict.txt", + ] + if include_detector: + required.append(DETECTOR_MODEL_PATH) + missing = [str(path.relative_to(APP_ROOT)) for path in required if not path.exists()] + if missing: + raise RuntimeError("Missing bundled OCR artifacts: " + ", ".join(missing)) + + +def _normalize_image(image: Image.Image) -> Image.Image: + return ImageOps.exif_transpose(image).convert("RGB") + + +def _save_temp_image(image: Image.Image) -> Path: + tmp = tempfile.NamedTemporaryFile(prefix="limbu-ocr-", suffix=".png", delete=False) + tmp_path = Path(tmp.name) + tmp.close() + _normalize_image(image).save(tmp_path) + return tmp_path + + +@lru_cache(maxsize=1) +def _text_recognition_class() -> type[Any]: + try: + from paddleocr._models.text_recognition import TextRecognition + except ImportError as exc: + raise RuntimeError("PaddleOCR TextRecognition is unavailable in this runtime") from exc + return TextRecognition + + +@lru_cache(maxsize=2) +def _recognizer(engine: str) -> Any: + _ensure_models_present() + cls = _text_recognition_class() + if engine == "sirijonga": + model_dir = SIRIJONGA_MODEL_DIR + elif engine == "devanagari": + model_dir = DEVANAGARI_MODEL_DIR + else: + raise ValueError(f"unknown recognizer engine: {engine}") + return cls( + model_name="PP-OCRv5_mobile_rec", + model_dir=str(model_dir), + device=os.environ.get("LIMBU_OCR_PADDLE_DEVICE", "cpu"), + ) + + +@lru_cache(maxsize=1) +def _detector() -> Any: + _ensure_models_present(include_detector=True) + try: + from ultralytics import YOLO + except ImportError as exc: + raise RuntimeError("ultralytics is unavailable in this runtime") from exc + return YOLO(str(DETECTOR_MODEL_PATH)) + + +def _result_mapping(item: object) -> dict[str, object] | None: + payload: object = item + if not isinstance(payload, dict): + payload = getattr(item, "json", None) + if not isinstance(payload, dict): + return None + nested = payload.get("res") + return nested if isinstance(nested, dict) else payload + + +def _recognize_with_engine(image_path: Path, engine: str) -> Recognition: + raw_result = _recognizer(engine).predict(str(image_path)) + best_text = "" + best_confidence: float | None = None + for item in raw_result if isinstance(raw_result, list) else [raw_result]: + payload = _result_mapping(item) + if payload is None: + continue + text = payload.get("rec_text") or payload.get("text") or payload.get("transcription") or "" + score = payload.get("rec_score") or payload.get("score") or payload.get("confidence") + confidence = float(score) if score is not None else None + text = str(text).strip() + if not text: + continue + if best_confidence is None or (confidence is not None and confidence > best_confidence): + best_text = text + best_confidence = confidence + return Recognition(text=best_text, confidence=best_confidence, engine=engine) + + +def _script_score(recognition: Recognition) -> float: + text = recognition.text or "" + confidence = recognition.confidence if recognition.confidence is not None else 0.0 + limbu_chars = len(LIMBU_RE.findall(text)) + deva_chars = len(DEVANAGARI_RE.findall(text)) + if recognition.engine == "sirijonga": + return confidence + min(limbu_chars, 12) * 0.06 - min(deva_chars, 12) * 0.04 + if recognition.engine == "devanagari": + return confidence + min(deva_chars, 12) * 0.035 - min(limbu_chars, 12) * 0.08 + return confidence + + +def _recognize_line_path(image_path: Path, mode: str) -> tuple[Recognition, list[Recognition]]: + if mode == "Sirijonga": + rec = _recognize_with_engine(image_path, "sirijonga") + return rec, [rec] + if mode == "Devanagari": + rec = _recognize_with_engine(image_path, "devanagari") + return rec, [rec] + candidates = [ + _recognize_with_engine(image_path, "sirijonga"), + _recognize_with_engine(image_path, "devanagari"), + ] + return max(candidates, key=_script_score), candidates + + +def _engine_key(mode: str) -> str: + if mode == "Sirijonga": + return "sirijonga" + if mode == "Devanagari": + return "devanagari" + raise ValueError(f"unsupported Paddle seed recognizer: {mode}") + + +@lru_cache(maxsize=8) +def _paddle_page_ocr( + seed_engine: str, + text_det_limit_side_len: int, + text_det_thresh: float, + text_det_box_thresh: float, + text_det_unclip_ratio: float, +) -> Any: + _ensure_models_present() + try: + from paddleocr import PaddleOCR + except ImportError as exc: + raise RuntimeError("PaddleOCR is unavailable in this runtime") from exc + if seed_engine == "sirijonga": + model_dir = SIRIJONGA_MODEL_DIR + elif seed_engine == "devanagari": + model_dir = DEVANAGARI_MODEL_DIR + else: + raise ValueError(f"unsupported Paddle seed engine: {seed_engine}") + return PaddleOCR( + text_recognition_model_name="PP-OCRv5_mobile_rec", + text_recognition_model_dir=str(model_dir), + text_det_limit_side_len=max(256, int(text_det_limit_side_len)), + text_det_thresh=float(text_det_thresh), + text_det_box_thresh=float(text_det_box_thresh), + text_det_unclip_ratio=float(text_det_unclip_ratio), + use_doc_orientation_classify=False, + use_doc_unwarping=False, + use_textline_orientation=False, + ) + + +def _coerce_point_pair(value: object) -> tuple[float, float] | None: + if hasattr(value, "tolist"): + value = value.tolist() + if isinstance(value, list | tuple) and len(value) >= 2: + try: + return float(value[0]), float(value[1]) + except (TypeError, ValueError): + return None + return None + + +def _paddle_box_from_value(value: object, *, image_width: int, image_height: int, confidence: float | None) -> Box | None: + if hasattr(value, "tolist"): + value = value.tolist() + if isinstance(value, list | tuple) and len(value) == 4 and all(isinstance(item, int | float) for item in value): + left, top, right, bottom = [float(item) for item in value] + if right < left: + left, right = right, left + if bottom < top: + top, bottom = bottom, top + elif isinstance(value, list | tuple): + points = [_coerce_point_pair(point) for point in value] + clean_points = [point for point in points if point is not None] + if not clean_points: + return None + left = min(point[0] for point in clean_points) + top = min(point[1] for point in clean_points) + right = max(point[0] for point in clean_points) + bottom = max(point[1] for point in clean_points) + else: + return None + box = Box( + left=max(0, int(math.floor(left))), + top=max(0, int(math.floor(top))), + right=min(image_width, int(math.ceil(right))), + bottom=min(image_height, int(math.ceil(bottom))), + confidence=float(confidence) if confidence is not None else 1.0, + ) + return box if box.width > 0 and box.height > 0 else None + + +def _as_list(value: object) -> list[Any]: + if value is None: + return [] + if hasattr(value, "tolist"): + value = value.tolist() + return value if isinstance(value, list) else [] + + +def _first_payload_list(payload: dict[str, object], keys: tuple[str, ...]) -> list[Any]: + for key in keys: + values = _as_list(payload.get(key)) + if values: + return values + return [] + + +def _paddle_detections_from_result(raw_result: object, *, image_width: int, image_height: int) -> list[PaddleDetection]: + candidates = raw_result + if isinstance(raw_result, list) and len(raw_result) == 1 and isinstance(raw_result[0], list): + candidates = raw_result[0] + if not isinstance(candidates, list): + candidates = [candidates] + + detections: list[PaddleDetection] = [] + for item in candidates: + payload = _result_mapping(item) + if payload is None: + continue + boxes = _first_payload_list(payload, ("rec_polys", "dt_polys", "rec_boxes", "dt_boxes")) + texts = _first_payload_list(payload, ("rec_texts", "texts")) + scores = _first_payload_list(payload, ("rec_scores", "scores")) + for index, raw_box in enumerate(boxes): + score: float | None = None + if index < len(scores) and scores[index] is not None: + try: + score = float(scores[index]) + except (TypeError, ValueError): + score = None + box = _paddle_box_from_value(raw_box, image_width=image_width, image_height=image_height, confidence=score) + if box is None: + continue + seed_text = str(texts[index]).strip() if index < len(texts) and texts[index] is not None else "" + detections.append(PaddleDetection(box=box, seed_text=seed_text, seed_confidence=score)) + return detections + + +def _predict_paddle_page_detections( + image: Image.Image, + *, + seed_recognizer: str, + text_det_limit_side_len: int, + text_det_thresh: float, + text_det_box_thresh: float, + text_det_unclip_ratio: float, +) -> list[PaddleDetection]: + normalized = _normalize_image(image) + page_path = _save_temp_image(normalized) + try: + ocr = _paddle_page_ocr( + _engine_key(seed_recognizer), + int(text_det_limit_side_len), + float(text_det_thresh), + float(text_det_box_thresh), + float(text_det_unclip_ratio), + ) + raw_result = ocr.predict(str(page_path)) + finally: + page_path.unlink(missing_ok=True) + return _paddle_detections_from_result(raw_result, image_width=normalized.width, image_height=normalized.height) + + +def recognize_line(image: Image.Image | None, mode: str) -> tuple[str, str]: + if image is None: + return "", "Upload a cropped text line image." + path = _save_temp_image(image) + try: + best, candidates = _recognize_line_path(path, mode) + finally: + path.unlink(missing_ok=True) + details = { + "selected_engine": best.engine, + "selected_confidence": best.confidence, + "candidates": [candidate.as_dict() for candidate in candidates], + } + return best.text, json.dumps(details, ensure_ascii=False, indent=2) + + +def _detect_boxes(image_path: Path, confidence: float) -> list[Box]: + result = _detector().predict( + source=str(image_path), + imgsz=1280, + conf=float(confidence), + verbose=False, + )[0] + boxes: list[Box] = [] + raw_boxes = getattr(result, "boxes", None) + if raw_boxes is None: + return boxes + xyxy_values = raw_boxes.xyxy.cpu().numpy() if hasattr(raw_boxes.xyxy, "cpu") else np.asarray(raw_boxes.xyxy) + conf_values = raw_boxes.conf.cpu().numpy() if hasattr(raw_boxes.conf, "cpu") else np.asarray(raw_boxes.conf) + for xyxy, conf in zip(xyxy_values, conf_values, strict=False): + left, top, right, bottom = [int(round(float(value))) for value in xyxy[:4]] + if right <= left or bottom <= top: + continue + boxes.append(Box(left=left, top=top, right=right, bottom=bottom, confidence=float(conf))) + return boxes + + +def _order_boxes(boxes: list[Box], mode: str, image_width: int) -> list[Box]: + if mode == "Two columns LTR": + return sorted(boxes, key=lambda box: (0 if box.x_center < image_width / 2 else 1, box.y_center, box.x_center)) + if mode == "Two columns RTL": + return sorted(boxes, key=lambda box: (0 if box.x_center >= image_width / 2 else 1, box.y_center, box.x_center)) + row_height = max(12, int(np.median([box.height for box in boxes])) if boxes else 24) + return sorted(boxes, key=lambda box: (math.floor(box.y_center / row_height), box.x_center)) + + +def _crop_box(image: Image.Image, box: Box, padding: int) -> Image.Image: + left = max(0, box.left - padding) + top = max(0, box.top - padding) + right = min(image.width, box.right + padding) + bottom = min(image.height, box.bottom + padding) + return image.crop((left, top, right, bottom)) + + +def _draw_boxes(image: Image.Image, boxes: list[Box]) -> Image.Image: + annotated = image.copy() + draw = ImageDraw.Draw(annotated) + for index, box in enumerate(boxes, start=1): + draw.rectangle((box.left, box.top, box.right, box.bottom), outline=(28, 120, 92), width=3) + draw.text((box.left + 4, max(0, box.top - 18)), str(index), fill=(28, 120, 92)) + return annotated + + +def _box_iou(left: Box, right: Box) -> float: + overlap_left = max(left.left, right.left) + overlap_top = max(left.top, right.top) + overlap_right = min(left.right, right.right) + overlap_bottom = min(left.bottom, right.bottom) + overlap_width = max(0, overlap_right - overlap_left) + overlap_height = max(0, overlap_bottom - overlap_top) + intersection = overlap_width * overlap_height + if intersection <= 0: + return 0.0 + left_area = max(1, left.width * left.height) + right_area = max(1, right.width * right.height) + return intersection / float(left_area + right_area - intersection) + + +def _merge_overlapping_boxes(boxes: list[Box], threshold: float = 0.80) -> list[Box]: + merged: list[Box] = [] + for box in sorted(boxes, key=lambda item: item.confidence, reverse=True): + if any(_box_iou(box, kept) >= threshold for kept in merged): + continue + merged.append(box) + return merged + + +def _cv2_threshold(gray: Image.Image, threshold: int) -> Any: + try: + import cv2 + except ImportError as exc: + raise RuntimeError("OpenCV is unavailable; deterministic page OCR requires opencv-python-headless") from exc + pixels = np.asarray(gray) + if threshold <= 0: + _value, binary = cv2.threshold(pixels, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU) + else: + _value, binary = cv2.threshold(pixels, int(threshold), 255, cv2.THRESH_BINARY_INV) + return cv2, binary + + +def _detect_image_line_boxes( + image: Image.Image, + *, + threshold: int, + horizontal_kernel: int, + vertical_kernel: int, + dilation_iterations: int, + min_width: int, + min_height: int, + max_height: int, + min_area: int, + padding: int, +) -> list[Box]: + normalized = _normalize_image(image) + gray = ImageOps.grayscale(normalized) + cv2, binary = _cv2_threshold(gray, threshold) + kernel = cv2.getStructuringElement( + cv2.MORPH_RECT, + (max(1, int(horizontal_kernel)), max(1, int(vertical_kernel))), + ) + dilated = cv2.dilate(binary, kernel, iterations=max(1, int(dilation_iterations))) + contours, _hierarchy = cv2.findContours(dilated, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) + boxes: list[Box] = [] + for contour in contours: + x, y, width, height = cv2.boundingRect(contour) + area = int(width * height) + if width < min_width or height < min_height or area < min_area: + continue + if max_height > 0 and height > max_height: + continue + left = max(0, int(x) - padding) + top = max(0, int(y) - padding) + right = min(normalized.width, int(x + width) + padding) + bottom = min(normalized.height, int(y + height) + padding) + if right <= left or bottom <= top: + continue + boxes.append(Box(left=left, top=top, right=right, bottom=bottom, confidence=1.0)) + return _merge_overlapping_boxes(boxes) + + +def _has_two_column_shape(boxes: list[Box], image_width: int) -> bool: + if len(boxes) < 8 or image_width <= 0: + return False + midpoint = image_width / 2.0 + left = [box for box in boxes if box.x_center < midpoint] + right = [box for box in boxes if box.x_center >= midpoint] + if len(left) < 3 or len(right) < 3: + return False + left_median = float(np.median([box.x_center for box in left])) + right_median = float(np.median([box.x_center for box in right])) + return (right_median - left_median) >= image_width * 0.22 + + +def _order_image_line_boxes(boxes: list[Box], mode: str, image_width: int) -> list[Box]: + if mode == "Auto": + mode = "Columns LTR" if _has_two_column_shape(boxes, image_width) else "Rows LTR" + if mode == "Columns LTR": + return sorted(boxes, key=lambda box: (0 if box.x_center < image_width / 2 else 1, box.y_center, box.x_center)) + if mode == "Columns RTL": + return sorted(boxes, key=lambda box: (0 if box.x_center >= image_width / 2 else 1, box.y_center, box.x_center)) + row_height = max(12, int(np.median([box.height for box in boxes])) if boxes else 24) + return sorted(boxes, key=lambda box: (math.floor(box.y_center / row_height), box.x_center)) + + +def _recognize_page_core( + image: Image.Image, + *, + mode: str, + reading_order: str, + threshold: int, + horizontal_kernel: int, + vertical_kernel: int, + dilation_iterations: int, + min_width: int, + min_height: int, + max_height: int, + min_area: int, + crop_padding: int, + max_lines: int, + artifact_dir: Path | None = None, + page_index: int = 0, +) -> dict[str, Any]: + normalized = _normalize_image(image) + boxes = _detect_image_line_boxes( + normalized, + threshold=threshold, + horizontal_kernel=horizontal_kernel, + vertical_kernel=vertical_kernel, + dilation_iterations=dilation_iterations, + min_width=min_width, + min_height=min_height, + max_height=max_height, + min_area=min_area, + padding=max(0, int(crop_padding // 2)), + ) + boxes = _order_image_line_boxes(boxes, reading_order, normalized.width) + if max_lines > 0: + boxes = boxes[: int(max_lines)] + + lines: list[str] = [] + gallery: list[tuple[Image.Image, str]] = [] + rows: list[dict[str, Any]] = [] + crop_dir = artifact_dir / "crops" / f"page-{page_index + 1:04d}" if artifact_dir is not None else None + if crop_dir is not None: + crop_dir.mkdir(parents=True, exist_ok=True) + + with tempfile.TemporaryDirectory(prefix="limbu-page-image-line-") as tmp_dir_name: + tmp_dir = Path(tmp_dir_name) + for index, box in enumerate(boxes, start=1): + crop = _crop_box(normalized, box, int(crop_padding)) + crop_path = tmp_dir / f"line-{index:04d}.png" + crop.save(crop_path) + best, candidates = _recognize_line_path(crop_path, mode) + if best.text: + lines.append(best.text) + saved_crop_path: str | None = None + if crop_dir is not None: + saved_crop = crop_dir / f"line-{index:04d}.png" + crop.save(saved_crop) + saved_crop_path = str(saved_crop.relative_to(artifact_dir)) + rows.append( + { + "page_index": page_index, + "index": index, + "box": box.as_dict(), + "crop_path": saved_crop_path, + "selected_engine": best.engine, + "selected_confidence": best.confidence, + "text": best.text, + "candidates": [candidate.as_dict() for candidate in candidates], + } + ) + caption = f"{index}. {best.text}" if best.text else f"{index}. " + gallery.append((crop, caption)) + + annotated = _draw_boxes(normalized, boxes) + annotated_path: str | None = None + if artifact_dir is not None: + page_dir = artifact_dir / "annotated-pages" + page_dir.mkdir(parents=True, exist_ok=True) + target = page_dir / f"page-{page_index + 1:04d}.png" + annotated.save(target) + annotated_path = str(target.relative_to(artifact_dir)) + return { + "text": "\n".join(lines), + "annotated": annotated, + "annotated_path": annotated_path, + "gallery": gallery, + "rows": rows, + "line_count": len(boxes), + "detector": "deterministic image-line projection", + "reading_order": reading_order, + "threshold": threshold, + "horizontal_kernel": horizontal_kernel, + "vertical_kernel": vertical_kernel, + "dilation_iterations": dilation_iterations, + } + + +def _recognize_page_paddle_core( + image: Image.Image, + *, + mode: str, + seed_recognizer: str, + reading_order: str, + text_det_limit_side_len: int, + text_det_thresh: float, + text_det_box_thresh: float, + text_det_unclip_ratio: float, + crop_padding: int, + max_lines: int, + artifact_dir: Path | None = None, + page_index: int = 0, +) -> dict[str, Any]: + normalized = _normalize_image(image) + detections = _predict_paddle_page_detections( + normalized, + seed_recognizer=seed_recognizer, + text_det_limit_side_len=text_det_limit_side_len, + text_det_thresh=text_det_thresh, + text_det_box_thresh=text_det_box_thresh, + text_det_unclip_ratio=text_det_unclip_ratio, + ) + ordered_boxes = _order_image_line_boxes([detection.box for detection in detections], reading_order, normalized.width) + detection_by_box = {(detection.box.left, detection.box.top, detection.box.right, detection.box.bottom): detection for detection in detections} + ordered_detections = [ + detection_by_box[(box.left, box.top, box.right, box.bottom)] + for box in ordered_boxes + if (box.left, box.top, box.right, box.bottom) in detection_by_box + ] + if max_lines > 0: + ordered_detections = ordered_detections[: int(max_lines)] + + lines: list[str] = [] + gallery: list[tuple[Image.Image, str]] = [] + rows: list[dict[str, Any]] = [] + crop_dir = artifact_dir / "crops" / f"page-{page_index + 1:04d}" if artifact_dir is not None else None + if crop_dir is not None: + crop_dir.mkdir(parents=True, exist_ok=True) + + with tempfile.TemporaryDirectory(prefix="limbu-page-paddle-") as tmp_dir_name: + tmp_dir = Path(tmp_dir_name) + for index, detection in enumerate(ordered_detections, start=1): + crop = _crop_box(normalized, detection.box, int(crop_padding)) + crop_path = tmp_dir / f"line-{index:04d}.png" + crop.save(crop_path) + best, candidates = _recognize_line_path(crop_path, mode) + if best.text: + lines.append(best.text) + saved_crop_path: str | None = None + if crop_dir is not None: + saved_crop = crop_dir / f"line-{index:04d}.png" + crop.save(saved_crop) + saved_crop_path = str(saved_crop.relative_to(artifact_dir)) + rows.append( + { + "page_index": page_index, + "index": index, + "box": detection.box.as_dict(), + "crop_path": saved_crop_path, + "paddle_seed_recognizer": seed_recognizer, + "paddle_seed_text": detection.seed_text, + "paddle_seed_confidence": detection.seed_confidence, + "selected_engine": best.engine, + "selected_confidence": best.confidence, + "text": best.text, + "candidates": [candidate.as_dict() for candidate in candidates], + } + ) + caption = f"{index}. {best.text}" if best.text else f"{index}. " + gallery.append((crop, caption)) + + boxes = [detection.box for detection in ordered_detections] + annotated = _draw_boxes(normalized, boxes) + annotated_path: str | None = None + if artifact_dir is not None: + page_dir = artifact_dir / "annotated-pages" + page_dir.mkdir(parents=True, exist_ok=True) + target = page_dir / f"page-{page_index + 1:04d}.png" + annotated.save(target) + annotated_path = str(target.relative_to(artifact_dir)) + return { + "text": "\n".join(lines), + "annotated": annotated, + "annotated_path": annotated_path, + "gallery": gallery, + "rows": rows, + "line_count": len(ordered_detections), + "detector": "PaddleOCR PP-OCRv5 full-page text detector", + "reading_order": reading_order, + "seed_recognizer": seed_recognizer, + "text_det_limit_side_len": text_det_limit_side_len, + "text_det_thresh": text_det_thresh, + "text_det_box_thresh": text_det_box_thresh, + "text_det_unclip_ratio": text_det_unclip_ratio, + } + + +def recognize_page_paddle( + image: Image.Image | None, + mode: str, + seed_recognizer: str, + reading_order: str, + text_det_limit_side_len: int, + text_det_thresh: float, + text_det_box_thresh: float, + text_det_unclip_ratio: float, + crop_padding: int, + max_lines: int, +) -> tuple[str, Image.Image | None, list[tuple[Image.Image, str]], str]: + if image is None: + return "", None, [], "Upload a page image." + + result = _recognize_page_paddle_core( + image, + mode=mode, + seed_recognizer=seed_recognizer, + reading_order=reading_order, + text_det_limit_side_len=text_det_limit_side_len, + text_det_thresh=text_det_thresh, + text_det_box_thresh=text_det_box_thresh, + text_det_unclip_ratio=text_det_unclip_ratio, + crop_padding=crop_padding, + max_lines=max_lines, + ) + details = { + "detector": result["detector"], + "reading_order": result["reading_order"], + "line_count": result["line_count"], + "recognition_mode": mode, + "paddle_seed_recognizer": result["seed_recognizer"], + "paddle": { + "text_det_limit_side_len": result["text_det_limit_side_len"], + "text_det_thresh": result["text_det_thresh"], + "text_det_box_thresh": result["text_det_box_thresh"], + "text_det_unclip_ratio": result["text_det_unclip_ratio"], + }, + "segmentation": { + "crop_padding": crop_padding, + }, + "rows": result["rows"], + } + return result["text"], result["annotated"], result["gallery"], json.dumps(details, ensure_ascii=False, indent=2) + + +def recognize_page( + image: Image.Image | None, + mode: str, + reading_order: str, + threshold: int, + horizontal_kernel: int, + vertical_kernel: int, + dilation_iterations: int, + min_width: int, + min_height: int, + max_height: int, + min_area: int, + crop_padding: int, + max_lines: int, +) -> tuple[str, Image.Image | None, list[tuple[Image.Image, str]], str]: + if image is None: + return "", None, [], "Upload a page image." + + result = _recognize_page_core( + image, + mode=mode, + reading_order=reading_order, + threshold=threshold, + horizontal_kernel=horizontal_kernel, + vertical_kernel=vertical_kernel, + dilation_iterations=dilation_iterations, + min_width=min_width, + min_height=min_height, + max_height=max_height, + min_area=min_area, + crop_padding=crop_padding, + max_lines=max_lines, + ) + details = { + "detector": result["detector"], + "reading_order": result["reading_order"], + "line_count": result["line_count"], + "recognition_mode": mode, + "segmentation": { + "threshold": result["threshold"], + "horizontal_kernel": result["horizontal_kernel"], + "vertical_kernel": result["vertical_kernel"], + "dilation_iterations": result["dilation_iterations"], + "min_width": min_width, + "min_height": min_height, + "max_height": max_height, + "min_area": min_area, + "crop_padding": crop_padding, + }, + "rows": result["rows"], + } + return result["text"], result["annotated"], result["gallery"], json.dumps(details, ensure_ascii=False, indent=2) + + +def recognize_page_yolo( + image: Image.Image | None, + mode: str, + detector_confidence: float, + reading_order: str, + crop_padding: int, + max_lines: int, +) -> tuple[str, Image.Image | None, list[tuple[Image.Image, str]], str]: + if image is None: + return "", None, [], "Upload a page image." + + normalized = _normalize_image(image) + page_path = _save_temp_image(normalized) + try: + boxes = _detect_boxes(page_path, detector_confidence) + finally: + page_path.unlink(missing_ok=True) + + boxes = _order_boxes(boxes, reading_order, normalized.width) + if max_lines > 0: + boxes = boxes[: int(max_lines)] + + lines: list[str] = [] + gallery: list[tuple[Image.Image, str]] = [] + rows: list[dict[str, Any]] = [] + with tempfile.TemporaryDirectory(prefix="limbu-page-ocr-") as tmp_dir_name: + tmp_dir = Path(tmp_dir_name) + for index, box in enumerate(boxes, start=1): + crop = _crop_box(normalized, box, int(crop_padding)) + crop_path = tmp_dir / f"line-{index:04d}.png" + crop.save(crop_path) + best, candidates = _recognize_line_path(crop_path, mode) + if best.text: + lines.append(best.text) + rows.append( + { + "index": index, + "box": box.as_dict(), + "selected_engine": best.engine, + "selected_confidence": best.confidence, + "text": best.text, + "candidates": [candidate.as_dict() for candidate in candidates], + } + ) + caption = f"{index}. {best.text}" if best.text else f"{index}. " + gallery.append((crop, caption)) + + text = "\n".join(lines) + annotated = _draw_boxes(normalized, boxes) + details = { + "detector": "YOLO cdc-grade1-allbooks-v1", + "detector_confidence": detector_confidence, + "reading_order": reading_order, + "line_count": len(boxes), + "recognition_mode": mode, + "rows": rows, + "warning": "Prototype page OCR. Detector was trained on rendered/augmented CDC pages; verify output before using it as text.", + } + return text, annotated, gallery, json.dumps(details, ensure_ascii=False, indent=2) + + +def _uploaded_path(item: object) -> Path: + if isinstance(item, str | Path): + return Path(item) + name = getattr(item, "name", None) + if isinstance(name, str): + return Path(name) + path = getattr(item, "path", None) + if isinstance(path, str): + return Path(path) + raise ValueError(f"unsupported uploaded file object: {type(item).__name__}") + + +def _render_pdf_pages(path: Path, *, dpi: int, max_pages: int) -> list[tuple[str, Image.Image]]: + try: + import pypdfium2 as pdfium + except ImportError as exc: + raise RuntimeError("PDF input requires pypdfium2 in the Space runtime") from exc + pages: list[tuple[str, Image.Image]] = [] + pdf = pdfium.PdfDocument(str(path)) + limit = len(pdf) if max_pages <= 0 else min(len(pdf), max_pages) + scale = max(72, int(dpi)) / 72.0 + for page_index in range(limit): + page = pdf[page_index] + bitmap = page.render(scale=scale) + pages.append((f"{path.name}:p{page_index + 1}", bitmap.to_pil().convert("RGB"))) + return pages + + +def _load_book_pages(files: list[object] | None, *, pdf_dpi: int, max_pages: int) -> list[tuple[str, Image.Image]]: + if not files: + return [] + pages: list[tuple[str, Image.Image]] = [] + for item in files: + path = _uploaded_path(item) + suffix = path.suffix.lower() + remaining = 0 if max_pages <= 0 else max_pages - len(pages) + if max_pages > 0 and remaining <= 0: + break + if suffix == ".pdf": + pages.extend(_render_pdf_pages(path, dpi=pdf_dpi, max_pages=remaining)) + continue + if suffix not in {".png", ".jpg", ".jpeg", ".webp", ".bmp", ".tif", ".tiff"}: + raise ValueError(f"unsupported book input file type: {path.name}") + with Image.open(path) as image: + pages.append((path.name, _normalize_image(image))) + return pages[:max_pages] if max_pages > 0 else pages + + +def _zip_directory(source_dir: Path) -> Path: + zip_path = Path(tempfile.NamedTemporaryFile(prefix="limbu-book-ocr-", suffix=".zip", delete=False).name) + with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as archive: + for path in sorted(source_dir.rglob("*")): + if path.is_file(): + archive.write(path, path.relative_to(source_dir)) + return zip_path + + +def recognize_book_paddle( + files: list[object] | None, + mode: str, + seed_recognizer: str, + reading_order: str, + text_det_limit_side_len: int, + text_det_thresh: float, + text_det_box_thresh: float, + text_det_unclip_ratio: float, + crop_padding: int, + max_lines_per_page: int, + max_pages: int, + pdf_dpi: int, +) -> tuple[str, str | None, str]: + pages = _load_book_pages(files, pdf_dpi=pdf_dpi, max_pages=max_pages) + if not pages: + return "", None, "Upload page images or a PDF." + + artifact_dir = Path(tempfile.mkdtemp(prefix="limbu-book-paddle-artifacts-")) + page_payloads: list[dict[str, Any]] = [] + page_texts: list[str] = [] + try: + for page_index, (source_name, image) in enumerate(pages): + page_result = _recognize_page_paddle_core( + image, + mode=mode, + seed_recognizer=seed_recognizer, + reading_order=reading_order, + text_det_limit_side_len=text_det_limit_side_len, + text_det_thresh=text_det_thresh, + text_det_box_thresh=text_det_box_thresh, + text_det_unclip_ratio=text_det_unclip_ratio, + crop_padding=crop_padding, + max_lines=max_lines_per_page, + artifact_dir=artifact_dir, + page_index=page_index, + ) + page_text = page_result["text"] + page_texts.append(page_text) + page_payloads.append( + { + "page_index": page_index, + "source_name": source_name, + "line_count": page_result["line_count"], + "annotated_path": page_result["annotated_path"], + "text": page_text, + "lines": page_result["rows"], + } + ) + book_text = "\n\n".join(text for text in page_texts if text.strip()) + payload = { + "created_at_utc": datetime.now(UTC).isoformat(), + "system": "limbu-book-ocr-paddle-v1", + "detector": "PaddleOCR PP-OCRv5 full-page text detector", + "recognition_mode": mode, + "paddle_seed_recognizer": seed_recognizer, + "reading_order": reading_order, + "page_count": len(page_payloads), + "line_count": sum(int(page["line_count"]) for page in page_payloads), + "paddle": { + "text_det_limit_side_len": text_det_limit_side_len, + "text_det_thresh": text_det_thresh, + "text_det_box_thresh": text_det_box_thresh, + "text_det_unclip_ratio": text_det_unclip_ratio, + }, + "segmentation": { + "crop_padding": crop_padding, + }, + "pages": page_payloads, + } + (artifact_dir / "book.txt").write_text(book_text + ("\n" if book_text else ""), encoding="utf-8") + (artifact_dir / "book.json").write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + zip_path = _zip_directory(artifact_dir) + finally: + shutil.rmtree(artifact_dir, ignore_errors=True) + + details = { + "page_count": len(page_payloads), + "line_count": sum(int(page["line_count"]) for page in page_payloads), + "artifact_zip": str(zip_path), + "warning": "Paddle-first operational OCR output with crop evidence; benchmark claims still require frozen-page scoring.", + } + return book_text, str(zip_path), json.dumps(details, ensure_ascii=False, indent=2) + + +def recognize_book( + files: list[object] | None, + mode: str, + reading_order: str, + threshold: int, + horizontal_kernel: int, + vertical_kernel: int, + dilation_iterations: int, + min_width: int, + min_height: int, + max_height: int, + min_area: int, + crop_padding: int, + max_lines_per_page: int, + max_pages: int, + pdf_dpi: int, +) -> tuple[str, str | None, str]: + pages = _load_book_pages(files, pdf_dpi=pdf_dpi, max_pages=max_pages) + if not pages: + return "", None, "Upload page images or a PDF." + + artifact_dir = Path(tempfile.mkdtemp(prefix="limbu-book-ocr-artifacts-")) + page_payloads: list[dict[str, Any]] = [] + page_texts: list[str] = [] + try: + for page_index, (source_name, image) in enumerate(pages): + page_result = _recognize_page_core( + image, + mode=mode, + reading_order=reading_order, + threshold=threshold, + horizontal_kernel=horizontal_kernel, + vertical_kernel=vertical_kernel, + dilation_iterations=dilation_iterations, + min_width=min_width, + min_height=min_height, + max_height=max_height, + min_area=min_area, + crop_padding=crop_padding, + max_lines=max_lines_per_page, + artifact_dir=artifact_dir, + page_index=page_index, + ) + page_text = page_result["text"] + page_texts.append(page_text) + page_payloads.append( + { + "page_index": page_index, + "source_name": source_name, + "line_count": page_result["line_count"], + "annotated_path": page_result["annotated_path"], + "text": page_text, + "lines": page_result["rows"], + } + ) + book_text = "\n\n".join(text for text in page_texts if text.strip()) + payload = { + "created_at_utc": datetime.now(UTC).isoformat(), + "system": "limbu-book-ocr-v1", + "detector": "deterministic image-line projection", + "recognition_mode": mode, + "reading_order": reading_order, + "page_count": len(page_payloads), + "line_count": sum(int(page["line_count"]) for page in page_payloads), + "segmentation": { + "threshold": threshold, + "horizontal_kernel": horizontal_kernel, + "vertical_kernel": vertical_kernel, + "dilation_iterations": dilation_iterations, + "min_width": min_width, + "min_height": min_height, + "max_height": max_height, + "min_area": min_area, + "crop_padding": crop_padding, + }, + "pages": page_payloads, + } + (artifact_dir / "book.txt").write_text(book_text + ("\n" if book_text else ""), encoding="utf-8") + (artifact_dir / "book.json").write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + zip_path = _zip_directory(artifact_dir) + finally: + shutil.rmtree(artifact_dir, ignore_errors=True) + + details = { + "page_count": len(page_payloads), + "line_count": sum(int(page["line_count"]) for page in page_payloads), + "artifact_zip": str(zip_path), + "warning": "This is operational OCR output with crop evidence, not a benchmark-quality claim.", + } + return book_text, str(zip_path), json.dumps(details, ensure_ascii=False, indent=2) + + +def health() -> str: + status: dict[str, Any] = { + "sirijonga_model": SIRIJONGA_MODEL_DIR.exists(), + "devanagari_model": DEVANAGARI_MODEL_DIR.exists(), + "line_detector": DETECTOR_MODEL_PATH.exists(), + "paddle_device": os.environ.get("LIMBU_OCR_PADDLE_DEVICE", "cpu"), + } + try: + _ensure_models_present() + status["artifact_check"] = "pass" + except Exception as exc: + status["artifact_check"] = f"fail: {type(exc).__name__}: {exc}" + return json.dumps(status, ensure_ascii=False, indent=2) + + +CSS = """ +.output-markdown textarea { font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace; } +""" + + +with gr.Blocks(title="Limbu OCR", css=CSS) as demo: + gr.Markdown( + """ +# Limbu OCR + +OCR for Sirijonga Limbu and Devanagari-written Limbu. The primary page and book +paths use PaddleOCR full-page text detection with the bundled Limbu recognizers, and +preserve crop evidence beside Unicode output. +""" + ) + + with gr.Tab("Line OCR"): + with gr.Row(): + line_image = gr.Image(type="pil", label="Cropped text line") + with gr.Column(): + line_mode = gr.Radio(["Auto", "Sirijonga", "Devanagari"], value="Auto", label="Recognizer") + line_button = gr.Button("Recognize Line", variant="primary") + line_text = gr.Textbox(label="Unicode text", lines=4) + line_details = gr.Code(label="Details", language="json") + line_button.click(recognize_line, inputs=[line_image, line_mode], outputs=[line_text, line_details]) + + with gr.Tab("Paddle Page OCR"): + with gr.Row(): + paddle_page_image = gr.Image(type="pil", label="Page image") + with gr.Column(): + paddle_page_mode = gr.Radio(["Auto", "Sirijonga", "Devanagari"], value="Auto", label="Recognizer") + paddle_page_seed = gr.Radio(["Sirijonga", "Devanagari"], value="Sirijonga", label="Paddle seed recognizer") + paddle_page_order = gr.Radio( + ["Auto", "Rows LTR", "Columns LTR", "Columns RTL"], + value="Rows LTR", + label="Reading order", + ) + paddle_page_limit = gr.Slider(512, 2048, value=1280, step=64, label="Paddle detector side limit") + paddle_page_thresh = gr.Slider(0.10, 0.90, value=0.30, step=0.05, label="Paddle det threshold") + paddle_page_box_thresh = gr.Slider(0.10, 0.90, value=0.60, step=0.05, label="Paddle box threshold") + paddle_page_unclip = gr.Slider(1.0, 3.0, value=1.5, step=0.1, label="Paddle unclip ratio") + paddle_page_crop_padding = gr.Slider(0, 32, value=12, step=1, label="Crop padding") + paddle_page_max_lines = gr.Slider(0, 300, value=0, step=1, label="Max lines (0 = no cap)") + paddle_page_button = gr.Button("Run Paddle Page OCR", variant="primary") + paddle_page_text = gr.Textbox(label="Draft Unicode text", lines=16) + paddle_page_annotated = gr.Image(type="pil", label="Paddle detected lines") + paddle_page_gallery = gr.Gallery(label="Line crops", columns=2, height=420) + paddle_page_details = gr.Code(label="Details", language="json") + paddle_page_button.click( + recognize_page_paddle, + inputs=[ + paddle_page_image, + paddle_page_mode, + paddle_page_seed, + paddle_page_order, + paddle_page_limit, + paddle_page_thresh, + paddle_page_box_thresh, + paddle_page_unclip, + paddle_page_crop_padding, + paddle_page_max_lines, + ], + outputs=[paddle_page_text, paddle_page_annotated, paddle_page_gallery, paddle_page_details], + ) + + with gr.Tab("Paddle Book OCR"): + with gr.Row(): + paddle_book_files = gr.Files( + label="Page images or PDF", + file_types=[".png", ".jpg", ".jpeg", ".webp", ".bmp", ".tif", ".tiff", ".pdf"], + ) + with gr.Column(): + paddle_book_mode = gr.Radio(["Auto", "Sirijonga", "Devanagari"], value="Auto", label="Recognizer") + paddle_book_seed = gr.Radio(["Sirijonga", "Devanagari"], value="Sirijonga", label="Paddle seed recognizer") + paddle_book_order = gr.Radio( + ["Auto", "Rows LTR", "Columns LTR", "Columns RTL"], + value="Rows LTR", + label="Reading order", + ) + paddle_book_limit = gr.Slider(512, 2048, value=1280, step=64, label="Paddle detector side limit") + paddle_book_thresh = gr.Slider(0.10, 0.90, value=0.30, step=0.05, label="Paddle det threshold") + paddle_book_box_thresh = gr.Slider(0.10, 0.90, value=0.60, step=0.05, label="Paddle box threshold") + paddle_book_unclip = gr.Slider(1.0, 3.0, value=1.5, step=0.1, label="Paddle unclip ratio") + paddle_book_crop_padding = gr.Slider(0, 32, value=12, step=1, label="Crop padding") + paddle_book_max_lines = gr.Slider(0, 300, value=0, step=1, label="Max lines per page (0 = no cap)") + paddle_book_max_pages = gr.Slider(0, 80, value=20, step=1, label="Max pages (0 = no cap)") + paddle_book_pdf_dpi = gr.Slider(120, 360, value=240, step=10, label="PDF render DPI") + paddle_book_button = gr.Button("Run Paddle Book OCR", variant="primary") + paddle_book_text = gr.Textbox(label="Unicode text", lines=18) + paddle_book_zip = gr.File(label="OCR artifact zip") + paddle_book_details = gr.Code(label="Details", language="json") + paddle_book_button.click( + recognize_book_paddle, + inputs=[ + paddle_book_files, + paddle_book_mode, + paddle_book_seed, + paddle_book_order, + paddle_book_limit, + paddle_book_thresh, + paddle_book_box_thresh, + paddle_book_unclip, + paddle_book_crop_padding, + paddle_book_max_lines, + paddle_book_max_pages, + paddle_book_pdf_dpi, + ], + outputs=[paddle_book_text, paddle_book_zip, paddle_book_details], + ) + + with gr.Tab("Image-Line Page Fallback"): + with gr.Row(): + page_image = gr.Image(type="pil", label="Page image") + with gr.Column(): + page_mode = gr.Radio(["Auto", "Sirijonga", "Devanagari"], value="Auto", label="Recognizer") + reading_order = gr.Radio( + ["Auto", "Rows LTR", "Columns LTR", "Columns RTL"], + value="Auto", + label="Reading order", + ) + threshold = gr.Slider(0, 255, value=0, step=1, label="Ink threshold (0 = Otsu)") + horizontal_kernel = gr.Slider(3, 81, value=23, step=2, label="Horizontal merge") + vertical_kernel = gr.Slider(1, 15, value=3, step=1, label="Vertical merge") + dilation_iterations = gr.Slider(1, 4, value=1, step=1, label="Dilation passes") + min_width = gr.Slider(5, 300, value=35, step=5, label="Min line width") + min_height = gr.Slider(4, 80, value=10, step=1, label="Min line height") + max_height = gr.Slider(0, 260, value=140, step=5, label="Max line height (0 = no cap)") + min_area = gr.Slider(20, 5000, value=100, step=20, label="Min line area") + crop_padding = gr.Slider(0, 32, value=12, step=1, label="Crop padding") + max_lines = gr.Slider(0, 300, value=180, step=1, label="Max lines (0 = no cap)") + page_button = gr.Button("Run Image-Line Page OCR", variant="secondary") + page_text = gr.Textbox(label="Draft Unicode text", lines=16) + annotated_image = gr.Image(type="pil", label="Detected lines") + crop_gallery = gr.Gallery(label="Line crops", columns=2, height=420) + page_details = gr.Code(label="Details", language="json") + page_button.click( + recognize_page, + inputs=[ + page_image, + page_mode, + reading_order, + threshold, + horizontal_kernel, + vertical_kernel, + dilation_iterations, + min_width, + min_height, + max_height, + min_area, + crop_padding, + max_lines, + ], + outputs=[page_text, annotated_image, crop_gallery, page_details], + ) + + with gr.Tab("Image-Line Book Fallback"): + with gr.Row(): + book_files = gr.Files( + label="Page images or PDF", + file_types=[".png", ".jpg", ".jpeg", ".webp", ".bmp", ".tif", ".tiff", ".pdf"], + ) + with gr.Column(): + book_mode = gr.Radio(["Auto", "Sirijonga", "Devanagari"], value="Auto", label="Recognizer") + book_order = gr.Radio( + ["Auto", "Rows LTR", "Columns LTR", "Columns RTL"], + value="Auto", + label="Reading order", + ) + book_threshold = gr.Slider(0, 255, value=0, step=1, label="Ink threshold (0 = Otsu)") + book_horizontal_kernel = gr.Slider(3, 81, value=23, step=2, label="Horizontal merge") + book_vertical_kernel = gr.Slider(1, 15, value=3, step=1, label="Vertical merge") + book_dilation_iterations = gr.Slider(1, 4, value=1, step=1, label="Dilation passes") + book_min_width = gr.Slider(5, 300, value=35, step=5, label="Min line width") + book_min_height = gr.Slider(4, 80, value=10, step=1, label="Min line height") + book_max_height = gr.Slider(0, 260, value=140, step=5, label="Max line height (0 = no cap)") + book_min_area = gr.Slider(20, 5000, value=100, step=20, label="Min line area") + book_crop_padding = gr.Slider(0, 32, value=12, step=1, label="Crop padding") + book_max_lines = gr.Slider(0, 300, value=180, step=1, label="Max lines per page (0 = no cap)") + book_max_pages = gr.Slider(0, 80, value=20, step=1, label="Max pages (0 = no cap)") + pdf_dpi = gr.Slider(120, 360, value=240, step=10, label="PDF render DPI") + book_button = gr.Button("Run Image-Line Book OCR", variant="secondary") + book_text = gr.Textbox(label="Unicode text", lines=18) + book_zip = gr.File(label="OCR artifact zip") + book_details = gr.Code(label="Details", language="json") + book_button.click( + recognize_book, + inputs=[ + book_files, + book_mode, + book_order, + book_threshold, + book_horizontal_kernel, + book_vertical_kernel, + book_dilation_iterations, + book_min_width, + book_min_height, + book_max_height, + book_min_area, + book_crop_padding, + book_max_lines, + book_max_pages, + pdf_dpi, + ], + outputs=[book_text, book_zip, book_details], + ) + + with gr.Tab("YOLO Probe"): + with gr.Row(): + yolo_image = gr.Image(type="pil", label="Page image") + with gr.Column(): + yolo_mode = gr.Radio(["Auto", "Sirijonga", "Devanagari"], value="Auto", label="Recognizer") + detector_conf = gr.Slider(0.05, 0.90, value=0.50, step=0.05, label="Detector confidence") + yolo_order = gr.Radio( + ["Rows LTR", "Two columns LTR", "Two columns RTL"], + value="Rows LTR", + label="Reading order", + ) + yolo_crop_padding = gr.Slider(0, 24, value=6, step=1, label="Crop padding") + yolo_max_lines = gr.Slider(0, 200, value=120, step=1, label="Max lines (0 = no cap)") + yolo_button = gr.Button("Run YOLO Probe", variant="secondary") + yolo_text = gr.Textbox(label="Draft Unicode text", lines=16) + yolo_annotated = gr.Image(type="pil", label="Detected lines") + yolo_gallery = gr.Gallery(label="Line crops", columns=2, height=420) + yolo_details = gr.Code(label="Details", language="json") + yolo_button.click( + recognize_page_yolo, + inputs=[yolo_image, yolo_mode, detector_conf, yolo_order, yolo_crop_padding, yolo_max_lines], + outputs=[yolo_text, yolo_annotated, yolo_gallery, yolo_details], + ) + + with gr.Tab("Runtime"): + health_button = gr.Button("Check OCR Runtime") + health_output = gr.Code(label="Status", language="json") + health_button.click(health, outputs=health_output) + demo.load(health, outputs=health_output) + + +if __name__ == "__main__": + demo.queue(max_size=8).launch() diff --git a/k2-ampixa-demo-ocr/models/space/models/deva-v2/artifacts/devanagari-v2.txt b/k2-ampixa-demo-ocr/models/space/models/deva-v2/artifacts/devanagari-v2.txt new file mode 100644 index 0000000000000000000000000000000000000000..8ed50c6075305551c5ae802d3dca08c15a4ae9c1 --- /dev/null +++ b/k2-ampixa-demo-ocr/models/space/models/deva-v2/artifacts/devanagari-v2.txt @@ -0,0 +1,143 @@ +! +" +% +' +( +) ++ +, +- +. +/ +0 +1 +2 +3 +7 +: +; += +? +A +C +D +N +O +[ +] +a +b +c +d +e +f +g +h +i +j +k +l +m +n +o +p +r +s +t +u +v +w +y +| +¥ +÷ +ʻ +ँ +ं +ः +अ +आ +इ +ई +उ +ऊ +ऋ +ऎ +ए +ऐ +ओ +औ +क +ख +ग +घ +ङ +च +छ +ज +झ +ञ +ट +ठ +ड +ढ +ण +त +थ +द +ध +न +ऩ +प +फ +ब +भ +म +य +र +ल +व +श +ष +स +ह +़ +ऽ +ा +ि +ी +ु +ू +ृ +ॆ +े +ै +ो +ौ +् +। +० +१ +२ +३ +४ +५ +६ +७ +८ +९ +ॽ +‌ +‍ +– +— +‘ +’ +‚ +“ +” +… +√ +∶ +ॅ +ॐ diff --git a/k2-ampixa-demo-ocr/models/space/models/deva-v2/artifacts/inference.json b/k2-ampixa-demo-ocr/models/space/models/deva-v2/artifacts/inference.json new file mode 100644 index 0000000000000000000000000000000000000000..88e2434f0fdedff3e00a473efba4f0f3a68316b1 --- /dev/null +++ b/k2-ampixa-demo-ocr/models/space/models/deva-v2/artifacts/inference.json @@ -0,0 +1 @@ +{"base_code":{"magic":"pir","trainable":true,"version":4},"program":{"regions":[{"#":"region_0","blocks":[{"#":"block_0","args":[],"ops":[{"#":"p","A":[0,1,1,"linear_8.b_0"],"DA":[],"O":{"%":1,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[145],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_8.w_0"],"DA":[],"O":{"%":2,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,145],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_2"],"DA":[],"O":{"%":3,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_1"],"DA":[],"O":{"%":4,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.b_0"],"DA":[],"O":{"%":5,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_0"],"DA":[],"O":{"%":6,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_135.w_0"],"DA":[],"O":{"%":7,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_2"],"DA":[],"O":{"%":8,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_1"],"DA":[],"O":{"%":9,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.b_0"],"DA":[],"O":{"%":10,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_0"],"DA":[],"O":{"%":11,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_134.w_0"],"DA":[],"O":{"%":12,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,960,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_2"],"DA":[],"O":{"%":13,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_1"],"DA":[],"O":{"%":14,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.b_0"],"DA":[],"O":{"%":15,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_0"],"DA":[],"O":{"%":16,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_133.w_0"],"DA":[],"O":{"%":17,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,120,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_4.b_0"],"DA":[],"O":{"%":18,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_4.w_0"],"DA":[],"O":{"%":19,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_7.b_0"],"DA":[],"O":{"%":20,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_7.w_0"],"DA":[],"O":{"%":21,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_6.b_0"],"DA":[],"O":{"%":22,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_6.w_0"],"DA":[],"O":{"%":23,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_3.b_0"],"DA":[],"O":{"%":24,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_3.w_0"],"DA":[],"O":{"%":25,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_5.b_0"],"DA":[],"O":{"%":26,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_5.w_0"],"DA":[],"O":{"%":27,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_4.b_0"],"DA":[],"O":{"%":28,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_4.w_0"],"DA":[],"O":{"%":29,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_2.b_0"],"DA":[],"O":{"%":30,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_2.w_0"],"DA":[],"O":{"%":31,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_3.b_0"],"DA":[],"O":{"%":32,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_3.w_0"],"DA":[],"O":{"%":33,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_2.b_0"],"DA":[],"O":{"%":34,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_2.w_0"],"DA":[],"O":{"%":35,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_1.b_0"],"DA":[],"O":{"%":36,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_1.w_0"],"DA":[],"O":{"%":37,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_1.b_0"],"DA":[],"O":{"%":38,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_1.w_0"],"DA":[],"O":{"%":39,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_0.b_0"],"DA":[],"O":{"%":40,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_0.w_0"],"DA":[],"O":{"%":41,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_0.b_0"],"DA":[],"O":{"%":42,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_0.w_0"],"DA":[],"O":{"%":43,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_2"],"DA":[],"O":{"%":44,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_1"],"DA":[],"O":{"%":45,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.b_0"],"DA":[],"O":{"%":46,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_0"],"DA":[],"O":{"%":47,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_132.w_0"],"DA":[],"O":{"%":48,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_2"],"DA":[],"O":{"%":49,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_1"],"DA":[],"O":{"%":50,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.b_0"],"DA":[],"O":{"%":51,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_0"],"DA":[],"O":{"%":52,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_131.w_0"],"DA":[],"O":{"%":53,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,480,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_163.b_0"],"DA":[],"O":{"%":54,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_163.w_0"],"DA":[],"O":{"%":55,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_55.w_1"],"DA":[],"O":{"%":56,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_55.w_0"],"DA":[],"O":{"%":57,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_54.w_1"],"DA":[],"O":{"%":58,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_54.w_0"],"DA":[],"O":{"%":59,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_162.b_0"],"DA":[],"O":{"%":60,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_162.w_0"],"DA":[],"O":{"%":61,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_53.w_1"],"DA":[],"O":{"%":62,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_53.w_0"],"DA":[],"O":{"%":63,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_52.w_1"],"DA":[],"O":{"%":64,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_52.w_0"],"DA":[],"O":{"%":65,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_161.b_0"],"DA":[],"O":{"%":66,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_161.w_0"],"DA":[],"O":{"%":67,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_51.w_1"],"DA":[],"O":{"%":68,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_51.w_0"],"DA":[],"O":{"%":69,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_50.w_1"],"DA":[],"O":{"%":70,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_50.w_0"],"DA":[],"O":{"%":71,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_160.b_0"],"DA":[],"O":{"%":72,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_160.w_0"],"DA":[],"O":{"%":73,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_49.w_1"],"DA":[],"O":{"%":74,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_49.w_0"],"DA":[],"O":{"%":75,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_48.w_1"],"DA":[],"O":{"%":76,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_48.w_0"],"DA":[],"O":{"%":77,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_159.b_0"],"DA":[],"O":{"%":78,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_159.w_0"],"DA":[],"O":{"%":79,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_47.w_1"],"DA":[],"O":{"%":80,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_47.w_0"],"DA":[],"O":{"%":81,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_46.w_1"],"DA":[],"O":{"%":82,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_46.w_0"],"DA":[],"O":{"%":83,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_108.b_0"],"DA":[],"O":{"%":84,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_108.w_0"],"DA":[],"O":{"%":85,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,120,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_107.b_0"],"DA":[],"O":{"%":86,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_107.w_0"],"DA":[],"O":{"%":87,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_158.b_0"],"DA":[],"O":{"%":88,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_158.w_0"],"DA":[],"O":{"%":89,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_45.w_1"],"DA":[],"O":{"%":90,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_45.w_0"],"DA":[],"O":{"%":91,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_44.w_1"],"DA":[],"O":{"%":92,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_44.w_0"],"DA":[],"O":{"%":93,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_157.b_0"],"DA":[],"O":{"%":94,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_157.w_0"],"DA":[],"O":{"%":95,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_43.w_1"],"DA":[],"O":{"%":96,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_43.w_0"],"DA":[],"O":{"%":97,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_42.w_1"],"DA":[],"O":{"%":98,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_42.w_0"],"DA":[],"O":{"%":99,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_97.b_0"],"DA":[],"O":{"%":100,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_97.w_0"],"DA":[],"O":{"%":101,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_96.b_0"],"DA":[],"O":{"%":102,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_96.w_0"],"DA":[],"O":{"%":103,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_156.b_0"],"DA":[],"O":{"%":104,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_156.w_0"],"DA":[],"O":{"%":105,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_41.w_1"],"DA":[],"O":{"%":106,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_41.w_0"],"DA":[],"O":{"%":107,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_40.w_1"],"DA":[],"O":{"%":108,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_40.w_0"],"DA":[],"O":{"%":109,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_155.b_0"],"DA":[],"O":{"%":110,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_155.w_0"],"DA":[],"O":{"%":111,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_39.w_1"],"DA":[],"O":{"%":112,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_39.w_0"],"DA":[],"O":{"%":113,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_38.w_1"],"DA":[],"O":{"%":114,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_38.w_0"],"DA":[],"O":{"%":115,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_154.b_0"],"DA":[],"O":{"%":116,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_154.w_0"],"DA":[],"O":{"%":117,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_37.w_1"],"DA":[],"O":{"%":118,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_37.w_0"],"DA":[],"O":{"%":119,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_36.w_1"],"DA":[],"O":{"%":120,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_36.w_0"],"DA":[],"O":{"%":121,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_153.b_0"],"DA":[],"O":{"%":122,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_153.w_0"],"DA":[],"O":{"%":123,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_35.w_1"],"DA":[],"O":{"%":124,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_35.w_0"],"DA":[],"O":{"%":125,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_34.w_1"],"DA":[],"O":{"%":126,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_34.w_0"],"DA":[],"O":{"%":127,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_152.b_0"],"DA":[],"O":{"%":128,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_152.w_0"],"DA":[],"O":{"%":129,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_33.w_1"],"DA":[],"O":{"%":130,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_33.w_0"],"DA":[],"O":{"%":131,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_32.w_1"],"DA":[],"O":{"%":132,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_32.w_0"],"DA":[],"O":{"%":133,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_151.b_0"],"DA":[],"O":{"%":134,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_151.w_0"],"DA":[],"O":{"%":135,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_31.w_1"],"DA":[],"O":{"%":136,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_31.w_0"],"DA":[],"O":{"%":137,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_30.w_1"],"DA":[],"O":{"%":138,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_30.w_0"],"DA":[],"O":{"%":139,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_150.b_0"],"DA":[],"O":{"%":140,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_150.w_0"],"DA":[],"O":{"%":141,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_29.w_1"],"DA":[],"O":{"%":142,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_29.w_0"],"DA":[],"O":{"%":143,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_28.w_1"],"DA":[],"O":{"%":144,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_28.w_0"],"DA":[],"O":{"%":145,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_149.b_0"],"DA":[],"O":{"%":146,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_149.w_0"],"DA":[],"O":{"%":147,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_27.w_1"],"DA":[],"O":{"%":148,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_27.w_0"],"DA":[],"O":{"%":149,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_26.w_1"],"DA":[],"O":{"%":150,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_26.w_0"],"DA":[],"O":{"%":151,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_148.b_0"],"DA":[],"O":{"%":152,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_148.w_0"],"DA":[],"O":{"%":153,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_25.w_1"],"DA":[],"O":{"%":154,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_25.w_0"],"DA":[],"O":{"%":155,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_24.w_1"],"DA":[],"O":{"%":156,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_24.w_0"],"DA":[],"O":{"%":157,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_147.b_0"],"DA":[],"O":{"%":158,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_147.w_0"],"DA":[],"O":{"%":159,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,128,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_23.w_1"],"DA":[],"O":{"%":160,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_23.w_0"],"DA":[],"O":{"%":161,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_22.w_1"],"DA":[],"O":{"%":162,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_22.w_0"],"DA":[],"O":{"%":163,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_146.b_0"],"DA":[],"O":{"%":164,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_146.w_0"],"DA":[],"O":{"%":165,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_21.w_1"],"DA":[],"O":{"%":166,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_21.w_0"],"DA":[],"O":{"%":167,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_20.w_1"],"DA":[],"O":{"%":168,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_20.w_0"],"DA":[],"O":{"%":169,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_145.b_0"],"DA":[],"O":{"%":170,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_145.w_0"],"DA":[],"O":{"%":171,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,128,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_19.w_1"],"DA":[],"O":{"%":172,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_19.w_0"],"DA":[],"O":{"%":173,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_18.w_1"],"DA":[],"O":{"%":174,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_18.w_0"],"DA":[],"O":{"%":175,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_144.b_0"],"DA":[],"O":{"%":176,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_144.w_0"],"DA":[],"O":{"%":177,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_17.w_1"],"DA":[],"O":{"%":178,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_17.w_0"],"DA":[],"O":{"%":179,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_16.w_1"],"DA":[],"O":{"%":180,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_16.w_0"],"DA":[],"O":{"%":181,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_143.b_0"],"DA":[],"O":{"%":182,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_143.w_0"],"DA":[],"O":{"%":183,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_15.w_1"],"DA":[],"O":{"%":184,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_15.w_0"],"DA":[],"O":{"%":185,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_14.w_1"],"DA":[],"O":{"%":186,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_14.w_0"],"DA":[],"O":{"%":187,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_142.b_0"],"DA":[],"O":{"%":188,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_142.w_0"],"DA":[],"O":{"%":189,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_13.w_1"],"DA":[],"O":{"%":190,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_13.w_0"],"DA":[],"O":{"%":191,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_12.w_1"],"DA":[],"O":{"%":192,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_12.w_0"],"DA":[],"O":{"%":193,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_141.b_0"],"DA":[],"O":{"%":194,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_141.w_0"],"DA":[],"O":{"%":195,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_11.w_1"],"DA":[],"O":{"%":196,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_11.w_0"],"DA":[],"O":{"%":197,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_10.w_1"],"DA":[],"O":{"%":198,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_10.w_0"],"DA":[],"O":{"%":199,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_140.b_0"],"DA":[],"O":{"%":200,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_140.w_0"],"DA":[],"O":{"%":201,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_9.w_1"],"DA":[],"O":{"%":202,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_9.w_0"],"DA":[],"O":{"%":203,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_8.w_1"],"DA":[],"O":{"%":204,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_8.w_0"],"DA":[],"O":{"%":205,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_139.b_0"],"DA":[],"O":{"%":206,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_139.w_0"],"DA":[],"O":{"%":207,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,32,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_7.w_1"],"DA":[],"O":{"%":208,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_7.w_0"],"DA":[],"O":{"%":209,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_6.w_1"],"DA":[],"O":{"%":210,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_6.w_0"],"DA":[],"O":{"%":211,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_138.b_0"],"DA":[],"O":{"%":212,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_138.w_0"],"DA":[],"O":{"%":213,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_5.w_1"],"DA":[],"O":{"%":214,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_5.w_0"],"DA":[],"O":{"%":215,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_4.w_1"],"DA":[],"O":{"%":216,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_4.w_0"],"DA":[],"O":{"%":217,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_137.b_0"],"DA":[],"O":{"%":218,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_137.w_0"],"DA":[],"O":{"%":219,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,16,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_3.w_1"],"DA":[],"O":{"%":220,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_3.w_0"],"DA":[],"O":{"%":221,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_2.w_1"],"DA":[],"O":{"%":222,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_2.w_0"],"DA":[],"O":{"%":223,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_136.b_0"],"DA":[],"O":{"%":224,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_136.w_0"],"DA":[],"O":{"%":225,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_1.w_1"],"DA":[],"O":{"%":226,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_1.w_0"],"DA":[],"O":{"%":227,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_0.w_1"],"DA":[],"O":{"%":228,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_0.w_0"],"DA":[],"O":{"%":229,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_2"],"DA":[],"O":{"%":230,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_1"],"DA":[],"O":{"%":231,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.b_0"],"DA":[],"O":{"%":232,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_0"],"DA":[],"O":{"%":233,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_0.w_0"],"DA":[],"O":{"%":234,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16,3,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"1.data","A":[{"AT":{"#":"0.a_str","D":"x"},"N":"name"},{"AT":{"#":"1.a_intarray","D":[-1,3,48,-1]},"N":"shape"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[0,0,""]},"N":"place"}],"I":[],"O":[{"%":235,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,3,48,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/ConvBNLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":235},{"%":234}],"O":[{"%":236,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/ConvBNLayer/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":236},{"%":231},{"%":230},{"%":233},{"%":232}],"O":[{"%":237,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}},{"%":238,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":239,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":240,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":241,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":242,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":16},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":237},{"%":225}],"O":[{"%":243,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":244,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":224},{"%":244}],"O":[{"%":245,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,16,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":243},{"%":245}],"O":[{"%":246,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":229},{"%":246}],"O":[{"%":247,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":247},{"%":228}],"O":[{"%":248,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":248}],"O":[{"%":249,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":227},{"%":249}],"O":[{"%":250,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":250},{"%":226}],"O":[{"%":251,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":251},{"%":219}],"O":[{"%":252,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":253,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":218},{"%":253}],"O":[{"%":254,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":252},{"%":254}],"O":[{"%":255,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":223},{"%":255}],"O":[{"%":256,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":256},{"%":222}],"O":[{"%":257,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":257}],"O":[{"%":258,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":221},{"%":258}],"O":[{"%":259,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":259},{"%":220}],"O":[{"%":260,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":32},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":260},{"%":213}],"O":[{"%":261,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":262,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":212},{"%":262}],"O":[{"%":263,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":261},{"%":263}],"O":[{"%":264,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":217},{"%":264}],"O":[{"%":265,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":265},{"%":216}],"O":[{"%":266,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":266}],"O":[{"%":267,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":215},{"%":267}],"O":[{"%":268,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":268},{"%":214}],"O":[{"%":269,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":269},{"%":207}],"O":[{"%":270,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":271,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":206},{"%":271}],"O":[{"%":272,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":270},{"%":272}],"O":[{"%":273,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":211},{"%":273}],"O":[{"%":274,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":274},{"%":210}],"O":[{"%":275,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":275}],"O":[{"%":276,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":209},{"%":276}],"O":[{"%":277,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":277},{"%":208}],"O":[{"%":278,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":64},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":278},{"%":201}],"O":[{"%":279,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":280,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":200},{"%":280}],"O":[{"%":281,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":279},{"%":281}],"O":[{"%":282,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":205},{"%":282}],"O":[{"%":283,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":283},{"%":204}],"O":[{"%":284,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":284}],"O":[{"%":285,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":203},{"%":285}],"O":[{"%":286,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":286},{"%":202}],"O":[{"%":287,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":287},{"%":195}],"O":[{"%":288,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":289,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":194},{"%":289}],"O":[{"%":290,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":288},{"%":290}],"O":[{"%":291,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":199},{"%":291}],"O":[{"%":292,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":292},{"%":198}],"O":[{"%":293,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":293}],"O":[{"%":294,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":197},{"%":294}],"O":[{"%":295,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":295},{"%":196}],"O":[{"%":296,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":64},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":296},{"%":189}],"O":[{"%":297,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":298,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":188},{"%":298}],"O":[{"%":299,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":297},{"%":299}],"O":[{"%":300,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":193},{"%":300}],"O":[{"%":301,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":301},{"%":192}],"O":[{"%":302,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":302}],"O":[{"%":303,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":191},{"%":303}],"O":[{"%":304,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":304},{"%":190}],"O":[{"%":305,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":305},{"%":183}],"O":[{"%":306,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":307,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":182},{"%":307}],"O":[{"%":308,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":306},{"%":308}],"O":[{"%":309,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":187},{"%":309}],"O":[{"%":310,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":310},{"%":186}],"O":[{"%":311,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":311}],"O":[{"%":312,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":185},{"%":312}],"O":[{"%":313,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":313},{"%":184}],"O":[{"%":314,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":128},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":314},{"%":177}],"O":[{"%":315,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":316,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":176},{"%":316}],"O":[{"%":317,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":315},{"%":317}],"O":[{"%":318,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":181},{"%":318}],"O":[{"%":319,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":319},{"%":180}],"O":[{"%":320,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":320}],"O":[{"%":321,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":179},{"%":321}],"O":[{"%":322,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":322},{"%":178}],"O":[{"%":323,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":323},{"%":171}],"O":[{"%":324,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":325,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":170},{"%":325}],"O":[{"%":326,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":324},{"%":326}],"O":[{"%":327,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":175},{"%":327}],"O":[{"%":328,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":328},{"%":174}],"O":[{"%":329,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":329}],"O":[{"%":330,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":173},{"%":330}],"O":[{"%":331,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":331},{"%":172}],"O":[{"%":332,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":128},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":332},{"%":165}],"O":[{"%":333,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":334,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":164},{"%":334}],"O":[{"%":335,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":333},{"%":335}],"O":[{"%":336,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":169},{"%":336}],"O":[{"%":337,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":337},{"%":168}],"O":[{"%":338,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":338}],"O":[{"%":339,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":167},{"%":339}],"O":[{"%":340,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":340},{"%":166}],"O":[{"%":341,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":341},{"%":159}],"O":[{"%":342,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":343,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":158},{"%":343}],"O":[{"%":344,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":342},{"%":344}],"O":[{"%":345,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":163},{"%":345}],"O":[{"%":346,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":346},{"%":162}],"O":[{"%":347,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":347}],"O":[{"%":348,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":161},{"%":348}],"O":[{"%":349,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":349},{"%":160}],"O":[{"%":350,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":350},{"%":153}],"O":[{"%":351,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":352,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":152},{"%":352}],"O":[{"%":353,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":351},{"%":353}],"O":[{"%":354,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":157},{"%":354}],"O":[{"%":355,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":355},{"%":156}],"O":[{"%":356,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":356}],"O":[{"%":357,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":155},{"%":357}],"O":[{"%":358,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":358},{"%":154}],"O":[{"%":359,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":359},{"%":147}],"O":[{"%":360,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":361,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":146},{"%":361}],"O":[{"%":362,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":360},{"%":362}],"O":[{"%":363,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":151},{"%":363}],"O":[{"%":364,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":364},{"%":150}],"O":[{"%":365,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":365}],"O":[{"%":366,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":149},{"%":366}],"O":[{"%":367,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":367},{"%":148}],"O":[{"%":368,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":368},{"%":141}],"O":[{"%":369,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":370,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":140},{"%":370}],"O":[{"%":371,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":369},{"%":371}],"O":[{"%":372,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":145},{"%":372}],"O":[{"%":373,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":373},{"%":144}],"O":[{"%":374,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":374}],"O":[{"%":375,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":143},{"%":375}],"O":[{"%":376,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":376},{"%":142}],"O":[{"%":377,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":377},{"%":135}],"O":[{"%":378,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":379,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":134},{"%":379}],"O":[{"%":380,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":378},{"%":380}],"O":[{"%":381,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":139},{"%":381}],"O":[{"%":382,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":382},{"%":138}],"O":[{"%":383,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":383}],"O":[{"%":384,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":137},{"%":384}],"O":[{"%":385,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":385},{"%":136}],"O":[{"%":386,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":386},{"%":129}],"O":[{"%":387,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":388,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":128},{"%":388}],"O":[{"%":389,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":387},{"%":389}],"O":[{"%":390,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":133},{"%":390}],"O":[{"%":391,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":391},{"%":132}],"O":[{"%":392,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":392}],"O":[{"%":393,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":131},{"%":393}],"O":[{"%":394,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":394},{"%":130}],"O":[{"%":395,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":395},{"%":123}],"O":[{"%":396,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":397,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":122},{"%":397}],"O":[{"%":398,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":396},{"%":398}],"O":[{"%":399,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":127},{"%":399}],"O":[{"%":400,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":400},{"%":126}],"O":[{"%":401,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":401}],"O":[{"%":402,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":125},{"%":402}],"O":[{"%":403,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":403},{"%":124}],"O":[{"%":404,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":404},{"%":117}],"O":[{"%":405,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":406,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":116},{"%":406}],"O":[{"%":407,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":405},{"%":407}],"O":[{"%":408,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":121},{"%":408}],"O":[{"%":409,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":409},{"%":120}],"O":[{"%":410,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":410}],"O":[{"%":411,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":119},{"%":411}],"O":[{"%":412,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":412},{"%":118}],"O":[{"%":413,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":413},{"%":111}],"O":[{"%":414,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":415,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":110},{"%":415}],"O":[{"%":416,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":414},{"%":416}],"O":[{"%":417,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":115},{"%":417}],"O":[{"%":418,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":418},{"%":114}],"O":[{"%":419,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":419}],"O":[{"%":420,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":113},{"%":420}],"O":[{"%":421,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":421},{"%":112}],"O":[{"%":422,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":422},{"%":105}],"O":[{"%":423,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":424,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":104},{"%":424}],"O":[{"%":425,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":423},{"%":425}],"O":[{"%":426,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":109},{"%":426}],"O":[{"%":427,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":427},{"%":108}],"O":[{"%":428,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":428}],"O":[{"%":429,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":107},{"%":429}],"O":[{"%":430,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":430},{"%":106}],"O":[{"%":431,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":432,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":431},{"%":432}],"O":[{"%":433,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":433},{"%":103}],"O":[{"%":434,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":435,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":102},{"%":435}],"O":[{"%":436,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":434},{"%":436}],"O":[{"%":437,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/ReLU/"},"N":"struct_name"}],"I":[{"%":437}],"O":[{"%":438,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":438},{"%":101}],"O":[{"%":439,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":440,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":100},{"%":440}],"O":[{"%":441,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":439},{"%":441}],"O":[{"%":442,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.16666670143604279},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Hardsigmoid/"},"N":"struct_name"}],"I":[{"%":442}],"O":[{"%":443,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/"},"N":"struct_name"}],"I":[{"%":431},{"%":443}],"O":[{"%":444,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":444},{"%":95}],"O":[{"%":445,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":446,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":94},{"%":446}],"O":[{"%":447,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":445},{"%":447}],"O":[{"%":448,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":99},{"%":448}],"O":[{"%":449,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":449},{"%":98}],"O":[{"%":450,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":450}],"O":[{"%":451,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":97},{"%":451}],"O":[{"%":452,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":452},{"%":96}],"O":[{"%":453,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":453},{"%":89}],"O":[{"%":454,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":455,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":88},{"%":455}],"O":[{"%":456,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":454},{"%":456}],"O":[{"%":457,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":93},{"%":457}],"O":[{"%":458,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":458},{"%":92}],"O":[{"%":459,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":459}],"O":[{"%":460,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":91},{"%":460}],"O":[{"%":461,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":461},{"%":90}],"O":[{"%":462,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":463,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":462},{"%":463}],"O":[{"%":464,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":464},{"%":87}],"O":[{"%":465,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":466,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":86},{"%":466}],"O":[{"%":467,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":465},{"%":467}],"O":[{"%":468,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/ReLU/"},"N":"struct_name"}],"I":[{"%":468}],"O":[{"%":469,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":469},{"%":85}],"O":[{"%":470,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":471,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":84},{"%":471}],"O":[{"%":472,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":470},{"%":472}],"O":[{"%":473,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.16666670143604279},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Hardsigmoid/"},"N":"struct_name"}],"I":[{"%":473}],"O":[{"%":474,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/"},"N":"struct_name"}],"I":[{"%":462},{"%":474}],"O":[{"%":475,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":475},{"%":79}],"O":[{"%":476,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":477,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":78},{"%":477}],"O":[{"%":478,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":476},{"%":478}],"O":[{"%":479,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":83},{"%":479}],"O":[{"%":480,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":480},{"%":82}],"O":[{"%":481,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":481}],"O":[{"%":482,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":81},{"%":482}],"O":[{"%":483,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":483},{"%":80}],"O":[{"%":484,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":484},{"%":73}],"O":[{"%":485,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":486,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":72},{"%":486}],"O":[{"%":487,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":485},{"%":487}],"O":[{"%":488,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":77},{"%":488}],"O":[{"%":489,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":489},{"%":76}],"O":[{"%":490,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":490}],"O":[{"%":491,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":75},{"%":491}],"O":[{"%":492,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":492},{"%":74}],"O":[{"%":493,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":493},{"%":67}],"O":[{"%":494,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":495,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":66},{"%":495}],"O":[{"%":496,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":494},{"%":496}],"O":[{"%":497,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":71},{"%":497}],"O":[{"%":498,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":498},{"%":70}],"O":[{"%":499,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":499}],"O":[{"%":500,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":69},{"%":500}],"O":[{"%":501,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":501},{"%":68}],"O":[{"%":502,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":502},{"%":61}],"O":[{"%":503,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":504,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":60},{"%":504}],"O":[{"%":505,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":503},{"%":505}],"O":[{"%":506,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":65},{"%":506}],"O":[{"%":507,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":507},{"%":64}],"O":[{"%":508,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":508}],"O":[{"%":509,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":63},{"%":509}],"O":[{"%":510,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":510},{"%":62}],"O":[{"%":511,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":511},{"%":55}],"O":[{"%":512,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":513,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":54},{"%":513}],"O":[{"%":514,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":512},{"%":514}],"O":[{"%":515,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":59},{"%":515}],"O":[{"%":516,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":516},{"%":58}],"O":[{"%":517,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":517}],"O":[{"%":518,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":57},{"%":518}],"O":[{"%":519,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":519},{"%":56}],"O":[{"%":520,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/"},"N":"struct_name"}],"I":[],"O":[{"%":521,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":false},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/"},"N":"struct_name"}],"I":[{"%":520},{"%":521}],"O":[{"%":522,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.assign","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":522}],"O":[{"%":523,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":523},{"%":53}],"O":[{"%":524,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":524},{"%":50},{"%":49},{"%":52},{"%":51}],"O":[{"%":525,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}},{"%":526,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":527,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":528,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":529,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":530,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/Swish/"},"N":"struct_name"}],"I":[{"%":525}],"O":[{"%":531,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":531},{"%":48}],"O":[{"%":532,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":532},{"%":45},{"%":44},{"%":47},{"%":46}],"O":[{"%":533,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}},{"%":534,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":535,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":536,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":537,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":538,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/Swish/"},"N":"struct_name"}],"I":[{"%":533}],"O":[{"%":539,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.shape64","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":539}],"O":[{"%":540,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":541,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":4}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":542,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":540},{"%":541},{"%":542}],"O":[{"%":543,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.flatten","A":[{"AT":{"#":"0.a_i32","D":2},"N":"start_axis"},{"AT":{"#":"0.a_i32","D":3},"N":"stop_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":539}],"O":[{"%":544,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":544}],"O":[{"%":545,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/LayerNorm/"},"N":"struct_name"}],"I":[{"%":545},{"%":43},{"%":42}],"O":[{"%":546,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":547,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":548,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":546},{"%":41}],"O":[{"%":549,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":549},{"%":40}],"O":[{"%":550,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":8},{"#":"0.a_i64","D":15}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":551,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[5],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":550},{"%":551}],"O":[{"%":552,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,3,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":4}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":552}],"O":[{"%":553,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[3,-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":554,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":555,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":554},{"%":555}],"O":[{"%":556,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.25819888710975647},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":557,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.scale","A":[{"AT":{"#":"0.a_f32","D":0.0},"N":"bias"},{"AT":{"#":"0.a_bool","D":true},"N":"bias_after_scale"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":556},{"%":557}],"O":[{"%":558,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":559,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":560,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":559},{"%":560}],"O":[{"%":561,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":562,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":563,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":562},{"%":563}],"O":[{"%":564,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":561}],"O":[{"%":565,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,15,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":558},{"%":565}],"O":[{"%":566,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":-1},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":566}],"O":[{"%":567,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":568,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout/"},"N":"struct_name"}],"I":[{"%":567},{"%":0},{"%":568}],"O":[{"%":569,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}},{"%":570,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":569},{"%":564}],"O":[{"%":571,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":571}],"O":[{"%":572,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":120}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":573,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[3],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":572},{"%":573}],"O":[{"%":574,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":574},{"%":39}],"O":[{"%":575,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":575},{"%":38}],"O":[{"%":576,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":577,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout_1/"},"N":"struct_name"}],"I":[{"%":576},{"%":0},{"%":577}],"O":[{"%":578,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":579,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/"},"N":"struct_name"}],"I":[{"%":545},{"%":578}],"O":[{"%":580,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/LayerNorm_1/"},"N":"struct_name"}],"I":[{"%":580},{"%":37},{"%":36}],"O":[{"%":581,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":582,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":583,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":581},{"%":35}],"O":[{"%":584,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":584},{"%":34}],"O":[{"%":585,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Swish/"},"N":"struct_name"}],"I":[{"%":585}],"O":[{"%":586,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":587,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout/"},"N":"struct_name"}],"I":[{"%":586},{"%":0},{"%":587}],"O":[{"%":588,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}},{"%":589,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":588},{"%":33}],"O":[{"%":590,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":590},{"%":32}],"O":[{"%":591,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":592,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[{"%":591},{"%":0},{"%":592}],"O":[{"%":593,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":594,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/"},"N":"struct_name"}],"I":[{"%":580},{"%":593}],"O":[{"%":595,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/LayerNorm/"},"N":"struct_name"}],"I":[{"%":595},{"%":31},{"%":30}],"O":[{"%":596,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":597,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":598,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":596},{"%":29}],"O":[{"%":599,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":599},{"%":28}],"O":[{"%":600,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":8},{"#":"0.a_i64","D":15}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":601,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[5],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":600},{"%":601}],"O":[{"%":602,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,3,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":4}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":602}],"O":[{"%":603,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[3,-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":604,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":605,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":604},{"%":605}],"O":[{"%":606,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.25819888710975647},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":607,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.scale","A":[{"AT":{"#":"0.a_f32","D":0.0},"N":"bias"},{"AT":{"#":"0.a_bool","D":true},"N":"bias_after_scale"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":606},{"%":607}],"O":[{"%":608,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":609,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":610,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":609},{"%":610}],"O":[{"%":611,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":612,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":613,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":612},{"%":613}],"O":[{"%":614,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":611}],"O":[{"%":615,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,15,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":608},{"%":615}],"O":[{"%":616,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":-1},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":616}],"O":[{"%":617,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":618,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout/"},"N":"struct_name"}],"I":[{"%":617},{"%":0},{"%":618}],"O":[{"%":619,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}},{"%":620,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":619},{"%":614}],"O":[{"%":621,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":621}],"O":[{"%":622,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":120}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":623,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[3],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":622},{"%":623}],"O":[{"%":624,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":624},{"%":27}],"O":[{"%":625,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":625},{"%":26}],"O":[{"%":626,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":627,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout_1/"},"N":"struct_name"}],"I":[{"%":626},{"%":0},{"%":627}],"O":[{"%":628,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":629,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/"},"N":"struct_name"}],"I":[{"%":595},{"%":628}],"O":[{"%":630,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/LayerNorm_1/"},"N":"struct_name"}],"I":[{"%":630},{"%":25},{"%":24}],"O":[{"%":631,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":632,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":633,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":631},{"%":23}],"O":[{"%":634,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":634},{"%":22}],"O":[{"%":635,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Swish/"},"N":"struct_name"}],"I":[{"%":635}],"O":[{"%":636,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":637,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout/"},"N":"struct_name"}],"I":[{"%":636},{"%":0},{"%":637}],"O":[{"%":638,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}},{"%":639,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":638},{"%":21}],"O":[{"%":640,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":640},{"%":20}],"O":[{"%":641,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":642,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[{"%":641},{"%":0},{"%":642}],"O":[{"%":643,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":644,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/"},"N":"struct_name"}],"I":[{"%":630},{"%":643}],"O":[{"%":645,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999974752427e-07},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/LayerNorm/"},"N":"struct_name"}],"I":[{"%":645},{"%":19},{"%":18}],"O":[{"%":646,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":647,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":648,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":649,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":650,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":120.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":651,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":649},{"%":650},{"%":543},{"%":651}],"O":[{"%":652,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.stack","A":[{"AT":{"#":"0.a_i32","D":0},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":652}],"O":[{"%":653,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":646},{"%":653}],"O":[{"%":654,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":654}],"O":[{"%":655,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/Conv2D/"},"N":"struct_name"}],"I":[{"%":655},{"%":17}],"O":[{"%":656,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":656},{"%":14},{"%":13},{"%":16},{"%":15}],"O":[{"%":657,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}},{"%":658,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":659,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":660,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":661,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":662,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/Swish/"},"N":"struct_name"}],"I":[{"%":657}],"O":[{"%":663,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":664,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":523},{"%":663}],"O":[{"%":665,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":665},{"%":664}],"O":[{"%":666,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,960,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/Conv2D/"},"N":"struct_name"}],"I":[{"%":666},{"%":12}],"O":[{"%":667,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":667},{"%":9},{"%":8},{"%":11},{"%":10}],"O":[{"%":668,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}},{"%":669,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":670,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":671,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":672,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":673,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/Swish/"},"N":"struct_name"}],"I":[{"%":668}],"O":[{"%":674,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/Conv2D/"},"N":"struct_name"}],"I":[{"%":674},{"%":7}],"O":[{"%":675,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":675},{"%":4},{"%":3},{"%":6},{"%":5}],"O":[{"%":676,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}},{"%":677,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":678,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":679,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":680,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":681,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/Swish/"},"N":"struct_name"}],"I":[{"%":676}],"O":[{"%":682,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[],"O":[{"%":683,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.squeeze","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[{"%":682},{"%":683}],"O":[{"%":684,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[{"%":684}],"O":[{"%":685,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/Linear/"},"N":"struct_name"}],"I":[{"%":685},{"%":2}],"O":[{"%":686,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,145],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/Linear/"},"N":"struct_name"}],"I":[{"%":686},{"%":1}],"O":[{"%":687,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,145],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":2},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/"},"N":"struct_name"}],"I":[{"%":687}],"O":[{"%":688,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,145],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.fetch","A":[{"AT":{"#":"0.a_str","D":"fetch_name_0"},"N":"name"},{"AT":{"#":"0.a_i32","D":0},"N":"col"}],"I":[{"%":688}],"O":[{"%":689,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,145],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"persistable"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]}]}]}]}} \ No newline at end of file diff --git a/k2-ampixa-demo-ocr/models/space/models/deva-v2/artifacts/inference.pdiparams b/k2-ampixa-demo-ocr/models/space/models/deva-v2/artifacts/inference.pdiparams new file mode 100644 index 0000000000000000000000000000000000000000..3f7ca3c960730acf1b527d545b6ca3da1c141b22 --- /dev/null +++ b/k2-ampixa-demo-ocr/models/space/models/deva-v2/artifacts/inference.pdiparams @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:32f5256f8a062830be4394606b8307c30dd9b9fb1be4e15af65606abffb479b4 +size 7630503 diff --git a/k2-ampixa-demo-ocr/models/space/models/deva-v2/artifacts/inference.yml b/k2-ampixa-demo-ocr/models/space/models/deva-v2/artifacts/inference.yml new file mode 100644 index 0000000000000000000000000000000000000000..9d5eb2be4bb9375544011f44f304efa73fab0404 --- /dev/null +++ b/k2-ampixa-demo-ocr/models/space/models/deva-v2/artifacts/inference.yml @@ -0,0 +1,186 @@ +Global: + model_name: PP-OCRv5_mobile_rec +Hpi: + backend_configs: + paddle_infer: + trt_dynamic_shapes: &id001 + x: + - - 1 + - 3 + - 48 + - 160 + - - 1 + - 3 + - 48 + - 320 + - - 8 + - 3 + - 48 + - 3200 + tensorrt: + dynamic_shapes: *id001 +PreProcess: + transform_ops: + - DecodeImage: + channel_first: false + img_mode: BGR + - MultiLabelEncode: + gtc_encode: NRTRLabelEncode + - RecResizeImg: + image_shape: + - 3 + - 48 + - 320 + - KeepKeys: + keep_keys: + - image + - label_ctc + - label_gtc + - length + - valid_ratio +PostProcess: + name: CTCLabelDecode + character_dict: + - '!' + - '"' + - '%' + - '''' + - ( + - ) + - + + - ',' + - '-' + - . + - / + - '0' + - '1' + - '2' + - '3' + - '7' + - ':' + - ; + - '=' + - '?' + - A + - C + - D + - N + - O + - '[' + - ']' + - a + - b + - c + - d + - e + - f + - g + - h + - i + - j + - k + - l + - m + - n + - o + - p + - r + - s + - t + - u + - v + - w + - y + - '|' + - ¥ + - ÷ + - ʻ + - ँ + - ं + - ः + - अ + - आ + - इ + - ई + - उ + - ऊ + - ऋ + - ऎ + - ए + - ऐ + - ओ + - औ + - क + - ख + - ग + - घ + - ङ + - च + - छ + - ज + - झ + - ञ + - ट + - ठ + - ड + - ढ + - ण + - त + - थ + - द + - ध + - न + - ऩ + - प + - फ + - ब + - भ + - म + - य + - र + - ल + - व + - श + - ष + - स + - ह + - ़ + - ऽ + - ा + - ि + - ी + - ु + - ू + - ृ + - ॆ + - े + - ै + - ो + - ौ + - ् + - । + - ० + - १ + - २ + - ३ + - ४ + - ५ + - ६ + - ७ + - ८ + - ९ + - ॽ + - ‌ + - ‍ + - – + - — + - ‘ + - ’ + - ‚ + - “ + - ” + - … + - √ + - ∶ + - ॅ + - ॐ diff --git a/k2-ampixa-demo-ocr/models/space/models/deva-v2/model-card.json b/k2-ampixa-demo-ocr/models/space/models/deva-v2/model-card.json new file mode 100644 index 0000000000000000000000000000000000000000..1f6cc466f7d9c222ad097522d7b21e95d35b6176 --- /dev/null +++ b/k2-ampixa-demo-ocr/models/space/models/deva-v2/model-card.json @@ -0,0 +1,45 @@ +{ + "model_id": "deva-v2-reexport-2026-07-06", + "backend": "paddleocr", + "base_model": "deva-v2 training checkpoint (recovered from ashish-experiments 2026-07-05)", + "created_at_utc": "2026-07-06T07:52:10.588624+00:00", + "artifacts": [ + { + "path": "artifacts/inference.json", + "required": true, + "sha256": "772e801de4c1cc260058f7c426ab618ef52ecc7ea51442886c8c8fc1606cb88b", + "kind": "file", + "size_bytes": 217712 + }, + { + "path": "artifacts/inference.pdiparams", + "required": true, + "sha256": "32f5256f8a062830be4394606b8307c30dd9b9fb1be4e15af65606abffb479b4", + "kind": "file", + "size_bytes": 7630503 + }, + { + "path": "artifacts/inference.yml", + "required": true, + "sha256": "4f76c7bd21ea18ec118adef93b98017b55a449072b35f1c3ea2baa3df217c8dc", + "kind": "file", + "size_bytes": 1812 + }, + { + "path": "artifacts/devanagari-v2.txt", + "required": true, + "sha256": "96806153df021c99b0195de9757d8fe6443c52f7c8a1c74bf76a5895c37b8c0b", + "kind": "file", + "size_bytes": 467 + } + ], + "backend_kwargs": { + "lang": "devanagari", + "text_recognition_model_name": "PP-OCRv5_mobile_rec", + "text_recognition_model_dir": "artifacts", + "recognition_mode": "line" + }, + "provenance": {}, + "metrics": {}, + "notes": "Re-export of the recovered deva-v2 training checkpoint with the correct 144-char devanagari-v2 dict; replaces the broken limbu-devanagari-ppocrv5 bundle whose truncated dict lacked anusvara/ii-matra/nna and emitted garbage. Verified on the recovered Newar frozen test: cp CER 0.0622 / grapheme 0.1312 / exact 0.158 - exact match to the recorded pre-crash baseline. Silver labels, diagnostic." +} diff --git a/k2-ampixa-demo-ocr/models/space/models/devanagari-ft-v2/MODEL-SOURCE.txt b/k2-ampixa-demo-ocr/models/space/models/devanagari-ft-v2/MODEL-SOURCE.txt new file mode 100644 index 0000000000000000000000000000000000000000..ce26711a61fef3ac3b5be7f7fd41d3db4207cd36 --- /dev/null +++ b/k2-ampixa-demo-ocr/models/space/models/devanagari-ft-v2/MODEL-SOURCE.txt @@ -0,0 +1,7 @@ +devanagari-ft-v2 — fine-tuned from PaddleOCR devanagari_PP-OCRv5_mobile_rec (Apache-2.0), 2026-09-24. +Training: k2 MPS, transformers PPOCRV5MobileRecForTextRecognition, CTC; v1b (4,000 steps) then v2 (19,540 steps, frozen BN). +Data: Gorkhapatra real print chunks (internal-use owner determination 2026-07-22), OFL-font synthetic citizenship/office/real-text lines, +NVIDIA OCR-Synthetic-Multilingual-v1 English (CC BY 4.0), Liberation/DejaVu/Lato English renders. Code: ocr-tech tools/deva_rec_torch. +Served through PaddleX onnxruntime engine; inference.yml copied unchanged from PaddlePaddle/devanagari_PP-OCRv5_mobile_rec_onnx. +69484bdc8dba4e956faf62f860587c4af8948eedb57dbba7409ab46376ad72aa inference.onnx +9bd172dd26440c8ce94d1cde5d5baea6aefdc7cf3c5c8492e0beedef656d4e54 inference.yml diff --git a/k2-ampixa-demo-ocr/models/space/models/devanagari-ft-v2/artifacts/inference.onnx b/k2-ampixa-demo-ocr/models/space/models/devanagari-ft-v2/artifacts/inference.onnx new file mode 100644 index 0000000000000000000000000000000000000000..d9ee9c4d2b77ccb0f0f77fb5160a253f508fa4e1 --- /dev/null +++ b/k2-ampixa-demo-ocr/models/space/models/devanagari-ft-v2/artifacts/inference.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:69484bdc8dba4e956faf62f860587c4af8948eedb57dbba7409ab46376ad72aa +size 22253444 diff --git a/k2-ampixa-demo-ocr/models/space/models/devanagari-ft-v2/artifacts/inference.yml b/k2-ampixa-demo-ocr/models/space/models/devanagari-ft-v2/artifacts/inference.yml new file mode 100644 index 0000000000000000000000000000000000000000..777c30094e8c858d2aee6182fd3b9aa975da1b52 --- /dev/null +++ b/k2-ampixa-demo-ocr/models/space/models/devanagari-ft-v2/artifacts/inference.yml @@ -0,0 +1,611 @@ +Global: + model_name: devanagari_PP-OCRv5_mobile_rec +Hpi: + backend_configs: + paddle_infer: + trt_dynamic_shapes: &id001 + x: + - - 1 + - 3 + - 48 + - 160 + - - 1 + - 3 + - 48 + - 320 + - - 8 + - 3 + - 48 + - 3200 + tensorrt: + dynamic_shapes: *id001 +PreProcess: + transform_ops: + - DecodeImage: + channel_first: false + img_mode: BGR + - MultiLabelEncode: + gtc_encode: NRTRLabelEncode + - RecResizeImg: + image_shape: + - 3 + - 48 + - 320 + - KeepKeys: + keep_keys: + - image + - label_ctc + - label_gtc + - length + - valid_ratio +PostProcess: + name: CTCLabelDecode + character_dict: + - '!' + - '"' + - '#' + - $ + - '%' + - '&' + - '''' + - ( + - ) + - '*' + - + + - ',' + - '-' + - . + - / + - '0' + - '1' + - '2' + - '3' + - '4' + - '5' + - '6' + - '7' + - '8' + - '9' + - ':' + - ; + - < + - '=' + - '>' + - '?' + - A + - B + - C + - D + - E + - F + - G + - H + - I + - J + - K + - L + - M + - N + - O + - P + - Q + - R + - S + - T + - U + - V + - W + - X + - Y + - Z + - '[' + - ']' + - _ + - '`' + - a + - b + - c + - d + - e + - f + - g + - h + - i + - j + - k + - l + - m + - n + - o + - p + - q + - r + - s + - t + - u + - v + - w + - x + - y + - z + - © + - ‥ + - '{' + - '}' + - \ + - '|' + - '@' + - ^ + - '~' + - ÷ + - ∕ + - ∙ + - ⋅ + - · + - ± + - ∓ + - ∩ + - ∪ + - □ + - ← + - ↔ + - ⇒ + - ⇐ + - ⇔ + - ∀ + - ∃ + - ∄ + - ∴ + - ∵ + - ∝ + - ∞ + - ⊥ + - ∟ + - ∠ + - ∡ + - ∢ + - ′ + - ″ + - ∥ + - ⊾ + - ⊿ + - ∂ + - ∫ + - ∬ + - ∭ + - ∮ + - ∯ + - ∰ + - ∑ + - ∏ + - √ + - ∛ + - ∜ + - ∱ + - ∲ + - ∳ + - ∶ + - ∷ + - ∼ + - ® + - ℉ + - Ω + - ℧ + - Å + - ⌀ + - ℏ + - ⅀ + - ⍺ + - ⍵ + - ¢ + - € + - £ + - ¥ + - ₿ + - Ⅰ + - Ⅱ + - Ⅲ + - Ⅳ + - Ⅴ + - Ⅵ + - Ⅶ + - Ⅷ + - Ⅸ + - Ⅹ + - Ⅺ + - Ⅻ + - ⅰ + - ⅱ + - ⅲ + - ⅳ + - ⅴ + - ⅵ + - ⅶ + - ⅷ + - ⅸ + - ⅹ + - ⅺ + - ⅻ + - ➀ + - ➁ + - ➂ + - ➃ + - ➄ + - ➅ + - ➆ + - ➇ + - ➈ + - ➉ + - ➊ + - ➋ + - ➌ + - ➍ + - ➎ + - ➏ + - ➐ + - ➑ + - ➒ + - ➓ + - ❶ + - ❷ + - ❸ + - ❹ + - ❺ + - ❻ + - ❼ + - ❽ + - ❾ + - ❿ + - ① + - ② + - ③ + - ④ + - ⑤ + - ⑥ + - ⑦ + - ⑧ + - ⑨ + - ⑩ + - ● + - ▶ + - 𝑢 + - ︽ + - – + - ﹥ + - 𝜓 + - • + - ∋ + - ƒ + - ⬆ + - Ạ + - ◀ + -  + - ▫ + - ︾ + - À + - Á + - Â + - Ã + - Ä + - Å + - Æ + - Ç + - È + - É + - Ê + - Ë + - Ì + - Í + - Î + - Ï + - Ð + - Ñ + - Ò + - Ó + - Ô + - Õ + - Ö + - Ø + - Ù + - Ú + - Û + - Ü + - Ý + - Þ + - à + - á + - â + - ã + - ä + - å + - æ + - ç + - è + - é + - ê + - ë + - ì + - í + - î + - ï + - ð + - ñ + - ò + - ó + - ô + - õ + - ö + - ø + - ù + - ú + - û + - ü + - ý + - þ + - ÿ + - ¡ + - ¤ + - ¦ + - § + - ¨ + - ª + - « + - ¬ + - ¯ + - ° + - ² + - ³ + - ´ + - µ + - ¶ + - ¸ + - ¹ + - º + - » + - ¼ + - ½ + - ¾ + - ¿ + - × + - ‐ + - ‑ + - ‒ + - — + - ― + - ‖ + - ‗ + - ‘ + - ’ + - ‚ + - ‛ + - “ + - ” + - „ + - ‟ + - † + - ‡ + - ‣ + - ․ + - … + - ‧ + - ‰ + - ‴ + - ‵ + - ‶ + - ‷ + - ‸ + - ‹ + - › + - ※ + - ‼ + - ‽ + - ‾ + - ₤ + - ₡ + - ₹ + - − + - ∖ + - ∗ + - ≈ + - ≠ + - ≡ + - ≤ + - ≥ + - ⊂ + - ⊃ + - ↑ + - → + - ↓ + - ↕ + - ™ + - Ω + - ℮ + - ∆ + - ✓ + - ✗ + - ✘ + - ▪ + - ◼ + - ✔ + - ✕ + - ☑ + - ☒ + - № + - ₽ + - ₴ + - Α + - α + - Β + - β + - Γ + - γ + - Δ + - δ + - Ε + - ε + - Ζ + - ζ + - Η + - η + - Θ + - θ + - Ι + - ι + - Κ + - κ + - Λ + - λ + - Μ + - μ + - Ν + - ν + - Ξ + - ξ + - Ο + - ο + - Π + - π + - Ρ + - ρ + - Σ + - σ + - ς + - Τ + - τ + - Υ + - υ + - Φ + - φ + - Χ + - χ + - Ψ + - ψ + - ω + - ऀ + - ँ + - ं + - ः + - ऄ + - अ + - आ + - इ + - ई + - उ + - ऊ + - ऋ + - ऌ + - ऍ + - ऎ + - ए + - ऐ + - ऑ + - ऒ + - ओ + - औ + - क + - ख + - ग + - घ + - ङ + - च + - छ + - ज + - झ + - ञ + - ट + - ठ + - ड + - ढ + - ण + - त + - थ + - द + - ध + - न + - ऩ + - प + - फ + - ब + - भ + - म + - य + - र + - ऱ + - ल + - ळ + - ऴ + - व + - श + - ष + - स + - ह + - ऺ + - ऻ + - ़ + - ऽ + - ा + - ि + - ी + - ु + - ू + - ृ + - ॄ + - ॅ + - ॆ + - े + - ै + - ॉ + - ॊ + - ो + - ौ + - ् + - ॎ + - ॏ + - ॐ + - ॑ + - ॒ + - ॓ + - ॔ + - ॕ + - ॖ + - ॗ + - क़ + - ख़ + - ग़ + - ज़ + - ड़ + - ढ़ + - फ़ + - य़ + - ॠ + - ॡ + - ॢ + - ॣ + - । + - ॥ + - ० + - १ + - २ + - ३ + - ४ + - ५ + - ६ + - ७ + - ८ + - ९ + - ॰ + - ॱ + - ॲ + - ॳ + - ॴ + - ॵ + - ॶ + - ॷ + - ॸ + - ॹ + - ॺ + - ॻ + - ॼ + - ॽ + - ॾ + - ॿ diff --git a/k2-ampixa-demo-ocr/models/space/models/devanagari-ft-v3/MODEL-SOURCE.txt b/k2-ampixa-demo-ocr/models/space/models/devanagari-ft-v3/MODEL-SOURCE.txt new file mode 100644 index 0000000000000000000000000000000000000000..afb4ca810aa19dcb214f1b11734126213a68bc69 --- /dev/null +++ b/k2-ampixa-demo-ocr/models/space/models/devanagari-ft-v3/MODEL-SOURCE.txt @@ -0,0 +1,7 @@ +devanagari-ft-v3 — fine-tuned from PaddleOCR devanagari_PP-OCRv5_mobile_rec (Apache-2.0), 2026-09-24. +Training: k2 MPS, transformers PPOCRV5MobileRecForTextRecognition, CTC; v1b (4,000 steps) then v2 (19,540 steps, frozen BN), then v3 (6,198 steps on converter-fixed labels: nayanepal j|m -> s| for क्र). +Data: Gorkhapatra real print chunks (internal-use owner determination 2026-07-22), OFL-font synthetic citizenship/office/real-text lines, +NVIDIA OCR-Synthetic-Multilingual-v1 English (CC BY 4.0), Liberation/DejaVu/Lato English renders. Code: ocr-tech tools/deva_rec_torch. +Served through PaddleX onnxruntime engine; inference.yml copied unchanged from PaddlePaddle/devanagari_PP-OCRv5_mobile_rec_onnx. +e6e46f8c2e43732a7b7eed7784e4827e112b9d24d2bba8079501473258e9350a inference.onnx +9bd172dd26440c8ce94d1cde5d5baea6aefdc7cf3c5c8492e0beedef656d4e54 inference.yml diff --git a/k2-ampixa-demo-ocr/models/space/models/devanagari-ft-v3/artifacts/inference.onnx b/k2-ampixa-demo-ocr/models/space/models/devanagari-ft-v3/artifacts/inference.onnx new file mode 100644 index 0000000000000000000000000000000000000000..b0ff39619e126ddcf277c7af4cfc28f7b74f0cae --- /dev/null +++ b/k2-ampixa-demo-ocr/models/space/models/devanagari-ft-v3/artifacts/inference.onnx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e6e46f8c2e43732a7b7eed7784e4827e112b9d24d2bba8079501473258e9350a +size 22253444 diff --git a/k2-ampixa-demo-ocr/models/space/models/devanagari-ft-v3/artifacts/inference.yml b/k2-ampixa-demo-ocr/models/space/models/devanagari-ft-v3/artifacts/inference.yml new file mode 100644 index 0000000000000000000000000000000000000000..777c30094e8c858d2aee6182fd3b9aa975da1b52 --- /dev/null +++ b/k2-ampixa-demo-ocr/models/space/models/devanagari-ft-v3/artifacts/inference.yml @@ -0,0 +1,611 @@ +Global: + model_name: devanagari_PP-OCRv5_mobile_rec +Hpi: + backend_configs: + paddle_infer: + trt_dynamic_shapes: &id001 + x: + - - 1 + - 3 + - 48 + - 160 + - - 1 + - 3 + - 48 + - 320 + - - 8 + - 3 + - 48 + - 3200 + tensorrt: + dynamic_shapes: *id001 +PreProcess: + transform_ops: + - DecodeImage: + channel_first: false + img_mode: BGR + - MultiLabelEncode: + gtc_encode: NRTRLabelEncode + - RecResizeImg: + image_shape: + - 3 + - 48 + - 320 + - KeepKeys: + keep_keys: + - image + - label_ctc + - label_gtc + - length + - valid_ratio +PostProcess: + name: CTCLabelDecode + character_dict: + - '!' + - '"' + - '#' + - $ + - '%' + - '&' + - '''' + - ( + - ) + - '*' + - + + - ',' + - '-' + - . + - / + - '0' + - '1' + - '2' + - '3' + - '4' + - '5' + - '6' + - '7' + - '8' + - '9' + - ':' + - ; + - < + - '=' + - '>' + - '?' + - A + - B + - C + - D + - E + - F + - G + - H + - I + - J + - K + - L + - M + - N + - O + - P + - Q + - R + - S + - T + - U + - V + - W + - X + - Y + - Z + - '[' + - ']' + - _ + - '`' + - a + - b + - c + - d + - e + - f + - g + - h + - i + - j + - k + - l + - m + - n + - o + - p + - q + - r + - s + - t + - u + - v + - w + - x + - y + - z + - © + - ‥ + - '{' + - '}' + - \ + - '|' + - '@' + - ^ + - '~' + - ÷ + - ∕ + - ∙ + - ⋅ + - · + - ± + - ∓ + - ∩ + - ∪ + - □ + - ← + - ↔ + - ⇒ + - ⇐ + - ⇔ + - ∀ + - ∃ + - ∄ + - ∴ + - ∵ + - ∝ + - ∞ + - ⊥ + - ∟ + - ∠ + - ∡ + - ∢ + - ′ + - ″ + - ∥ + - ⊾ + - ⊿ + - ∂ + - ∫ + - ∬ + - ∭ + - ∮ + - ∯ + - ∰ + - ∑ + - ∏ + - √ + - ∛ + - ∜ + - ∱ + - ∲ + - ∳ + - ∶ + - ∷ + - ∼ + - ® + - ℉ + - Ω + - ℧ + - Å + - ⌀ + - ℏ + - ⅀ + - ⍺ + - ⍵ + - ¢ + - € + - £ + - ¥ + - ₿ + - Ⅰ + - Ⅱ + - Ⅲ + - Ⅳ + - Ⅴ + - Ⅵ + - Ⅶ + - Ⅷ + - Ⅸ + - Ⅹ + - Ⅺ + - Ⅻ + - ⅰ + - ⅱ + - ⅲ + - ⅳ + - ⅴ + - ⅵ + - ⅶ + - ⅷ + - ⅸ + - ⅹ + - ⅺ + - ⅻ + - ➀ + - ➁ + - ➂ + - ➃ + - ➄ + - ➅ + - ➆ + - ➇ + - ➈ + - ➉ + - ➊ + - ➋ + - ➌ + - ➍ + - ➎ + - ➏ + - ➐ + - ➑ + - ➒ + - ➓ + - ❶ + - ❷ + - ❸ + - ❹ + - ❺ + - ❻ + - ❼ + - ❽ + - ❾ + - ❿ + - ① + - ② + - ③ + - ④ + - ⑤ + - ⑥ + - ⑦ + - ⑧ + - ⑨ + - ⑩ + - ● + - ▶ + - 𝑢 + - ︽ + - – + - ﹥ + - 𝜓 + - • + - ∋ + - ƒ + - ⬆ + - Ạ + - ◀ + -  + - ▫ + - ︾ + - À + - Á + - Â + - Ã + - Ä + - Å + - Æ + - Ç + - È + - É + - Ê + - Ë + - Ì + - Í + - Î + - Ï + - Ð + - Ñ + - Ò + - Ó + - Ô + - Õ + - Ö + - Ø + - Ù + - Ú + - Û + - Ü + - Ý + - Þ + - à + - á + - â + - ã + - ä + - å + - æ + - ç + - è + - é + - ê + - ë + - ì + - í + - î + - ï + - ð + - ñ + - ò + - ó + - ô + - õ + - ö + - ø + - ù + - ú + - û + - ü + - ý + - þ + - ÿ + - ¡ + - ¤ + - ¦ + - § + - ¨ + - ª + - « + - ¬ + - ¯ + - ° + - ² + - ³ + - ´ + - µ + - ¶ + - ¸ + - ¹ + - º + - » + - ¼ + - ½ + - ¾ + - ¿ + - × + - ‐ + - ‑ + - ‒ + - — + - ― + - ‖ + - ‗ + - ‘ + - ’ + - ‚ + - ‛ + - “ + - ” + - „ + - ‟ + - † + - ‡ + - ‣ + - ․ + - … + - ‧ + - ‰ + - ‴ + - ‵ + - ‶ + - ‷ + - ‸ + - ‹ + - › + - ※ + - ‼ + - ‽ + - ‾ + - ₤ + - ₡ + - ₹ + - − + - ∖ + - ∗ + - ≈ + - ≠ + - ≡ + - ≤ + - ≥ + - ⊂ + - ⊃ + - ↑ + - → + - ↓ + - ↕ + - ™ + - Ω + - ℮ + - ∆ + - ✓ + - ✗ + - ✘ + - ▪ + - ◼ + - ✔ + - ✕ + - ☑ + - ☒ + - № + - ₽ + - ₴ + - Α + - α + - Β + - β + - Γ + - γ + - Δ + - δ + - Ε + - ε + - Ζ + - ζ + - Η + - η + - Θ + - θ + - Ι + - ι + - Κ + - κ + - Λ + - λ + - Μ + - μ + - Ν + - ν + - Ξ + - ξ + - Ο + - ο + - Π + - π + - Ρ + - ρ + - Σ + - σ + - ς + - Τ + - τ + - Υ + - υ + - Φ + - φ + - Χ + - χ + - Ψ + - ψ + - ω + - ऀ + - ँ + - ं + - ः + - ऄ + - अ + - आ + - इ + - ई + - उ + - ऊ + - ऋ + - ऌ + - ऍ + - ऎ + - ए + - ऐ + - ऑ + - ऒ + - ओ + - औ + - क + - ख + - ग + - घ + - ङ + - च + - छ + - ज + - झ + - ञ + - ट + - ठ + - ड + - ढ + - ण + - त + - थ + - द + - ध + - न + - ऩ + - प + - फ + - ब + - भ + - म + - य + - र + - ऱ + - ल + - ळ + - ऴ + - व + - श + - ष + - स + - ह + - ऺ + - ऻ + - ़ + - ऽ + - ा + - ि + - ी + - ु + - ू + - ृ + - ॄ + - ॅ + - ॆ + - े + - ै + - ॉ + - ॊ + - ो + - ौ + - ् + - ॎ + - ॏ + - ॐ + - ॑ + - ॒ + - ॓ + - ॔ + - ॕ + - ॖ + - ॗ + - क़ + - ख़ + - ग़ + - ज़ + - ड़ + - ढ़ + - फ़ + - य़ + - ॠ + - ॡ + - ॢ + - ॣ + - । + - ॥ + - ० + - १ + - २ + - ३ + - ४ + - ५ + - ६ + - ७ + - ८ + - ९ + - ॰ + - ॱ + - ॲ + - ॳ + - ॴ + - ॵ + - ॶ + - ॷ + - ॸ + - ॹ + - ॺ + - ॻ + - ॼ + - ॽ + - ॾ + - ॿ diff --git a/k2-ampixa-demo-ocr/models/space/models/devanagari-ppocrv5/MODEL-SOURCE.txt b/k2-ampixa-demo-ocr/models/space/models/devanagari-ppocrv5/MODEL-SOURCE.txt new file mode 100644 index 0000000000000000000000000000000000000000..f97ba61e18b43d1c113dfadde68029f25fdda432 --- /dev/null +++ b/k2-ampixa-demo-ocr/models/space/models/devanagari-ppocrv5/MODEL-SOURCE.txt @@ -0,0 +1,5 @@ +source: PaddleOCR official devanagari_PP-OCRv5_mobile_rec (Apache-2.0), copied from the PaddleX cache on k2 2026-09-24 +20d3b121184ec6b7de1705015022f4b22117990f6e5728a5d21c314bac9c1444 inference.json +719be7d20bfe9530e2deae324c999e9911087496bce5e70846767c448d023a01 inference.pdiparams +9bd172dd26440c8ce94d1cde5d5baea6aefdc7cf3c5c8492e0beedef656d4e54 inference.yml +b823d922aa6aedc9fda8412b94e2600885bf8442c5d2197f456a4e672d36481c config.json diff --git a/k2-ampixa-demo-ocr/models/space/models/devanagari-ppocrv5/artifacts/README.md b/k2-ampixa-demo-ocr/models/space/models/devanagari-ppocrv5/artifacts/README.md new file mode 100644 index 0000000000000000000000000000000000000000..93ba80f117be9db034336cca498e0d1048935826 --- /dev/null +++ b/k2-ampixa-demo-ocr/models/space/models/devanagari-ppocrv5/artifacts/README.md @@ -0,0 +1,169 @@ +--- +license: apache-2.0 +library_name: PaddleOCR +language: +- en +pipeline_tag: image-to-text +tags: +- OCR +- PaddlePaddle +- PaddleOCR +- textline_recognition +--- + +# devanagari_PP-OCRv5_mobile_rec + +## Introduction + +devanagari_PP-OCRv5_mobile_rec is one of the PP-OCRv5_rec that are the latest generation text line recognition models developed by PaddleOCR team. It aims to efficiently and accurately support the recognition of Devanagari. The key accuracy metrics are as follow: + +| Model | Accuracy (%) | +|-|-| +| devanagari_PP-OCRv5_mobile_rec | 84.96| + + + +**Note**: If any character (including punctuation) in a line was incorrect, the entire line was marked as wrong. This ensures higher accuracy in practical applications. + +## Quick Start + +### Installation + +1. PaddlePaddle + +Please refer to the following commands to install PaddlePaddle using pip: + +```bash +# for CUDA11.8 +python -m pip install paddlepaddle-gpu==3.0.0 -i https://www.paddlepaddle.org.cn/packages/stable/cu118/ + +# for CUDA12.6 +python -m pip install paddlepaddle-gpu==3.0.0 -i https://www.paddlepaddle.org.cn/packages/stable/cu126/ + +# for CPU +python -m pip install paddlepaddle==3.0.0 -i https://www.paddlepaddle.org.cn/packages/stable/cpu/ +``` + +For details about PaddlePaddle installation, please refer to the [PaddlePaddle official website](https://www.paddlepaddle.org.cn/en/install/quick). + +2. PaddleOCR + +Install the latest version of the PaddleOCR inference package from PyPI: + +```bash +python -m pip install paddleocr +``` + +### Model Usage + +You can quickly experience the functionality with a single command: + +```bash +paddleocr text_recognition \ + --model_name devanagari_PP-OCRv5_mobile_rec \ + -i https://cdn-uploads.huggingface.co/production/uploads/684ad4f6eb7d8ee8f6a92a3a/dtgfI1BdDM7c9BB0X3-xE.png +``` + +You can also integrate the model inference of the text recognition module into your project. Before running the following code, please download the sample image to your local machine. + +```python +from paddleocr import TextRecognition +model = TextRecognition(model_name="devanagari_PP-OCRv5_mobile_rec") +output = model.predict(input="dtgfI1BdDM7c9BB0X3-xE.png", batch_size=1) +for res in output: + res.print() + res.save_to_img(save_path="./output/") + res.save_to_json(save_path="./output/res.json") +``` + +After running, the obtained result is as follows: + +```json +{'res': {'input_path': '/root/.paddlex/predict_input/dtgfI1BdDM7c9BB0X3-xE.png', 'page_index': None, 'rec_text': 'कख ग घड', 'rec_score': 0.8845340013504028}} +``` + +The visualized image is as follows: + +![image/jpeg](https://cdn-uploads.huggingface.co/production/uploads/684ad4f6eb7d8ee8f6a92a3a/G6Zqw5OG2kSNopsgBJYWb.png) + +For details about usage command and descriptions of parameters, please refer to the [Document](https://paddlepaddle.github.io/PaddleOCR/latest/en/version3.x/module_usage/text_recognition.html#iii-quick-start). + +### Pipeline Usage + +The ability of a single model is limited. But the pipeline consists of several models can provide more capacity to resolve difficult problems in real-world scenarios. + +#### PP-OCRv5 + +The general OCR pipeline is used to solve text recognition tasks by extracting text information from images and outputting it in string format. And there are 5 modules in the pipeline: +* Document Image Orientation Classification Module (Optional) +* Text Image Unwarping Module (Optional) +* Text Line Orientation Classification Module (Optional) +* Text Detection Module +* Text Recognition Module + +Run a single command to quickly experience the OCR pipeline: + +```bash +paddleocr ocr -i https://cdn-uploads.huggingface.co/production/uploads/684ad4f6eb7d8ee8f6a92a3a/4565zt8fsAJ2JCVyP2OEa.png \ + --text_recognition_model_name devanagari_PP-OCRv5_mobile_rec \ + --use_doc_orientation_classify False \ + --use_doc_unwarping False \ + --use_textline_orientation True \ + --save_path ./output \ + --device gpu:0 +``` + +Results are printed to the terminal: + +```json +{'res': {'input_path': '/root/.paddlex/predict_input/4565zt8fsAJ2JCVyP2OEa.png', 'page_index': None, 'model_settings': {'use_doc_preprocessor': True, 'use_textline_orientation': False}, 'doc_preprocessor_res': {'input_path': None, 'page_index': None, 'model_settings': {'use_doc_orientation_classify': False, 'use_doc_unwarping': False}, 'angle': -1}, 'dt_polys': array([[[ 172, 201], + ..., + [ 172, 290]], + + ..., + + [[ 795, 2010], + ..., + [ 795, 2055]]], shape=(42, 4, 2), dtype=int16), 'text_det_params': {'limit_side_len': 64, 'limit_type': 'min', 'thresh': 0.3, 'max_side_limit': 4000, 'box_thresh': 0.6, 'unclip_ratio': 1.5}, 'text_type': 'general', 'textline_orientation_angles': array([-1, ..., -1], shape=(42,)), 'text_rec_score_thresh': 0.0, 'return_word_box': False, 'rec_texts': ['विषय-सूची', 'क्र.सं.', 'विवरण', 'पृष्ठ सं.', '1', 'आरईसी लिमिटेड और आरईसीआईपीएमटी के बारे में', '2-3', '2', 'विदयुत क्षत्र के अधिकारियों के लिए राष्टीय नियमित प्रशिक्षण कार्यक्रम', '4-10', '3', 'विदयुत क्षत्र के अधिकारियों के लिए आरईसी द्वारा प्रायोजित प्रशिक्षण कार्यक्रम', '11-14', 'आरईसीआईपीएमटी/ऑफ-कैंपस में आरईसी के कर्मचारियों के लिए इन-हाउस', '4', 'प्रशिक्षण कार्यक्रम', '15-16', '5', 'अनुकूलित प्रशिकषण कैंपस', '17-18', '6', 'आरईसीआईपीएमटी कैंपस', '19-21', '7', 'अंतरिक फैकल्टी के सदस्य', '22', '8', 'बाहरी फैकल्टी के सदस्य', '23', 'संस्थानों और यूटिलिटीज के साथ समझौता ज़ापन', '9', '24', 'मिशन', 'अपने अनुभव, विशेषज्ञता को साझञा करने और बिजली', 'यूटिलिटिज के प्रबंधकीय कर्मियों को प्रबुद्ध करने के लिए', 'बिजली क्षेत्र के मानव संसाधन विकास के लिए वैश्िक', 'उत्कृष्टता की एक संस्था का निर्माण करना।', 'विज़न', 'बिजली इंजीनियरों/्रबंधकों तक पहुंचना, शिक्षित करना,', 'प्रित करना, पोषण करना, प्रबुद करना और सक्रय करना', 'और उच्च उत्पादकता प्रस्त करने के लिए मानव संसाधनों', 'में गुणवता सुधार के लिए प्रयास करना।'], 'rec_scores': array([0.96054012, ..., 0.96115613], shape=(42,)), 'rec_polys': array([[[ 172, 201], + ..., + [ 172, 290]], + + ..., + + [[ 795, 2010], + ..., + [ 795, 2055]]], shape=(42, 4, 2), dtype=int16), 'rec_boxes': array([[ 172, ..., 290], + ..., + [ 795, ..., 2061]], shape=(42, 4), dtype=int16)}} +``` + +If save_path is specified, the visualization results will be saved under `save_path`. The visualization output is shown below: + +![image/jpeg](https://cdn-uploads.huggingface.co/production/uploads/684ad4f6eb7d8ee8f6a92a3a/yS8pRQnX1uIlgfjaqPXlu.png) + +The command-line method is for quick experience. For project integration, also only a few codes are needed as well: + +```python +from paddleocr import PaddleOCR + +ocr = PaddleOCR( + text_recognition_model_name="devanagari_PP-OCRv5_mobile_rec", + use_doc_orientation_classify=False, # Use use_doc_orientation_classify to enable/disable document orientation classification model + use_doc_unwarping=False, # Use use_doc_unwarping to enable/disable document unwarping module + use_textline_orientation=True, # Use use_textline_orientation to enable/disable textline orientation classification model + device="gpu:0", # Use device to specify GPU for model inference +) +result = ocr.predict("https://cdn-uploads.huggingface.co/production/uploads/684ad4f6eb7d8ee8f6a92a3a/4565zt8fsAJ2JCVyP2OEa.png") +for res in result: + res.print() + res.save_to_img("output") + res.save_to_json("output") +``` + +The default model used in pipeline is `PP-OCRv5_server_rec`, so it is needed that specifing to `devanagari_PP-OCRv5_mobile_rec` by argument `text_recognition_model_name`. And you can also use the local model file by argument `text_recognition_model_dir`. For details about usage command and descriptions of parameters, please refer to the [Document](https://paddlepaddle.github.io/PaddleOCR/latest/en/version3.x/pipeline_usage/OCR.html#2-quick-start). + +## Links + +[PaddleOCR Repo](https://github.com/paddlepaddle/paddleocr) + +[PaddleOCR Documentation](https://paddlepaddle.github.io/PaddleOCR/latest/en/index.html) diff --git a/k2-ampixa-demo-ocr/models/space/models/devanagari-ppocrv5/artifacts/config.json b/k2-ampixa-demo-ocr/models/space/models/devanagari-ppocrv5/artifacts/config.json new file mode 100644 index 0000000000000000000000000000000000000000..daf2c1401ced9f3f479d2b334945f4835651c304 --- /dev/null +++ b/k2-ampixa-demo-ocr/models/space/models/devanagari-ppocrv5/artifacts/config.json @@ -0,0 +1,665 @@ +{ + "Global": { + "model_name": "devanagari_PP-OCRv5_mobile_rec" + }, + "Hpi": { + "backend_configs": { + "paddle_infer": { + "trt_dynamic_shapes": { + "x": [ + [ + 1, + 3, + 48, + 160 + ], + [ + 1, + 3, + 48, + 320 + ], + [ + 8, + 3, + 48, + 3200 + ] + ] + } + }, + "tensorrt": { + "dynamic_shapes": { + "x": [ + [ + 1, + 3, + 48, + 160 + ], + [ + 1, + 3, + 48, + 320 + ], + [ + 8, + 3, + 48, + 3200 + ] + ] + } + } + } + }, + "PreProcess": { + "transform_ops": [ + { + "DecodeImage": { + "channel_first": false, + "img_mode": "BGR" + } + }, + { + "MultiLabelEncode": { + "gtc_encode": "NRTRLabelEncode" + } + }, + { + "RecResizeImg": { + "image_shape": [ + 3, + 48, + 320 + ] + } + }, + { + "KeepKeys": { + "keep_keys": [ + "image", + "label_ctc", + "label_gtc", + "length", + "valid_ratio" + ] + } + } + ] + }, + "PostProcess": { + "name": "CTCLabelDecode", + "character_dict": [ + "!", + "\"", + "#", + "$", + "%", + "&", + "'", + "(", + ")", + "*", + "+", + ",", + "-", + ".", + "/", + "0", + "1", + "2", + "3", + "4", + "5", + "6", + "7", + "8", + "9", + ":", + ";", + "<", + "=", + ">", + "?", + "A", + "B", + "C", + "D", + "E", + "F", + "G", + "H", + "I", + "J", + "K", + "L", + "M", + "N", + "O", + "P", + "Q", + "R", + "S", + "T", + "U", + "V", + "W", + "X", + "Y", + "Z", + "[", + "]", + "_", + "`", + "a", + "b", + "c", + "d", + "e", + "f", + "g", + "h", + "i", + "j", + "k", + "l", + "m", + "n", + "o", + "p", + "q", + "r", + "s", + "t", + "u", + "v", + "w", + "x", + "y", + "z", + "©", + "‥", + "{", + "}", + "\\", + "|", + "@", + "^", + "~", + "÷", + "∕", + "∙", + "⋅", + "·", + "±", + "∓", + "∩", + "∪", + "□", + "←", + "↔", + "⇒", + "⇐", + "⇔", + "∀", + "∃", + "∄", + "∴", + "∵", + "∝", + "∞", + "⊥", + "∟", + "∠", + "∡", + "∢", + "′", + "″", + "∥", + "⊾", + "⊿", + "∂", + "∫", + "∬", + "∭", + "∮", + "∯", + "∰", + "∑", + "∏", + "√", + "∛", + "∜", + "∱", + "∲", + "∳", + "∶", + "∷", + "∼", + "®", + "℉", + "Ω", + "℧", + "Å", + "⌀", + "ℏ", + "⅀", + "⍺", + "⍵", + "¢", + "€", + "£", + "¥", + "₿", + "Ⅰ", + "Ⅱ", + "Ⅲ", + "Ⅳ", + "Ⅴ", + "Ⅵ", + "Ⅶ", + "Ⅷ", + "Ⅸ", + "Ⅹ", + "Ⅺ", + "Ⅻ", + "ⅰ", + "ⅱ", + "ⅲ", + "ⅳ", + "ⅴ", + "ⅵ", + "ⅶ", + "ⅷ", + "ⅸ", + "ⅹ", + "ⅺ", + "ⅻ", + "➀", + "➁", + "➂", + "➃", + "➄", + "➅", + "➆", + "➇", + "➈", + "➉", + "➊", + "➋", + "➌", + "➍", + "➎", + "➏", + "➐", + "➑", + "➒", + "➓", + "❶", + "❷", + "❸", + "❹", + "❺", + "❻", + "❼", + "❽", + "❾", + "❿", + "①", + "②", + "③", + "④", + "⑤", + "⑥", + "⑦", + "⑧", + "⑨", + "⑩", + "●", + "▶", + "𝑢", + "︽", + "–", + "﹥", + "𝜓", + "•", + "∋", + "ƒ", + "⬆", + "Ạ", + "◀", + "", + "▫", + "︾", + "À", + "Á", + "Â", + "Ã", + "Ä", + "Å", + "Æ", + "Ç", + "È", + "É", + "Ê", + "Ë", + "Ì", + "Í", + "Î", + "Ï", + "Ð", + "Ñ", + "Ò", + "Ó", + "Ô", + "Õ", + "Ö", + "Ø", + "Ù", + "Ú", + "Û", + "Ü", + "Ý", + "Þ", + "à", + "á", + "â", + "ã", + "ä", + "å", + "æ", + "ç", + "è", + "é", + "ê", + "ë", + "ì", + "í", + "î", + "ï", + "ð", + "ñ", + "ò", + "ó", + "ô", + "õ", + "ö", + "ø", + "ù", + "ú", + "û", + "ü", + "ý", + "þ", + "ÿ", + "¡", + "¤", + "¦", + "§", + "¨", + "ª", + "«", + "¬", + "¯", + "°", + "²", + "³", + "´", + "µ", + "¶", + "¸", + "¹", + "º", + "»", + "¼", + "½", + "¾", + "¿", + "×", + "‐", + "‑", + "‒", + "—", + "―", + "‖", + "‗", + "‘", + "’", + "‚", + "‛", + "“", + "”", + "„", + "‟", + "†", + "‡", + "‣", + "․", + "…", + "‧", + "‰", + "‴", + "‵", + "‶", + "‷", + "‸", + "‹", + "›", + "※", + "‼", + "‽", + "‾", + "₤", + "₡", + "₹", + "−", + "∖", + "∗", + "≈", + "≠", + "≡", + "≤", + "≥", + "⊂", + "⊃", + "↑", + "→", + "↓", + "↕", + "™", + "Ω", + "℮", + "∆", + "✓", + "✗", + "✘", + "▪", + "◼", + "✔", + "✕", + "☑", + "☒", + "№", + "₽", + "₴", + "Α", + "α", + "Β", + "β", + "Γ", + "γ", + "Δ", + "δ", + "Ε", + "ε", + "Ζ", + "ζ", + "Η", + "η", + "Θ", + "θ", + "Ι", + "ι", + "Κ", + "κ", + "Λ", + "λ", + "Μ", + "μ", + "Ν", + "ν", + "Ξ", + "ξ", + "Ο", + "ο", + "Π", + "π", + "Ρ", + "ρ", + "Σ", + "σ", + "ς", + "Τ", + "τ", + "Υ", + "υ", + "Φ", + "φ", + "Χ", + "χ", + "Ψ", + "ψ", + "ω", + "ऀ", + "ँ", + "ं", + "ः", + "ऄ", + "अ", + "आ", + "इ", + "ई", + "उ", + "ऊ", + "ऋ", + "ऌ", + "ऍ", + "ऎ", + "ए", + "ऐ", + "ऑ", + "ऒ", + "ओ", + "औ", + "क", + "ख", + "ग", + "घ", + "ङ", + "च", + "छ", + "ज", + "झ", + "ञ", + "ट", + "ठ", + "ड", + "ढ", + "ण", + "त", + "थ", + "द", + "ध", + "न", + "ऩ", + "प", + "फ", + "ब", + "भ", + "म", + "य", + "र", + "ऱ", + "ल", + "ळ", + "ऴ", + "व", + "श", + "ष", + "स", + "ह", + "ऺ", + "ऻ", + "़", + "ऽ", + "ा", + "ि", + "ी", + "ु", + "ू", + "ृ", + "ॄ", + "ॅ", + "ॆ", + "े", + "ै", + "ॉ", + "ॊ", + "ो", + "ौ", + "्", + "ॎ", + "ॏ", + "ॐ", + "॑", + "॒", + "॓", + "॔", + "ॕ", + "ॖ", + "ॗ", + "क़", + "ख़", + "ग़", + "ज़", + "ड़", + "ढ़", + "फ़", + "य़", + "ॠ", + "ॡ", + "ॢ", + "ॣ", + "।", + "॥", + "०", + "१", + "२", + "३", + "४", + "५", + "६", + "७", + "८", + "९", + "॰", + "ॱ", + "ॲ", + "ॳ", + "ॴ", + "ॵ", + "ॶ", + "ॷ", + "ॸ", + "ॹ", + "ॺ", + "ॻ", + "ॼ", + "ॽ", + "ॾ", + "ॿ" + ] + } +} \ No newline at end of file diff --git a/k2-ampixa-demo-ocr/models/space/models/devanagari-ppocrv5/artifacts/inference.json b/k2-ampixa-demo-ocr/models/space/models/devanagari-ppocrv5/artifacts/inference.json new file mode 100644 index 0000000000000000000000000000000000000000..c8074e02ecd9018da4e75f1621020e394d38b0b3 --- /dev/null +++ b/k2-ampixa-demo-ocr/models/space/models/devanagari-ppocrv5/artifacts/inference.json @@ -0,0 +1 @@ +{"base_code":{"magic":"pir","trainable":true,"version":1},"program":{"regions":[{"#":"region_0","blocks":[{"#":"block_0","args":[],"ops":[{"#":"p","A":[0,1,1,"linear_8.b_0"],"DA":[],"O":{"%":1,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[570],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_8.w_0"],"DA":[],"O":{"%":2,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,570],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_2"],"DA":[],"O":{"%":3,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_1"],"DA":[],"O":{"%":4,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.b_0"],"DA":[],"O":{"%":5,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_0"],"DA":[],"O":{"%":6,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_135.w_0"],"DA":[],"O":{"%":7,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_2"],"DA":[],"O":{"%":8,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_1"],"DA":[],"O":{"%":9,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.b_0"],"DA":[],"O":{"%":10,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_0"],"DA":[],"O":{"%":11,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_134.w_0"],"DA":[],"O":{"%":12,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,960,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_2"],"DA":[],"O":{"%":13,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_1"],"DA":[],"O":{"%":14,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.b_0"],"DA":[],"O":{"%":15,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_0"],"DA":[],"O":{"%":16,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_133.w_0"],"DA":[],"O":{"%":17,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,120,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_4.b_0"],"DA":[],"O":{"%":18,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_4.w_0"],"DA":[],"O":{"%":19,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_7.b_0"],"DA":[],"O":{"%":20,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_7.w_0"],"DA":[],"O":{"%":21,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_6.b_0"],"DA":[],"O":{"%":22,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_6.w_0"],"DA":[],"O":{"%":23,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_3.b_0"],"DA":[],"O":{"%":24,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_3.w_0"],"DA":[],"O":{"%":25,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_5.b_0"],"DA":[],"O":{"%":26,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_5.w_0"],"DA":[],"O":{"%":27,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_4.b_0"],"DA":[],"O":{"%":28,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_4.w_0"],"DA":[],"O":{"%":29,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_2.b_0"],"DA":[],"O":{"%":30,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_2.w_0"],"DA":[],"O":{"%":31,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_3.b_0"],"DA":[],"O":{"%":32,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_3.w_0"],"DA":[],"O":{"%":33,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_2.b_0"],"DA":[],"O":{"%":34,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_2.w_0"],"DA":[],"O":{"%":35,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_1.b_0"],"DA":[],"O":{"%":36,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_1.w_0"],"DA":[],"O":{"%":37,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_1.b_0"],"DA":[],"O":{"%":38,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_1.w_0"],"DA":[],"O":{"%":39,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_0.b_0"],"DA":[],"O":{"%":40,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_0.w_0"],"DA":[],"O":{"%":41,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_0.b_0"],"DA":[],"O":{"%":42,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_0.w_0"],"DA":[],"O":{"%":43,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_2"],"DA":[],"O":{"%":44,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_1"],"DA":[],"O":{"%":45,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.b_0"],"DA":[],"O":{"%":46,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_0"],"DA":[],"O":{"%":47,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_132.w_0"],"DA":[],"O":{"%":48,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_2"],"DA":[],"O":{"%":49,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_1"],"DA":[],"O":{"%":50,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.b_0"],"DA":[],"O":{"%":51,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_0"],"DA":[],"O":{"%":52,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_131.w_0"],"DA":[],"O":{"%":53,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,480,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_163.b_0"],"DA":[],"O":{"%":54,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_163.w_0"],"DA":[],"O":{"%":55,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_55.w_1"],"DA":[],"O":{"%":56,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_55.w_0"],"DA":[],"O":{"%":57,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_54.w_1"],"DA":[],"O":{"%":58,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_54.w_0"],"DA":[],"O":{"%":59,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_162.b_0"],"DA":[],"O":{"%":60,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_162.w_0"],"DA":[],"O":{"%":61,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_53.w_1"],"DA":[],"O":{"%":62,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_53.w_0"],"DA":[],"O":{"%":63,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_52.w_1"],"DA":[],"O":{"%":64,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_52.w_0"],"DA":[],"O":{"%":65,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_161.b_0"],"DA":[],"O":{"%":66,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_161.w_0"],"DA":[],"O":{"%":67,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_51.w_1"],"DA":[],"O":{"%":68,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_51.w_0"],"DA":[],"O":{"%":69,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_50.w_1"],"DA":[],"O":{"%":70,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_50.w_0"],"DA":[],"O":{"%":71,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_160.b_0"],"DA":[],"O":{"%":72,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_160.w_0"],"DA":[],"O":{"%":73,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_49.w_1"],"DA":[],"O":{"%":74,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_49.w_0"],"DA":[],"O":{"%":75,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_48.w_1"],"DA":[],"O":{"%":76,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_48.w_0"],"DA":[],"O":{"%":77,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_159.b_0"],"DA":[],"O":{"%":78,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_159.w_0"],"DA":[],"O":{"%":79,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_47.w_1"],"DA":[],"O":{"%":80,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_47.w_0"],"DA":[],"O":{"%":81,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_46.w_1"],"DA":[],"O":{"%":82,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_46.w_0"],"DA":[],"O":{"%":83,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_108.b_0"],"DA":[],"O":{"%":84,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_108.w_0"],"DA":[],"O":{"%":85,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,120,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_107.b_0"],"DA":[],"O":{"%":86,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_107.w_0"],"DA":[],"O":{"%":87,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_158.b_0"],"DA":[],"O":{"%":88,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_158.w_0"],"DA":[],"O":{"%":89,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_45.w_1"],"DA":[],"O":{"%":90,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_45.w_0"],"DA":[],"O":{"%":91,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_44.w_1"],"DA":[],"O":{"%":92,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_44.w_0"],"DA":[],"O":{"%":93,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_157.b_0"],"DA":[],"O":{"%":94,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_157.w_0"],"DA":[],"O":{"%":95,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_43.w_1"],"DA":[],"O":{"%":96,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_43.w_0"],"DA":[],"O":{"%":97,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_42.w_1"],"DA":[],"O":{"%":98,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_42.w_0"],"DA":[],"O":{"%":99,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_97.b_0"],"DA":[],"O":{"%":100,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_97.w_0"],"DA":[],"O":{"%":101,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_96.b_0"],"DA":[],"O":{"%":102,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_96.w_0"],"DA":[],"O":{"%":103,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_156.b_0"],"DA":[],"O":{"%":104,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_156.w_0"],"DA":[],"O":{"%":105,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_41.w_1"],"DA":[],"O":{"%":106,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_41.w_0"],"DA":[],"O":{"%":107,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_40.w_1"],"DA":[],"O":{"%":108,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_40.w_0"],"DA":[],"O":{"%":109,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_155.b_0"],"DA":[],"O":{"%":110,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_155.w_0"],"DA":[],"O":{"%":111,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_39.w_1"],"DA":[],"O":{"%":112,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_39.w_0"],"DA":[],"O":{"%":113,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_38.w_1"],"DA":[],"O":{"%":114,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_38.w_0"],"DA":[],"O":{"%":115,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_154.b_0"],"DA":[],"O":{"%":116,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_154.w_0"],"DA":[],"O":{"%":117,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_37.w_1"],"DA":[],"O":{"%":118,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_37.w_0"],"DA":[],"O":{"%":119,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_36.w_1"],"DA":[],"O":{"%":120,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_36.w_0"],"DA":[],"O":{"%":121,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_153.b_0"],"DA":[],"O":{"%":122,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_153.w_0"],"DA":[],"O":{"%":123,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_35.w_1"],"DA":[],"O":{"%":124,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_35.w_0"],"DA":[],"O":{"%":125,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_34.w_1"],"DA":[],"O":{"%":126,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_34.w_0"],"DA":[],"O":{"%":127,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_152.b_0"],"DA":[],"O":{"%":128,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_152.w_0"],"DA":[],"O":{"%":129,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_33.w_1"],"DA":[],"O":{"%":130,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_33.w_0"],"DA":[],"O":{"%":131,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_32.w_1"],"DA":[],"O":{"%":132,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_32.w_0"],"DA":[],"O":{"%":133,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_151.b_0"],"DA":[],"O":{"%":134,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_151.w_0"],"DA":[],"O":{"%":135,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_31.w_1"],"DA":[],"O":{"%":136,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_31.w_0"],"DA":[],"O":{"%":137,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_30.w_1"],"DA":[],"O":{"%":138,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_30.w_0"],"DA":[],"O":{"%":139,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_150.b_0"],"DA":[],"O":{"%":140,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_150.w_0"],"DA":[],"O":{"%":141,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_29.w_1"],"DA":[],"O":{"%":142,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_29.w_0"],"DA":[],"O":{"%":143,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_28.w_1"],"DA":[],"O":{"%":144,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_28.w_0"],"DA":[],"O":{"%":145,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_149.b_0"],"DA":[],"O":{"%":146,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_149.w_0"],"DA":[],"O":{"%":147,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_27.w_1"],"DA":[],"O":{"%":148,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_27.w_0"],"DA":[],"O":{"%":149,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_26.w_1"],"DA":[],"O":{"%":150,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_26.w_0"],"DA":[],"O":{"%":151,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_148.b_0"],"DA":[],"O":{"%":152,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_148.w_0"],"DA":[],"O":{"%":153,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_25.w_1"],"DA":[],"O":{"%":154,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_25.w_0"],"DA":[],"O":{"%":155,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_24.w_1"],"DA":[],"O":{"%":156,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_24.w_0"],"DA":[],"O":{"%":157,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_147.b_0"],"DA":[],"O":{"%":158,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_147.w_0"],"DA":[],"O":{"%":159,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,128,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_23.w_1"],"DA":[],"O":{"%":160,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_23.w_0"],"DA":[],"O":{"%":161,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_22.w_1"],"DA":[],"O":{"%":162,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_22.w_0"],"DA":[],"O":{"%":163,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_146.b_0"],"DA":[],"O":{"%":164,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_146.w_0"],"DA":[],"O":{"%":165,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_21.w_1"],"DA":[],"O":{"%":166,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_21.w_0"],"DA":[],"O":{"%":167,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_20.w_1"],"DA":[],"O":{"%":168,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_20.w_0"],"DA":[],"O":{"%":169,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_145.b_0"],"DA":[],"O":{"%":170,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_145.w_0"],"DA":[],"O":{"%":171,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,128,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_19.w_1"],"DA":[],"O":{"%":172,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_19.w_0"],"DA":[],"O":{"%":173,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_18.w_1"],"DA":[],"O":{"%":174,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_18.w_0"],"DA":[],"O":{"%":175,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_144.b_0"],"DA":[],"O":{"%":176,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_144.w_0"],"DA":[],"O":{"%":177,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_17.w_1"],"DA":[],"O":{"%":178,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_17.w_0"],"DA":[],"O":{"%":179,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_16.w_1"],"DA":[],"O":{"%":180,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_16.w_0"],"DA":[],"O":{"%":181,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_143.b_0"],"DA":[],"O":{"%":182,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_143.w_0"],"DA":[],"O":{"%":183,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_15.w_1"],"DA":[],"O":{"%":184,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_15.w_0"],"DA":[],"O":{"%":185,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_14.w_1"],"DA":[],"O":{"%":186,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_14.w_0"],"DA":[],"O":{"%":187,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_142.b_0"],"DA":[],"O":{"%":188,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_142.w_0"],"DA":[],"O":{"%":189,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_13.w_1"],"DA":[],"O":{"%":190,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_13.w_0"],"DA":[],"O":{"%":191,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_12.w_1"],"DA":[],"O":{"%":192,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_12.w_0"],"DA":[],"O":{"%":193,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_141.b_0"],"DA":[],"O":{"%":194,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_141.w_0"],"DA":[],"O":{"%":195,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_11.w_1"],"DA":[],"O":{"%":196,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_11.w_0"],"DA":[],"O":{"%":197,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_10.w_1"],"DA":[],"O":{"%":198,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_10.w_0"],"DA":[],"O":{"%":199,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_140.b_0"],"DA":[],"O":{"%":200,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_140.w_0"],"DA":[],"O":{"%":201,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_9.w_1"],"DA":[],"O":{"%":202,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_9.w_0"],"DA":[],"O":{"%":203,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_8.w_1"],"DA":[],"O":{"%":204,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_8.w_0"],"DA":[],"O":{"%":205,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_139.b_0"],"DA":[],"O":{"%":206,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_139.w_0"],"DA":[],"O":{"%":207,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,32,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_7.w_1"],"DA":[],"O":{"%":208,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_7.w_0"],"DA":[],"O":{"%":209,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_6.w_1"],"DA":[],"O":{"%":210,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_6.w_0"],"DA":[],"O":{"%":211,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_138.b_0"],"DA":[],"O":{"%":212,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_138.w_0"],"DA":[],"O":{"%":213,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_5.w_1"],"DA":[],"O":{"%":214,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_5.w_0"],"DA":[],"O":{"%":215,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_4.w_1"],"DA":[],"O":{"%":216,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_4.w_0"],"DA":[],"O":{"%":217,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_137.b_0"],"DA":[],"O":{"%":218,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_137.w_0"],"DA":[],"O":{"%":219,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,16,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_3.w_1"],"DA":[],"O":{"%":220,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_3.w_0"],"DA":[],"O":{"%":221,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_2.w_1"],"DA":[],"O":{"%":222,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_2.w_0"],"DA":[],"O":{"%":223,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_136.b_0"],"DA":[],"O":{"%":224,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_136.w_0"],"DA":[],"O":{"%":225,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_1.w_1"],"DA":[],"O":{"%":226,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_1.w_0"],"DA":[],"O":{"%":227,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_0.w_1"],"DA":[],"O":{"%":228,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_0.w_0"],"DA":[],"O":{"%":229,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_2"],"DA":[],"O":{"%":230,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_1"],"DA":[],"O":{"%":231,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.b_0"],"DA":[],"O":{"%":232,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_0"],"DA":[],"O":{"%":233,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_0.w_0"],"DA":[],"O":{"%":234,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16,3,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"1.data","A":[{"AT":{"#":"0.a_str","D":"x"},"N":"name"},{"AT":{"#":"1.a_intarray","D":[-1,3,48,-1]},"N":"shape"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[0,0,""]},"N":"place"}],"I":[],"O":[{"%":235,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,3,48,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/ConvBNLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":235},{"%":234}],"O":[{"%":236,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/ConvBNLayer/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":236},{"%":231},{"%":230},{"%":233},{"%":232}],"O":[{"%":237,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}},{"%":238,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":239,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":240,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":241,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":242,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":16},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":237},{"%":225}],"O":[{"%":243,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":244,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":224},{"%":244}],"O":[{"%":245,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,16,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":243},{"%":245}],"O":[{"%":246,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":229},{"%":246}],"O":[{"%":247,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":247},{"%":228}],"O":[{"%":248,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":248}],"O":[{"%":249,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":227},{"%":249}],"O":[{"%":250,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":250},{"%":226}],"O":[{"%":251,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":251},{"%":219}],"O":[{"%":252,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":253,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":218},{"%":253}],"O":[{"%":254,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":252},{"%":254}],"O":[{"%":255,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":223},{"%":255}],"O":[{"%":256,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":256},{"%":222}],"O":[{"%":257,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":257}],"O":[{"%":258,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":221},{"%":258}],"O":[{"%":259,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":259},{"%":220}],"O":[{"%":260,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":32},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":260},{"%":213}],"O":[{"%":261,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":262,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":212},{"%":262}],"O":[{"%":263,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":261},{"%":263}],"O":[{"%":264,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":217},{"%":264}],"O":[{"%":265,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":265},{"%":216}],"O":[{"%":266,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":266}],"O":[{"%":267,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":215},{"%":267}],"O":[{"%":268,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":268},{"%":214}],"O":[{"%":269,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":269},{"%":207}],"O":[{"%":270,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":271,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":206},{"%":271}],"O":[{"%":272,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":270},{"%":272}],"O":[{"%":273,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":211},{"%":273}],"O":[{"%":274,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":274},{"%":210}],"O":[{"%":275,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":275}],"O":[{"%":276,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":209},{"%":276}],"O":[{"%":277,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":277},{"%":208}],"O":[{"%":278,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":64},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":278},{"%":201}],"O":[{"%":279,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":280,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":200},{"%":280}],"O":[{"%":281,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":279},{"%":281}],"O":[{"%":282,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":205},{"%":282}],"O":[{"%":283,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":283},{"%":204}],"O":[{"%":284,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":284}],"O":[{"%":285,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":203},{"%":285}],"O":[{"%":286,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":286},{"%":202}],"O":[{"%":287,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":287},{"%":195}],"O":[{"%":288,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":289,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":194},{"%":289}],"O":[{"%":290,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":288},{"%":290}],"O":[{"%":291,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":199},{"%":291}],"O":[{"%":292,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":292},{"%":198}],"O":[{"%":293,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":293}],"O":[{"%":294,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":197},{"%":294}],"O":[{"%":295,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":295},{"%":196}],"O":[{"%":296,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":64},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":296},{"%":189}],"O":[{"%":297,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":298,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":188},{"%":298}],"O":[{"%":299,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":297},{"%":299}],"O":[{"%":300,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":193},{"%":300}],"O":[{"%":301,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":301},{"%":192}],"O":[{"%":302,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":302}],"O":[{"%":303,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":191},{"%":303}],"O":[{"%":304,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":304},{"%":190}],"O":[{"%":305,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":305},{"%":183}],"O":[{"%":306,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":307,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":182},{"%":307}],"O":[{"%":308,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":306},{"%":308}],"O":[{"%":309,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":187},{"%":309}],"O":[{"%":310,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":310},{"%":186}],"O":[{"%":311,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":311}],"O":[{"%":312,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":185},{"%":312}],"O":[{"%":313,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":313},{"%":184}],"O":[{"%":314,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":128},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":314},{"%":177}],"O":[{"%":315,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":316,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":176},{"%":316}],"O":[{"%":317,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":315},{"%":317}],"O":[{"%":318,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":181},{"%":318}],"O":[{"%":319,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":319},{"%":180}],"O":[{"%":320,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":320}],"O":[{"%":321,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":179},{"%":321}],"O":[{"%":322,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":322},{"%":178}],"O":[{"%":323,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":323},{"%":171}],"O":[{"%":324,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":325,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":170},{"%":325}],"O":[{"%":326,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":324},{"%":326}],"O":[{"%":327,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":175},{"%":327}],"O":[{"%":328,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":328},{"%":174}],"O":[{"%":329,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":329}],"O":[{"%":330,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":173},{"%":330}],"O":[{"%":331,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":331},{"%":172}],"O":[{"%":332,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":128},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":332},{"%":165}],"O":[{"%":333,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":334,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":164},{"%":334}],"O":[{"%":335,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":333},{"%":335}],"O":[{"%":336,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":169},{"%":336}],"O":[{"%":337,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":337},{"%":168}],"O":[{"%":338,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":338}],"O":[{"%":339,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":167},{"%":339}],"O":[{"%":340,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":340},{"%":166}],"O":[{"%":341,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":341},{"%":159}],"O":[{"%":342,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":343,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":158},{"%":343}],"O":[{"%":344,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":342},{"%":344}],"O":[{"%":345,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":163},{"%":345}],"O":[{"%":346,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":346},{"%":162}],"O":[{"%":347,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":347}],"O":[{"%":348,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":161},{"%":348}],"O":[{"%":349,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":349},{"%":160}],"O":[{"%":350,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":350},{"%":153}],"O":[{"%":351,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":352,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":152},{"%":352}],"O":[{"%":353,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":351},{"%":353}],"O":[{"%":354,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":157},{"%":354}],"O":[{"%":355,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":355},{"%":156}],"O":[{"%":356,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":356}],"O":[{"%":357,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":155},{"%":357}],"O":[{"%":358,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":358},{"%":154}],"O":[{"%":359,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":359},{"%":147}],"O":[{"%":360,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":361,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":146},{"%":361}],"O":[{"%":362,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":360},{"%":362}],"O":[{"%":363,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":151},{"%":363}],"O":[{"%":364,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":364},{"%":150}],"O":[{"%":365,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":365}],"O":[{"%":366,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":149},{"%":366}],"O":[{"%":367,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":367},{"%":148}],"O":[{"%":368,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":368},{"%":141}],"O":[{"%":369,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":370,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":140},{"%":370}],"O":[{"%":371,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":369},{"%":371}],"O":[{"%":372,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":145},{"%":372}],"O":[{"%":373,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":373},{"%":144}],"O":[{"%":374,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":374}],"O":[{"%":375,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":143},{"%":375}],"O":[{"%":376,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":376},{"%":142}],"O":[{"%":377,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":377},{"%":135}],"O":[{"%":378,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":379,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":134},{"%":379}],"O":[{"%":380,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":378},{"%":380}],"O":[{"%":381,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":139},{"%":381}],"O":[{"%":382,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":382},{"%":138}],"O":[{"%":383,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":383}],"O":[{"%":384,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":137},{"%":384}],"O":[{"%":385,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":385},{"%":136}],"O":[{"%":386,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":386},{"%":129}],"O":[{"%":387,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":388,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":128},{"%":388}],"O":[{"%":389,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":387},{"%":389}],"O":[{"%":390,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":133},{"%":390}],"O":[{"%":391,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":391},{"%":132}],"O":[{"%":392,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":392}],"O":[{"%":393,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":131},{"%":393}],"O":[{"%":394,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":394},{"%":130}],"O":[{"%":395,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":395},{"%":123}],"O":[{"%":396,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":397,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":122},{"%":397}],"O":[{"%":398,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":396},{"%":398}],"O":[{"%":399,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":127},{"%":399}],"O":[{"%":400,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":400},{"%":126}],"O":[{"%":401,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":401}],"O":[{"%":402,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":125},{"%":402}],"O":[{"%":403,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":403},{"%":124}],"O":[{"%":404,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":404},{"%":117}],"O":[{"%":405,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":406,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":116},{"%":406}],"O":[{"%":407,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":405},{"%":407}],"O":[{"%":408,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":121},{"%":408}],"O":[{"%":409,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":409},{"%":120}],"O":[{"%":410,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":410}],"O":[{"%":411,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":119},{"%":411}],"O":[{"%":412,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":412},{"%":118}],"O":[{"%":413,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":413},{"%":111}],"O":[{"%":414,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":415,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":110},{"%":415}],"O":[{"%":416,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":414},{"%":416}],"O":[{"%":417,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":115},{"%":417}],"O":[{"%":418,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":418},{"%":114}],"O":[{"%":419,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":419}],"O":[{"%":420,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":113},{"%":420}],"O":[{"%":421,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":421},{"%":112}],"O":[{"%":422,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":422},{"%":105}],"O":[{"%":423,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":424,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":104},{"%":424}],"O":[{"%":425,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":423},{"%":425}],"O":[{"%":426,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":109},{"%":426}],"O":[{"%":427,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":427},{"%":108}],"O":[{"%":428,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":428}],"O":[{"%":429,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":107},{"%":429}],"O":[{"%":430,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":430},{"%":106}],"O":[{"%":431,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":432,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":431},{"%":432}],"O":[{"%":433,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":433},{"%":103}],"O":[{"%":434,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":435,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":102},{"%":435}],"O":[{"%":436,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":434},{"%":436}],"O":[{"%":437,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/ReLU/"},"N":"struct_name"}],"I":[{"%":437}],"O":[{"%":438,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":438},{"%":101}],"O":[{"%":439,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":440,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":100},{"%":440}],"O":[{"%":441,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":439},{"%":441}],"O":[{"%":442,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.16666670143604279},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Hardsigmoid/"},"N":"struct_name"}],"I":[{"%":442}],"O":[{"%":443,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/"},"N":"struct_name"}],"I":[{"%":431},{"%":443}],"O":[{"%":444,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":444},{"%":95}],"O":[{"%":445,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":446,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":94},{"%":446}],"O":[{"%":447,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":445},{"%":447}],"O":[{"%":448,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":99},{"%":448}],"O":[{"%":449,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":449},{"%":98}],"O":[{"%":450,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":450}],"O":[{"%":451,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":97},{"%":451}],"O":[{"%":452,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":452},{"%":96}],"O":[{"%":453,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":453},{"%":89}],"O":[{"%":454,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":455,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":88},{"%":455}],"O":[{"%":456,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":454},{"%":456}],"O":[{"%":457,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":93},{"%":457}],"O":[{"%":458,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":458},{"%":92}],"O":[{"%":459,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":459}],"O":[{"%":460,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":91},{"%":460}],"O":[{"%":461,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":461},{"%":90}],"O":[{"%":462,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":463,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":462},{"%":463}],"O":[{"%":464,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":464},{"%":87}],"O":[{"%":465,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":466,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":86},{"%":466}],"O":[{"%":467,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":465},{"%":467}],"O":[{"%":468,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/ReLU/"},"N":"struct_name"}],"I":[{"%":468}],"O":[{"%":469,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":469},{"%":85}],"O":[{"%":470,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":471,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":84},{"%":471}],"O":[{"%":472,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":470},{"%":472}],"O":[{"%":473,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.16666670143604279},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Hardsigmoid/"},"N":"struct_name"}],"I":[{"%":473}],"O":[{"%":474,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/"},"N":"struct_name"}],"I":[{"%":462},{"%":474}],"O":[{"%":475,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":475},{"%":79}],"O":[{"%":476,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":477,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":78},{"%":477}],"O":[{"%":478,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":476},{"%":478}],"O":[{"%":479,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":83},{"%":479}],"O":[{"%":480,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":480},{"%":82}],"O":[{"%":481,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":481}],"O":[{"%":482,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":81},{"%":482}],"O":[{"%":483,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":483},{"%":80}],"O":[{"%":484,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":484},{"%":73}],"O":[{"%":485,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":486,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":72},{"%":486}],"O":[{"%":487,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":485},{"%":487}],"O":[{"%":488,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":77},{"%":488}],"O":[{"%":489,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":489},{"%":76}],"O":[{"%":490,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":490}],"O":[{"%":491,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":75},{"%":491}],"O":[{"%":492,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":492},{"%":74}],"O":[{"%":493,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":493},{"%":67}],"O":[{"%":494,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":495,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":66},{"%":495}],"O":[{"%":496,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":494},{"%":496}],"O":[{"%":497,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":71},{"%":497}],"O":[{"%":498,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":498},{"%":70}],"O":[{"%":499,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":499}],"O":[{"%":500,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":69},{"%":500}],"O":[{"%":501,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":501},{"%":68}],"O":[{"%":502,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":502},{"%":61}],"O":[{"%":503,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":504,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":60},{"%":504}],"O":[{"%":505,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":503},{"%":505}],"O":[{"%":506,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":65},{"%":506}],"O":[{"%":507,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":507},{"%":64}],"O":[{"%":508,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":508}],"O":[{"%":509,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":63},{"%":509}],"O":[{"%":510,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":510},{"%":62}],"O":[{"%":511,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":511},{"%":55}],"O":[{"%":512,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":513,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":54},{"%":513}],"O":[{"%":514,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":512},{"%":514}],"O":[{"%":515,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":59},{"%":515}],"O":[{"%":516,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":516},{"%":58}],"O":[{"%":517,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":517}],"O":[{"%":518,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":57},{"%":518}],"O":[{"%":519,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":519},{"%":56}],"O":[{"%":520,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/"},"N":"struct_name"}],"I":[],"O":[{"%":521,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":false},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/"},"N":"struct_name"}],"I":[{"%":520},{"%":521}],"O":[{"%":522,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.assign","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":522}],"O":[{"%":523,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":523},{"%":53}],"O":[{"%":524,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":524},{"%":50},{"%":49},{"%":52},{"%":51}],"O":[{"%":525,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}},{"%":526,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":527,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":528,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":529,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":530,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/Swish/"},"N":"struct_name"}],"I":[{"%":525}],"O":[{"%":531,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":531},{"%":48}],"O":[{"%":532,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":532},{"%":45},{"%":44},{"%":47},{"%":46}],"O":[{"%":533,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}},{"%":534,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":535,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":536,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":537,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":538,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/Swish/"},"N":"struct_name"}],"I":[{"%":533}],"O":[{"%":539,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.shape64","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":539}],"O":[{"%":540,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":541,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":4}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":542,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":540},{"%":541},{"%":542}],"O":[{"%":543,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.flatten","A":[{"AT":{"#":"0.a_i32","D":2},"N":"start_axis"},{"AT":{"#":"0.a_i32","D":3},"N":"stop_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":539}],"O":[{"%":544,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":544}],"O":[{"%":545,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/LayerNorm/"},"N":"struct_name"}],"I":[{"%":545},{"%":43},{"%":42}],"O":[{"%":546,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":547,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":548,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":546},{"%":41}],"O":[{"%":549,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":549},{"%":40}],"O":[{"%":550,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":8},{"#":"0.a_i64","D":15}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":551,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[5],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":550},{"%":551}],"O":[{"%":552,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,3,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":4}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":552}],"O":[{"%":553,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[3,-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":554,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":555,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":554},{"%":555}],"O":[{"%":556,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.25819888710975647},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":557,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.scale","A":[{"AT":{"#":"0.a_f32","D":0.0},"N":"bias"},{"AT":{"#":"0.a_bool","D":true},"N":"bias_after_scale"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":556},{"%":557}],"O":[{"%":558,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":559,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":560,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":559},{"%":560}],"O":[{"%":561,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":562,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":563,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":562},{"%":563}],"O":[{"%":564,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":561}],"O":[{"%":565,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,15,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":558},{"%":565}],"O":[{"%":566,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":-1},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":566}],"O":[{"%":567,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":568,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout/"},"N":"struct_name"}],"I":[{"%":567},{"%":0},{"%":568}],"O":[{"%":569,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}},{"%":570,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":569},{"%":564}],"O":[{"%":571,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":571}],"O":[{"%":572,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":120}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":573,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[3],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":572},{"%":573}],"O":[{"%":574,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":574},{"%":39}],"O":[{"%":575,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":575},{"%":38}],"O":[{"%":576,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":577,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout_1/"},"N":"struct_name"}],"I":[{"%":576},{"%":0},{"%":577}],"O":[{"%":578,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":579,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/"},"N":"struct_name"}],"I":[{"%":545},{"%":578}],"O":[{"%":580,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/LayerNorm_1/"},"N":"struct_name"}],"I":[{"%":580},{"%":37},{"%":36}],"O":[{"%":581,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":582,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":583,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":581},{"%":35}],"O":[{"%":584,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":584},{"%":34}],"O":[{"%":585,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Swish/"},"N":"struct_name"}],"I":[{"%":585}],"O":[{"%":586,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":587,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout/"},"N":"struct_name"}],"I":[{"%":586},{"%":0},{"%":587}],"O":[{"%":588,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}},{"%":589,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":588},{"%":33}],"O":[{"%":590,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":590},{"%":32}],"O":[{"%":591,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":592,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[{"%":591},{"%":0},{"%":592}],"O":[{"%":593,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":594,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/"},"N":"struct_name"}],"I":[{"%":580},{"%":593}],"O":[{"%":595,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/LayerNorm/"},"N":"struct_name"}],"I":[{"%":595},{"%":31},{"%":30}],"O":[{"%":596,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":597,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":598,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":596},{"%":29}],"O":[{"%":599,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":599},{"%":28}],"O":[{"%":600,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":8},{"#":"0.a_i64","D":15}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":601,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[5],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":600},{"%":601}],"O":[{"%":602,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,3,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":4}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":602}],"O":[{"%":603,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[3,-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":604,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":605,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":604},{"%":605}],"O":[{"%":606,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.25819888710975647},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":607,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.scale","A":[{"AT":{"#":"0.a_f32","D":0.0},"N":"bias"},{"AT":{"#":"0.a_bool","D":true},"N":"bias_after_scale"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":606},{"%":607}],"O":[{"%":608,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":609,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":610,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":609},{"%":610}],"O":[{"%":611,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":612,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":613,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":612},{"%":613}],"O":[{"%":614,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":611}],"O":[{"%":615,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,15,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":608},{"%":615}],"O":[{"%":616,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":-1},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":616}],"O":[{"%":617,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":618,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout/"},"N":"struct_name"}],"I":[{"%":617},{"%":0},{"%":618}],"O":[{"%":619,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}},{"%":620,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":619},{"%":614}],"O":[{"%":621,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":621}],"O":[{"%":622,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":120}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":623,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[3],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":622},{"%":623}],"O":[{"%":624,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":624},{"%":27}],"O":[{"%":625,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":625},{"%":26}],"O":[{"%":626,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":627,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout_1/"},"N":"struct_name"}],"I":[{"%":626},{"%":0},{"%":627}],"O":[{"%":628,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":629,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/"},"N":"struct_name"}],"I":[{"%":595},{"%":628}],"O":[{"%":630,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/LayerNorm_1/"},"N":"struct_name"}],"I":[{"%":630},{"%":25},{"%":24}],"O":[{"%":631,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":632,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":633,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":631},{"%":23}],"O":[{"%":634,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":634},{"%":22}],"O":[{"%":635,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Swish/"},"N":"struct_name"}],"I":[{"%":635}],"O":[{"%":636,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":637,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout/"},"N":"struct_name"}],"I":[{"%":636},{"%":0},{"%":637}],"O":[{"%":638,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}},{"%":639,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":638},{"%":21}],"O":[{"%":640,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":640},{"%":20}],"O":[{"%":641,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":642,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[{"%":641},{"%":0},{"%":642}],"O":[{"%":643,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":644,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/"},"N":"struct_name"}],"I":[{"%":630},{"%":643}],"O":[{"%":645,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999974752427e-07},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/LayerNorm/"},"N":"struct_name"}],"I":[{"%":645},{"%":19},{"%":18}],"O":[{"%":646,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":647,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":648,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":649,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":650,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":120.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":651,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":649},{"%":650},{"%":543},{"%":651}],"O":[{"%":652,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.stack","A":[{"AT":{"#":"0.a_i32","D":0},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":652}],"O":[{"%":653,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":646},{"%":653}],"O":[{"%":654,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":654}],"O":[{"%":655,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/Conv2D/"},"N":"struct_name"}],"I":[{"%":655},{"%":17}],"O":[{"%":656,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":656},{"%":14},{"%":13},{"%":16},{"%":15}],"O":[{"%":657,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}},{"%":658,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":659,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":660,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":661,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":662,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/Swish/"},"N":"struct_name"}],"I":[{"%":657}],"O":[{"%":663,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":664,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":523},{"%":663}],"O":[{"%":665,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":665},{"%":664}],"O":[{"%":666,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,960,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/Conv2D/"},"N":"struct_name"}],"I":[{"%":666},{"%":12}],"O":[{"%":667,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":667},{"%":9},{"%":8},{"%":11},{"%":10}],"O":[{"%":668,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}},{"%":669,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":670,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":671,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":672,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":673,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/Swish/"},"N":"struct_name"}],"I":[{"%":668}],"O":[{"%":674,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/Conv2D/"},"N":"struct_name"}],"I":[{"%":674},{"%":7}],"O":[{"%":675,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":675},{"%":4},{"%":3},{"%":6},{"%":5}],"O":[{"%":676,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}},{"%":677,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":678,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":679,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":680,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":681,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/Swish/"},"N":"struct_name"}],"I":[{"%":676}],"O":[{"%":682,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[],"O":[{"%":683,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.squeeze","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[{"%":682},{"%":683}],"O":[{"%":684,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[{"%":684}],"O":[{"%":685,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/Linear/"},"N":"struct_name"}],"I":[{"%":685},{"%":2}],"O":[{"%":686,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,570],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/Linear/"},"N":"struct_name"}],"I":[{"%":686},{"%":1}],"O":[{"%":687,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,570],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":2},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/"},"N":"struct_name"}],"I":[{"%":687}],"O":[{"%":688,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,570],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.fetch","A":[{"AT":{"#":"0.a_str","D":"fetch_name_0"},"N":"name"},{"AT":{"#":"0.a_i32","D":0},"N":"col"}],"I":[{"%":688}],"O":[{"%":689,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,570],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"persistable"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]}]}]}]}} \ No newline at end of file diff --git a/k2-ampixa-demo-ocr/models/space/models/devanagari-ppocrv5/artifacts/inference.pdiparams b/k2-ampixa-demo-ocr/models/space/models/devanagari-ppocrv5/artifacts/inference.pdiparams new file mode 100644 index 0000000000000000000000000000000000000000..82b9b1cce0712695ca2caef0fe64b27fdd6616db --- /dev/null +++ b/k2-ampixa-demo-ocr/models/space/models/devanagari-ppocrv5/artifacts/inference.pdiparams @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:719be7d20bfe9530e2deae324c999e9911087496bce5e70846767c448d023a01 +size 7836203 diff --git a/k2-ampixa-demo-ocr/models/space/models/devanagari-ppocrv5/artifacts/inference.yml b/k2-ampixa-demo-ocr/models/space/models/devanagari-ppocrv5/artifacts/inference.yml new file mode 100644 index 0000000000000000000000000000000000000000..777c30094e8c858d2aee6182fd3b9aa975da1b52 --- /dev/null +++ b/k2-ampixa-demo-ocr/models/space/models/devanagari-ppocrv5/artifacts/inference.yml @@ -0,0 +1,611 @@ +Global: + model_name: devanagari_PP-OCRv5_mobile_rec +Hpi: + backend_configs: + paddle_infer: + trt_dynamic_shapes: &id001 + x: + - - 1 + - 3 + - 48 + - 160 + - - 1 + - 3 + - 48 + - 320 + - - 8 + - 3 + - 48 + - 3200 + tensorrt: + dynamic_shapes: *id001 +PreProcess: + transform_ops: + - DecodeImage: + channel_first: false + img_mode: BGR + - MultiLabelEncode: + gtc_encode: NRTRLabelEncode + - RecResizeImg: + image_shape: + - 3 + - 48 + - 320 + - KeepKeys: + keep_keys: + - image + - label_ctc + - label_gtc + - length + - valid_ratio +PostProcess: + name: CTCLabelDecode + character_dict: + - '!' + - '"' + - '#' + - $ + - '%' + - '&' + - '''' + - ( + - ) + - '*' + - + + - ',' + - '-' + - . + - / + - '0' + - '1' + - '2' + - '3' + - '4' + - '5' + - '6' + - '7' + - '8' + - '9' + - ':' + - ; + - < + - '=' + - '>' + - '?' + - A + - B + - C + - D + - E + - F + - G + - H + - I + - J + - K + - L + - M + - N + - O + - P + - Q + - R + - S + - T + - U + - V + - W + - X + - Y + - Z + - '[' + - ']' + - _ + - '`' + - a + - b + - c + - d + - e + - f + - g + - h + - i + - j + - k + - l + - m + - n + - o + - p + - q + - r + - s + - t + - u + - v + - w + - x + - y + - z + - © + - ‥ + - '{' + - '}' + - \ + - '|' + - '@' + - ^ + - '~' + - ÷ + - ∕ + - ∙ + - ⋅ + - · + - ± + - ∓ + - ∩ + - ∪ + - □ + - ← + - ↔ + - ⇒ + - ⇐ + - ⇔ + - ∀ + - ∃ + - ∄ + - ∴ + - ∵ + - ∝ + - ∞ + - ⊥ + - ∟ + - ∠ + - ∡ + - ∢ + - ′ + - ″ + - ∥ + - ⊾ + - ⊿ + - ∂ + - ∫ + - ∬ + - ∭ + - ∮ + - ∯ + - ∰ + - ∑ + - ∏ + - √ + - ∛ + - ∜ + - ∱ + - ∲ + - ∳ + - ∶ + - ∷ + - ∼ + - ® + - ℉ + - Ω + - ℧ + - Å + - ⌀ + - ℏ + - ⅀ + - ⍺ + - ⍵ + - ¢ + - € + - £ + - ¥ + - ₿ + - Ⅰ + - Ⅱ + - Ⅲ + - Ⅳ + - Ⅴ + - Ⅵ + - Ⅶ + - Ⅷ + - Ⅸ + - Ⅹ + - Ⅺ + - Ⅻ + - ⅰ + - ⅱ + - ⅲ + - ⅳ + - ⅴ + - ⅵ + - ⅶ + - ⅷ + - ⅸ + - ⅹ + - ⅺ + - ⅻ + - ➀ + - ➁ + - ➂ + - ➃ + - ➄ + - ➅ + - ➆ + - ➇ + - ➈ + - ➉ + - ➊ + - ➋ + - ➌ + - ➍ + - ➎ + - ➏ + - ➐ + - ➑ + - ➒ + - ➓ + - ❶ + - ❷ + - ❸ + - ❹ + - ❺ + - ❻ + - ❼ + - ❽ + - ❾ + - ❿ + - ① + - ② + - ③ + - ④ + - ⑤ + - ⑥ + - ⑦ + - ⑧ + - ⑨ + - ⑩ + - ● + - ▶ + - 𝑢 + - ︽ + - – + - ﹥ + - 𝜓 + - • + - ∋ + - ƒ + - ⬆ + - Ạ + - ◀ + -  + - ▫ + - ︾ + - À + - Á + - Â + - Ã + - Ä + - Å + - Æ + - Ç + - È + - É + - Ê + - Ë + - Ì + - Í + - Î + - Ï + - Ð + - Ñ + - Ò + - Ó + - Ô + - Õ + - Ö + - Ø + - Ù + - Ú + - Û + - Ü + - Ý + - Þ + - à + - á + - â + - ã + - ä + - å + - æ + - ç + - è + - é + - ê + - ë + - ì + - í + - î + - ï + - ð + - ñ + - ò + - ó + - ô + - õ + - ö + - ø + - ù + - ú + - û + - ü + - ý + - þ + - ÿ + - ¡ + - ¤ + - ¦ + - § + - ¨ + - ª + - « + - ¬ + - ¯ + - ° + - ² + - ³ + - ´ + - µ + - ¶ + - ¸ + - ¹ + - º + - » + - ¼ + - ½ + - ¾ + - ¿ + - × + - ‐ + - ‑ + - ‒ + - — + - ― + - ‖ + - ‗ + - ‘ + - ’ + - ‚ + - ‛ + - “ + - ” + - „ + - ‟ + - † + - ‡ + - ‣ + - ․ + - … + - ‧ + - ‰ + - ‴ + - ‵ + - ‶ + - ‷ + - ‸ + - ‹ + - › + - ※ + - ‼ + - ‽ + - ‾ + - ₤ + - ₡ + - ₹ + - − + - ∖ + - ∗ + - ≈ + - ≠ + - ≡ + - ≤ + - ≥ + - ⊂ + - ⊃ + - ↑ + - → + - ↓ + - ↕ + - ™ + - Ω + - ℮ + - ∆ + - ✓ + - ✗ + - ✘ + - ▪ + - ◼ + - ✔ + - ✕ + - ☑ + - ☒ + - № + - ₽ + - ₴ + - Α + - α + - Β + - β + - Γ + - γ + - Δ + - δ + - Ε + - ε + - Ζ + - ζ + - Η + - η + - Θ + - θ + - Ι + - ι + - Κ + - κ + - Λ + - λ + - Μ + - μ + - Ν + - ν + - Ξ + - ξ + - Ο + - ο + - Π + - π + - Ρ + - ρ + - Σ + - σ + - ς + - Τ + - τ + - Υ + - υ + - Φ + - φ + - Χ + - χ + - Ψ + - ψ + - ω + - ऀ + - ँ + - ं + - ः + - ऄ + - अ + - आ + - इ + - ई + - उ + - ऊ + - ऋ + - ऌ + - ऍ + - ऎ + - ए + - ऐ + - ऑ + - ऒ + - ओ + - औ + - क + - ख + - ग + - घ + - ङ + - च + - छ + - ज + - झ + - ञ + - ट + - ठ + - ड + - ढ + - ण + - त + - थ + - द + - ध + - न + - ऩ + - प + - फ + - ब + - भ + - म + - य + - र + - ऱ + - ल + - ळ + - ऴ + - व + - श + - ष + - स + - ह + - ऺ + - ऻ + - ़ + - ऽ + - ा + - ि + - ी + - ु + - ू + - ृ + - ॄ + - ॅ + - ॆ + - े + - ै + - ॉ + - ॊ + - ो + - ौ + - ् + - ॎ + - ॏ + - ॐ + - ॑ + - ॒ + - ॓ + - ॔ + - ॕ + - ॖ + - ॗ + - क़ + - ख़ + - ग़ + - ज़ + - ड़ + - ढ़ + - फ़ + - य़ + - ॠ + - ॡ + - ॢ + - ॣ + - । + - ॥ + - ० + - १ + - २ + - ३ + - ४ + - ५ + - ६ + - ७ + - ८ + - ९ + - ॰ + - ॱ + - ॲ + - ॳ + - ॴ + - ॵ + - ॶ + - ॷ + - ॸ + - ॹ + - ॺ + - ॻ + - ॼ + - ॽ + - ॾ + - ॿ diff --git a/k2-ampixa-demo-ocr/models/space/models/limbu-sirijonga-ft-v2/artifacts/inference.json b/k2-ampixa-demo-ocr/models/space/models/limbu-sirijonga-ft-v2/artifacts/inference.json new file mode 100644 index 0000000000000000000000000000000000000000..06777274c009438976027117311fef02e7a1c612 --- /dev/null +++ b/k2-ampixa-demo-ocr/models/space/models/limbu-sirijonga-ft-v2/artifacts/inference.json @@ -0,0 +1 @@ +{"base_code":{"magic":"pir","trainable":true,"version":4},"program":{"regions":[{"#":"region_0","blocks":[{"#":"block_0","args":[],"ops":[{"#":"p","A":[0,1,1,"linear_8.b_0"],"DA":[],"O":{"%":1,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[93],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_8.w_0"],"DA":[],"O":{"%":2,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,93],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_2"],"DA":[],"O":{"%":3,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_1"],"DA":[],"O":{"%":4,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.b_0"],"DA":[],"O":{"%":5,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_150.w_0"],"DA":[],"O":{"%":6,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_135.w_0"],"DA":[],"O":{"%":7,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_2"],"DA":[],"O":{"%":8,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_1"],"DA":[],"O":{"%":9,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.b_0"],"DA":[],"O":{"%":10,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_149.w_0"],"DA":[],"O":{"%":11,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_134.w_0"],"DA":[],"O":{"%":12,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,960,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_2"],"DA":[],"O":{"%":13,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_1"],"DA":[],"O":{"%":14,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.b_0"],"DA":[],"O":{"%":15,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_148.w_0"],"DA":[],"O":{"%":16,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_133.w_0"],"DA":[],"O":{"%":17,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,120,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_4.b_0"],"DA":[],"O":{"%":18,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_4.w_0"],"DA":[],"O":{"%":19,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_7.b_0"],"DA":[],"O":{"%":20,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_7.w_0"],"DA":[],"O":{"%":21,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_6.b_0"],"DA":[],"O":{"%":22,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_6.w_0"],"DA":[],"O":{"%":23,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_3.b_0"],"DA":[],"O":{"%":24,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_3.w_0"],"DA":[],"O":{"%":25,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_5.b_0"],"DA":[],"O":{"%":26,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_5.w_0"],"DA":[],"O":{"%":27,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_4.b_0"],"DA":[],"O":{"%":28,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_4.w_0"],"DA":[],"O":{"%":29,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_2.b_0"],"DA":[],"O":{"%":30,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_2.w_0"],"DA":[],"O":{"%":31,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_3.b_0"],"DA":[],"O":{"%":32,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_3.w_0"],"DA":[],"O":{"%":33,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_2.b_0"],"DA":[],"O":{"%":34,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_2.w_0"],"DA":[],"O":{"%":35,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_1.b_0"],"DA":[],"O":{"%":36,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_1.w_0"],"DA":[],"O":{"%":37,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_1.b_0"],"DA":[],"O":{"%":38,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_1.w_0"],"DA":[],"O":{"%":39,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_0.b_0"],"DA":[],"O":{"%":40,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"linear_0.w_0"],"DA":[],"O":{"%":41,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,360],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_0.b_0"],"DA":[],"O":{"%":42,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"layer_norm_0.w_0"],"DA":[],"O":{"%":43,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_2"],"DA":[],"O":{"%":44,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_1"],"DA":[],"O":{"%":45,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.b_0"],"DA":[],"O":{"%":46,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_147.w_0"],"DA":[],"O":{"%":47,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_132.w_0"],"DA":[],"O":{"%":48,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_2"],"DA":[],"O":{"%":49,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_1"],"DA":[],"O":{"%":50,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.b_0"],"DA":[],"O":{"%":51,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_146.w_0"],"DA":[],"O":{"%":52,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_131.w_0"],"DA":[],"O":{"%":53,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,480,1,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_163.b_0"],"DA":[],"O":{"%":54,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_163.w_0"],"DA":[],"O":{"%":55,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_55.w_1"],"DA":[],"O":{"%":56,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_55.w_0"],"DA":[],"O":{"%":57,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_54.w_1"],"DA":[],"O":{"%":58,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_54.w_0"],"DA":[],"O":{"%":59,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_162.b_0"],"DA":[],"O":{"%":60,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_162.w_0"],"DA":[],"O":{"%":61,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_53.w_1"],"DA":[],"O":{"%":62,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_53.w_0"],"DA":[],"O":{"%":63,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_52.w_1"],"DA":[],"O":{"%":64,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_52.w_0"],"DA":[],"O":{"%":65,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_161.b_0"],"DA":[],"O":{"%":66,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_161.w_0"],"DA":[],"O":{"%":67,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_51.w_1"],"DA":[],"O":{"%":68,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_51.w_0"],"DA":[],"O":{"%":69,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_50.w_1"],"DA":[],"O":{"%":70,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_50.w_0"],"DA":[],"O":{"%":71,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_160.b_0"],"DA":[],"O":{"%":72,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_160.w_0"],"DA":[],"O":{"%":73,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_49.w_1"],"DA":[],"O":{"%":74,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_49.w_0"],"DA":[],"O":{"%":75,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_48.w_1"],"DA":[],"O":{"%":76,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_48.w_0"],"DA":[],"O":{"%":77,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_159.b_0"],"DA":[],"O":{"%":78,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_159.w_0"],"DA":[],"O":{"%":79,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_47.w_1"],"DA":[],"O":{"%":80,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_47.w_0"],"DA":[],"O":{"%":81,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_46.w_1"],"DA":[],"O":{"%":82,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_46.w_0"],"DA":[],"O":{"%":83,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_108.b_0"],"DA":[],"O":{"%":84,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_108.w_0"],"DA":[],"O":{"%":85,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,120,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_107.b_0"],"DA":[],"O":{"%":86,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_107.w_0"],"DA":[],"O":{"%":87,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120,480,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_158.b_0"],"DA":[],"O":{"%":88,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_158.w_0"],"DA":[],"O":{"%":89,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_45.w_1"],"DA":[],"O":{"%":90,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_45.w_0"],"DA":[],"O":{"%":91,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_44.w_1"],"DA":[],"O":{"%":92,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_44.w_0"],"DA":[],"O":{"%":93,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_157.b_0"],"DA":[],"O":{"%":94,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_157.w_0"],"DA":[],"O":{"%":95,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_43.w_1"],"DA":[],"O":{"%":96,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_43.w_0"],"DA":[],"O":{"%":97,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_42.w_1"],"DA":[],"O":{"%":98,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_42.w_0"],"DA":[],"O":{"%":99,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_97.b_0"],"DA":[],"O":{"%":100,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_97.w_0"],"DA":[],"O":{"%":101,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,60,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_96.b_0"],"DA":[],"O":{"%":102,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_96.w_0"],"DA":[],"O":{"%":103,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_156.b_0"],"DA":[],"O":{"%":104,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_156.w_0"],"DA":[],"O":{"%":105,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_41.w_1"],"DA":[],"O":{"%":106,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_41.w_0"],"DA":[],"O":{"%":107,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_40.w_1"],"DA":[],"O":{"%":108,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_40.w_0"],"DA":[],"O":{"%":109,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_155.b_0"],"DA":[],"O":{"%":110,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_155.w_0"],"DA":[],"O":{"%":111,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_39.w_1"],"DA":[],"O":{"%":112,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_39.w_0"],"DA":[],"O":{"%":113,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_38.w_1"],"DA":[],"O":{"%":114,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_38.w_0"],"DA":[],"O":{"%":115,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_154.b_0"],"DA":[],"O":{"%":116,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_154.w_0"],"DA":[],"O":{"%":117,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_37.w_1"],"DA":[],"O":{"%":118,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_37.w_0"],"DA":[],"O":{"%":119,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_36.w_1"],"DA":[],"O":{"%":120,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_36.w_0"],"DA":[],"O":{"%":121,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_153.b_0"],"DA":[],"O":{"%":122,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_153.w_0"],"DA":[],"O":{"%":123,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_35.w_1"],"DA":[],"O":{"%":124,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_35.w_0"],"DA":[],"O":{"%":125,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_34.w_1"],"DA":[],"O":{"%":126,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_34.w_0"],"DA":[],"O":{"%":127,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_152.b_0"],"DA":[],"O":{"%":128,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_152.w_0"],"DA":[],"O":{"%":129,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_33.w_1"],"DA":[],"O":{"%":130,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_33.w_0"],"DA":[],"O":{"%":131,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_32.w_1"],"DA":[],"O":{"%":132,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_32.w_0"],"DA":[],"O":{"%":133,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_151.b_0"],"DA":[],"O":{"%":134,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_151.w_0"],"DA":[],"O":{"%":135,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_31.w_1"],"DA":[],"O":{"%":136,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_31.w_0"],"DA":[],"O":{"%":137,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_30.w_1"],"DA":[],"O":{"%":138,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_30.w_0"],"DA":[],"O":{"%":139,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_150.b_0"],"DA":[],"O":{"%":140,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_150.w_0"],"DA":[],"O":{"%":141,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_29.w_1"],"DA":[],"O":{"%":142,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_29.w_0"],"DA":[],"O":{"%":143,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_28.w_1"],"DA":[],"O":{"%":144,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_28.w_0"],"DA":[],"O":{"%":145,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_149.b_0"],"DA":[],"O":{"%":146,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_149.w_0"],"DA":[],"O":{"%":147,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,240,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_27.w_1"],"DA":[],"O":{"%":148,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_27.w_0"],"DA":[],"O":{"%":149,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_26.w_1"],"DA":[],"O":{"%":150,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_26.w_0"],"DA":[],"O":{"%":151,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_148.b_0"],"DA":[],"O":{"%":152,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_148.w_0"],"DA":[],"O":{"%":153,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,1,5,5],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_25.w_1"],"DA":[],"O":{"%":154,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_25.w_0"],"DA":[],"O":{"%":155,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_24.w_1"],"DA":[],"O":{"%":156,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_24.w_0"],"DA":[],"O":{"%":157,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_147.b_0"],"DA":[],"O":{"%":158,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_147.w_0"],"DA":[],"O":{"%":159,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[240,128,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_23.w_1"],"DA":[],"O":{"%":160,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_23.w_0"],"DA":[],"O":{"%":161,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_22.w_1"],"DA":[],"O":{"%":162,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_22.w_0"],"DA":[],"O":{"%":163,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_146.b_0"],"DA":[],"O":{"%":164,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_146.w_0"],"DA":[],"O":{"%":165,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_21.w_1"],"DA":[],"O":{"%":166,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_21.w_0"],"DA":[],"O":{"%":167,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_20.w_1"],"DA":[],"O":{"%":168,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_20.w_0"],"DA":[],"O":{"%":169,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_145.b_0"],"DA":[],"O":{"%":170,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_145.w_0"],"DA":[],"O":{"%":171,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,128,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_19.w_1"],"DA":[],"O":{"%":172,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_19.w_0"],"DA":[],"O":{"%":173,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_18.w_1"],"DA":[],"O":{"%":174,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_18.w_0"],"DA":[],"O":{"%":175,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_144.b_0"],"DA":[],"O":{"%":176,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_144.w_0"],"DA":[],"O":{"%":177,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_17.w_1"],"DA":[],"O":{"%":178,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_17.w_0"],"DA":[],"O":{"%":179,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_16.w_1"],"DA":[],"O":{"%":180,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_16.w_0"],"DA":[],"O":{"%":181,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_143.b_0"],"DA":[],"O":{"%":182,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_143.w_0"],"DA":[],"O":{"%":183,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[128,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_15.w_1"],"DA":[],"O":{"%":184,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_15.w_0"],"DA":[],"O":{"%":185,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_14.w_1"],"DA":[],"O":{"%":186,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_14.w_0"],"DA":[],"O":{"%":187,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_142.b_0"],"DA":[],"O":{"%":188,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_142.w_0"],"DA":[],"O":{"%":189,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_13.w_1"],"DA":[],"O":{"%":190,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_13.w_0"],"DA":[],"O":{"%":191,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_12.w_1"],"DA":[],"O":{"%":192,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_12.w_0"],"DA":[],"O":{"%":193,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_141.b_0"],"DA":[],"O":{"%":194,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_141.w_0"],"DA":[],"O":{"%":195,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,64,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_11.w_1"],"DA":[],"O":{"%":196,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_11.w_0"],"DA":[],"O":{"%":197,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_10.w_1"],"DA":[],"O":{"%":198,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_10.w_0"],"DA":[],"O":{"%":199,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_140.b_0"],"DA":[],"O":{"%":200,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_140.w_0"],"DA":[],"O":{"%":201,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_9.w_1"],"DA":[],"O":{"%":202,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_9.w_0"],"DA":[],"O":{"%":203,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_8.w_1"],"DA":[],"O":{"%":204,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_8.w_0"],"DA":[],"O":{"%":205,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_139.b_0"],"DA":[],"O":{"%":206,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_139.w_0"],"DA":[],"O":{"%":207,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[64,32,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_7.w_1"],"DA":[],"O":{"%":208,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_7.w_0"],"DA":[],"O":{"%":209,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_6.w_1"],"DA":[],"O":{"%":210,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_6.w_0"],"DA":[],"O":{"%":211,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_138.b_0"],"DA":[],"O":{"%":212,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_138.w_0"],"DA":[],"O":{"%":213,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_5.w_1"],"DA":[],"O":{"%":214,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_5.w_0"],"DA":[],"O":{"%":215,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_4.w_1"],"DA":[],"O":{"%":216,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_4.w_0"],"DA":[],"O":{"%":217,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_137.b_0"],"DA":[],"O":{"%":218,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_137.w_0"],"DA":[],"O":{"%":219,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[32,16,1,1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_3.w_1"],"DA":[],"O":{"%":220,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_3.w_0"],"DA":[],"O":{"%":221,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_2.w_1"],"DA":[],"O":{"%":222,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_2.w_0"],"DA":[],"O":{"%":223,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_136.b_0"],"DA":[],"O":{"%":224,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_136.w_0"],"DA":[],"O":{"%":225,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16,1,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_1.w_1"],"DA":[],"O":{"%":226,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_1.w_0"],"DA":[],"O":{"%":227,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_0.w_1"],"DA":[],"O":{"%":228,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"learnable_affine_block_0.w_0"],"DA":[],"O":{"%":229,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_2"],"DA":[],"O":{"%":230,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_1"],"DA":[],"O":{"%":231,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,1,0],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.b_0"],"DA":[],"O":{"%":232,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"batch_norm2d_0.w_0"],"DA":[],"O":{"%":233,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"p","A":[0,1,1,"conv2d_0.w_0"],"DA":[],"O":{"%":234,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16,3,3,3],"NCHW",[],0]}},"OA":[1,0,1],"QA":[]},{"#":"1.data","A":[{"AT":{"#":"0.a_str","D":"x"},"N":"name"},{"AT":{"#":"1.a_intarray","D":[-1,3,48,-1]},"N":"shape"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[0,0,""]},"N":"place"}],"I":[],"O":[{"%":235,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,3,48,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/ConvBNLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":235},{"%":234}],"O":[{"%":236,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/ConvBNLayer/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":236},{"%":231},{"%":230},{"%":233},{"%":232}],"O":[{"%":237,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}},{"%":238,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":239,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":240,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":241,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[16],"NCHW",[],0]}},{"%":242,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":16},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":237},{"%":225}],"O":[{"%":243,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":244,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":224},{"%":244}],"O":[{"%":245,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,16,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":243},{"%":245}],"O":[{"%":246,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":229},{"%":246}],"O":[{"%":247,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":247},{"%":228}],"O":[{"%":248,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":248}],"O":[{"%":249,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":227},{"%":249}],"O":[{"%":250,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":250},{"%":226}],"O":[{"%":251,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,16,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":251},{"%":219}],"O":[{"%":252,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":253,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":218},{"%":253}],"O":[{"%":254,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":252},{"%":254}],"O":[{"%":255,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":223},{"%":255}],"O":[{"%":256,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":256},{"%":222}],"O":[{"%":257,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":257}],"O":[{"%":258,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":221},{"%":258}],"O":[{"%":259,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":259},{"%":220}],"O":[{"%":260,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":32},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":260},{"%":213}],"O":[{"%":261,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":262,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":212},{"%":262}],"O":[{"%":263,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,32,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":261},{"%":263}],"O":[{"%":264,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":217},{"%":264}],"O":[{"%":265,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":265},{"%":216}],"O":[{"%":266,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":266}],"O":[{"%":267,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":215},{"%":267}],"O":[{"%":268,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":268},{"%":214}],"O":[{"%":269,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,32,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":269},{"%":207}],"O":[{"%":270,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":271,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":206},{"%":271}],"O":[{"%":272,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":270},{"%":272}],"O":[{"%":273,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":211},{"%":273}],"O":[{"%":274,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":274},{"%":210}],"O":[{"%":275,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":275}],"O":[{"%":276,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":209},{"%":276}],"O":[{"%":277,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":277},{"%":208}],"O":[{"%":278,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":64},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":278},{"%":201}],"O":[{"%":279,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":280,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":200},{"%":280}],"O":[{"%":281,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":279},{"%":281}],"O":[{"%":282,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":205},{"%":282}],"O":[{"%":283,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":283},{"%":204}],"O":[{"%":284,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":284}],"O":[{"%":285,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":203},{"%":285}],"O":[{"%":286,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":286},{"%":202}],"O":[{"%":287,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":287},{"%":195}],"O":[{"%":288,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":289,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":194},{"%":289}],"O":[{"%":290,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":288},{"%":290}],"O":[{"%":291,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":199},{"%":291}],"O":[{"%":292,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":292},{"%":198}],"O":[{"%":293,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":293}],"O":[{"%":294,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":197},{"%":294}],"O":[{"%":295,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_1/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":295},{"%":196}],"O":[{"%":296,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,24,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":64},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":296},{"%":189}],"O":[{"%":297,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":298,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":188},{"%":298}],"O":[{"%":299,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,64,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":297},{"%":299}],"O":[{"%":300,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":193},{"%":300}],"O":[{"%":301,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":301},{"%":192}],"O":[{"%":302,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":302}],"O":[{"%":303,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":191},{"%":303}],"O":[{"%":304,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":304},{"%":190}],"O":[{"%":305,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,64,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":305},{"%":183}],"O":[{"%":306,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":307,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":182},{"%":307}],"O":[{"%":308,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":306},{"%":308}],"O":[{"%":309,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":187},{"%":309}],"O":[{"%":310,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":310},{"%":186}],"O":[{"%":311,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":311}],"O":[{"%":312,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":185},{"%":312}],"O":[{"%":313,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":313},{"%":184}],"O":[{"%":314,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":128},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":314},{"%":177}],"O":[{"%":315,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":316,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":176},{"%":316}],"O":[{"%":317,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":315},{"%":317}],"O":[{"%":318,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":181},{"%":318}],"O":[{"%":319,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":319},{"%":180}],"O":[{"%":320,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":320}],"O":[{"%":321,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":179},{"%":321}],"O":[{"%":322,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":322},{"%":178}],"O":[{"%":323,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":323},{"%":171}],"O":[{"%":324,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":325,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":170},{"%":325}],"O":[{"%":326,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":324},{"%":326}],"O":[{"%":327,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":175},{"%":327}],"O":[{"%":328,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":328},{"%":174}],"O":[{"%":329,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":329}],"O":[{"%":330,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":173},{"%":330}],"O":[{"%":331,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_2/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":331},{"%":172}],"O":[{"%":332,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":128},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":332},{"%":165}],"O":[{"%":333,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":334,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":164},{"%":334}],"O":[{"%":335,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,128,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":333},{"%":335}],"O":[{"%":336,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":169},{"%":336}],"O":[{"%":337,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":337},{"%":168}],"O":[{"%":338,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":338}],"O":[{"%":339,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":167},{"%":339}],"O":[{"%":340,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":340},{"%":166}],"O":[{"%":341,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,128,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":341},{"%":159}],"O":[{"%":342,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":343,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":158},{"%":343}],"O":[{"%":344,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":342},{"%":344}],"O":[{"%":345,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":163},{"%":345}],"O":[{"%":346,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":346},{"%":162}],"O":[{"%":347,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":347}],"O":[{"%":348,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":161},{"%":348}],"O":[{"%":349,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":349},{"%":160}],"O":[{"%":350,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":350},{"%":153}],"O":[{"%":351,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":352,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":152},{"%":352}],"O":[{"%":353,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":351},{"%":353}],"O":[{"%":354,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":157},{"%":354}],"O":[{"%":355,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":355},{"%":156}],"O":[{"%":356,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":356}],"O":[{"%":357,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":155},{"%":357}],"O":[{"%":358,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":358},{"%":154}],"O":[{"%":359,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":359},{"%":147}],"O":[{"%":360,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":361,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":146},{"%":361}],"O":[{"%":362,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":360},{"%":362}],"O":[{"%":363,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":151},{"%":363}],"O":[{"%":364,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":364},{"%":150}],"O":[{"%":365,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":365}],"O":[{"%":366,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":149},{"%":366}],"O":[{"%":367,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":367},{"%":148}],"O":[{"%":368,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":368},{"%":141}],"O":[{"%":369,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":370,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":140},{"%":370}],"O":[{"%":371,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":369},{"%":371}],"O":[{"%":372,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":145},{"%":372}],"O":[{"%":373,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":373},{"%":144}],"O":[{"%":374,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":374}],"O":[{"%":375,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":143},{"%":375}],"O":[{"%":376,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":376},{"%":142}],"O":[{"%":377,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":377},{"%":135}],"O":[{"%":378,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":379,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":134},{"%":379}],"O":[{"%":380,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":378},{"%":380}],"O":[{"%":381,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":139},{"%":381}],"O":[{"%":382,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":382},{"%":138}],"O":[{"%":383,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":383}],"O":[{"%":384,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":137},{"%":384}],"O":[{"%":385,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":385},{"%":136}],"O":[{"%":386,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":386},{"%":129}],"O":[{"%":387,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":388,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":128},{"%":388}],"O":[{"%":389,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":387},{"%":389}],"O":[{"%":390,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":133},{"%":390}],"O":[{"%":391,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":391},{"%":132}],"O":[{"%":392,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":392}],"O":[{"%":393,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":131},{"%":393}],"O":[{"%":394,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":394},{"%":130}],"O":[{"%":395,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":395},{"%":123}],"O":[{"%":396,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":397,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":122},{"%":397}],"O":[{"%":398,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":396},{"%":398}],"O":[{"%":399,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":127},{"%":399}],"O":[{"%":400,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":400},{"%":126}],"O":[{"%":401,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":401}],"O":[{"%":402,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":125},{"%":402}],"O":[{"%":403,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":403},{"%":124}],"O":[{"%":404,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":404},{"%":117}],"O":[{"%":405,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":406,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":116},{"%":406}],"O":[{"%":407,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":405},{"%":407}],"O":[{"%":408,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":121},{"%":408}],"O":[{"%":409,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":409},{"%":120}],"O":[{"%":410,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":410}],"O":[{"%":411,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":119},{"%":411}],"O":[{"%":412,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":412},{"%":118}],"O":[{"%":413,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":413},{"%":111}],"O":[{"%":414,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":415,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":110},{"%":415}],"O":[{"%":416,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":414},{"%":416}],"O":[{"%":417,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":115},{"%":417}],"O":[{"%":418,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":418},{"%":114}],"O":[{"%":419,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":419}],"O":[{"%":420,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":113},{"%":420}],"O":[{"%":421,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_3/LCNetV3Block_4/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":421},{"%":112}],"O":[{"%":422,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,12,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":240},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":422},{"%":105}],"O":[{"%":423,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":424,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":104},{"%":424}],"O":[{"%":425,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":423},{"%":425}],"O":[{"%":426,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":109},{"%":426}],"O":[{"%":427,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":427},{"%":108}],"O":[{"%":428,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":428}],"O":[{"%":429,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":107},{"%":429}],"O":[{"%":430,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":430},{"%":106}],"O":[{"%":431,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":432,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":431},{"%":432}],"O":[{"%":433,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":433},{"%":103}],"O":[{"%":434,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":435,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":102},{"%":435}],"O":[{"%":436,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":434},{"%":436}],"O":[{"%":437,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/ReLU/"},"N":"struct_name"}],"I":[{"%":437}],"O":[{"%":438,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":438},{"%":101}],"O":[{"%":439,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":440,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":100},{"%":440}],"O":[{"%":441,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":439},{"%":441}],"O":[{"%":442,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.16666670143604279},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/Hardsigmoid/"},"N":"struct_name"}],"I":[{"%":442}],"O":[{"%":443,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/SELayer/"},"N":"struct_name"}],"I":[{"%":431},{"%":443}],"O":[{"%":444,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,240,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":444},{"%":95}],"O":[{"%":445,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":446,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":94},{"%":446}],"O":[{"%":447,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":445},{"%":447}],"O":[{"%":448,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":99},{"%":448}],"O":[{"%":449,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":449},{"%":98}],"O":[{"%":450,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":450}],"O":[{"%":451,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":97},{"%":451}],"O":[{"%":452,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":452},{"%":96}],"O":[{"%":453,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":453},{"%":89}],"O":[{"%":454,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":455,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":88},{"%":455}],"O":[{"%":456,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":454},{"%":456}],"O":[{"%":457,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":93},{"%":457}],"O":[{"%":458,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":458},{"%":92}],"O":[{"%":459,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":459}],"O":[{"%":460,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":91},{"%":460}],"O":[{"%":461,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":461},{"%":90}],"O":[{"%":462,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[],"O":[{"%":463,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":true},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/AdaptiveAvgPool2D/"},"N":"struct_name"}],"I":[{"%":462},{"%":463}],"O":[{"%":464,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":464},{"%":87}],"O":[{"%":465,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":466,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":86},{"%":466}],"O":[{"%":467,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":465},{"%":467}],"O":[{"%":468,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.relu","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/ReLU/"},"N":"struct_name"}],"I":[{"%":468}],"O":[{"%":469,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":469},{"%":85}],"O":[{"%":470,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[],"O":[{"%":471,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":84},{"%":471}],"O":[{"%":472,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Conv2D_1/"},"N":"struct_name"}],"I":[{"%":470},{"%":472}],"O":[{"%":473,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardsigmoid","A":[{"AT":{"#":"0.a_f32","D":0.16666670143604279},"N":"slope"},{"AT":{"#":"0.a_f32","D":0.5},"N":"offset"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/Hardsigmoid/"},"N":"struct_name"}],"I":[{"%":473}],"O":[{"%":474,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/SELayer/"},"N":"struct_name"}],"I":[{"%":462},{"%":474}],"O":[{"%":475,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":475},{"%":79}],"O":[{"%":476,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":477,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":78},{"%":477}],"O":[{"%":478,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":476},{"%":478}],"O":[{"%":479,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":83},{"%":479}],"O":[{"%":480,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":480},{"%":82}],"O":[{"%":481,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":481}],"O":[{"%":482,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":81},{"%":482}],"O":[{"%":483,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_1/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":483},{"%":80}],"O":[{"%":484,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,6,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":484},{"%":73}],"O":[{"%":485,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":486,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":72},{"%":486}],"O":[{"%":487,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":485},{"%":487}],"O":[{"%":488,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":77},{"%":488}],"O":[{"%":489,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":489},{"%":76}],"O":[{"%":490,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":490}],"O":[{"%":491,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":75},{"%":491}],"O":[{"%":492,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":492},{"%":74}],"O":[{"%":493,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":493},{"%":67}],"O":[{"%":494,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":495,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":66},{"%":495}],"O":[{"%":496,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":494},{"%":496}],"O":[{"%":497,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":71},{"%":497}],"O":[{"%":498,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":498},{"%":70}],"O":[{"%":499,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":499}],"O":[{"%":500,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":69},{"%":500}],"O":[{"%":501,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_2/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":501},{"%":68}],"O":[{"%":502,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.depthwise_conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":2}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_i32","D":480},"N":"groups"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":502},{"%":61}],"O":[{"%":503,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":504,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":60},{"%":504}],"O":[{"%":505,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":503},{"%":505}],"O":[{"%":506,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":65},{"%":506}],"O":[{"%":507,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":507},{"%":64}],"O":[{"%":508,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":508}],"O":[{"%":509,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":63},{"%":509}],"O":[{"%":510,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":510},{"%":62}],"O":[{"%":511,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":511},{"%":55}],"O":[{"%":512,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":1},{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[],"O":[{"%":513,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":54},{"%":513}],"O":[{"%":514,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1,480,1,1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":512},{"%":514}],"O":[{"%":515,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":59},{"%":515}],"O":[{"%":516,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":516},{"%":58}],"O":[{"%":517,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.hardswish","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/Hardswish/"},"N":"struct_name"}],"I":[{"%":517}],"O":[{"%":518,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.multiply","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":57},{"%":518}],"O":[{"%":519,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/PPLCNetV3/Sequential_4/LCNetV3Block_3/LearnableRepLayer_1/Act/LearnableAffineBlock/"},"N":"struct_name"}],"I":[{"%":519},{"%":56}],"O":[{"%":520,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,3,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/"},"N":"struct_name"}],"I":[],"O":[{"%":521,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[2],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.pool2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":2}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_bool","D":false},"N":"ceil_mode"},{"AT":{"#":"0.a_bool","D":true},"N":"exclusive"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"avg"},"N":"pooling_type"},{"AT":{"#":"0.a_bool","D":false},"N":"global_pooling"},{"AT":{"#":"0.a_bool","D":false},"N":"adaptive"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_str","D":"/PPLCNetV3/"},"N":"struct_name"}],"I":[{"%":520},{"%":521}],"O":[{"%":522,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.assign","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":522}],"O":[{"%":523,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/Conv2D/"},"N":"struct_name"}],"I":[{"%":523},{"%":53}],"O":[{"%":524,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":524},{"%":50},{"%":49},{"%":52},{"%":51}],"O":[{"%":525,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}},{"%":526,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":527,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":528,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":529,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":530,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer/Swish/"},"N":"struct_name"}],"I":[{"%":525}],"O":[{"%":531,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/Conv2D/"},"N":"struct_name"}],"I":[{"%":531},{"%":48}],"O":[{"%":532,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":532},{"%":45},{"%":44},{"%":47},{"%":46}],"O":[{"%":533,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}},{"%":534,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":535,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":536,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":537,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":538,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_1/Swish/"},"N":"struct_name"}],"I":[{"%":533}],"O":[{"%":539,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.shape64","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":539}],"O":[{"%":540,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":541,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":4}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":542,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":540},{"%":541},{"%":542}],"O":[{"%":543,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.flatten","A":[{"AT":{"#":"0.a_i32","D":2},"N":"start_axis"},{"AT":{"#":"0.a_i32","D":3},"N":"stop_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":539}],"O":[{"%":544,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":544}],"O":[{"%":545,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/LayerNorm/"},"N":"struct_name"}],"I":[{"%":545},{"%":43},{"%":42}],"O":[{"%":546,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":547,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":548,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":546},{"%":41}],"O":[{"%":549,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":549},{"%":40}],"O":[{"%":550,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":8},{"#":"0.a_i64","D":15}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":551,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[5],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":550},{"%":551}],"O":[{"%":552,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,3,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":4}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":552}],"O":[{"%":553,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[3,-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":554,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":555,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":554},{"%":555}],"O":[{"%":556,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.25819888710975647},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":557,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.scale","A":[{"AT":{"#":"0.a_f32","D":0.0},"N":"bias"},{"AT":{"#":"0.a_bool","D":true},"N":"bias_after_scale"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":556},{"%":557}],"O":[{"%":558,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":559,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":560,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":559},{"%":560}],"O":[{"%":561,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":562,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":563,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":553},{"%":562},{"%":563}],"O":[{"%":564,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":561}],"O":[{"%":565,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,15,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":558},{"%":565}],"O":[{"%":566,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":-1},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":566}],"O":[{"%":567,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":568,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout/"},"N":"struct_name"}],"I":[{"%":567},{"%":0},{"%":568}],"O":[{"%":569,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}},{"%":570,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":569},{"%":564}],"O":[{"%":571,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":571}],"O":[{"%":572,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":120}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":573,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[3],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/"},"N":"struct_name"}],"I":[{"%":572},{"%":573}],"O":[{"%":574,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":574},{"%":39}],"O":[{"%":575,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":575},{"%":38}],"O":[{"%":576,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":577,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Attention/Dropout_1/"},"N":"struct_name"}],"I":[{"%":576},{"%":0},{"%":577}],"O":[{"%":578,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":579,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/"},"N":"struct_name"}],"I":[{"%":545},{"%":578}],"O":[{"%":580,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/LayerNorm_1/"},"N":"struct_name"}],"I":[{"%":580},{"%":37},{"%":36}],"O":[{"%":581,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":582,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":583,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":581},{"%":35}],"O":[{"%":584,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":584},{"%":34}],"O":[{"%":585,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Swish/"},"N":"struct_name"}],"I":[{"%":585}],"O":[{"%":586,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":587,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout/"},"N":"struct_name"}],"I":[{"%":586},{"%":0},{"%":587}],"O":[{"%":588,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}},{"%":589,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":588},{"%":33}],"O":[{"%":590,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":590},{"%":32}],"O":[{"%":591,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":592,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[{"%":591},{"%":0},{"%":592}],"O":[{"%":593,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":594,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block/"},"N":"struct_name"}],"I":[{"%":580},{"%":593}],"O":[{"%":595,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/LayerNorm/"},"N":"struct_name"}],"I":[{"%":595},{"%":31},{"%":30}],"O":[{"%":596,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":597,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":598,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":596},{"%":29}],"O":[{"%":599,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear/"},"N":"struct_name"}],"I":[{"%":599},{"%":28}],"O":[{"%":600,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,360],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":3},{"#":"0.a_i64","D":8},{"#":"0.a_i64","D":15}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":601,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[5],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":600},{"%":601}],"O":[{"%":602,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,3,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":4}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":602}],"O":[{"%":603,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[3,-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":604,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":605,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":604},{"%":605}],"O":[{"%":606,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.25819888710975647},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":607,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.scale","A":[{"AT":{"#":"0.a_f32","D":0.0},"N":"bias"},{"AT":{"#":"0.a_bool","D":true},"N":"bias_after_scale"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":606},{"%":607}],"O":[{"%":608,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":609,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":610,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":609},{"%":610}],"O":[{"%":611,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":612,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":3}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":613,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.slice","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"axes"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":1}]},"N":"infer_flags"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0}]},"N":"decrease_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":603},{"%":612},{"%":613}],"O":[{"%":614,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":611}],"O":[{"%":615,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,15,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":608},{"%":615}],"O":[{"%":616,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":-1},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":616}],"O":[{"%":617,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":618,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout/"},"N":"struct_name"}],"I":[{"%":617},{"%":0},{"%":618}],"O":[{"%":619,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,-1],"NCHW",[],0]}},{"%":620,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,8,-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":619},{"%":614}],"O":[{"%":621,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,8,-1,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":3}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":621}],"O":[{"%":622,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,8,15],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":0},{"#":"0.a_i64","D":-1},{"#":"0.a_i64","D":120}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[],"O":[{"%":623,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[3],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/"},"N":"struct_name"}],"I":[{"%":622},{"%":623}],"O":[{"%":624,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":624},{"%":27}],"O":[{"%":625,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Linear_1/"},"N":"struct_name"}],"I":[{"%":625},{"%":26}],"O":[{"%":626,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":627,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Attention/Dropout_1/"},"N":"struct_name"}],"I":[{"%":626},{"%":0},{"%":627}],"O":[{"%":628,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":629,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/"},"N":"struct_name"}],"I":[{"%":595},{"%":628}],"O":[{"%":630,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/LayerNorm_1/"},"N":"struct_name"}],"I":[{"%":630},{"%":25},{"%":24}],"O":[{"%":631,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":632,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":633,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":631},{"%":23}],"O":[{"%":634,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear/"},"N":"struct_name"}],"I":[{"%":634},{"%":22}],"O":[{"%":635,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Swish/"},"N":"struct_name"}],"I":[{"%":635}],"O":[{"%":636,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout/"},"N":"struct_name"}],"I":[],"O":[{"%":637,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout/"},"N":"struct_name"}],"I":[{"%":636},{"%":0},{"%":637}],"O":[{"%":638,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,240],"NCHW",[],0]}},{"%":639,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,240],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":638},{"%":21}],"O":[{"%":640,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Linear_1/"},"N":"struct_name"}],"I":[{"%":640},{"%":20}],"O":[{"%":641,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.10000000149011612},"N":"value"},{"AT":{"#":"1.a_dtype","D":"float32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[],"O":[{"%":642,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.dropout","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_str","D":"upscale_in_train"},"N":"mode"},{"AT":{"#":"0.a_i32","D":0},"N":"seed"},{"AT":{"#":"0.a_bool","D":false},"N":"fix_seed"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/Mlp/Dropout_1/"},"N":"struct_name"}],"I":[{"%":641},{"%":0},{"%":642}],"O":[{"%":643,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":644,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/Block_1/"},"N":"struct_name"}],"I":[{"%":630},{"%":643}],"O":[{"%":645,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.layer_norm","A":[{"AT":{"#":"0.a_f32","D":9.999999974752427e-07},"N":"epsilon"},{"AT":{"#":"0.a_i32","D":2},"N":"begin_norm_axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/LayerNorm/"},"N":"struct_name"}],"I":[{"%":645},{"%":19},{"%":18}],"O":[{"%":646,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}},{"%":647,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}},{"%":648,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":0.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":649,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":650,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[]},"N":"shape"},{"AT":{"#":"0.a_f64","D":120.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":651,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":649},{"%":650},{"%":543},{"%":651}],"O":[{"%":652,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.stack","A":[{"AT":{"#":"0.a_i32","D":0},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":652}],"O":[{"%":653,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[4],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.reshape","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":646},{"%":653}],"O":[{"%":654,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":3},{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":2}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":654}],"O":[{"%":655,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/Conv2D/"},"N":"struct_name"}],"I":[{"%":655},{"%":17}],"O":[{"%":656,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":656},{"%":14},{"%":13},{"%":16},{"%":15}],"O":[{"%":657,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}},{"%":658,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":659,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":660,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":661,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[480],"NCHW",[],0]}},{"%":662,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_2/Swish/"},"N":"struct_name"}],"I":[{"%":657}],"O":[{"%":663,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full","A":[{"AT":{"#":"1.a_intarray","D":[1]},"N":"shape"},{"AT":{"#":"0.a_f64","D":1.0},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int32"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[],"O":[{"%":664,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i32"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"0.combine","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":523},{"%":663}],"O":[{"%":665,"TT":{"#":"0.t_vec","D":[{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]},{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,480,1,-1],"NCHW",[],0]}]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.concat","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/"},"N":"struct_name"}],"I":[{"%":665},{"%":664}],"O":[{"%":666,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,960,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":1}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/Conv2D/"},"N":"struct_name"}],"I":[{"%":666},{"%":12}],"O":[{"%":667,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":667},{"%":9},{"%":8},{"%":11},{"%":10}],"O":[{"%":668,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}},{"%":669,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":670,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":671,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":672,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[60],"NCHW",[],0]}},{"%":673,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_3/Swish/"},"N":"struct_name"}],"I":[{"%":668}],"O":[{"%":674,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,60,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.conv2d","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"strides"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":0}]},"N":"paddings"},{"AT":{"#":"0.a_str","D":"EXPLICIT"},"N":"padding_algorithm"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":1},{"#":"0.a_i32","D":1}]},"N":"dilations"},{"AT":{"#":"0.a_i32","D":1},"N":"groups"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/Conv2D/"},"N":"struct_name"}],"I":[{"%":674},{"%":7}],"O":[{"%":675,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.batch_norm_","A":[{"AT":{"#":"0.a_bool","D":true},"N":"is_test"},{"AT":{"#":"0.a_f32","D":0.8999999761581421},"N":"momentum"},{"AT":{"#":"0.a_f32","D":9.999999747378752e-06},"N":"epsilon"},{"AT":{"#":"0.a_str","D":"NCHW"},"N":"data_format"},{"AT":{"#":"0.a_bool","D":true},"N":"use_global_stats"},{"AT":{"#":"0.a_bool","D":false},"N":"trainable_statistics"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/BatchNorm2D/"},"N":"struct_name"}],"I":[{"%":675},{"%":4},{"%":3},{"%":6},{"%":5}],"O":[{"%":676,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}},{"%":677,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":678,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":679,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":680,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[120],"NCHW",[],0]}},{"%":681,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_ui8"},[-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false},{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.swish","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/EncoderWithSVTR/ConvBNLayer_4/Swish/"},"N":"struct_name"}],"I":[{"%":676}],"O":[{"%":682,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,1,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.full_int_array","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i64","D":2}]},"N":"value"},{"AT":{"#":"1.a_dtype","D":"int64"},"N":"dtype"},{"AT":{"#":"1.a_place","D":[1,0,""]},"N":"place"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[],"O":[{"%":683,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_i64"},[1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"stop_gradient"}]},{"#":"1.squeeze","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[{"%":682},{"%":683}],"O":[{"%":684,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,120,-1],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.transpose","A":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_i32","D":0},{"#":"0.a_i32","D":2},{"#":"0.a_i32","D":1}]},"N":"perm"},{"AT":{"#":"0.a_str","D":"/MultiHead/SequenceEncoder/Im2Seq/"},"N":"struct_name"}],"I":[{"%":684}],"O":[{"%":685,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,120],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.matmul","A":[{"AT":{"#":"0.a_bool","D":false},"N":"transpose_x"},{"AT":{"#":"0.a_bool","D":false},"N":"transpose_y"},{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/Linear/"},"N":"struct_name"}],"I":[{"%":685},{"%":2}],"O":[{"%":686,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,93],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.add","A":[{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/Linear/"},"N":"struct_name"}],"I":[{"%":686},{"%":1}],"O":[{"%":687,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,93],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.softmax","A":[{"AT":{"#":"0.a_i32","D":2},"N":"axis"},{"AT":{"#":"0.a_str","D":"/MultiHead/CTCHead/"},"N":"struct_name"}],"I":[{"%":687}],"O":[{"%":688,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,93],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]},{"#":"1.fetch","A":[{"AT":{"#":"0.a_str","D":"fetch_name_0"},"N":"name"},{"AT":{"#":"0.a_i32","D":0},"N":"col"}],"I":[{"%":688}],"O":[{"%":689,"TT":{"#":"0.t_dtensor","D":[{"#":"0.t_f32"},[-1,-1,93],"NCHW",[],0]}}],"OA":[{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":true}]},"N":"persistable"},{"AT":{"#":"0.a_array","D":[{"#":"0.a_bool","D":false}]},"N":"stop_gradient"}]}]}]}]}} \ No newline at end of file diff --git a/k2-ampixa-demo-ocr/models/space/models/limbu-sirijonga-ft-v2/artifacts/inference.pdiparams b/k2-ampixa-demo-ocr/models/space/models/limbu-sirijonga-ft-v2/artifacts/inference.pdiparams new file mode 100644 index 0000000000000000000000000000000000000000..fb0d21ff9f938f1b251e4a16f16ae9abebf717ca --- /dev/null +++ b/k2-ampixa-demo-ocr/models/space/models/limbu-sirijonga-ft-v2/artifacts/inference.pdiparams @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:97ae5d8121ea4a05de8ac0c98460df9bb66f2965d507da83ed9de5324baf3971 +size 7605333 diff --git a/k2-ampixa-demo-ocr/models/space/models/limbu-sirijonga-ft-v2/artifacts/inference.yml b/k2-ampixa-demo-ocr/models/space/models/limbu-sirijonga-ft-v2/artifacts/inference.yml new file mode 100644 index 0000000000000000000000000000000000000000..29bde88c28d738efb701127504047d368f9390a9 --- /dev/null +++ b/k2-ampixa-demo-ocr/models/space/models/limbu-sirijonga-ft-v2/artifacts/inference.yml @@ -0,0 +1,134 @@ +Global: + model_name: PP-OCRv5_mobile_rec +Hpi: + backend_configs: + paddle_infer: + trt_dynamic_shapes: &id001 + x: + - - 1 + - 3 + - 48 + - 160 + - - 1 + - 3 + - 48 + - 320 + - - 8 + - 3 + - 48 + - 3200 + tensorrt: + dynamic_shapes: *id001 +PreProcess: + transform_ops: + - DecodeImage: + channel_first: false + img_mode: BGR + - MultiLabelEncode: + gtc_encode: NRTRLabelEncode + - RecResizeImg: + image_shape: + - 3 + - 48 + - 320 + - KeepKeys: + keep_keys: + - image + - label_ctc + - label_gtc + - length + - valid_ratio +PostProcess: + name: CTCLabelDecode + character_dict: + - '!' + - '"' + - '''' + - ( + - ) + - '*' + - + + - ',' + - '-' + - . + - / + - ':' + - '=' + - '?' + - S + - X + - '[' + - ']' + - a + - c + - i + - s + - t + - '|' + - । + - ॥ + - ᤀ + - ᤁ + - ᤂ + - ᤃ + - ᤄ + - ᤅ + - ᤆ + - ᤇ + - ᤈ + - ᤋ + - ᤌ + - ᤍ + - ᤎ + - ᤏ + - ᤐ + - ᤑ + - ᤒ + - ᤓ + - ᤔ + - ᤕ + - ᤖ + - ᤗ + - ᤘ + - ᤙ + - ᤛ + - ᤜ + - ᤠ + - ᤡ + - ᤢ + - ᤣ + - ᤤ + - ᤥ + - ᤦ + - ᤧ + - ᤨ + - ᤩ + - ᤪ + - ᤫ + - ᤰ + - ᤱ + - ᤳ + - ᤴ + - ᤵ + - ᤶ + - ᤷ + - ᤸ + - ᤹ + - ᤺ + - ᤻ + - ᥄ + - ᥅ + - ᥆ + - ᥇ + - ᥈ + - ᥉ + - ᥊ + - ᥋ + - ᥌ + - ᥍ + - ᥎ + - ᥏ + - ‌ + - ‘ + - ’ + - … diff --git a/k2-ampixa-demo-ocr/models/space/models/limbu-sirijonga-ft-v2/artifacts/limbu-sirijonga-v2.txt b/k2-ampixa-demo-ocr/models/space/models/limbu-sirijonga-ft-v2/artifacts/limbu-sirijonga-v2.txt new file mode 100644 index 0000000000000000000000000000000000000000..69666ffcb38b800d8f317973e8bd2ee8552a38b3 --- /dev/null +++ b/k2-ampixa-demo-ocr/models/space/models/limbu-sirijonga-ft-v2/artifacts/limbu-sirijonga-v2.txt @@ -0,0 +1,91 @@ +! +" +' +( +) +* ++ +, +- +. +/ +: += +? +S +X +[ +] +a +c +i +s +t +| +। +॥ +ᤀ +ᤁ +ᤂ +ᤃ +ᤄ +ᤅ +ᤆ +ᤇ +ᤈ +ᤋ +ᤌ +ᤍ +ᤎ +ᤏ +ᤐ +ᤑ +ᤒ +ᤓ +ᤔ +ᤕ +ᤖ +ᤗ +ᤘ +ᤙ +ᤛ +ᤜ +ᤠ +ᤡ +ᤢ +ᤣ +ᤤ +ᤥ +ᤦ +ᤧ +ᤨ +ᤩ +ᤪ +ᤫ +ᤰ +ᤱ +ᤳ +ᤴ +ᤵ +ᤶ +ᤷ +ᤸ +᤹ +᤺ +᤻ +᥄ +᥅ +᥆ +᥇ +᥈ +᥉ +᥊ +᥋ +᥌ +᥍ +᥎ +᥏ +‌ +‘ +’ +… diff --git a/k2-ampixa-demo-ocr/models/space/models/limbu-sirijonga-ft-v2/model-card.json b/k2-ampixa-demo-ocr/models/space/models/limbu-sirijonga-ft-v2/model-card.json new file mode 100644 index 0000000000000000000000000000000000000000..edf505b657703a9724dc095a4b8c81f5e571f501 --- /dev/null +++ b/k2-ampixa-demo-ocr/models/space/models/limbu-sirijonga-ft-v2/model-card.json @@ -0,0 +1,45 @@ +{ + "model_id": "limbu-sirijonga-ft-v2-best", + "backend": "paddleocr", + "base_model": "PP-OCRv5_mobile_rec_pretrained (generic; champion training checkpoint lost 2026-07-04)", + "created_at_utc": "2026-07-06T07:19:31.363403+00:00", + "artifacts": [ + { + "path": "artifacts/inference.json", + "required": true, + "sha256": "0b5ca684a4e1acc77bad0af537670800f21923e69ea1a79cfb899f25dd54f0eb", + "kind": "file", + "size_bytes": 217706 + }, + { + "path": "artifacts/inference.pdiparams", + "required": true, + "sha256": "97ae5d8121ea4a05de8ac0c98460df9bb66f2965d507da83ed9de5324baf3971", + "kind": "file", + "size_bytes": 7605333 + }, + { + "path": "artifacts/inference.yml", + "required": true, + "sha256": "8701ae3c6d1586bf8db570a009374cf88d94bb3bf733c665e03146aee2b854c9", + "kind": "file", + "size_bytes": 1443 + }, + { + "path": "artifacts/limbu-sirijonga-v2.txt", + "required": true, + "sha256": "a708e4e6c74ac17097a2c8fe24e3f3fd057482969959f5f17950150523693d7d", + "kind": "file", + "size_bytes": 316 + } + ], + "backend_kwargs": { + "lang": "limbu-sirijonga", + "text_recognition_model_name": "PP-OCRv5_mobile_rec", + "text_recognition_model_dir": "artifacts", + "recognition_mode": "line" + }, + "provenance": {}, + "metrics": {}, + "notes": "ft-v2 2026-07-06: trained on rebuilt 2x corpus (46,753 rows, real x8 replay), frozen 902-line test cp CER 0.0047 / grapheme 0.0098 / exact 0.859 vs prior champion 0.0138/0.0284/0.637; page-eval-v2 end-to-end 0.0272 cp (prior 0.043). Silver labels, diagnostic. Run artifacts: outputs/limbu-ft-v2-run-2026-07-06 + HF ampixa/ocr-tech-artifacts." +} diff --git a/k2-ampixa-demo-ocr/models/space/models/line-detector/best.pt b/k2-ampixa-demo-ocr/models/space/models/line-detector/best.pt new file mode 100644 index 0000000000000000000000000000000000000000..a8706714465ff0f1e76880d7bb694168106f8ffe --- /dev/null +++ b/k2-ampixa-demo-ocr/models/space/models/line-detector/best.pt @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bc57415eb53e4c0372a590196ea3de045bbcdabfc823cd06955a38a3e88dfec3 +size 6362922 diff --git a/k2-ampixa-demo-ocr/models/space/requirements.txt b/k2-ampixa-demo-ocr/models/space/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..82824eeff4366fb442254d826a0d08ccaa771b02 --- /dev/null +++ b/k2-ampixa-demo-ocr/models/space/requirements.txt @@ -0,0 +1,8 @@ +gradio==5.49.1 +pillow>=10.0.0 +numpy>=1.26.0,<2.3 +opencv-python-headless>=4.10.0.84,<4.13 +pypdfium2>=4.30.0,<5 +paddlepaddle==3.3.1 +paddleocr==3.7.0 +ultralytics==8.3.0 diff --git a/k2-ampixa-demo-ocr/workers-ocr/README.md b/k2-ampixa-demo-ocr/workers-ocr/README.md new file mode 100644 index 0000000000000000000000000000000000000000..ef82fdc58e869e2abcf2a586b9d51e273f9b7bcb --- /dev/null +++ b/k2-ampixa-demo-ocr/workers-ocr/README.md @@ -0,0 +1,314 @@ +# OCR worker (Limbu Sirijonga + Devanagari) + +Port 8906, worker name `ocr`. Line and page OCR on CPU with PaddleOCR 3.7.0 / +paddlepaddle 3.3.1, ported from the non-Gradio inference paths of the private +Hugging Face Space `ampixa/limbu-ocr`. + +## Endpoints + +### `GET /health` + +```json +{ + "ok": true, + "worker": "ocr", + "loaded": true, + "models": { + "sirijonga": "/Users/k2/ampixa-demo/models/ocr/space/models/limbu-sirijonga-ft-v2/artifacts", + "devanagari": "/Users/k2/ampixa-demo/models/ocr/space/models/deva-v2/artifacts", + "recognizer_model_name": "PP-OCRv5_mobile_rec", + "detector_model_name": "PP-OCRv6_medium_det", + "detector_limit": "max/1280", + "max_lines": 120, + "max_image_side": 2000, + "load_seconds": 1.19 + }, + "device": "cpu" +} +``` + +`/health` answers as soon as uvicorn binds; the Paddle predictors are built in a +background thread and `loaded` flips to `true` when they are ready. If the load +fails, `/health` returns 503 with `ok: false` and an `error` string. + +### `POST /recognize` + +`multipart/form-data`: + +| field | required | values | default | +|----------|----------|-----------------------------------------|---------| +| `file` | yes | PNG / JPEG / WebP, <= 10 MB | - | +| `mode` | no | `line`, `page` | `page` | +| `script` | no | `auto`, `sirijonga`, `devanagari` | `auto` | + +The image is EXIF-transposed, converted to RGB and downscaled so the longest +side is at most 2000 px. Every box in the response is in **processed-image** +pixels (`image_size` reports those dimensions), not the original upload's. + +Response: + +```json +{ + "text": "line 1\nline 2", + "lines": [ + {"text": "line 1", "confidence": 0.918, "box": [13, 0, 300, 14], "script": "sirijonga"} + ], + "script": "sirijonga", + "mode": "page", + "elapsed_s": 4.94, + "image_size": [316, 600], + "truncated": false, + "overlay_png_b64": "iVBORw0..." +} +``` + +Two keys extend the contract in `PLAN.md`, both additive: + +- `image_size` — the processed width/height the `box` values refer to. +- `truncated` — true when the page had more detected lines than + `AMPIXA_OCR_MAX_LINES` (default 120) and the tail was dropped. + +`overlay_png_b64` is `null` in `line` mode. In `page` mode it is a base64 PNG of +the processed image with every ordered box drawn and numbered, downscaled so its +longest side is at most 1400 px (`AMPIXA_OCR_OVERLAY_MAX_SIDE`). A full +newspaper page produces roughly 1.4 MB of PNG, i.e. ~1.85 MB of base64; the +website should prefer column-sized crops. + +Errors are always `{"error": "..."}`: + +| case | status | +|------------------------------|--------| +| missing `file` field | 400 | +| `mode`/`script` not in the enum | 400 | +| empty or undecodable file | 400 | +| GIF/BMP/TIFF/... upload | 415 | +| upload above 10 MB | 413 | +| models still loading / failed| 503 | +| anything unhandled | 500 | + +## How the two modes work + +**`line`** — the whole (downscaled) image is one crop, fed straight to the +recognizer(s). No detector runs, so this is fast (~0.07 s) and the returned box +is the full image. + +**`page`** — PaddleOCR full-page text detection (`TextDetection`, PaddleOCR +3.7.0's default `PP-OCRv6_medium_det`, auto-downloaded to +`~/.paddlex/official_models`) produces line polygons. They are reduced to +axis-aligned boxes, sorted in the Space's `Rows LTR` order, cropped with 12 px +padding and recognized in batches of 16. + +## Script routing + +`sirijonga` and `devanagari` run exactly one recognizer. + +`auto` copies the Space's `_script_score` verbatim: both recognizers run on each +crop and the higher score wins, ties going to Sirijonga. + +``` +sirijonga : confidence + 0.06 * min(limbu_chars, 12) - 0.04 * min(deva_chars, 12) +devanagari: confidence + 0.035 * min(deva_chars, 12) - 0.08 * min(limbu_chars, 12) +``` + +Two things are worth knowing before wiring the site: + +1. **`auto` is strongly biased towards Sirijonga.** The Sirijonga bonus is + 0.06/char against 0.035/char for Devanagari, so a Sirijonga candidate with + 12+ Limbu characters starts 0.72 ahead. Measured on a real Devanagari + newspaper column (`docs/smoke/ocr/page-column-devanagari-*.json`): forcing + `script=devanagari` reads the text, while `script=auto` routes 18 of 19 lines + to Sirijonga and returns transliteration noise. Expose the script selector in + the UI; do not rely on `auto` for Devanagari input. +2. **The "fall back when the output has no Limbu codepoints" heuristic cannot + work here.** The Sirijonga recognizer's character dictionary (in + `inference.yml`) contains only Limbu, digits and punctuation, so it can never + emit a Devanagari codepoint and its output essentially always contains Limbu + characters. Score comparison is the only routing signal available. + +`auto` skips the Devanagari pass whenever the Sirijonga candidate already scores +at least `1.0 + 0.035 * 12 = 1.42`, which is the largest score any Devanagari +candidate can reach. That is an exact prune: it never changes which text is +selected, it only avoids work. + +## Deviations from the Space's `app.py` + +| what | Space | here | why | +|------|-------|------|-----| +| page pipeline | `PaddleOCR(...)` pipeline, then re-recognize each crop | `TextDetection` + batched recognizers | The pipeline recognizes every box with the seed recognizer and the Space then throws that away and recognizes each crop again. Dropping the wasted pass saves ~40 s on a 305-line page with identical boxes (`use_textline_orientation=False` makes `rec_polys == dt_polys`). | +| detector `limit_type` | PaddleX default `min` | `max` | With `min`, `limit_side_len=1280` scales the *shortest* side up to 1280 and a page costs 7.7 s to detect regardless of its size. With `max` the same page takes 3.2 s and a column crop 1.6 s, for 303 boxes vs 305. Override with `AMPIXA_OCR_DET_LIMIT_TYPE=min` to match the Space exactly. | +| line cap | Space default 0 (uncapped) | 120 | Bounds worst-case request time. A 305-line broadsheet would otherwise take ~90 s in `auto`. | +| model presence check | requires `models/deva-v2/artifacts/nep_eng_dict.txt` | requires `inference.{json,pdiparams,yml}` | **That file does not exist in the Space.** The deployed `app.py` (sha256 `cffc507f...`) checks for `nep_eng_dict.txt` in `deva-v2/artifacts`, but the directory only ships `devanagari-v2.txt` (the repo copy of `app.py` in `ampixa/ocr-tech` still names `devanagari-v2.txt`, so this is a regression in the Space upload). `_ensure_models_present()` therefore raises on the live Space for every route. Worth fixing there. Neither dictionary file is read at inference time anyway — the character dictionary is embedded in `inference.yml` under `PostProcess.character_dict`. | +| YOLO line detector | optional probe tab | not ported | `models/line-detector/best.pt` is downloaded (6.4 MB) but unused; the Space calls the Paddle detector the primary route and the YOLO route needs `ultralytics` + torch. | +| PDF / book batch | Paddle Book OCR tab | not ported | Out of scope for the demo contract. | + +Detector thresholds match the Space's Paddle page defaults: `thresh=0.30`, +`box_thresh=0.60`, `unclip_ratio=1.5`, `crop_padding=12`, reading order +`Rows LTR`. + +## Models + +Fetched on k2 with `huggingface_hub.snapshot_download("ampixa/limbu-ocr", +repo_type="space", ...)` into `~/ampixa-demo/models/ocr/space` (21 MB total, not +in git). The recognizer weights are PP-OCRv5_mobile_rec fine-tunes. + +``` +96806153df021c99b0195de9757d8fe6443c52f7c8a1c74bf76a5895c37b8c0b models/deva-v2/artifacts/devanagari-v2.txt +772e801de4c1cc260058f7c426ab618ef52ecc7ea51442886c8c8fc1606cb88b models/deva-v2/artifacts/inference.json +32f5256f8a062830be4394606b8307c30dd9b9fb1be4e15af65606abffb479b4 models/deva-v2/artifacts/inference.pdiparams +4f76c7bd21ea18ec118adef93b98017b55a449072b35f1c3ea2baa3df217c8dc models/deva-v2/artifacts/inference.yml +f6e7dae5427ce893f8b15824060d29e46bd9981218d587b86a13591d4871d588 models/deva-v2/model-card.json +0b5ca684a4e1acc77bad0af537670800f21923e69ea1a79cfb899f25dd54f0eb models/limbu-sirijonga-ft-v2/artifacts/inference.json +97ae5d8121ea4a05de8ac0c98460df9bb66f2965d507da83ed9de5324baf3971 models/limbu-sirijonga-ft-v2/artifacts/inference.pdiparams +8701ae3c6d1586bf8db570a009374cf88d94bb3bf733c665e03146aee2b854c9 models/limbu-sirijonga-ft-v2/artifacts/inference.yml +a708e4e6c74ac17097a2c8fe24e3f3fd057482969959f5f17950150523693d7d models/limbu-sirijonga-ft-v2/artifacts/limbu-sirijonga-v2.txt +1265a26d557ae752743e7ec56d3970e419aa5fe6ecc34785d3e9d3a1e49c58a4 models/limbu-sirijonga-ft-v2/model-card.json +bc57415eb53e4c0372a590196ea3de045bbcdabfc823cd06955a38a3e88dfec3 models/line-detector/best.pt (downloaded, unused) +cffc507fd79f1ee31b6469315c92ff6b8e2360affe617ae8e2f8fa709b92fa01 app.py (reference only) +``` + +The text detector is PaddleOCR's own `PP-OCRv6_medium_det`, already cached at +`~/.paddlex/official_models/PP-OCRv6_medium_det` +(`inference.pdiparams` sha256 `85218d2e3d98f5a21c58b4220627be923a97aee5db3cc71f39536ab31ac53960`). + +Model-card notes carried over from the Space, unchanged and worth repeating on +the site: the Sirijonga recognizer reports frozen-test codepoint CER 0.0047 on +**silver** (machine-derived) labels and is described as diagnostic, not a +claim-safe benchmark. The Devanagari model has not been validated on +human-reviewed Devanagari-written Limbu pages. + +## Device + +CPU only. paddlepaddle has no Metal/MPS backend on macOS arm64, so there is no +GPU option on k2. `cpu_threads` (4/8/16) and `enable_mkldnn` (on/off) were +measured and changed nothing on this host (all within 3% of each other), so both +are left at the PaddleOCR defaults. + +## Install and run on k2 + +The worker reuses `~/ocr-tech/.venv` (python 3.11.14), which already has the +exact stack the Space pins: `paddlepaddle==3.3.1`, `paddleocr==3.7.0`, plus +pillow 10.4.0, opencv-python 4.11.0 and numpy 2.3.5. Per the venv policy, +`uv pip install --dry-run` was run first and showed the four additions as pure +installs with no upgrade or downgrade of an existing package: + +```sh +export PATH=/opt/homebrew/bin:$PATH +uv pip install --python ~/ocr-tech/.venv/bin/python -r ~/ampixa-demo/workers/ocr/requirements.txt +``` + +Start it: + +```sh +cd ~/ampixa-demo && nohup ./workers/ocr/run.sh > /dev/null 2>&1 & +``` + +`run.sh` binds 127.0.0.1:8906 and appends to `~/ampixa-demo/logs/ocr.log`. It +honours `AMPIXA_DEMO_ROOT`, `AMPIXA_OCR_VENV`, `AMPIXA_OCR_HOST`, +`AMPIXA_OCR_PORT` and `AMPIXA_OCR_MODEL_ROOT`. + +Other tunables, all environment variables read at import time: +`AMPIXA_OCR_MAX_LINES` (120), `AMPIXA_OCR_OVERLAY_MAX_SIDE` (1400), +`AMPIXA_OCR_REC_BATCH_SIZE` (16), `AMPIXA_OCR_DET_LIMIT_SIDE_LEN` (1280), +`AMPIXA_OCR_DET_LIMIT_TYPE` (`max`), `AMPIXA_OCR_DET_THRESH` (0.30), +`AMPIXA_OCR_DET_BOX_THRESH` (0.60), `AMPIXA_OCR_DET_UNCLIP_RATIO` (1.5). + +Smoke test: + +```sh +curl -s http://127.0.0.1:8906/health +curl -s -F "file=@$HOME/ampixa-demo/logs/ocr-smoke/samples/limbu-line-sirijonga.png" \ + -F mode=line -F script=auto http://127.0.0.1:8906/recognize +curl -s -F "file=@$HOME/ampixa-demo/logs/ocr-smoke/samples/limbu-column-sirijonga.png" \ + -F mode=page -F script=auto http://127.0.0.1:8906/recognize +``` + +## Measured latency (k2, Mac Studio M2 Ultra, CPU) + +Model load after the process starts: 1.2 s (plus ~9 s to import paddle before +uvicorn binds). Full table in `docs/smoke/ocr/latency.json`. + +| case | mode | script | input px | lines | server `elapsed_s` | +|------|------|--------|----------|-------|--------------------| +| Sirijonga headline crop | line | auto | 1176x183 | 1 | 0.07 | +| Sirijonga headline crop | line | sirijonga | 1176x183 | 1 | 0.07 | +| Devanagari line crop | line | devanagari | 822x141 | 1 | 0.07 | +| Sirijonga newspaper column | page | auto | 316x600 | 23 | 4.94 | +| Devanagari newspaper column | page | devanagari | 316x600 | 19 | 2.76 | +| Devanagari newspaper column | page | auto | 316x600 | 19 | 4.84 | +| Sirijonga article block (3.5 columns) | page | auto | 930x600 | 90 | 18.70 | +| Full broadsheet page (capped) | page | sirijonga | 1297x2000 | 120 | 17.12 | +| Full broadsheet page (capped) | page | auto | 1297x2000 | 120 | 29.93 | + +Cost model: detection ~1.6 s for a column and ~3.2 s for a full page, then +~130 ms per line per recognizer pass. `auto` is up to 2x a forced script. A full +uncapped 305-line broadsheet would be ~90 s in `auto`, which is why +`AMPIXA_OCR_MAX_LINES` defaults to 120 and why the website samples are single +newspaper columns. + +## Sample images + +`site/assets/ocr-samples/` holds three images for the website's "try a sample" +buttons, all cut from Gorkhapatra pages already present read-only on k2 under +`~/ocr-tech/data`: + +| file | bytes | px | cut from | +|------|-------|----|----------| +| `limbu-line-sirijonga.png` | 26 754 | 1176x183 | `data/limbu-gorkhapatra-language-page-pack-2026-06-16/inputs/gorkhapatra-language-page-0001-01.png` crop `(76, 369, 1252, 552)` | +| `limbu-column-sirijonga.png` | 91 080 | 316x600 | same page, crop `(360, 1150, 676, 1750)` | +| `deva-column-devanagari.png` | 105 069 | 316x600 | `data/gorkhapatra-language-page-pack-smoke/inputs/gorkhapatra-language-page-0001-02.png` crop `(360, 1150, 676, 1750)` | + +**Provenance and licence.** Both source pages are language-supplement pages of +*Gorkhapatra* ("नयाँ नेपाल"), the Nepali state-owned daily, taken from its public +e-paper — the first via +`epaper.gorkhapatraonline.com` (manifest +`data/gorkhapatra-pack-smoke/manifests/gorkhapatra-pack.jsonl` records the source +PDF URLs and sha256s). The content is **copyright Gorkhapatra Sansthan; it is not +openly licensed.** These are small excerpts (one headline, two single columns) +used as OCR demo input. The ocr-tech manifests mark every one of these rows +`claim_evidence_eligible: false` / `reference_status: pending_manual_label`, so +they are demo material, not benchmark evidence. If the public site needs +unambiguously redistributable samples, replace them with text rendered from +Noto Sans Limbu (present on k2 at +`/System/Library/Fonts/Supplemental/NotoSansLimbu-Regular.ttf`, SIL OFL) or with +material the project owns. + +## Ground-truthed check on rendered text + +k2 ships `/System/Library/Fonts/Supplemental/NotoSansLimbu-Regular.ttf`, so three +Sirijonga lines were rendered at 64 px with PIL and pushed through `mode=line`, +`script=sirijonga`. All three came back **exact**, codepoint CER 0.000, +confidence 0.953-0.970, 0.07-0.09 s each: + +| reference | recognized | exact | +|-----------|------------|-------| +| `ᤕᤠᤰᤌᤢᤱ ᤐᤠᤴ` | `ᤕᤠᤰᤌᤢᤱ ᤐᤠᤴ` | yes | +| `ᤗᤡᤶᤒᤢ ᤛᤡᤖᤡᤈᤥᤱᤀᤥ ᤛᤠᤵᤐᤴ` | `ᤗᤡᤶᤒᤢ ᤛᤡᤖᤡᤈᤥᤱᤀᤥ ᤛᤠᤵᤐᤴ` | yes | +| `᥇᥈᥉᥊᥋ ᤀᤠᤱ ᥌᥍᥎᥏᥆` | `᥇᥈᥉᥊᥋ ᤀᤠᤱ ᥌᥍᥎᥏᥆` | yes | + +Caveat: this Pillow build reports `features.check("raqm") == False`, so the text +is drawn without complex-script shaping. The glyphs are correct but positioned +more simply than properly typeset Limbu, and the images are clean synthetic +renders. Treat this as "the pipeline and the character dictionary are wired up +correctly", not as an accuracy result. Artifacts in `docs/smoke/ocr/rendered/`. + +## Smoke evidence + +`docs/smoke/ocr/` contains the request JSON for all ten cases, the decoded box +overlays, `latency.json`, the input crops under `docs/smoke/ocr/inputs/` and the +rendered-text check under `docs/smoke/ocr/rendered/`. The same files live on k2 +in `~/ampixa-demo/logs/ocr-smoke/` together with the two full-page inputs that +are too large for git. + +## Known gaps + +- There is no ground-truth transcription for the scanned pages used, so the page + smoke tests show the worker runs end to end and produces plausible Limbu at + high recognizer confidence (median 0.845 over a 23-line Sirijonga column, + 0.83-0.97 on headline lines). They are **not** an accuracy measurement on real + scans. The Space's own model card is the only accuracy claim, and it is on + silver labels. +- The only ground-truthed measurement here is the rendered-text check below, and + it is easier than a real scan. +- The `auto` route is unreliable for Devanagari input (see Script routing). +- Page mode is slow on dense pages; a broadsheet is 18-30 s. Anything more + responsive needs either a smaller input or batching across requests. diff --git a/k2-ampixa-demo-ocr/workers-ocr/requirements.txt b/k2-ampixa-demo-ocr/workers-ocr/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..e1da30801b9b5d2f7792ed1c8df036f463f4dc47 --- /dev/null +++ b/k2-ampixa-demo-ocr/workers-ocr/requirements.txt @@ -0,0 +1,9 @@ +# Added on top of the existing ~/ocr-tech/.venv on k2 (python 3.11). +# That venv already provides the heavy stack the Space pins: +# paddlepaddle==3.3.1, paddleocr==3.7.0, pillow 10.4.0, opencv-python 4.11.0, numpy 2.3.5 +# `uv pip install --dry-run` against it showed these four as pure additions with +# no upgrade or downgrade of any existing package. +fastapi==0.141.1 +starlette==1.6.0 +uvicorn==0.52.4 +python-multipart==0.0.32 diff --git a/k2-ampixa-demo-ocr/workers-ocr/run.sh b/k2-ampixa-demo-ocr/workers-ocr/run.sh new file mode 100644 index 0000000000000000000000000000000000000000..dc6a3df9952c7d7ff24f2850e69b5f091d7ec9a9 --- /dev/null +++ b/k2-ampixa-demo-ocr/workers-ocr/run.sh @@ -0,0 +1,16 @@ +#!/bin/sh +# Start the Ampixa OCR worker on k2 (127.0.0.1:8906), logging to ~/ampixa-demo/logs/ocr.log. +set -eu + +ROOT="${AMPIXA_DEMO_ROOT:-$HOME/ampixa-demo}" +VENV="${AMPIXA_OCR_VENV:-$HOME/ocr-tech/.venv}" + +AMPIXA_OCR_MODEL_ROOT="${AMPIXA_OCR_MODEL_ROOT:-$ROOT/models/ocr/space/models}" +export AMPIXA_OCR_MODEL_ROOT + +mkdir -p "$ROOT/logs" + +exec "$VENV/bin/python" "$ROOT/workers/ocr/server.py" \ + --host "${AMPIXA_OCR_HOST:-127.0.0.1}" \ + --port "${AMPIXA_OCR_PORT:-8906}" \ + >> "$ROOT/logs/ocr.log" 2>&1 diff --git a/k2-ampixa-demo-ocr/workers-ocr/server.py b/k2-ampixa-demo-ocr/workers-ocr/server.py new file mode 100644 index 0000000000000000000000000000000000000000..128939401ec88574cda7e9cd2608f87588b13ce2 --- /dev/null +++ b/k2-ampixa-demo-ocr/workers-ocr/server.py @@ -0,0 +1,715 @@ +"""Ampixa OCR worker: Limbu Sirijonga + Devanagari OCR on CPU via PaddleOCR. + +Ported from the non-Gradio inference paths of the private Hugging Face Space +``ampixa/limbu-ocr`` (``app.py``, sha256 cffc507fd79f1ee31b6469315c92ff6b8e2360affe617ae8e2f8fa709b92fa01). + +Two routes are exposed: + +``line`` + The uploaded image is treated as a single cropped text line and sent + straight to the recognizer(s). + +``page`` + PaddleOCR full-page text detection produces line boxes, the boxes are put + into reading order, every crop is recognized, and a PNG overlay with the + boxes drawn on it is returned alongside the text. + +Everything runs on CPU: paddlepaddle has no Metal/MPS backend on macOS arm64. +""" + +from __future__ import annotations + +import argparse +import base64 +import io +import logging +import math +import os +import re +import sys +import threading +import time +import traceback +from collections.abc import AsyncIterator +from contextlib import asynccontextmanager +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +import numpy as np +import uvicorn +from fastapi import FastAPI, File, Form, Request, UploadFile +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse +from paddleocr import TextDetection +from paddleocr._models.text_recognition import TextRecognition +from paddlex import create_model +from PIL import Image, ImageDraw, ImageOps, UnidentifiedImageError +from starlette.concurrency import run_in_threadpool +from starlette.exceptions import HTTPException as StarletteHTTPException + +WORKER_NAME = "ocr" +DEFAULT_HOST = os.environ.get("AMPIXA_OCR_HOST", "127.0.0.1") +DEFAULT_PORT = int(os.environ.get("AMPIXA_OCR_PORT", "8906")) + +MODEL_ROOT = Path( + os.environ.get( + "AMPIXA_OCR_MODEL_ROOT", + str(Path.home() / "ampixa-demo" / "models" / "ocr" / "space" / "models"), + ) +).expanduser() +SIRIJONGA_MODEL_DIR = MODEL_ROOT / "limbu-sirijonga-ft-v2" / "artifacts" +# devanagari-ft-v3 (2026-09-24): official PaddleOCR devanagari_PP-OCRv5_mobile_rec fine-tuned +# on real Gorkhapatra print, synthetic citizenship/office lines, and English replay; served as +# ONNX (see ../models/.../devanagari-ft-v3/MODEL-SOURCE.txt). Same 568-entry dictionary +# (Devanagari + all Latin letters + 0-9). Roll back to the official model by pointing +# AMPIXA_OCR_DEVANAGARI_DIR at devanagari-ppocrv5/artifacts. +DEVANAGARI_MODEL_DIR = Path( + os.environ.get("AMPIXA_OCR_DEVANAGARI_DIR", str(MODEL_ROOT / "devanagari-ft-v3" / "artifacts")) +).expanduser() + +# The PP-OCRv5 recognizer packs live under model_dir; the character dictionary is +# embedded in inference.yml (PostProcess.character_dict), so the standalone .txt +# dictionaries shipped next to them are documentation only and are not loaded. +# Each model_name must match Global.model_name in that model's inference.yml. +SIRIJONGA_MODEL_NAME = "PP-OCRv5_mobile_rec" +DEVANAGARI_MODEL_NAME = "devanagari_PP-OCRv5_mobile_rec" +REQUIRED_RECOGNIZER_FILES = ("inference.json", "inference.pdiparams", "inference.yml") +# A directory holding inference.onnx (tools/deva_rec_torch/export_onnx.py output) is served +# through PaddleX's onnxruntime engine with the same pre/post-processing as Paddle. +REQUIRED_ONNX_FILES = ("inference.onnx", "inference.yml") + + +def recognizer_engine(model_dir: Path) -> str: + return "onnxruntime" if (model_dir / "inference.onnx").is_file() else "paddle_static" + +MAX_UPLOAD_BYTES = 10 * 1024 * 1024 +MAX_IMAGE_SIDE = 2000 +OVERLAY_MAX_SIDE = int(os.environ.get("AMPIXA_OCR_OVERLAY_MAX_SIDE", "1400")) +MAX_LINES = int(os.environ.get("AMPIXA_OCR_MAX_LINES", "120")) +RECOGNIZER_BATCH_SIZE = int(os.environ.get("AMPIXA_OCR_REC_BATCH_SIZE", "16")) + +# Detector settings. The Space leaves limit_type at the PaddleX default ("min"), +# which upscales every page so its *shortest* side is >= limit_side_len and costs +# ~8 s per page on this host. "max" bounds the *longest* side instead: 2.4x faster +# on a full newspaper page for the same box count (303 vs 305 boxes measured). +DETECTOR_LIMIT_SIDE_LEN = int(os.environ.get("AMPIXA_OCR_DET_LIMIT_SIDE_LEN", "1280")) +DETECTOR_LIMIT_TYPE = os.environ.get("AMPIXA_OCR_DET_LIMIT_TYPE", "max") +DETECTOR_THRESH = float(os.environ.get("AMPIXA_OCR_DET_THRESH", "0.30")) +DETECTOR_BOX_THRESH = float(os.environ.get("AMPIXA_OCR_DET_BOX_THRESH", "0.60")) +DETECTOR_UNCLIP_RATIO = float(os.environ.get("AMPIXA_OCR_DET_UNCLIP_RATIO", "1.5")) +DETECTOR_MODEL_NAME = "PP-OCRv6_medium_det" # PaddleOCR 3.7.0 default text detector. + +CROP_PADDING = 12 # Space default for the Paddle page tab. +READING_ORDER = "Rows LTR" # Space default for the Paddle page tab. + +SUPPORTED_MODES = ("line", "page") +SUPPORTED_SCRIPTS = ("auto", "sirijonga", "devanagari") +SUPPORTED_IMAGE_FORMATS = {"PNG": "image/png", "JPEG": "image/jpeg", "WEBP": "image/webp"} + +LIMBU_RE = re.compile("[\u1900-\u194F]") +DEVANAGARI_RE = re.compile("[\u0900-\u097F]") + +# Upper bound of _script_score() for a Devanagari candidate: rec_score is a +# probability (<= 1.0) and the Devanagari bonus saturates at 12 * 0.035. If the +# Sirijonga candidate already scores at least this much, the Devanagari pass +# cannot change the outcome and is skipped. This is an exact prune, not an +# approximation: it never changes the selected text. +MAX_DEVANAGARI_SCRIPT_SCORE = 1.0 + 0.035 * 12 + +LOGGER = logging.getLogger("ampixa.ocr") + + +@dataclass(slots=True) +class Recognition: + """One recognizer output for one crop.""" + + text: str + confidence: float | None + engine: str + + +@dataclass(slots=True) +class Box: + """Axis-aligned line box in processed-image pixel coordinates.""" + + left: int + top: int + right: int + bottom: int + confidence: float + + @property + def width(self) -> int: + return max(0, self.right - self.left) + + @property + def height(self) -> int: + return max(0, self.bottom - self.top) + + @property + def x_center(self) -> float: + return (self.left + self.right) / 2.0 + + @property + def y_center(self) -> float: + return (self.top + self.bottom) / 2.0 + + def as_list(self) -> list[int]: + return [self.left, self.top, self.right, self.bottom] + + +class OcrError(Exception): + """Client-visible OCR failure carrying an HTTP status code.""" + + def __init__(self, message: str, status_code: int) -> None: + super().__init__(message) + self.message = message + self.status_code = status_code + + +class Engines: + """Holds the Paddle predictors and serializes every call into them. + + Paddle predictors are not documented as thread-safe, and uvicorn runs request + handlers in a thread pool, so every predict() call goes through ``lock``. + """ + + def __init__(self) -> None: + self.lock = threading.Lock() + self.recognizers: dict[str, Any] = {} + self.detector: Any = None + self.loaded = False + self.load_seconds: float | None = None + self.load_error: str | None = None + + def ensure_model_files(self) -> None: + missing: list[str] = [] + for model_dir in (SIRIJONGA_MODEL_DIR, DEVANAGARI_MODEL_DIR): + required = REQUIRED_ONNX_FILES if recognizer_engine(model_dir) == "onnxruntime" else REQUIRED_RECOGNIZER_FILES + for name in required: + path = model_dir / name + if not path.is_file(): + missing.append(str(path)) + if missing: + raise RuntimeError("missing OCR model artifacts: " + ", ".join(missing)) + + def load(self) -> None: + """Build every predictor once. Called from a background thread at startup.""" + started = time.perf_counter() + try: + self.ensure_model_files() + for engine, model_name, model_dir in ( + ("sirijonga", SIRIJONGA_MODEL_NAME, SIRIJONGA_MODEL_DIR), + ("devanagari", DEVANAGARI_MODEL_NAME, DEVANAGARI_MODEL_DIR), + ): + step = time.perf_counter() + backend = recognizer_engine(model_dir) + if backend == "onnxruntime": + self.recognizers[engine] = create_model( + model_name=model_name, model_dir=str(model_dir), engine="onnxruntime", device="cpu" + ) + else: + self.recognizers[engine] = TextRecognition( + model_name=model_name, + model_dir=str(model_dir), + device="cpu", + ) + LOGGER.info( + "loaded recognizer engine=%s backend=%s model=%s dir=%s in %.2fs", + engine, + backend, + model_name, + model_dir, + time.perf_counter() - step, + ) + step = time.perf_counter() + self.detector = TextDetection( + limit_side_len=DETECTOR_LIMIT_SIDE_LEN, + limit_type=DETECTOR_LIMIT_TYPE, + thresh=DETECTOR_THRESH, + box_thresh=DETECTOR_BOX_THRESH, + unclip_ratio=DETECTOR_UNCLIP_RATIO, + device="cpu", + ) + LOGGER.info("loaded text detector in %.2fs", time.perf_counter() - step) + except Exception as exc: # noqa: BLE001 - recorded and surfaced through /health + self.load_error = f"{type(exc).__name__}: {exc}" + LOGGER.error("model load failed: %s\n%s", self.load_error, traceback.format_exc()) + return + self.load_seconds = time.perf_counter() - started + self.loaded = True + LOGGER.info("all OCR models loaded in %.2fs", self.load_seconds) + + +ENGINES = Engines() + + +def _payload(item: object) -> dict[str, Any] | None: + """Unwrap a PaddleX result object into its plain result mapping.""" + candidate: object = item + if not isinstance(candidate, dict): + candidate = getattr(item, "json", None) + if not isinstance(candidate, dict): + return None + nested = candidate.get("res") + return nested if isinstance(nested, dict) else candidate + + +def _script_score(recognition: Recognition) -> float: + """Score copied verbatim from the Space's app.py ``_script_score``. + + The Sirijonga bonus (0.06/char, capped at 12 chars) is larger than the + Devanagari one (0.035/char), so this rule leans towards Sirijonga on mixed + pages. Callers that know the script should pass it explicitly. + """ + text = recognition.text or "" + confidence = recognition.confidence if recognition.confidence is not None else 0.0 + limbu_chars = len(LIMBU_RE.findall(text)) + deva_chars = len(DEVANAGARI_RE.findall(text)) + if recognition.engine == "sirijonga": + return confidence + min(limbu_chars, 12) * 0.06 - min(deva_chars, 12) * 0.04 + if recognition.engine == "devanagari": + return confidence + min(deva_chars, 12) * 0.035 - min(limbu_chars, 12) * 0.08 + return confidence + + +def _recognize_batch(engine: str, crops: list[np.ndarray]) -> list[Recognition]: + """Run one recognizer over a list of BGR crops, preserving input order.""" + if not crops: + return [] + predictor = ENGINES.recognizers.get(engine) + if predictor is None: + raise OcrError(f"recognizer '{engine}' is not loaded", 503) + raw = list(predictor.predict(crops, batch_size=RECOGNIZER_BATCH_SIZE)) + if len(raw) != len(crops): + raise OcrError( + f"recognizer '{engine}' returned {len(raw)} results for {len(crops)} crops", + 500, + ) + results: list[Recognition] = [] + for item in raw: + payload = _payload(item) + if payload is None: + results.append(Recognition(text="", confidence=None, engine=engine)) + continue + text = payload.get("rec_text") or payload.get("text") or "" + score = payload.get("rec_score") + if score is None: + score = payload.get("score") + confidence: float | None + try: + confidence = float(score) if score is not None else None + except (TypeError, ValueError): + confidence = None + results.append(Recognition(text=str(text).strip(), confidence=confidence, engine=engine)) + return results + + +def _recognize_routed(crops: list[np.ndarray], script: str) -> list[Recognition]: + """Recognize crops under the requested script routing. + + ``auto`` reproduces the Space: both engines run and the higher ``_script_score`` + wins, with ties going to Sirijonga. The Devanagari pass is skipped for crops + whose Sirijonga score already exceeds every score Devanagari could reach. + """ + if script in ("sirijonga", "devanagari"): + return _recognize_batch(script, crops) + + sirijonga = _recognize_batch("sirijonga", crops) + scores = [_script_score(rec) for rec in sirijonga] + pending = [i for i, score in enumerate(scores) if score < MAX_DEVANAGARI_SCRIPT_SCORE] + if not pending: + return sirijonga + devanagari = _recognize_batch("devanagari", [crops[i] for i in pending]) + selected = list(sirijonga) + for index, candidate in zip(pending, devanagari, strict=True): + if _script_score(candidate) > scores[index]: + selected[index] = candidate + return selected + + +def _to_bgr(image: Image.Image) -> np.ndarray: + """PIL RGB image -> contiguous BGR ndarray, the layout PaddleX expects.""" + return np.asarray(image)[:, :, ::-1].copy() + + +def _box_from_polygon(polygon: object, *, width: int, height: int, confidence: float) -> Box | None: + array = np.asarray(polygon, dtype=np.float64).reshape(-1, 2) + if array.size == 0: + return None + box = Box( + left=max(0, int(math.floor(float(array[:, 0].min())))), + top=max(0, int(math.floor(float(array[:, 1].min())))), + right=min(width, int(math.ceil(float(array[:, 0].max())))), + bottom=min(height, int(math.ceil(float(array[:, 1].max())))), + confidence=confidence, + ) + return box if box.width > 0 and box.height > 0 else None + + +def _detect_boxes(image: Image.Image) -> list[Box]: + """Full-page text detection -> axis-aligned line boxes.""" + if ENGINES.detector is None: + raise OcrError("text detector is not loaded", 503) + raw = list(ENGINES.detector.predict(_to_bgr(image))) + boxes: list[Box] = [] + for item in raw: + payload = _payload(item) + if payload is None: + continue + polygons = payload.get("dt_polys") + if polygons is None: + continue + # dt_scores comes back as an ndarray, so never use truthiness on it. + scores = payload.get("dt_scores") + if scores is None: + scores = [] + for index, polygon in enumerate(polygons): + confidence = 1.0 + if index < len(scores) and scores[index] is not None: + try: + confidence = float(scores[index]) + except (TypeError, ValueError): + confidence = 1.0 + box = _box_from_polygon( + polygon, width=image.width, height=image.height, confidence=confidence + ) + if box is not None: + boxes.append(box) + return boxes + + +def _has_two_column_shape(boxes: list[Box], image_width: int) -> bool: + """Copied from the Space's app.py.""" + if len(boxes) < 8 or image_width <= 0: + return False + midpoint = image_width / 2.0 + left = [box for box in boxes if box.x_center < midpoint] + right = [box for box in boxes if box.x_center >= midpoint] + if len(left) < 3 or len(right) < 3: + return False + left_median = float(np.median([box.x_center for box in left])) + right_median = float(np.median([box.x_center for box in right])) + return (right_median - left_median) >= image_width * 0.22 + + +def _order_boxes(boxes: list[Box], mode: str, image_width: int) -> list[Box]: + """Copied from the Space's app.py ``_order_image_line_boxes``.""" + if mode == "Auto": + mode = "Columns LTR" if _has_two_column_shape(boxes, image_width) else "Rows LTR" + if mode == "Columns LTR": + return sorted( + boxes, + key=lambda box: (0 if box.x_center < image_width / 2 else 1, box.y_center, box.x_center), + ) + if mode == "Columns RTL": + return sorted( + boxes, + key=lambda box: (0 if box.x_center >= image_width / 2 else 1, box.y_center, box.x_center), + ) + row_height = max(12, int(np.median([box.height for box in boxes])) if boxes else 24) + return sorted(boxes, key=lambda box: (math.floor(box.y_center / row_height), box.x_center)) + + +def _crop(image: Image.Image, box: Box, padding: int) -> Image.Image: + return image.crop( + ( + max(0, box.left - padding), + max(0, box.top - padding), + min(image.width, box.right + padding), + min(image.height, box.bottom + padding), + ) + ) + + +def _overlay_png_b64(image: Image.Image, boxes: list[Box]) -> str: + """Draw the ordered boxes on the page and return a base64 PNG.""" + annotated = image.copy() + draw = ImageDraw.Draw(annotated) + for index, box in enumerate(boxes, start=1): + draw.rectangle( + (box.left, box.top, box.right, box.bottom), outline=(28, 120, 92), width=3 + ) + draw.text((box.left + 4, max(0, box.top - 12)), str(index), fill=(28, 120, 92)) + longest = max(annotated.size) + if longest > OVERLAY_MAX_SIDE: + scale = OVERLAY_MAX_SIDE / longest + annotated = annotated.resize( + (max(1, round(annotated.width * scale)), max(1, round(annotated.height * scale))), + Image.LANCZOS, + ) + buffer = io.BytesIO() + annotated.save(buffer, format="PNG", optimize=True) + return base64.b64encode(buffer.getvalue()).decode("ascii") + + +def _decode_image(raw: bytes) -> Image.Image: + """Validate and normalize an uploaded image; downscale the longest side.""" + try: + probe = Image.open(io.BytesIO(raw)) + image_format = probe.format + probe.load() + image = ImageOps.exif_transpose(probe).convert("RGB") + probe.close() + except UnidentifiedImageError as exc: + raise OcrError("file is not a decodable image", 400) from exc + except (OSError, ValueError) as exc: + raise OcrError(f"could not decode image: {exc}", 400) from exc + if image_format not in SUPPORTED_IMAGE_FORMATS: + raise OcrError( + f"unsupported image format {image_format!r}; expected one of " + + ", ".join(sorted(SUPPORTED_IMAGE_FORMATS)), + 415, + ) + longest = max(image.size) + if longest > MAX_IMAGE_SIDE: + scale = MAX_IMAGE_SIDE / longest + image = image.resize( + (max(1, round(image.width * scale)), max(1, round(image.height * scale))), + Image.LANCZOS, + ) + if image.width < 4 or image.height < 4: + raise OcrError("image is too small to recognize", 400) + return image + + +def _resolved_script(recognitions: list[Recognition], requested: str) -> str: + if requested in ("sirijonga", "devanagari"): + return requested + engines = [rec.engine for rec in recognitions if rec.text] + if not engines: + return "sirijonga" + return max(set(engines), key=engines.count) + + +def _run_line(image: Image.Image, script: str) -> dict[str, Any]: + crops = [_to_bgr(image)] + with ENGINES.lock: + recognitions = _recognize_routed(crops, script) + recognition = recognitions[0] + line = { + "text": recognition.text, + "confidence": recognition.confidence, + "box": [0, 0, image.width, image.height], + "script": recognition.engine, + } + return { + "text": recognition.text, + "lines": [line], + "script": _resolved_script(recognitions, script), + "truncated": False, + "overlay_png_b64": None, + } + + +def _run_page(image: Image.Image, script: str) -> dict[str, Any]: + with ENGINES.lock: + boxes = _detect_boxes(image) + ordered = _order_boxes(boxes, READING_ORDER, image.width) + truncated = MAX_LINES > 0 and len(ordered) > MAX_LINES + if truncated: + LOGGER.warning( + "page has %d detected lines, truncating to AMPIXA_OCR_MAX_LINES=%d", + len(ordered), + MAX_LINES, + ) + ordered = ordered[:MAX_LINES] + crops = [_to_bgr(_crop(image, box, CROP_PADDING)) for box in ordered] + recognitions = _recognize_routed(crops, script) + overlay = _overlay_png_b64(image, ordered) + + lines: list[dict[str, Any]] = [] + texts: list[str] = [] + for box, recognition in zip(ordered, recognitions, strict=True): + lines.append( + { + "text": recognition.text, + "confidence": recognition.confidence, + "box": box.as_list(), + "script": recognition.engine, + } + ) + if recognition.text: + texts.append(recognition.text) + return { + "text": "\n".join(texts), + "lines": lines, + "script": _resolved_script(recognitions, script), + "truncated": truncated, + "overlay_png_b64": overlay, + } + + +@asynccontextmanager +async def _lifespan(_app: FastAPI) -> AsyncIterator[None]: + """Serve /health immediately; build the Paddle predictors in the background.""" + LOGGER.info( + "starting OCR worker: model_root=%s detector=%s (%s/%d) max_lines=%d", + MODEL_ROOT, + DETECTOR_MODEL_NAME, + DETECTOR_LIMIT_TYPE, + DETECTOR_LIMIT_SIDE_LEN, + MAX_LINES, + ) + loader = threading.Thread(target=ENGINES.load, name="ocr-model-load", daemon=True) + loader.start() + yield + LOGGER.info("OCR worker shutting down") + + +app = FastAPI(title="Ampixa OCR worker", docs_url=None, redoc_url=None, lifespan=_lifespan) + + +@app.exception_handler(OcrError) +async def _ocr_error_handler(_request: Request, exc: OcrError) -> JSONResponse: + return JSONResponse(status_code=exc.status_code, content={"error": exc.message}) + + +@app.exception_handler(RequestValidationError) +async def _validation_error_handler( + _request: Request, exc: RequestValidationError +) -> JSONResponse: + """Report malformed multipart bodies as {"error": ...} instead of FastAPI's 422.""" + problems = "; ".join( + f"{'.'.join(str(part) for part in error.get('loc', ()))}: {error.get('msg', 'invalid')}" + for error in exc.errors() + ) + return JSONResponse(status_code=400, content={"error": f"invalid request: {problems}"}) + + +@app.exception_handler(StarletteHTTPException) +async def _http_error_handler(_request: Request, exc: StarletteHTTPException) -> JSONResponse: + """Keep 404/405 and friends on the {"error": ...} contract.""" + return JSONResponse(status_code=exc.status_code, content={"error": str(exc.detail)}) + + +@app.exception_handler(Exception) +async def _unhandled_error_handler(_request: Request, exc: Exception) -> JSONResponse: + """Last resort: log the traceback, return JSON, never a bare stack trace.""" + LOGGER.error("unhandled error: %s\n%s", exc, traceback.format_exc()) + return JSONResponse( + status_code=500, content={"error": f"internal error: {type(exc).__name__}"} + ) + + +@app.get("/health") +def health() -> JSONResponse: + body: dict[str, Any] = { + "ok": ENGINES.load_error is None, + "worker": WORKER_NAME, + "loaded": ENGINES.loaded, + "models": { + "sirijonga": str(SIRIJONGA_MODEL_DIR), + "devanagari": str(DEVANAGARI_MODEL_DIR), + "sirijonga_model_name": SIRIJONGA_MODEL_NAME, + "devanagari_model_name": DEVANAGARI_MODEL_NAME, + "devanagari_backend": recognizer_engine(DEVANAGARI_MODEL_DIR), + "detector_model_name": DETECTOR_MODEL_NAME, + "detector_limit": f"{DETECTOR_LIMIT_TYPE}/{DETECTOR_LIMIT_SIDE_LEN}", + "max_lines": MAX_LINES, + "max_image_side": MAX_IMAGE_SIDE, + "load_seconds": round(ENGINES.load_seconds, 2) if ENGINES.load_seconds else None, + }, + "device": "cpu", + } + if ENGINES.load_error is not None: + body["error"] = ENGINES.load_error + return JSONResponse(status_code=503, content=body) + return JSONResponse(status_code=200, content=body) + + +@app.post("/recognize") +async def recognize( + file: UploadFile = File(...), + mode: str = Form("page"), + script: str = Form("auto"), +) -> JSONResponse: + started = time.perf_counter() + mode = (mode or "page").strip().lower() + script = (script or "auto").strip().lower() + if mode not in SUPPORTED_MODES: + raise OcrError(f"mode must be one of {', '.join(SUPPORTED_MODES)}", 400) + if script not in SUPPORTED_SCRIPTS: + raise OcrError(f"script must be one of {', '.join(SUPPORTED_SCRIPTS)}", 400) + if not ENGINES.loaded: + if ENGINES.load_error is not None: + raise OcrError(f"OCR models failed to load: {ENGINES.load_error}", 503) + raise OcrError("OCR models are still loading", 503) + + try: + raw = await file.read() + except Exception as exc: # noqa: BLE001 - upload stream failures are client errors + LOGGER.error("upload read failed: %s\n%s", exc, traceback.format_exc()) + raise OcrError(f"could not read uploaded file: {exc}", 400) from exc + finally: + await file.close() + + if not raw: + raise OcrError("uploaded file is empty", 400) + if len(raw) > MAX_UPLOAD_BYTES: + raise OcrError( + f"image is {len(raw)} bytes, limit is {MAX_UPLOAD_BYTES} bytes", 413 + ) + + image = _decode_image(raw) + runner = _run_line if mode == "line" else _run_page + try: + result = await run_in_threadpool(runner, image, script) + except OcrError: + raise + except Exception as exc: # noqa: BLE001 - converted to a JSON 500 below + LOGGER.error( + "recognition failed mode=%s script=%s: %s\n%s", + mode, + script, + exc, + traceback.format_exc(), + ) + raise OcrError(f"recognition failed: {type(exc).__name__}: {exc}", 500) from exc + + elapsed = time.perf_counter() - started + LOGGER.info( + "recognize mode=%s script=%s -> %s bytes=%d size=%dx%d lines=%d truncated=%s chars=%d %.2fs", + mode, + script, + result["script"], + len(raw), + image.width, + image.height, + len(result["lines"]), + result["truncated"], + len(result["text"]), + elapsed, + ) + return JSONResponse( + status_code=200, + content={ + "text": result["text"], + "lines": result["lines"], + "script": result["script"], + "mode": mode, + "elapsed_s": round(elapsed, 3), + "image_size": [image.width, image.height], + "truncated": result["truncated"], + "overlay_png_b64": result["overlay_png_b64"], + }, + ) + + +def main() -> int: + parser = argparse.ArgumentParser(description="Ampixa OCR worker (Limbu Sirijonga + Devanagari)") + parser.add_argument("--host", default=DEFAULT_HOST) + parser.add_argument("--port", type=int, default=DEFAULT_PORT) + args = parser.parse_args() + logging.basicConfig( + level=logging.INFO, + format="%(asctime)s %(levelname)s %(name)s %(message)s", + stream=sys.stdout, + ) + uvicorn.run(app, host=args.host, port=args.port, log_level="info", access_log=False) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/k2-ampixa-demo-ocr/workers-ocr/server.py.bak-20260924-deva-v2 b/k2-ampixa-demo-ocr/workers-ocr/server.py.bak-20260924-deva-v2 new file mode 100644 index 0000000000000000000000000000000000000000..49fe967d254fc4af6f893a713d7d67bbab84e24d --- /dev/null +++ b/k2-ampixa-demo-ocr/workers-ocr/server.py.bak-20260924-deva-v2 @@ -0,0 +1,687 @@ +"""Ampixa OCR worker: Limbu Sirijonga + Devanagari OCR on CPU via PaddleOCR. + +Ported from the non-Gradio inference paths of the private Hugging Face Space +``ampixa/limbu-ocr`` (``app.py``, sha256 cffc507fd79f1ee31b6469315c92ff6b8e2360affe617ae8e2f8fa709b92fa01). + +Two routes are exposed: + +``line`` + The uploaded image is treated as a single cropped text line and sent + straight to the recognizer(s). + +``page`` + PaddleOCR full-page text detection produces line boxes, the boxes are put + into reading order, every crop is recognized, and a PNG overlay with the + boxes drawn on it is returned alongside the text. + +Everything runs on CPU: paddlepaddle has no Metal/MPS backend on macOS arm64. +""" + +from __future__ import annotations + +import argparse +import base64 +import io +import logging +import math +import os +import re +import sys +import threading +import time +import traceback +from collections.abc import AsyncIterator +from contextlib import asynccontextmanager +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +import numpy as np +import uvicorn +from fastapi import FastAPI, File, Form, Request, UploadFile +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse +from paddleocr import TextDetection +from paddleocr._models.text_recognition import TextRecognition +from PIL import Image, ImageDraw, ImageOps, UnidentifiedImageError +from starlette.concurrency import run_in_threadpool +from starlette.exceptions import HTTPException as StarletteHTTPException + +WORKER_NAME = "ocr" +DEFAULT_HOST = os.environ.get("AMPIXA_OCR_HOST", "127.0.0.1") +DEFAULT_PORT = int(os.environ.get("AMPIXA_OCR_PORT", "8906")) + +MODEL_ROOT = Path( + os.environ.get( + "AMPIXA_OCR_MODEL_ROOT", + str(Path.home() / "ampixa-demo" / "models" / "ocr" / "space" / "models"), + ) +).expanduser() +SIRIJONGA_MODEL_DIR = MODEL_ROOT / "limbu-sirijonga-ft-v2" / "artifacts" +DEVANAGARI_MODEL_DIR = MODEL_ROOT / "deva-v2" / "artifacts" + +# The PP-OCRv5 recognizer packs live under model_dir; the character dictionary is +# embedded in inference.yml (PostProcess.character_dict), so the standalone .txt +# dictionaries shipped next to them are documentation only and are not loaded. +RECOGNIZER_MODEL_NAME = "PP-OCRv5_mobile_rec" +REQUIRED_RECOGNIZER_FILES = ("inference.json", "inference.pdiparams", "inference.yml") + +MAX_UPLOAD_BYTES = 10 * 1024 * 1024 +MAX_IMAGE_SIDE = 2000 +OVERLAY_MAX_SIDE = int(os.environ.get("AMPIXA_OCR_OVERLAY_MAX_SIDE", "1400")) +MAX_LINES = int(os.environ.get("AMPIXA_OCR_MAX_LINES", "120")) +RECOGNIZER_BATCH_SIZE = int(os.environ.get("AMPIXA_OCR_REC_BATCH_SIZE", "16")) + +# Detector settings. The Space leaves limit_type at the PaddleX default ("min"), +# which upscales every page so its *shortest* side is >= limit_side_len and costs +# ~8 s per page on this host. "max" bounds the *longest* side instead: 2.4x faster +# on a full newspaper page for the same box count (303 vs 305 boxes measured). +DETECTOR_LIMIT_SIDE_LEN = int(os.environ.get("AMPIXA_OCR_DET_LIMIT_SIDE_LEN", "1280")) +DETECTOR_LIMIT_TYPE = os.environ.get("AMPIXA_OCR_DET_LIMIT_TYPE", "max") +DETECTOR_THRESH = float(os.environ.get("AMPIXA_OCR_DET_THRESH", "0.30")) +DETECTOR_BOX_THRESH = float(os.environ.get("AMPIXA_OCR_DET_BOX_THRESH", "0.60")) +DETECTOR_UNCLIP_RATIO = float(os.environ.get("AMPIXA_OCR_DET_UNCLIP_RATIO", "1.5")) +DETECTOR_MODEL_NAME = "PP-OCRv6_medium_det" # PaddleOCR 3.7.0 default text detector. + +CROP_PADDING = 12 # Space default for the Paddle page tab. +READING_ORDER = "Rows LTR" # Space default for the Paddle page tab. + +SUPPORTED_MODES = ("line", "page") +SUPPORTED_SCRIPTS = ("auto", "sirijonga", "devanagari") +SUPPORTED_IMAGE_FORMATS = {"PNG": "image/png", "JPEG": "image/jpeg", "WEBP": "image/webp"} + +LIMBU_RE = re.compile("[\u1900-\u194F]") +DEVANAGARI_RE = re.compile("[\u0900-\u097F]") + +# Upper bound of _script_score() for a Devanagari candidate: rec_score is a +# probability (<= 1.0) and the Devanagari bonus saturates at 12 * 0.035. If the +# Sirijonga candidate already scores at least this much, the Devanagari pass +# cannot change the outcome and is skipped. This is an exact prune, not an +# approximation: it never changes the selected text. +MAX_DEVANAGARI_SCRIPT_SCORE = 1.0 + 0.035 * 12 + +LOGGER = logging.getLogger("ampixa.ocr") + + +@dataclass(slots=True) +class Recognition: + """One recognizer output for one crop.""" + + text: str + confidence: float | None + engine: str + + +@dataclass(slots=True) +class Box: + """Axis-aligned line box in processed-image pixel coordinates.""" + + left: int + top: int + right: int + bottom: int + confidence: float + + @property + def width(self) -> int: + return max(0, self.right - self.left) + + @property + def height(self) -> int: + return max(0, self.bottom - self.top) + + @property + def x_center(self) -> float: + return (self.left + self.right) / 2.0 + + @property + def y_center(self) -> float: + return (self.top + self.bottom) / 2.0 + + def as_list(self) -> list[int]: + return [self.left, self.top, self.right, self.bottom] + + +class OcrError(Exception): + """Client-visible OCR failure carrying an HTTP status code.""" + + def __init__(self, message: str, status_code: int) -> None: + super().__init__(message) + self.message = message + self.status_code = status_code + + +class Engines: + """Holds the Paddle predictors and serializes every call into them. + + Paddle predictors are not documented as thread-safe, and uvicorn runs request + handlers in a thread pool, so every predict() call goes through ``lock``. + """ + + def __init__(self) -> None: + self.lock = threading.Lock() + self.recognizers: dict[str, Any] = {} + self.detector: Any = None + self.loaded = False + self.load_seconds: float | None = None + self.load_error: str | None = None + + def ensure_model_files(self) -> None: + missing: list[str] = [] + for model_dir in (SIRIJONGA_MODEL_DIR, DEVANAGARI_MODEL_DIR): + for name in REQUIRED_RECOGNIZER_FILES: + path = model_dir / name + if not path.is_file(): + missing.append(str(path)) + if missing: + raise RuntimeError("missing OCR model artifacts: " + ", ".join(missing)) + + def load(self) -> None: + """Build every predictor once. Called from a background thread at startup.""" + started = time.perf_counter() + try: + self.ensure_model_files() + for engine, model_dir in ( + ("sirijonga", SIRIJONGA_MODEL_DIR), + ("devanagari", DEVANAGARI_MODEL_DIR), + ): + step = time.perf_counter() + self.recognizers[engine] = TextRecognition( + model_name=RECOGNIZER_MODEL_NAME, + model_dir=str(model_dir), + device="cpu", + ) + LOGGER.info( + "loaded recognizer engine=%s dir=%s in %.2fs", + engine, + model_dir, + time.perf_counter() - step, + ) + step = time.perf_counter() + self.detector = TextDetection( + limit_side_len=DETECTOR_LIMIT_SIDE_LEN, + limit_type=DETECTOR_LIMIT_TYPE, + thresh=DETECTOR_THRESH, + box_thresh=DETECTOR_BOX_THRESH, + unclip_ratio=DETECTOR_UNCLIP_RATIO, + device="cpu", + ) + LOGGER.info("loaded text detector in %.2fs", time.perf_counter() - step) + except Exception as exc: # noqa: BLE001 - recorded and surfaced through /health + self.load_error = f"{type(exc).__name__}: {exc}" + LOGGER.error("model load failed: %s\n%s", self.load_error, traceback.format_exc()) + return + self.load_seconds = time.perf_counter() - started + self.loaded = True + LOGGER.info("all OCR models loaded in %.2fs", self.load_seconds) + + +ENGINES = Engines() + + +def _payload(item: object) -> dict[str, Any] | None: + """Unwrap a PaddleX result object into its plain result mapping.""" + candidate: object = item + if not isinstance(candidate, dict): + candidate = getattr(item, "json", None) + if not isinstance(candidate, dict): + return None + nested = candidate.get("res") + return nested if isinstance(nested, dict) else candidate + + +def _script_score(recognition: Recognition) -> float: + """Score copied verbatim from the Space's app.py ``_script_score``. + + The Sirijonga bonus (0.06/char, capped at 12 chars) is larger than the + Devanagari one (0.035/char), so this rule leans towards Sirijonga on mixed + pages. Callers that know the script should pass it explicitly. + """ + text = recognition.text or "" + confidence = recognition.confidence if recognition.confidence is not None else 0.0 + limbu_chars = len(LIMBU_RE.findall(text)) + deva_chars = len(DEVANAGARI_RE.findall(text)) + if recognition.engine == "sirijonga": + return confidence + min(limbu_chars, 12) * 0.06 - min(deva_chars, 12) * 0.04 + if recognition.engine == "devanagari": + return confidence + min(deva_chars, 12) * 0.035 - min(limbu_chars, 12) * 0.08 + return confidence + + +def _recognize_batch(engine: str, crops: list[np.ndarray]) -> list[Recognition]: + """Run one recognizer over a list of BGR crops, preserving input order.""" + if not crops: + return [] + predictor = ENGINES.recognizers.get(engine) + if predictor is None: + raise OcrError(f"recognizer '{engine}' is not loaded", 503) + raw = list(predictor.predict(crops, batch_size=RECOGNIZER_BATCH_SIZE)) + if len(raw) != len(crops): + raise OcrError( + f"recognizer '{engine}' returned {len(raw)} results for {len(crops)} crops", + 500, + ) + results: list[Recognition] = [] + for item in raw: + payload = _payload(item) + if payload is None: + results.append(Recognition(text="", confidence=None, engine=engine)) + continue + text = payload.get("rec_text") or payload.get("text") or "" + score = payload.get("rec_score") + if score is None: + score = payload.get("score") + confidence: float | None + try: + confidence = float(score) if score is not None else None + except (TypeError, ValueError): + confidence = None + results.append(Recognition(text=str(text).strip(), confidence=confidence, engine=engine)) + return results + + +def _recognize_routed(crops: list[np.ndarray], script: str) -> list[Recognition]: + """Recognize crops under the requested script routing. + + ``auto`` reproduces the Space: both engines run and the higher ``_script_score`` + wins, with ties going to Sirijonga. The Devanagari pass is skipped for crops + whose Sirijonga score already exceeds every score Devanagari could reach. + """ + if script in ("sirijonga", "devanagari"): + return _recognize_batch(script, crops) + + sirijonga = _recognize_batch("sirijonga", crops) + scores = [_script_score(rec) for rec in sirijonga] + pending = [i for i, score in enumerate(scores) if score < MAX_DEVANAGARI_SCRIPT_SCORE] + if not pending: + return sirijonga + devanagari = _recognize_batch("devanagari", [crops[i] for i in pending]) + selected = list(sirijonga) + for index, candidate in zip(pending, devanagari, strict=True): + if _script_score(candidate) > scores[index]: + selected[index] = candidate + return selected + + +def _to_bgr(image: Image.Image) -> np.ndarray: + """PIL RGB image -> contiguous BGR ndarray, the layout PaddleX expects.""" + return np.asarray(image)[:, :, ::-1].copy() + + +def _box_from_polygon(polygon: object, *, width: int, height: int, confidence: float) -> Box | None: + array = np.asarray(polygon, dtype=np.float64).reshape(-1, 2) + if array.size == 0: + return None + box = Box( + left=max(0, int(math.floor(float(array[:, 0].min())))), + top=max(0, int(math.floor(float(array[:, 1].min())))), + right=min(width, int(math.ceil(float(array[:, 0].max())))), + bottom=min(height, int(math.ceil(float(array[:, 1].max())))), + confidence=confidence, + ) + return box if box.width > 0 and box.height > 0 else None + + +def _detect_boxes(image: Image.Image) -> list[Box]: + """Full-page text detection -> axis-aligned line boxes.""" + if ENGINES.detector is None: + raise OcrError("text detector is not loaded", 503) + raw = list(ENGINES.detector.predict(_to_bgr(image))) + boxes: list[Box] = [] + for item in raw: + payload = _payload(item) + if payload is None: + continue + polygons = payload.get("dt_polys") + if polygons is None: + continue + # dt_scores comes back as an ndarray, so never use truthiness on it. + scores = payload.get("dt_scores") + if scores is None: + scores = [] + for index, polygon in enumerate(polygons): + confidence = 1.0 + if index < len(scores) and scores[index] is not None: + try: + confidence = float(scores[index]) + except (TypeError, ValueError): + confidence = 1.0 + box = _box_from_polygon( + polygon, width=image.width, height=image.height, confidence=confidence + ) + if box is not None: + boxes.append(box) + return boxes + + +def _has_two_column_shape(boxes: list[Box], image_width: int) -> bool: + """Copied from the Space's app.py.""" + if len(boxes) < 8 or image_width <= 0: + return False + midpoint = image_width / 2.0 + left = [box for box in boxes if box.x_center < midpoint] + right = [box for box in boxes if box.x_center >= midpoint] + if len(left) < 3 or len(right) < 3: + return False + left_median = float(np.median([box.x_center for box in left])) + right_median = float(np.median([box.x_center for box in right])) + return (right_median - left_median) >= image_width * 0.22 + + +def _order_boxes(boxes: list[Box], mode: str, image_width: int) -> list[Box]: + """Copied from the Space's app.py ``_order_image_line_boxes``.""" + if mode == "Auto": + mode = "Columns LTR" if _has_two_column_shape(boxes, image_width) else "Rows LTR" + if mode == "Columns LTR": + return sorted( + boxes, + key=lambda box: (0 if box.x_center < image_width / 2 else 1, box.y_center, box.x_center), + ) + if mode == "Columns RTL": + return sorted( + boxes, + key=lambda box: (0 if box.x_center >= image_width / 2 else 1, box.y_center, box.x_center), + ) + row_height = max(12, int(np.median([box.height for box in boxes])) if boxes else 24) + return sorted(boxes, key=lambda box: (math.floor(box.y_center / row_height), box.x_center)) + + +def _crop(image: Image.Image, box: Box, padding: int) -> Image.Image: + return image.crop( + ( + max(0, box.left - padding), + max(0, box.top - padding), + min(image.width, box.right + padding), + min(image.height, box.bottom + padding), + ) + ) + + +def _overlay_png_b64(image: Image.Image, boxes: list[Box]) -> str: + """Draw the ordered boxes on the page and return a base64 PNG.""" + annotated = image.copy() + draw = ImageDraw.Draw(annotated) + for index, box in enumerate(boxes, start=1): + draw.rectangle( + (box.left, box.top, box.right, box.bottom), outline=(28, 120, 92), width=3 + ) + draw.text((box.left + 4, max(0, box.top - 12)), str(index), fill=(28, 120, 92)) + longest = max(annotated.size) + if longest > OVERLAY_MAX_SIDE: + scale = OVERLAY_MAX_SIDE / longest + annotated = annotated.resize( + (max(1, round(annotated.width * scale)), max(1, round(annotated.height * scale))), + Image.LANCZOS, + ) + buffer = io.BytesIO() + annotated.save(buffer, format="PNG", optimize=True) + return base64.b64encode(buffer.getvalue()).decode("ascii") + + +def _decode_image(raw: bytes) -> Image.Image: + """Validate and normalize an uploaded image; downscale the longest side.""" + try: + probe = Image.open(io.BytesIO(raw)) + image_format = probe.format + probe.load() + image = ImageOps.exif_transpose(probe).convert("RGB") + probe.close() + except UnidentifiedImageError as exc: + raise OcrError("file is not a decodable image", 400) from exc + except (OSError, ValueError) as exc: + raise OcrError(f"could not decode image: {exc}", 400) from exc + if image_format not in SUPPORTED_IMAGE_FORMATS: + raise OcrError( + f"unsupported image format {image_format!r}; expected one of " + + ", ".join(sorted(SUPPORTED_IMAGE_FORMATS)), + 415, + ) + longest = max(image.size) + if longest > MAX_IMAGE_SIDE: + scale = MAX_IMAGE_SIDE / longest + image = image.resize( + (max(1, round(image.width * scale)), max(1, round(image.height * scale))), + Image.LANCZOS, + ) + if image.width < 4 or image.height < 4: + raise OcrError("image is too small to recognize", 400) + return image + + +def _resolved_script(recognitions: list[Recognition], requested: str) -> str: + if requested in ("sirijonga", "devanagari"): + return requested + engines = [rec.engine for rec in recognitions if rec.text] + if not engines: + return "sirijonga" + return max(set(engines), key=engines.count) + + +def _run_line(image: Image.Image, script: str) -> dict[str, Any]: + crops = [_to_bgr(image)] + with ENGINES.lock: + recognitions = _recognize_routed(crops, script) + recognition = recognitions[0] + line = { + "text": recognition.text, + "confidence": recognition.confidence, + "box": [0, 0, image.width, image.height], + "script": recognition.engine, + } + return { + "text": recognition.text, + "lines": [line], + "script": _resolved_script(recognitions, script), + "truncated": False, + "overlay_png_b64": None, + } + + +def _run_page(image: Image.Image, script: str) -> dict[str, Any]: + with ENGINES.lock: + boxes = _detect_boxes(image) + ordered = _order_boxes(boxes, READING_ORDER, image.width) + truncated = MAX_LINES > 0 and len(ordered) > MAX_LINES + if truncated: + LOGGER.warning( + "page has %d detected lines, truncating to AMPIXA_OCR_MAX_LINES=%d", + len(ordered), + MAX_LINES, + ) + ordered = ordered[:MAX_LINES] + crops = [_to_bgr(_crop(image, box, CROP_PADDING)) for box in ordered] + recognitions = _recognize_routed(crops, script) + overlay = _overlay_png_b64(image, ordered) + + lines: list[dict[str, Any]] = [] + texts: list[str] = [] + for box, recognition in zip(ordered, recognitions, strict=True): + lines.append( + { + "text": recognition.text, + "confidence": recognition.confidence, + "box": box.as_list(), + "script": recognition.engine, + } + ) + if recognition.text: + texts.append(recognition.text) + return { + "text": "\n".join(texts), + "lines": lines, + "script": _resolved_script(recognitions, script), + "truncated": truncated, + "overlay_png_b64": overlay, + } + + +@asynccontextmanager +async def _lifespan(_app: FastAPI) -> AsyncIterator[None]: + """Serve /health immediately; build the Paddle predictors in the background.""" + LOGGER.info( + "starting OCR worker: model_root=%s detector=%s (%s/%d) max_lines=%d", + MODEL_ROOT, + DETECTOR_MODEL_NAME, + DETECTOR_LIMIT_TYPE, + DETECTOR_LIMIT_SIDE_LEN, + MAX_LINES, + ) + loader = threading.Thread(target=ENGINES.load, name="ocr-model-load", daemon=True) + loader.start() + yield + LOGGER.info("OCR worker shutting down") + + +app = FastAPI(title="Ampixa OCR worker", docs_url=None, redoc_url=None, lifespan=_lifespan) + + +@app.exception_handler(OcrError) +async def _ocr_error_handler(_request: Request, exc: OcrError) -> JSONResponse: + return JSONResponse(status_code=exc.status_code, content={"error": exc.message}) + + +@app.exception_handler(RequestValidationError) +async def _validation_error_handler( + _request: Request, exc: RequestValidationError +) -> JSONResponse: + """Report malformed multipart bodies as {"error": ...} instead of FastAPI's 422.""" + problems = "; ".join( + f"{'.'.join(str(part) for part in error.get('loc', ()))}: {error.get('msg', 'invalid')}" + for error in exc.errors() + ) + return JSONResponse(status_code=400, content={"error": f"invalid request: {problems}"}) + + +@app.exception_handler(StarletteHTTPException) +async def _http_error_handler(_request: Request, exc: StarletteHTTPException) -> JSONResponse: + """Keep 404/405 and friends on the {"error": ...} contract.""" + return JSONResponse(status_code=exc.status_code, content={"error": str(exc.detail)}) + + +@app.exception_handler(Exception) +async def _unhandled_error_handler(_request: Request, exc: Exception) -> JSONResponse: + """Last resort: log the traceback, return JSON, never a bare stack trace.""" + LOGGER.error("unhandled error: %s\n%s", exc, traceback.format_exc()) + return JSONResponse( + status_code=500, content={"error": f"internal error: {type(exc).__name__}"} + ) + + +@app.get("/health") +def health() -> JSONResponse: + body: dict[str, Any] = { + "ok": ENGINES.load_error is None, + "worker": WORKER_NAME, + "loaded": ENGINES.loaded, + "models": { + "sirijonga": str(SIRIJONGA_MODEL_DIR), + "devanagari": str(DEVANAGARI_MODEL_DIR), + "recognizer_model_name": RECOGNIZER_MODEL_NAME, + "detector_model_name": DETECTOR_MODEL_NAME, + "detector_limit": f"{DETECTOR_LIMIT_TYPE}/{DETECTOR_LIMIT_SIDE_LEN}", + "max_lines": MAX_LINES, + "max_image_side": MAX_IMAGE_SIDE, + "load_seconds": round(ENGINES.load_seconds, 2) if ENGINES.load_seconds else None, + }, + "device": "cpu", + } + if ENGINES.load_error is not None: + body["error"] = ENGINES.load_error + return JSONResponse(status_code=503, content=body) + return JSONResponse(status_code=200, content=body) + + +@app.post("/recognize") +async def recognize( + file: UploadFile = File(...), + mode: str = Form("page"), + script: str = Form("auto"), +) -> JSONResponse: + started = time.perf_counter() + mode = (mode or "page").strip().lower() + script = (script or "auto").strip().lower() + if mode not in SUPPORTED_MODES: + raise OcrError(f"mode must be one of {', '.join(SUPPORTED_MODES)}", 400) + if script not in SUPPORTED_SCRIPTS: + raise OcrError(f"script must be one of {', '.join(SUPPORTED_SCRIPTS)}", 400) + if not ENGINES.loaded: + if ENGINES.load_error is not None: + raise OcrError(f"OCR models failed to load: {ENGINES.load_error}", 503) + raise OcrError("OCR models are still loading", 503) + + try: + raw = await file.read() + except Exception as exc: # noqa: BLE001 - upload stream failures are client errors + LOGGER.error("upload read failed: %s\n%s", exc, traceback.format_exc()) + raise OcrError(f"could not read uploaded file: {exc}", 400) from exc + finally: + await file.close() + + if not raw: + raise OcrError("uploaded file is empty", 400) + if len(raw) > MAX_UPLOAD_BYTES: + raise OcrError( + f"image is {len(raw)} bytes, limit is {MAX_UPLOAD_BYTES} bytes", 413 + ) + + image = _decode_image(raw) + runner = _run_line if mode == "line" else _run_page + try: + result = await run_in_threadpool(runner, image, script) + except OcrError: + raise + except Exception as exc: # noqa: BLE001 - converted to a JSON 500 below + LOGGER.error( + "recognition failed mode=%s script=%s: %s\n%s", + mode, + script, + exc, + traceback.format_exc(), + ) + raise OcrError(f"recognition failed: {type(exc).__name__}: {exc}", 500) from exc + + elapsed = time.perf_counter() - started + LOGGER.info( + "recognize mode=%s script=%s -> %s bytes=%d size=%dx%d lines=%d truncated=%s chars=%d %.2fs", + mode, + script, + result["script"], + len(raw), + image.width, + image.height, + len(result["lines"]), + result["truncated"], + len(result["text"]), + elapsed, + ) + return JSONResponse( + status_code=200, + content={ + "text": result["text"], + "lines": result["lines"], + "script": result["script"], + "mode": mode, + "elapsed_s": round(elapsed, 3), + "image_size": [image.width, image.height], + "truncated": result["truncated"], + "overlay_png_b64": result["overlay_png_b64"], + }, + ) + + +def main() -> int: + parser = argparse.ArgumentParser(description="Ampixa OCR worker (Limbu Sirijonga + Devanagari)") + parser.add_argument("--host", default=DEFAULT_HOST) + parser.add_argument("--port", type=int, default=DEFAULT_PORT) + args = parser.parse_args() + logging.basicConfig( + level=logging.INFO, + format="%(asctime)s %(levelname)s %(name)s %(message)s", + stream=sys.stdout, + ) + uvicorn.run(app, host=args.host, port=args.port, log_level="info", access_log=False) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/k2-ampixa-demo-ocr/workers-ocr/server.py.bak-20260924-ft-v2 b/k2-ampixa-demo-ocr/workers-ocr/server.py.bak-20260924-ft-v2 new file mode 100644 index 0000000000000000000000000000000000000000..e488201e6f01313b119ff3a1dabf642c2ec29a8e --- /dev/null +++ b/k2-ampixa-demo-ocr/workers-ocr/server.py.bak-20260924-ft-v2 @@ -0,0 +1,715 @@ +"""Ampixa OCR worker: Limbu Sirijonga + Devanagari OCR on CPU via PaddleOCR. + +Ported from the non-Gradio inference paths of the private Hugging Face Space +``ampixa/limbu-ocr`` (``app.py``, sha256 cffc507fd79f1ee31b6469315c92ff6b8e2360affe617ae8e2f8fa709b92fa01). + +Two routes are exposed: + +``line`` + The uploaded image is treated as a single cropped text line and sent + straight to the recognizer(s). + +``page`` + PaddleOCR full-page text detection produces line boxes, the boxes are put + into reading order, every crop is recognized, and a PNG overlay with the + boxes drawn on it is returned alongside the text. + +Everything runs on CPU: paddlepaddle has no Metal/MPS backend on macOS arm64. +""" + +from __future__ import annotations + +import argparse +import base64 +import io +import logging +import math +import os +import re +import sys +import threading +import time +import traceback +from collections.abc import AsyncIterator +from contextlib import asynccontextmanager +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +import numpy as np +import uvicorn +from fastapi import FastAPI, File, Form, Request, UploadFile +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse +from paddleocr import TextDetection +from paddleocr._models.text_recognition import TextRecognition +from paddlex import create_model +from PIL import Image, ImageDraw, ImageOps, UnidentifiedImageError +from starlette.concurrency import run_in_threadpool +from starlette.exceptions import HTTPException as StarletteHTTPException + +WORKER_NAME = "ocr" +DEFAULT_HOST = os.environ.get("AMPIXA_OCR_HOST", "127.0.0.1") +DEFAULT_PORT = int(os.environ.get("AMPIXA_OCR_PORT", "8906")) + +MODEL_ROOT = Path( + os.environ.get( + "AMPIXA_OCR_MODEL_ROOT", + str(Path.home() / "ampixa-demo" / "models" / "ocr" / "space" / "models"), + ) +).expanduser() +SIRIJONGA_MODEL_DIR = MODEL_ROOT / "limbu-sirijonga-ft-v2" / "artifacts" +# devanagari-ft-v2 (2026-09-24): official PaddleOCR devanagari_PP-OCRv5_mobile_rec fine-tuned +# on real Gorkhapatra print, synthetic citizenship/office lines, and English replay; served as +# ONNX (see ../models/.../devanagari-ft-v2/MODEL-SOURCE.txt). Same 568-entry dictionary +# (Devanagari + all Latin letters + 0-9). Roll back to the official model by pointing +# AMPIXA_OCR_DEVANAGARI_DIR at devanagari-ppocrv5/artifacts. +DEVANAGARI_MODEL_DIR = Path( + os.environ.get("AMPIXA_OCR_DEVANAGARI_DIR", str(MODEL_ROOT / "devanagari-ft-v2" / "artifacts")) +).expanduser() + +# The PP-OCRv5 recognizer packs live under model_dir; the character dictionary is +# embedded in inference.yml (PostProcess.character_dict), so the standalone .txt +# dictionaries shipped next to them are documentation only and are not loaded. +# Each model_name must match Global.model_name in that model's inference.yml. +SIRIJONGA_MODEL_NAME = "PP-OCRv5_mobile_rec" +DEVANAGARI_MODEL_NAME = "devanagari_PP-OCRv5_mobile_rec" +REQUIRED_RECOGNIZER_FILES = ("inference.json", "inference.pdiparams", "inference.yml") +# A directory holding inference.onnx (tools/deva_rec_torch/export_onnx.py output) is served +# through PaddleX's onnxruntime engine with the same pre/post-processing as Paddle. +REQUIRED_ONNX_FILES = ("inference.onnx", "inference.yml") + + +def recognizer_engine(model_dir: Path) -> str: + return "onnxruntime" if (model_dir / "inference.onnx").is_file() else "paddle_static" + +MAX_UPLOAD_BYTES = 10 * 1024 * 1024 +MAX_IMAGE_SIDE = 2000 +OVERLAY_MAX_SIDE = int(os.environ.get("AMPIXA_OCR_OVERLAY_MAX_SIDE", "1400")) +MAX_LINES = int(os.environ.get("AMPIXA_OCR_MAX_LINES", "120")) +RECOGNIZER_BATCH_SIZE = int(os.environ.get("AMPIXA_OCR_REC_BATCH_SIZE", "16")) + +# Detector settings. The Space leaves limit_type at the PaddleX default ("min"), +# which upscales every page so its *shortest* side is >= limit_side_len and costs +# ~8 s per page on this host. "max" bounds the *longest* side instead: 2.4x faster +# on a full newspaper page for the same box count (303 vs 305 boxes measured). +DETECTOR_LIMIT_SIDE_LEN = int(os.environ.get("AMPIXA_OCR_DET_LIMIT_SIDE_LEN", "1280")) +DETECTOR_LIMIT_TYPE = os.environ.get("AMPIXA_OCR_DET_LIMIT_TYPE", "max") +DETECTOR_THRESH = float(os.environ.get("AMPIXA_OCR_DET_THRESH", "0.30")) +DETECTOR_BOX_THRESH = float(os.environ.get("AMPIXA_OCR_DET_BOX_THRESH", "0.60")) +DETECTOR_UNCLIP_RATIO = float(os.environ.get("AMPIXA_OCR_DET_UNCLIP_RATIO", "1.5")) +DETECTOR_MODEL_NAME = "PP-OCRv6_medium_det" # PaddleOCR 3.7.0 default text detector. + +CROP_PADDING = 12 # Space default for the Paddle page tab. +READING_ORDER = "Rows LTR" # Space default for the Paddle page tab. + +SUPPORTED_MODES = ("line", "page") +SUPPORTED_SCRIPTS = ("auto", "sirijonga", "devanagari") +SUPPORTED_IMAGE_FORMATS = {"PNG": "image/png", "JPEG": "image/jpeg", "WEBP": "image/webp"} + +LIMBU_RE = re.compile("[\u1900-\u194F]") +DEVANAGARI_RE = re.compile("[\u0900-\u097F]") + +# Upper bound of _script_score() for a Devanagari candidate: rec_score is a +# probability (<= 1.0) and the Devanagari bonus saturates at 12 * 0.035. If the +# Sirijonga candidate already scores at least this much, the Devanagari pass +# cannot change the outcome and is skipped. This is an exact prune, not an +# approximation: it never changes the selected text. +MAX_DEVANAGARI_SCRIPT_SCORE = 1.0 + 0.035 * 12 + +LOGGER = logging.getLogger("ampixa.ocr") + + +@dataclass(slots=True) +class Recognition: + """One recognizer output for one crop.""" + + text: str + confidence: float | None + engine: str + + +@dataclass(slots=True) +class Box: + """Axis-aligned line box in processed-image pixel coordinates.""" + + left: int + top: int + right: int + bottom: int + confidence: float + + @property + def width(self) -> int: + return max(0, self.right - self.left) + + @property + def height(self) -> int: + return max(0, self.bottom - self.top) + + @property + def x_center(self) -> float: + return (self.left + self.right) / 2.0 + + @property + def y_center(self) -> float: + return (self.top + self.bottom) / 2.0 + + def as_list(self) -> list[int]: + return [self.left, self.top, self.right, self.bottom] + + +class OcrError(Exception): + """Client-visible OCR failure carrying an HTTP status code.""" + + def __init__(self, message: str, status_code: int) -> None: + super().__init__(message) + self.message = message + self.status_code = status_code + + +class Engines: + """Holds the Paddle predictors and serializes every call into them. + + Paddle predictors are not documented as thread-safe, and uvicorn runs request + handlers in a thread pool, so every predict() call goes through ``lock``. + """ + + def __init__(self) -> None: + self.lock = threading.Lock() + self.recognizers: dict[str, Any] = {} + self.detector: Any = None + self.loaded = False + self.load_seconds: float | None = None + self.load_error: str | None = None + + def ensure_model_files(self) -> None: + missing: list[str] = [] + for model_dir in (SIRIJONGA_MODEL_DIR, DEVANAGARI_MODEL_DIR): + required = REQUIRED_ONNX_FILES if recognizer_engine(model_dir) == "onnxruntime" else REQUIRED_RECOGNIZER_FILES + for name in required: + path = model_dir / name + if not path.is_file(): + missing.append(str(path)) + if missing: + raise RuntimeError("missing OCR model artifacts: " + ", ".join(missing)) + + def load(self) -> None: + """Build every predictor once. Called from a background thread at startup.""" + started = time.perf_counter() + try: + self.ensure_model_files() + for engine, model_name, model_dir in ( + ("sirijonga", SIRIJONGA_MODEL_NAME, SIRIJONGA_MODEL_DIR), + ("devanagari", DEVANAGARI_MODEL_NAME, DEVANAGARI_MODEL_DIR), + ): + step = time.perf_counter() + backend = recognizer_engine(model_dir) + if backend == "onnxruntime": + self.recognizers[engine] = create_model( + model_name=model_name, model_dir=str(model_dir), engine="onnxruntime", device="cpu" + ) + else: + self.recognizers[engine] = TextRecognition( + model_name=model_name, + model_dir=str(model_dir), + device="cpu", + ) + LOGGER.info( + "loaded recognizer engine=%s backend=%s model=%s dir=%s in %.2fs", + engine, + backend, + model_name, + model_dir, + time.perf_counter() - step, + ) + step = time.perf_counter() + self.detector = TextDetection( + limit_side_len=DETECTOR_LIMIT_SIDE_LEN, + limit_type=DETECTOR_LIMIT_TYPE, + thresh=DETECTOR_THRESH, + box_thresh=DETECTOR_BOX_THRESH, + unclip_ratio=DETECTOR_UNCLIP_RATIO, + device="cpu", + ) + LOGGER.info("loaded text detector in %.2fs", time.perf_counter() - step) + except Exception as exc: # noqa: BLE001 - recorded and surfaced through /health + self.load_error = f"{type(exc).__name__}: {exc}" + LOGGER.error("model load failed: %s\n%s", self.load_error, traceback.format_exc()) + return + self.load_seconds = time.perf_counter() - started + self.loaded = True + LOGGER.info("all OCR models loaded in %.2fs", self.load_seconds) + + +ENGINES = Engines() + + +def _payload(item: object) -> dict[str, Any] | None: + """Unwrap a PaddleX result object into its plain result mapping.""" + candidate: object = item + if not isinstance(candidate, dict): + candidate = getattr(item, "json", None) + if not isinstance(candidate, dict): + return None + nested = candidate.get("res") + return nested if isinstance(nested, dict) else candidate + + +def _script_score(recognition: Recognition) -> float: + """Score copied verbatim from the Space's app.py ``_script_score``. + + The Sirijonga bonus (0.06/char, capped at 12 chars) is larger than the + Devanagari one (0.035/char), so this rule leans towards Sirijonga on mixed + pages. Callers that know the script should pass it explicitly. + """ + text = recognition.text or "" + confidence = recognition.confidence if recognition.confidence is not None else 0.0 + limbu_chars = len(LIMBU_RE.findall(text)) + deva_chars = len(DEVANAGARI_RE.findall(text)) + if recognition.engine == "sirijonga": + return confidence + min(limbu_chars, 12) * 0.06 - min(deva_chars, 12) * 0.04 + if recognition.engine == "devanagari": + return confidence + min(deva_chars, 12) * 0.035 - min(limbu_chars, 12) * 0.08 + return confidence + + +def _recognize_batch(engine: str, crops: list[np.ndarray]) -> list[Recognition]: + """Run one recognizer over a list of BGR crops, preserving input order.""" + if not crops: + return [] + predictor = ENGINES.recognizers.get(engine) + if predictor is None: + raise OcrError(f"recognizer '{engine}' is not loaded", 503) + raw = list(predictor.predict(crops, batch_size=RECOGNIZER_BATCH_SIZE)) + if len(raw) != len(crops): + raise OcrError( + f"recognizer '{engine}' returned {len(raw)} results for {len(crops)} crops", + 500, + ) + results: list[Recognition] = [] + for item in raw: + payload = _payload(item) + if payload is None: + results.append(Recognition(text="", confidence=None, engine=engine)) + continue + text = payload.get("rec_text") or payload.get("text") or "" + score = payload.get("rec_score") + if score is None: + score = payload.get("score") + confidence: float | None + try: + confidence = float(score) if score is not None else None + except (TypeError, ValueError): + confidence = None + results.append(Recognition(text=str(text).strip(), confidence=confidence, engine=engine)) + return results + + +def _recognize_routed(crops: list[np.ndarray], script: str) -> list[Recognition]: + """Recognize crops under the requested script routing. + + ``auto`` reproduces the Space: both engines run and the higher ``_script_score`` + wins, with ties going to Sirijonga. The Devanagari pass is skipped for crops + whose Sirijonga score already exceeds every score Devanagari could reach. + """ + if script in ("sirijonga", "devanagari"): + return _recognize_batch(script, crops) + + sirijonga = _recognize_batch("sirijonga", crops) + scores = [_script_score(rec) for rec in sirijonga] + pending = [i for i, score in enumerate(scores) if score < MAX_DEVANAGARI_SCRIPT_SCORE] + if not pending: + return sirijonga + devanagari = _recognize_batch("devanagari", [crops[i] for i in pending]) + selected = list(sirijonga) + for index, candidate in zip(pending, devanagari, strict=True): + if _script_score(candidate) > scores[index]: + selected[index] = candidate + return selected + + +def _to_bgr(image: Image.Image) -> np.ndarray: + """PIL RGB image -> contiguous BGR ndarray, the layout PaddleX expects.""" + return np.asarray(image)[:, :, ::-1].copy() + + +def _box_from_polygon(polygon: object, *, width: int, height: int, confidence: float) -> Box | None: + array = np.asarray(polygon, dtype=np.float64).reshape(-1, 2) + if array.size == 0: + return None + box = Box( + left=max(0, int(math.floor(float(array[:, 0].min())))), + top=max(0, int(math.floor(float(array[:, 1].min())))), + right=min(width, int(math.ceil(float(array[:, 0].max())))), + bottom=min(height, int(math.ceil(float(array[:, 1].max())))), + confidence=confidence, + ) + return box if box.width > 0 and box.height > 0 else None + + +def _detect_boxes(image: Image.Image) -> list[Box]: + """Full-page text detection -> axis-aligned line boxes.""" + if ENGINES.detector is None: + raise OcrError("text detector is not loaded", 503) + raw = list(ENGINES.detector.predict(_to_bgr(image))) + boxes: list[Box] = [] + for item in raw: + payload = _payload(item) + if payload is None: + continue + polygons = payload.get("dt_polys") + if polygons is None: + continue + # dt_scores comes back as an ndarray, so never use truthiness on it. + scores = payload.get("dt_scores") + if scores is None: + scores = [] + for index, polygon in enumerate(polygons): + confidence = 1.0 + if index < len(scores) and scores[index] is not None: + try: + confidence = float(scores[index]) + except (TypeError, ValueError): + confidence = 1.0 + box = _box_from_polygon( + polygon, width=image.width, height=image.height, confidence=confidence + ) + if box is not None: + boxes.append(box) + return boxes + + +def _has_two_column_shape(boxes: list[Box], image_width: int) -> bool: + """Copied from the Space's app.py.""" + if len(boxes) < 8 or image_width <= 0: + return False + midpoint = image_width / 2.0 + left = [box for box in boxes if box.x_center < midpoint] + right = [box for box in boxes if box.x_center >= midpoint] + if len(left) < 3 or len(right) < 3: + return False + left_median = float(np.median([box.x_center for box in left])) + right_median = float(np.median([box.x_center for box in right])) + return (right_median - left_median) >= image_width * 0.22 + + +def _order_boxes(boxes: list[Box], mode: str, image_width: int) -> list[Box]: + """Copied from the Space's app.py ``_order_image_line_boxes``.""" + if mode == "Auto": + mode = "Columns LTR" if _has_two_column_shape(boxes, image_width) else "Rows LTR" + if mode == "Columns LTR": + return sorted( + boxes, + key=lambda box: (0 if box.x_center < image_width / 2 else 1, box.y_center, box.x_center), + ) + if mode == "Columns RTL": + return sorted( + boxes, + key=lambda box: (0 if box.x_center >= image_width / 2 else 1, box.y_center, box.x_center), + ) + row_height = max(12, int(np.median([box.height for box in boxes])) if boxes else 24) + return sorted(boxes, key=lambda box: (math.floor(box.y_center / row_height), box.x_center)) + + +def _crop(image: Image.Image, box: Box, padding: int) -> Image.Image: + return image.crop( + ( + max(0, box.left - padding), + max(0, box.top - padding), + min(image.width, box.right + padding), + min(image.height, box.bottom + padding), + ) + ) + + +def _overlay_png_b64(image: Image.Image, boxes: list[Box]) -> str: + """Draw the ordered boxes on the page and return a base64 PNG.""" + annotated = image.copy() + draw = ImageDraw.Draw(annotated) + for index, box in enumerate(boxes, start=1): + draw.rectangle( + (box.left, box.top, box.right, box.bottom), outline=(28, 120, 92), width=3 + ) + draw.text((box.left + 4, max(0, box.top - 12)), str(index), fill=(28, 120, 92)) + longest = max(annotated.size) + if longest > OVERLAY_MAX_SIDE: + scale = OVERLAY_MAX_SIDE / longest + annotated = annotated.resize( + (max(1, round(annotated.width * scale)), max(1, round(annotated.height * scale))), + Image.LANCZOS, + ) + buffer = io.BytesIO() + annotated.save(buffer, format="PNG", optimize=True) + return base64.b64encode(buffer.getvalue()).decode("ascii") + + +def _decode_image(raw: bytes) -> Image.Image: + """Validate and normalize an uploaded image; downscale the longest side.""" + try: + probe = Image.open(io.BytesIO(raw)) + image_format = probe.format + probe.load() + image = ImageOps.exif_transpose(probe).convert("RGB") + probe.close() + except UnidentifiedImageError as exc: + raise OcrError("file is not a decodable image", 400) from exc + except (OSError, ValueError) as exc: + raise OcrError(f"could not decode image: {exc}", 400) from exc + if image_format not in SUPPORTED_IMAGE_FORMATS: + raise OcrError( + f"unsupported image format {image_format!r}; expected one of " + + ", ".join(sorted(SUPPORTED_IMAGE_FORMATS)), + 415, + ) + longest = max(image.size) + if longest > MAX_IMAGE_SIDE: + scale = MAX_IMAGE_SIDE / longest + image = image.resize( + (max(1, round(image.width * scale)), max(1, round(image.height * scale))), + Image.LANCZOS, + ) + if image.width < 4 or image.height < 4: + raise OcrError("image is too small to recognize", 400) + return image + + +def _resolved_script(recognitions: list[Recognition], requested: str) -> str: + if requested in ("sirijonga", "devanagari"): + return requested + engines = [rec.engine for rec in recognitions if rec.text] + if not engines: + return "sirijonga" + return max(set(engines), key=engines.count) + + +def _run_line(image: Image.Image, script: str) -> dict[str, Any]: + crops = [_to_bgr(image)] + with ENGINES.lock: + recognitions = _recognize_routed(crops, script) + recognition = recognitions[0] + line = { + "text": recognition.text, + "confidence": recognition.confidence, + "box": [0, 0, image.width, image.height], + "script": recognition.engine, + } + return { + "text": recognition.text, + "lines": [line], + "script": _resolved_script(recognitions, script), + "truncated": False, + "overlay_png_b64": None, + } + + +def _run_page(image: Image.Image, script: str) -> dict[str, Any]: + with ENGINES.lock: + boxes = _detect_boxes(image) + ordered = _order_boxes(boxes, READING_ORDER, image.width) + truncated = MAX_LINES > 0 and len(ordered) > MAX_LINES + if truncated: + LOGGER.warning( + "page has %d detected lines, truncating to AMPIXA_OCR_MAX_LINES=%d", + len(ordered), + MAX_LINES, + ) + ordered = ordered[:MAX_LINES] + crops = [_to_bgr(_crop(image, box, CROP_PADDING)) for box in ordered] + recognitions = _recognize_routed(crops, script) + overlay = _overlay_png_b64(image, ordered) + + lines: list[dict[str, Any]] = [] + texts: list[str] = [] + for box, recognition in zip(ordered, recognitions, strict=True): + lines.append( + { + "text": recognition.text, + "confidence": recognition.confidence, + "box": box.as_list(), + "script": recognition.engine, + } + ) + if recognition.text: + texts.append(recognition.text) + return { + "text": "\n".join(texts), + "lines": lines, + "script": _resolved_script(recognitions, script), + "truncated": truncated, + "overlay_png_b64": overlay, + } + + +@asynccontextmanager +async def _lifespan(_app: FastAPI) -> AsyncIterator[None]: + """Serve /health immediately; build the Paddle predictors in the background.""" + LOGGER.info( + "starting OCR worker: model_root=%s detector=%s (%s/%d) max_lines=%d", + MODEL_ROOT, + DETECTOR_MODEL_NAME, + DETECTOR_LIMIT_TYPE, + DETECTOR_LIMIT_SIDE_LEN, + MAX_LINES, + ) + loader = threading.Thread(target=ENGINES.load, name="ocr-model-load", daemon=True) + loader.start() + yield + LOGGER.info("OCR worker shutting down") + + +app = FastAPI(title="Ampixa OCR worker", docs_url=None, redoc_url=None, lifespan=_lifespan) + + +@app.exception_handler(OcrError) +async def _ocr_error_handler(_request: Request, exc: OcrError) -> JSONResponse: + return JSONResponse(status_code=exc.status_code, content={"error": exc.message}) + + +@app.exception_handler(RequestValidationError) +async def _validation_error_handler( + _request: Request, exc: RequestValidationError +) -> JSONResponse: + """Report malformed multipart bodies as {"error": ...} instead of FastAPI's 422.""" + problems = "; ".join( + f"{'.'.join(str(part) for part in error.get('loc', ()))}: {error.get('msg', 'invalid')}" + for error in exc.errors() + ) + return JSONResponse(status_code=400, content={"error": f"invalid request: {problems}"}) + + +@app.exception_handler(StarletteHTTPException) +async def _http_error_handler(_request: Request, exc: StarletteHTTPException) -> JSONResponse: + """Keep 404/405 and friends on the {"error": ...} contract.""" + return JSONResponse(status_code=exc.status_code, content={"error": str(exc.detail)}) + + +@app.exception_handler(Exception) +async def _unhandled_error_handler(_request: Request, exc: Exception) -> JSONResponse: + """Last resort: log the traceback, return JSON, never a bare stack trace.""" + LOGGER.error("unhandled error: %s\n%s", exc, traceback.format_exc()) + return JSONResponse( + status_code=500, content={"error": f"internal error: {type(exc).__name__}"} + ) + + +@app.get("/health") +def health() -> JSONResponse: + body: dict[str, Any] = { + "ok": ENGINES.load_error is None, + "worker": WORKER_NAME, + "loaded": ENGINES.loaded, + "models": { + "sirijonga": str(SIRIJONGA_MODEL_DIR), + "devanagari": str(DEVANAGARI_MODEL_DIR), + "sirijonga_model_name": SIRIJONGA_MODEL_NAME, + "devanagari_model_name": DEVANAGARI_MODEL_NAME, + "devanagari_backend": recognizer_engine(DEVANAGARI_MODEL_DIR), + "detector_model_name": DETECTOR_MODEL_NAME, + "detector_limit": f"{DETECTOR_LIMIT_TYPE}/{DETECTOR_LIMIT_SIDE_LEN}", + "max_lines": MAX_LINES, + "max_image_side": MAX_IMAGE_SIDE, + "load_seconds": round(ENGINES.load_seconds, 2) if ENGINES.load_seconds else None, + }, + "device": "cpu", + } + if ENGINES.load_error is not None: + body["error"] = ENGINES.load_error + return JSONResponse(status_code=503, content=body) + return JSONResponse(status_code=200, content=body) + + +@app.post("/recognize") +async def recognize( + file: UploadFile = File(...), + mode: str = Form("page"), + script: str = Form("auto"), +) -> JSONResponse: + started = time.perf_counter() + mode = (mode or "page").strip().lower() + script = (script or "auto").strip().lower() + if mode not in SUPPORTED_MODES: + raise OcrError(f"mode must be one of {', '.join(SUPPORTED_MODES)}", 400) + if script not in SUPPORTED_SCRIPTS: + raise OcrError(f"script must be one of {', '.join(SUPPORTED_SCRIPTS)}", 400) + if not ENGINES.loaded: + if ENGINES.load_error is not None: + raise OcrError(f"OCR models failed to load: {ENGINES.load_error}", 503) + raise OcrError("OCR models are still loading", 503) + + try: + raw = await file.read() + except Exception as exc: # noqa: BLE001 - upload stream failures are client errors + LOGGER.error("upload read failed: %s\n%s", exc, traceback.format_exc()) + raise OcrError(f"could not read uploaded file: {exc}", 400) from exc + finally: + await file.close() + + if not raw: + raise OcrError("uploaded file is empty", 400) + if len(raw) > MAX_UPLOAD_BYTES: + raise OcrError( + f"image is {len(raw)} bytes, limit is {MAX_UPLOAD_BYTES} bytes", 413 + ) + + image = _decode_image(raw) + runner = _run_line if mode == "line" else _run_page + try: + result = await run_in_threadpool(runner, image, script) + except OcrError: + raise + except Exception as exc: # noqa: BLE001 - converted to a JSON 500 below + LOGGER.error( + "recognition failed mode=%s script=%s: %s\n%s", + mode, + script, + exc, + traceback.format_exc(), + ) + raise OcrError(f"recognition failed: {type(exc).__name__}: {exc}", 500) from exc + + elapsed = time.perf_counter() - started + LOGGER.info( + "recognize mode=%s script=%s -> %s bytes=%d size=%dx%d lines=%d truncated=%s chars=%d %.2fs", + mode, + script, + result["script"], + len(raw), + image.width, + image.height, + len(result["lines"]), + result["truncated"], + len(result["text"]), + elapsed, + ) + return JSONResponse( + status_code=200, + content={ + "text": result["text"], + "lines": result["lines"], + "script": result["script"], + "mode": mode, + "elapsed_s": round(elapsed, 3), + "image_size": [image.width, image.height], + "truncated": result["truncated"], + "overlay_png_b64": result["overlay_png_b64"], + }, + ) + + +def main() -> int: + parser = argparse.ArgumentParser(description="Ampixa OCR worker (Limbu Sirijonga + Devanagari)") + parser.add_argument("--host", default=DEFAULT_HOST) + parser.add_argument("--port", type=int, default=DEFAULT_PORT) + args = parser.parse_args() + logging.basicConfig( + level=logging.INFO, + format="%(asctime)s %(levelname)s %(name)s %(message)s", + stream=sys.stdout, + ) + uvicorn.run(app, host=args.host, port=args.port, log_level="info", access_log=False) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/k2-ampixa-demo-ocr/workers-ocr/server.py.bak-20260924-official-paddle b/k2-ampixa-demo-ocr/workers-ocr/server.py.bak-20260924-official-paddle new file mode 100644 index 0000000000000000000000000000000000000000..f3a415cacfa6f8ec49bb46a5aaa0ef0690313a27 --- /dev/null +++ b/k2-ampixa-demo-ocr/workers-ocr/server.py.bak-20260924-official-paddle @@ -0,0 +1,694 @@ +"""Ampixa OCR worker: Limbu Sirijonga + Devanagari OCR on CPU via PaddleOCR. + +Ported from the non-Gradio inference paths of the private Hugging Face Space +``ampixa/limbu-ocr`` (``app.py``, sha256 cffc507fd79f1ee31b6469315c92ff6b8e2360affe617ae8e2f8fa709b92fa01). + +Two routes are exposed: + +``line`` + The uploaded image is treated as a single cropped text line and sent + straight to the recognizer(s). + +``page`` + PaddleOCR full-page text detection produces line boxes, the boxes are put + into reading order, every crop is recognized, and a PNG overlay with the + boxes drawn on it is returned alongside the text. + +Everything runs on CPU: paddlepaddle has no Metal/MPS backend on macOS arm64. +""" + +from __future__ import annotations + +import argparse +import base64 +import io +import logging +import math +import os +import re +import sys +import threading +import time +import traceback +from collections.abc import AsyncIterator +from contextlib import asynccontextmanager +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +import numpy as np +import uvicorn +from fastapi import FastAPI, File, Form, Request, UploadFile +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse +from paddleocr import TextDetection +from paddleocr._models.text_recognition import TextRecognition +from PIL import Image, ImageDraw, ImageOps, UnidentifiedImageError +from starlette.concurrency import run_in_threadpool +from starlette.exceptions import HTTPException as StarletteHTTPException + +WORKER_NAME = "ocr" +DEFAULT_HOST = os.environ.get("AMPIXA_OCR_HOST", "127.0.0.1") +DEFAULT_PORT = int(os.environ.get("AMPIXA_OCR_PORT", "8906")) + +MODEL_ROOT = Path( + os.environ.get( + "AMPIXA_OCR_MODEL_ROOT", + str(Path.home() / "ampixa-demo" / "models" / "ocr" / "space" / "models"), + ) +).expanduser() +SIRIJONGA_MODEL_DIR = MODEL_ROOT / "limbu-sirijonga-ft-v2" / "artifacts" +# Official PaddleOCR devanagari_PP-OCRv5_mobile_rec (replaced deva-v2 on 2026-09-24). +# Its dictionary covers Devanagari plus all 52 Latin letters and 0-9, so mixed +# Nepali/English lines are readable; deva-v2 had only 28 Latin letters and 5 digits. +DEVANAGARI_MODEL_DIR = MODEL_ROOT / "devanagari-ppocrv5" / "artifacts" + +# The PP-OCRv5 recognizer packs live under model_dir; the character dictionary is +# embedded in inference.yml (PostProcess.character_dict), so the standalone .txt +# dictionaries shipped next to them are documentation only and are not loaded. +# Each model_name must match Global.model_name in that model's inference.yml. +SIRIJONGA_MODEL_NAME = "PP-OCRv5_mobile_rec" +DEVANAGARI_MODEL_NAME = "devanagari_PP-OCRv5_mobile_rec" +REQUIRED_RECOGNIZER_FILES = ("inference.json", "inference.pdiparams", "inference.yml") + +MAX_UPLOAD_BYTES = 10 * 1024 * 1024 +MAX_IMAGE_SIDE = 2000 +OVERLAY_MAX_SIDE = int(os.environ.get("AMPIXA_OCR_OVERLAY_MAX_SIDE", "1400")) +MAX_LINES = int(os.environ.get("AMPIXA_OCR_MAX_LINES", "120")) +RECOGNIZER_BATCH_SIZE = int(os.environ.get("AMPIXA_OCR_REC_BATCH_SIZE", "16")) + +# Detector settings. The Space leaves limit_type at the PaddleX default ("min"), +# which upscales every page so its *shortest* side is >= limit_side_len and costs +# ~8 s per page on this host. "max" bounds the *longest* side instead: 2.4x faster +# on a full newspaper page for the same box count (303 vs 305 boxes measured). +DETECTOR_LIMIT_SIDE_LEN = int(os.environ.get("AMPIXA_OCR_DET_LIMIT_SIDE_LEN", "1280")) +DETECTOR_LIMIT_TYPE = os.environ.get("AMPIXA_OCR_DET_LIMIT_TYPE", "max") +DETECTOR_THRESH = float(os.environ.get("AMPIXA_OCR_DET_THRESH", "0.30")) +DETECTOR_BOX_THRESH = float(os.environ.get("AMPIXA_OCR_DET_BOX_THRESH", "0.60")) +DETECTOR_UNCLIP_RATIO = float(os.environ.get("AMPIXA_OCR_DET_UNCLIP_RATIO", "1.5")) +DETECTOR_MODEL_NAME = "PP-OCRv6_medium_det" # PaddleOCR 3.7.0 default text detector. + +CROP_PADDING = 12 # Space default for the Paddle page tab. +READING_ORDER = "Rows LTR" # Space default for the Paddle page tab. + +SUPPORTED_MODES = ("line", "page") +SUPPORTED_SCRIPTS = ("auto", "sirijonga", "devanagari") +SUPPORTED_IMAGE_FORMATS = {"PNG": "image/png", "JPEG": "image/jpeg", "WEBP": "image/webp"} + +LIMBU_RE = re.compile("[\u1900-\u194F]") +DEVANAGARI_RE = re.compile("[\u0900-\u097F]") + +# Upper bound of _script_score() for a Devanagari candidate: rec_score is a +# probability (<= 1.0) and the Devanagari bonus saturates at 12 * 0.035. If the +# Sirijonga candidate already scores at least this much, the Devanagari pass +# cannot change the outcome and is skipped. This is an exact prune, not an +# approximation: it never changes the selected text. +MAX_DEVANAGARI_SCRIPT_SCORE = 1.0 + 0.035 * 12 + +LOGGER = logging.getLogger("ampixa.ocr") + + +@dataclass(slots=True) +class Recognition: + """One recognizer output for one crop.""" + + text: str + confidence: float | None + engine: str + + +@dataclass(slots=True) +class Box: + """Axis-aligned line box in processed-image pixel coordinates.""" + + left: int + top: int + right: int + bottom: int + confidence: float + + @property + def width(self) -> int: + return max(0, self.right - self.left) + + @property + def height(self) -> int: + return max(0, self.bottom - self.top) + + @property + def x_center(self) -> float: + return (self.left + self.right) / 2.0 + + @property + def y_center(self) -> float: + return (self.top + self.bottom) / 2.0 + + def as_list(self) -> list[int]: + return [self.left, self.top, self.right, self.bottom] + + +class OcrError(Exception): + """Client-visible OCR failure carrying an HTTP status code.""" + + def __init__(self, message: str, status_code: int) -> None: + super().__init__(message) + self.message = message + self.status_code = status_code + + +class Engines: + """Holds the Paddle predictors and serializes every call into them. + + Paddle predictors are not documented as thread-safe, and uvicorn runs request + handlers in a thread pool, so every predict() call goes through ``lock``. + """ + + def __init__(self) -> None: + self.lock = threading.Lock() + self.recognizers: dict[str, Any] = {} + self.detector: Any = None + self.loaded = False + self.load_seconds: float | None = None + self.load_error: str | None = None + + def ensure_model_files(self) -> None: + missing: list[str] = [] + for model_dir in (SIRIJONGA_MODEL_DIR, DEVANAGARI_MODEL_DIR): + for name in REQUIRED_RECOGNIZER_FILES: + path = model_dir / name + if not path.is_file(): + missing.append(str(path)) + if missing: + raise RuntimeError("missing OCR model artifacts: " + ", ".join(missing)) + + def load(self) -> None: + """Build every predictor once. Called from a background thread at startup.""" + started = time.perf_counter() + try: + self.ensure_model_files() + for engine, model_name, model_dir in ( + ("sirijonga", SIRIJONGA_MODEL_NAME, SIRIJONGA_MODEL_DIR), + ("devanagari", DEVANAGARI_MODEL_NAME, DEVANAGARI_MODEL_DIR), + ): + step = time.perf_counter() + self.recognizers[engine] = TextRecognition( + model_name=model_name, + model_dir=str(model_dir), + device="cpu", + ) + LOGGER.info( + "loaded recognizer engine=%s model=%s dir=%s in %.2fs", + engine, + model_name, + model_dir, + time.perf_counter() - step, + ) + step = time.perf_counter() + self.detector = TextDetection( + limit_side_len=DETECTOR_LIMIT_SIDE_LEN, + limit_type=DETECTOR_LIMIT_TYPE, + thresh=DETECTOR_THRESH, + box_thresh=DETECTOR_BOX_THRESH, + unclip_ratio=DETECTOR_UNCLIP_RATIO, + device="cpu", + ) + LOGGER.info("loaded text detector in %.2fs", time.perf_counter() - step) + except Exception as exc: # noqa: BLE001 - recorded and surfaced through /health + self.load_error = f"{type(exc).__name__}: {exc}" + LOGGER.error("model load failed: %s\n%s", self.load_error, traceback.format_exc()) + return + self.load_seconds = time.perf_counter() - started + self.loaded = True + LOGGER.info("all OCR models loaded in %.2fs", self.load_seconds) + + +ENGINES = Engines() + + +def _payload(item: object) -> dict[str, Any] | None: + """Unwrap a PaddleX result object into its plain result mapping.""" + candidate: object = item + if not isinstance(candidate, dict): + candidate = getattr(item, "json", None) + if not isinstance(candidate, dict): + return None + nested = candidate.get("res") + return nested if isinstance(nested, dict) else candidate + + +def _script_score(recognition: Recognition) -> float: + """Score copied verbatim from the Space's app.py ``_script_score``. + + The Sirijonga bonus (0.06/char, capped at 12 chars) is larger than the + Devanagari one (0.035/char), so this rule leans towards Sirijonga on mixed + pages. Callers that know the script should pass it explicitly. + """ + text = recognition.text or "" + confidence = recognition.confidence if recognition.confidence is not None else 0.0 + limbu_chars = len(LIMBU_RE.findall(text)) + deva_chars = len(DEVANAGARI_RE.findall(text)) + if recognition.engine == "sirijonga": + return confidence + min(limbu_chars, 12) * 0.06 - min(deva_chars, 12) * 0.04 + if recognition.engine == "devanagari": + return confidence + min(deva_chars, 12) * 0.035 - min(limbu_chars, 12) * 0.08 + return confidence + + +def _recognize_batch(engine: str, crops: list[np.ndarray]) -> list[Recognition]: + """Run one recognizer over a list of BGR crops, preserving input order.""" + if not crops: + return [] + predictor = ENGINES.recognizers.get(engine) + if predictor is None: + raise OcrError(f"recognizer '{engine}' is not loaded", 503) + raw = list(predictor.predict(crops, batch_size=RECOGNIZER_BATCH_SIZE)) + if len(raw) != len(crops): + raise OcrError( + f"recognizer '{engine}' returned {len(raw)} results for {len(crops)} crops", + 500, + ) + results: list[Recognition] = [] + for item in raw: + payload = _payload(item) + if payload is None: + results.append(Recognition(text="", confidence=None, engine=engine)) + continue + text = payload.get("rec_text") or payload.get("text") or "" + score = payload.get("rec_score") + if score is None: + score = payload.get("score") + confidence: float | None + try: + confidence = float(score) if score is not None else None + except (TypeError, ValueError): + confidence = None + results.append(Recognition(text=str(text).strip(), confidence=confidence, engine=engine)) + return results + + +def _recognize_routed(crops: list[np.ndarray], script: str) -> list[Recognition]: + """Recognize crops under the requested script routing. + + ``auto`` reproduces the Space: both engines run and the higher ``_script_score`` + wins, with ties going to Sirijonga. The Devanagari pass is skipped for crops + whose Sirijonga score already exceeds every score Devanagari could reach. + """ + if script in ("sirijonga", "devanagari"): + return _recognize_batch(script, crops) + + sirijonga = _recognize_batch("sirijonga", crops) + scores = [_script_score(rec) for rec in sirijonga] + pending = [i for i, score in enumerate(scores) if score < MAX_DEVANAGARI_SCRIPT_SCORE] + if not pending: + return sirijonga + devanagari = _recognize_batch("devanagari", [crops[i] for i in pending]) + selected = list(sirijonga) + for index, candidate in zip(pending, devanagari, strict=True): + if _script_score(candidate) > scores[index]: + selected[index] = candidate + return selected + + +def _to_bgr(image: Image.Image) -> np.ndarray: + """PIL RGB image -> contiguous BGR ndarray, the layout PaddleX expects.""" + return np.asarray(image)[:, :, ::-1].copy() + + +def _box_from_polygon(polygon: object, *, width: int, height: int, confidence: float) -> Box | None: + array = np.asarray(polygon, dtype=np.float64).reshape(-1, 2) + if array.size == 0: + return None + box = Box( + left=max(0, int(math.floor(float(array[:, 0].min())))), + top=max(0, int(math.floor(float(array[:, 1].min())))), + right=min(width, int(math.ceil(float(array[:, 0].max())))), + bottom=min(height, int(math.ceil(float(array[:, 1].max())))), + confidence=confidence, + ) + return box if box.width > 0 and box.height > 0 else None + + +def _detect_boxes(image: Image.Image) -> list[Box]: + """Full-page text detection -> axis-aligned line boxes.""" + if ENGINES.detector is None: + raise OcrError("text detector is not loaded", 503) + raw = list(ENGINES.detector.predict(_to_bgr(image))) + boxes: list[Box] = [] + for item in raw: + payload = _payload(item) + if payload is None: + continue + polygons = payload.get("dt_polys") + if polygons is None: + continue + # dt_scores comes back as an ndarray, so never use truthiness on it. + scores = payload.get("dt_scores") + if scores is None: + scores = [] + for index, polygon in enumerate(polygons): + confidence = 1.0 + if index < len(scores) and scores[index] is not None: + try: + confidence = float(scores[index]) + except (TypeError, ValueError): + confidence = 1.0 + box = _box_from_polygon( + polygon, width=image.width, height=image.height, confidence=confidence + ) + if box is not None: + boxes.append(box) + return boxes + + +def _has_two_column_shape(boxes: list[Box], image_width: int) -> bool: + """Copied from the Space's app.py.""" + if len(boxes) < 8 or image_width <= 0: + return False + midpoint = image_width / 2.0 + left = [box for box in boxes if box.x_center < midpoint] + right = [box for box in boxes if box.x_center >= midpoint] + if len(left) < 3 or len(right) < 3: + return False + left_median = float(np.median([box.x_center for box in left])) + right_median = float(np.median([box.x_center for box in right])) + return (right_median - left_median) >= image_width * 0.22 + + +def _order_boxes(boxes: list[Box], mode: str, image_width: int) -> list[Box]: + """Copied from the Space's app.py ``_order_image_line_boxes``.""" + if mode == "Auto": + mode = "Columns LTR" if _has_two_column_shape(boxes, image_width) else "Rows LTR" + if mode == "Columns LTR": + return sorted( + boxes, + key=lambda box: (0 if box.x_center < image_width / 2 else 1, box.y_center, box.x_center), + ) + if mode == "Columns RTL": + return sorted( + boxes, + key=lambda box: (0 if box.x_center >= image_width / 2 else 1, box.y_center, box.x_center), + ) + row_height = max(12, int(np.median([box.height for box in boxes])) if boxes else 24) + return sorted(boxes, key=lambda box: (math.floor(box.y_center / row_height), box.x_center)) + + +def _crop(image: Image.Image, box: Box, padding: int) -> Image.Image: + return image.crop( + ( + max(0, box.left - padding), + max(0, box.top - padding), + min(image.width, box.right + padding), + min(image.height, box.bottom + padding), + ) + ) + + +def _overlay_png_b64(image: Image.Image, boxes: list[Box]) -> str: + """Draw the ordered boxes on the page and return a base64 PNG.""" + annotated = image.copy() + draw = ImageDraw.Draw(annotated) + for index, box in enumerate(boxes, start=1): + draw.rectangle( + (box.left, box.top, box.right, box.bottom), outline=(28, 120, 92), width=3 + ) + draw.text((box.left + 4, max(0, box.top - 12)), str(index), fill=(28, 120, 92)) + longest = max(annotated.size) + if longest > OVERLAY_MAX_SIDE: + scale = OVERLAY_MAX_SIDE / longest + annotated = annotated.resize( + (max(1, round(annotated.width * scale)), max(1, round(annotated.height * scale))), + Image.LANCZOS, + ) + buffer = io.BytesIO() + annotated.save(buffer, format="PNG", optimize=True) + return base64.b64encode(buffer.getvalue()).decode("ascii") + + +def _decode_image(raw: bytes) -> Image.Image: + """Validate and normalize an uploaded image; downscale the longest side.""" + try: + probe = Image.open(io.BytesIO(raw)) + image_format = probe.format + probe.load() + image = ImageOps.exif_transpose(probe).convert("RGB") + probe.close() + except UnidentifiedImageError as exc: + raise OcrError("file is not a decodable image", 400) from exc + except (OSError, ValueError) as exc: + raise OcrError(f"could not decode image: {exc}", 400) from exc + if image_format not in SUPPORTED_IMAGE_FORMATS: + raise OcrError( + f"unsupported image format {image_format!r}; expected one of " + + ", ".join(sorted(SUPPORTED_IMAGE_FORMATS)), + 415, + ) + longest = max(image.size) + if longest > MAX_IMAGE_SIDE: + scale = MAX_IMAGE_SIDE / longest + image = image.resize( + (max(1, round(image.width * scale)), max(1, round(image.height * scale))), + Image.LANCZOS, + ) + if image.width < 4 or image.height < 4: + raise OcrError("image is too small to recognize", 400) + return image + + +def _resolved_script(recognitions: list[Recognition], requested: str) -> str: + if requested in ("sirijonga", "devanagari"): + return requested + engines = [rec.engine for rec in recognitions if rec.text] + if not engines: + return "sirijonga" + return max(set(engines), key=engines.count) + + +def _run_line(image: Image.Image, script: str) -> dict[str, Any]: + crops = [_to_bgr(image)] + with ENGINES.lock: + recognitions = _recognize_routed(crops, script) + recognition = recognitions[0] + line = { + "text": recognition.text, + "confidence": recognition.confidence, + "box": [0, 0, image.width, image.height], + "script": recognition.engine, + } + return { + "text": recognition.text, + "lines": [line], + "script": _resolved_script(recognitions, script), + "truncated": False, + "overlay_png_b64": None, + } + + +def _run_page(image: Image.Image, script: str) -> dict[str, Any]: + with ENGINES.lock: + boxes = _detect_boxes(image) + ordered = _order_boxes(boxes, READING_ORDER, image.width) + truncated = MAX_LINES > 0 and len(ordered) > MAX_LINES + if truncated: + LOGGER.warning( + "page has %d detected lines, truncating to AMPIXA_OCR_MAX_LINES=%d", + len(ordered), + MAX_LINES, + ) + ordered = ordered[:MAX_LINES] + crops = [_to_bgr(_crop(image, box, CROP_PADDING)) for box in ordered] + recognitions = _recognize_routed(crops, script) + overlay = _overlay_png_b64(image, ordered) + + lines: list[dict[str, Any]] = [] + texts: list[str] = [] + for box, recognition in zip(ordered, recognitions, strict=True): + lines.append( + { + "text": recognition.text, + "confidence": recognition.confidence, + "box": box.as_list(), + "script": recognition.engine, + } + ) + if recognition.text: + texts.append(recognition.text) + return { + "text": "\n".join(texts), + "lines": lines, + "script": _resolved_script(recognitions, script), + "truncated": truncated, + "overlay_png_b64": overlay, + } + + +@asynccontextmanager +async def _lifespan(_app: FastAPI) -> AsyncIterator[None]: + """Serve /health immediately; build the Paddle predictors in the background.""" + LOGGER.info( + "starting OCR worker: model_root=%s detector=%s (%s/%d) max_lines=%d", + MODEL_ROOT, + DETECTOR_MODEL_NAME, + DETECTOR_LIMIT_TYPE, + DETECTOR_LIMIT_SIDE_LEN, + MAX_LINES, + ) + loader = threading.Thread(target=ENGINES.load, name="ocr-model-load", daemon=True) + loader.start() + yield + LOGGER.info("OCR worker shutting down") + + +app = FastAPI(title="Ampixa OCR worker", docs_url=None, redoc_url=None, lifespan=_lifespan) + + +@app.exception_handler(OcrError) +async def _ocr_error_handler(_request: Request, exc: OcrError) -> JSONResponse: + return JSONResponse(status_code=exc.status_code, content={"error": exc.message}) + + +@app.exception_handler(RequestValidationError) +async def _validation_error_handler( + _request: Request, exc: RequestValidationError +) -> JSONResponse: + """Report malformed multipart bodies as {"error": ...} instead of FastAPI's 422.""" + problems = "; ".join( + f"{'.'.join(str(part) for part in error.get('loc', ()))}: {error.get('msg', 'invalid')}" + for error in exc.errors() + ) + return JSONResponse(status_code=400, content={"error": f"invalid request: {problems}"}) + + +@app.exception_handler(StarletteHTTPException) +async def _http_error_handler(_request: Request, exc: StarletteHTTPException) -> JSONResponse: + """Keep 404/405 and friends on the {"error": ...} contract.""" + return JSONResponse(status_code=exc.status_code, content={"error": str(exc.detail)}) + + +@app.exception_handler(Exception) +async def _unhandled_error_handler(_request: Request, exc: Exception) -> JSONResponse: + """Last resort: log the traceback, return JSON, never a bare stack trace.""" + LOGGER.error("unhandled error: %s\n%s", exc, traceback.format_exc()) + return JSONResponse( + status_code=500, content={"error": f"internal error: {type(exc).__name__}"} + ) + + +@app.get("/health") +def health() -> JSONResponse: + body: dict[str, Any] = { + "ok": ENGINES.load_error is None, + "worker": WORKER_NAME, + "loaded": ENGINES.loaded, + "models": { + "sirijonga": str(SIRIJONGA_MODEL_DIR), + "devanagari": str(DEVANAGARI_MODEL_DIR), + "sirijonga_model_name": SIRIJONGA_MODEL_NAME, + "devanagari_model_name": DEVANAGARI_MODEL_NAME, + "detector_model_name": DETECTOR_MODEL_NAME, + "detector_limit": f"{DETECTOR_LIMIT_TYPE}/{DETECTOR_LIMIT_SIDE_LEN}", + "max_lines": MAX_LINES, + "max_image_side": MAX_IMAGE_SIDE, + "load_seconds": round(ENGINES.load_seconds, 2) if ENGINES.load_seconds else None, + }, + "device": "cpu", + } + if ENGINES.load_error is not None: + body["error"] = ENGINES.load_error + return JSONResponse(status_code=503, content=body) + return JSONResponse(status_code=200, content=body) + + +@app.post("/recognize") +async def recognize( + file: UploadFile = File(...), + mode: str = Form("page"), + script: str = Form("auto"), +) -> JSONResponse: + started = time.perf_counter() + mode = (mode or "page").strip().lower() + script = (script or "auto").strip().lower() + if mode not in SUPPORTED_MODES: + raise OcrError(f"mode must be one of {', '.join(SUPPORTED_MODES)}", 400) + if script not in SUPPORTED_SCRIPTS: + raise OcrError(f"script must be one of {', '.join(SUPPORTED_SCRIPTS)}", 400) + if not ENGINES.loaded: + if ENGINES.load_error is not None: + raise OcrError(f"OCR models failed to load: {ENGINES.load_error}", 503) + raise OcrError("OCR models are still loading", 503) + + try: + raw = await file.read() + except Exception as exc: # noqa: BLE001 - upload stream failures are client errors + LOGGER.error("upload read failed: %s\n%s", exc, traceback.format_exc()) + raise OcrError(f"could not read uploaded file: {exc}", 400) from exc + finally: + await file.close() + + if not raw: + raise OcrError("uploaded file is empty", 400) + if len(raw) > MAX_UPLOAD_BYTES: + raise OcrError( + f"image is {len(raw)} bytes, limit is {MAX_UPLOAD_BYTES} bytes", 413 + ) + + image = _decode_image(raw) + runner = _run_line if mode == "line" else _run_page + try: + result = await run_in_threadpool(runner, image, script) + except OcrError: + raise + except Exception as exc: # noqa: BLE001 - converted to a JSON 500 below + LOGGER.error( + "recognition failed mode=%s script=%s: %s\n%s", + mode, + script, + exc, + traceback.format_exc(), + ) + raise OcrError(f"recognition failed: {type(exc).__name__}: {exc}", 500) from exc + + elapsed = time.perf_counter() - started + LOGGER.info( + "recognize mode=%s script=%s -> %s bytes=%d size=%dx%d lines=%d truncated=%s chars=%d %.2fs", + mode, + script, + result["script"], + len(raw), + image.width, + image.height, + len(result["lines"]), + result["truncated"], + len(result["text"]), + elapsed, + ) + return JSONResponse( + status_code=200, + content={ + "text": result["text"], + "lines": result["lines"], + "script": result["script"], + "mode": mode, + "elapsed_s": round(elapsed, 3), + "image_size": [image.width, image.height], + "truncated": result["truncated"], + "overlay_png_b64": result["overlay_png_b64"], + }, + ) + + +def main() -> int: + parser = argparse.ArgumentParser(description="Ampixa OCR worker (Limbu Sirijonga + Devanagari)") + parser.add_argument("--host", default=DEFAULT_HOST) + parser.add_argument("--port", type=int, default=DEFAULT_PORT) + args = parser.parse_args() + logging.basicConfig( + level=logging.INFO, + format="%(asctime)s %(levelname)s %(name)s %(message)s", + stream=sys.stdout, + ) + uvicorn.run(app, host=args.host, port=args.port, log_level="info", access_log=False) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/logs/eval_v4_last.log b/logs/eval_v4_last.log new file mode 100644 index 0000000000000000000000000000000000000000..ffa015375a107edfe64ac3dcf3c6ae380a91ac8f --- /dev/null +++ b/logs/eval_v4_last.log @@ -0,0 +1,47 @@ + Loading weights: 0%| | 0/1035 [00:00 1 and attention_mask is None and is_causal +batch 1 width 320: T=40 max|diff|=5.96e-07 argmax agree=1.0000 +batch 4 width 480: T=60 max|diff|=1.10e-06 argmax agree=1.0000 +batch 2 width 1200: T=150 max|diff|=6.56e-07 argmax agree=1.0000 +exported and verified: /home/ampixa/ocr/ocr-deva-ft/export/v4-last-onnx +e1v4_chunks: 3000 predictions +e7_kra: 530 predictions +e1b_lines_kfix: 1500 predictions +e2_newar: 1139 predictions +e3_cit_ne: 800 predictions +e3_office_ne: 300 predictions +e3_cit_en: 300 predictions +e3_realtext: 400 predictions +e4_english: 120 predictions +e4_mixed: 120 predictions +e5_handwriting_probe: 450 predictions +e6_nvidia_en: 419 predictions +h1_nepali_cc0_test: 871 predictions +h2_iiit_test: 2000 predictions +h3_indicscan: 835 predictions +h4_dhcd_digits_test: 800 predictions +h4_dhcd_digits_test: 800 predictions +/home/ampixa/ocr/.venv-serve/lib/python3.11/site-packages/paddle/utils/cpp_extension/extension_utils.py:712: UserWarning: No ccache found. Please be aware that recompiling all source files may be required. You can download and install ccache from: https://github.com/ccache/ccache/blob/master/doc/INSTALL.md + warnings.warn(warning_message) +h4_dhcd_digits_test: 800 predictions +set official v3 v4last +e1v4_chunks cp 0.0513 gr 0.0817 ex 0.47 cp 0.0057 gr 0.0098 ex 0.93 cp 0.0063 gr 0.0111 ex 0.93 n=3000 +e7_kra cp 0.0552 gr 0.0996 ex 0.33 cp 0.0086 gr 0.0150 ex 0.89 cp 0.0087 gr 0.0149 ex 0.88 n=530 +e1b_lines_kfix cp 0.0769 gr 0.1265 ex 0.13 cp 0.0257 gr 0.0500 ex 0.54 cp 0.0266 gr 0.0518 ex 0.53 n=1500 +e2_newar cp 0.0911 gr 0.1742 ex 0.06 cp 0.0354 gr 0.0779 ex 0.35 cp 0.0367 gr 0.0802 ex 0.34 n=1139 +e3_cit_ne cp 0.0678 gr 0.1155 ex 0.56 cp 0.0075 gr 0.0125 ex 0.94 cp 0.0083 gr 0.0152 ex 0.92 n=800 +e3_office_ne cp 0.0777 gr 0.1089 ex 0.54 cp 0.0092 gr 0.0138 ex 0.92 cp 0.0111 gr 0.0167 ex 0.90 n=300 +e3_cit_en cp 0.0194 gr 0.0194 ex 0.83 cp 0.0064 gr 0.0064 ex 0.95 cp 0.0055 gr 0.0055 ex 0.96 n=300 +e3_realtext cp 0.0857 gr 0.1388 ex 0.47 cp 0.0120 gr 0.0216 ex 0.89 cp 0.0166 gr 0.0344 ex 0.84 n=400 +e4_english cp 0.0257 gr 0.0257 ex 0.62 cp 0.0164 gr 0.0164 ex 0.72 cp 0.0235 gr 0.0235 ex 0.66 n=120 +e4_mixed cp 0.0678 gr 0.0785 ex 0.36 cp 0.0267 gr 0.0346 ex 0.70 cp 0.0325 gr 0.0415 ex 0.62 n=120 +e5_handwriting_probe cp 0.6465 gr 0.7112 ex 0.01 cp 0.6102 gr 0.7176 ex 0.00 cp 0.5301 gr 0.6529 ex 0.04 n=450 +e6_nvidia_en cp 0.1062 gr 0.1062 ex 0.71 cp 0.0284 gr 0.0284 ex 0.84 cp 0.0357 gr 0.0357 ex 0.81 n=419 +h1_nepali_cc0_test cp 0.4075 gr 0.5477 ex 0.20 cp 0.6886 gr 0.9664 ex 0.04 cp 0.1554 gr 0.2426 ex 0.55 n=871 +h2_iiit_test cp 0.4944 gr 0.6582 ex 0.07 cp 0.6051 gr 0.8296 ex 0.03 cp 0.0911 gr 0.1521 ex 0.64 n=2000 +h3_indicscan cp 0.2520 gr 0.3649 ex 0.38 cp 0.4580 gr 0.6264 ex 0.14 cp 0.1337 gr 0.2053 ex 0.59 n=835 +h4_dhcd_digits_test cp 0.7185 gr 0.7185 ex 0.02 cp 0.5295 gr 0.5295 ex 0.05 cp 0.0021 gr 0.0021 ex 0.98 n=800 +EVAL_V4_DONE diff --git a/logs/setup_env.log b/logs/setup_env.log new file mode 100644 index 0000000000000000000000000000000000000000..a6fb00423af1b756ba5119c55643938668860a3d --- /dev/null +++ b/logs/setup_env.log @@ -0,0 +1,405 @@ ++ OCR_ROOT=/home/ampixa/ocr ++ export UV_INSTALL_DIR=/home/ampixa/ocr/bin UV_NO_MODIFY_PATH=1 ++ UV_INSTALL_DIR=/home/ampixa/ocr/bin ++ UV_NO_MODIFY_PATH=1 ++ export UV_CACHE_DIR=/home/ampixa/ocr/.uv-cache UV_PYTHON_INSTALL_DIR=/home/ampixa/ocr/.uv-python ++ UV_CACHE_DIR=/home/ampixa/ocr/.uv-cache ++ UV_PYTHON_INSTALL_DIR=/home/ampixa/ocr/.uv-python ++ REQ=/home/ampixa/ocr/ocr-tech/tools/deva_rec_torch/recipes/k2 ++ cd /home/ampixa/ocr ++ '[' '!' -x /home/ampixa/ocr/bin/uv ']' ++ curl -LsSf https://astral.sh/uv/install.sh ++ sh +downloading uv 0.12.21 x86_64-unknown-linux-gnu +installing to /home/ampixa/ocr/bin + uv + uvx +everything's installed! ++ UV=/home/ampixa/ocr/bin/uv ++ /home/ampixa/ocr/bin/uv venv --allow-existing --python 3.11 .venv-torch +Downloading cpython-3.11.16-linux-x86_64-gnu (download) (29.4MiB) + Downloaded cpython-3.11.16-linux-x86_64-gnu (download) +Using CPython 3.11.16 +Creating virtual environment at: .venv-torch +Activate with: source .venv-torch/bin/activate ++ /home/ampixa/ocr/bin/uv pip install --python .venv-torch/bin/python --index-url https://download.pytorch.org/whl/cu126 torch==2.14.0 +Using Python 3.11.16 environment at: .venv-torch +Resolved 29 packages in 3.85s +Downloading nvidia-nvshmem-cu12 (132.7MiB) +Downloading setuptools (1.2MiB) +Downloading sympy (6.0MiB) +Downloading networkx (2.0MiB) +Downloading cuda-bindings (7.3MiB) +Downloading nvidia-nvjitlink-cu12 (37.9MiB) +Downloading torch (828.9MiB) +Downloading triton (235.4MiB) +Downloading nvidia-cusparselt-cu12 (273.9MiB) +Downloading nvidia-curand-cu12 (53.7MiB) +Downloading nvidia-cuda-cupti-cu12 (8.5MiB) +Downloading nvidia-cusparse-cu12 (206.5MiB) +Downloading nvidia-nccl-cu12 (276.3MiB) +Downloading nvidia-cudnn-cu12 (674.0MiB) +Downloading nvidia-cusolver-cu12 (150.9MiB) +Downloading nvidia-cublas-cu12 (374.9MiB) +Downloading nvidia-cufile-cu12 (1.1MiB) +Downloading nvidia-cuda-nvrtc-cu12 (22.6MiB) +Downloading nvidia-cufft-cu12 (190.9MiB) + Downloaded setuptools + Downloaded triton + Downloaded nvidia-cufile-cu12 + Downloaded torch + Downloaded nvidia-nvjitlink-cu12 + Downloaded networkx + Downloaded nvidia-cuda-cupti-cu12 + Downloaded nvidia-nvshmem-cu12 + Downloaded nvidia-curand-cu12 + Downloaded sympy + Downloaded cuda-bindings + Downloaded nvidia-cusparselt-cu12 + Downloaded nvidia-cusparse-cu12 + Downloaded nvidia-nccl-cu12 + Downloaded nvidia-cuda-nvrtc-cu12 + Downloaded nvidia-cusolver-cu12 + Downloaded nvidia-cudnn-cu12 + Downloaded nvidia-cublas-cu12 + Downloaded nvidia-cufft-cu12 +Prepared 29 packages in 4m 17s +Installed 29 packages in 424ms + + cuda-bindings==12.9.7 + + cuda-pathfinder==1.6.0 + + cuda-toolkit==12.6.3 + + filelock==3.32.3 + + fsspec==2026.7.0 + + jinja2==3.1.6 + + markupsafe==3.0.3 + + mpmath==1.3.0 + + networkx==3.6.1 + + nvidia-cublas-cu12==12.6.4.1 + + nvidia-cuda-cupti-cu12==12.6.80 + + nvidia-cuda-nvrtc-cu12==12.6.85 + + nvidia-cuda-runtime-cu12==12.6.77 + + nvidia-cudnn-cu12==9.10.2.21 + + nvidia-cufft-cu12==11.3.0.4 + + nvidia-cufile-cu12==1.11.1.6 + + nvidia-curand-cu12==10.3.7.77 + + nvidia-cusolver-cu12==11.7.1.2 + + nvidia-cusparse-cu12==12.5.4.2 + + nvidia-cusparselt-cu12==0.7.1 + + nvidia-nccl-cu12==2.29.3 + + nvidia-nvjitlink-cu12==12.9.86 + + nvidia-nvshmem-cu12==3.4.5 + + nvidia-nvtx-cu12==12.6.77 + + setuptools==78.1.0 + + sympy==1.14.0 + + torch==2.14.0+cu126 + + triton==3.8.0 + + typing-extensions==4.16.0 ++ /home/ampixa/ocr/bin/uv pip install --python .venv-torch/bin/python transformers==5.17.0 safetensors==0.8.0 onnx==1.23.0 onnxruntime==1.30.0 numpy==2.4.6 pillow huggingface_hub rapidfuzz regex pyyaml opencv-python-headless +Using Python 3.11.16 environment at: .venv-torch +Resolved 35 packages in 784ms +Downloading tokenizers (3.2MiB) +Downloading pygments (1.2MiB) +Downloading pillow (6.6MiB) +Downloading opencv-python-headless (58.4MiB) +Downloading transformers (11.7MiB) +Downloading rapidfuzz (3.0MiB) +Downloading numpy (16.1MiB) +Downloading hf-xet (4.3MiB) +Downloading onnxruntime (22.5MiB) +Downloading onnx (8.5MiB) + Downloaded pygments + Downloaded rapidfuzz + Downloaded tokenizers + Downloaded hf-xet + Downloaded pillow + Downloaded onnx + Downloaded transformers + Downloaded numpy + Downloaded onnxruntime + Downloaded opencv-python-headless +Prepared 32 packages in 14.74s +Installed 32 packages in 1.14s + + annotated-doc==0.0.5 + + anyio==4.15.1 + + certifi==2026.7.22 + + click==8.5.0 + + flatbuffers==25.12.19 + + h11==0.16.0 + + hf-xet==1.6.0 + + httpcore==1.0.9 + + httpx==0.28.1 + + huggingface-hub==1.33.0 + + idna==3.20 + + markdown-it-py==4.2.0 + + mdurl==0.1.2 + + ml-dtypes==0.6.0 + + numpy==2.4.6 + + onnx==1.23.0 + + onnxruntime==1.30.0 + + opencv-python-headless==5.0.0.93 + + packaging==26.3 + + pillow==12.3.0 + + protobuf==7.36.2 + + pygments==2.21.0 + + pyyaml==6.0.3 + + rapidfuzz==3.14.6 + + regex==2026.9.29 + + rich==15.0.0 + + safetensors==0.8.0 + + shellingham==1.5.4 + + tokenizers==0.23.2 + + tqdm==4.70.1 + + transformers==5.17.0 + + typer==0.27.2 ++ .venv-torch/bin/python -c 'import torch, transformers; print(torch.__version__, transformers.__version__, torch.version.cuda, torch.cuda.is_available(), [torch.cuda.get_device_name(i) for i in range(torch.cuda.device_count())])' +2.14.0+cu126 5.17.0 12.6 True ['Tesla T4', 'Tesla T4'] ++ /home/ampixa/ocr/bin/uv venv --allow-existing --python 3.11 .venv-serve +Using CPython 3.11.16 +Creating virtual environment at: .venv-serve +Activate with: source .venv-serve/bin/activate ++ /home/ampixa/ocr/bin/uv pip install --python .venv-serve/bin/python -r /home/ampixa/ocr/ocr-tech/tools/deva_rec_torch/recipes/k2/serve-requirements.txt +Using Python 3.11.16 environment at: .venv-serve +Resolved 145 packages in 1.23s +Downloading pycryptodome (2.2MiB) +Downloading pygments (1.2MiB) +Downloading nvidia-cufile (1.2MiB) +Downloading networkx (2.0MiB) +Downloading tiktoken (1.1MiB) +Downloading nvidia-cusolver (191.6MiB) +Downloading nvidia-cusparse (139.2MiB) +Downloading nvidia-nvjitlink (38.8MiB) +Downloading sympy (6.0MiB) +Downloading nvidia-cuda-runtime (2.1MiB) +Downloading sentencepiece (1.3MiB) +Downloading setuptools (1.0MiB) +Downloading lxml (5.0MiB) +Downloading nvidia-cublas (403.5MiB) +Downloading opencv-python-headless (47.7MiB) +Downloading numpy (16.1MiB) +Downloading pydantic-core (2.0MiB) +Downloading tokenizers (3.1MiB) +Downloading pyarrow (46.6MiB) +Downloading pandas (10.8MiB) +Downloading scikit-learn (8.9MiB) +Downloading aiohttp (1.7MiB) +Downloading paddlepaddle (185.8MiB) +Downloading shapely (3.0MiB) +Downloading nvidia-cufft (204.2MiB) +Downloading cuda-bindings (6.8MiB) +Downloading transformers (11.4MiB) +Downloading nvidia-cuda-nvrtc (86.0MiB) +Downloading opencv-contrib-python (65.5MiB) +Downloading pillow (4.3MiB) +Downloading nvidia-nvshmem-cu13 (57.6MiB) +Downloading h5py (4.8MiB) +Downloading scipy (33.7MiB) +Downloading nvidia-curand (56.8MiB) +Downloading nvidia-cusparselt-cu13 (162.3MiB) +Downloading nvidia-cuda-cupti (10.2MiB) +Downloading pymupdf (23.8MiB) +Downloading hf-xet (4.3MiB) +Downloading nvidia-nccl-cu13 (196.4MiB) +Downloading triton (192.1MiB) +Downloading modelscope (5.8MiB) +Downloading pypdfium2 (2.7MiB) +Downloading nvidia-cudnn-cu13 (349.2MiB) +Downloading torch (507.5MiB) +Downloading paddlex (2.1MiB) + Downloaded setuptools + Downloaded tiktoken + Downloaded nvidia-cufile + Downloaded pygments + Downloaded sentencepiece + Downloaded aiohttp + Downloaded networkx + Downloaded pydantic-core + Downloaded pycryptodome + Downloaded paddlex + Downloaded nvidia-cuda-runtime + Downloaded pypdfium2 + Downloaded shapely + Downloaded tokenizers + Downloaded pillow + Downloaded hf-xet + Downloaded h5py + Downloaded lxml + Downloaded modelscope + Downloaded sympy + Downloaded cuda-bindings + Downloaded scikit-learn + Downloaded nvidia-cuda-cupti + Downloaded pandas + Downloaded transformers + Downloaded numpy + Downloaded pymupdf + Downloaded scipy + Downloaded nvidia-nvjitlink + Downloaded pyarrow + Downloaded opencv-python-headless + Downloaded nvidia-curand + Downloaded nvidia-nvshmem-cu13 + Downloaded opencv-contrib-python + Downloaded nvidia-cuda-nvrtc + Downloaded nvidia-cusparse + Downloaded nvidia-cusparselt-cu13 + Downloaded paddlepaddle + Downloaded triton + Downloaded nvidia-cusolver + Downloaded nvidia-nccl-cu13 + Downloaded nvidia-cufft + Downloaded nvidia-cudnn-cu13 + Downloaded nvidia-cublas + Downloaded torch +Prepared 136 packages in 5m 34s +Installed 145 packages in 998ms + + accelerate==1.14.0 + + aiohappyeyeballs==2.6.2 + + aiohttp==3.14.1 + + aiosignal==1.4.0 + + aistudio-sdk==0.3.8 + + annotated-doc==0.0.4 + + annotated-types==0.7.0 + + anyio==4.13.0 + + attrs==26.1.0 + + bce-python-sdk==0.9.72 + + beautifulsoup4==4.15.0 + + cachetools==7.1.4 + + certifi==2026.5.20 + + chardet==7.4.3 + + charset-normalizer==3.4.7 + + click==8.4.1 + + colorlog==6.10.1 + + crc32c==2.8 + + cssselect==1.4.0 + + cssutils==2.15.0 + + cuda-bindings==13.4.3 + + cuda-pathfinder==1.8.2 + + cuda-toolkit==13.0.2 + + datasets==5.0.0 + + dill==0.4.1 + + distro==1.9.0 + + einops==0.8.2 + + encutils==1.0.0 + + et-xmlfile==2.0.0 + + fastapi==0.141.1 + + filelock==3.29.4 + + filetype==1.2.0 + + flatbuffers==25.12.19 + + frozenlist==1.8.0 + + fsspec==2026.4.0 + + ftfy==6.3.1 + + future==1.0.0 + + h11==0.16.0 + + h5py==3.16.0 + + hf-xet==1.5.1 + + httpcore==1.0.9 + + httpx==0.27.2 + + huggingface-hub==0.36.2 + + idna==3.18 + + imagesize==2.0.0 + + iniconfig==2.3.0 + + jinja2==3.1.6 + + jiter==0.15.0 + + joblib==1.5.3 + + latex2mathml==3.81.0 + + lxml==6.1.1 + + markdown-it-py==4.2.0 + + markupsafe==3.0.3 + + mdurl==0.1.2 + + modelscope==1.37.1 + + more-itertools==11.1.0 + + mpmath==1.3.0 + + multidict==6.7.1 + + multiprocess==0.70.19 + + narwhals==2.22.1 + + networkx==3.6.1 + + numpy==2.3.5 + + nvidia-cublas==13.1.1.3 + + nvidia-cuda-cupti==13.0.85 + + nvidia-cuda-nvrtc==13.0.88 + + nvidia-cuda-runtime==13.0.96 + + nvidia-cudnn-cu13==9.20.0.48 + + nvidia-cufft==12.0.0.61 + + nvidia-cufile==1.15.1.6 + + nvidia-curand==10.4.0.35 + + nvidia-cusolver==12.0.4.66 + + nvidia-cusparse==12.6.3.3 + + nvidia-cusparselt-cu13==0.8.1 + + nvidia-nccl-cu13==2.29.7 + + nvidia-nvjitlink==13.0.88 + + nvidia-nvshmem-cu13==3.4.5 + + nvidia-nvtx==13.0.85 + + onnxruntime==1.30.0 + + openai==1.109.1 + + opencv-contrib-python==4.10.0.84 + + opencv-python-headless==4.11.0.86 + + openpyxl==3.1.5 + + opt-einsum==3.3.0 + + packaging==26.2 + + paddleocr==3.7.0 + + paddlepaddle==3.3.1 + + paddlex==3.7.1 + + pandas==3.0.3 + + pillow==10.4.0 + + platformdirs==4.10.0 + + pluggy==1.6.0 + + premailer==3.10.0 + + prettytable==3.17.0 + + propcache==0.5.2 + + protobuf==7.35.1 + + psutil==7.2.2 + + py-cpuinfo==9.0.0 + + pyarrow==24.0.0 + + pyclipper==1.4.0 + + pycryptodome==3.23.0 + + pydantic==2.13.4 + + pydantic-core==2.46.4 + + pydantic-settings==2.14.1 + + pygments==2.20.0 + + pymupdf==1.27.2.3 + + pypdfium2==4.30.0 + + pytest==9.1.0 + + python-bidi==0.6.10 + + python-dateutil==2.9.0.post0 + + python-dotenv==1.2.2 + + python-multipart==0.0.32 + + pyyaml==6.0.2 + + regex==2026.5.9 + + requests==2.34.2 + + rich==15.0.0 + + ruamel-yaml==0.19.1 + + safetensors==0.8.0 + + scikit-learn==1.9.0 + + scipy==1.17.1 + + sentencepiece==0.2.1 + + setuptools==81.0.0 + + shapely==2.1.2 + + shellingham==1.5.4 + + six==1.17.0 + + sniffio==1.3.1 + + soupsieve==2.8.4 + + starlette==1.6.0 + + surya-ocr==0.20.0 + + sympy==1.14.0 + + threadpoolctl==3.6.0 + + tiktoken==0.13.0 + + tokenizers==0.22.2 + + torch==2.12.0 + + tqdm==4.68.2 + + transformers==4.57.6 + + triton==3.7.0 + + typer==0.25.1 + + typing-extensions==4.15.0 + + typing-inspection==0.4.2 + + ujson==5.12.1 + + urllib3==2.7.0 + + uvicorn==0.52.4 + + wcwidth==0.8.1 + + xxhash==3.7.0 + + yarl==1.24.2 ++ .venv-serve/bin/python -c 'import paddle, paddlex, paddleocr, onnxruntime; print(paddle.__version__, paddlex.__version__, onnxruntime.__version__)' +/home/ampixa/ocr/.venv-serve/lib/python3.11/site-packages/paddle/utils/cpp_extension/extension_utils.py:712: UserWarning: No ccache found. Please be aware that recompiling all source files may be required. You can download and install ccache from: https://github.com/ccache/ccache/blob/master/doc/INSTALL.md + warnings.warn(warning_message) +3.3.1 3.7.1 1.30.0 ++ echo T4_SETUP_DONE +T4_SETUP_DONE diff --git a/logs/smoke_train.log b/logs/smoke_train.log new file mode 100644 index 0000000000000000000000000000000000000000..89c223887e7877ff40eceb4b2be751f29f2c85d9 --- /dev/null +++ b/logs/smoke_train.log @@ -0,0 +1,23 @@ +ctc cpu=24.265554 cuda=24.265553 |dloss|=1.91e-06 max|dgrad|=1.04e-06 + Loading weights: 0%| | 0/1035 [00:00 + sys.exit(main()) + ^^^^^^ + File "/home/ampixa/ocr/ocr-tech/tools/deva_rec_torch/train.py", line 319, in main + part_loss = ctc_loss(logits(model, pixel_values[part].to(device)), [ids[i] for i in rows]) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/ampixa/ocr/ocr-tech/tools/deva_rec_torch/common.py", line 104, in logits + features = model.model(pixel_values).last_hidden_state + ^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/ampixa/ocr/.venv-torch/lib/python3.11/site-packages/torch/nn/modules/module.py", line 1783, in _wrapped_call_impl + return self._call_impl(*args, **kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/ampixa/ocr/.venv-torch/lib/python3.11/site-packages/torch/nn/modules/module.py", line 1794, in _call_impl + return forward_call(*args, **kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/ampixa/ocr/.venv-torch/lib/python3.11/site-packages/transformers/utils/generic.py", line 939, in wrapper + output = func(self, *args, **kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/ampixa/ocr/.venv-torch/lib/python3.11/site-packages/transformers/models/pp_ocrv5_mobile_rec/modeling_pp_ocrv5_mobile_rec.py", line 337, in forward + outputs = self.backbone(pixel_values, **kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/ampixa/ocr/.venv-torch/lib/python3.11/site-packages/torch/nn/modules/module.py", line 1783, in _wrapped_call_impl + return self._call_impl(*args, **kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/ampixa/ocr/.venv-torch/lib/python3.11/site-packages/torch/nn/modules/module.py", line 1794, in _call_impl + return forward_call(*args, **kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/ampixa/ocr/.venv-torch/lib/python3.11/site-packages/transformers/utils/generic.py", line 939, in wrapper + output = func(self, *args, **kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/ampixa/ocr/.venv-torch/lib/python3.11/site-packages/transformers/backbone_utils.py", line 172, in wrapper + output = forward_function(self, *args, **kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/ampixa/ocr/.venv-torch/lib/python3.11/site-packages/transformers/models/pp_lcnet_v3/modeling_pp_lcnet_v3.py", line 365, in forward + hidden_states = self.encoder(pixel_values, **kwargs).hidden_states + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/ampixa/ocr/.venv-torch/lib/python3.11/site-packages/torch/nn/modules/module.py", line 1783, in _wrapped_call_impl + return self._call_impl(*args, **kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/ampixa/ocr/.venv-torch/lib/python3.11/site-packages/torch/nn/modules/module.py", line 1794, in _call_impl + return forward_call(*args, **kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/ampixa/ocr/.venv-torch/lib/python3.11/site-packages/transformers/utils/generic.py", line 1068, in wrapper + output = func(self, *args, **kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/ampixa/ocr/.venv-torch/lib/python3.11/site-packages/transformers/utils/output_capturing.py", line 286, in wrapper + outputs = func(self, *args, **kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/ampixa/ocr/.venv-torch/lib/python3.11/site-packages/transformers/models/pp_lcnet_v3/modeling_pp_lcnet_v3.py", line 404, in forward + hidden_state = block(hidden_state) + ^^^^^^^^^^^^^^^^^^^ + File "/home/ampixa/ocr/.venv-torch/lib/python3.11/site-packages/torch/nn/modules/module.py", line 1783, in _wrapped_call_impl + return self._call_impl(*args, **kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/ampixa/ocr/.venv-torch/lib/python3.11/site-packages/torch/nn/modules/module.py", line 1889, in _call_impl + return inner() + ^^^^^^^ + File "/home/ampixa/ocr/.venv-torch/lib/python3.11/site-packages/torch/nn/modules/module.py", line 1837, in inner + result = forward_call(*args, **kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/ampixa/ocr/.venv-torch/lib/python3.11/site-packages/transformers/models/pp_lcnet_v3/modeling_pp_lcnet_v3.py", line 291, in forward + hidden_states = layer(hidden_states) + ^^^^^^^^^^^^^^^^^^^^ + File "/home/ampixa/ocr/.venv-torch/lib/python3.11/site-packages/transformers/modeling_layers.py", line 109, in __call__ + return super().__call__(*args, **kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/ampixa/ocr/.venv-torch/lib/python3.11/site-packages/torch/nn/modules/module.py", line 1783, in _wrapped_call_impl + return self._call_impl(*args, **kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/ampixa/ocr/.venv-torch/lib/python3.11/site-packages/torch/nn/modules/module.py", line 1794, in _call_impl + return forward_call(*args, **kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/ampixa/ocr/.venv-torch/lib/python3.11/site-packages/transformers/models/pp_lcnet_v3/modeling_pp_lcnet_v3.py", line 247, in forward + hidden_state = self.depthwise_convolution(hidden_state) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/ampixa/ocr/.venv-torch/lib/python3.11/site-packages/torch/nn/modules/module.py", line 1783, in _wrapped_call_impl + return self._call_impl(*args, **kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/ampixa/ocr/.venv-torch/lib/python3.11/site-packages/torch/nn/modules/module.py", line 1794, in _call_impl + return forward_call(*args, **kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/ampixa/ocr/.venv-torch/lib/python3.11/site-packages/transformers/models/pp_lcnet_v3/modeling_pp_lcnet_v3.py", line 157, in forward + output = residual if output is None else output + residual + ~~~~~~~^~~~~~~~~~ +torch.OutOfMemoryError: CUDA out of memory. Tried to allocate 86.00 MiB. GPU 0 has a total capacity of 14.57 GiB of which 58.00 MiB is free. Including non-PyTorch memory, this process has 14.50 GiB memory in use. Of the allocated memory 11.38 GiB is allocated by PyTorch, and 2.99 GiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation. See documentation for Memory Management (https://docs.pytorch.org/docs/stable/notes/cuda.html#optimizing-memory-usage-with-pytorch-cuda-alloc-conf) diff --git a/logs/train_v4.log b/logs/train_v4.log new file mode 100644 index 0000000000000000000000000000000000000000..90d04b95999d3171c0e4354a0d6ab2e249078252 --- /dev/null +++ b/logs/train_v4.log @@ -0,0 +1,190 @@ +{ + "iiit_hw_kept": 69853, + "nep_hw_kept": 3187, + "dhcd_digits_kept": 15000, + "real_v4_kept": 125017, + "cit_ne_kept": 30000, + "office_ne_kept": 12000, + "cit_en_v1_kept": 10000, + "realtext_v1_kept": 29959, + "longne_kept": 19930, + "latin_text_kept": 18881, + "latin_cit_en_kept": 10000, + "nvidia_en_kept": 31934, + "real_dev_kept": 15570, + "synth_dev_kept": 800, + "en_dev_kept": 600, + "hw_hindi_dev_kept": 2000, + "hw_nep_dev_kept": 300 +} +reading image sizes... + Loading weights: 0%| | 0/1035 [00:00//.tsv rows: image_path, reference, prediction, score. +Scoring is done separately with tools/eval_metrics.py. +""" + +from __future__ import annotations + +import json +import sys +import time +from pathlib import Path + +import numpy as np +from paddleocr._models.text_recognition import TextRecognition +from PIL import Image, ImageOps + +HOME = Path.home() +MODELS = { + "deva-v2": ("PP-OCRv5_mobile_rec", HOME / "ampixa-demo/models/ocr/space/models/deva-v2/artifacts"), + "official": ("devanagari_PP-OCRv5_mobile_rec", HOME / ".paddlex/official_models/devanagari_PP-OCRv5_mobile_rec"), +} +BATCH_SIZE = 16 + + +def load_set(root: Path, labels: Path) -> list[tuple[str, str]]: + rows: list[tuple[str, str]] = [] + for line_no, line in enumerate(labels.read_text(encoding="utf-8").splitlines(), start=1): + if not line.strip(): + continue + parts = line.split("\t", 1) + if len(parts) != 2: + raise ValueError(f"{labels}:{line_no}: expected '\\t'") + image_path = root / parts[0] + if not image_path.is_file(): + raise FileNotFoundError(f"{labels}:{line_no}: missing image {image_path}") + rows.append((parts[0], parts[1])) + return rows + + +def to_bgr(path: Path) -> np.ndarray: + # Mirrors the worker: exif_transpose -> RGB -> BGR contiguous ndarray. + with Image.open(path) as probe: + image = ImageOps.exif_transpose(probe).convert("RGB") + return np.asarray(image)[:, :, ::-1].copy() + + +def main() -> int: + out = Path(sys.argv[1]) + sets = { + name: (Path(root), Path(labels)) + for name, root, labels in (arg.split(":", 2) for arg in sys.argv[2:]) + } + timings: dict[str, dict[str, float]] = {} + for model, (model_name, model_dir) in MODELS.items(): + for required in ("inference.json", "inference.pdiparams", "inference.yml"): + if not (model_dir / required).is_file(): + raise FileNotFoundError(f"{model}: missing {model_dir / required}") + predictor = TextRecognition(model_name=model_name, model_dir=str(model_dir), device="cpu") + timings[model] = {} + for set_name, (root, labels) in sets.items(): + rows = load_set(root, labels) + crops = [to_bgr(root / rel) for rel, _ in rows] + started = time.perf_counter() + results = list(predictor.predict(crops, batch_size=BATCH_SIZE)) + elapsed = time.perf_counter() - started + if len(results) != len(rows): + raise RuntimeError(f"{model}/{set_name}: {len(results)} results for {len(rows)} crops") + (out / model).mkdir(parents=True, exist_ok=True) + with (out / model / f"{set_name}.tsv").open("w", encoding="utf-8") as handle: + for (rel, reference), result in zip(rows, results, strict=True): + payload = result.json.get("res", result.json) if hasattr(result, "json") else result + text = str(payload.get("rec_text") or "").strip() + score = payload.get("rec_score") + clean_ref = reference.replace("\t", " ") + handle.write(f"{rel}\t{clean_ref}\t{text.replace(chr(9), ' ')}\t{score}\n") + timings[model][set_name] = round(elapsed / len(rows) * 1000, 2) + print(f"{model} {set_name}: {len(rows)} lines, {timings[model][set_name]} ms/line", flush=True) + (out / "timings_ms_per_line.json").write_text(json.dumps(timings, indent=2), encoding="utf-8") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ocr-deva-eval-20260924/smoke.tgz b/ocr-deva-eval-20260924/smoke.tgz new file mode 100644 index 0000000000000000000000000000000000000000..b6599254067e377819a99959351ab90d9a5cec02 --- /dev/null +++ b/ocr-deva-eval-20260924/smoke.tgz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4e1304b689cdad1fa8f97d83fbbdb823f0d788caec56cbb2bc5b80bb79417ac3 +size 2815497 diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0000.png b/ocr-deva-eval-20260924/smoke/english/images/english_0000.png new file mode 100644 index 0000000000000000000000000000000000000000..5fab30e33fe2c94fc417ce5406257e17bdec4d54 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0000.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0001.png b/ocr-deva-eval-20260924/smoke/english/images/english_0001.png new file mode 100644 index 0000000000000000000000000000000000000000..739b23c9cd05fbc16583fdfd7fe2fcc59257f897 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0001.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0002.png b/ocr-deva-eval-20260924/smoke/english/images/english_0002.png new file mode 100644 index 0000000000000000000000000000000000000000..802f12716542032983f0853db666d5ebe042cde3 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0002.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0003.png b/ocr-deva-eval-20260924/smoke/english/images/english_0003.png new file mode 100644 index 0000000000000000000000000000000000000000..702cc2cc97e3de6797ee976fdf513077859047dc Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0003.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0004.png b/ocr-deva-eval-20260924/smoke/english/images/english_0004.png new file mode 100644 index 0000000000000000000000000000000000000000..fc39d8b87c371f50791f06eb0defde5599f3a4b3 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0004.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0005.png b/ocr-deva-eval-20260924/smoke/english/images/english_0005.png new file mode 100644 index 0000000000000000000000000000000000000000..922b79944686a5cbb2feb25f9767fc3dc8fa369a Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0005.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0006.png b/ocr-deva-eval-20260924/smoke/english/images/english_0006.png new file mode 100644 index 0000000000000000000000000000000000000000..17008397fe1ab7ff6237ea4de25335ff3e5eb098 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0006.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0007.png b/ocr-deva-eval-20260924/smoke/english/images/english_0007.png new file mode 100644 index 0000000000000000000000000000000000000000..1f1a0b52099d2526869db2065e76e67a7c3f2323 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0007.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0008.png b/ocr-deva-eval-20260924/smoke/english/images/english_0008.png new file mode 100644 index 0000000000000000000000000000000000000000..fb607325bfec8716e2b80043a6e30c7d441e39e7 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0008.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0009.png b/ocr-deva-eval-20260924/smoke/english/images/english_0009.png new file mode 100644 index 0000000000000000000000000000000000000000..e13e73b4b9360a212f03d2a244cf0a49ebbd9da6 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0009.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0010.png b/ocr-deva-eval-20260924/smoke/english/images/english_0010.png new file mode 100644 index 0000000000000000000000000000000000000000..ece00e1cc91758f24634c4807b28c42a30c484d5 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0010.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0011.png b/ocr-deva-eval-20260924/smoke/english/images/english_0011.png new file mode 100644 index 0000000000000000000000000000000000000000..eddfc91f7e9aa2aaefaf46d9a34c8f61268da2ac Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0011.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0012.png b/ocr-deva-eval-20260924/smoke/english/images/english_0012.png new file mode 100644 index 0000000000000000000000000000000000000000..ae7b04b541afcb44e546004894821161489f5d01 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0012.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0013.png b/ocr-deva-eval-20260924/smoke/english/images/english_0013.png new file mode 100644 index 0000000000000000000000000000000000000000..f96d83801b7d2eedb10dabfda31d7c4564b586b1 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0013.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0014.png b/ocr-deva-eval-20260924/smoke/english/images/english_0014.png new file mode 100644 index 0000000000000000000000000000000000000000..a4eebf6253619a05710a3bb5f843fda5294648c8 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0014.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0015.png b/ocr-deva-eval-20260924/smoke/english/images/english_0015.png new file mode 100644 index 0000000000000000000000000000000000000000..4bb6a9ef561fc678399908e7b048a48fa97eff95 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0015.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0016.png b/ocr-deva-eval-20260924/smoke/english/images/english_0016.png new file mode 100644 index 0000000000000000000000000000000000000000..8e7c2b9ec7b7991082b3f24f6fcd927741ee3eec Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0016.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0017.png b/ocr-deva-eval-20260924/smoke/english/images/english_0017.png new file mode 100644 index 0000000000000000000000000000000000000000..5d3a3de5ec88681bc9d776030d2ef73ce37f0358 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0017.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0018.png b/ocr-deva-eval-20260924/smoke/english/images/english_0018.png new file mode 100644 index 0000000000000000000000000000000000000000..6c928fb82fdcb9efd99f05111f4f6d000acf2736 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0018.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0019.png b/ocr-deva-eval-20260924/smoke/english/images/english_0019.png new file mode 100644 index 0000000000000000000000000000000000000000..f1870c26d1275625d14f95774af6a3294038d542 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0019.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0020.png b/ocr-deva-eval-20260924/smoke/english/images/english_0020.png new file mode 100644 index 0000000000000000000000000000000000000000..de027b80e6930f4a5c57cce900d6ba92181116ee Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0020.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0021.png b/ocr-deva-eval-20260924/smoke/english/images/english_0021.png new file mode 100644 index 0000000000000000000000000000000000000000..ca3ee9c25f078adc3ddff0e507f161b8c44a8998 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0021.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0022.png b/ocr-deva-eval-20260924/smoke/english/images/english_0022.png new file mode 100644 index 0000000000000000000000000000000000000000..aa45cf1d15b09fde805516449c1da4fc946ed758 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0022.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0023.png b/ocr-deva-eval-20260924/smoke/english/images/english_0023.png new file mode 100644 index 0000000000000000000000000000000000000000..effa125542a8658ab470eaef4f909e209f933111 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0023.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0024.png b/ocr-deva-eval-20260924/smoke/english/images/english_0024.png new file mode 100644 index 0000000000000000000000000000000000000000..463c7ec597f275215aed26a5ee8f7410fb9ac19c Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0024.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0025.png b/ocr-deva-eval-20260924/smoke/english/images/english_0025.png new file mode 100644 index 0000000000000000000000000000000000000000..671578983561b8de3dd14898ea67d65b85921373 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0025.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0026.png b/ocr-deva-eval-20260924/smoke/english/images/english_0026.png new file mode 100644 index 0000000000000000000000000000000000000000..fbeb12b36ea4a66b493ed8761c45c98aa99880c0 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0026.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0027.png b/ocr-deva-eval-20260924/smoke/english/images/english_0027.png new file mode 100644 index 0000000000000000000000000000000000000000..f99c1b3396c8781ca4f987fe5470e8c4ea482ff3 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0027.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0028.png b/ocr-deva-eval-20260924/smoke/english/images/english_0028.png new file mode 100644 index 0000000000000000000000000000000000000000..57c7b98edde7c0d8fdfcaa395fa0ff4edd54d594 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0028.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0029.png b/ocr-deva-eval-20260924/smoke/english/images/english_0029.png new file mode 100644 index 0000000000000000000000000000000000000000..1ed36a8284a76445d2e42a01a2b4bb9047a4bf25 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0029.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0030.png b/ocr-deva-eval-20260924/smoke/english/images/english_0030.png new file mode 100644 index 0000000000000000000000000000000000000000..cba7a61b633d6a4a8ddce0cc8e81589702034715 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0030.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0031.png b/ocr-deva-eval-20260924/smoke/english/images/english_0031.png new file mode 100644 index 0000000000000000000000000000000000000000..984764e7a2ddf09f40489fbb53c08978b99c69a8 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0031.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0032.png b/ocr-deva-eval-20260924/smoke/english/images/english_0032.png new file mode 100644 index 0000000000000000000000000000000000000000..8b5cb16231764a7d6a3b6b9f379d3c14c705fe06 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0032.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0033.png b/ocr-deva-eval-20260924/smoke/english/images/english_0033.png new file mode 100644 index 0000000000000000000000000000000000000000..e09f66fa856990732e71430df591727e9a1e001b Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0033.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0034.png b/ocr-deva-eval-20260924/smoke/english/images/english_0034.png new file mode 100644 index 0000000000000000000000000000000000000000..1515dddf59971dabc5ba0e4c43a5c2d2868c770a Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0034.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0035.png b/ocr-deva-eval-20260924/smoke/english/images/english_0035.png new file mode 100644 index 0000000000000000000000000000000000000000..654858cf17d513d004bb69f0c8d66e60cc13223c Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0035.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0036.png b/ocr-deva-eval-20260924/smoke/english/images/english_0036.png new file mode 100644 index 0000000000000000000000000000000000000000..77dcd0d4abd60194ab81ccd9751bb0ebfa6bcff0 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0036.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0037.png b/ocr-deva-eval-20260924/smoke/english/images/english_0037.png new file mode 100644 index 0000000000000000000000000000000000000000..2a59921df067adb0e6f23b263f54d0e83a7f3d68 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0037.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0038.png b/ocr-deva-eval-20260924/smoke/english/images/english_0038.png new file mode 100644 index 0000000000000000000000000000000000000000..b4069f6d18b104ca9f644c1a7c615faf942f8f6f Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0038.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0039.png b/ocr-deva-eval-20260924/smoke/english/images/english_0039.png new file mode 100644 index 0000000000000000000000000000000000000000..e7016ae8e7ce2f5fdd64ba91c96b4469ecae1a39 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0039.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0040.png b/ocr-deva-eval-20260924/smoke/english/images/english_0040.png new file mode 100644 index 0000000000000000000000000000000000000000..df2f5d44d9fb3c7799a602501cad201ad0b9f0d7 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0040.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0041.png b/ocr-deva-eval-20260924/smoke/english/images/english_0041.png new file mode 100644 index 0000000000000000000000000000000000000000..c2f06b56d4e2c41538637fc6336c9f467ab4ac23 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0041.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0042.png b/ocr-deva-eval-20260924/smoke/english/images/english_0042.png new file mode 100644 index 0000000000000000000000000000000000000000..87cf12fcc160afbdec6cb9696865ed8c733fec8b Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0042.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0043.png b/ocr-deva-eval-20260924/smoke/english/images/english_0043.png new file mode 100644 index 0000000000000000000000000000000000000000..bd7d02d6bf5e294113ed435d9a5018d2f184b062 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0043.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0044.png b/ocr-deva-eval-20260924/smoke/english/images/english_0044.png new file mode 100644 index 0000000000000000000000000000000000000000..240f10cb2fca323b0834cee8203d3dee31ea84d1 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0044.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0045.png b/ocr-deva-eval-20260924/smoke/english/images/english_0045.png new file mode 100644 index 0000000000000000000000000000000000000000..19f0152560658f257055e7e5d0025f94cd3ba65b Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0045.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0046.png b/ocr-deva-eval-20260924/smoke/english/images/english_0046.png new file mode 100644 index 0000000000000000000000000000000000000000..13925e9452b74afdfa73affe104ca87a6463a819 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0046.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0047.png b/ocr-deva-eval-20260924/smoke/english/images/english_0047.png new file mode 100644 index 0000000000000000000000000000000000000000..38230f31058382213ba50841e44e9bb31250e683 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0047.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0048.png b/ocr-deva-eval-20260924/smoke/english/images/english_0048.png new file mode 100644 index 0000000000000000000000000000000000000000..914ee79ed393c98efb92a92a58e9fd2a93dd2d45 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0048.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0049.png b/ocr-deva-eval-20260924/smoke/english/images/english_0049.png new file mode 100644 index 0000000000000000000000000000000000000000..a6f34cdb48872d8b1122f596c82fcfb8d7e60da7 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0049.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0050.png b/ocr-deva-eval-20260924/smoke/english/images/english_0050.png new file mode 100644 index 0000000000000000000000000000000000000000..c3a0491332b42f884c94ec81c90c3cd57963bbeb Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0050.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0051.png b/ocr-deva-eval-20260924/smoke/english/images/english_0051.png new file mode 100644 index 0000000000000000000000000000000000000000..23bcdfc4ec29f771639f66cf4acefa1a2ae24d39 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0051.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0052.png b/ocr-deva-eval-20260924/smoke/english/images/english_0052.png new file mode 100644 index 0000000000000000000000000000000000000000..da79a12fc4f9746b228ca468809d53bf3f5868dc Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0052.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0053.png b/ocr-deva-eval-20260924/smoke/english/images/english_0053.png new file mode 100644 index 0000000000000000000000000000000000000000..35ea5c95e89eb2b4c164ae87af586e20770a4ceb Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0053.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0054.png b/ocr-deva-eval-20260924/smoke/english/images/english_0054.png new file mode 100644 index 0000000000000000000000000000000000000000..eff33188d98255990001f027742821e516ef3b06 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0054.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0055.png b/ocr-deva-eval-20260924/smoke/english/images/english_0055.png new file mode 100644 index 0000000000000000000000000000000000000000..23a12c2496e135de8af8cdd51de4c12b4c2e5ecd Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0055.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0056.png b/ocr-deva-eval-20260924/smoke/english/images/english_0056.png new file mode 100644 index 0000000000000000000000000000000000000000..11fe887a3fddf30996af1ead44594f4ac12c946c Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0056.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0057.png b/ocr-deva-eval-20260924/smoke/english/images/english_0057.png new file mode 100644 index 0000000000000000000000000000000000000000..de49042b85682ff3125a5d208058c025c7285996 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0057.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0058.png b/ocr-deva-eval-20260924/smoke/english/images/english_0058.png new file mode 100644 index 0000000000000000000000000000000000000000..4c2d9f62241d048177e2b58a8ae8ffc6eaa8a40a Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0058.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0059.png b/ocr-deva-eval-20260924/smoke/english/images/english_0059.png new file mode 100644 index 0000000000000000000000000000000000000000..0163ec99f6cc9e7cae45e462b0a95cadf6007024 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0059.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0060.png b/ocr-deva-eval-20260924/smoke/english/images/english_0060.png new file mode 100644 index 0000000000000000000000000000000000000000..215c5230ca85fd20f2c31f9baeb1b52449d3f4ab Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0060.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0061.png b/ocr-deva-eval-20260924/smoke/english/images/english_0061.png new file mode 100644 index 0000000000000000000000000000000000000000..5cefde2659358f8eb45dc15ca547f25d15cc9535 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0061.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0062.png b/ocr-deva-eval-20260924/smoke/english/images/english_0062.png new file mode 100644 index 0000000000000000000000000000000000000000..b9ce40f0120c3fadc6a0ec039d09459ddc61eaaf Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0062.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0063.png b/ocr-deva-eval-20260924/smoke/english/images/english_0063.png new file mode 100644 index 0000000000000000000000000000000000000000..1714a62ac5e162220084fd3a206960a01c8622ea Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0063.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0064.png b/ocr-deva-eval-20260924/smoke/english/images/english_0064.png new file mode 100644 index 0000000000000000000000000000000000000000..deccb57fa99dda4290b106dff1d23d61674a2841 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0064.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0065.png b/ocr-deva-eval-20260924/smoke/english/images/english_0065.png new file mode 100644 index 0000000000000000000000000000000000000000..ffda0f0ed0a8b7d55a70ed4563780f54517b43db Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0065.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0066.png b/ocr-deva-eval-20260924/smoke/english/images/english_0066.png new file mode 100644 index 0000000000000000000000000000000000000000..499ca18a5a1f75e8e26fa80a7b33751c286300d6 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0066.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0067.png b/ocr-deva-eval-20260924/smoke/english/images/english_0067.png new file mode 100644 index 0000000000000000000000000000000000000000..57daff18023b4f5ec904071e8678bff272fdae36 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0067.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0068.png b/ocr-deva-eval-20260924/smoke/english/images/english_0068.png new file mode 100644 index 0000000000000000000000000000000000000000..2b9c19cba70e83fe7d25d2e2c2ceba956cb678e5 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0068.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0069.png b/ocr-deva-eval-20260924/smoke/english/images/english_0069.png new file mode 100644 index 0000000000000000000000000000000000000000..872e3d4360f3440600b12d610034c42c59860a40 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0069.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0070.png b/ocr-deva-eval-20260924/smoke/english/images/english_0070.png new file mode 100644 index 0000000000000000000000000000000000000000..e453c5296c82d592809678eeb37b6cc63a29c340 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0070.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0071.png b/ocr-deva-eval-20260924/smoke/english/images/english_0071.png new file mode 100644 index 0000000000000000000000000000000000000000..9a1032d2944552bdd7881306de992c6f0c649e91 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0071.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0072.png b/ocr-deva-eval-20260924/smoke/english/images/english_0072.png new file mode 100644 index 0000000000000000000000000000000000000000..28b9f3a447697ce26212cf6eb187a810834b5b60 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0072.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0073.png b/ocr-deva-eval-20260924/smoke/english/images/english_0073.png new file mode 100644 index 0000000000000000000000000000000000000000..1ef48e025e84c6b74e3e6e5f69a1b95e9381f726 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0073.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0074.png b/ocr-deva-eval-20260924/smoke/english/images/english_0074.png new file mode 100644 index 0000000000000000000000000000000000000000..399fef6663d962b32faf14525cdb63872a692ee8 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0074.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0075.png b/ocr-deva-eval-20260924/smoke/english/images/english_0075.png new file mode 100644 index 0000000000000000000000000000000000000000..fea3aeb5cf0701a4a812cac38a4db046e4f3881e Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0075.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0076.png b/ocr-deva-eval-20260924/smoke/english/images/english_0076.png new file mode 100644 index 0000000000000000000000000000000000000000..cd85d73a9af2e5d58a15b17725181693929c5b78 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0076.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0077.png b/ocr-deva-eval-20260924/smoke/english/images/english_0077.png new file mode 100644 index 0000000000000000000000000000000000000000..db92ad908028447c977c102ccee0c31620038a29 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0077.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0078.png b/ocr-deva-eval-20260924/smoke/english/images/english_0078.png new file mode 100644 index 0000000000000000000000000000000000000000..ea618945946767f76ef2d5727606015c730fd766 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0078.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0079.png b/ocr-deva-eval-20260924/smoke/english/images/english_0079.png new file mode 100644 index 0000000000000000000000000000000000000000..5072a972a655cc4d7493193b35db91020dd75ac3 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0079.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0080.png b/ocr-deva-eval-20260924/smoke/english/images/english_0080.png new file mode 100644 index 0000000000000000000000000000000000000000..d9a5202a17c4263bb14b61620a22a0ad0f29eb5e Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0080.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0081.png b/ocr-deva-eval-20260924/smoke/english/images/english_0081.png new file mode 100644 index 0000000000000000000000000000000000000000..ba1b6f255aabbbed354f274dc3ee11d1379dbe17 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0081.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0082.png b/ocr-deva-eval-20260924/smoke/english/images/english_0082.png new file mode 100644 index 0000000000000000000000000000000000000000..d18566a33d79a3433bb6030f9c11c8274e3f4275 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0082.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0083.png b/ocr-deva-eval-20260924/smoke/english/images/english_0083.png new file mode 100644 index 0000000000000000000000000000000000000000..46adc8e78bf5e5ff221de1db88413e0aee1b42a9 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0083.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0084.png b/ocr-deva-eval-20260924/smoke/english/images/english_0084.png new file mode 100644 index 0000000000000000000000000000000000000000..22ebd70434d2aedc3bb4e7b76dcf7ca20638bc73 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0084.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0085.png b/ocr-deva-eval-20260924/smoke/english/images/english_0085.png new file mode 100644 index 0000000000000000000000000000000000000000..50a7be700ab715006cd117e552acb06bbbdfc9e7 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0085.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0086.png b/ocr-deva-eval-20260924/smoke/english/images/english_0086.png new file mode 100644 index 0000000000000000000000000000000000000000..0306a0f58b4993c331b58e477814df8eaac3b09e Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0086.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0087.png b/ocr-deva-eval-20260924/smoke/english/images/english_0087.png new file mode 100644 index 0000000000000000000000000000000000000000..387963dbe5ac439e39fe6df4c2f3726daca9a142 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0087.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0088.png b/ocr-deva-eval-20260924/smoke/english/images/english_0088.png new file mode 100644 index 0000000000000000000000000000000000000000..1a28e97541cf4626cc43af4a08ed7d2fdfec76af Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0088.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0089.png b/ocr-deva-eval-20260924/smoke/english/images/english_0089.png new file mode 100644 index 0000000000000000000000000000000000000000..dee62902a46a161bb0609a76b18983f32198a1e5 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0089.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0090.png b/ocr-deva-eval-20260924/smoke/english/images/english_0090.png new file mode 100644 index 0000000000000000000000000000000000000000..0255e082f69ed43b06d618aff136deb478fa68e7 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0090.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0091.png b/ocr-deva-eval-20260924/smoke/english/images/english_0091.png new file mode 100644 index 0000000000000000000000000000000000000000..274e79538a267fef8ffee76461d130e34a842b07 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0091.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0092.png b/ocr-deva-eval-20260924/smoke/english/images/english_0092.png new file mode 100644 index 0000000000000000000000000000000000000000..e3f9afe9b67371493f36a56a520d20c0ff5fdee6 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0092.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0093.png b/ocr-deva-eval-20260924/smoke/english/images/english_0093.png new file mode 100644 index 0000000000000000000000000000000000000000..203427824c38ef6b6724281c9f169a978af15f69 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0093.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0094.png b/ocr-deva-eval-20260924/smoke/english/images/english_0094.png new file mode 100644 index 0000000000000000000000000000000000000000..593399e9cc85aa2ea99f813f3739692db06349f4 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0094.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0095.png b/ocr-deva-eval-20260924/smoke/english/images/english_0095.png new file mode 100644 index 0000000000000000000000000000000000000000..d0187acd36d6bca6cc630be5b3c4905720b18ec2 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0095.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0096.png b/ocr-deva-eval-20260924/smoke/english/images/english_0096.png new file mode 100644 index 0000000000000000000000000000000000000000..49eb056a3a7f194b718c949d0d56296f51b64bbc Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0096.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0097.png b/ocr-deva-eval-20260924/smoke/english/images/english_0097.png new file mode 100644 index 0000000000000000000000000000000000000000..07002671dc5a3b9ed2a100bff1b6ed625ec91bff Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0097.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0098.png b/ocr-deva-eval-20260924/smoke/english/images/english_0098.png new file mode 100644 index 0000000000000000000000000000000000000000..28a912f4b175bc6b6e4e590b63692e65321b71a2 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0098.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0099.png b/ocr-deva-eval-20260924/smoke/english/images/english_0099.png new file mode 100644 index 0000000000000000000000000000000000000000..4d08b9bd346639253ecbc9f0f5d115e06056c21b Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0099.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0100.png b/ocr-deva-eval-20260924/smoke/english/images/english_0100.png new file mode 100644 index 0000000000000000000000000000000000000000..19595aa15430623f4312c51b8e5b848c7781cb5a Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0100.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0101.png b/ocr-deva-eval-20260924/smoke/english/images/english_0101.png new file mode 100644 index 0000000000000000000000000000000000000000..3c5c2f333cc8bfc2a5a4522b65f0a4c43e222a64 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0101.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0102.png b/ocr-deva-eval-20260924/smoke/english/images/english_0102.png new file mode 100644 index 0000000000000000000000000000000000000000..58fe1155c1a44239b73c415b730314c04dbeb9b2 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0102.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0103.png b/ocr-deva-eval-20260924/smoke/english/images/english_0103.png new file mode 100644 index 0000000000000000000000000000000000000000..243884d42d7cf5504f2316adb232941a19535d42 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0103.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0104.png b/ocr-deva-eval-20260924/smoke/english/images/english_0104.png new file mode 100644 index 0000000000000000000000000000000000000000..4e46358e4497bed1df5f8684712ed908b5291159 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0104.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0105.png b/ocr-deva-eval-20260924/smoke/english/images/english_0105.png new file mode 100644 index 0000000000000000000000000000000000000000..49dc704492ecea1acf4b09234834e31aaf1c93ff Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0105.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0106.png b/ocr-deva-eval-20260924/smoke/english/images/english_0106.png new file mode 100644 index 0000000000000000000000000000000000000000..f0e4814ec3f954565739198f6a41a954686052a5 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0106.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0107.png b/ocr-deva-eval-20260924/smoke/english/images/english_0107.png new file mode 100644 index 0000000000000000000000000000000000000000..1bbf365ecf17943136fc3e0915ee3bf999fd4e7b Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0107.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0108.png b/ocr-deva-eval-20260924/smoke/english/images/english_0108.png new file mode 100644 index 0000000000000000000000000000000000000000..e43da2d05fbb9cda7b91060e8d5be19622b27c36 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0108.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0109.png b/ocr-deva-eval-20260924/smoke/english/images/english_0109.png new file mode 100644 index 0000000000000000000000000000000000000000..ac20b92e039950a67ef722768a00c3bd1d60c376 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0109.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0110.png b/ocr-deva-eval-20260924/smoke/english/images/english_0110.png new file mode 100644 index 0000000000000000000000000000000000000000..8d04d36112ab0cdad825f1a2e4fb565bffaabd40 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0110.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0111.png b/ocr-deva-eval-20260924/smoke/english/images/english_0111.png new file mode 100644 index 0000000000000000000000000000000000000000..186579e86268877a9ac8d8f24a4498530b5bde50 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0111.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0112.png b/ocr-deva-eval-20260924/smoke/english/images/english_0112.png new file mode 100644 index 0000000000000000000000000000000000000000..7ec9559faed9a692ef74643e0e61261999fee6c0 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0112.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0113.png b/ocr-deva-eval-20260924/smoke/english/images/english_0113.png new file mode 100644 index 0000000000000000000000000000000000000000..00a58c05c7e102c2f3aa943176a235fe9e4f73a1 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0113.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0114.png b/ocr-deva-eval-20260924/smoke/english/images/english_0114.png new file mode 100644 index 0000000000000000000000000000000000000000..40ea95ca25817760a88b3baec6bdeaf1b8a9edc1 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0114.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0115.png b/ocr-deva-eval-20260924/smoke/english/images/english_0115.png new file mode 100644 index 0000000000000000000000000000000000000000..6c88c3244098b51ff33d1d7b3087bd0c070dec5c Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0115.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0116.png b/ocr-deva-eval-20260924/smoke/english/images/english_0116.png new file mode 100644 index 0000000000000000000000000000000000000000..d579561e5e9f08d434dd7ba575dc029d5a90f40d Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0116.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0117.png b/ocr-deva-eval-20260924/smoke/english/images/english_0117.png new file mode 100644 index 0000000000000000000000000000000000000000..a7b3fa6a58fc1b72c74b0d94e61a9b3c1917a4d0 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0117.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0118.png b/ocr-deva-eval-20260924/smoke/english/images/english_0118.png new file mode 100644 index 0000000000000000000000000000000000000000..f432cd2c7e62a673be74af04e108bab28bb065b0 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0118.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/images/english_0119.png b/ocr-deva-eval-20260924/smoke/english/images/english_0119.png new file mode 100644 index 0000000000000000000000000000000000000000..6c25bc1d58c838a4f10382417668920cf4b3bd67 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/english/images/english_0119.png differ diff --git a/ocr-deva-eval-20260924/smoke/english/labels.txt b/ocr-deva-eval-20260924/smoke/english/labels.txt new file mode 100644 index 0000000000000000000000000000000000000000..21d4fc4bfc1d54cb72e34d0fa3a593f8b65b69e8 --- /dev/null +++ b/ocr-deva-eval-20260924/smoke/english/labels.txt @@ -0,0 +1,120 @@ +images/english_0000.png Name: Dipak Maharjan +images/english_0001.png Name: Prakash Rai +images/english_0002.png Ministry of Education, Science and Technology +images/english_0003.png Name: Sita Karki +images/english_0004.png Quality Control Department +images/english_0005.png Date of Birth: 02/09/1970 +images/english_0006.png Total Amount: Rs. 67,589.00 +images/english_0007.png Total Amount: Rs. 29,804.00 +images/english_0008.png Name: Bikash Sharma +images/english_0009.png Citizenship No. 72-28-75-29783 +images/english_0010.png Email: anjali.tamang@yahoo.com +images/english_0011.png Name: Sita Bista +images/english_0012.png Name: Kamala Maharjan +images/english_0013.png Name: Suresh Shrestha +images/english_0014.png Name: Suresh Rai +images/english_0015.png Total Amount: Rs. 95,444.00 +images/english_0016.png Name: Prakash Tamang +images/english_0017.png Phone: 9812799146 +images/english_0018.png Name: Hari Bista +images/english_0019.png Citizenship No. 58-53-82-37809 +images/english_0020.png Invoice No. INV-2024-9422 +images/english_0021.png Citizenship No. 52-29-82-14251 +images/english_0022.png Email: gita.limbu@gmail.com +images/english_0023.png Quality Control Department +images/english_0024.png Invoice No. INV-2020-5129 +images/english_0025.png Address: Butwal-28, Baneshwor +images/english_0026.png For office use only +images/english_0027.png Signature of the Applicant +images/english_0028.png Terms and Conditions Apply +images/english_0029.png Address: Taplejung-6, Lakeside +images/english_0030.png Name: Bikash Adhikari +images/english_0031.png Invoice No. INV-2023-9933 +images/english_0032.png Citizenship No. 11-49-70-32308 +images/english_0033.png Email: suresh.bista@ampixa.com +images/english_0034.png Phone: 9832497777 +images/english_0035.png Email: ram.thapa@ampixa.com +images/english_0036.png Citizenship No. 17-45-67-17734 +images/english_0037.png Citizenship No. 49-99-60-51712 +images/english_0038.png Address: Butwal-26, Thamel +images/english_0039.png Please submit the form before the deadline. +images/english_0040.png Total Amount: Rs. 22,339.00 +images/english_0041.png Date of Birth: 10/10/1989 +images/english_0042.png Ward Office, Kathmandu Metropolitan City +images/english_0043.png Date of Birth: 05/12/1998 +images/english_0044.png Date of Birth: 22/05/1998 +images/english_0045.png Citizenship No. 24-73-78-99698 +images/english_0046.png Email: anjali.maharjan@ampixa.com +images/english_0047.png Date of Birth: 20/07/1975 +images/english_0048.png Received with thanks from the above party. +images/english_0049.png Address: Kathmandu-4, Kalanki +images/english_0050.png Invoice No. INV-2023-8263 +images/english_0051.png Phone: 9878974340 +images/english_0052.png Citizenship No. 36-65-63-96785 +images/english_0053.png Date of Birth: 28/10/2010 +images/english_0054.png Name: Sita Magar +images/english_0055.png Email: anjali.rai@gmail.com +images/english_0056.png Name: Prakash Gurung +images/english_0057.png Address: Biratnagar-7, Baneshwor +images/english_0058.png Email: kamala.limbu@gmail.com +images/english_0059.png Date of Birth: 19/11/1978 +images/english_0060.png Address: Pokhara-23, Lakeside +images/english_0061.png Email: sunita.tamang@gmail.com +images/english_0062.png Phone: 9830442584 +images/english_0063.png Date of Birth: 12/09/1989 +images/english_0064.png Phone: 9857391765 +images/english_0065.png Received with thanks from the above party. +images/english_0066.png Address: Taplejung-25, Bhanuchowk +images/english_0067.png Invoice No. INV-2021-4499 +images/english_0068.png Phone: 9897462954 +images/english_0069.png Phone: 9834822880 +images/english_0070.png Total Amount: Rs. 47,892.00 +images/english_0071.png Date of Birth: 26/09/1993 +images/english_0072.png Date of Birth: 13/02/1975 +images/english_0073.png Date of Birth: 24/07/1988 +images/english_0074.png Date of Birth: 16/01/1961 +images/english_0075.png Citizenship No. 39-32-82-57896 +images/english_0076.png Name: Ram Magar +images/english_0077.png Citizenship No. 50-19-74-59311 +images/english_0078.png Phone: 9849609824 +images/english_0079.png Address: Pokhara-19, Lakeside +images/english_0080.png Signature of the Applicant +images/english_0081.png Date of Birth: 11/06/1970 +images/english_0082.png Phone: 9879318111 +images/english_0083.png Name: Bikash Gurung +images/english_0084.png Please submit the form before the deadline. +images/english_0085.png Email: sita.maharjan@ampixa.com +images/english_0086.png The meeting will be held on Sunday at 10 AM. +images/english_0087.png Email: sunita.magar@gmail.com +images/english_0088.png Email: bikash.adhikari@example.com +images/english_0089.png Name: Bikash Shrestha +images/english_0090.png Date of Birth: 17/09/1984 +images/english_0091.png Email: dipak.gurung@example.com +images/english_0092.png Phone: 9856941244 +images/english_0093.png Address: Ilam-31, Maitighar +images/english_0094.png Citizenship No. 60-15-73-79262 +images/english_0095.png Invoice No. INV-2026-5563 +images/english_0096.png Total Amount: Rs. 21,352.00 +images/english_0097.png Invoice No. INV-2024-3203 +images/english_0098.png Phone: 9880924094 +images/english_0099.png Total Amount: Rs. 37,315.00 +images/english_0100.png Address: Bhaktapur-26, Lakeside +images/english_0101.png Email: manisha.bista@ampixa.com +images/english_0102.png Invoice No. INV-2025-8254 +images/english_0103.png Invoice No. INV-2026-0182 +images/english_0104.png Address: Taplejung-28, Baneshwor +images/english_0105.png Name: Bikash Karki +images/english_0106.png Name: Manisha Bista +images/english_0107.png Phone: 9837987347 +images/english_0108.png Email: kamala.rai@example.com +images/english_0109.png Citizenship No. 74-21-76-41702 +images/english_0110.png Name: Sunita Bista +images/english_0111.png Ward Office, Kathmandu Metropolitan City +images/english_0112.png Invoice No. INV-2023-8004 +images/english_0113.png Email: suresh.karki@gmail.com +images/english_0114.png Address: Taplejung-8, Bhanuchowk +images/english_0115.png Email: dipak.bista@yahoo.com +images/english_0116.png Name: Suresh Magar +images/english_0117.png Date of Birth: 03/04/1979 +images/english_0118.png Total Amount: Rs. 79,463.00 +images/english_0119.png Name: Ram Bista diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0000.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0000.png new file mode 100644 index 0000000000000000000000000000000000000000..a95742c2cd23d47cce3fb074d9ea6aff71b3e4bc Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0000.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0001.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0001.png new file mode 100644 index 0000000000000000000000000000000000000000..9f9317c3ace62e257dece510545ac60fef2ae97c Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0001.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0002.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0002.png new file mode 100644 index 0000000000000000000000000000000000000000..35c88b14a683aff03c73f83695a4cfd6834891f3 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0002.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0003.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0003.png new file mode 100644 index 0000000000000000000000000000000000000000..19af978e247193ee9517103580a9f0ce7e3d3b82 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0003.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0004.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0004.png new file mode 100644 index 0000000000000000000000000000000000000000..6fc9b8794ac59362c546dbbfa05e7a2af2b180fb Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0004.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0005.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0005.png new file mode 100644 index 0000000000000000000000000000000000000000..1f39d9bc6dadaf537373bc4438e9c01b0c8cef7d Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0005.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0006.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0006.png new file mode 100644 index 0000000000000000000000000000000000000000..2e4016eec5aab7e0275afbc5f2939bea0c54b8f0 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0006.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0007.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0007.png new file mode 100644 index 0000000000000000000000000000000000000000..bb91151dec48424884b0608751f78171463ab71a Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0007.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0008.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0008.png new file mode 100644 index 0000000000000000000000000000000000000000..e6d1a072ceaf05a00a03b25ec51ba0b4113765c9 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0008.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0009.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0009.png new file mode 100644 index 0000000000000000000000000000000000000000..fddd2563a5b6179217718b20c6bbf37626c326b8 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0009.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0010.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0010.png new file mode 100644 index 0000000000000000000000000000000000000000..c878d047d1f2ee855a15d8a2337a28797f331821 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0010.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0011.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0011.png new file mode 100644 index 0000000000000000000000000000000000000000..a0e1485679bde93b40130a8d389f1fec7c2611f2 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0011.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0012.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0012.png new file mode 100644 index 0000000000000000000000000000000000000000..0aadf710eafded5f393a33c2aa5c50a941bdede5 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0012.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0013.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0013.png new file mode 100644 index 0000000000000000000000000000000000000000..b53e2ba37be0bf96c1a11493737062d691eabe08 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0013.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0014.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0014.png new file mode 100644 index 0000000000000000000000000000000000000000..31045c396efc427cffcf983594b0925c80195e71 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0014.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0015.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0015.png new file mode 100644 index 0000000000000000000000000000000000000000..0726dbac4c186f29e9f716a1e8b2596d1f352002 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0015.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0016.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0016.png new file mode 100644 index 0000000000000000000000000000000000000000..9d5fda642a68315b23c7505073905db8d43df1a1 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0016.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0017.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0017.png new file mode 100644 index 0000000000000000000000000000000000000000..2728da89ab8a1b32621bff163435f2279b91f2e9 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0017.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0018.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0018.png new file mode 100644 index 0000000000000000000000000000000000000000..2faca1398f200c4c976069fa7cc79006aee176c3 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0018.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0019.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0019.png new file mode 100644 index 0000000000000000000000000000000000000000..c67c08221471ac39119aad5a056b01cc082bda3c Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0019.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0020.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0020.png new file mode 100644 index 0000000000000000000000000000000000000000..6e3cad551d0681a0124f6f26e6a1a77723159b97 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0020.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0021.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0021.png new file mode 100644 index 0000000000000000000000000000000000000000..feda823e362ae98b3aaf22b8462b860ec110190e Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0021.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0022.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0022.png new file mode 100644 index 0000000000000000000000000000000000000000..ff2b2caff3a5a86414ec606d88175e0036e1a8a0 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0022.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0023.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0023.png new file mode 100644 index 0000000000000000000000000000000000000000..b63802099d27f6bd15f18c4a71ba95ebda745ddc Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0023.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0024.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0024.png new file mode 100644 index 0000000000000000000000000000000000000000..bf1206c7b3c7980198c03c97a8196b2226362204 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0024.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0025.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0025.png new file mode 100644 index 0000000000000000000000000000000000000000..6bfe553d33f94a23981fbf2163723e6584513a23 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0025.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0026.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0026.png new file mode 100644 index 0000000000000000000000000000000000000000..a8fe9464827f33a27b3412ab33afa8fa579c6c65 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0026.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0027.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0027.png new file mode 100644 index 0000000000000000000000000000000000000000..1415965f57bf95e4a54fc5551edfd4e86ee4f52d Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0027.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0028.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0028.png new file mode 100644 index 0000000000000000000000000000000000000000..883b22e102ae85d0eeedd24d7fde8af9c0bd89cb Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0028.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0029.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0029.png new file mode 100644 index 0000000000000000000000000000000000000000..7f88e47e50d2076f0526088cfda136394c61eb62 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0029.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0030.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0030.png new file mode 100644 index 0000000000000000000000000000000000000000..5f6006cf23423a6c244e5d0011fb879212dac1c8 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0030.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0031.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0031.png new file mode 100644 index 0000000000000000000000000000000000000000..bf5fe206b159026aaf97c5126791aa349f5a4121 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0031.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0032.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0032.png new file mode 100644 index 0000000000000000000000000000000000000000..0d6d9d77f9b08d7d5708130d9f0ee5d9becbc676 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0032.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0033.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0033.png new file mode 100644 index 0000000000000000000000000000000000000000..ee82a006f7773aec70756fc099962bd30e33b41c Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0033.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0034.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0034.png new file mode 100644 index 0000000000000000000000000000000000000000..023d1325561579031580e9c209d95dbd21fe2eb5 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0034.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0035.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0035.png new file mode 100644 index 0000000000000000000000000000000000000000..0af6c7857fe2a5accad1bdba632b3065c984aaef Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0035.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0036.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0036.png new file mode 100644 index 0000000000000000000000000000000000000000..d50c3f6ed4aa6a1bc82cd3543ed8f1a11137a66b Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0036.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0037.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0037.png new file mode 100644 index 0000000000000000000000000000000000000000..38f2abfd101a1f7c13289c74dec73053ca9e0272 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0037.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0038.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0038.png new file mode 100644 index 0000000000000000000000000000000000000000..ca3342e767882510b72bb8f5638200afa99583ee Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0038.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0039.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0039.png new file mode 100644 index 0000000000000000000000000000000000000000..4a1f262466a69917d1a6d32ef883ed578045117c Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0039.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0040.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0040.png new file mode 100644 index 0000000000000000000000000000000000000000..6214bfbd412540653d0527ce24ac4081d0a9af7d Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0040.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0041.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0041.png new file mode 100644 index 0000000000000000000000000000000000000000..2f15170820d607af47e3714d4f917ac188edcb85 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0041.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0042.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0042.png new file mode 100644 index 0000000000000000000000000000000000000000..a20ece70615baacf50f5d3d4facda3afdd4f27d4 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0042.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0043.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0043.png new file mode 100644 index 0000000000000000000000000000000000000000..0ca8ac961d22e6993b0f287e42f716261443d296 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0043.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0044.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0044.png new file mode 100644 index 0000000000000000000000000000000000000000..63ce6655f97b3811270fb72303c2706943f50af3 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0044.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0045.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0045.png new file mode 100644 index 0000000000000000000000000000000000000000..2c255ebb340f985ad259ba30ccd5284cb3abd215 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0045.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0046.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0046.png new file mode 100644 index 0000000000000000000000000000000000000000..01befd53d6e3722cf1d4ef8a586c54282a93ed75 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0046.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0047.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0047.png new file mode 100644 index 0000000000000000000000000000000000000000..148ef2548e80e710ebe3c962a376340cb25070ab Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0047.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0048.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0048.png new file mode 100644 index 0000000000000000000000000000000000000000..f93c47b2c873e3526e06b08babfa742763b4cfe9 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0048.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0049.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0049.png new file mode 100644 index 0000000000000000000000000000000000000000..cb056b19d54a8080465315efb5812d2407ed592f Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0049.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0050.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0050.png new file mode 100644 index 0000000000000000000000000000000000000000..2c3a021f0528d31d273a2ab0e361c35a3d48e319 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0050.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0051.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0051.png new file mode 100644 index 0000000000000000000000000000000000000000..1e246d8040b5be368fa00b0c16790394285d0c6b Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0051.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0052.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0052.png new file mode 100644 index 0000000000000000000000000000000000000000..badd81a97f74a5e2c5772b969c80579b7c948abe Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0052.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0053.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0053.png new file mode 100644 index 0000000000000000000000000000000000000000..805778dc46155a245fcc85af293969bb27c77658 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0053.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0054.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0054.png new file mode 100644 index 0000000000000000000000000000000000000000..110280001d11d6daf35faf79e8eefdedd327e21e Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0054.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0055.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0055.png new file mode 100644 index 0000000000000000000000000000000000000000..2ecbba11b2bfb7bd87fd88b554b424963c020043 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0055.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0056.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0056.png new file mode 100644 index 0000000000000000000000000000000000000000..4b6a449076772af66ff79aee0624504a169eba67 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0056.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0057.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0057.png new file mode 100644 index 0000000000000000000000000000000000000000..d8fbdc187226498dbb27b6d8672bee54474ae286 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0057.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0058.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0058.png new file mode 100644 index 0000000000000000000000000000000000000000..1317107c45b1e17f1989fbb03e9621c984a6882e Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0058.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0059.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0059.png new file mode 100644 index 0000000000000000000000000000000000000000..2b055d6b4f7b4a588adad103651ba61e33d108ae Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0059.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0060.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0060.png new file mode 100644 index 0000000000000000000000000000000000000000..af36b37dffc6425836dae85ef61106e841f05142 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0060.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0061.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0061.png new file mode 100644 index 0000000000000000000000000000000000000000..2db511bddcd9e1425e510f154c8c561d46450d93 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0061.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0062.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0062.png new file mode 100644 index 0000000000000000000000000000000000000000..e4b564241109352998d58b494bcfe7eaf82e126f Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0062.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0063.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0063.png new file mode 100644 index 0000000000000000000000000000000000000000..066c60239318087adad84a68162b54f13573eb88 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0063.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0064.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0064.png new file mode 100644 index 0000000000000000000000000000000000000000..06b1b51b37960e23d58251fc7347b12eb41ff55e Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0064.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0065.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0065.png new file mode 100644 index 0000000000000000000000000000000000000000..a34e9c9172562b8481127ff53160d5c1114b6650 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0065.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0066.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0066.png new file mode 100644 index 0000000000000000000000000000000000000000..dc829647312b0804e29d10e7588c1182e0da9292 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0066.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0067.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0067.png new file mode 100644 index 0000000000000000000000000000000000000000..75cb96b519c3a168b12338e70d279845b1128fb2 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0067.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0068.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0068.png new file mode 100644 index 0000000000000000000000000000000000000000..113d3e0829175d501c79c55ded88d5c0f7babf76 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0068.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0069.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0069.png new file mode 100644 index 0000000000000000000000000000000000000000..326541311abdef20af954bd97f78f34d92bdc029 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0069.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0070.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0070.png new file mode 100644 index 0000000000000000000000000000000000000000..02d0231a3470fc9be86ef24ba6f92a1a6a9eea8a Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0070.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0071.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0071.png new file mode 100644 index 0000000000000000000000000000000000000000..a9ab675122427ce96d71051bec93a72381c642ad Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0071.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0072.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0072.png new file mode 100644 index 0000000000000000000000000000000000000000..2e1c126ccc400778c3ea931a2bae415a5cd75349 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0072.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0073.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0073.png new file mode 100644 index 0000000000000000000000000000000000000000..68266e6b1acb16baa81560da1f744110b9c6019d Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0073.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0074.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0074.png new file mode 100644 index 0000000000000000000000000000000000000000..16e84bb02f5ed0925d17358403b47400395156f6 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0074.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0075.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0075.png new file mode 100644 index 0000000000000000000000000000000000000000..39d7da2973f252699127dc2184ffa39c471488ed Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0075.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0076.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0076.png new file mode 100644 index 0000000000000000000000000000000000000000..bf58f7b7d570bdc55bd9687675569de43ddf1e89 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0076.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0077.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0077.png new file mode 100644 index 0000000000000000000000000000000000000000..eb68d37a3316c577eab1d5eb271fc6b1b4e4f85d Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0077.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0078.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0078.png new file mode 100644 index 0000000000000000000000000000000000000000..8cf4f7f088b743550d5b31539b0c80ec00200ab7 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0078.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0079.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0079.png new file mode 100644 index 0000000000000000000000000000000000000000..a2d4818c57fe9d25d63b0fc59f3bcd2caac35620 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0079.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0080.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0080.png new file mode 100644 index 0000000000000000000000000000000000000000..d30f766a0bc30bcea3aeb92041f2e476fc94b5a3 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0080.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0081.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0081.png new file mode 100644 index 0000000000000000000000000000000000000000..f250c116c5f8a3e03c9804c7dde4a9859adc792e Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0081.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0082.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0082.png new file mode 100644 index 0000000000000000000000000000000000000000..21314cb7dcc7f3fbf16bca6bf718976593eb9946 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0082.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0083.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0083.png new file mode 100644 index 0000000000000000000000000000000000000000..b7ac7241a7d0c712f36427a62bac3218ab0bca05 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0083.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0084.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0084.png new file mode 100644 index 0000000000000000000000000000000000000000..d4a27aea4c50f70f32d67695cd817e1592bd67e7 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0084.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0085.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0085.png new file mode 100644 index 0000000000000000000000000000000000000000..8ff7cf3c4846d28271f83a2fefb48f60978c08f1 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0085.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0086.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0086.png new file mode 100644 index 0000000000000000000000000000000000000000..23bbeeafb56ae87c1372e510aabcb2320a9a42e4 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0086.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0087.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0087.png new file mode 100644 index 0000000000000000000000000000000000000000..618c9a8a1aa16b4879c5d73547df91a7d69dc5d0 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0087.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0088.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0088.png new file mode 100644 index 0000000000000000000000000000000000000000..2e1e301c60b638e662f4539d4a4fb4ef44ebaf95 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0088.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0089.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0089.png new file mode 100644 index 0000000000000000000000000000000000000000..222932b8450ac087782e11267118aa385185e6cb Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0089.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0090.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0090.png new file mode 100644 index 0000000000000000000000000000000000000000..4fff022c6cc72fe9e4f8ba25f221c57b8059c021 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0090.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0091.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0091.png new file mode 100644 index 0000000000000000000000000000000000000000..015562b072e8060562ecf877df33bdec8edb0c61 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0091.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0092.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0092.png new file mode 100644 index 0000000000000000000000000000000000000000..c92c0ce866a9c01c5c1e2a2ebc0a5da8f6d23772 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0092.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0093.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0093.png new file mode 100644 index 0000000000000000000000000000000000000000..eee055f33c027147739e2363d7bb8a7ee1bd1e52 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0093.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0094.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0094.png new file mode 100644 index 0000000000000000000000000000000000000000..f7124409566c401afef9772b949579ee8a48adfd Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0094.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0095.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0095.png new file mode 100644 index 0000000000000000000000000000000000000000..3d5cd3c6a7aa9845e5b363a530fb0873b2d39ad9 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0095.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0096.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0096.png new file mode 100644 index 0000000000000000000000000000000000000000..e6b316dbd4879a4ae16663a0a7a511a1fd828f23 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0096.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0097.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0097.png new file mode 100644 index 0000000000000000000000000000000000000000..85b7fe5bf838e275b8d4c907373a58ec3b1d3e70 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0097.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0098.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0098.png new file mode 100644 index 0000000000000000000000000000000000000000..ce2235694c485396f63a2893e6166239d9be8e14 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0098.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0099.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0099.png new file mode 100644 index 0000000000000000000000000000000000000000..da3632754a82387cb88375a579a240081b7a0779 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0099.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0100.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0100.png new file mode 100644 index 0000000000000000000000000000000000000000..70b3b5a2ecc4c030d36acf9d79723f25e7262d2d Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0100.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0101.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0101.png new file mode 100644 index 0000000000000000000000000000000000000000..a08f754b6d9995d8ff58f9237084a9c4d11fa959 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0101.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0102.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0102.png new file mode 100644 index 0000000000000000000000000000000000000000..94ecc65c462287f63dcd7640148338ff75d3bb74 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0102.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0103.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0103.png new file mode 100644 index 0000000000000000000000000000000000000000..1d54e38106f78c92c9250ec99717821928421020 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0103.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0104.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0104.png new file mode 100644 index 0000000000000000000000000000000000000000..509669f3adaa505217db3d668cb1f8db0938eca6 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0104.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0105.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0105.png new file mode 100644 index 0000000000000000000000000000000000000000..bf42beddaeff1ea9020c15c9cb98d141029b47f7 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0105.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0106.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0106.png new file mode 100644 index 0000000000000000000000000000000000000000..97e47c3ad646785cd86001aa9153b9964fe0cd89 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0106.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0107.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0107.png new file mode 100644 index 0000000000000000000000000000000000000000..53a4cf6de4c836ee60b851ad55e2314609158ecc Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0107.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0108.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0108.png new file mode 100644 index 0000000000000000000000000000000000000000..d8d418737522dcd7ac559d08ab4a0ef6aa4e5a05 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0108.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0109.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0109.png new file mode 100644 index 0000000000000000000000000000000000000000..34ca073611092cfbc8ce2ac9c38a251529540e4e Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0109.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0110.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0110.png new file mode 100644 index 0000000000000000000000000000000000000000..0fadc26fa5e8421a58110a12c2dfa3ed800116a6 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0110.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0111.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0111.png new file mode 100644 index 0000000000000000000000000000000000000000..1ca4fe138cc6cf180bee9926d905cfe69247509b Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0111.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0112.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0112.png new file mode 100644 index 0000000000000000000000000000000000000000..1ef82d2594df151f43905c71117308bc5ad589a2 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0112.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0113.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0113.png new file mode 100644 index 0000000000000000000000000000000000000000..41dbf0a0c2181f0e402edaa3d7abe846fc215962 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0113.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0114.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0114.png new file mode 100644 index 0000000000000000000000000000000000000000..a2351f4ce75b691b36dcbd0b6d77be9dcc4f5509 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0114.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0115.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0115.png new file mode 100644 index 0000000000000000000000000000000000000000..69b6ec25607ca451bf319d3a015ab0fd5641f692 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0115.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0116.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0116.png new file mode 100644 index 0000000000000000000000000000000000000000..d234f2261424c1e3ffdbb49fc11d07859e6b1d9d Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0116.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0117.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0117.png new file mode 100644 index 0000000000000000000000000000000000000000..767dcd35787b71680c4422b016fa098f9866c8e3 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0117.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0118.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0118.png new file mode 100644 index 0000000000000000000000000000000000000000..b6a4ec374b9fd8766734a8bf8ffe4d2d9e815f13 Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0118.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0119.png b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0119.png new file mode 100644 index 0000000000000000000000000000000000000000..2d467421db48c1a34d0bacc3d36a46f5f71b701d Binary files /dev/null and b/ocr-deva-eval-20260924/smoke/mixed/images/mixed_0119.png differ diff --git a/ocr-deva-eval-20260924/smoke/mixed/labels.txt b/ocr-deva-eval-20260924/smoke/mixed/labels.txt new file mode 100644 index 0000000000000000000000000000000000000000..aca3cb458e1e0680c5f7d257362aea351965b598 --- /dev/null +++ b/ocr-deva-eval-20260924/smoke/mixed/labels.txt @@ -0,0 +1,120 @@ +images/mixed_0000.png जिल्ला: Lalitpur, वडा नं. 15 +images/mixed_0001.png जन्म मिति: 2063/02/05 +images/mixed_0002.png ठेगाना: Hetauda-15, Jawalakhel +images/mixed_0003.png कुल रकम: Rs. 57604 +images/mixed_0004.png नाम: Hari Rai +images/mixed_0005.png कुल रकम: Rs. 882 +images/mixed_0006.png जन्म मिति: 2078/03/14 +images/mixed_0007.png नाम: Hari Karki +images/mixed_0008.png WiFi पासवर्ड परिवर्तन गर्नुहोस् +images/mixed_0009.png जिल्ला: Bhaktapur, वडा नं. 12 +images/mixed_0010.png मोबाइल नम्बर: 9838199212 +images/mixed_0011.png COVID-19 विरुद्धको खोप अभियान सुरु +images/mixed_0012.png ठेगाना: Kathmandu-1, Kalanki +images/mixed_0013.png विद्यालयमा ICT कक्षा सञ्चालन +images/mixed_0014.png जिल्ला: Butwal, वडा नं. 18 +images/mixed_0015.png नाम: Suresh Limbu +images/mixed_0016.png मोबाइल नम्बर: 9822142160 +images/mixed_0017.png मोबाइल नम्बर: 9857360180 +images/mixed_0018.png नाम: Dipak Tamang +images/mixed_0019.png इमेल: manisha.karki@ampixa.com +images/mixed_0020.png ठेगाना: Hetauda-18, Bhanuchowk +images/mixed_0021.png ठेगाना: Hetauda-18, Lakeside +images/mixed_0022.png नाम: Kamala Shrestha +images/mixed_0023.png जन्म मिति: 2061/07/02 +images/mixed_0024.png NEPSE सूचकांक 12 अंकले बढ्यो +images/mixed_0025.png जिल्ला: Pokhara, वडा नं. 26 +images/mixed_0026.png ठेगाना: Dharan-29, Thamel +images/mixed_0027.png इमेल: bikash.rai@gmail.com +images/mixed_0028.png ठेगाना: Lalitpur-14, Bhanuchowk +images/mixed_0029.png नाम: Bikash Limbu +images/mixed_0030.png ठेगाना: Biratnagar-13, Jawalakhel +images/mixed_0031.png कुल रकम: Rs. 5658 +images/mixed_0032.png इमेल: kamala.karki@ampixa.com +images/mixed_0033.png नाम: Ram Magar +images/mixed_0034.png ठेगाना: Bhaktapur-10, Maitighar +images/mixed_0035.png जिल्ला: Biratnagar, वडा नं. 18 +images/mixed_0036.png कुल रकम: Rs. 86803 +images/mixed_0037.png कुल रकम: Rs. 24266 +images/mixed_0038.png नाम: Sunita Tamang +images/mixed_0039.png नाम: Dipak Adhikari +images/mixed_0040.png नाम: Sunita Thapa +images/mixed_0041.png ठेगाना: Ilam-14, Thamel +images/mixed_0042.png ठेगाना: Taplejung-7, Kalanki +images/mixed_0043.png Google Maps मा ठेगाना खोज्नुहोस् +images/mixed_0044.png नाम: Anjali Magar +images/mixed_0045.png मोबाइल नम्बर: 9873530270 +images/mixed_0046.png COVID-19 विरुद्धको खोप अभियान सुरु +images/mixed_0047.png NEPSE सूचकांक 12 अंकले बढ्यो +images/mixed_0048.png नाम: Manisha Maharjan +images/mixed_0049.png जन्म मिति: 2066/11/11 +images/mixed_0050.png जन्म मिति: 2060/09/17 +images/mixed_0051.png जन्म मिति: 2045/03/06 +images/mixed_0052.png जन्म मिति: 2049/09/17 +images/mixed_0053.png ठेगाना: Taplejung-16, Jawalakhel +images/mixed_0054.png जन्म मिति: 2062/09/17 +images/mixed_0055.png जिल्ला: Lalitpur, वडा नं. 22 +images/mixed_0056.png QR कोड स्क्यान गरी भुक्तानी गर्नुहोस् +images/mixed_0057.png मोबाइल नम्बर: 9882178865 +images/mixed_0058.png कुल रकम: Rs. 20130 +images/mixed_0059.png इमेल: hari.gurung@example.com +images/mixed_0060.png ठेगाना: Taplejung-26, Lakeside +images/mixed_0061.png कुल रकम: Rs. 20577 +images/mixed_0062.png इमेल: kamala.bista@gmail.com +images/mixed_0063.png जिल्ला: Bhaktapur, वडा नं. 31 +images/mixed_0064.png जन्म मिति: 2061/03/09 +images/mixed_0065.png इमेल: sita.sharma@yahoo.com +images/mixed_0066.png मोबाइल नम्बर: 9878444393 +images/mixed_0067.png ठेगाना: Lalitpur-15, Maitighar +images/mixed_0068.png मोबाइल नम्बर: 9852181002 +images/mixed_0069.png जन्म मिति: 2067/03/10 +images/mixed_0070.png कुल रकम: Rs. 21297 +images/mixed_0071.png मोबाइल नम्बर: 9833913147 +images/mixed_0072.png इमेल: dipak.maharjan@example.com +images/mixed_0073.png कुल रकम: Rs. 20132 +images/mixed_0074.png नाम: Kamala Gurung +images/mixed_0075.png जन्म मिति: 2048/01/26 +images/mixed_0076.png मोबाइल नम्बर: 9898016467 +images/mixed_0077.png PDF फाइल डाउनलोड गर्नुहोस् +images/mixed_0078.png कुल रकम: Rs. 45235 +images/mixed_0079.png Nepal Telecom ले 5G सेवा परीक्षण गर्यो +images/mixed_0080.png जिल्ला: Pokhara, वडा नं. 14 +images/mixed_0081.png नाम: Gita Tamang +images/mixed_0082.png PDF फाइल डाउनलोड गर्नुहोस् +images/mixed_0083.png ठेगाना: Butwal-11, Baneshwor +images/mixed_0084.png जिल्ला: Kathmandu, वडा नं. 13 +images/mixed_0085.png मोबाइल नम्बर: 9839057687 +images/mixed_0086.png नाम: Ram Sharma +images/mixed_0087.png जिल्ला: Hetauda, वडा नं. 1 +images/mixed_0088.png मोबाइल नम्बर: 9824105749 +images/mixed_0089.png नाम: Gita Maharjan +images/mixed_0090.png इमेल: manisha.tamang@yahoo.com +images/mixed_0091.png इमेल: bikash.thapa@yahoo.com +images/mixed_0092.png ठेगाना: Pokhara-25, Bhanuchowk +images/mixed_0093.png जन्म मिति: 2076/09/23 +images/mixed_0094.png कुल रकम: Rs. 3300 +images/mixed_0095.png मोबाइल नम्बर: 9822947218 +images/mixed_0096.png कुल रकम: Rs. 24243 +images/mixed_0097.png ठेगाना: Ilam-27, Kalanki +images/mixed_0098.png कुल रकम: Rs. 25606 +images/mixed_0099.png WiFi पासवर्ड परिवर्तन गर्नुहोस् +images/mixed_0100.png इमेल: kamala.tamang@example.com +images/mixed_0101.png जन्म मिति: 2082/10/08 +images/mixed_0102.png मोबाइल नम्बर: 9848068415 +images/mixed_0103.png जिल्ला: Biratnagar, वडा नं. 1 +images/mixed_0104.png ठेगाना: Hetauda-6, Koteshwor +images/mixed_0105.png कुल रकम: Rs. 24080 +images/mixed_0106.png ठेगाना: Lalitpur-3, Thamel +images/mixed_0107.png कुल रकम: Rs. 12545 +images/mixed_0108.png मोबाइल नम्बर: 9808601175 +images/mixed_0109.png इमेल: gita.maharjan@gmail.com +images/mixed_0110.png जिल्ला: Lalitpur, वडा नं. 25 +images/mixed_0111.png जिल्ला: Lalitpur, वडा नं. 7 +images/mixed_0112.png मोबाइल नम्बर: 9806487204 +images/mixed_0113.png जिल्ला: Lalitpur, वडा नं. 19 +images/mixed_0114.png मोबाइल नम्बर: 9856515331 +images/mixed_0115.png इमेल: suresh.rai@yahoo.com +images/mixed_0116.png इमेल: kamala.gurung@gmail.com +images/mixed_0117.png जिल्ला: Dharan, वडा नं. 18 +images/mixed_0118.png SEE परीक्षाको नतिजा प्रकाशित +images/mixed_0119.png कुल रकम: Rs. 56406 diff --git a/ocr-deva-eval-20260924/smoke/summary.json b/ocr-deva-eval-20260924/smoke/summary.json new file mode 100644 index 0000000000000000000000000000000000000000..6a2197bc3a8ebd3ca5edaf0d03d68aca2c63a4e9 --- /dev/null +++ b/ocr-deva-eval-20260924/smoke/summary.json @@ -0,0 +1,18 @@ +{ + "seed": 20260924, + "fonts": [ + "/usr/share/fonts/truetype/noto/NotoSansDevanagari-Regular.ttf", + "/usr/share/fonts/truetype/noto/NotoSans-Regular.ttf" + ], + "raqm": true, + "subsets": { + "english": { + "lines": 120, + "degraded": 60 + }, + "mixed": { + "lines": 120, + "degraded": 60 + } + } +} \ No newline at end of file diff --git a/ocr-tech-mps-integration/tools/prepare_native_spotcheck_bundle.py b/ocr-tech-mps-integration/tools/prepare_native_spotcheck_bundle.py new file mode 100644 index 0000000000000000000000000000000000000000..71cbca45e358f29be3fc1de8bf29899519dd36e8 --- /dev/null +++ b/ocr-tech-mps-integration/tools/prepare_native_spotcheck_bundle.py @@ -0,0 +1,381 @@ +#!/usr/bin/env python3 +"""Prepare a native-reader spot-check bundle for recognizer eval labels. + +Input labels use PaddleOCR recognition format: + + images/foo.pngground truth text + +The bundle intentionally does not mark anything verified. It copies a sampled set +of crops, writes a CSV for review, and creates a small browser page that lets a +reviewer export corrected rows. Optional PaddleOCR prediction files are accepted +when available, but label verification can run without them. +""" + +from __future__ import annotations + +import argparse +import csv +import hashlib +import html +import json +import platform +import random +import shutil +import sys +from datetime import datetime, timezone +from dataclasses import dataclass +from pathlib import Path +from typing import Any + + +REVIEW_FIELDS = [ + "review_id", + "sample_id", + "source_image_path", + "bundle_image_path", + "source_pdf", + "page", + "bbox_json", + "machine_text", + "prediction", + "prediction_score", + "review_status", + "corrected_text", + "reviewer", + "notes", +] + +VALID_STATUSES = "accept_machine_text, corrected_text, unreadable, bad_crop, not_target_script" + + +@dataclass(frozen=True) +class LabelRow: + index: int + rel_path: str + text: str + + +@dataclass(frozen=True) +class Prediction: + text: str + score: str + + +def _read_label_rows(path: Path) -> list[LabelRow]: + if not path.exists(): + raise FileNotFoundError(f"label file does not exist: {path}") + rows: list[LabelRow] = [] + with path.open("r", encoding="utf-8", newline="") as handle: + for line_no, line in enumerate(handle, 1): + line = line.rstrip("\n") + if not line: + continue + if "\t" not in line: + raise ValueError(f"{path}:{line_no}: expected tab-separated image path and text") + rel_path, text = line.split("\t", 1) + if not rel_path: + raise ValueError(f"{path}:{line_no}: empty image path") + rows.append(LabelRow(index=len(rows), rel_path=rel_path, text=text)) + if not rows: + raise ValueError(f"label file has no usable rows: {path}") + return rows + + +def _hash_file(path: Path) -> str: + digest = hashlib.sha256() + with path.open("rb") as handle: + for chunk in iter(lambda: handle.read(1024 * 1024), b""): + digest.update(chunk) + return digest.hexdigest() + + +def _read_predictions(path: Path | None) -> dict[str, Prediction]: + if path is None: + return {} + if not path.exists(): + raise FileNotFoundError(f"prediction file does not exist: {path}") + predictions: dict[str, Prediction] = {} + with path.open("r", encoding="utf-8", newline="") as handle: + for line_no, line in enumerate(handle, 1): + line = line.rstrip("\n") + if not line: + continue + parts = line.split("\t") + if len(parts) < 2: + raise ValueError(f"{path}:{line_no}: expected at least image path and prediction") + image_key = _image_key(parts[0]) + predictions[image_key] = Prediction(text=parts[1], score=parts[2] if len(parts) >= 3 else "") + return predictions + + +def _read_manifest(path: Path | None) -> dict[str, dict[str, Any]]: + if path is None: + return {} + if not path.exists(): + raise FileNotFoundError(f"manifest file does not exist: {path}") + rows: dict[str, dict[str, Any]] = {} + with path.open("r", encoding="utf-8") as handle: + for line_no, line in enumerate(handle, 1): + line = line.strip() + if not line: + continue + try: + payload = json.loads(line) + except json.JSONDecodeError as exc: + raise ValueError(f"{path}:{line_no}: invalid JSON: {exc}") from exc + image_path = str(payload.get("image_path") or "") + if image_path: + rows[image_path] = payload + rows[_image_key(image_path)] = payload + sample_id = str(payload.get("sample_id") or "") + if sample_id: + rows[sample_id] = payload + return rows + + +def _image_key(path: str) -> str: + return Path(path).name + + +def _metadata_for(row: LabelRow, manifest: dict[str, dict[str, Any]]) -> dict[str, Any]: + return manifest.get(row.rel_path) or manifest.get(_image_key(row.rel_path)) or {} + + +def _sample_rows(rows: list[LabelRow], sample_size: int, seed: int) -> list[LabelRow]: + if sample_size <= 0: + raise ValueError("--sample-size must be positive") + if sample_size >= len(rows): + return rows + rng = random.Random(seed) + indexes = sorted(rng.sample(range(len(rows)), sample_size)) + return [rows[i] for i in indexes] + + +def _copy_image(data_dir: Path, rel_path: str, image_dir: Path, review_id: str) -> str: + source = data_dir / rel_path + if not source.exists(): + raise FileNotFoundError(f"label references missing image: {source}") + suffix = source.suffix or ".png" + dest = image_dir / f"{review_id}{suffix}" + shutil.copy2(source, dest) + return f"images/{dest.name}" + + +def _csv_escape_for_js(value: str) -> str: + return value.replace("\\", "\\\\").replace("`", "\\`").replace("${", "\\${") + + +def _write_csv(path: Path, rows: list[dict[str, str]]) -> None: + with path.open("w", encoding="utf-8", newline="") as handle: + writer = csv.DictWriter(handle, fieldnames=REVIEW_FIELDS) + writer.writeheader() + writer.writerows(rows) + + +def _write_html(path: Path, rows: list[dict[str, str]], title: str) -> None: + cards: list[str] = [] + for row in rows: + rid = row["review_id"] + machine_text = html.escape(row["machine_text"]) + prediction = html.escape(row["prediction"]) + source = html.escape(row["source_image_path"]) + img = html.escape(row["bundle_image_path"]) + cards.append( + f""" +
+
+ {html.escape(rid)} + {source} +
+ line crop {html.escape(rid)} + + + + + + +
+""" + ) + + rows_json = json.dumps(rows, ensure_ascii=False) + page = f""" + + + + {html.escape(title)} + + + +
+

{html.escape(title)}

+

Valid statuses: {html.escape(VALID_STATUSES)}. This page does not save automatically; use Export CSV after review.

+ +
+{''.join(cards)} + + + +""" + path.write_text(page, encoding="utf-8") + + +def prepare_bundle( + *, + label_file: Path, + data_dir: Path, + out_dir: Path, + sample_size: int, + seed: int, + title: str, + manifest_file: Path | None = None, + prediction_file: Path | None = None, +) -> dict[str, Any]: + rows = _read_label_rows(label_file) + manifest = _read_manifest(manifest_file) + predictions = _read_predictions(prediction_file) + sampled = _sample_rows(rows, sample_size, seed) + + if out_dir.exists() and any(out_dir.iterdir()): + raise FileExistsError(f"output directory exists and is not empty: {out_dir}") + image_dir = out_dir / "images" + image_dir.mkdir(parents=True, exist_ok=True) + + review_rows: list[dict[str, str]] = [] + for ordinal, row in enumerate(sampled, 1): + review_id = f"review-{ordinal:04d}" + metadata = _metadata_for(row, manifest) + meta = metadata.get("metadata") if isinstance(metadata.get("metadata"), dict) else {} + pred = predictions.get(_image_key(row.rel_path), Prediction("", "")) + bundle_image = _copy_image(data_dir, row.rel_path, image_dir, review_id) + review_rows.append( + { + "review_id": review_id, + "sample_id": str(metadata.get("sample_id") or ""), + "source_image_path": row.rel_path, + "bundle_image_path": bundle_image, + "source_pdf": str(meta.get("source_pdf") or ""), + "page": str(meta.get("page") or ""), + "bbox_json": json.dumps(meta.get("bbox") or [], ensure_ascii=False), + "machine_text": row.text, + "prediction": pred.text, + "prediction_score": pred.score, + "review_status": "", + "corrected_text": "", + "reviewer": "", + "notes": "", + } + ) + + _write_csv(out_dir / "spotcheck-review.csv", review_rows) + _write_html(out_dir / "spotcheck-review.html", review_rows, title) + summary = { + "created_at": datetime.now(timezone.utc).isoformat(), + "title": title, + "label_file": str(label_file), + "label_file_sha256": _hash_file(label_file), + "data_dir": str(data_dir), + "manifest_file": str(manifest_file) if manifest_file else None, + "manifest_file_sha256": _hash_file(manifest_file) if manifest_file else None, + "prediction_file": str(prediction_file) if prediction_file else None, + "prediction_file_sha256": _hash_file(prediction_file) if prediction_file else None, + "source_rows": len(rows), + "sampled_rows": len(sampled), + "seed": seed, + "valid_review_statuses": VALID_STATUSES.split(", "), + "claim_evidence_eligible": False, + "review_state": "unreviewed", + "artifacts": { + "review_csv": "spotcheck-review.csv", + "review_html": "spotcheck-review.html", + "images_dir": "images", + }, + "machine": { + "platform": platform.platform(), + "python": sys.version, + }, + "command": " ".join(sys.argv), + } + (out_dir / "summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + return summary + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--label-file", type=Path, required=True) + parser.add_argument("--data-dir", type=Path, required=True) + parser.add_argument("--out", type=Path, required=True) + parser.add_argument("--manifest-file", type=Path) + parser.add_argument("--prediction-file", type=Path) + parser.add_argument("--sample-size", type=int, default=50) + parser.add_argument("--seed", type=int, default=20260619) + parser.add_argument("--title", default="Native-reader OCR spot check") + args = parser.parse_args(argv) + + summary = prepare_bundle( + label_file=args.label_file, + data_dir=args.data_dir, + out_dir=args.out, + manifest_file=args.manifest_file, + prediction_file=args.prediction_file, + sample_size=args.sample_size, + seed=args.seed, + title=args.title, + ) + print(f"wrote {summary['sampled_rows']} review rows -> {args.out}") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ocr-tech-mps-integration/tools/prepare_paddleocr_training_smoke.py b/ocr-tech-mps-integration/tools/prepare_paddleocr_training_smoke.py new file mode 100644 index 0000000000000000000000000000000000000000..efcfb9b92a2d97d550ac433871cd23ba18001030 --- /dev/null +++ b/ocr-tech-mps-integration/tools/prepare_paddleocr_training_smoke.py @@ -0,0 +1,224 @@ +#!/usr/bin/env python3 +"""Prepare a tiny PaddleOCR train/dev smoke workspace from a portable bundle. + +The smoke workspace proves that a training bundle can be extracted and started without +using the sealed held-out eval split for checkpoint selection. It samples only the +bundle's training labels and PaddleOCR validation labels, which correspond to the +dev split recorded in the bundle manifest. +""" + +from __future__ import annotations + +import argparse +import json +import shutil +import tarfile +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +from ocrtech.manifest import sha256_file + + +RECIPE_DIR = Path("training-recipes/ppocrv5-mobile-devclean") +TRAIN_LABEL = RECIPE_DIR / "labels" / "train.txt" +DEV_LABEL = RECIPE_DIR / "labels" / "eval.txt" +CONFIG = RECIPE_DIR / "paddle_recognizer.yml" +DICTIONARY = RECIPE_DIR / "nep_eng_dict.txt" +TRAINING_SUMMARY = RECIPE_DIR / "recognizer-training-summary.json" +README = RECIPE_DIR / "README.md" + + +def _load_yaml_module() -> Any: + try: + import yaml + except ImportError as exc: # pragma: no cover - exercised only in missing dependency envs. + raise RuntimeError("PyYAML is required to prepare a PaddleOCR smoke workspace") from exc + return yaml + + +def _read_member_text(archive: tarfile.TarFile, member_name: str) -> str: + member = archive.getmember(member_name) + handle = archive.extractfile(member) + if handle is None: + raise ValueError(f"archive member is not readable: {member_name}") + return handle.read().decode("utf-8") + + +def _label_rows(text: str, *, label: str) -> list[str]: + rows = [line.rstrip("\n") for line in text.splitlines() if line.strip()] + if not rows: + raise ValueError(f"{label} label file has no rows") + for index, row in enumerate(rows, 1): + if "\t" not in row: + raise ValueError(f"{label}:{index}: expected image path and text separated by a tab") + return rows + + +def _select_rows(rows: list[str], count: int, *, label: str) -> list[str]: + if count <= 0: + raise ValueError(f"{label} row count must be positive") + if len(rows) < count: + raise ValueError(f"{label} label file has only {len(rows)} rows, requested {count}") + return rows[:count] + + +def _image_paths(rows: list[str]) -> list[str]: + return [row.split("\t", 1)[0] for row in rows] + + +def _copy_member(archive: tarfile.TarFile, member_name: str, out: Path) -> None: + member = archive.getmember(member_name) + if member.isdir(): + raise ValueError(f"archive member is a directory, expected file: {member_name}") + target = out / member_name + target.parent.mkdir(parents=True, exist_ok=True) + source = archive.extractfile(member) + if source is None: + raise ValueError(f"archive member is not readable: {member_name}") + with source, target.open("wb") as handle: + shutil.copyfileobj(source, handle) + + +def _copy_optional_member(archive: tarfile.TarFile, member_name: str, out: Path) -> bool: + try: + _copy_member(archive, member_name, out) + except KeyError: + return False + return True + + +def _write_text(path: Path, value: str) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(value, encoding="utf-8") + + +def _patch_config(config_text: str, args: argparse.Namespace) -> str: + yaml = _load_yaml_module() + payload = yaml.safe_load(config_text) + if not isinstance(payload, dict): + raise ValueError("PaddleOCR config must be a YAML object") + global_cfg = payload.setdefault("Global", {}) + if not isinstance(global_cfg, dict): + raise ValueError("PaddleOCR config Global must be an object") + global_cfg["use_gpu"] = bool(args.use_gpu) + global_cfg["epoch_num"] = int(args.epoch_num) + global_cfg["print_batch_step"] = 1 + global_cfg["save_epoch_step"] = 1 + global_cfg["eval_batch_step"] = [0, int(args.eval_batch_step)] + global_cfg["save_model_dir"] = str(RECIPE_DIR / "smoke-checkpoints") + global_cfg["save_res_path"] = str(RECIPE_DIR / "smoke-predicts.txt") + if args.pretrained_model is not None: + global_cfg["pretrained_model"] = str(args.pretrained_model) + + optimizer = payload.get("Optimizer") + if isinstance(optimizer, dict): + lr = optimizer.get("lr") + if isinstance(lr, dict): + lr["warmup_epoch"] = 0 + + train_loader = payload.get("Train", {}).get("loader") if isinstance(payload.get("Train"), dict) else None + if isinstance(train_loader, dict): + train_loader["batch_size_per_card"] = int(args.batch_size) + train_loader["drop_last"] = False + train_loader["num_workers"] = int(args.num_workers) + + eval_loader = payload.get("Eval", {}).get("loader") if isinstance(payload.get("Eval"), dict) else None + if isinstance(eval_loader, dict): + eval_loader["batch_size_per_card"] = int(args.batch_size) + eval_loader["drop_last"] = False + eval_loader["num_workers"] = int(args.num_workers) + + return yaml.safe_dump(payload, allow_unicode=True, sort_keys=False) + + +def prepare_smoke(args: argparse.Namespace) -> dict[str, Any]: + archive_path = Path(args.bundle_archive) + out = Path(args.out) + if out.exists() and any(out.iterdir()) and not args.force: + raise FileExistsError(f"output directory exists and is not empty: {out}") + if out.exists() and args.force: + shutil.rmtree(out) + out.mkdir(parents=True, exist_ok=True) + + with tarfile.open(archive_path, "r:gz") as archive: + train_rows = _select_rows(_label_rows(_read_member_text(archive, str(TRAIN_LABEL)), label="train"), args.train_rows, label="train") + dev_rows = _select_rows(_label_rows(_read_member_text(archive, str(DEV_LABEL)), label="dev"), args.dev_rows, label="dev") + config_text = _read_member_text(archive, str(CONFIG)) + for member_name in [str(DICTIONARY), str(TRAINING_SUMMARY), str(README)]: + _copy_member(archive, member_name, out) + corpus_audit_present = _copy_optional_member(archive, "recognizer-corpus-audit/recognizer-corpus-audit.json", out) + for image_path in [*_image_paths(train_rows), *_image_paths(dev_rows)]: + _copy_member(archive, image_path, out) + + _write_text(out / TRAIN_LABEL, "\n".join(train_rows) + "\n") + _write_text(out / DEV_LABEL, "\n".join(dev_rows) + "\n") + _write_text(out / CONFIG, _patch_config(config_text, args)) + + command = ( + f"PYTHONPATH={args.paddleocr_dir} {args.python_bin} " + f"{Path(args.paddleocr_dir) / 'tools' / 'train.py'} -c {CONFIG}" + ) + summary = { + "created_at": datetime.now(timezone.utc).isoformat(), + "bundle_archive": str(archive_path), + "bundle_archive_sha256": sha256_file(archive_path), + "output_dir": str(out), + "train_rows": len(train_rows), + "dev_rows": len(dev_rows), + "source_labels": { + "train": str(TRAIN_LABEL), + "dev": str(DEV_LABEL), + "dev_note": "The bundle file is named labels/eval.txt because PaddleOCR calls validation Eval; it is the dev split in the bundle manifest, not the sealed held-out eval pack.", + }, + "corpus_audit_copied_from_archive": corpus_audit_present, + "sealed_eval_used": False, + "config": str(out / CONFIG), + "config_sha256": sha256_file(out / CONFIG), + "dictionary": str(out / DICTIONARY), + "dictionary_sha256": sha256_file(out / DICTIONARY), + "epoch_num": int(args.epoch_num), + "batch_size": int(args.batch_size), + "num_workers": int(args.num_workers), + "use_gpu": bool(args.use_gpu), + "paddleocr_dir": str(args.paddleocr_dir), + "python_bin": str(args.python_bin), + "run_command_from_output_dir": command, + } + _write_text(out / "paddleocr-training-smoke.json", json.dumps(summary, ensure_ascii=False, indent=2) + "\n") + _write_text( + out / "SMOKE.md", + "# PaddleOCR Training Smoke\n\n" + "This workspace is a train/dev-only smoke subset of the portable training bundle. " + "It does not use the sealed held-out eval split.\n\n" + "Run from this directory:\n\n" + "```bash\n" + f"{command}\n" + "```\n", + ) + return summary + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--bundle-archive", type=Path, required=True) + parser.add_argument("--out", type=Path, required=True) + parser.add_argument("--train-rows", type=int, default=32) + parser.add_argument("--dev-rows", type=int, default=8) + parser.add_argument("--epoch-num", type=int, default=1) + parser.add_argument("--eval-batch-step", type=int, default=1) + parser.add_argument("--batch-size", type=int, default=2) + parser.add_argument("--num-workers", type=int, default=0) + parser.add_argument("--use-gpu", action="store_true") + parser.add_argument("--pretrained-model") + parser.add_argument("--paddleocr-dir", default="/tmp/PaddleOCR-v3.7.0") + parser.add_argument("--python-bin", default="/tmp/ocrtech-paddle311/bin/python") + parser.add_argument("--force", action="store_true") + args = parser.parse_args(argv) + summary = prepare_smoke(args) + print(f"wrote {args.out} train_rows={summary['train_rows']} dev_rows={summary['dev_rows']} sealed_eval_used={summary['sealed_eval_used']}") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ocr-tech-mps-integration/tools/prepare_page_ocr_eval_pack_metadata.py b/ocr-tech-mps-integration/tools/prepare_page_ocr_eval_pack_metadata.py new file mode 100644 index 0000000000000000000000000000000000000000..51f4677b29a9b74d449a1a8ff4bb2d41527d59aa --- /dev/null +++ b/ocr-tech-mps-integration/tools/prepare_page_ocr_eval_pack_metadata.py @@ -0,0 +1,474 @@ +#!/usr/bin/env python3 +"""Prepare scorer metadata sidecars for a page-level OCR eval manifest. + +This tool fills missing manifest-level provenance required by +``tools/run_page_ocr_eval.py`` and writes the reproducible sidecars that scorer +claim-safety checks expect: a rewritten eval manifest, ``summary.json`` with the +page-pack digest, and ``script-inventory.json``. + +It does not certify labels. Draft references remain draft references, and +claim-evidence flags are preserved unless an explicit fallback is needed for a +missing field. +""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import platform +import sys +import unicodedata +from collections import Counter +from datetime import UTC, datetime +from pathlib import Path +from typing import Any + +import regex +from PIL import Image + +from ocrtech.manifest import ManifestEntry, load_manifest, sha256_file, write_manifest + + +TOOLS_DIR = Path(__file__).resolve().parent +if str(TOOLS_DIR) not in sys.path: + sys.path.insert(0, str(TOOLS_DIR)) + +import run_page_ocr_eval as page_scorer + + +REPORT_JSON = "page-ocr-eval-pack-metadata.json" +README = "README.md" +EVAL_MANIFEST = "eval-manifest.jsonl" +SUMMARY_JSON = "summary.json" +SCRIPT_INVENTORY_JSON = "script-inventory.json" +DEFAULT_NORMALIZATION = "NFC_preserve_whitespace" +SOURCE_IMAGE_FALLBACK_KEYS = ( + "source_image", + "source_image_path", + "raw_image_path", + "raw_copy_path", + "prepared_image_path", + "image_path", +) +PAGE_FALLBACK_KEYS = ( + "book_page_number", + "page_sequence_number", + "source_document_page_number", + "source_page_number", + "page_number", + "page_id", +) + + +def _nfc(value: str) -> str: + return unicodedata.normalize("NFC", value or "") + + +def _text_sha256(value: str) -> str: + return hashlib.sha256(_nfc(value).encode("utf-8")).hexdigest() + + +def _graphemes(value: str) -> list[str]: + return regex.findall(r"\X", _nfc(value)) + + +def _has_any(metadata: dict[str, Any], keys: tuple[str, ...]) -> bool: + return any(metadata.get(key) not in (None, "", [], {}) for key in keys) + + +def _bool_from_metadata(metadata: dict[str, Any], keys: tuple[str, ...], fallback: bool) -> bool: + for key in keys: + if key not in metadata: + continue + value = metadata[key] + if isinstance(value, bool): + return value + if isinstance(value, str): + lowered = value.strip().lower() + if lowered in {"1", "true", "yes", "y"}: + return True + if lowered in {"0", "false", "no", "n"}: + return False + return bool(value) + return fallback + + +def _resolve_path(value: Any, *, base_dir: Path) -> Path | None: + if not isinstance(value, str) or not value.strip(): + return None + path = Path(value) + if path.is_absolute(): + return path + candidate = base_dir / path + if candidate.exists(): + return candidate + if path.exists(): + return path + return candidate + + +def _path_text(value: Any, *, base_dir: Path) -> str: + path = _resolve_path(value, base_dir=base_dir) + if path is None: + return "" + try: + return str(path.resolve()) + except OSError: + return str(path) + + +def _image_size(path: Path) -> tuple[int, int]: + if not path.is_file(): + raise FileNotFoundError(f"manifest image is missing: {path}") + with Image.open(path) as image: + return image.size + + +def _read_reference_payload(entry: ManifestEntry, input_path: Path, manifest_dir: Path) -> dict[str, Any]: + payload = page_scorer._reference_payload_for(entry, input_path, manifest_dir) + if not isinstance(payload, dict): + raise ValueError(f"{entry.sample_id}: reference payload must be a JSON object") + return payload + + +def _reference_text(payload: dict[str, Any]) -> str: + text = payload.get("text") + if isinstance(text, str): + return text + return "" + + +def _reference_metadata(payload: dict[str, Any]) -> dict[str, Any]: + metadata = payload.get("metadata") + if isinstance(metadata, dict): + return dict(metadata) + return {} + + +def _fallback_source_image(metadata: dict[str, Any], *, input_path: Path, manifest_dir: Path) -> tuple[str, str]: + for key in SOURCE_IMAGE_FALLBACK_KEYS: + value = metadata.get(key) + path_text = _path_text(value, base_dir=manifest_dir) + if path_text: + path = Path(path_text) + source_sha256 = sha256_file(path) if path.is_file() else "" + return path_text, source_sha256 + return str(input_path), sha256_file(input_path) + + +def _fallback_page(metadata: dict[str, Any], *, entry: ManifestEntry) -> str: + for key in PAGE_FALLBACK_KEYS: + value = metadata.get(key) + if value not in (None, "", [], {}): + return str(value) + return entry.sample_id + + +def _rewritten_entry( + entry: ManifestEntry, + *, + manifest_dir: Path, + dataset: str, + language: str, + script: str, + domain: str, + gt_status: str, + split: str, + claim_eligible: bool, +) -> tuple[ManifestEntry, dict[str, Any]]: + input_path = page_scorer._resolve_manifest_path(entry.image_path, manifest_dir) + input_sha256 = sha256_file(input_path) + width, height = _image_size(input_path) + payload = _read_reference_payload(entry, input_path, manifest_dir) + ref_metadata = _reference_metadata(payload) + reference_path = page_scorer._reference_path_for(entry, input_path, manifest_dir) + + metadata = dict(entry.metadata or {}) + if reference_path is not None: + metadata["reference_path"] = str(reference_path.resolve()) + metadata.setdefault("language", language) + metadata.setdefault("script", script) + metadata.setdefault("domain", domain) + metadata.setdefault("gt_status", gt_status) + metadata.setdefault("split", split) + if not any(key in metadata for key in page_scorer.CLAIM_ELIGIBLE_KEYS): + metadata["claim_evidence_eligible"] = claim_eligible + if "reference_status" not in metadata and ref_metadata.get("reference_status") not in (None, ""): + metadata["reference_status"] = ref_metadata["reference_status"] + if not _has_any(metadata, page_scorer.SOURCE_DOCUMENT_KEYS): + source_image, source_sha256 = _fallback_source_image(metadata, input_path=input_path, manifest_dir=manifest_dir) + metadata["source_image"] = source_image + if source_sha256: + metadata.setdefault("source_image_sha256", source_sha256) + if not _has_any(metadata, page_scorer.PAGE_KEYS): + metadata["page"] = _fallback_page(metadata, entry=entry) + if not _has_any(metadata, page_scorer.BBOX_KEYS): + metadata["bbox"] = [0, 0, width, height] + metadata.setdefault("bbox_coordinate_space", "image_pixels_xywh") + metadata.setdefault("bbox_scope", "whole_page") + metadata.setdefault("image_width", width) + metadata.setdefault("image_height", height) + metadata.setdefault("page_eval_pack_metadata_source_manifest_dir", str(manifest_dir)) + + rewritten = ManifestEntry( + sample_id=entry.sample_id, + dataset=entry.dataset or dataset, + split=entry.split or split, + image_path=str(input_path.resolve()), + text=entry.text, + sha256=input_sha256, + metadata=metadata, + ) + stats = { + "reference_text": _reference_text(payload), + "reference_status": str(ref_metadata.get("reference_status") or metadata.get("reference_status") or ""), + "reference_claim_eligible": _bool_from_metadata(ref_metadata, page_scorer.CLAIM_ELIGIBLE_KEYS, False), + "claim_eligible": _bool_from_metadata(metadata, page_scorer.CLAIM_ELIGIBLE_KEYS, claim_eligible), + "language": str(metadata.get("language") or language), + "script": str(metadata.get("script") or script), + "domain": str(metadata.get("domain") or domain), + "gt_status": str(metadata.get("gt_status") or gt_status), + "split": str(metadata.get("split") or split), + "line_count": len(page_scorer._reference_lines(payload)), + } + return rewritten, stats + + +def _digest_rows_from_manifest(manifest_path: Path, *, language: str, script: str, domain: str, gt_status: str, claim_eligible: bool) -> list[Any]: + manifest = page_scorer.load_manifest(manifest_path) + manifest_dir = manifest_path.parent + rows = [] + for entry in manifest: + input_path = page_scorer._resolve_manifest_path(entry.image_path, manifest_dir) + reference_path = page_scorer._reference_path_for(entry, input_path, manifest_dir) + reference = page_scorer._reference_for(entry, input_path, manifest_dir) + reference_payload = page_scorer._reference_payload_for(entry, input_path, manifest_dir) + reference_fields = page_scorer._reference_fields(reference) + if page_scorer._reference_lines(reference_payload): + reference_fields.append("line_bboxes") + rows.append( + page_scorer.PageEvalRow( + sample_id=entry.sample_id, + input_path=str(input_path), + input_sha256=sha256_file(input_path), + document_path="", + document_sha256="", + document_source_path="", + language=page_scorer._entry_language(entry, language), + script=page_scorer._entry_script(entry, script), + domain=page_scorer._entry_domain(entry, domain), + gt_status=page_scorer._entry_gt_status(entry, gt_status), + split=page_scorer._entry_split(entry), + claim_eligible=page_scorer._entry_claim_eligible(entry, claim_eligible), + source_document=page_scorer._metadata_value_for_keys(entry.metadata or {}, page_scorer.SOURCE_DOCUMENT_KEYS), + source_page=page_scorer._metadata_value_for_keys(entry.metadata or {}, page_scorer.PAGE_KEYS), + source_bbox=page_scorer._metadata_value_for_keys(entry.metadata or {}, page_scorer.BBOX_KEYS), + reference_path=str(reference_path) if reference_path else "", + reference_sha256=sha256_file(reference_path) if reference_path else "", + reference_status=str((reference.metadata or {}).get("reference_status") or "") if reference else "", + reference_claim_eligible=str((reference.metadata or {}).get("claim_evidence_eligible")) + if reference and (reference.metadata or {}).get("claim_evidence_eligible") is not None + else "", + reference_text=reference.text if reference and reference.text is not None else "", + reference_fields=reference_fields, + ) + ) + return rows + + +def _write_script_inventory(path: Path, *, texts: list[str], language: str, script: str) -> dict[str, Any]: + text = _nfc("\n".join(texts)) + codepoints = sorted({f"U+{ord(ch):04X}" for ch in text if ch.strip()}) + graphemes = sorted({cluster for cluster in _graphemes(text) if cluster.strip()}) + payload = { + "task": "page_level_ocr", + "language": language, + "script": script, + "normalization": DEFAULT_NORMALIZATION, + "required_codepoints": codepoints, + "required_graphemes": graphemes, + "required_codepoint_count": len(codepoints), + "required_grapheme_count": len(graphemes), + "reference_text_sha256_nfc": _text_sha256(text), + } + path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + return payload + + +def _write_readme(path: Path, report: dict[str, Any]) -> None: + lines = [ + "# Page OCR Eval Pack Metadata", + "", + "This directory contains scorer sidecars for an existing page OCR eval manifest.", + "It does not certify draft references as gold.", + "", + f"- source manifest: `{report['source_eval_manifest']}`", + f"- rewritten manifest: `{report['eval_manifest']}`", + f"- summary: `{report['summary_file']}`", + f"- script inventory: `{report['script_inventory_file']}`", + f"- samples: `{report['sample_count']}`", + f"- lines: `{report['line_count']}`", + f"- pack content sha256: `{report['pack_content_sha256']}`", + f"- claim-ready references: `{report['claim_ready_reference_count']}/{report['sample_count']}`", + "", + report["claim_boundary"], + "", + ] + path.write_text("\n".join(lines), encoding="utf-8") + + +def prepare_page_eval_pack_metadata(args: argparse.Namespace) -> dict[str, Any]: + eval_manifest = Path(args.eval_manifest) + out = Path(args.out) + if out.exists() and any(out.iterdir()) and not args.force: + raise FileExistsError(f"output directory exists and is not empty: {out}") + out.mkdir(parents=True, exist_ok=True) + + manifest = load_manifest(eval_manifest) + if not manifest: + raise ValueError(f"eval manifest contains no rows: {eval_manifest}") + dataset = args.dataset or manifest[0].dataset + rewritten: list[ManifestEntry] = [] + stats_rows: list[dict[str, Any]] = [] + for entry in manifest: + rewritten_entry, stats = _rewritten_entry( + entry, + manifest_dir=eval_manifest.parent, + dataset=dataset, + language=args.language, + script=args.script, + domain=args.domain, + gt_status=args.gt_status, + split=args.split, + claim_eligible=args.claim_eligible, + ) + rewritten.append(rewritten_entry) + stats_rows.append(stats) + + rewritten_manifest = out / EVAL_MANIFEST + write_manifest(rewritten, rewritten_manifest) + digest_rows = _digest_rows_from_manifest( + rewritten_manifest, + language=args.language, + script=args.script, + domain=args.domain, + gt_status=args.gt_status, + claim_eligible=args.claim_eligible, + ) + pack_content_sha256 = page_scorer._page_pack_content_digest(digest_rows) + reference_texts = [str(row["reference_text"]) for row in stats_rows] + script_inventory_path = out / SCRIPT_INVENTORY_JSON + script_inventory = _write_script_inventory( + script_inventory_path, + texts=reference_texts, + language=args.language, + script=args.script, + ) + reference_status_counts = dict(sorted(Counter(str(row["reference_status"] or "") for row in stats_rows).items())) + gt_status_counts = dict(sorted(Counter(str(row["gt_status"] or "") for row in stats_rows).items())) + claim_ready_count = sum( + 1 + for row in stats_rows + if row["reference_status"] == "verified" and row["reference_claim_eligible"] is True and row["claim_eligible"] is True + ) + line_count = sum(int(row["line_count"]) for row in stats_rows) + summary = { + "dataset": dataset, + "task": "page_level_ocr", + "language": args.language, + "script": args.script, + "domain": args.domain, + "split": args.split, + "eval_pack_version": args.eval_pack_version, + "frozen_eval_pack": args.frozen_eval_pack, + "unseen_for_selection": args.unseen_for_selection, + "claim_eligible_default": args.claim_eligible, + "sample_count": len(rewritten), + "line_count": line_count, + "reference_status_counts": reference_status_counts, + "gt_status_counts": gt_status_counts, + "claim_eligible_rows": sum(1 for row in stats_rows if row["claim_eligible"]), + "claim_ready_reference_count": claim_ready_count, + "pack_content_sha256": pack_content_sha256, + "eval_pack": { + "task": "page_level_ocr", + "manifest_file": str(rewritten_manifest), + "summary_file": str(out / SUMMARY_JSON), + "script_inventory_file": str(script_inventory_path), + "rows": len(rewritten), + "pack_content_sha256": pack_content_sha256, + }, + "artifacts": { + "source_eval_manifest": str(eval_manifest), + "source_eval_manifest_sha256": sha256_file(eval_manifest), + "eval_manifest": str(rewritten_manifest), + "script_inventory": str(script_inventory_path), + }, + "normalization": DEFAULT_NORMALIZATION, + "claim_boundary": "Metadata sidecars only; draft references are not claim evidence until human verified.", + } + summary_path = out / SUMMARY_JSON + summary_path.write_text(json.dumps(summary, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + report_path = out / REPORT_JSON + report = { + "tool": "tools/prepare_page_ocr_eval_pack_metadata.py", + "created_at_utc": datetime.now(UTC).isoformat(), + "machine": platform.node(), + "command": " ".join(sys.argv), + "source_eval_manifest": str(eval_manifest), + "source_eval_manifest_sha256": sha256_file(eval_manifest), + "out": str(out), + "eval_manifest": str(rewritten_manifest), + "eval_manifest_sha256": sha256_file(rewritten_manifest), + "summary_file": str(summary_path), + "summary_file_sha256": sha256_file(summary_path), + "script_inventory_file": str(script_inventory_path), + "script_inventory_file_sha256": sha256_file(script_inventory_path), + "script_inventory": script_inventory, + "sample_count": len(rewritten), + "line_count": line_count, + "pack_content_sha256": pack_content_sha256, + "reference_status_counts": reference_status_counts, + "gt_status_counts": gt_status_counts, + "claim_ready_reference_count": claim_ready_count, + "claim_boundary": summary["claim_boundary"], + } + report["report_json"] = str(report_path) + report_path.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + _write_readme(out / README, report) + return report + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--eval-manifest", type=Path, required=True) + parser.add_argument("--out", type=Path, required=True) + parser.add_argument("--dataset", default="") + parser.add_argument("--language", default="limbu") + parser.add_argument("--script", default="Limbu") + parser.add_argument("--domain", default="real_print") + parser.add_argument("--gt-status", default="draft_machine_ocr_needs_human_review") + parser.add_argument("--split", default="eval") + parser.add_argument("--eval-pack-version", default="page-ocr-eval-pack-metadata-v1") + parser.add_argument("--frozen-eval-pack", action=argparse.BooleanOptionalAction, default=False) + parser.add_argument("--unseen-for-selection", action=argparse.BooleanOptionalAction, default=False) + parser.add_argument("--claim-eligible", action=argparse.BooleanOptionalAction, default=False) + parser.add_argument("--force", action="store_true") + args = parser.parse_args(argv) + try: + report = prepare_page_eval_pack_metadata(args) + except Exception as exc: + print(f"prepare_page_ocr_eval_pack_metadata: error: {exc}", file=sys.stderr) + return 2 + print(report["report_json"] if "report_json" in report else str(Path(args.out) / REPORT_JSON)) + print( + "samples={sample_count} lines={line_count} pack_content_sha256={pack_content_sha256}".format( + **report + ) + ) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ocr-tech-mps-integration/tools/prepare_recognizer_training_job.py b/ocr-tech-mps-integration/tools/prepare_recognizer_training_job.py new file mode 100644 index 0000000000000000000000000000000000000000..7e69fc9e128483e6a2d3b661e71b5c65cee77f40 --- /dev/null +++ b/ocr-tech-mps-integration/tools/prepare_recognizer_training_job.py @@ -0,0 +1,370 @@ +#!/usr/bin/env python3 +"""Materialize a reproducible recognizer training job from an admission plan.""" + +from __future__ import annotations + +import argparse +import importlib.util +import json +import shlex +import shutil +import stat +import sys +import tarfile +from datetime import datetime, timezone +from pathlib import Path, PurePosixPath +from typing import Any + +from ocrtech.manifest import sha256_file + + +JOB_MANIFEST = "recognizer-training-job.json" +RUN_SCRIPT = "run-training.sh" + + +def _load_validator() -> Any: + path = Path(__file__).resolve().parent / "validate_recognizer_training_admission_plan.py" + spec = importlib.util.spec_from_file_location("validate_recognizer_training_admission_plan", path) + if spec is None or spec.loader is None: + raise RuntimeError(f"could not load admission-plan validator: {path}") + module = importlib.util.module_from_spec(spec) + sys.modules[spec.name] = module + spec.loader.exec_module(module) + return module + + +def _read_json(path: Path) -> dict[str, Any]: + try: + payload = json.loads(path.read_text(encoding="utf-8")) + except json.JSONDecodeError as exc: + raise ValueError(f"invalid JSON: {path}: {exc}") from exc + if not isinstance(payload, dict): + raise ValueError(f"JSON file must contain an object: {path}") + return payload + + +def _write_json(path: Path, payload: dict[str, Any]) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + + +def _resolve(root: Path, value: str) -> Path: + path = Path(value) + if path.is_absolute(): + return path + return root / path + + +def _archive_member_name(value: str) -> str: + if not value: + return "" + path = PurePosixPath(value.replace("\\", "/")) + if path.is_absolute() or ".." in path.parts: + return "" + return path.as_posix() + + +def _parse_config_member(command: str) -> str: + parts = shlex.split(command) + for index, part in enumerate(parts): + if part == "-c" and index + 1 < len(parts): + return _archive_member_name(parts[index + 1]) + if part.startswith("-c="): + return _archive_member_name(part.split("=", 1)[1]) + raise ValueError(f"training command has no -c config argument: {command}") + + +def _select_plan(plan_payload: dict[str, Any], plan_id: str | None) -> dict[str, Any]: + plans = plan_payload.get("plans") + if not isinstance(plans, list) or not plans: + raise ValueError("plan file must contain a non-empty plans list") + if plan_id is None: + if len(plans) != 1: + raise ValueError("--plan-id is required when plan file contains multiple plans") + plan = plans[0] + if not isinstance(plan, dict): + raise ValueError("selected plan must be an object") + return plan + matches = [plan for plan in plans if isinstance(plan, dict) and plan.get("id") == plan_id] + if len(matches) != 1: + raise ValueError(f"plan id must resolve exactly once: {plan_id} matches={len(matches)}") + return matches[0] + + +def _select_validation(validation: dict[str, Any], plan_id: str) -> dict[str, Any]: + matches = [plan for plan in validation.get("plans", []) if isinstance(plan, dict) and plan.get("id") == plan_id] + if len(matches) != 1: + raise ValueError(f"validation result missing selected plan: {plan_id}") + selected = matches[0] + if selected.get("training_ready") is not True: + issues = selected.get("issues") or [] + blockers = selected.get("blockers") or [] + raise ValueError(f"selected plan is not training-ready: issues={issues} blockers={blockers}") + return selected + + +def _read_archive_members(archive_path: Path) -> tuple[set[str], list[dict[str, Any]]]: + members: set[str] = set() + member_records: list[dict[str, Any]] = [] + try: + with tarfile.open(archive_path, "r:*") as archive: + for member in archive.getmembers(): + if member.isdir(): + continue + normalized = _archive_member_name(member.name) + if not normalized: + raise ValueError(f"unsafe archive member path: {member.name}") + members.add(normalized) + member_records.append( + { + "name": normalized, + "size": member.size, + } + ) + except tarfile.TarError as exc: + raise ValueError(f"could not inspect training bundle archive: {archive_path}: {exc}") from exc + return members, member_records + + +def _require_members(members: set[str], required: list[str]) -> list[str]: + missing = [member for member in required if member and member not in members] + if missing: + raise ValueError(f"training bundle archive is missing required members: {missing}") + return required + + +def _optional_member_status(members: set[str], member: str) -> dict[str, Any]: + return { + "member": member, + "present": bool(member and member in members), + } + + +def _sealed_member_hits(members: set[str], selection: dict[str, Any]) -> list[str]: + candidates = [ + _archive_member_name(str(selection.get("sealed_eval_manifest") or "")), + _archive_member_name(str(selection.get("sealed_eval_label_file") or "")), + ] + return [member for member in candidates if member and member in members] + + +def _write_run_script( + *, + path: Path, + archive_path: Path, + python_bin: str, + paddleocr_dir: str, + config_member: str, +) -> str: + quoted_archive = shlex.quote(str(archive_path)) + quoted_python = shlex.quote(python_bin) + quoted_paddleocr = shlex.quote(paddleocr_dir) + quoted_config = shlex.quote(config_member) + content = ( + "#!/usr/bin/env bash\n" + "set -euo pipefail\n\n" + "JOB_DIR=\"$(cd \"$(dirname \"${BASH_SOURCE[0]}\")\" && pwd)\"\n" + "WORKSPACE=\"${WORKSPACE:-$JOB_DIR/workspace}\"\n" + f"ARCHIVE={quoted_archive}\n" + f"PYTHON_BIN={quoted_python}\n" + f"PADDLEOCR_DIR={quoted_paddleocr}\n" + f"CONFIG_MEMBER={quoted_config}\n\n" + "mkdir -p \"$WORKSPACE\"\n" + "if [ ! -f \"$WORKSPACE/$CONFIG_MEMBER\" ]; then\n" + " tar -xzf \"$ARCHIVE\" -C \"$WORKSPACE\"\n" + "fi\n\n" + "cd \"$WORKSPACE\"\n" + "PYTHONPATH=\"$PADDLEOCR_DIR${PYTHONPATH:+:$PYTHONPATH}\" \\\n" + " \"$PYTHON_BIN\" \"$PADDLEOCR_DIR/tools/train.py\" -c \"$CONFIG_MEMBER\"\n" + ) + path.write_text(content, encoding="utf-8") + mode = path.stat().st_mode + path.chmod(mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH) + return content + + +def prepare_training_job(args: argparse.Namespace) -> dict[str, Any]: + root = Path(args.root).resolve() + plan_path = Path(args.plan) + if not plan_path.is_absolute(): + plan_path = root / plan_path + plan_payload = _read_json(plan_path) + selected_plan = _select_plan(plan_payload, args.plan_id) + plan_id = str(selected_plan.get("id") or "") + if not plan_id: + raise ValueError("selected plan is missing id") + + validator = _load_validator() + validation = validator.validate_plans(plan_path, root) + selected_validation = _select_validation(validation, plan_id) + + bundle = selected_plan.get("training_bundle") + selection = selected_plan.get("selection_policy") + if not isinstance(bundle, dict) or not isinstance(selection, dict): + raise ValueError("selected plan must contain training_bundle and selection_policy objects") + + archive_path = _resolve(root, str(bundle.get("archive") or "")) + manifest_path = _resolve(root, str(bundle.get("manifest") or "")) + if sha256_file(archive_path) != bundle.get("archive_sha256"): + raise ValueError(f"training bundle archive sha256 mismatch after validation: {archive_path}") + if sha256_file(manifest_path) != bundle.get("manifest_sha256"): + raise ValueError(f"training bundle manifest sha256 mismatch after validation: {manifest_path}") + bundle_manifest = _read_json(manifest_path) + + config_member = _parse_config_member(str(bundle.get("run_command_after_extract") or "")) + members, member_records = _read_archive_members(archive_path) + required_members = sorted( + { + _archive_member_name(str(bundle.get("bundle_train_manifest") or "")), + _archive_member_name(str(bundle.get("bundle_dev_manifest") or "")), + _archive_member_name(str(bundle_manifest.get("train_manifest") or "")), + _archive_member_name(str(bundle_manifest.get("eval_manifest") or "")), + config_member, + } + ) + _require_members(members, required_members) + + sealed_hits = _sealed_member_hits(members, selection) + if sealed_hits: + raise ValueError(f"sealed eval artifacts are present in the training bundle archive: {sealed_hits}") + + corpus_audit = bundle_manifest.get("recognizer_corpus_audit") + corpus_audit_member = "" + if isinstance(corpus_audit, dict): + corpus_audit_member = _archive_member_name(str(corpus_audit.get("path") or "")) + corpus_audit_status = _optional_member_status(members, corpus_audit_member) + warnings: list[str] = [] + if isinstance(corpus_audit, dict) and corpus_audit.get("required") is True and not corpus_audit_status["present"]: + warnings.append( + "training bundle manifest records a required passing recognizer-corpus audit, " + "but the audit JSON is not packaged in the archive" + ) + + out = Path(args.out) + if out.exists() and any(out.iterdir()) and not args.force: + raise FileExistsError(f"output directory exists and is not empty: {out}") + if out.exists() and args.force: + shutil.rmtree(out) + out.mkdir(parents=True, exist_ok=True) + + python_bin = str(args.python_bin) + paddleocr_dir = str(args.paddleocr_dir) + run_script_path = out / RUN_SCRIPT + _write_run_script( + path=run_script_path, + archive_path=archive_path, + python_bin=python_bin, + paddleocr_dir=paddleocr_dir, + config_member=config_member, + ) + + paddleocr_path = Path(paddleocr_dir).expanduser() + python_path = Path(python_bin).expanduser() + job = { + "created_at": datetime.now(timezone.utc).isoformat(), + "claim_boundary": ( + "This materializes a train/dev recognizer training job only. " + "It does not contain a trained checkpoint and does not admit a model." + ), + "plan": { + "path": str(plan_path), + "sha256": sha256_file(plan_path), + "id": plan_id, + "language": selected_plan.get("language"), + "script": selected_plan.get("script"), + "model_family": selected_plan.get("model_family"), + }, + "validation": { + "training_ready": selected_validation.get("training_ready"), + "heldout_admission_ready": selected_validation.get("heldout_admission_ready"), + "counts": selected_validation.get("counts"), + "allowed_checkpoint_selection_splits": selected_validation.get("selection", {}).get( + "allowed_checkpoint_selection_splits" + ), + "forbidden_checkpoint_selection_splits": selected_validation.get("selection", {}).get( + "forbidden_checkpoint_selection_splits" + ), + }, + "training_bundle": { + "archive": str(archive_path), + "archive_sha256": sha256_file(archive_path), + "manifest": str(manifest_path), + "manifest_sha256": sha256_file(manifest_path), + "manifest_payload_sha256": sha256_file(manifest_path), + "recipe_backend": bundle.get("recipe_backend"), + "run_command_after_extract": bundle.get("run_command_after_extract"), + "config_member": config_member, + "required_members": required_members, + "member_count": len(members), + "member_total_bytes": sum(int(record["size"]) for record in member_records), + "recognizer_corpus_audit": { + "manifest_record": corpus_audit, + "archive_status": corpus_audit_status, + }, + }, + "sealed_eval": { + "manifest": str(_resolve(root, str(selection.get("sealed_eval_manifest") or ""))), + "manifest_sha256": sha256_file(_resolve(root, str(selection.get("sealed_eval_manifest") or ""))), + "label_file": str(_resolve(root, str(selection.get("sealed_eval_label_file") or ""))), + "label_file_sha256": sha256_file(_resolve(root, str(selection.get("sealed_eval_label_file") or ""))), + "used_for_training": False, + "archive_member_hits": sealed_hits, + }, + "external_dependencies": { + "python_bin": python_bin, + "python_bin_exists": python_path.exists(), + "paddleocr_dir": paddleocr_dir, + "paddleocr_dir_exists": paddleocr_path.exists(), + "paddleocr_train_py": str(paddleocr_path / "tools" / "train.py"), + "paddleocr_train_py_exists": (paddleocr_path / "tools" / "train.py").exists(), + }, + "outputs": { + "job_dir": str(out), + "run_script": str(run_script_path), + "run_script_sha256": sha256_file(run_script_path), + "workspace_default": str(out / "workspace"), + "run_command_from_job_dir": f"./{RUN_SCRIPT}", + }, + "script_preview_sha256": sha256_file(run_script_path), + "warnings": warnings, + } + _write_json(out / JOB_MANIFEST, job) + (out / "README.md").write_text( + "# Recognizer Training Job\n\n" + "This directory contains a reproducible launcher for the train/dev PaddleOCR recognizer bundle. " + "The sealed held-out eval manifest and label file are recorded for audit only and are not packaged " + "or used by the generated training script.\n\n" + "Run from this directory:\n\n" + "```bash\n" + f"./{RUN_SCRIPT}\n" + "```\n\n" + "The script extracts the portable training bundle into `workspace/` on first run, then launches " + "PaddleOCR with the bundle config.\n\n" + f"Script SHA-256: `{sha256_file(run_script_path)}`\n", + encoding="utf-8", + ) + return job + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--plan", type=Path, required=True) + parser.add_argument("--plan-id") + parser.add_argument("--root", type=Path, default=Path(".")) + parser.add_argument("--out", type=Path, required=True) + parser.add_argument("--python-bin", default=sys.executable) + parser.add_argument("--paddleocr-dir", default="PaddleOCR") + parser.add_argument("--force", action="store_true") + args = parser.parse_args(argv) + job = prepare_training_job(args) + print(out_path := Path(args.out) / JOB_MANIFEST) + print( + f"plan_id={job['plan']['id']} training_ready={job['validation']['training_ready']} " + f"sealed_eval_used_for_training={job['sealed_eval']['used_for_training']} " + f"warnings={len(job['warnings'])}" + ) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ocr-tech-mps-integration/tools/prepare_recognizer_training_runtime_launch.py b/ocr-tech-mps-integration/tools/prepare_recognizer_training_runtime_launch.py new file mode 100644 index 0000000000000000000000000000000000000000..afaecc86bd187ea9ca1c713fd236dbf99fa2d580 --- /dev/null +++ b/ocr-tech-mps-integration/tools/prepare_recognizer_training_runtime_launch.py @@ -0,0 +1,307 @@ +#!/usr/bin/env python3 +"""Prepare a host-specific launcher for a preflighted recognizer training job.""" + +from __future__ import annotations + +import argparse +import json +import os +import shlex +import shutil +import stat +import subprocess +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +from ocrtech.manifest import sha256_file + + +LAUNCH_MANIFEST = "recognizer-training-runtime-launch.json" +RUN_SCRIPT = "run-training-current-host.sh" + + +def _read_json(path: Path, label: str) -> dict[str, Any]: + if not path.exists(): + raise FileNotFoundError(f"{label} does not exist: {path}") + try: + payload = json.loads(path.read_text(encoding="utf-8")) + except json.JSONDecodeError as exc: + raise ValueError(f"{label} is invalid JSON: {path}: {exc}") from exc + if not isinstance(payload, dict): + raise ValueError(f"{label} must contain a JSON object: {path}") + return payload + + +def _write_json(path: Path, payload: Any) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + + +def _resolve(root: Path, value: str) -> Path: + path = Path(value) + if path.is_absolute(): + return path + return root / path + + +def _detect_paddle_device(python_bin: Path, paddleocr_dir: Path, timeout_seconds: int) -> dict[str, Any]: + code = ( + "import json\n" + "import paddle\n" + "compiled = paddle.device.is_compiled_with_cuda()\n" + "count = paddle.device.cuda.device_count() if compiled else 0\n" + "print(json.dumps({" + "'paddle': getattr(paddle, '__version__', None), " + "'compiled_with_cuda': compiled, " + "'cuda_device_count': count, " + "'device': str(paddle.device.get_device())" + "}, ensure_ascii=False))\n" + ) + env = os.environ.copy() + existing_pythonpath = env.get("PYTHONPATH") + env["PYTHONPATH"] = str(paddleocr_dir) if not existing_pythonpath else f"{paddleocr_dir}{os.pathsep}{existing_pythonpath}" + try: + completed = subprocess.run( + [str(python_bin), "-c", code], + check=False, + capture_output=True, + text=True, + timeout=timeout_seconds, + env=env, + ) + except subprocess.TimeoutExpired as exc: + return { + "ok": False, + "issue": f"device detection timed out after {timeout_seconds}s", + "stdout": exc.stdout or "", + "stderr": exc.stderr or "", + } + except OSError as exc: + return {"ok": False, "issue": f"device detection could not start: {exc}", "stdout": "", "stderr": str(exc)} + if completed.returncode != 0: + return { + "ok": False, + "issue": "device detection command failed", + "returncode": completed.returncode, + "stdout": completed.stdout, + "stderr": completed.stderr, + } + try: + payload = json.loads(completed.stdout.strip().splitlines()[-1]) + except (IndexError, json.JSONDecodeError) as exc: + return { + "ok": False, + "issue": f"device detection output was not JSON: {exc}", + "returncode": completed.returncode, + "stdout": completed.stdout, + "stderr": completed.stderr, + } + if not isinstance(payload, dict): + return {"ok": False, "issue": "device detection output was not an object", "stdout": completed.stdout} + return {"ok": True, "stdout": completed.stdout, "stderr": completed.stderr, **payload} + + +def _shell_array(values: list[str]) -> str: + quoted = " ".join(shlex.quote(value) for value in values) + return f"({quoted})" + + +def _write_run_script( + *, + path: Path, + archive_path: Path, + python_bin: Path, + paddleocr_dir: Path, + config_member: str, + workspace: Path, + log_path: Path, + overrides: list[str], +) -> str: + content = ( + "#!/usr/bin/env bash\n" + "set -euo pipefail\n\n" + "LAUNCH_DIR=\"$(cd \"$(dirname \"${BASH_SOURCE[0]}\")\" && pwd)\"\n" + f"WORKSPACE={shlex.quote(str(workspace))}\n" + f"ARCHIVE={shlex.quote(str(archive_path))}\n" + f"PYTHON_BIN={shlex.quote(str(python_bin))}\n" + f"PADDLEOCR_DIR={shlex.quote(str(paddleocr_dir))}\n" + f"CONFIG_MEMBER={shlex.quote(config_member)}\n" + f"TRAIN_LOG={shlex.quote(str(log_path))}\n" + f"OVERRIDES={_shell_array(overrides)}\n\n" + "mkdir -p \"$WORKSPACE\" \"$(dirname \"$TRAIN_LOG\")\"\n" + "if [ ! -f \"$WORKSPACE/$CONFIG_MEMBER\" ]; then\n" + " tar -xzf \"$ARCHIVE\" -C \"$WORKSPACE\"\n" + "fi\n\n" + "cd \"$WORKSPACE\"\n" + "PYTHONPATH=\"$PADDLEOCR_DIR${PYTHONPATH:+:$PYTHONPATH}\" \\\n" + " \"$PYTHON_BIN\" \"$PADDLEOCR_DIR/tools/train.py\" -c \"$CONFIG_MEMBER\" -o \"${OVERRIDES[@]}\" \\\n" + " 2>&1 | tee \"$TRAIN_LOG\"\n" + ) + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(content, encoding="utf-8") + path.chmod(path.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH) + return content + + +def prepare_runtime_launch(args: argparse.Namespace) -> dict[str, Any]: + root = Path(args.root).resolve() + out = _resolve(root, str(args.out)) + if out.exists() and any(out.iterdir()) and not args.force: + raise FileExistsError(f"output directory exists and is not empty: {out}") + if out.exists() and args.force: + shutil.rmtree(out) + out.mkdir(parents=True, exist_ok=True) + + job_path = _resolve(root, str(args.job_manifest)) + job = _read_json(job_path, "training job manifest") + preflight_path = _resolve(root, str(args.preflight_report)) + preflight = _read_json(preflight_path, "training runtime preflight report") + issues: list[str] = [] + warnings: list[str] = [] + if preflight.get("ready_to_start_training") is not True: + issues.append("runtime preflight is not ready_to_start_training=true") + if preflight.get("issue_count") not in (0, None): + issues.append(f"runtime preflight has issues: {preflight.get('issue_count')}") + if job.get("sealed_eval", {}).get("used_for_training") is not False: + issues.append("training job does not prove sealed eval was excluded from training") + + archive_path = _resolve(root, str(job.get("training_bundle", {}).get("archive") or "")) + config_member = str(job.get("training_bundle", {}).get("config_member") or "") + dependencies = job.get("external_dependencies", {}) if isinstance(job.get("external_dependencies"), dict) else {} + python_bin = Path(str(args.python_bin or dependencies.get("python_bin") or "")) + paddleocr_dir = Path(str(args.paddleocr_dir or dependencies.get("paddleocr_dir") or "")) + train_py = paddleocr_dir / "tools" / "train.py" + for label, path in {"archive": archive_path, "python_bin": python_bin, "paddleocr_dir": paddleocr_dir, "paddleocr_train_py": train_py}.items(): + if not path.exists(): + issues.append(f"{label} does not exist: {path}") + if not config_member: + issues.append("training job manifest does not record training_bundle.config_member") + + device = _detect_paddle_device(python_bin, paddleocr_dir, int(args.device_timeout_seconds)) if python_bin.exists() and paddleocr_dir.exists() else {"ok": False} + if not device.get("ok"): + issues.append(f"could not detect Paddle runtime device: {device.get('issue')}") + + requested_device = str(args.device) + if requested_device == "auto": + use_gpu = bool(device.get("compiled_with_cuda") and int(device.get("cuda_device_count") or 0) > 0) + elif requested_device == "gpu": + use_gpu = True + if not bool(device.get("compiled_with_cuda") and int(device.get("cuda_device_count") or 0) > 0): + issues.append("GPU launch requested, but Paddle does not report an available CUDA device") + elif requested_device == "cpu": + use_gpu = False + else: # pragma: no cover - argparse choices prevent this. + raise ValueError(f"unsupported device: {requested_device}") + if not use_gpu: + warnings.append("launch uses CPU override because no CUDA Paddle device is available or CPU was requested") + + workspace = Path(args.workspace) if args.workspace else out / "workspace" + if not workspace.is_absolute(): + workspace = root / workspace + recipe_dir = Path(config_member).parent + checkpoint_dir = args.checkpoint_dir or f"{recipe_dir.as_posix()}/checkpoints-current-host-{'gpu' if use_gpu else 'cpu'}" + overrides = [ + f"Global.use_gpu={str(use_gpu)}", + f"Global.save_model_dir={checkpoint_dir}", + ] + if not use_gpu: + overrides.extend(["Train.loader.num_workers=0", "Eval.loader.num_workers=0"]) + if args.epoch_num is not None: + overrides.append(f"Global.epoch_num={int(args.epoch_num)}") + if args.extra_override: + overrides.extend(args.extra_override) + + run_script = out / RUN_SCRIPT + log_path = out / "training.log" + if not issues: + _write_run_script( + path=run_script, + archive_path=archive_path, + python_bin=python_bin, + paddleocr_dir=paddleocr_dir, + config_member=config_member, + workspace=workspace, + log_path=log_path, + overrides=overrides, + ) + + launch_command = f"cd {shlex.quote(str(out))} && ./{RUN_SCRIPT}" + detached_command = f"cd {shlex.quote(str(out))} && nohup ./{RUN_SCRIPT} > launch.nohup.log 2>&1 & echo $! > training.pid" + tmux_session = str(args.tmux_session) + tmux_launch_command = ( + f"tmux new-session -d -s {shlex.quote(tmux_session)} " + f"-c {shlex.quote(str(out))} ./{RUN_SCRIPT}" + ) + manifest = { + "created_at": datetime.now(timezone.utc).isoformat(), + "ready_to_launch": not issues, + "issue_count": len(issues), + "warning_count": len(warnings), + "issues": issues, + "warnings": warnings, + "job_manifest": str(job_path), + "job_manifest_sha256": sha256_file(job_path), + "preflight_report": str(preflight_path), + "preflight_report_sha256": sha256_file(preflight_path), + "archive": str(archive_path), + "archive_sha256": sha256_file(archive_path) if archive_path.exists() else None, + "workspace": str(workspace), + "config_member": config_member, + "run_script": str(run_script) if not issues else None, + "run_script_sha256": sha256_file(run_script) if run_script.exists() else None, + "training_log": str(log_path), + "python_bin": str(python_bin), + "paddleocr_dir": str(paddleocr_dir), + "device_detection": device, + "requested_device": requested_device, + "effective_use_gpu": use_gpu, + "overrides": overrides, + "checkpoint_dir": str(workspace / checkpoint_dir), + "launch_command": launch_command if not issues else None, + "detached_launch_command": detached_command if not issues else None, + "tmux_session": tmux_session, + "tmux_launch_command": tmux_launch_command if not issues else None, + "completion_audit_command": ( + "uv run python tools/audit_recognizer_training_completion.py " + f"--job-manifest {shlex.quote(str(job_path))} --root {shlex.quote(str(root))} " + f"--workspace {shlex.quote(str(workspace))} --out outputs/limbu-devanagari-cdc-ppocrv5-training-completion-audit-2026-06-21 " + "--checkpoint-name best_accuracy " + f"--checkpoint-dir {shlex.quote(checkpoint_dir)}" + ) + if not issues + else None, + "claim_boundary": ( + "Host-specific training launcher only. This does not admit a model; checkpoint selection must remain " + "train/dev only and the sealed held-out eval must be scored only after training/export/package." + ), + } + _write_json(out / LAUNCH_MANIFEST, manifest) + return manifest + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--job-manifest", type=Path, required=True) + parser.add_argument("--preflight-report", type=Path, required=True) + parser.add_argument("--root", type=Path, default=Path(".")) + parser.add_argument("--out", type=Path, required=True) + parser.add_argument("--workspace", type=Path) + parser.add_argument("--python-bin") + parser.add_argument("--paddleocr-dir") + parser.add_argument("--device", choices=["auto", "cpu", "gpu"], default="auto") + parser.add_argument("--checkpoint-dir") + parser.add_argument("--epoch-num", type=int) + parser.add_argument("--extra-override", action="append") + parser.add_argument("--tmux-session", default="limbu_devanagari_ppocrv5_training") + parser.add_argument("--device-timeout-seconds", type=int, default=30) + parser.add_argument("--force", action="store_true") + args = parser.parse_args(argv) + manifest = prepare_runtime_launch(args) + print(Path(args.out) / LAUNCH_MANIFEST) + print(f"ready_to_launch={manifest['ready_to_launch']} issues={manifest['issue_count']} warnings={manifest['warning_count']}") + return 0 if manifest["ready_to_launch"] else 1 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ocr-tech-mps-integration/tools/prepare_unresolved_page_review_packet.py b/ocr-tech-mps-integration/tools/prepare_unresolved_page_review_packet.py new file mode 100644 index 0000000000000000000000000000000000000000..b565d208e1dc64407a03d331d0169bc3e534c2df --- /dev/null +++ b/ocr-tech-mps-integration/tools/prepare_unresolved_page_review_packet.py @@ -0,0 +1,356 @@ +#!/usr/bin/env python3 +"""Prepare a textless review packet for unresolved page OCR regions.""" + +from __future__ import annotations + +import argparse +import ast +import hashlib +import html +import json +import re +from datetime import UTC, datetime +from pathlib import Path +from typing import Any + +from PIL import Image + + +def _sha256_file(path: Path) -> str: + digest = hashlib.sha256() + with path.open("rb") as handle: + for chunk in iter(lambda: handle.read(1024 * 1024), b""): + digest.update(chunk) + return digest.hexdigest() + + +def _read_json_object(path: Path, *, label: str) -> dict[str, Any]: + try: + payload = json.loads(path.read_text(encoding="utf-8")) + except FileNotFoundError as exc: + raise ValueError(f"{label} does not exist: {path}") from exc + except json.JSONDecodeError as exc: + raise ValueError(f"{label} is not valid JSON: {path} ({exc})") from exc + if not isinstance(payload, dict): + raise ValueError(f"{label} must be a JSON object: {path}") + return payload + + +def _load_manifest_images(path: Path) -> dict[str, Path]: + manifest_dir = path.parent + images: dict[str, Path] = {} + try: + lines = path.read_text(encoding="utf-8").splitlines() + except FileNotFoundError as exc: + raise ValueError(f"eval manifest does not exist: {path}") from exc + for line_number, line in enumerate(lines, start=1): + if not line.strip(): + continue + try: + payload = json.loads(line) + except json.JSONDecodeError as exc: + raise ValueError(f"eval manifest line {line_number} is not valid JSON: {path}") from exc + if not isinstance(payload, dict): + raise ValueError(f"eval manifest line {line_number} must be a JSON object: {path}") + sample_id = payload.get("sample_id") + image_path = payload.get("image_path") + if not isinstance(sample_id, str) or not sample_id: + raise ValueError(f"eval manifest line {line_number} missing sample_id: {path}") + if not isinstance(image_path, str) or not image_path: + raise ValueError(f"eval manifest line {line_number} missing image_path: {path}") + image = Path(image_path) + if not image.is_absolute() and not image.exists(): + image = manifest_dir / image + images[sample_id] = image + if not images: + raise ValueError(f"eval manifest is empty: {path}") + return images + + +def _parse_bbox(value: Any) -> list[float] | None: + if value in (None, "", []): + return None + raw = value + if isinstance(value, str): + try: + raw = ast.literal_eval(value) + except (SyntaxError, ValueError) as exc: + raise ValueError(f"bbox is not parseable: {value!r}") from exc + if not isinstance(raw, list | tuple) or len(raw) != 4: + raise ValueError(f"bbox must be a 4-item list: {value!r}") + try: + bbox = [float(item) for item in raw] + except (TypeError, ValueError) as exc: + raise ValueError(f"bbox contains non-numeric values: {value!r}") from exc + if bbox[2] <= 0 or bbox[3] <= 0: + raise ValueError(f"bbox width/height must be positive: {value!r}") + return bbox + + +def _union_bboxes(boxes: list[list[float]]) -> list[float]: + left = min(box[0] for box in boxes) + top = min(box[1] for box in boxes) + right = max(box[0] + box[2] for box in boxes) + bottom = max(box[1] + box[3] for box in boxes) + return [left, top, right - left, bottom - top] + + +def _crop_bbox(bbox: list[float], *, width: int, height: int, padding: int) -> tuple[int, int, int, int]: + left = max(0, int(bbox[0]) - padding) + top = max(0, int(bbox[1]) - padding) + right = min(width, int(bbox[0] + bbox[2] + 0.999999) + padding) + bottom = min(height, int(bbox[1] + bbox[3] + 0.999999) + padding) + if right <= left or bottom <= top: + raise ValueError(f"crop is empty after clipping bbox {bbox!r} against {width}x{height}") + return left, top, right, bottom + + +def _safe_name(value: str) -> str: + cleaned = re.sub(r"[^A-Za-z0-9._-]+", "-", value).strip(".-") + return cleaned or "row" + + +def _reference_rows(failure: dict[str, Any]) -> list[dict[str, Any]]: + rows = failure.get("top_unmatched_references") + if not isinstance(rows, list): + raise ValueError("failure analysis missing top_unmatched_references list") + return [row for row in rows if isinstance(row, dict)] + + +def _prediction_rows(failure: dict[str, Any]) -> list[dict[str, Any]]: + rows = failure.get("top_unmatched_predictions") + if not isinstance(rows, list): + raise ValueError("failure analysis missing top_unmatched_predictions list") + return [row for row in rows if isinstance(row, dict)] + + +def _hidden_reference_texts(failure: dict[str, Any]) -> set[str]: + values: set[str] = set() + for key in ("top_unmatched_references", "top_unmatched_predictions"): + rows = failure.get(key) + if not isinstance(rows, list): + continue + for row in rows: + if not isinstance(row, dict): + continue + value = row.get("reference_text") + if isinstance(value, str) and value: + values.add(value) + return values + + +def _packet_row( + source_row: dict[str, Any], + *, + row_kind: str, + image_path: Path, + out_crops: Path, + padding: int, + index: int, + hidden_reference_texts: set[str], +) -> dict[str, Any]: + sample_id = str(source_row.get("sample_id") or "") + if not sample_id: + raise ValueError(f"{row_kind} row {index} is missing sample_id") + reference_bbox = _parse_bbox(source_row.get("reference_bbox")) + predicted_bbox = _parse_bbox(source_row.get("predicted_bbox")) + best_prediction_bbox = _parse_bbox(source_row.get("best_any_prediction_bbox")) + crop_boxes = [box for box in (reference_bbox, predicted_bbox, best_prediction_bbox) if box is not None] + if not crop_boxes: + raise ValueError(f"{row_kind} row {index} has no bbox to crop") + display_bbox = _union_bboxes(crop_boxes) + with Image.open(image_path) as image: + rgb = image.convert("RGB") + crop_xyxy = _crop_bbox(display_bbox, width=rgb.width, height=rgb.height, padding=padding) + row_id = f"{row_kind}-{index:04d}-{_safe_name(sample_id)}" + crop_path = out_crops / f"{row_id}.png" + crop_path.parent.mkdir(parents=True, exist_ok=True) + rgb.crop(crop_xyxy).save(crop_path) + image_size = [rgb.width, rgb.height] + visible_prediction = source_row.get("predicted_text") or source_row.get("best_any_prediction_text") or "" + exact_hidden_reference_text_echo = visible_prediction in hidden_reference_texts + if exact_hidden_reference_text_echo: + visible_prediction = "" + return { + "row_id": row_id, + "review_status": "pending", + "corrected_text": "", + "reviewer": "", + "notes": "", + "sample_id": sample_id, + "row_kind": row_kind, + "page_index": source_row.get("page_index"), + "reference_line_id": source_row.get("reference_line_id") or "", + "predicted_line_id": source_row.get("predicted_line_id") or source_row.get("best_any_prediction_line_id") or "", + "reference_bbox": reference_bbox, + "predicted_bbox": predicted_bbox, + "best_any_prediction_bbox": best_prediction_bbox, + "display_bbox": display_bbox, + "crop_xyxy": list(crop_xyxy), + "crop_path": str(crop_path), + "crop_sha256": _sha256_file(crop_path), + "image_path": str(image_path), + "image_sha256": _sha256_file(image_path), + "image_size": image_size, + "iou": source_row.get("iou"), + "best_any_prediction_iou": source_row.get("best_any_prediction_iou"), + "confidence": source_row.get("confidence") or source_row.get("best_any_prediction_confidence"), + "visible_machine_prediction_text": visible_prediction, + "exact_hidden_reference_text_echo_suppressed": exact_hidden_reference_text_echo, + "reference_text_visible": False, + "instructions": "Review the crop geometry and machine text. Do not use hidden reference text.", + } + + +def _write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None: + path.write_text("".join(json.dumps(row, ensure_ascii=False, sort_keys=True) + "\n" for row in rows), encoding="utf-8") + + +def _write_html(path: Path, rows: list[dict[str, Any]], *, packet_jsonl: Path) -> None: + cards: list[str] = [] + for row in rows: + rel_crop = Path(row["crop_path"]).name + prediction = html.escape(str(row.get("visible_machine_prediction_text") or "")) + cards.append( + "\n".join( + [ + '
', + f"

{html.escape(str(row['row_id']))}

", + f"

sample {html.escape(str(row['sample_id']))} · kind {html.escape(str(row['row_kind']))}

", + f'unresolved crop {html.escape(str(row[', + f"

reference line {html.escape(str(row.get('reference_line_id') or ''))}

", + f"

predicted line {html.escape(str(row.get('predicted_line_id') or ''))}

", + f"

machine text
{prediction}

", + f"

bbox {html.escape(json.dumps(row.get('display_bbox'), ensure_ascii=False))}

", + '

review_status: pending · reference text hidden

', + "
", + ] + ) + ) + path.write_text( + "\n".join( + [ + "", + '', + "Unresolved OCR Region Review", + "", + "", + "

Unresolved OCR Region Review

", + f"

Edit {html.escape(packet_jsonl.name)} after review. Reference text is intentionally hidden.

", + *cards, + "", + ] + ) + + "\n", + encoding="utf-8", + ) + + +def _write_markdown(path: Path, summary: dict[str, Any]) -> None: + path.write_text( + "\n".join( + [ + "# Unresolved OCR Region Review Packet", + "", + f"- rows: `{summary['row_count']}`", + f"- reference-unmatched rows: `{summary['reference_unmatched_count']}`", + f"- prediction-unmatched rows: `{summary['prediction_unmatched_count']}`", + f"- review JSONL: `{summary['review_jsonl']}`", + f"- review HTML: `{summary['review_html']}`", + f"- reference text visible: `{summary['reference_text_visible']}`", + f"- exact hidden-reference machine echoes suppressed: `{summary['exact_hidden_reference_text_echo_suppressed_count']}`", + "", + "This packet is diagnostic and textless for hidden references. Use it to inspect geometry, missed regions, and machine-output crops.", + ] + ) + + "\n", + encoding="utf-8", + ) + + +def prepare_packet(args: argparse.Namespace) -> dict[str, Any]: + failure_path = Path(args.failure_analysis) + manifest_path = Path(args.eval_manifest) + out = Path(args.out) + out.mkdir(parents=True, exist_ok=True) + crops = out / "crops" + crops.mkdir(parents=True, exist_ok=True) + failure = _read_json_object(failure_path, label="failure analysis") + sample_images = _load_manifest_images(manifest_path) + hidden_reference_texts = _hidden_reference_texts(failure) + rows: list[dict[str, Any]] = [] + for index, row in enumerate(_reference_rows(failure), start=1): + sample_id = str(row.get("sample_id") or "") + if sample_id not in sample_images: + raise ValueError(f"sample {sample_id!r} from failure analysis is missing from eval manifest") + rows.append( + _packet_row( + row, + row_kind="reference_unmatched", + image_path=sample_images[sample_id], + out_crops=crops, + padding=args.padding, + index=index, + hidden_reference_texts=hidden_reference_texts, + ) + ) + for index, row in enumerate(_prediction_rows(failure), start=1): + sample_id = str(row.get("sample_id") or "") + if sample_id not in sample_images: + raise ValueError(f"sample {sample_id!r} from failure analysis is missing from eval manifest") + rows.append( + _packet_row( + row, + row_kind="prediction_unmatched", + image_path=sample_images[sample_id], + out_crops=crops, + padding=args.padding, + index=index, + hidden_reference_texts=hidden_reference_texts, + ) + ) + review_jsonl = out / "unresolved-region-review.jsonl" + review_html = out / "unresolved-region-review.html" + summary_path = out / "unresolved-region-review-packet.json" + report_path = out / "README.md" + _write_jsonl(review_jsonl, rows) + _write_html(review_html, rows, packet_jsonl=review_jsonl) + summary = { + "tool": "tools/prepare_unresolved_page_review_packet.py", + "created_at_utc": datetime.now(UTC).isoformat(), + "failure_analysis": str(failure_path), + "failure_analysis_sha256": _sha256_file(failure_path), + "eval_manifest": str(manifest_path), + "eval_manifest_sha256": _sha256_file(manifest_path), + "output_dir": str(out), + "row_count": len(rows), + "reference_unmatched_count": sum(1 for row in rows if row["row_kind"] == "reference_unmatched"), + "prediction_unmatched_count": sum(1 for row in rows if row["row_kind"] == "prediction_unmatched"), + "exact_hidden_reference_text_echo_suppressed_count": sum(1 for row in rows if row["exact_hidden_reference_text_echo_suppressed"]), + "reference_text_visible": False, + "review_jsonl": str(review_jsonl), + "review_jsonl_sha256": _sha256_file(review_jsonl), + "review_html": str(review_html), + "review_html_sha256": _sha256_file(review_html), + "report": str(report_path), + } + summary_path.write_text(json.dumps(summary, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + _write_markdown(report_path, summary) + return summary + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--failure-analysis", required=True, type=Path) + parser.add_argument("--eval-manifest", required=True, type=Path) + parser.add_argument("--out", required=True, type=Path) + parser.add_argument("--padding", type=int, default=24) + args = parser.parse_args() + if args.padding < 0: + raise SystemExit("--padding must be non-negative") + summary = prepare_packet(args) + print(f"wrote {summary['output_dir']} rows={summary['row_count']}") + + +if __name__ == "__main__": + main() diff --git a/ocr-tech-mps-integration/tools/prioritize_candidate_line_reviews.py b/ocr-tech-mps-integration/tools/prioritize_candidate_line_reviews.py new file mode 100644 index 0000000000000000000000000000000000000000..63f14aec655e125ee969f233e33a873ab6267030 --- /dev/null +++ b/ocr-tech-mps-integration/tools/prioritize_candidate_line_reviews.py @@ -0,0 +1,301 @@ +#!/usr/bin/env python3 +"""Prioritize candidate-only line review rows for human missed-line review.""" + +from __future__ import annotations + +import argparse +import csv +import html +import json +from datetime import UTC, datetime +from pathlib import Path +from typing import Any + +from ocrtech.manifest import sha256_file + + +def _read_jsonl(path: Path) -> list[dict[str, Any]]: + try: + lines = path.read_text(encoding="utf-8").splitlines() + except FileNotFoundError as exc: + raise ValueError(f"candidate review JSONL is missing: {path}") from exc + rows: list[dict[str, Any]] = [] + for line_number, line in enumerate(lines, start=1): + if not line.strip(): + continue + try: + payload = json.loads(line) + except json.JSONDecodeError as exc: + raise ValueError(f"candidate review JSONL has invalid JSON at {path}:{line_number}: {exc}") from exc + if not isinstance(payload, dict): + raise ValueError(f"candidate review JSONL row must be an object at {path}:{line_number}") + payload["_row_number"] = line_number + rows.append(payload) + return rows + + +def _write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None: + path.write_text("".join(json.dumps(row, ensure_ascii=False, sort_keys=True) + "\n" for row in rows), encoding="utf-8") + + +def _float(value: Any, default: float = 0.0) -> float: + try: + return float(value) + except (TypeError, ValueError): + return default + + +def _bbox(row: dict[str, Any]) -> tuple[float, float, float, float] | None: + value = row.get("candidate_bbox") + if not isinstance(value, list | tuple) or len(value) != 4: + return None + try: + x, y, width, height = (float(item) for item in value) + except (TypeError, ValueError): + return None + if width <= 0 or height <= 0: + return None + return x, y, width, height + + +def _image_size(row: dict[str, Any]) -> tuple[float, float] | None: + value = row.get("image_size") + if not isinstance(value, list | tuple) or len(value) != 2: + return None + try: + width, height = (float(item) for item in value) + except (TypeError, ValueError): + return None + if width <= 0 or height <= 0: + return None + return width, height + + +def _category(row: dict[str, Any], args: argparse.Namespace) -> tuple[str, str, float, list[str]]: + role = str(row.get("candidate_structural_role") or "text").strip() or "text" + text = str(row.get("candidate_text") or "").strip() + max_iou = _float(row.get("max_selected_iou"), 1.0) + confidence = _float(row.get("candidate_confidence"), 0.0) + bbox = _bbox(row) + image_size = _image_size(row) + reasons: list[str] = [] + score = 0.0 + if role == "text": + score += 100.0 + reasons.append("text_candidate") + if text: + score += min(len(text), 120) / 12.0 + reasons.append("non_empty_candidate_text") + if max_iou <= float(args.high_priority_max_selected_iou): + score += 25.0 + reasons.append("low_selected_overlap") + elif max_iou < float(args.covered_iou): + score += 12.0 + reasons.append("partial_selected_overlap") + if confidence < float(args.low_confidence_threshold): + score += 10.0 + reasons.append("low_confidence_needs_transcription") + if bbox is not None and image_size is not None: + _, y, width, height = bbox + image_width, image_height = image_size + if width / image_width >= float(args.min_wide_text_ratio): + score += 10.0 + reasons.append("wide_text_region") + if y / image_height >= float(args.bottom_region_y_ratio): + score += 5.0 + reasons.append("bottom_page_region") + if height / image_height <= float(args.max_short_text_height_ratio): + score += 3.0 + reasons.append("single_row_height") + return "body_line_candidate", "transcribe_visible_line_or_reject", score, reasons + if role == "page_marker": + score += 40.0 + reasons.append("page_marker_candidate") + if max_iou <= float(args.high_priority_max_selected_iou): + score += 8.0 + reasons.append("low_selected_overlap") + if text and text.isdigit(): + score += 2.0 + reasons.append("digit_only_marker") + return "structural_page_marker", "verify_marker_or_reject", score, reasons + reasons.append(f"structural_role_{role}") + return "other_candidate", "inspect_or_reject", score, reasons + + +def _priority_label(category: str, score: float) -> str: + if category == "body_line_candidate" and score >= 130: + return "high" + if category == "body_line_candidate": + return "medium" + if category == "structural_page_marker": + return "structural" + return "low" + + +def _sort_key(row: dict[str, Any]) -> tuple[int, float, str]: + category_rank = {"body_line_candidate": 0, "structural_page_marker": 1, "other_candidate": 2} + return ( + category_rank.get(str(row.get("review_category")), 9), + -_float(row.get("review_priority_score"), 0.0), + str(row.get("row_id") or ""), + ) + + +def _write_tsv(path: Path, rows: list[dict[str, Any]]) -> None: + fields = [ + "priority_rank", + "review_priority", + "review_category", + "suggested_review_action", + "row_id", + "sample_id", + "candidate_line_id", + "candidate_structural_role", + "candidate_confidence", + "max_selected_iou", + "candidate_bbox", + "candidate_text", + "best_selected_text", + "crop_path", + "review_status", + "corrected_text", + "reviewer", + "notes", + ] + with path.open("w", encoding="utf-8", newline="") as handle: + writer = csv.DictWriter(handle, fieldnames=fields, delimiter="\t", lineterminator="\n") + writer.writeheader() + for row in rows: + payload = {field: row.get(field, "") for field in fields} + payload["candidate_bbox"] = json.dumps(row.get("candidate_bbox"), ensure_ascii=False, separators=(",", ":")) + for key in ("candidate_text", "best_selected_text", "notes"): + payload[key] = str(payload.get(key) or "").replace("\r\n", "\n").replace("\r", "\n").replace("\n", r"\n") + writer.writerow(payload) + + +def _write_html(path: Path, rows: list[dict[str, Any]]) -> None: + cards: list[str] = [] + for row in rows: + crop_path = Path(str(row.get("crop_path") or "")) + crop_ref = crop_path.as_posix() + if crop_path.is_file(): + try: + crop_ref = crop_path.resolve().as_uri() + except ValueError: + crop_ref = crop_path.as_posix() + cards.append( + "\n".join( + [ + f"
", + f"

#{row.get('priority_rank')} {html.escape(str(row.get('row_id') or ''))}

", + f"

{html.escape(str(row.get('review_priority')))} · {html.escape(str(row.get('review_category')))} · {html.escape(str(row.get('suggested_review_action')))}

", + f"

sample {html.escape(str(row.get('sample_id') or ''))} · candidate {html.escape(str(row.get('candidate_line_id') or ''))}

", + f"\"candidate", + f"

candidate text
{html.escape(str(row.get('candidate_text') or ''))}

", + f"

selected overlap {html.escape(str(row.get('max_selected_iou')))} · confidence {html.escape(str(row.get('candidate_confidence')))}

", + f"

nearest selected text
{html.escape(str(row.get('best_selected_text') or ''))}

", + f"

reasons {html.escape(', '.join(str(item) for item in row.get('review_priority_reasons', [])))}

", + '

Leave pending until a reviewer accepts/rejects and supplies corrected_text when needed.

', + "
", + ] + ) + ) + path.write_text( + "\n".join( + [ + "", + '', + "Prioritized Candidate-Line Review", + "", + "", + "

Prioritized Candidate-Line Review

", + "

This is a reviewer queue. It does not accept rows automatically.

", + *cards, + "", + ] + ) + + "\n", + encoding="utf-8", + ) + + +def prioritize_reviews(args: argparse.Namespace) -> dict[str, Any]: + input_path = Path(args.input) + out = Path(args.out) + out.mkdir(parents=True, exist_ok=True) + rows = _read_jsonl(input_path) + prioritized_rows: list[dict[str, Any]] = [] + for row in rows: + output_row = {key: value for key, value in row.items() if not key.startswith("_")} + category, action, score, reasons = _category(row, args) + output_row["review_category"] = category + output_row["suggested_review_action"] = action + output_row["review_priority_score"] = round(score, 6) + output_row["review_priority"] = _priority_label(category, score) + output_row["review_priority_reasons"] = reasons + output_row["review_status"] = "pending" + output_row.setdefault("corrected_text", "") + prioritized_rows.append(output_row) + prioritized_rows.sort(key=_sort_key) + for index, row in enumerate(prioritized_rows, start=1): + row["priority_rank"] = index + jsonl_path = out / "prioritized-candidate-line-review.jsonl" + tsv_path = out / "prioritized-candidate-line-review.tsv" + html_path = out / "prioritized-candidate-line-review.html" + report_path = out / "candidate-line-review-prioritization.json" + _write_jsonl(jsonl_path, prioritized_rows) + _write_tsv(tsv_path, prioritized_rows) + _write_html(html_path, prioritized_rows) + category_counts: dict[str, int] = {} + priority_counts: dict[str, int] = {} + for row in prioritized_rows: + category_counts[str(row["review_category"])] = category_counts.get(str(row["review_category"]), 0) + 1 + priority_counts[str(row["review_priority"])] = priority_counts.get(str(row["review_priority"]), 0) + 1 + report = { + "tool": "tools/prioritize_candidate_line_reviews.py", + "created_at_utc": datetime.now(UTC).isoformat(), + "input": str(input_path), + "input_sha256": sha256_file(input_path), + "output_dir": str(out), + "row_count": len(prioritized_rows), + "category_counts": dict(sorted(category_counts.items())), + "priority_counts": dict(sorted(priority_counts.items())), + "policy": { + "high_priority_max_selected_iou": float(args.high_priority_max_selected_iou), + "covered_iou": float(args.covered_iou), + "low_confidence_threshold": float(args.low_confidence_threshold), + "min_wide_text_ratio": float(args.min_wide_text_ratio), + "bottom_region_y_ratio": float(args.bottom_region_y_ratio), + "max_short_text_height_ratio": float(args.max_short_text_height_ratio), + }, + "jsonl": str(jsonl_path), + "jsonl_sha256": sha256_file(jsonl_path), + "tsv": str(tsv_path), + "tsv_sha256": sha256_file(tsv_path), + "html": str(html_path), + "html_sha256": sha256_file(html_path), + "claim_boundary": "human review prioritization only; no candidate row is accepted or promoted automatically", + } + report_path.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + return report + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--input", required=True, type=Path) + parser.add_argument("--out", required=True, type=Path) + parser.add_argument("--high-priority-max-selected-iou", type=float, default=0.35) + parser.add_argument("--covered-iou", type=float, default=0.50) + parser.add_argument("--low-confidence-threshold", type=float, default=0.70) + parser.add_argument("--min-wide-text-ratio", type=float, default=0.20) + parser.add_argument("--bottom-region-y-ratio", type=float, default=0.75) + parser.add_argument("--max-short-text-height-ratio", type=float, default=0.04) + args = parser.parse_args() + report = prioritize_reviews(args) + print(str(Path(report["output_dir"]) / "candidate-line-review-prioritization.json")) + print(report["jsonl"]) + print(f"rows={report['row_count']} categories={report['category_counts']}") + + +if __name__ == "__main__": + main() diff --git a/ocr-tech-mps-integration/tools/promote_limbu_book_split_prefill_as_line_text.py b/ocr-tech-mps-integration/tools/promote_limbu_book_split_prefill_as_line_text.py new file mode 100644 index 0000000000000000000000000000000000000000..49ba0cf8c415d42b2237e4d063243ce6a7938e31 --- /dev/null +++ b/ocr-tech-mps-integration/tools/promote_limbu_book_split_prefill_as_line_text.py @@ -0,0 +1,419 @@ +#!/usr/bin/env python3 +"""Create a diagnostic line-text correction packet from recognizer-prefilled split segments.""" + +from __future__ import annotations + +import argparse +import csv +import html +import json +import os +from collections import Counter, defaultdict +from datetime import UTC, datetime +from pathlib import Path +from typing import Any + +from ocrtech.manifest import sha256_file +from ocrtech.normalization import normalize_ocr_text + + +OUTPUT_TSV = "book-unresolved-review-packet-with-recognizer-line-text.tsv" +OUTPUT_HTML = "book-unresolved-review-packet-with-recognizer-line-text.html" +REPORT_JSON = "book-line-split-prefill-line-text-promotion.json" +COMPLETE_GROUP_STATUSES = {"suggested", "empty_prediction"} +TEXT_SEGMENT_STATUSES = {"suggested", "allowed_low_confidence"} + + +def _read_json_object(path: Path, *, label: str) -> dict[str, Any]: + try: + payload = json.loads(path.read_text(encoding="utf-8")) + except FileNotFoundError as exc: + raise ValueError(f"{label} is missing: {path}") from exc + except json.JSONDecodeError as exc: + raise ValueError(f"{label} is invalid JSON: {path}: {exc}") from exc + if not isinstance(payload, dict): + raise ValueError(f"{label} must contain a JSON object: {path}") + return payload + + +def _read_tsv(path: Path, *, label: str) -> tuple[list[dict[str, str]], list[str]]: + try: + handle = path.open("r", encoding="utf-8", newline="") + except FileNotFoundError as exc: + raise ValueError(f"{label} is missing: {path}") from exc + with handle: + reader = csv.DictReader(handle, delimiter="\t") + if reader.fieldnames is None: + raise ValueError(f"{label} has no header: {path}") + return [dict(row) for row in reader], list(reader.fieldnames) + + +def _verify_sha(path: Path, expected: object, *, label: str) -> str: + if not path.is_file(): + raise ValueError(f"{label} is missing: {path}") + actual = sha256_file(path) + if not isinstance(expected, str) or not expected: + raise ValueError(f"{label} missing recorded SHA-256") + if actual != expected: + raise ValueError(f"{label} SHA-256 mismatch: recorded={expected} actual={actual} path={path}") + return actual + + +def _write_tsv(path: Path, rows: list[dict[str, str]], fields: list[str]) -> None: + with path.open("w", encoding="utf-8", newline="") as handle: + writer = csv.DictWriter(handle, fieldnames=fields, delimiter="\t", lineterminator="\n") + writer.writeheader() + writer.writerows(rows) + + +def _relative_ref(path: Path, root: Path) -> str: + return os.path.relpath(path, root) + + +def _group_rows(rows: list[dict[str, str]]) -> dict[str, list[dict[str, str]]]: + grouped: dict[str, list[dict[str, str]]] = defaultdict(list) + for row in rows: + packet_row_id = str(row.get("packet_row_id") or "") + if not packet_row_id: + raise ValueError("recognizer prefill worksheet contains row with empty packet_row_id") + grouped[packet_row_id].append(row) + for packet_rows in grouped.values(): + packet_rows.sort(key=lambda item: int(str(item.get("segment_index") or "0"))) + return grouped + + +def _confidence(row: dict[str, str]) -> float | None: + value = str(row.get("candidate_segment_confidence") or "").strip() + if not value: + return None + try: + return float(value) + except ValueError as exc: + raise ValueError(f"invalid candidate_segment_confidence {value!r} for {row.get('worksheet_row_id')!r}") from exc + + +def _effective_status(row: dict[str, str], low_confidence_threshold: float | None) -> str: + status = str(row.get("candidate_segment_prefill_status") or "") + if status != "low_confidence" or low_confidence_threshold is None: + return status + confidence = _confidence(row) + if confidence is not None and confidence >= low_confidence_threshold and normalize_ocr_text(str(row.get("candidate_segment_text") or "")).strip(): + return "allowed_low_confidence" + return status + + +def _complete_group(rows: list[dict[str, str]], low_confidence_threshold: float | None) -> bool: + statuses = {_effective_status(row, low_confidence_threshold) for row in rows} + text_segments = sum(1 for row in rows if _effective_status(row, low_confidence_threshold) in TEXT_SEGMENT_STATUSES) + return statuses <= (COMPLETE_GROUP_STATUSES | {"allowed_low_confidence"}) and text_segments >= 2 + + +def _line_text(rows: list[dict[str, str]], joiner: str, low_confidence_threshold: float | None) -> str: + parts = [ + normalize_ocr_text(str(row.get("candidate_segment_text") or "")).strip() + for row in rows + if _effective_status(row, low_confidence_threshold) in TEXT_SEGMENT_STATUSES + ] + return normalize_ocr_text(joiner.join(part for part in parts if part)).strip() + + +def _append_note(existing: str, note: str) -> str: + existing = str(existing or "").strip() + return f"{existing}; {note}" if existing else note + + +def _write_html( + path: Path, + *, + out: Path, + output_rows: list[dict[str, str]], + grouped_prefill_rows: dict[str, list[dict[str, str]]], + promoted_packet_ids: set[str], + skipped_by_packet_id: dict[str, dict[str, Any]], + review_status: str, +) -> None: + packet_rows_by_id = {row.get("packet_row_id", ""): row for row in output_rows} + lines = [ + "", + '', + "Limbu Recognizer Line-Text Review Packet", + ( + "" + ), + "", + "

Limbu Recognizer Line-Text Review Packet

", + ( + "

Recognizer text here is a suggestion, not reviewed truth. " + "When review_status is pending, the existing applicator will not apply the corrected_text value. " + "A reviewer must inspect the source crop and segment crops before marking a row corrected or accepted.

" + ), + f"

output review_status: {html.escape(review_status)}

", + ] + for packet_row_id, prefill_rows in sorted(grouped_prefill_rows.items()): + packet_row = packet_rows_by_id.get(packet_row_id, {}) + promoted = packet_row_id in promoted_packet_ids + skipped = skipped_by_packet_id.get(packet_row_id) + article_class = "accepted" if promoted else "skipped" + suggested_text = str(packet_row.get("corrected_text") or "") + lines.extend( + [ + f'
', + f"

{html.escape(packet_row_id)}

", + f"

page {html.escape(str(packet_row.get('book_page_id') or ''))} · line {html.escape(str(packet_row.get('book_line_id') or ''))}

", + f"

machine line text

{html.escape(str(packet_row.get('text') or ''))}
", + ] + ) + crop_path = Path(str(packet_row.get("crop_path") or "")) + if crop_path.is_file(): + lines.append(f"

source crop
\"source

") + overlay_path = Path(str(packet_row.get("split_suggestion_overlay_path") or "")) + if overlay_path.is_file(): + lines.append(f"

split overlay
\"split

") + if promoted: + lines.append("

suggested corrected_text

") + lines.append(f"
{html.escape(suggested_text)}
") + elif skipped: + lines.append(f"

not auto-suggested: {html.escape(str(skipped.get('reason') or 'skipped'))}

") + if "status_counts" in skipped: + lines.append(f"

segment status counts: {html.escape(json.dumps(skipped['status_counts'], ensure_ascii=False, sort_keys=True))}

") + lines.append("") + for prefill_row in prefill_rows: + status = str(prefill_row.get("candidate_segment_prefill_status") or "") + confidence = str(prefill_row.get("candidate_segment_confidence") or "") + status_class = "low" if status == "low_confidence" else "" + crop = Path(str(prefill_row.get("segment_crop_path") or "")) + crop_html = "" + if crop.is_file(): + crop_html = f"\"segment" + lines.extend( + [ + "", + f"", + f'', + f"", + f"", + f"", + "", + ] + ) + lines.extend(["
segmentcandidate statusconfidencecandidate textcrop
{html.escape(str(prefill_row.get('segment_index') or ''))}{html.escape(status)}{html.escape(confidence)}{html.escape(str(prefill_row.get('candidate_segment_text') or ''))}{crop_html}
", "
"]) + ungrouped_rows = [row for row in output_rows if str(row.get("packet_row_id") or "") not in grouped_prefill_rows] + if ungrouped_rows: + lines.extend( + [ + "

Other Pending Packet Rows

", + ( + "

These rows do not have recognizer split-segment suggestions in this packet, " + "but they are still part of the unresolved review TSV.

" + ), + ] + ) + for row in ungrouped_rows: + packet_row_id = str(row.get("packet_row_id") or "") + item_type = str(row.get("review_item_type") or "") + lines.extend( + [ + '
', + f"

{html.escape(packet_row_id)}

", + f"

type {html.escape(item_type)} · page {html.escape(str(row.get('book_page_id') or ''))}

", + f"

suggested action {html.escape(str(row.get('suggested_review_action') or ''))}

", + f"

review reasons {html.escape(str(row.get('review_reasons') or ''))}

", + f"

machine/candidate text

{html.escape(str(row.get('text') or ''))}
", + ] + ) + suggested = str(row.get("corrected_text") or "").strip() + if suggested: + lines.append(f"

suggested corrected_text

{html.escape(suggested)}
") + crop_path = Path(str(row.get("crop_path") or "")) + if crop_path.is_file(): + lines.append(f"

crop
\"crop

") + lines.append("
") + lines.append("") + path.write_text("\n".join(lines) + "\n", encoding="utf-8") + + +def promote_line_text(args: argparse.Namespace) -> dict[str, Any]: + prefill_report_path = Path(args.prefill_report) + low_confidence_threshold = getattr(args, "allow_low_confidence_above", None) + if low_confidence_threshold is not None: + low_confidence_threshold = float(low_confidence_threshold) + if low_confidence_threshold < 0.0 or low_confidence_threshold > 1.0: + raise ValueError("--allow-low-confidence-above must be between 0 and 1") + report = _read_json_object(prefill_report_path, label="recognizer prefill report") + if report.get("tool") != "tools/prefill_limbu_book_split_transcription_worksheet.py": + raise ValueError(f"unexpected prefill report tool: {report.get('tool')!r}") + augmented_tsv = Path(str(report.get("augmented_tsv") or "")) + _verify_sha(augmented_tsv, report.get("augmented_tsv_sha256"), label="augmented worksheet TSV") + prefilled_packet = Path(args.prefilled_packet) if args.prefilled_packet else Path(str(report.get("prefilled_packet") or "")) + expected_packet_sha = args.prefilled_packet_sha256 or report.get("prefilled_packet_sha256") + _verify_sha(prefilled_packet, expected_packet_sha, label="prefilled packet TSV") + prefill_rows, _prefill_fields = _read_tsv(augmented_tsv, label="augmented worksheet TSV") + packet_rows, packet_fields = _read_tsv(prefilled_packet, label="prefilled packet TSV") + required_packet = {"packet_row_id", "review_item_type", "review_status", "corrected_text", "split_corrected_texts", "split_bboxes", "notes"} + missing = sorted(required_packet - set(packet_fields)) + if missing: + raise ValueError(f"prefilled packet TSV missing columns {missing}: {prefilled_packet}") + grouped = _group_rows(prefill_rows) + output_rows = [dict(row) for row in packet_rows] + packet_by_id = {row.get("packet_row_id", ""): row for row in output_rows} + if len(packet_by_id) != len(output_rows): + raise ValueError("prefilled packet contains duplicate packet_row_id values") + promoted_packet_ids: list[str] = [] + allowed_low_confidence_segments: list[dict[str, Any]] = [] + candidate_missing_suggestion_ids: list[str] = [] + skipped: list[dict[str, Any]] = [] + skipped_by_packet_id: dict[str, dict[str, Any]] = {} + for packet_row_id, rows in sorted(grouped.items()): + packet_row = packet_by_id.get(packet_row_id) + if packet_row is None: + raise ValueError(f"recognizer prefill references unknown packet_row_id {packet_row_id!r}") + status_counts = Counter(row.get("candidate_segment_prefill_status") or "blank" for row in rows) + if packet_row.get("review_item_type") != "existing_book_line": + skipped_record = {"packet_row_id": packet_row_id, "reason": "not_existing_book_line"} + skipped.append(skipped_record) + skipped_by_packet_id[packet_row_id] = skipped_record + continue + if not _complete_group(rows, low_confidence_threshold): + skipped_record = { + "packet_row_id": packet_row_id, + "reason": "incomplete_or_low_confidence_group", + "status_counts": dict(sorted(status_counts.items())), + } + skipped.append(skipped_record) + skipped_by_packet_id[packet_row_id] = skipped_record + continue + corrected = _line_text(rows, str(args.joiner), low_confidence_threshold) + if not corrected: + skipped_record = { + "packet_row_id": packet_row_id, + "reason": "empty_joined_line_text", + "status_counts": dict(sorted(status_counts.items())), + } + skipped.append(skipped_record) + skipped_by_packet_id[packet_row_id] = skipped_record + continue + packet_row["review_status"] = str(args.review_status) + packet_row["corrected_text"] = corrected + packet_row["split_corrected_texts"] = "" + packet_row["split_bboxes"] = "" + packet_row["reviewer"] = str(args.reviewer) + packet_row["notes"] = _append_note(packet_row.get("notes", ""), "diagnostic_recognizer_prefill_line_text_no_split") + for row in rows: + if _effective_status(row, low_confidence_threshold) == "allowed_low_confidence": + allowed_low_confidence_segments.append( + { + "packet_row_id": packet_row_id, + "worksheet_row_id": row.get("worksheet_row_id"), + "segment_index": row.get("segment_index"), + "candidate_segment_confidence": row.get("candidate_segment_confidence"), + "candidate_segment_text": row.get("candidate_segment_text"), + } + ) + promoted_packet_ids.append(packet_row_id) + if bool(getattr(args, "suggest_candidate_missing_text", False)): + for packet_row in output_rows: + if str(packet_row.get("review_item_type") or "") != "candidate_missing_line": + continue + if str(packet_row.get("review_status") or "").strip().lower() != "pending": + continue + if str(packet_row.get("corrected_text") or "").strip(): + continue + suggestion = normalize_ocr_text(str(packet_row.get("text") or "")).strip() + if not suggestion: + continue + packet_row["corrected_text"] = suggestion + packet_row["notes"] = _append_note(packet_row.get("notes", ""), "candidate_missing_line_machine_text_review_suggestion") + candidate_missing_suggestion_ids.append(str(packet_row.get("packet_row_id") or "")) + + out = Path(args.out) + out.mkdir(parents=True, exist_ok=True) + output_tsv = out / OUTPUT_TSV + _write_tsv(output_tsv, output_rows, packet_fields) + output_html = out / OUTPUT_HTML + _write_html( + output_html, + out=out, + output_rows=output_rows, + grouped_prefill_rows=grouped, + promoted_packet_ids=set(promoted_packet_ids), + skipped_by_packet_id=skipped_by_packet_id, + review_status=str(args.review_status), + ) + status_counts = Counter((row.get("review_status") or "blank") for row in output_rows) + accepted_statuses = {"accept", "accepted", "approved", "corrected", "verified", "done"} + review_status = str(args.review_status).strip().lower() + report_out = { + "tool": "tools/promote_limbu_book_split_prefill_as_line_text.py", + "created_at_utc": datetime.now(UTC).isoformat(), + "prefill_report": str(prefill_report_path), + "prefill_report_sha256": sha256_file(prefill_report_path), + "source_augmented_tsv": str(augmented_tsv), + "source_augmented_tsv_sha256": sha256_file(augmented_tsv), + "prefilled_packet": str(prefilled_packet), + "prefilled_packet_sha256": sha256_file(prefilled_packet), + "out": str(out), + "output_tsv": str(output_tsv), + "output_tsv_sha256": sha256_file(output_tsv), + "output_html": str(output_html), + "output_html_sha256": sha256_file(output_html), + "joiner": str(args.joiner), + "review_status": str(args.review_status), + "reviewer": str(args.reviewer), + "allow_low_confidence_above": low_confidence_threshold, + "allowed_low_confidence_segment_count": len(allowed_low_confidence_segments), + "allowed_low_confidence_segments": allowed_low_confidence_segments, + "suggest_candidate_missing_text": bool(getattr(args, "suggest_candidate_missing_text", False)), + "candidate_missing_suggestion_count": len(candidate_missing_suggestion_ids), + "candidate_missing_suggestion_packet_row_ids": candidate_missing_suggestion_ids, + "review_mode": "auto_apply_diagnostic" if review_status in accepted_statuses else "manual_review_pending", + "source_packet_row_count": len(grouped), + "promoted_packet_row_count": len(promoted_packet_ids), + "promoted_packet_row_ids": promoted_packet_ids, + "skipped": skipped, + "status_counts": dict(sorted(status_counts.items())), + "boundary": ( + "Diagnostic automatic recognizer-prefill line-text correction only; not human review. " + "When review_status is pending this is a reviewer suggestion packet and the applicator will not apply corrected_text. " + "It preserves existing line boxes and clears split fields, and must pass strict frozen-page score/admission before operational use." + ), + } + report_path = out / REPORT_JSON + report_out["report_json"] = str(report_path) + report_path.write_text(json.dumps(report_out, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + return report_out + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--prefill-report", type=Path, required=True) + parser.add_argument("--prefilled-packet", type=Path) + parser.add_argument("--prefilled-packet-sha256") + parser.add_argument("--out", type=Path, required=True) + parser.add_argument("--joiner", default=" ") + parser.add_argument("--review-status", default="corrected") + parser.add_argument("--reviewer", default="diagnostic-recognizer-prefill-line-text-v1") + parser.add_argument("--allow-low-confidence-above", type=float) + parser.add_argument("--suggest-candidate-missing-text", action="store_true") + args = parser.parse_args(argv) + report = promote_line_text(args) + print(report["report_json"]) + print(report["output_tsv"]) + print(f"promoted_rows={report['promoted_packet_row_count']}") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ocr-tech-mps-integration/tools/promote_limbu_book_split_transcription_prefill.py b/ocr-tech-mps-integration/tools/promote_limbu_book_split_transcription_prefill.py new file mode 100644 index 0000000000000000000000000000000000000000..2b4d229fed60bcb4ad8812e2cc5a71d0fb3a07aa --- /dev/null +++ b/ocr-tech-mps-integration/tools/promote_limbu_book_split_transcription_prefill.py @@ -0,0 +1,188 @@ +#!/usr/bin/env python3 +"""Create a diagnostic auto-promoted worksheet from recognizer-prefilled segments.""" + +from __future__ import annotations + +import argparse +import csv +import json +from collections import Counter, defaultdict +from datetime import UTC, datetime +from pathlib import Path +from typing import Any + +from ocrtech.manifest import sha256_file + + +OUTPUT_TSV = "book-line-split-transcription-worksheet-auto-promoted.tsv" +REPORT_JSON = "book-line-split-transcription-worksheet-auto-promotion.json" +COMPLETE_GROUP_STATUSES = {"suggested", "empty_prediction"} + + +def _read_json_object(path: Path, *, label: str) -> dict[str, Any]: + try: + payload = json.loads(path.read_text(encoding="utf-8")) + except FileNotFoundError as exc: + raise ValueError(f"{label} is missing: {path}") from exc + except json.JSONDecodeError as exc: + raise ValueError(f"{label} is invalid JSON: {path}: {exc}") from exc + if not isinstance(payload, dict): + raise ValueError(f"{label} must contain a JSON object: {path}") + return payload + + +def _read_tsv(path: Path, *, label: str) -> tuple[list[dict[str, str]], list[str]]: + try: + handle = path.open("r", encoding="utf-8", newline="") + except FileNotFoundError as exc: + raise ValueError(f"{label} is missing: {path}") from exc + with handle: + reader = csv.DictReader(handle, delimiter="\t") + if reader.fieldnames is None: + raise ValueError(f"{label} has no header: {path}") + return [dict(row) for row in reader], list(reader.fieldnames) + + +def _verify_sha(path: Path, expected: object, *, label: str) -> str: + if not path.is_file(): + raise ValueError(f"{label} is missing: {path}") + actual = sha256_file(path) + if not isinstance(expected, str) or not expected: + raise ValueError(f"{label} missing recorded SHA-256") + if actual != expected: + raise ValueError(f"{label} SHA-256 mismatch: recorded={expected} actual={actual} path={path}") + return actual + + +def _write_tsv(path: Path, rows: list[dict[str, str]], fields: list[str]) -> None: + with path.open("w", encoding="utf-8", newline="") as handle: + writer = csv.DictWriter(handle, fieldnames=fields, delimiter="\t", lineterminator="\n") + writer.writeheader() + writer.writerows(rows) + + +def _group_rows(rows: list[dict[str, str]]) -> dict[str, list[dict[str, str]]]: + grouped: dict[str, list[dict[str, str]]] = defaultdict(list) + for row in rows: + grouped[row.get("packet_row_id", "")].append(row) + for packet_row_id, packet_rows in grouped.items(): + if not packet_row_id: + raise ValueError("worksheet contains row with empty packet_row_id") + packet_rows.sort(key=lambda item: int(str(item.get("segment_index") or "0"))) + return grouped + + +def _complete_group(rows: list[dict[str, str]]) -> bool: + statuses = {str(row.get("candidate_segment_prefill_status") or "") for row in rows} + suggested = sum(1 for row in rows if row.get("candidate_segment_prefill_status") == "suggested") + return statuses <= COMPLETE_GROUP_STATUSES and suggested >= 2 + + +def promote_prefill(args: argparse.Namespace) -> dict[str, Any]: + prefill_report_path = Path(args.prefill_report) + report = _read_json_object(prefill_report_path, label="recognizer prefill report") + if report.get("tool") != "tools/prefill_limbu_book_split_transcription_worksheet.py": + raise ValueError(f"unexpected prefill report tool: {report.get('tool')!r}") + if "does not edit segment_text" not in str(report.get("boundary") or ""): + raise ValueError("prefill report does not state review-gated boundary") + augmented_tsv = Path(str(report.get("augmented_tsv") or "")) + _verify_sha(augmented_tsv, report.get("augmented_tsv_sha256"), label="augmented worksheet TSV") + rows, fields = _read_tsv(augmented_tsv, label="augmented worksheet TSV") + required = { + "worksheet_row_id", + "packet_row_id", + "segment_status", + "segment_text", + "candidate_segment_text", + "candidate_segment_confidence", + "candidate_segment_prefill_status", + } + missing = sorted(required - set(fields)) + if missing: + raise ValueError(f"augmented worksheet TSV missing columns {missing}: {augmented_tsv}") + if int(report.get("row_count") or -1) != len(rows): + raise ValueError(f"prefill row_count mismatch: recorded={report.get('row_count')} actual={len(rows)}") + + out = Path(args.out) + out.mkdir(parents=True, exist_ok=True) + grouped = _group_rows(rows) + output_rows = [dict(row) for row in rows] + output_by_id = {row["worksheet_row_id"]: row for row in output_rows} + promoted_packet_ids: list[str] = [] + skipped: list[dict[str, Any]] = [] + promoted_segment_count = 0 + dropped_empty_segment_count = 0 + for packet_row_id, packet_rows in sorted(grouped.items()): + status_counts = Counter(row.get("candidate_segment_prefill_status") or "blank" for row in packet_rows) + if not _complete_group(packet_rows): + skipped.append({"packet_row_id": packet_row_id, "reason": "incomplete_or_low_confidence_group", "status_counts": dict(sorted(status_counts.items()))}) + continue + promoted_packet_ids.append(packet_row_id) + for source_row in packet_rows: + row = output_by_id[source_row["worksheet_row_id"]] + status = source_row.get("candidate_segment_prefill_status") + if status == "empty_prediction": + row["segment_status"] = "non_text" + row["segment_text"] = "" + row["notes"] = _append_note(row.get("notes", ""), "diagnostic_auto_promote_empty_prediction_as_non_text") + dropped_empty_segment_count += 1 + continue + row["segment_status"] = str(args.segment_status) + row["segment_text"] = source_row.get("candidate_segment_text", "") + row["notes"] = _append_note(row.get("notes", ""), "diagnostic_auto_promoted_from_recognizer_prefill") + promoted_segment_count += 1 + + output_tsv = out / OUTPUT_TSV + _write_tsv(output_tsv, output_rows, fields) + status_counts = Counter(row.get("segment_status") or "blank" for row in output_rows) + report_out = { + "tool": "tools/promote_limbu_book_split_transcription_prefill.py", + "created_at_utc": datetime.now(UTC).isoformat(), + "prefill_report": str(prefill_report_path), + "prefill_report_sha256": sha256_file(prefill_report_path), + "prefilled_packet": report.get("prefilled_packet"), + "prefilled_packet_sha256": report.get("prefilled_packet_sha256"), + "source_augmented_tsv": str(augmented_tsv), + "source_augmented_tsv_sha256": sha256_file(augmented_tsv), + "out": str(out), + "worksheet_tsv": str(output_tsv), + "worksheet_tsv_sha256": sha256_file(output_tsv), + "worksheet_segment_row_count": len(output_rows), + "source_packet_row_count": len(grouped), + "promoted_packet_row_count": len(promoted_packet_ids), + "promoted_packet_row_ids": promoted_packet_ids, + "promoted_segment_count": promoted_segment_count, + "dropped_empty_segment_count": dropped_empty_segment_count, + "skipped": skipped, + "status_counts": dict(sorted(status_counts.items())), + "boundary": ( + "Diagnostic automatic recognizer-prefill promotion only; not human review. " + "Must pass application audit and strict frozen-page score/admission before any operational use." + ), + } + report_path = out / REPORT_JSON + report_out["report_json"] = str(report_path) + report_path.write_text(json.dumps(report_out, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + return report_out + + +def _append_note(existing: str, note: str) -> str: + existing = str(existing or "").strip() + return f"{existing}; {note}" if existing else note + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--prefill-report", type=Path, required=True) + parser.add_argument("--out", type=Path, required=True) + parser.add_argument("--segment-status", default="text") + args = parser.parse_args(argv) + report = promote_prefill(args) + print(report["report_json"]) + print(report["worksheet_tsv"]) + print(f"promoted_groups={report['promoted_packet_row_count']} promoted_segments={report['promoted_segment_count']}") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ocr-tech-mps-integration/tools/render_kiratrai_real_lines.py b/ocr-tech-mps-integration/tools/render_kiratrai_real_lines.py new file mode 100644 index 0000000000000000000000000000000000000000..10130003da25c76d801fb6901f74a08edc5fb535 --- /dev/null +++ b/ocr-tech-mps-integration/tools/render_kiratrai_real_lines.py @@ -0,0 +1,176 @@ +#!/usr/bin/env python3 +"""Render the REAL Kirat Rai Sikkim Herald lines into a PaddleOCR train corpus. + +This is the PRIMARY recognizer corpus: real Kirat Rai language text (the clean +lines extracted from the Sikkim Herald PDFs, legacy->Unicode converted) rendered +in the Kanchenjunga font across all four weights and the five degradation +profiles used by ``tools/synthesize_script_corpus.py`` via the same HarfBuzz/raqm +shaping path (mandatory for correct glyph placement). + +Unlike random-syllable synthesis, every label here is a real printed Kirat Rai +line, so the recognizer learns real-language n-gram statistics — the Limbu +playbook (real prose render -> real-page CER) that beat random synth. + +A deliberate train/eval FONT GAP remains: training renders Kanchenjunga; the real +eval crops (``data/kiratrai-real-eval-pack/``) are the legacy ``kiratraifont`` +print. That gap makes the real-page CER conservative (same caveat as Limbu/ +Devanagari) — it is intentional and honest, not a leak. +""" + +from __future__ import annotations + +import argparse +import json +import random +import sys +import unicodedata +from pathlib import Path + +# Reuse the validated rendering + shaping path from the generic synthesizer so +# real-line renders are byte-for-byte consistent with the synthetic augmentation. +sys.path.insert(0, str(Path(__file__).resolve().parent)) +from synthesize_script_corpus import ( # noqa: E402 + DEGRADATIONS, + build_checkers, + load_fonts, + render_line, +) + +KR_LO, KR_HI = 0x16D40, 0x16D79 +MIN_KR_CHARS = 6 + +KANCHENJUNGA_DIR = Path("data/fonts/himalayan-scripts/Kanchenjunga-2.001") +FONT_WEIGHTS = [ + "Kanchenjunga-Regular.ttf", + "Kanchenjunga-Medium.ttf", + "Kanchenjunga-SemiBold.ttf", + "Kanchenjunga-Bold.ttf", +] +# The five degradation profiles documented in the synthesizer (clean/scan/ +# low_light/bright_uneven/rotate). DEGRADATIONS weights "clean" twice; collapse +# to the distinct set so every line gets each profile exactly once per weight. +PROFILES = sorted(set(DEGRADATIONS)) + + +def kr_char_count(text: str) -> int: + return sum(1 for ch in text if KR_LO <= ord(ch) <= KR_HI) + + +def is_clean(text: str) -> bool: + return all(KR_LO <= ord(ch) <= KR_HI or ch == " " for ch in text) and ( + kr_char_count(text) >= MIN_KR_CHARS + ) + + +def load_clean_unique_texts(lines_json: Path) -> list[str]: + data = json.loads(lines_json.read_text(encoding="utf-8")) + seen: set[str] = set() + ordered: list[str] = [] + for entry in data["lines"]: + gt = unicodedata.normalize("NFC", entry["unicode_text"]) + if not is_clean(gt): + continue + if gt in seen: + continue + seen.add(gt) + ordered.append(gt) + return ordered + + +def main(argv: list[str] | None = None) -> int: + p = argparse.ArgumentParser(description=__doc__) + p.add_argument( + "--lines-json", + type=Path, + default=Path("data/real-text/sikkim-herald/kiratrai.lines.json"), + ) + p.add_argument("--out", type=Path, default=Path("data/kiratrai-train/real-renders")) + p.add_argument("--font-size", type=int, default=38) + p.add_argument( + "--renders-per-combo", + type=int, + default=5, + help="distinct degradation draws per (text, weight, profile)", + ) + p.add_argument("--seed", type=int, default=23) + args = p.parse_args(argv) + + texts = load_clean_unique_texts(args.lines_json) + if not texts: + raise SystemExit("no clean real lines found — aborting") + + font_paths = [KANCHENJUNGA_DIR / name for name in FONT_WEIGHTS] + fonts = load_fonts(font_paths, args.font_size) # raqm layout engine + checkers = build_checkers(font_paths) # uharfbuzz dotted-circle guard + + images_dir = args.out / "images" + images_dir.mkdir(parents=True, exist_ok=True) + + rng = random.Random(args.seed) + + # Drop any text that fails to shape cleanly in ANY weight (would emit a + # dotted-circle glyph absent from the label, corrupting the pair). + renderable: list[str] = [] + dropped_shaping = 0 + for text in texts: + if checkers and not all(c.is_clean(text) for c in checkers): + dropped_shaping += 1 + continue + renderable.append(text) + + label_path = args.out / "labels.txt" + count = 0 + per_profile: dict[str, int] = {prof: 0 for prof in PROFILES} + per_weight: dict[str, int] = {name: 0 for name in FONT_WEIGHTS} + failures = 0 + with label_path.open("w", encoding="utf-8") as lf: + for text in renderable: + for weight_idx, (font, weight_name) in enumerate(zip(fonts, FONT_WEIGHTS)): + for profile in PROFILES: + for draw in range(args.renders_per_combo): + try: + img = render_line(text, font, profile, rng) + except Exception as exc: # one bad render must not kill the run + failures += 1 + print( + f" WARN render failed (weight={weight_name} " + f"profile={profile}): {exc}", + file=sys.stderr, + ) + continue + name = f"kiratrai_real_{count:06d}.png" + img.save(images_dir / name) + lf.write(f"images/{name}\t{text}\n") + count += 1 + per_profile[profile] += 1 + per_weight[weight_name] += 1 + + summary = { + "corpus": "kiratrai-real-line-renders", + "lines_json": str(args.lines_json), + "unique_clean_texts": len(texts), + "dropped_by_shaping": dropped_shaping, + "rendered_texts": len(renderable), + "fonts": [str(fp) for fp in font_paths], + "font_weights": FONT_WEIGHTS, + "profiles": PROFILES, + "renders_per_combo": args.renders_per_combo, + "font_size": args.font_size, + "seed": args.seed, + "total_images": count, + "render_failures": failures, + "per_profile": per_profile, + "per_weight": per_weight, + "shaping_validated": bool(checkers), + "label_path": str(label_path), + "images_dir": str(images_dir), + } + (args.out / "summary.json").write_text( + json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8" + ) + print(json.dumps(summary, ensure_ascii=False, indent=2)) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/ocr-tech-mps-integration/tools/run_eval_output_command.py b/ocr-tech-mps-integration/tools/run_eval_output_command.py new file mode 100644 index 0000000000000000000000000000000000000000..1e6ebff8cb6a8a8ce95cda7c44332eaf62ef84bd --- /dev/null +++ b/ocr-tech-mps-integration/tools/run_eval_output_command.py @@ -0,0 +1,372 @@ +#!/usr/bin/env python3 +"""Materialize canonical eval outputs with a recorded external command.""" + +from __future__ import annotations + +import argparse +import json +import platform +import shlex +import subprocess +import sys +import traceback +from dataclasses import dataclass +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +from ocrtech.manifest import ManifestEntry, load_manifest, sha256_file + + +@dataclass(frozen=True) +class CommandRecord: + sample_id: str + command: list[str] + stdout_path: str + stdout_sha256: str + stderr_path: str + stderr_sha256: str + returncode: int + output_path: str + output_sha256: str | None + output_size_bytes: int | None + input_path: str | None = None + input_sha256: str | None = None + + def to_dict(self) -> dict[str, Any]: + payload = { + "sample_id": self.sample_id, + "command": self.command, + "stdout_path": self.stdout_path, + "stdout_sha256": self.stdout_sha256, + "stderr_path": self.stderr_path, + "stderr_sha256": self.stderr_sha256, + "returncode": self.returncode, + "output_path": self.output_path, + "output_sha256": self.output_sha256, + "output_size_bytes": self.output_size_bytes, + } + if self.input_path is not None or self.input_sha256 is not None: + payload["input_path"] = self.input_path + payload["input_sha256"] = self.input_sha256 + return payload + + +def _resolve_manifest_path(path_value: str, manifest_dir: Path) -> Path: + path = Path(path_value) + if path.is_absolute() or path.exists(): + return path + candidate = manifest_dir / path + if candidate.exists(): + return candidate + return path + + +def _render_command(template: str, values: dict[str, str]) -> list[str]: + try: + rendered = template.format(**values) + except KeyError as exc: + raise ValueError(f"unknown command placeholder: {exc}") from exc + command = shlex.split(rendered) + if not command: + raise ValueError("rendered command is empty") + return command + + +def _default_command(args: argparse.Namespace) -> str: + if args.command: + return args.command + if args.mode == "recognizer" and args.model_config: + summary_path = args.out / "recognizer-predictions.summary.json" + return ( + f"{shlex.quote(sys.executable)} tools/predict_recognizer_eval.py " + "--label-file {label_file} --data-dir {data_dir} " + f"--model-config {shlex.quote(str(args.model_config))} " + "--out {prediction_file} " + f"--summary-file {shlex.quote(str(summary_path))}" + ) + if args.mode == "page" and args.model_config: + return ( + f"{shlex.quote(sys.executable)} -m ocrtech.cli parse-doc " + "{input_path} --out {output_dir} --engine candidate " + f"--model-config {shlex.quote(str(args.model_config))}" + ) + raise ValueError("--command is required unless --model-config is provided for a supported mode") + + +def _output_metadata(path: Path) -> tuple[str | None, int | None]: + if not path.exists(): + return None, None + if not path.is_file(): + raise ValueError(f"expected output path to be a file: {path}") + return sha256_file(path), path.stat().st_size + + +def _existing_file_sha256(path: Path | None) -> str | None: + if path is None or not path.exists(): + return None + if not path.is_file(): + raise ValueError(f"expected provenance path to be a file: {path}") + return sha256_file(path) + + +def _run_command(command: list[str], stdout_path: Path, stderr_path: Path, timeout_seconds: int | None) -> int: + stdout_path.parent.mkdir(parents=True, exist_ok=True) + stderr_path.parent.mkdir(parents=True, exist_ok=True) + try: + completed = subprocess.run( + command, + check=False, + capture_output=True, + text=True, + timeout=timeout_seconds, + ) + except subprocess.TimeoutExpired as exc: + stdout_path.write_text(exc.stdout or "", encoding="utf-8") + stderr_path.write_text((exc.stderr or "") + f"\nTimeoutExpired: command exceeded {timeout_seconds}s\n", encoding="utf-8") + return 124 + stdout_path.write_text(completed.stdout, encoding="utf-8") + stderr_path.write_text(completed.stderr, encoding="utf-8") + return completed.returncode + + +def _materialize_recognizer(args: argparse.Namespace, out: Path) -> list[CommandRecord]: + prediction_file = args.prediction_file + prediction_file.parent.mkdir(parents=True, exist_ok=True) + command = _render_command( + args.command, + { + "label_file": str(args.label_file), + "data_dir": str(args.data_dir), + "prediction_file": str(prediction_file), + "out_dir": str(out), + }, + ) + stdout_path = out / "logs" / "recognizer.stdout.txt" + stderr_path = out / "logs" / "recognizer.stderr.txt" + returncode = _run_command(command, stdout_path, stderr_path, args.timeout_seconds) + output_sha256, output_size = _output_metadata(prediction_file) + if returncode != 0: + raise RuntimeError(f"recognizer output command failed with return code {returncode}; stderr: {stderr_path}") + if output_sha256 is None: + raise FileNotFoundError(f"recognizer command did not write prediction file: {prediction_file}") + return [ + CommandRecord( + sample_id="__recognizer_eval__", + command=command, + stdout_path=str(stdout_path), + stdout_sha256=sha256_file(stdout_path), + stderr_path=str(stderr_path), + stderr_sha256=sha256_file(stderr_path), + returncode=returncode, + output_path=str(prediction_file), + output_sha256=output_sha256, + output_size_bytes=output_size, + ) + ] + + +def _materialize_page(args: argparse.Namespace, out: Path) -> list[CommandRecord]: + entries = load_manifest(args.eval_manifest) + if not entries: + raise ValueError(f"eval manifest contains no rows: {args.eval_manifest}") + args.documents_dir.mkdir(parents=True, exist_ok=True) + records: list[CommandRecord] = [] + manifest_dir = args.eval_manifest.parent + for entry in entries: + input_path = _resolve_manifest_path(entry.image_path, manifest_dir) + if not input_path.exists(): + raise FileNotFoundError(f"eval manifest input is missing for {entry.sample_id}: {input_path}") + sample_output_dir = args.documents_dir / entry.sample_id + sample_output_dir.mkdir(parents=True, exist_ok=True) + document_json = sample_output_dir / "document.json" + command = _render_command( + args.command, + { + "input_path": str(input_path), + "sample_id": entry.sample_id, + "output_dir": str(sample_output_dir), + "document_json": str(document_json), + "documents_dir": str(args.documents_dir), + "out_dir": str(out), + }, + ) + stdout_path = out / "logs" / f"{entry.sample_id}.stdout.txt" + stderr_path = out / "logs" / f"{entry.sample_id}.stderr.txt" + returncode = _run_command(command, stdout_path, stderr_path, args.timeout_seconds) + output_sha256, output_size = _output_metadata(document_json) + if returncode != 0: + raise RuntimeError(f"page output command failed for {entry.sample_id} with return code {returncode}; stderr: {stderr_path}") + if output_sha256 is None: + raise FileNotFoundError(f"page command did not write document JSON for {entry.sample_id}: {document_json}") + records.append( + CommandRecord( + sample_id=entry.sample_id, + command=command, + stdout_path=str(stdout_path), + stdout_sha256=sha256_file(stdout_path), + stderr_path=str(stderr_path), + stderr_sha256=sha256_file(stderr_path), + returncode=returncode, + output_path=str(document_json), + output_sha256=output_sha256, + output_size_bytes=output_size, + input_path=str(input_path), + input_sha256=sha256_file(input_path), + ) + ) + return records + + +def _write_summary(out: Path, args: argparse.Namespace, records: list[CommandRecord]) -> dict[str, Any]: + payload = { + "created_at": datetime.now(timezone.utc).isoformat(), + "mode": args.mode, + "system_name": args.system_name, + "model_name": args.model_name, + "model_config": str(args.model_config) if args.model_config else None, + "checkpoint": args.checkpoint, + "config": args.config, + "dictionary": args.dictionary, + "command_template": args.command, + "timeout_seconds": args.timeout_seconds, + "record_count": len(records), + "records": [record.to_dict() for record in records], + "machine": {"platform": platform.platform(), "python": sys.version}, + "invocation": " ".join(sys.argv), + } + if args.mode == "recognizer": + payload.update( + { + "label_file": str(args.label_file), + "label_file_sha256": sha256_file(args.label_file), + "data_dir": str(args.data_dir), + "prediction_file": str(args.prediction_file), + } + ) + else: + payload.update( + { + "eval_manifest": str(args.eval_manifest), + "eval_manifest_sha256": sha256_file(args.eval_manifest), + "documents_dir": str(args.documents_dir), + } + ) + (out / "output-command-run.json").write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + lines = [ + "# Eval Output Command Run", + "", + f"- mode: {args.mode}", + f"- system: {args.system_name}", + f"- model: {args.model_name}", + f"- checkpoint: {args.checkpoint}", + f"- records: {len(records)}", + "", + "## Outputs", + "", + ] + for record in records: + if record.input_path: + lines.append( + f"- {record.sample_id}: input `{record.input_path}` sha256={record.input_sha256}; " + f"output `{record.output_path}` sha256={record.output_sha256}; " + f"stdout `{record.stdout_path}` sha256={record.stdout_sha256}; " + f"stderr `{record.stderr_path}` sha256={record.stderr_sha256}" + ) + else: + lines.append( + f"- {record.sample_id}: `{record.output_path}` sha256={record.output_sha256}; " + f"stdout `{record.stdout_path}` sha256={record.stdout_sha256}; " + f"stderr `{record.stderr_path}` sha256={record.stderr_sha256}" + ) + (out / "output-command-run.md").write_text("\n".join(lines) + "\n", encoding="utf-8") + (out / "command-template.txt").write_text(args.command + "\n", encoding="utf-8") + return payload + + +def run_materialization(args: argparse.Namespace) -> dict[str, Any]: + out = args.out + if out.exists() and any(out.iterdir()) and not args.force: + raise FileExistsError(f"output directory exists and is not empty: {out}") + out.mkdir(parents=True, exist_ok=True) + try: + if args.mode == "recognizer": + records = _materialize_recognizer(args, out) + elif args.mode == "page": + records = _materialize_page(args, out) + else: + raise ValueError(f"unsupported mode: {args.mode}") + return _write_summary(out, args, records) + except Exception as exc: + payload = { + "created_at": datetime.now(timezone.utc).isoformat(), + "mode": args.mode, + "system_name": args.system_name, + "model_name": args.model_name, + "checkpoint": args.checkpoint, + "config": args.config, + "dictionary": args.dictionary, + "command_template": args.command, + "timeout_seconds": args.timeout_seconds, + "machine": {"platform": platform.platform(), "python": sys.version}, + "invocation": " ".join(sys.argv), + "error_type": type(exc).__name__, + "error": str(exc), + "traceback": traceback.format_exc(), + } + if args.mode == "recognizer": + payload.update( + { + "label_file": str(args.label_file) if args.label_file else None, + "label_file_sha256": _existing_file_sha256(args.label_file), + "data_dir": str(args.data_dir) if args.data_dir else None, + "prediction_file": str(args.prediction_file) if args.prediction_file else None, + } + ) + elif args.mode == "page": + payload.update( + { + "eval_manifest": str(args.eval_manifest) if args.eval_manifest else None, + "eval_manifest_sha256": _existing_file_sha256(args.eval_manifest), + "documents_dir": str(args.documents_dir) if args.documents_dir else None, + } + ) + (out / "output-command-run-error.json").write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + raise + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--mode", choices=["recognizer", "page"], required=True) + parser.add_argument("--command", help="Command template. Recognizer placeholders: {label_file}, {data_dir}, {prediction_file}, {out_dir}. Page placeholders: {input_path}, {sample_id}, {output_dir}, {document_json}, {documents_dir}, {out_dir}.") + parser.add_argument("--model-config", type=Path, help="candidate model card; supplies the default command template when --command is omitted") + parser.add_argument("--out", type=Path, required=True) + parser.add_argument("--system-name", required=True) + parser.add_argument("--model-name", default="") + parser.add_argument("--checkpoint", default="") + parser.add_argument("--config", default="") + parser.add_argument("--dictionary", default="") + parser.add_argument("--timeout-seconds", type=int) + parser.add_argument("--force", action="store_true") + parser.add_argument("--label-file", type=Path) + parser.add_argument("--data-dir", type=Path) + parser.add_argument("--prediction-file", type=Path) + parser.add_argument("--eval-manifest", type=Path) + parser.add_argument("--documents-dir", type=Path) + args = parser.parse_args(argv) + args.command = _default_command(args) + if args.mode == "recognizer": + missing = [name for name in ("label_file", "data_dir", "prediction_file") if getattr(args, name) is None] + if missing: + parser.error("--mode recognizer requires " + ", ".join(f"--{name.replace('_', '-')}" for name in missing)) + if args.mode == "page": + missing = [name for name in ("eval_manifest", "documents_dir") if getattr(args, name) is None] + if missing: + parser.error("--mode page requires " + ", ".join(f"--{name.replace('_', '-')}" for name in missing)) + summary = run_materialization(args) + print(f"wrote {args.out} mode={summary['mode']} records={summary['record_count']}") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ocr-tech-mps-integration/tools/run_eval_recipe.py b/ocr-tech-mps-integration/tools/run_eval_recipe.py new file mode 100644 index 0000000000000000000000000000000000000000..d3324f0b95a59fec87c03bfeabeb49a3b9d26454 --- /dev/null +++ b/ocr-tech-mps-integration/tools/run_eval_recipe.py @@ -0,0 +1,828 @@ +#!/usr/bin/env python3 +"""Run a recognizer eval recipe into one auditable output directory.""" + +from __future__ import annotations + +import argparse +import importlib.util +import json +import platform +import shlex +import subprocess +import sys +import traceback +from argparse import Namespace +from datetime import datetime, timezone +from pathlib import Path +from types import ModuleType +from typing import Any + +from ocrtech.manifest import sha256_file + + +TOOLS_DIR = Path(__file__).resolve().parent +RECOGNIZER_TASK = "recognizer_oracle_crop" +PAGE_TASK = "page_level_ocr" + + +def _load_tool(name: str) -> ModuleType: + path = TOOLS_DIR / f"{name}.py" + spec = importlib.util.spec_from_file_location(name, path) + if spec is None or spec.loader is None: + raise RuntimeError(f"could not load tool module: {path}") + module = importlib.util.module_from_spec(spec) + sys.modules[spec.name] = module + spec.loader.exec_module(module) + return module + + +def _read_recipe_file(path: Path) -> dict[str, Any]: + if not path.exists(): + raise FileNotFoundError(f"recipe file does not exist: {path}") + try: + payload = json.loads(path.read_text(encoding="utf-8")) + except json.JSONDecodeError as exc: + raise ValueError(f"recipe file is invalid JSON: {path}: {exc}") from exc + if not isinstance(payload, dict): + raise ValueError(f"recipe file must contain a JSON object: {path}") + return payload + + +def _select_recipe(payload: dict[str, Any], recipe_id: str) -> dict[str, Any]: + recipes = payload.get("recipes") + if not isinstance(recipes, list): + raise ValueError("recipe file must contain a recipes list") + matches = [recipe for recipe in recipes if isinstance(recipe, dict) and recipe.get("id") == recipe_id] + if not matches: + raise ValueError(f"recipe id not found: {recipe_id}") + if len(matches) > 1: + raise ValueError(f"duplicate recipe id found: {recipe_id}") + return matches[0] + + +def _resolve_path(root: Path, value: str | None) -> Path | None: + if not value: + return None + path = Path(value) + if path.is_absolute(): + return path + return root / path + + +def _selected_validation(validation: dict[str, Any], recipe_id: str) -> dict[str, Any]: + for recipe in validation.get("recipes", []): + if recipe.get("id") == recipe_id: + return recipe + raise ValueError(f"validation result missing selected recipe: {recipe_id}") + + +def _bool(value: Any) -> bool: + if isinstance(value, bool): + return value + if isinstance(value, str): + lowered = value.strip().lower() + if lowered in {"1", "true", "yes", "y"}: + return True + if lowered in {"0", "false", "no", "n", ""}: + return False + return bool(value) + + +def _unresolved_external_command(command_template: str) -> bool: + return "REPLACE_WITH" in command_template or "<" in command_template or ">" in command_template + + +def _spotcheck_calibration_file(root: Path, eval_pack: dict[str, Any], cli_value: Path | None) -> Path | None: + recipe_value = eval_pack.get("spotcheck_calibration_file") + recipe_path = _resolve_path(root, recipe_value) if isinstance(recipe_value, str) and recipe_value else None + if cli_value is not None and recipe_path is not None and cli_value.resolve() != recipe_path.resolve(): + raise ValueError( + "spotcheck calibration file mismatch: " + f"recipe declares {recipe_path}, CLI provided {cli_value}" + ) + return cli_value or recipe_path + + +def _write_json(path: Path, payload: Any) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + + +def _fmt_metric(value: Any) -> str: + if isinstance(value, int | float) and not isinstance(value, bool): + return f"{float(value):.6f}" + return str(value) + + +def _write_claim_safety_report( + path: Path, + recipe_id: str, + recipe: dict[str, Any], + score: dict[str, Any], + audit: dict[str, Any], + output_audit: dict[str, Any] | None = None, +) -> None: + eval_run = score["eval_run"] + metrics = score["metrics"] + warnings = eval_run.get("warnings") or [] + machine = eval_run.get("machine") if isinstance(eval_run.get("machine"), dict) else {} + provenance = metrics.get("provenance_coverage") if isinstance(metrics.get("provenance_coverage"), dict) else {} + metadata_coverage = metrics.get("metadata_coverage") if isinstance(metrics.get("metadata_coverage"), dict) else {} + reference_coverage = metrics.get("reference_coverage") if isinstance(metrics.get("reference_coverage"), dict) else {} + metric_means = metrics.get("metric_means") if isinstance(metrics.get("metric_means"), dict) else {} + leakage = metrics.get("leakage") if isinstance(metrics.get("leakage"), dict) else {} + normalization = metrics.get("normalization_summary") if isinstance(metrics.get("normalization_summary"), dict) else {} + dictionary_coverage = metrics.get("dictionary_coverage") if isinstance(metrics.get("dictionary_coverage"), dict) else {} + uncertainty = metrics.get("uncertainty") if isinstance(metrics.get("uncertainty"), dict) else {} + intervals = uncertainty.get("metrics") if isinstance(uncertainty.get("metrics"), dict) else {} + script_inventory = metrics.get("script_inventory") if isinstance(metrics.get("script_inventory"), dict) else {} + lines = [ + "# Eval Claim Safety Report", + "", + f"- recipe: {recipe_id}", + f"- task: {recipe.get('task')}", + f"- audit passed: {audit.get('audit_passed')}", + f"- claim safe: {eval_run.get('claim_safe')}", + f"- eval mode: {eval_run.get('eval_mode')}", + f"- score created at: {eval_run.get('created_at')}", + f"- score machine platform: {machine.get('platform')}", + f"- score machine python: {machine.get('python')}", + f"- score command: {eval_run.get('command')}", + "", + "## What Was Scored", + "", + ] + if eval_run.get("eval_mode") == "page_level_ocr": + lines.extend( + [ + f"- system: {eval_run.get('system_name')}", + f"- model: {eval_run.get('model_name')}", + f"- checkpoint: {eval_run.get('checkpoint') or '(not recorded)'}", + f"- config: {eval_run.get('config') or '(not recorded)'}", + f"- dictionary: {eval_run.get('dictionary') or '(not recorded)'}", + f"- artifact identity: {json.dumps(eval_run.get('artifact_identity', {}), ensure_ascii=False, sort_keys=True)}", + f"- normalization profile: {eval_run.get('normalization_profile')}", + f"- eval manifest: {eval_run.get('eval_manifest')}", + f"- documents dir: {eval_run.get('documents_dir')}", + f"- manifest samples: {metrics.get('manifest_samples')}", + f"- scored pages: {metrics.get('scored_pages')}", + f"- missing documents: {metrics.get('missing_documents')}", + f"- missing references: {metrics.get('missing_references')}", + ] + ) + else: + lines.extend( + [ + f"- model: {eval_run.get('model_name')}", + f"- checkpoint: {eval_run.get('checkpoint') or '(not recorded)'}", + f"- config: {eval_run.get('config') or '(not recorded)'}", + f"- dictionary: {eval_run.get('dictionary') or '(not recorded)'}", + f"- artifact identity: {json.dumps(eval_run.get('artifact_identity', {}), ensure_ascii=False, sort_keys=True)}", + f"- normalization profile: {eval_run.get('normalization_profile')}", + f"- label file: {eval_run.get('label_file')}", + f"- prediction file: {eval_run.get('prediction_file')}", + f"- scored lines: {metrics.get('n_lines')}", + f"- unmatched labels: {metrics.get('unmatched_labels')}", + f"- unmatched predictions: {metrics.get('unmatched_predictions')}", + ] + ) + lines.extend( + [ + "", + "## Ground Truth And Pack", + "", + f"- eval pack version: {eval_run.get('eval_pack_version') or '(missing)'}", + f"- frozen eval pack: {eval_run.get('frozen_eval_pack')}", + f"- unseen for selection: {eval_run.get('unseen_for_selection')}", + f"- selected checkpoint on test: {eval_run.get('selected_checkpoint_on_test')}", + f"- languages: {eval_run.get('languages')}", + f"- scripts: {eval_run.get('scripts')}", + f"- domains: {eval_run.get('domains')}", + f"- GT statuses: {eval_run.get('gt_statuses')}", + f"- splits: {eval_run.get('splits')}", + f"- script inventory file: {script_inventory.get('inventory_file')}", + f"- observed codepoints/graphemes: {script_inventory.get('observed_codepoint_count')}/{script_inventory.get('observed_grapheme_count')}", + f"- missing required codepoints: {script_inventory.get('missing_required_codepoints')}", + f"- missing required graphemes: {script_inventory.get('missing_required_graphemes')}", + f"- metadata contradictions: {metrics.get('metadata_contradictions', [])}", + ] + ) + if eval_run.get("eval_mode") == "page_level_ocr": + lines.extend( + [ + f"- metadata coverage: {metadata_coverage}", + f"- reference coverage: {reference_coverage}", + f"- normalization changed reference/prediction/any: {normalization.get('reference_changed')}/{normalization.get('prediction_changed')}/{normalization.get('any_changed')} of {normalization.get('total')}", + f"- dictionary coverage checked: {dictionary_coverage.get('checked')}", + f"- dictionary reference codepoints/dictionary codepoints: {dictionary_coverage.get('gt_codepoint_count')}/{dictionary_coverage.get('dictionary_codepoint_count')}", + f"- dictionary missing reference codepoints: {dictionary_coverage.get('missing_gt_codepoints')}", + ] + ) + else: + lines.extend( + [ + f"- provenance coverage: {provenance}", + f"- normalizer counts: {metrics.get('normalizer_counts', {})}", + f"- normalization changed GT/prediction/any: {normalization.get('gt_changed')}/{normalization.get('prediction_changed')}/{normalization.get('any_changed')} of {normalization.get('total')}", + f"- dictionary coverage checked: {dictionary_coverage.get('checked')}", + f"- dictionary GT codepoints/dictionary codepoints: {dictionary_coverage.get('gt_codepoint_count')}/{dictionary_coverage.get('dictionary_codepoint_count')}", + f"- dictionary missing GT codepoints: {dictionary_coverage.get('missing_gt_codepoints')}", + ] + ) + lines.extend( + [ + f"- leakage checked: {leakage.get('checked')}", + "", + "## Metrics", + "", + ] + ) + if eval_run.get("eval_mode") == "page_level_ocr": + lines.extend( + [ + f"- text codepoint CER micro: {_fmt_metric(metrics.get('text_cer_codepoint_micro'))}", + f"- text grapheme CER micro: {_fmt_metric(metrics.get('text_cer_grapheme_micro'))}", + f"- text exact accuracy: {_fmt_metric(metrics.get('text_exact_accuracy'))}", + f"- line detection F1 mean: {_fmt_metric(metric_means.get('line_detection_f1'))}", + f"- line mean IoU: {_fmt_metric(metric_means.get('line_mean_iou'))}", + f"- reading-order pair accuracy: {_fmt_metric(metric_means.get('reading_order_pair_accuracy'))}", + f"- text codepoint edits/ref: {metrics.get('text_codepoint_edits')}/{metrics.get('text_codepoint_ref_len')}", + f"- text grapheme edits/ref: {metrics.get('text_grapheme_edits')}/{metrics.get('text_grapheme_ref_len')}", + f"- text exact pages/ref pages: {metrics.get('text_exact_pages')}/{metrics.get('text_reference_pages')}", + f"- zero-length text references: {metrics.get('zero_length_text_references')}", + f"- uncertainty method: {uncertainty.get('method')}", + f"- uncertainty scoring units: {uncertainty.get('effective_sample_size')}/{uncertainty.get('min_claim_scoring_units')}", + f"- text grapheme CER 95% CI: {_fmt_metric((intervals.get('text_cer_grapheme_micro') or {}).get('low'))}..{_fmt_metric((intervals.get('text_cer_grapheme_micro') or {}).get('high'))}", + ] + ) + lines.extend(["", "## Slices", ""]) + for row in metrics.get("slices", []): + if not isinstance(row, dict): + continue + row_means = row.get("metric_means") if isinstance(row.get("metric_means"), dict) else {} + lines.append( + f"- {row.get('language')} / {row.get('script')} / {row.get('domain')} / {row.get('gt_status')} / {row.get('split')}: " + f"pages={row.get('scored_pages')} text_graph_CER={_fmt_metric(row.get('text_cer_grapheme_micro'))} " + f"text_cp_CER={_fmt_metric(row.get('text_cer_codepoint_micro'))} " + f"exact={_fmt_metric(row.get('text_exact_accuracy'))} line_F1={_fmt_metric(row_means.get('line_detection_f1', 0.0))}" + ) + else: + lines.extend( + [ + f"- codepoint CER micro: {_fmt_metric(metrics.get('cer_codepoint_micro'))}", + f"- grapheme CER micro: {_fmt_metric(metrics.get('cer_grapheme_micro'))}", + f"- exact-line accuracy: {_fmt_metric(metrics.get('exact_line_accuracy'))}", + f"- codepoint edits/ref: {metrics.get('codepoint_edits')}/{metrics.get('codepoint_ref_len')}", + f"- grapheme edits/ref: {metrics.get('grapheme_edits')}/{metrics.get('grapheme_ref_len')}", + f"- zero-length GT lines: {metrics.get('zero_length_gt_lines')}", + f"- uncertainty method: {uncertainty.get('method')}", + f"- uncertainty scoring units: {uncertainty.get('effective_sample_size')}/{uncertainty.get('min_claim_scoring_units')}", + f"- grapheme CER 95% CI: {_fmt_metric((intervals.get('cer_grapheme_micro') or {}).get('low'))}..{_fmt_metric((intervals.get('cer_grapheme_micro') or {}).get('high'))}", + ] + ) + lines.extend(["", "## Slices", ""]) + for row in metrics.get("slices", []): + if not isinstance(row, dict): + continue + lines.append( + f"- {row.get('language')} / {row.get('script')} / {row.get('domain')} / {row.get('gt_status')} / {row.get('split')}: " + f"n={row.get('n_lines')} graph_CER={_fmt_metric(row.get('cer_grapheme_micro'))} " + f"cp_CER={_fmt_metric(row.get('cer_codepoint_micro'))} exact={_fmt_metric(row.get('exact_line_accuracy'))}" + ) + score_eval_run_name = "page-eval-run.json" if eval_run.get("eval_mode") == "page_level_ocr" else "eval-run.json" + lines.extend( + [ + "", + "## Review Artifacts", + "", + "- audit JSON: audit.json", + f"- eval run JSON: score/{score_eval_run_name}", + "- metrics JSON: score/metrics.json", + "- metrics Markdown: score/metrics.md", + "- command text: score/command.txt", + ] + ) + if eval_run.get("eval_mode") == "page_level_ocr": + lines.extend( + [ + f"- page output audit passed: {output_audit.get('passed') if output_audit else '(not run)'}", + f"- page output audit records: {output_audit.get('record_count') if output_audit else 0}", + "- page output audit JSON: output-audit/output-audit-run.json", + "- page output audit Markdown: output-audit/output-audit-run.md", + "- page metrics CSV: score/page-metrics.csv", + "- reference artifacts TSV: score/reference-artifacts.tsv", + "- text pairs TSV: score/text-pairs.tsv", + "- missing TSV: score/missing.tsv", + "- worst pages: score/worst-pages.csv", + "- line alignment CSV: score/line-alignment.csv", + "- review CSV: score/sample-review.csv", + "- review HTML: score/sample-review.html", + "- confusions JSON: score/confusions.json", + ] + ) + else: + lines.extend( + [ + "- predictions TSV: score/predictions.tsv", + "- unmatched TSV: score/unmatched.tsv", + "- worst lines: score/worst-lines.csv", + "- review CSV: score/sample-review.csv", + "- review HTML: score/sample-review.html", + "- confusions JSON: score/confusions.json", + ] + ) + lines.extend( + [ + "", + "## Warnings", + "", + ] + ) + lines.extend([f"- {warning}" for warning in warnings] or ["- none"]) + path.write_text("\n".join(lines) + "\n", encoding="utf-8") + + +def _build_leakage_manifests(recipe: dict[str, Any], root: Path, out: Path, force: bool) -> list[Path]: + leakage_tool = _load_tool("build_recognizer_leakage_manifest") + eval_pack = recipe["eval_pack"] + label_specs: list[str] = [] + train_manifests: list[Path] = [] + for index, source in enumerate(recipe.get("leakage_sources") or []): + if not isinstance(source, dict): + raise ValueError(f"{recipe['id']}: leakage_sources[{index}] must be an object") + manifest_file = _resolve_path(root, source.get("manifest_file")) + if manifest_file is not None: + train_manifests.append(manifest_file) + continue + label_file = _resolve_path(root, source.get("label_file")) + data_dir = _resolve_path(root, source.get("data_dir")) + split = str(source.get("split") or "train") + if label_file is None or data_dir is None: + raise ValueError(f"{recipe['id']}: leakage_sources[{index}] must provide manifest_file or label_file/data_dir") + label_specs.append(f"{label_file}::{data_dir}::{split}") + if label_specs: + leakage_dir = out / "leakage" + built_manifest = leakage_dir / "train-dev.jsonl" + build_args = Namespace( + label=label_specs, + out=built_manifest, + summary=leakage_dir / "train-dev.summary.json", + source=str(recipe["model_family"]), + default_split="train", + language=str(recipe["language"]), + script=str(recipe["script"]), + domain=str(eval_pack.get("domain") or "unknown"), + gt_status=str(eval_pack.get("gt_status") or "unknown"), + text_only=False, + allow_missing_images=False, + force=force, + ) + leakage_tool.build_manifest(build_args) + train_manifests.append(built_manifest) + return train_manifests + + +def _command_for_recipe(recipe: dict[str, Any], root: Path, materialize_out: Path) -> tuple[str, Path | None]: + runner = recipe["runner"] + runner_type = runner.get("type") + task = recipe.get("task") + if runner_type == "model_config": + model_config = _resolve_path(root, runner.get("model_config")) + if model_config is None: + raise ValueError(f"{recipe['id']}: runner.model_config is required") + if task == RECOGNIZER_TASK: + summary_path = materialize_out / "recognizer-predictions.summary.json" + command = ( + f"{shlex.quote(sys.executable)} {shlex.quote(str(TOOLS_DIR / 'predict_recognizer_eval.py'))} " + "--label-file {label_file} --data-dir {data_dir} " + f"--model-config {shlex.quote(str(model_config))} " + "--out {prediction_file} " + f"--summary-file {shlex.quote(str(summary_path))}" + ) + return command, model_config + if task == PAGE_TASK: + command = ( + f"{shlex.quote(sys.executable)} -m ocrtech.cli parse-doc " + "{input_path} --out {output_dir} --engine candidate " + f"--model-config {shlex.quote(str(model_config))}" + ) + return command, model_config + raise ValueError(f"{recipe['id']}: unsupported task {task!r}") + if runner_type == "external_command": + command_template = runner.get("command_template") + if not isinstance(command_template, str) or not command_template: + raise ValueError(f"{recipe['id']}: external command_template is required") + return command_template, None + raise ValueError(f"{recipe['id']}: unsupported runner.type {runner_type!r}") + + +def _materialize_outputs( + recipe: dict[str, Any], + root: Path, + out: Path, + timeout_seconds: int | None, + force: bool, + allow_unresolved_external: bool, +) -> dict[str, Any]: + materialize_tool = _load_tool("run_eval_output_command") + runner = recipe["runner"] + eval_pack = recipe["eval_pack"] + materialize_out = out / "materialize" + command_template, model_config = _command_for_recipe(recipe, root, materialize_out) + if runner.get("type") == "external_command" and _unresolved_external_command(command_template) and not allow_unresolved_external: + raise ValueError(f"{recipe['id']}: external command is unresolved; replace the template before running") + task = recipe.get("task") + label_file = _resolve_path(root, eval_pack.get("label_file")) + data_dir = _resolve_path(root, eval_pack.get("data_dir")) + eval_manifest = _resolve_path(root, eval_pack.get("eval_manifest")) + if task == RECOGNIZER_TASK and (label_file is None or data_dir is None): + raise ValueError(f"{recipe['id']}: eval_pack.label_file and eval_pack.data_dir are required") + if task == PAGE_TASK and eval_manifest is None: + raise ValueError(f"{recipe['id']}: eval_pack.eval_manifest is required") + if task not in {RECOGNIZER_TASK, PAGE_TASK}: + raise ValueError(f"{recipe['id']}: unsupported task {task!r}") + materialize_args = Namespace( + mode="page" if task == PAGE_TASK else "recognizer", + command=command_template, + out=materialize_out, + system_name=str(recipe["id"]), + model_name=str(runner.get("model_name") or recipe["model_family"]), + model_config=model_config, + checkpoint=str(runner.get("checkpoint") or runner.get("checkpoint_path") or ""), + config=str(runner.get("config") or runner.get("training_summary") or ""), + dictionary=str(runner.get("dictionary") or ""), + timeout_seconds=timeout_seconds, + force=force, + label_file=label_file, + data_dir=data_dir, + prediction_file=out / "predictions.txt" if task == RECOGNIZER_TASK else None, + eval_manifest=eval_manifest if task == PAGE_TASK else None, + documents_dir=out / "documents" if task == PAGE_TASK else None, + ) + return materialize_tool.run_materialization(materialize_args) + + +def _render_output_audit_command(template: str, values: dict[str, str]) -> list[str]: + try: + rendered = template.format(**values) + except KeyError as exc: + raise ValueError(f"unknown output_audit command placeholder: {exc}") from exc + command = shlex.split(rendered) + if not command: + raise ValueError("rendered output_audit command is empty") + return command + + +def _optional_file_record(path: Path) -> dict[str, Any] | None: + if not path.is_file(): + return None + return { + "path": str(path), + "sha256": sha256_file(path), + "size_bytes": path.stat().st_size, + } + + +def _run_page_output_audits( + recipe: dict[str, Any], + out: Path, + materialization: dict[str, Any], + timeout_seconds: int | None, + allow_unresolved_external: bool, +) -> dict[str, Any] | None: + if recipe.get("task") != PAGE_TASK: + return None + runner = recipe.get("runner") + if not isinstance(runner, dict): + return None + output_audit = runner.get("output_audit") + if not isinstance(output_audit, dict): + return None + template = output_audit.get("command_template") + if not isinstance(template, str) or not template: + return None + result_filename = str(output_audit.get("result_filename") or "limbu-output-audit.json") + markdown_filename = output_audit.get("markdown_filename") + if not isinstance(markdown_filename, str) or not markdown_filename: + markdown_filename = "limbu-output-audit.md" if result_filename == "limbu-output-audit.json" else "" + if _unresolved_external_command(template) and not allow_unresolved_external: + raise ValueError(f"{recipe['id']}: output_audit command is unresolved; replace the template before running") + audit_root = out / "output-audit" + logs_dir = audit_root / "logs" + audit_root.mkdir(parents=True, exist_ok=True) + records: list[dict[str, Any]] = [] + for record in materialization.get("records", []): + if not isinstance(record, dict): + continue + sample_id = str(record.get("sample_id") or f"sample-{len(records) + 1}") + output_path_value = record.get("output_path") + if not isinstance(output_path_value, str) or not output_path_value: + raise ValueError(f"{recipe['id']}: materialization record for {sample_id} missing output_path") + document_json = Path(output_path_value) + output_dir = document_json.parent + command = _render_output_audit_command( + template, + { + "output_dir": str(output_dir), + "documents_dir": str(out / "documents"), + "out_dir": str(audit_root), + }, + ) + stdout_path = logs_dir / f"{sample_id}.stdout.txt" + stderr_path = logs_dir / f"{sample_id}.stderr.txt" + try: + completed = subprocess.run( + command, + check=False, + capture_output=True, + text=True, + timeout=timeout_seconds, + ) + returncode = completed.returncode + stdout_text = completed.stdout + stderr_text = completed.stderr + except subprocess.TimeoutExpired as exc: + returncode = 124 + stdout_text = exc.stdout or "" + stderr_text = (exc.stderr or "") + f"\nTimeoutExpired: command exceeded {timeout_seconds}s\n" + stdout_path.parent.mkdir(parents=True, exist_ok=True) + stdout_path.write_text(stdout_text, encoding="utf-8") + stderr_path.write_text(stderr_text, encoding="utf-8") + audit_json = _optional_file_record(output_dir / result_filename) + audit_md = _optional_file_record(output_dir / markdown_filename) if markdown_filename else None + row = { + "sample_id": sample_id, + "output_dir": str(output_dir), + "command": command, + "stdout_path": str(stdout_path), + "stdout_sha256": sha256_file(stdout_path), + "stderr_path": str(stderr_path), + "stderr_sha256": sha256_file(stderr_path), + "returncode": returncode, + "audit_json": audit_json, + "audit_markdown": audit_md, + } + records.append(row) + if returncode != 0: + _write_output_audit_summary(audit_root, recipe, template, records) + raise RuntimeError(f"page output_audit command failed for {sample_id} with return code {returncode}; stderr: {stderr_path}") + return _write_output_audit_summary(audit_root, recipe, template, records) + + +def _write_output_audit_summary( + audit_root: Path, + recipe: dict[str, Any], + template: str, + records: list[dict[str, Any]], +) -> dict[str, Any]: + passed = all(record.get("returncode") == 0 for record in records) + payload = { + "created_at": datetime.now(timezone.utc).isoformat(), + "recipe_id": recipe.get("id"), + "task": recipe.get("task"), + "command_template": template, + "record_count": len(records), + "passed": passed, + "records": records, + "machine": {"platform": platform.platform(), "python": sys.version}, + } + _write_json(audit_root / "output-audit-run.json", payload) + (audit_root / "command-template.txt").write_text(template.strip() + "\n", encoding="utf-8") + lines = [ + "# Page Output Audit Run", + "", + f"- recipe: {recipe.get('id')}", + f"- task: {recipe.get('task')}", + f"- passed: {passed}", + f"- records: {len(records)}", + f"- command template: `{template}`", + "", + "## Outputs", + "", + ] + for record in records: + line = f"- {record.get('sample_id')}: returncode={record.get('returncode')} output_dir=`{record.get('output_dir')}`" + if isinstance(record.get("stdout_path"), str) and isinstance(record.get("stdout_sha256"), str): + line += f" stdout=`{record['stdout_path']}` sha256={record['stdout_sha256']}" + if isinstance(record.get("stderr_path"), str) and isinstance(record.get("stderr_sha256"), str): + line += f" stderr=`{record['stderr_path']}` sha256={record['stderr_sha256']}" + audit_json = record.get("audit_json") + if isinstance(audit_json, dict) and isinstance(audit_json.get("path"), str) and isinstance(audit_json.get("sha256"), str): + line += f" audit_json=`{audit_json['path']}` sha256={audit_json['sha256']}" + audit_markdown = record.get("audit_markdown") + if ( + isinstance(audit_markdown, dict) + and isinstance(audit_markdown.get("path"), str) + and isinstance(audit_markdown.get("sha256"), str) + ): + line += f" audit_markdown=`{audit_markdown['path']}` sha256={audit_markdown['sha256']}" + lines.append(line) + (audit_root / "output-audit-run.md").write_text("\n".join(lines) + "\n", encoding="utf-8") + return payload + + +def _score_outputs( + recipe: dict[str, Any], + root: Path, + out: Path, + train_manifests: list[Path], + args: argparse.Namespace, +) -> dict[str, Any]: + runner = recipe["runner"] + eval_pack = recipe["eval_pack"] + common = { + "out": out / "score", + "summary_file": _resolve_path(root, eval_pack.get("summary_file")), + "script_inventory_file": _resolve_path(root, eval_pack.get("script_inventory_file")), + "spotcheck_calibration_file": _spotcheck_calibration_file(root, eval_pack, args.spotcheck_calibration_file), + "train_manifest": train_manifests, + "model_name": str(runner.get("model_name") or recipe["model_family"]), + "checkpoint": str(runner.get("checkpoint") or runner.get("checkpoint_path") or ""), + "config": str(runner.get("config") or runner.get("training_summary") or ""), + "dictionary": str(runner.get("dictionary") or ""), + "language": str(recipe["language"]), + "script": str(recipe["script"]), + "domain": str(eval_pack.get("domain") or "unknown"), + "gt_status": str(eval_pack.get("gt_status") or "unknown"), + "eval_pack_version": str(eval_pack.get("eval_pack_version") or ""), + "frozen_eval_pack": _bool(eval_pack.get("frozen_eval_pack")), + "unseen_for_selection": _bool(eval_pack.get("unseen_for_selection")), + "selected_checkpoint_on_test": _bool(runner.get("selected_checkpoint_on_test")), + "claim_eligible": _bool(eval_pack.get("claim_eligible")), + "review_sample_size": args.review_sample_size, + "require_claim_safe": args.require_claim_safe, + "force": args.force, + } + if recipe.get("task") == PAGE_TASK: + scorer = _load_tool("run_page_ocr_eval") + eval_manifest = _resolve_path(root, eval_pack.get("eval_manifest")) + if eval_manifest is None: + raise ValueError(f"{recipe['id']}: eval_pack.eval_manifest is required") + output_audit = runner.get("output_audit") if isinstance(runner.get("output_audit"), dict) else {} + score_args = Namespace( + eval_manifest=eval_manifest, + documents_dir=out / "documents", + ocr_output_kind=str(eval_pack.get("ocr_output_kind") or "live_detector"), + require_output_audit=False, + output_audit_filename=str(output_audit.get("result_filename") or "limbu-output-audit.json"), + output_audit_passed_field=str(output_audit.get("passed_field") or "passed"), + system_name=str(recipe["id"]), + line_iou_threshold=float(eval_pack.get("line_iou_threshold") or 0.5), + **common, + ) + return scorer.run_eval(score_args) + if recipe.get("task") == RECOGNIZER_TASK: + scorer = _load_tool("run_recognizer_eval") + label_file = _resolve_path(root, eval_pack.get("label_file")) + data_dir = _resolve_path(root, eval_pack.get("data_dir")) + if label_file is None or data_dir is None: + raise ValueError(f"{recipe['id']}: eval_pack.label_file and eval_pack.data_dir are required") + score_args = Namespace( + label_file=label_file, + data_dir=data_dir, + prediction_file=out / "predictions.txt", + manifest_file=_resolve_path(root, eval_pack.get("manifest_file")), + split=str(eval_pack.get("split") or "eval"), + known_leakage="; ".join(str(item) for item in recipe.get("known_leakage", []) if item), + min_match_rate=args.min_match_rate, + require_full_match=True, + **common, + ) + return scorer.run_eval(score_args) + raise ValueError(f"{recipe['id']}: unsupported task {recipe.get('task')!r}") + + +def run_recipe(args: argparse.Namespace) -> dict[str, Any]: + root = args.root.resolve() + recipes_path = args.recipes if args.recipes.is_absolute() else root / args.recipes + out = args.out + if out.exists() and any(out.iterdir()) and not args.force: + raise FileExistsError(f"output directory exists and is not empty: {out}") + + payload = _read_recipe_file(recipes_path) + recipe = _select_recipe(payload, args.recipe_id) + if recipe.get("task") not in {RECOGNIZER_TASK, PAGE_TASK}: + raise ValueError(f"{args.recipe_id}: unsupported task {recipe.get('task')!r}") + + validator = _load_tool("validate_eval_harness_recipes") + validation = validator.validate_recipes(recipes_path, root) + recipe_validation = _selected_validation(validation, args.recipe_id) + if not recipe_validation.get("valid"): + raise ValueError(f"{args.recipe_id}: recipe is not structurally valid: {recipe_validation.get('issues')}") + if args.require_claim_safe and not recipe_validation.get("claim_ready"): + raise ValueError( + f"{args.recipe_id}: recipe is not claim-ready: " + + "; ".join(recipe_validation.get("claim_blockers") or []) + ) + + out.mkdir(parents=True, exist_ok=True) + _write_json(out / "recipe.json", recipe) + _write_json(out / "recipe-validation.json", recipe_validation) + + try: + train_manifests = _build_leakage_manifests(recipe, root, out, args.force) + materialization = _materialize_outputs( + recipe, + root, + out, + args.timeout_seconds, + args.force, + args.allow_unresolved_external, + ) + output_audit = _run_page_output_audits( + recipe, + out, + materialization, + args.timeout_seconds, + args.allow_unresolved_external, + ) + score = _score_outputs(recipe, root, out, train_manifests, args) + audit_tool = _load_tool("audit_eval_run") + audit = audit_tool.audit_run(out / "score") + _write_json(out / "audit.json", audit) + _write_claim_safety_report(out / "claim-safety.md", args.recipe_id, recipe, score, audit, output_audit) + eval_run_name = "page-eval-run.json" if recipe.get("task") == PAGE_TASK else "eval-run.json" + scored_output: dict[str, str] = ( + {"documents_dir": str(out / "documents")} + if recipe.get("task") == PAGE_TASK + else {"prediction_file": str(out / "predictions.txt")} + ) + summary = { + "created_at": datetime.now(timezone.utc).isoformat(), + "recipe_id": args.recipe_id, + "recipe_file": str(recipes_path), + "recipe_file_sha256": sha256_file(recipes_path), + "root": str(root), + "outputs": { + **scored_output, + "materialization_dir": str(out / "materialize"), + "output_audit_dir": str(out / "output-audit") if output_audit else None, + "score_dir": str(out / "score"), + "recipe_file": str(out / "recipe.json"), + "recipe_validation_file": str(out / "recipe-validation.json"), + "audit_file": str(out / "audit.json"), + "claim_safety_report": str(out / "claim-safety.md"), + }, + "train_manifests": [{"path": str(path), "sha256": sha256_file(path)} for path in train_manifests], + "recipe_validation": recipe_validation, + "materialization": materialization, + "output_audit": output_audit, + "audit": { + "audit_passed": audit["audit_passed"], + "claim_safe": audit["claim_safe"], + "issues": audit["issues"], + }, + "score": { + "claim_safe": score["eval_run"]["claim_safe"], + "warnings": score["eval_run"]["warnings"], + "metrics_file": str(out / "score" / "metrics.json"), + "metrics_file_sha256": sha256_file(out / "score" / "metrics.json"), + "eval_run_file": str(out / "score" / eval_run_name), + "eval_run_file_sha256": sha256_file(out / "score" / eval_run_name), + }, + "machine": {"platform": platform.platform(), "python": sys.version}, + "command": " ".join(sys.argv), + } + _write_json(out / "recipe-run.json", summary) + return summary + except Exception as exc: + error_payload = { + "created_at": datetime.now(timezone.utc).isoformat(), + "recipe_id": args.recipe_id, + "recipe_file": str(recipes_path), + "recipe_file_sha256": sha256_file(recipes_path), + "root": str(root), + "out": str(out), + "recipe_validation": recipe_validation, + "machine": {"platform": platform.platform(), "python": sys.version}, + "command": " ".join(sys.argv), + "error_type": type(exc).__name__, + "error": str(exc), + "traceback": traceback.format_exc(), + } + _write_json(out / "recipe-run-error.json", error_payload) + raise + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--recipes", type=Path, default=Path("configs/eval-harness-recipes-v1.json")) + parser.add_argument("--recipe-id", required=True) + parser.add_argument("--root", type=Path, default=Path(".")) + parser.add_argument("--out", type=Path, required=True) + parser.add_argument("--timeout-seconds", type=int) + parser.add_argument("--spotcheck-calibration-file", type=Path) + parser.add_argument("--min-match-rate", type=float, default=0.99) + parser.add_argument("--review-sample-size", type=int, default=50) + parser.add_argument("--require-claim-safe", action="store_true") + parser.add_argument("--allow-unresolved-external", action="store_true") + parser.add_argument("--force", action="store_true") + args = parser.parse_args(argv) + summary = run_recipe(args) + score = summary["score"] + print(f"wrote {args.out} recipe={args.recipe_id} claim_safe={score['claim_safe']}") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ocr-tech-mps-integration/tools/run_limbu_book_ocr.py b/ocr-tech-mps-integration/tools/run_limbu_book_ocr.py new file mode 100644 index 0000000000000000000000000000000000000000..9767df5786f92d4e1a4e86934e87dced11200235 --- /dev/null +++ b/ocr-tech-mps-integration/tools/run_limbu_book_ocr.py @@ -0,0 +1,2313 @@ +#!/usr/bin/env python3 +"""Run the operational Limbu book OCR path from raw page captures.""" + +from __future__ import annotations + +import argparse +import csv +import html +import importlib.util +import json +import os +import platform +import re +import shlex +import statistics +import sys +from datetime import UTC, datetime +from pathlib import Path +from types import ModuleType +from typing import Any + +from ocrtech.errors import OcrTechError +from ocrtech.manifest import sha256_file + + +DEFAULT_MODEL_CONFIG = "outputs/limbu-router-v4-ppocr-devanagari-sirijonga-confidence-guard-2026-06-22/model-card.json" +DETECTOR_PROFILES: dict[str, dict[str, Any]] = { + "current": { + "description": "Use the runner's current image-line detector defaults.", + "usage_note": "Default stable profile. If page-layout review shows missed lines, rerun the same source with current-plus-balanced-rescue and inspect the added-line packet before changing defaults.", + "parse_kwargs": {}, + }, + "balanced-pdf-text": { + "description": "CDC PDF-text probe profile: improved source-line coverage with modest review-row growth.", + "usage_note": "Replacement detector probe. It can recover source lines, but it may replace larger baseline boxes; prefer current-plus-balanced-rescue for the next real book/photo probe.", + "parse_kwargs": { + "line_detection_mode": "image-line", + "image_line_allow_empty_lines": True, + "image_line_horizontal_kernel": 23, + "image_line_vertical_kernel": 3, + "image_line_dilation_iterations": 1, + "image_line_min_width": 15, + "image_line_min_height": 10, + "image_line_min_area": 50, + "image_line_max_height": 100, + "image_line_detector_padding": 2, + }, + }, + "current-plus-balanced-rescue": { + "description": "Keep current detector defaults and add the balanced PDF-text settings as a rescue pass.", + "usage_note": "Additive missed-line probe. It keeps current detector boxes as primary and appends rescue boxes; keep it opt-in until checked on the next real book/photo batch.", + "parse_kwargs": { + "line_detection_mode": "image-line", + "image_line_allow_empty_lines": True, + "image_line_rescue_detector_passes": [ + { + "horizontal_kernel": 23, + "vertical_kernel": 3, + "dilation_iterations": 1, + "min_width": 15, + "min_height": 10, + "min_area": 50, + "max_height": 100, + "detector_padding": 2, + } + ], + }, + }, +} +GAP_REVIEW_CROP_PADDING = 12 +GAP_REVIEW_QUEUE_HEADER = [ + "gap_row_id", + "book_page_number", + "book_page_id", + "image_path", + "gap_index", + "from_y", + "to_y", + "gap", + "threshold", + "page_height_ratio", + "gap_ink_dark_pixel_count", + "gap_ink_density", + "gap_ink_bbox", + "gap_ink_row_bands", + "gap_candidate_text_band_crop_paths", + "gap_candidate_text_band_crop_sha256s", + "gap_candidate_text_band_count", + "gap_horizontal_rule_count", + "gap_page_graphic_band_count", + "gap_review_priority", + "gap_recommended_action", + "crop_path", + "crop_sha256", + "page_context_path", + "page_context_sha256", + "review_status", + "insert_after_row_index", + "corrected_text", + "reviewer", + "notes", +] +PAGE_TRIAGE_REVIEW_QUEUE_HEADER = [ + "page_triage_id", + "book_page_number", + "book_page_id", + "image_path", + "image_sha256", + "recommended_action", + "operator_flags", + "line_count", + "review_line_count", + "review_ratio", + "sirijonga_count", + "devanagari_count", + "mixed_count", + "other_count", + "other_ratio", + "suspicious_gap_count", + "candidate_text_gap_count", + "horizontal_rule_gap_count", + "max_row_gap", + "review_status", + "operator_decision", + "reviewer", + "notes", +] +PAGE_LAYOUT_REVIEW_MANIFEST_HEADER = [ + "layout_page_id", + "book_page_number", + "book_page_id", + "image_path", + "image_sha256", + "document_json", + "document_json_sha256", + "overlay_path", + "overlay_sha256", + "line_count", + "empty_line_count", + "review_line_count", + "reading_order", + "operator_flags", + "notes", +] + + +def _load_sibling_module(name: str) -> ModuleType: + path = Path(__file__).resolve().parent / f"{name}.py" + spec = importlib.util.spec_from_file_location(name, path) + if spec is None or spec.loader is None: + raise RuntimeError(f"could not load tool module: {path}") + module = importlib.util.module_from_spec(spec) + sys.modules[spec.name] = module + spec.loader.exec_module(module) + return module + + +def _capture_args(args: argparse.Namespace, page_manifest: Path, capture_out: Path) -> argparse.Namespace: + return argparse.Namespace( + page_manifest=page_manifest, + out=capture_out, + rotate_degrees=getattr(args, "rotate_degrees", 0.0), + crop_box=getattr(args, "crop_box", None), + perspective_quad=getattr(args, "perspective_quad", None), + auto_detect_page=getattr(args, "auto_detect_page", False), + auto_deskew=getattr(args, "auto_deskew", True), + max_auto_deskew_degrees=getattr(args, "max_auto_deskew_degrees", 8.0), + no_autocontrast=getattr(args, "no_autocontrast", False), + no_grayscale=getattr(args, "no_grayscale", False), + preserve_parse_defaults=getattr(args, "preserve_page_lines", True), + require_metadata_path_self=True, + allow_failed_capture_audit=False, + min_prepared_width=getattr(args, "min_prepared_width", None), + min_prepared_height=getattr(args, "min_prepared_height", None), + min_prepared_entropy=getattr(args, "min_prepared_entropy", None), + min_prepared_luminance_stddev=getattr(args, "min_prepared_luminance_stddev", None), + min_prepared_edge_stddev=getattr(args, "min_prepared_edge_stddev", None), + min_prepared_laplacian_variance=getattr(args, "min_prepared_laplacian_variance", None), + require_auto_detect_page=getattr(args, "require_auto_detect_page", False), + min_auto_detect_page_area_ratio=getattr(args, "min_auto_detect_page_area_ratio", None), + fail_on_auto_detect_page_border_touch=getattr(args, "fail_on_auto_detect_page_border_touch", False), + require_auto_deskew_applied=getattr(args, "require_auto_deskew_applied", False), + max_abs_auto_deskew_degrees=getattr(args, "max_abs_auto_deskew_degrees", None), + ) + + +def _parse_args(args: argparse.Namespace, prepared_manifest: Path, book_out: Path) -> argparse.Namespace: + return argparse.Namespace( + page_manifest=prepared_manifest, + out=book_out, + engine=args.engine, + model_config=args.model_config, + fallback_engine=args.fallback_engine, + fallback_model_config=args.fallback_model_config, + line_assembly=args.line_assembly, + line_assembly_y_tolerance=args.line_assembly_y_tolerance, + line_assembly_max_gap=args.line_assembly_max_gap, + line_assembly_max_merged_width=args.line_assembly_max_merged_width, + line_assembly_max_merged_width_ratio=args.line_assembly_max_merged_width_ratio, + line_assembly_max_component_width=args.line_assembly_max_component_width, + line_assembly_max_component_width_ratio=args.line_assembly_max_component_width_ratio, + line_assembly_min_vertical_overlap_ratio=args.line_assembly_min_vertical_overlap_ratio, + line_assembly_joiner=args.line_assembly_joiner, + line_assembly_require_text_structural_role=args.line_assembly_require_text_structural_role, + reading_order_profile_map=args.reading_order_profile_map, + reading_order_profile_map_audit=args.reading_order_profile_map_audit, + require_reading_order_profile_safe=args.require_reading_order_profile_safe, + require_reading_order_profile_map_safe=args.require_reading_order_profile_map_safe, + reading_order_profile_x_scale=args.reading_order_profile_x_scale, + reading_order_profile_y_scale=args.reading_order_profile_y_scale, + reading_order_profile_outside_weight=args.reading_order_profile_outside_weight, + ) + + +def _hash_if_file(path: Path) -> str | None: + return sha256_file(path) if path.is_file() else None + + +def _safe_name(value: object) -> str: + cleaned = re.sub(r"[^A-Za-z0-9._-]+", "-", str(value or "")).strip(".-") + return cleaned or "page" + + +def _int_or_zero(value: object) -> int: + try: + return int(value or 0) + except (TypeError, ValueError): + return 0 + + +def _number_or_none(value: object) -> float | None: + if isinstance(value, bool) or not isinstance(value, int | float): + return None + return float(value) + + +def _median(values: list[float]) -> float | None: + return statistics.median(values) if values else None + + +def _layout_gap_summary(document_json: object) -> dict[str, Any]: + path = Path(str(document_json or "")) + if not path.is_file(): + return {"available": False, "error": f"document.json is missing: {path}"} + try: + payload = json.loads(path.read_text(encoding="utf-8")) + except (OSError, json.JSONDecodeError) as exc: + return {"available": False, "error": f"document.json could not be read: {type(exc).__name__}: {exc}"} + if not isinstance(payload, dict): + return {"available": False, "error": "document.json root is not an object"} + pages = payload.get("pages") + if not isinstance(pages, list): + return {"available": False, "error": "document.json pages is not a list"} + boxes: list[tuple[float, float]] = [] + heights: list[float] = [] + page_heights: list[float] = [] + for page in pages: + if not isinstance(page, dict): + continue + page_height = _number_or_none(page.get("height")) + if page_height is not None and page_height > 0: + page_heights.append(page_height) + lines = page.get("text_lines") + if not isinstance(lines, list): + continue + for line in lines: + if not isinstance(line, dict): + continue + metadata = line.get("metadata") + if isinstance(metadata, dict) and metadata.get("structural_role") == "page_marker": + continue + bbox = line.get("bbox") + if not isinstance(bbox, list | tuple) or len(bbox) != 4: + continue + x = _number_or_none(bbox[0]) + y = _number_or_none(bbox[1]) + w = _number_or_none(bbox[2]) + h = _number_or_none(bbox[3]) + if x is None or y is None or w is None or h is None or w <= 0 or h <= 0: + continue + boxes.append((y, y + h)) + heights.append(h) + if len(boxes) < 3: + return { + "available": True, + "row_count": len(boxes), + "suspicious_gap_count": 0, + "suspicious_gaps": [], + } + median_height = _median(heights) or 0.0 + row_tolerance = max(1.0, median_height * 0.35) + rows: list[list[float]] = [] + for top, bottom in sorted(boxes): + if not rows or top > rows[-1][1] + row_tolerance: + rows.append([top, bottom]) + else: + rows[-1][1] = max(rows[-1][1], bottom) + gaps: list[tuple[int, float, float, float]] = [] + for index, (previous, current) in enumerate(zip(rows, rows[1:]), start=1): + gap = current[0] - previous[1] + if gap > 0: + gaps.append((index, previous[1], current[0], gap)) + positive_gaps = [gap for _, _, _, gap in gaps] + median_gap = _median(positive_gaps) or 0.0 + threshold = max(median_height * 1.50, median_gap * 1.75, 18.0) + page_height = max(page_heights) if page_heights else None + suspicious: list[dict[str, Any]] = [] + for index, previous_bottom, current_top, gap in gaps: + if gap < threshold: + continue + item: dict[str, Any] = { + "after_row_index": index - 1, + "before_row_index": index, + "from_y": round(previous_bottom, 2), + "to_y": round(current_top, 2), + "gap": round(gap, 2), + "threshold": round(threshold, 2), + } + if page_height is not None: + item["page_height_ratio"] = round(gap / page_height, 4) + suspicious.append(item) + return { + "available": True, + "row_count": len(rows), + "median_line_height": round(median_height, 2), + "median_row_gap": round(median_gap, 2), + "max_row_gap": round(max(positive_gaps), 2) if positive_gaps else 0.0, + "suspicious_gap_threshold": round(threshold, 2), + "suspicious_gap_count": len(suspicious), + "suspicious_gaps": suspicious, + } + + +def _page_operator_flags(page_summary: dict[str, Any]) -> list[str]: + line_count = _int_or_zero(page_summary.get("line_count")) + review_count = _int_or_zero(page_summary.get("review_line_count")) + counts = page_summary.get("script_counts") if isinstance(page_summary.get("script_counts"), dict) else {} + other_count = _int_or_zero(counts.get("other")) + layout_gap = page_summary.get("layout_gap_summary") if isinstance(page_summary.get("layout_gap_summary"), dict) else {} + flags: list[str] = [] + if page_summary.get("audit_passed") is False: + flags.append("page_audit_failed") + if layout_gap.get("available") is False: + flags.append("line_geometry_unavailable") + elif _int_or_zero(layout_gap.get("suspicious_gap_count")) > 0: + review_summary = page_summary.get("layout_gap_review_summary") + if isinstance(review_summary, dict): + if _int_or_zero(review_summary.get("candidate_text_gap_count")) > 0: + flags.append("possible_missed_line_gap") + else: + flags.append("possible_missed_line_gap") + if line_count == 0: + flags.append("no_detected_lines") + return flags + review_ratio = review_count / line_count + other_ratio = other_count / line_count + if review_count == line_count: + flags.append("all_lines_need_review") + elif review_ratio >= 0.5: + flags.append("high_review_burden") + if other_ratio >= 0.25: + flags.append("high_other_script_share") + return flags + + +def _page_summaries(book_run: dict[str, Any]) -> list[dict[str, Any]]: + pages = book_run.get("pages", []) + if not isinstance(pages, list): + return [] + summaries: list[dict[str, Any]] = [] + for page in pages: + if not isinstance(page, dict): + continue + summary = { + "page_number": page.get("page_number"), + "page_id": page.get("page_id"), + "line_count": page.get("line_count"), + "review_line_count": page.get("review_line_count"), + "script_counts": page.get("script_counts"), + "audit_passed": page.get("audit_passed"), + "image_path": page.get("image_path"), + "book_document_json": page.get("book_document_json") or page.get("document_json"), + "layout_gap_summary": _layout_gap_summary(page.get("book_document_json") or page.get("document_json")), + } + summary["operator_flags"] = _page_operator_flags(summary) + summaries.append(summary) + return summaries + + +def _apply_layout_gap_review_guidance( + page_summaries: list[dict[str, Any]], + layout_gap_packet: dict[str, Any], +) -> None: + by_page_id = { + str(item.get("book_page_id") or ""): item + for item in layout_gap_packet.get("layout_gap_review_page_summaries", []) + if isinstance(item, dict) + } + for page in page_summaries: + page_id = str(page.get("page_id") or "") + page["layout_gap_review_summary"] = by_page_id.get( + page_id, + { + "book_page_id": page_id, + "gap_count": 0, + "candidate_text_gap_count": 0, + "horizontal_rule_gap_count": 0, + "priority_counts": {}, + "recommended_action_counts": {}, + }, + ) + page["operator_flags"] = _page_operator_flags(page) + + +def _operator_attention_pages(page_summaries: list[dict[str, Any]]) -> list[dict[str, Any]]: + attention: list[dict[str, Any]] = [] + for page in page_summaries: + flags = page.get("operator_flags") + if not isinstance(flags, list) or not flags: + continue + attention.append( + { + "page_number": page.get("page_number"), + "page_id": page.get("page_id"), + "flags": flags, + "line_count": page.get("line_count"), + "review_line_count": page.get("review_line_count"), + "script_counts": page.get("script_counts"), + "image_path": page.get("image_path"), + "layout_gap_summary": page.get("layout_gap_summary"), + } + ) + return attention + + +def _page_triage_action(flags: list[str]) -> str: + flag_set = set(flags) + if "page_audit_failed" in flag_set or "line_geometry_unavailable" in flag_set or "no_detected_lines" in flag_set: + return "inspect_or_reshoot" + if "all_lines_need_review" in flag_set and "high_other_script_share" in flag_set: + return "source_reject_candidate" + if "possible_missed_line_gap" in flag_set and ("high_review_burden" in flag_set or "all_lines_need_review" in flag_set): + return "inspect_layout_gap_then_line_review" + if "possible_missed_line_gap" in flag_set: + return "inspect_layout_gap" + if "high_review_burden" in flag_set or "all_lines_need_review" in flag_set: + return "review_low_confidence_lines" + if "high_other_script_share" in flag_set: + return "inspect_source_page" + return "accept_page" + + +def _write_page_triage_dashboard(path: Path, queue_path: Path, rows: list[dict[str, str]]) -> int: + cards: list[str] = [] + for row in rows: + image_path = str(row.get("image_path") or "") + if image_path and Path(image_path).is_file(): + href = _relative_href(image_path, base_dir=path.parent) + image_markup = f'{html.escape(row[' + else: + image_markup = '
No page image available.
' + tsv_row = "\t".join(str(row.get(field) or "") for field in PAGE_TRIAGE_REVIEW_QUEUE_HEADER) + cards.append( + f"""
+
{image_markup}
+
+
+ {html.escape(row['recommended_action'])} + page {html.escape(row['book_page_number'])}: {html.escape(row['book_page_id'])} + flags {html.escape(row['operator_flags'] or 'none')} +
+
+
lines
{html.escape(row['line_count'])}
+
review lines
{html.escape(row['review_line_count'])} ({html.escape(row['review_ratio'])})
+
script counts
Sirijonga {html.escape(row['sirijonga_count'])}, Devanagari {html.escape(row['devanagari_count'])}, mixed {html.escape(row['mixed_count'])}, other {html.escape(row['other_count'])}
+
layout gaps
{html.escape(row['suspicious_gap_count'])}, candidate text {html.escape(row['candidate_text_gap_count'])}, rules {html.escape(row['horizontal_rule_gap_count'])}, max row gap {html.escape(row['max_row_gap'])}
+
decision
{html.escape(row['operator_decision'])}
+
+ +
+
""" + ) + page = f""" + + + + + Limbu Book OCR Page Triage + + + +
+

Limbu Book OCR Page Triage

+

Rows mirror {html.escape(queue_path.name)}; make page-level keep/reject/reshoot decisions before spending time on line-level review.

+
+
+ {"".join(cards)} +
+ + +""" + path.write_text(page, encoding="utf-8") + return len(cards) + + +def _write_page_triage_review_packet(out: Path, page_summaries: list[dict[str, Any]]) -> dict[str, Any]: + packet_dir = out / "page-triage-review" + queue_path = packet_dir / "page-triage-review-queue.tsv" + dashboard_path = packet_dir / "page-triage-review-dashboard.html" + packet_dir.mkdir(parents=True, exist_ok=True) + rows: list[dict[str, str]] = [] + for page in page_summaries: + flags = page.get("operator_flags") if isinstance(page.get("operator_flags"), list) else [] + counts = page.get("script_counts") if isinstance(page.get("script_counts"), dict) else {} + layout_gap = page.get("layout_gap_summary") if isinstance(page.get("layout_gap_summary"), dict) else {} + gap_review = page.get("layout_gap_review_summary") if isinstance(page.get("layout_gap_review_summary"), dict) else {} + line_count = _int_or_zero(page.get("line_count")) + review_count = _int_or_zero(page.get("review_line_count")) + other_count = _int_or_zero(counts.get("other")) + image_path = Path(str(page.get("image_path") or "")) + row = { + "page_triage_id": "page-{page_number:04d}-{page_id}".format( + page_number=_int_or_zero(page.get("page_number")), + page_id=_safe_name(page.get("page_id")), + ), + "book_page_number": str(page.get("page_number") or ""), + "book_page_id": str(page.get("page_id") or ""), + "image_path": str(image_path), + "image_sha256": sha256_file(image_path) if image_path.is_file() else "", + "recommended_action": _page_triage_action([str(flag) for flag in flags]), + "operator_flags": ",".join(str(flag) for flag in flags), + "line_count": str(line_count), + "review_line_count": str(review_count), + "review_ratio": f"{(review_count / line_count):.4f}" if line_count else "", + "sirijonga_count": str(_int_or_zero(counts.get("limbu_sirijonga"))), + "devanagari_count": str(_int_or_zero(counts.get("devanagari_limbu"))), + "mixed_count": str(_int_or_zero(counts.get("mixed_limbu_devanagari"))), + "other_count": str(other_count), + "other_ratio": f"{(other_count / line_count):.4f}" if line_count else "", + "suspicious_gap_count": str(_int_or_zero(layout_gap.get("suspicious_gap_count"))), + "candidate_text_gap_count": str(_int_or_zero(gap_review.get("candidate_text_gap_count"))), + "horizontal_rule_gap_count": str(_int_or_zero(gap_review.get("horizontal_rule_gap_count"))), + "max_row_gap": str(layout_gap.get("max_row_gap") or ""), + "review_status": "pending", + "operator_decision": "", + "reviewer": "", + "notes": "", + } + rows.append(row) + with queue_path.open("w", encoding="utf-8", newline="") as handle: + writer = csv.DictWriter(handle, fieldnames=PAGE_TRIAGE_REVIEW_QUEUE_HEADER, delimiter="\t", lineterminator="\n") + writer.writeheader() + writer.writerows(rows) + dashboard_card_count = _write_page_triage_dashboard(dashboard_path, queue_path, rows) + action_counts = dict(sorted((action, sum(1 for row in rows if row["recommended_action"] == action)) for action in {row["recommended_action"] for row in rows})) + return { + "page_triage_review_dir": str(packet_dir), + "page_triage_review_queue": str(queue_path), + "page_triage_review_queue_sha256": sha256_file(queue_path), + "page_triage_review_dashboard": str(dashboard_path), + "page_triage_review_dashboard_sha256": sha256_file(dashboard_path), + "page_triage_review_row_count": len(rows), + "page_triage_review_dashboard_card_count": dashboard_card_count, + "page_triage_recommended_action_counts": action_counts, + } + + +def _readme_page_table(page_summaries: list[dict[str, Any]]) -> list[str]: + if not page_summaries: + return [] + lines = [ + "Per-page counts:", + "", + "| page | page_id | lines | review | Sirijonga | Devanagari | mixed | other | audit |", + "|---:|---|---:|---:|---:|---:|---:|---:|---|", + ] + for page in page_summaries: + counts = page.get("script_counts") if isinstance(page.get("script_counts"), dict) else {} + lines.append( + "| {page_number} | `{page_id}` | {lines_count} | {review_count} | {sirijonga} | {devanagari} | {mixed} | {other} | `{audit}` |".format( + page_number=page.get("page_number") or "", + page_id=page.get("page_id") or "", + lines_count=page.get("line_count") or 0, + review_count=page.get("review_line_count") or 0, + sirijonga=counts.get("limbu_sirijonga", 0), + devanagari=counts.get("devanagari_limbu", 0), + mixed=counts.get("mixed_limbu_devanagari", 0), + other=counts.get("other", 0), + audit=page.get("audit_passed"), + ) + ) + lines.append("") + return lines + + +def _readme_operator_attention(attention_pages: list[dict[str, Any]]) -> list[str]: + if not attention_pages: + return [ + "Operator attention:", + "", + "- none", + "", + ] + lines = [ + "Operator attention:", + "", + "| page | page_id | flags | lines | review | other | max row gap |", + "|---:|---|---|---:|---:|---:|---:|", + ] + for page in attention_pages: + counts = page.get("script_counts") if isinstance(page.get("script_counts"), dict) else {} + flags = page.get("flags") if isinstance(page.get("flags"), list) else [] + layout_gap = page.get("layout_gap_summary") if isinstance(page.get("layout_gap_summary"), dict) else {} + lines.append( + "| {page_number} | `{page_id}` | `{flags}` | {lines_count} | {review_count} | {other} | {max_gap} |".format( + page_number=page.get("page_number") or "", + page_id=page.get("page_id") or "", + flags=",".join(str(flag) for flag in flags), + lines_count=page.get("line_count") or 0, + review_count=page.get("review_line_count") or 0, + other=counts.get("other", 0), + max_gap=layout_gap.get("max_row_gap", ""), + ) + ) + lines.append("") + return lines + + +def _source_manifest_counts(manifest_summary: dict[str, Any] | None) -> dict[str, Any] | None: + if manifest_summary is None: + return None + pdf_render = manifest_summary.get("pdf_render") + pdf_source: dict[str, Any] = {} + if isinstance(pdf_render, dict): + rendered_pages = pdf_render.get("rendered_pages") + pdf_source = { + "source_pdf": pdf_render.get("source_pdf"), + "source_pdf_sha256": pdf_render.get("source_pdf_sha256"), + "source_pdf_page_count": pdf_render.get("source_pdf_page_count"), + "pdf_start_page": pdf_render.get("pdf_start_page"), + "pdf_end_page": pdf_render.get("pdf_end_page"), + "pdf_dpi": pdf_render.get("pdf_dpi"), + "pdf_renderer": pdf_render.get("pdf_renderer"), + "rendered_page_count": len(rendered_pages) if isinstance(rendered_pages, list) else None, + } + return { + "source_kind": manifest_summary.get("source_kind"), + "page_count": manifest_summary.get("page_count"), + "discovered_image_count": manifest_summary.get("discovered_image_count"), + "skipped_image_count": manifest_summary.get("skipped_image_count"), + "duplicate_image_group_count": manifest_summary.get("duplicate_image_group_count"), + "skip_duplicate_images": manifest_summary.get("skip_duplicate_images"), + "include_filename_regex": manifest_summary.get("include_filename_regex"), + "exclude_filename_regex": manifest_summary.get("exclude_filename_regex"), + **pdf_source, + } + + +def _source_attention_flags(source_counts: dict[str, Any] | None) -> list[str]: + if source_counts is None: + return [] + flags: list[str] = [] + skipped_count = _int_or_zero(source_counts.get("skipped_image_count")) + duplicate_group_count = _int_or_zero(source_counts.get("duplicate_image_group_count")) + if skipped_count > 0: + flags.append("source_images_skipped") + if duplicate_group_count > 0: + if bool(source_counts.get("skip_duplicate_images")): + flags.append("duplicate_source_images_removed") + else: + flags.append("duplicate_source_images_present") + return flags + + +def _readme_source_selection(source_counts: dict[str, Any] | None, source_flags: list[str]) -> list[str]: + if source_counts is None: + return [] + if source_counts.get("source_kind") == "pdf_rendered_pages": + return [ + "Source selection:", + "", + f"- source kind: `{source_counts.get('source_kind')}`", + f"- source PDF: `{source_counts.get('source_pdf')}`", + f"- source PDF pages: `{source_counts.get('source_pdf_page_count')}`", + f"- rendered PDF window: `{source_counts.get('pdf_start_page')}..{source_counts.get('pdf_end_page')}`", + f"- rendered DPI: `{source_counts.get('pdf_dpi')}`", + f"- PDF renderer: `{source_counts.get('pdf_renderer')}`", + f"- rendered pages: `{source_counts.get('rendered_page_count')}`", + f"- pages kept for OCR: `{source_counts.get('page_count')}`", + f"- skipped rendered pages: `{source_counts.get('skipped_image_count')}`", + f"- duplicate rendered page groups: `{source_counts.get('duplicate_image_group_count')}`", + f"- source flags: `{','.join(source_flags) if source_flags else 'none'}`", + "", + ] + return [ + "Source selection:", + "", + f"- source kind: `{source_counts.get('source_kind')}`", + f"- discovered images: `{source_counts.get('discovered_image_count')}`", + f"- pages kept for OCR: `{source_counts.get('page_count')}`", + f"- skipped images: `{source_counts.get('skipped_image_count')}`", + f"- duplicate image groups: `{source_counts.get('duplicate_image_group_count')}`", + f"- skip duplicate images: `{source_counts.get('skip_duplicate_images')}`", + f"- include filename regex: `{source_counts.get('include_filename_regex')}`", + f"- exclude filename regex: `{source_counts.get('exclude_filename_regex')}`", + f"- source flags: `{','.join(source_flags) if source_flags else 'none'}`", + "", + ] + + +def _readme_page_triage(summary: dict[str, Any]) -> list[str]: + return [ + "Page triage:", + "", + f"- page triage queue: `{summary['page_triage_review_queue']}`", + f"- page triage dashboard: `{summary['page_triage_review_dashboard']}`", + f"- recommended actions: `{json.dumps(summary['page_triage_recommended_action_counts'], ensure_ascii=False, sort_keys=True)}`", + "", + ] + + +def _readme_page_layout(summary: dict[str, Any]) -> list[str]: + return [ + "Page layout review:", + "", + f"- layout review manifest: `{summary['page_layout_review_manifest']}`", + f"- layout review dashboard: `{summary['page_layout_review_dashboard']}`", + f"- overlays: `{summary['page_layout_review_overlay_count']}`", + "- inspect full-page overlays before line transcription to catch missed boxes, bad reading order, and empty OCR regions in page context", + "", + ] + + +def _readme_review_priority(summary: dict[str, Any]) -> list[str]: + focused_summary = summary.get("book_line_focused_review_summary") if isinstance(summary.get("book_line_focused_review_summary"), dict) else {} + return [ + "Line review priority:", + "", + f"- priority review queue: `{summary['book_line_priority_review_queue']}`", + f"- priority review dashboard: `{summary['book_priority_review_dashboard']}`", + f"- focused review queue: `{summary.get('book_line_focused_review_queue')}`", + f"- focused review dashboard: `{summary.get('book_focused_review_dashboard')}`", + f"- focused rows: `{focused_summary.get('row_count')}` of `{focused_summary.get('source_row_count')}` canonical review rows; omitted low-confidence spotchecks: `{focused_summary.get('omitted_low_confidence_spotcheck_count')}`", + f"- priority counts: `{json.dumps(summary.get('book_line_review_priority_counts') or {}, ensure_ascii=False, sort_keys=True)}`", + f"- recommended actions: `{json.dumps(summary.get('book_line_review_recommended_action_counts') or {}, ensure_ascii=False, sort_keys=True)}`", + "- edit the canonical queue for exhaustive review; use the focused queue as a bounded working view without hiding high-priority rows", + f"- after editing the focused queue, merge it back into a full canonical queue before application: `uv run python tools/merge_limbu_book_focused_review_queue.py {summary['book_ocr_dir']} --out {Path(str(summary['book_ocr_dir'])) / 'book-line-review-queue.with-focused-edits.tsv'}`", + "", + ] + + +def _readme_layout_gap_review(summary: dict[str, Any]) -> list[str]: + return [ + "Layout gap review:", + "", + f"- layout gap review queue: `{summary['layout_gap_review_queue']}`", + f"- layout gap review dashboard: `{summary['layout_gap_review_dashboard']}`", + f"- highlighted page contexts: `{summary.get('layout_gap_review_page_context_count')}`", + f"- priority counts: `{json.dumps(summary.get('layout_gap_review_priority_counts') or {}, ensure_ascii=False, sort_keys=True)}`", + f"- recommended actions: `{json.dumps(summary.get('layout_gap_review_recommended_action_counts') or {}, ensure_ascii=False, sort_keys=True)}`", + "- gap rows include dark-pixel ink stats and highlighted page context so likely missed text bands can be reviewed before likely blank spacing", + "", + ] + + +def _readme_browser_review_station(summary: dict[str, Any]) -> list[str]: + command = summary.get("browser_review_station_command") + if not command: + return [] + apply_command = summary.get("browser_review_station_apply_command") + training_pack_command = summary.get("browser_review_station_training_pack_command") + return [ + "Browser review station:", + "", + "Create a bounded browser review packet from this run's focused review queue:", + "", + "```bash", + str(command), + "```", + "", + "Review in the generated HTML, export `book-unresolved-review-packet.reviewed.tsv`, save it in the browser review station directory, then apply the reviewed TSV:", + "", + "```bash", + str(apply_command), + "```", + "", + "The apply command audits the reviewed TSV against the original packet directory before writing the final reviewed book projection.", + "", + "If the reviewed rows should become training input, export a reviewed-only training pack from that final projection:", + "", + "```bash", + str(training_pack_command), + "```", + "", + ] + + +def _readme_detector_profile(summary: dict[str, Any]) -> list[str]: + parse_kwargs = summary.get("detector_profile_parse_kwargs") + if not isinstance(parse_kwargs, dict): + parse_kwargs = {} + if parse_kwargs: + profile_kind = "additive rescue" if "image_line_rescue_detector_passes" in parse_kwargs else "replacement override" + else: + profile_kind = "default" + return [ + "Detector profile:", + "", + f"- active profile: `{summary.get('detector_profile')}`", + f"- profile kind: `{profile_kind}`", + f"- intent: {summary.get('detector_profile_description')}", + f"- use note: {summary.get('detector_profile_usage_note')}", + f"- profiled manifest: `{summary.get('profiled_page_manifest')}`", + "- profile evidence is operational line-preservation evidence, not a standalone OCR-quality claim", + "", + ] + _readme_detector_profile_probe(summary) + + +def _readme_detector_profile_probe(summary: dict[str, Any]) -> list[str]: + command = summary.get("detector_profile_probe_command") + if not command: + return [] + compare_command = summary.get("detector_profile_probe_compare_command") + compare_lines = [ + str(compare_command), + ] if compare_command else [ + "# compare command unavailable for this detector profile", + ] + return [ + "Optional missed-line probe from this exact source manifest:", + "", + "```bash", + str(command), + "```", + "", + "Then compare line geometry against this run before accepting added boxes as real page text:", + "", + "```bash", + *compare_lines, + "```", + "", + ] + + +def _review_application_command(out: Path) -> str: + return f"uv run python tools/apply_limbu_book_review_queues.py {out} --out {out}-reviewed" + + +def _training_pack_command(out: Path) -> str: + return f"uv run python tools/export_limbu_book_training_pack.py {out}-reviewed/final-book --out {out}-training-pack-reviewed" + + +def _browser_review_station_apply_command(summary: dict[str, Any], *, out: Path) -> str | None: + if not summary.get("browser_review_station_command"): + return None + book_output_dir = summary.get("book_ocr_dir") + if not book_output_dir: + return None + station_out = out / "browser-review-station-pending" + reviewed_tsv = station_out / "book-unresolved-review-packet.reviewed.tsv" + return _shell_command( + [ + "uv", + "run", + "python", + "tools/apply_limbu_book_unresolved_review_packet.py", + book_output_dir, + "--review-packet", + reviewed_tsv, + "--packet-dir", + station_out, + "--out", + out / "browser-review-station-applied", + ] + ) + + +def _browser_review_station_training_pack_command(summary: dict[str, Any], *, out: Path) -> str | None: + if not summary.get("browser_review_station_apply_command"): + return None + return _shell_command( + [ + "uv", + "run", + "python", + "tools/export_limbu_book_training_pack.py", + out / "browser-review-station-applied" / "final-book", + "--out", + out / "browser-review-station-training-pack-reviewed", + ] + ) + + +def _review_station_command(summary: dict[str, Any], *, out: Path) -> str | None: + focused_summary = summary.get("book_line_focused_review_summary") + focused_row_count = _int_or_zero(focused_summary.get("row_count")) if isinstance(focused_summary, dict) else 0 + review_row_count = _int_or_zero(summary.get("book_line_review_row_count")) + layout_gap_row_count = _int_or_zero(summary.get("layout_gap_review_row_count")) + if focused_row_count <= 0 and review_row_count <= 0 and layout_gap_row_count <= 0: + return None + triage_counts = summary.get("page_triage_recommended_action_counts") + if isinstance(triage_counts, dict) and ( + _int_or_zero(triage_counts.get("source_reject_candidate")) > 0 + or _int_or_zero(triage_counts.get("inspect_or_reshoot")) > 0 + ): + return None + book_output_dir = summary.get("book_ocr_dir") + review_queue = summary.get("book_line_focused_review_queue") or summary.get("book_line_priority_review_queue") or summary.get("book_line_review_queue") + if not book_output_dir or not review_queue: + return None + station_out = out / "browser-review-station-pending" + command = [ + "uv", + "run", + "python", + "tools/prepare_limbu_book_unresolved_review_packet.py", + "--book-output-dir", + book_output_dir, + "--book-line-review-queue", + review_queue, + ] + layout_gap_queue = summary.get("layout_gap_review_queue") + if layout_gap_row_count > 0 and layout_gap_queue: + command.extend(["--missing-line-review-queue", layout_gap_queue]) + command.extend(["--out", station_out]) + return _shell_command(command) + + +def _shell_command(parts: list[object]) -> str: + return " ".join(shlex.quote(str(part)) for part in parts) + + +def _append_value_option(parts: list[object], option: str, value: object | None) -> None: + if value is not None: + parts.extend([option, value]) + + +def _append_true_flag(parts: list[object], option: str, enabled: object) -> None: + if bool(enabled): + parts.append(option) + + +def _detector_profile_probe_command(args: argparse.Namespace, *, raw_page_manifest: Path, out: Path) -> str | None: + profile_name = str(getattr(args, "detector_profile", "current") or "current") + if profile_name != "current": + return None + probe_out = Path(f"{out}-current-plus-balanced-rescue") + parts: list[object] = [ + "/tmp/ocrtech-paddle311/bin/python", + "tools/run_limbu_book_ocr.py", + "--page-manifest", + raw_page_manifest, + "--out", + probe_out, + "--engine", + getattr(args, "engine", "candidate"), + "--model-config", + getattr(args, "model_config", None) or DEFAULT_MODEL_CONFIG, + "--detector-profile", + "current-plus-balanced-rescue", + ] + _append_value_option(parts, "--fallback-engine", getattr(args, "fallback_engine", None)) + _append_value_option(parts, "--fallback-model-config", getattr(args, "fallback_model_config", None)) + _append_value_option(parts, "--rotate-degrees", getattr(args, "rotate_degrees", None)) + _append_value_option(parts, "--crop-box", getattr(args, "crop_box", None)) + _append_value_option(parts, "--perspective-quad", getattr(args, "perspective_quad", None)) + _append_true_flag(parts, "--auto-detect-page", getattr(args, "auto_detect_page", False)) + if getattr(args, "auto_deskew", True) is False: + parts.append("--no-auto-deskew") + _append_value_option(parts, "--max-auto-deskew-degrees", getattr(args, "max_auto_deskew_degrees", None)) + _append_true_flag(parts, "--no-autocontrast", getattr(args, "no_autocontrast", False)) + _append_true_flag(parts, "--no-grayscale", getattr(args, "no_grayscale", False)) + _append_value_option(parts, "--min-prepared-width", getattr(args, "min_prepared_width", None)) + _append_value_option(parts, "--min-prepared-height", getattr(args, "min_prepared_height", None)) + _append_value_option(parts, "--min-prepared-entropy", getattr(args, "min_prepared_entropy", None)) + _append_value_option(parts, "--min-prepared-luminance-stddev", getattr(args, "min_prepared_luminance_stddev", None)) + _append_value_option(parts, "--min-prepared-edge-stddev", getattr(args, "min_prepared_edge_stddev", None)) + _append_value_option(parts, "--min-prepared-laplacian-variance", getattr(args, "min_prepared_laplacian_variance", None)) + _append_true_flag(parts, "--require-auto-detect-page", getattr(args, "require_auto_detect_page", False)) + _append_value_option(parts, "--min-auto-detect-page-area-ratio", getattr(args, "min_auto_detect_page_area_ratio", None)) + _append_true_flag(parts, "--fail-on-auto-detect-page-border-touch", getattr(args, "fail_on_auto_detect_page_border_touch", False)) + _append_true_flag(parts, "--require-auto-deskew-applied", getattr(args, "require_auto_deskew_applied", False)) + _append_value_option(parts, "--max-abs-auto-deskew-degrees", getattr(args, "max_abs_auto_deskew_degrees", None)) + if getattr(args, "preserve_page_lines", True) is False: + parts.append("--no-preserve-page-lines") + if getattr(args, "line_assembly", False): + parts.append("--line-assembly") + _append_value_option(parts, "--line-assembly-y-tolerance", getattr(args, "line_assembly_y_tolerance", None)) + _append_value_option(parts, "--line-assembly-max-gap", getattr(args, "line_assembly_max_gap", None)) + _append_value_option(parts, "--line-assembly-max-merged-width", getattr(args, "line_assembly_max_merged_width", None)) + _append_value_option(parts, "--line-assembly-max-merged-width-ratio", getattr(args, "line_assembly_max_merged_width_ratio", None)) + _append_value_option(parts, "--line-assembly-max-component-width", getattr(args, "line_assembly_max_component_width", None)) + _append_value_option(parts, "--line-assembly-max-component-width-ratio", getattr(args, "line_assembly_max_component_width_ratio", None)) + _append_value_option(parts, "--line-assembly-min-vertical-overlap-ratio", getattr(args, "line_assembly_min_vertical_overlap_ratio", None)) + _append_value_option(parts, "--line-assembly-joiner", getattr(args, "line_assembly_joiner", None)) + if getattr(args, "line_assembly_require_text_structural_role", True) is False: + parts.append("--no-line-assembly-require-text-structural-role") + _append_value_option(parts, "--reading-order-profile-map", getattr(args, "reading_order_profile_map", None)) + _append_value_option(parts, "--reading-order-profile-map-audit", getattr(args, "reading_order_profile_map_audit", None)) + _append_true_flag(parts, "--require-reading-order-profile-safe", getattr(args, "require_reading_order_profile_safe", False)) + _append_true_flag(parts, "--require-reading-order-profile-map-safe", getattr(args, "require_reading_order_profile_map_safe", False)) + _append_value_option(parts, "--reading-order-profile-x-scale", getattr(args, "reading_order_profile_x_scale", None)) + _append_value_option(parts, "--reading-order-profile-y-scale", getattr(args, "reading_order_profile_y_scale", None)) + _append_value_option(parts, "--reading-order-profile-outside-weight", getattr(args, "reading_order_profile_outside_weight", None)) + if getattr(args, "skip_book_audit", False): + parts.append("--skip-book-audit") + return _shell_command(parts) + + +def _detector_profile_probe_compare_command(args: argparse.Namespace, *, out: Path) -> str | None: + profile_name = str(getattr(args, "detector_profile", "current") or "current") + if profile_name != "current": + return None + probe_out = Path(f"{out}-current-plus-balanced-rescue") + delta_out = Path(f"{out}-current-plus-balanced-rescue-line-geometry-delta-review") + return _shell_command( + [ + "uv", + "run", + "python", + "tools/compare_limbu_book_line_geometry.py", + "--baseline-run", + out, + "--candidate-run", + probe_out, + "--out", + delta_out, + ] + ) + + +def _readme_review_application(summary: dict[str, Any]) -> list[str]: + return [ + "After review:", + "", + "Edit the review queues, then write the final reviewed book projection:", + "", + "```bash", + str(summary["review_application_command"]), + "```", + "", + "Before running this, inspect `page-triage-review-queue.tsv`; set `operator_decision=reject`, `reshoot`, or `drop` for bad source pages that should not enter the reviewed book.", + "", + "The command applies explicit page-triage decisions first, then book-line corrections, then accepted layout-gap insertions, and writes the reviewed book under `final-book/` in the output directory.", + "", + "Then export explicitly reviewed lines into a recognizer-training pack:", + "", + "```bash", + str(summary["training_pack_command"]), + "```", + "", + "This exporter excludes unreviewed OCR rows by default. Use `--include-unreviewed` only for bootstrap diagnostics, not training truth.", + "", + "For the browser review-station path that audits an exported reviewed TSV, applies it, audits the final book, and exports reviewed-only training rows, follow `docs/LIMBU_REVIEW_TO_TRAINING_RUNBOOK.md`.", + "", + ] + + +def _relative_href(path_value: str, *, base_dir: Path) -> str: + path = Path(path_value) + if path.is_absolute(): + try: + return path.relative_to(base_dir.resolve()).as_posix() + except ValueError: + return path.as_uri() + try: + return path.relative_to(base_dir).as_posix() + except ValueError: + return Path(os.path.relpath(path, start=base_dir)).as_posix() + + +def _document_layout_lines(document_json: Path) -> tuple[list[dict[str, Any]], dict[str, Any], str | None]: + try: + payload = json.loads(document_json.read_text(encoding="utf-8")) + except (OSError, json.JSONDecodeError) as exc: + return [], {}, f"could not read document geometry: {type(exc).__name__}: {exc}" + if not isinstance(payload, dict): + return [], {}, "document.json root is not an object" + pages = payload.get("pages") + if not isinstance(pages, list) or not pages or not isinstance(pages[0], dict): + return [], {}, "document.json has no page object" + page = pages[0] + page_metadata = page.get("metadata") if isinstance(page.get("metadata"), dict) else {} + image_line_ocr = page_metadata.get("image_line_ocr") if isinstance(page_metadata.get("image_line_ocr"), dict) else {} + lines = page.get("text_lines") + if not isinstance(lines, list): + return [], image_line_ocr, "document.json text_lines is not a list" + rows: list[dict[str, Any]] = [] + for index, line in enumerate(lines): + if not isinstance(line, dict): + continue + bbox = line.get("bbox") + if not isinstance(bbox, list | tuple) or len(bbox) != 4: + continue + x = _number_or_none(bbox[0]) + y = _number_or_none(bbox[1]) + w = _number_or_none(bbox[2]) + h = _number_or_none(bbox[3]) + if x is None or y is None or w is None or h is None or w <= 0 or h <= 0: + continue + metadata = line.get("metadata") if isinstance(line.get("metadata"), dict) else {} + pipeline = metadata.get("limbu_pipeline") if isinstance(metadata.get("limbu_pipeline"), dict) else {} + rows.append( + { + "index": index, + "line_id": str(line.get("line_id") or ""), + "bbox": [x, y, w, h], + "text": str(line.get("text") or ""), + "confidence": _number_or_none(line.get("confidence")), + "needs_review": bool(pipeline.get("needs_review", False)), + "structural_role": str(metadata.get("structural_role") or "text"), + } + ) + return rows, image_line_ocr, None + + +def _line_overlay_color(line: dict[str, Any]) -> tuple[int, int, int]: + if not str(line.get("text") or "").strip(): + return (220, 38, 38) + if bool(line.get("needs_review")): + return (245, 158, 11) + if str(line.get("structural_role") or "text") != "text": + return (79, 70, 229) + return (22, 163, 74) + + +def _write_page_layout_overlay( + *, + image_path: Path, + document_json: Path, + overlay_path: Path, +) -> tuple[dict[str, Any], str | None]: + try: + from PIL import Image, ImageDraw, ImageFont + except ImportError as exc: + return {}, f"Pillow unavailable: {exc}" + if not image_path.is_file(): + return {}, f"image_path missing: {image_path}" + if not document_json.is_file(): + return {}, f"document_json missing: {document_json}" + lines, image_line_ocr, warning = _document_layout_lines(document_json) + if warning: + return {}, warning + try: + with Image.open(image_path) as source_image: + image = source_image.convert("RGB") + except OSError as exc: + return {}, f"could not open page image: {type(exc).__name__}: {exc}" + max_width = 1800 + scale = min(1.0, max_width / image.width) if image.width > 0 else 1.0 + if scale < 1.0: + image = image.resize((max(1, int(round(image.width * scale))), max(1, int(round(image.height * scale))))) + draw = ImageDraw.Draw(image) + try: + font = ImageFont.load_default() + except OSError: + font = None + for line in lines: + x, y, w, h = [float(value) * scale for value in line["bbox"]] + color = _line_overlay_color(line) + draw.rectangle([x, y, x + w, y + h], outline=color, width=max(2, int(round(2 * scale)))) + label = str(int(line["index"]) + 1) + label_x = max(0, int(round(x))) + label_y = max(0, int(round(y - 12))) + if font is not None: + box = draw.textbbox((label_x, label_y), label, font=font) + draw.rectangle(box, fill=color) + draw.text((label_x, label_y), label, fill="white", font=font) + else: + draw.text((label_x, label_y), label, fill=color) + overlay_path.parent.mkdir(parents=True, exist_ok=True) + image.save(overlay_path) + empty_line_count = sum(1 for line in lines if not str(line.get("text") or "").strip()) + review_line_count = sum(1 for line in lines if bool(line.get("needs_review"))) + return ( + { + "line_count": len(lines), + "empty_line_count": empty_line_count, + "review_line_count": review_line_count, + "reading_order": str(image_line_ocr.get("reading_order") or ""), + "overlay_size": list(image.size), + }, + None, + ) + + +def _write_page_layout_review_dashboard(path: Path, manifest_path: Path, rows: list[dict[str, str]]) -> int: + cards: list[str] = [] + for row in rows: + overlay_path = str(row.get("overlay_path") or "") + if overlay_path and Path(overlay_path).is_file(): + href = _relative_href(overlay_path, base_dir=path.parent) + overlay_markup = f'{html.escape(row[' + else: + overlay_markup = '
No layout overlay available.
' + tsv_row = "\t".join(str(row.get(field) or "") for field in PAGE_LAYOUT_REVIEW_MANIFEST_HEADER) + cards.append( + f"""
+
{overlay_markup}
+
+
+ page {html.escape(row['book_page_number'])}: {html.escape(row['book_page_id'])} + lines {html.escape(row['line_count'])} + empty {html.escape(row['empty_line_count'])} + review {html.escape(row['review_line_count'])} + order {html.escape(row['reading_order'] or 'unknown')} +
+
+
operator flags
{html.escape(row['operator_flags'] or 'none')}
+
image
{html.escape(row['image_path'])}
+
document
{html.escape(row['document_json'])}
+
notes
{html.escape(row['notes'])}
+
+ +
+
""" + ) + page = f""" + + + + + Limbu Book OCR Page Layout Review + + + +
+

Limbu Book OCR Page Layout Review

+

Rows mirror {html.escape(manifest_path.name)}. Box colors: green accepted text, amber review text, red empty OCR, purple structural text. Inspect this before line-level transcription.

+
+
+ {"".join(cards)} +
+ + +""" + path.write_text(page, encoding="utf-8") + return len(cards) + + +def _write_page_layout_review_packet(out: Path, page_summaries: list[dict[str, Any]]) -> dict[str, Any]: + packet_dir = out / "page-layout-review" + overlays_dir = packet_dir / "overlays" + manifest_path = packet_dir / "page-layout-review-manifest.tsv" + dashboard_path = packet_dir / "page-layout-review-dashboard.html" + packet_dir.mkdir(parents=True, exist_ok=True) + rows: list[dict[str, str]] = [] + for page in page_summaries: + page_number = _int_or_zero(page.get("page_number")) + page_id = str(page.get("page_id") or "") + layout_page_id = "layout-{page_number:04d}-{page_id}".format( + page_number=page_number, + page_id=_safe_name(page_id), + ) + image_path = Path(str(page.get("image_path") or "")) + document_json = Path(str(page.get("book_document_json") or "")) + overlay_path = overlays_dir / f"{layout_page_id}.png" + overlay_summary, warning = _write_page_layout_overlay( + image_path=image_path, + document_json=document_json, + overlay_path=overlay_path, + ) + flags = page.get("operator_flags") if isinstance(page.get("operator_flags"), list) else [] + row = { + "layout_page_id": layout_page_id, + "book_page_number": str(page.get("page_number") or ""), + "book_page_id": page_id, + "image_path": str(image_path), + "image_sha256": sha256_file(image_path) if image_path.is_file() else "", + "document_json": str(document_json), + "document_json_sha256": sha256_file(document_json) if document_json.is_file() else "", + "overlay_path": str(overlay_path) if overlay_path.is_file() else "", + "overlay_sha256": sha256_file(overlay_path) if overlay_path.is_file() else "", + "line_count": str(overlay_summary.get("line_count", page.get("line_count") or "")), + "empty_line_count": str(overlay_summary.get("empty_line_count", "")), + "review_line_count": str(overlay_summary.get("review_line_count", page.get("review_line_count") or "")), + "reading_order": str(overlay_summary.get("reading_order") or ""), + "operator_flags": ",".join(str(flag) for flag in flags), + "notes": warning or "", + } + rows.append(row) + with manifest_path.open("w", encoding="utf-8", newline="") as handle: + writer = csv.DictWriter(handle, fieldnames=PAGE_LAYOUT_REVIEW_MANIFEST_HEADER, delimiter="\t", lineterminator="\n") + writer.writeheader() + writer.writerows(rows) + dashboard_card_count = _write_page_layout_review_dashboard(dashboard_path, manifest_path, rows) + overlay_count = sum(1 for row in rows if row.get("overlay_path")) + return { + "page_layout_review_dir": str(packet_dir), + "page_layout_review_manifest": str(manifest_path), + "page_layout_review_manifest_sha256": sha256_file(manifest_path), + "page_layout_review_dashboard": str(dashboard_path), + "page_layout_review_dashboard_sha256": sha256_file(dashboard_path), + "page_layout_review_row_count": len(rows), + "page_layout_review_overlay_count": overlay_count, + "page_layout_review_dashboard_card_count": dashboard_card_count, + } + + +def _write_gap_crop( + image_path: Path, + crop_path: Path, + *, + from_y: float, + to_y: float, + padding: int = GAP_REVIEW_CROP_PADDING, +) -> tuple[str | None, str | None]: + try: + from PIL import Image + except ImportError as exc: + return None, f"Pillow unavailable: {exc}" + if not image_path.is_file(): + return None, f"image_path missing: {image_path}" + try: + with Image.open(image_path) as image: + width, height = image.size + top = max(0, int(round(from_y)) - padding) + bottom = min(height, int(round(to_y)) + padding) + if bottom <= top: + return None, f"empty gap crop bounds: from_y={from_y} to_y={to_y} image_height={height}" + crop_path.parent.mkdir(parents=True, exist_ok=True) + image.crop((0, top, width, bottom)).save(crop_path) + except OSError as exc: + return None, f"could not crop gap image: {type(exc).__name__}: {exc}" + return sha256_file(crop_path), None + + +def _gap_ink_stats( + image_path: Path, + *, + from_y: float, + to_y: float, + dark_threshold: int = 210, +) -> tuple[dict[str, str], str | None]: + try: + from PIL import Image + except ImportError as exc: + return _empty_gap_ink_stats(), f"Pillow unavailable for ink stats: {exc}" + if not image_path.is_file(): + return _empty_gap_ink_stats(), f"image_path missing for ink stats: {image_path}" + try: + with Image.open(image_path) as source: + image = source.convert("L") + width, height = image.size + top = max(0, int(round(from_y))) + bottom = min(height, int(round(to_y))) + if bottom <= top: + return _empty_gap_ink_stats(), f"empty gap ink bounds: from_y={from_y} to_y={to_y} image_height={height}" + band = image.crop((0, top, width, bottom)) + dark_mask = band.point(lambda pixel: 255 if pixel < dark_threshold else 0, mode="L") + histogram = dark_mask.histogram() + dark_pixels = int(histogram[255]) + total_pixels = max(1, band.width * band.height) + ink_bbox = dark_mask.getbbox() + row_bands = _gap_ink_row_bands(dark_mask, page_y_offset=top) + except OSError as exc: + return _empty_gap_ink_stats(), f"could not inspect gap ink: {type(exc).__name__}: {exc}" + page_bbox = "" + if ink_bbox is not None: + left, local_top, right, local_bottom = ink_bbox + page_bbox = json.dumps([left, top + local_top, right, top + local_bottom], separators=(",", ":")) + candidate_text_band_count = sum(1 for row in row_bands if row.get("kind") == "candidate_text_band") + horizontal_rule_count = sum(1 for row in row_bands if row.get("kind") == "horizontal_rule") + page_graphic_band_count = sum(1 for row in row_bands if row.get("kind") == "page_graphic_or_illustration") + return ( + { + "gap_ink_dark_pixel_count": str(dark_pixels), + "gap_ink_density": f"{dark_pixels / total_pixels:.6f}", + "gap_ink_bbox": page_bbox, + "gap_ink_row_bands": json.dumps(row_bands, ensure_ascii=False, separators=(",", ":")), + "gap_candidate_text_band_count": str(candidate_text_band_count), + "gap_horizontal_rule_count": str(horizontal_rule_count), + "gap_page_graphic_band_count": str(page_graphic_band_count), + }, + None, + ) + + +def _empty_gap_ink_stats() -> dict[str, str]: + return { + "gap_ink_dark_pixel_count": "", + "gap_ink_density": "", + "gap_ink_bbox": "", + "gap_ink_row_bands": "", + "gap_candidate_text_band_count": "", + "gap_horizontal_rule_count": "", + "gap_page_graphic_band_count": "", + } + + +def _gap_ink_row_bands(dark_mask: Any, *, page_y_offset: int, max_row_gap: int = 2) -> list[dict[str, Any]]: + width, _height = dark_mask.size + rows: list[tuple[int, int, tuple[int, int, int, int] | None]] = [] + for y in range(dark_mask.height): + row = dark_mask.crop((0, y, width, y + 1)) + bbox = row.getbbox() + if bbox is None: + continue + histogram = row.histogram() + rows.append((y, int(histogram[255]), bbox)) + clusters: list[list[tuple[int, int, tuple[int, int, int, int] | None]]] = [] + current: list[tuple[int, int, tuple[int, int, int, int] | None]] = [] + previous_y: int | None = None + for row in rows: + y = row[0] + if previous_y is None or y <= previous_y + max_row_gap: + current.append(row) + else: + clusters.append(current) + current = [row] + previous_y = y + if current: + clusters.append(current) + bands: list[dict[str, Any]] = [] + for cluster in clusters: + ys = [item[0] for item in cluster] + dark_pixels = sum(item[1] for item in cluster) + row_bboxes = [item[2] for item in cluster if item[2] is not None] + left = min(bbox[0] for bbox in row_bboxes) + right = max(bbox[2] for bbox in row_bboxes) + top = min(ys) + bottom = max(ys) + 1 + band_width = right - left + band_height = bottom - top + max_row_dark = max(item[1] for item in cluster) + width_ratio = band_width / width if width > 0 else 0.0 + band_area = max(1, band_width * band_height) + band_density = dark_pixels / band_area + kind = _gap_ink_band_kind( + band_height=band_height, + width_ratio=width_ratio, + band_density=band_density, + dark_pixels=dark_pixels, + max_row_dark=max_row_dark, + page_width=width, + ) + bands.append( + { + "from_y": page_y_offset + top, + "to_y": page_y_offset + bottom, + "height": band_height, + "dark_pixels": dark_pixels, + "max_row_dark": max_row_dark, + "bbox": [left, page_y_offset + top, right, page_y_offset + bottom], + "width_ratio": round(width_ratio, 4), + "density": round(band_density, 6), + "kind": kind, + } + ) + return bands + + +def _gap_ink_band_kind( + *, + band_height: int, + width_ratio: float, + band_density: float, + dark_pixels: int, + max_row_dark: int, + page_width: int, +) -> str: + row_span_ratio = max_row_dark / page_width if page_width > 0 else 0.0 + if band_height <= 8 and width_ratio >= 0.45 and max_row_dark >= 64: + return "horizontal_rule" + if ( + 24 <= band_height <= 72 + and width_ratio >= 0.45 + and row_span_ratio >= 0.30 + and 0.015 <= band_density <= 0.45 + ): + return "page_graphic_or_illustration" + if band_height >= 96 and width_ratio >= 0.25 and dark_pixels >= 1000 and band_density >= 0.01: + return "page_graphic_or_illustration" + if band_height >= 12 and dark_pixels >= 32 and band_density >= 0.001: + return "candidate_text_band" + return "sparse_ink" + + +def _gap_review_guidance(ink_stats: dict[str, str]) -> dict[str, str]: + try: + dark_pixels = int(ink_stats.get("gap_ink_dark_pixel_count") or 0) + density = float(ink_stats.get("gap_ink_density") or 0.0) + candidate_text_bands = int(ink_stats.get("gap_candidate_text_band_count") or 0) + horizontal_rules = int(ink_stats.get("gap_horizontal_rule_count") or 0) + page_graphics = int(ink_stats.get("gap_page_graphic_band_count") or 0) + except (TypeError, ValueError): + return { + "gap_review_priority": "medium", + "gap_recommended_action": "inspect_gap_crop", + } + if candidate_text_bands > 0: + return { + "gap_review_priority": "high", + "gap_recommended_action": "inspect_possible_text_ink", + } + if horizontal_rules > 0: + return { + "gap_review_priority": "low", + "gap_recommended_action": "likely_rule_or_spacing", + } + if page_graphics > 0: + return { + "gap_review_priority": "medium", + "gap_recommended_action": "inspect_page_graphic_or_illustration", + } + if dark_pixels >= 32 and density >= 0.00025: + return { + "gap_review_priority": "medium", + "gap_recommended_action": "inspect_sparse_ink", + } + return { + "gap_review_priority": "low", + "gap_recommended_action": "likely_blank_spacing", + } + + +def _json_string_list(values: list[str]) -> str: + return json.dumps(values, ensure_ascii=False, separators=(",", ":")) + + +def _json_cell_string_list(value: str) -> list[str]: + if not value.strip(): + return [] + try: + payload = json.loads(value) + except json.JSONDecodeError: + return [] + if not isinstance(payload, list): + return [] + return [str(item) for item in payload if isinstance(item, str)] + + +def _write_gap_candidate_band_crops( + *, + image_path: Path, + crops_dir: Path, + gap_row_id: str, + row_bands_json: str, + padding: int = GAP_REVIEW_CROP_PADDING, +) -> tuple[list[str], list[str], list[str]]: + if not row_bands_json: + return [], [], [] + try: + row_bands = json.loads(row_bands_json) + except json.JSONDecodeError as exc: + return [], [], [f"gap ink row bands JSON invalid: {exc}"] + if not isinstance(row_bands, list): + return [], [], ["gap ink row bands JSON is not a list"] + candidate_bands = [ + band + for band in row_bands + if isinstance(band, dict) and band.get("kind") == "candidate_text_band" + ] + if not candidate_bands: + return [], [], [] + try: + from PIL import Image + except ImportError as exc: + return [], [], [f"Pillow unavailable for candidate band crops: {exc}"] + if not image_path.is_file(): + return [], [], [f"image_path missing for candidate band crops: {image_path}"] + crop_paths: list[str] = [] + crop_sha256s: list[str] = [] + warnings: list[str] = [] + try: + with Image.open(image_path) as image: + width, height = image.size + for index, band in enumerate(candidate_bands, start=1): + bbox = band.get("bbox") + if not isinstance(bbox, list | tuple) or len(bbox) != 4: + warnings.append(f"candidate band {index} missing bbox") + continue + try: + left = max(0, int(round(float(bbox[0]))) - padding) + top = max(0, int(round(float(bbox[1]))) - padding) + right = min(width, int(round(float(bbox[2]))) + padding) + bottom = min(height, int(round(float(bbox[3]))) + padding) + except (TypeError, ValueError) as exc: + warnings.append(f"candidate band {index} invalid bbox: {exc}") + continue + if right <= left or bottom <= top: + warnings.append(f"candidate band {index} empty crop bounds") + continue + crop_path = crops_dir / f"{gap_row_id}-candidate-band-{index:02d}.png" + crop_path.parent.mkdir(parents=True, exist_ok=True) + image.crop((left, top, right, bottom)).save(crop_path) + crop_paths.append(str(crop_path)) + crop_sha256s.append(sha256_file(crop_path)) + except OSError as exc: + return crop_paths, crop_sha256s, [*warnings, f"could not crop candidate bands: {type(exc).__name__}: {exc}"] + return crop_paths, crop_sha256s, warnings + + +def _write_gap_page_context( + *, + image_path: Path, + context_path: Path, + from_y: float, + to_y: float, + max_width: int = 1600, +) -> tuple[str | None, str | None]: + try: + from PIL import Image, ImageDraw + except ImportError as exc: + return None, f"Pillow unavailable for gap page context: {exc}" + if not image_path.is_file(): + return None, f"image_path missing for gap page context: {image_path}" + try: + with Image.open(image_path) as source_image: + image = source_image.convert("RGBA") + scale = min(1.0, max_width / image.width) if image.width > 0 else 1.0 + if scale < 1.0: + image = image.resize((max(1, int(round(image.width * scale))), max(1, int(round(image.height * scale))))) + top = max(0, min(image.height, int(round(from_y * scale)))) + bottom = max(0, min(image.height, int(round(to_y * scale)))) + if bottom <= top: + return None, f"invalid gap page context bounds: from_y={from_y} to_y={to_y}" + draw = ImageDraw.Draw(image, "RGBA") + draw.rectangle([0, top, image.width - 1, bottom], fill=(245, 158, 11, 72), outline=(185, 28, 28, 255), width=3) + context_path.parent.mkdir(parents=True, exist_ok=True) + image.convert("RGB").save(context_path) + except OSError as exc: + return None, f"could not write gap page context: {type(exc).__name__}: {exc}" + return sha256_file(context_path), None + + +def _write_gap_review_dashboard(path: Path, queue_path: Path, rows: list[dict[str, str]]) -> int: + cards: list[str] = [] + for row in rows: + crop_path = str(row.get("crop_path") or "") + if crop_path and Path(crop_path).is_file(): + href = _relative_href(crop_path, base_dir=path.parent) + crop_markup = f'{html.escape(row[' + else: + crop_markup = '
No crop available.
' + page_context_path = str(row.get("page_context_path") or "") + if page_context_path and Path(page_context_path).is_file(): + href = _relative_href(page_context_path, base_dir=path.parent) + context_markup = f'{html.escape(row[' + else: + context_markup = '
No page context available.
' + candidate_crop_paths = _json_cell_string_list(str(row.get("gap_candidate_text_band_crop_paths") or "")) + candidate_markup_parts: list[str] = [] + for index, candidate_path in enumerate(candidate_crop_paths, start=1): + path_obj = Path(candidate_path) + if not path_obj.is_file(): + candidate_markup_parts.append(f'
Missing candidate band crop {index}: {html.escape(candidate_path)}
') + continue + href = _relative_href(str(path_obj), base_dir=path.parent) + candidate_markup_parts.append( + f'{html.escape(row[' + ) + candidate_markup = "\n".join(candidate_markup_parts) if candidate_markup_parts else '
No candidate text-band crop.
' + tsv_row = "\t".join(str(row.get(field) or "") for field in GAP_REVIEW_QUEUE_HEADER) + cards.append( + f"""
+
+
Gap crop
{crop_markup}
+
Page context
{context_markup}
+
+
+
+ page {html.escape(row['book_page_number'])}: {html.escape(row['book_page_id'])} + gap {html.escape(row['gap'])} + threshold {html.escape(row['threshold'])} + {html.escape(row.get('gap_review_priority') or 'priority?')} +
+
+
gap_row_id
{html.escape(row['gap_row_id'])}
+
region
y={html.escape(row['from_y'])}..{html.escape(row['to_y'])}
+
ink
{html.escape(row.get('gap_ink_dark_pixel_count') or '')} dark pixels, density {html.escape(row.get('gap_ink_density') or '')}
+
bands
{html.escape(row.get('gap_candidate_text_band_count') or '')} candidate text, {html.escape(row.get('gap_horizontal_rule_count') or '')} horizontal rules, {html.escape(row.get('gap_page_graphic_band_count') or '')} page graphics
+
candidate crops
{candidate_markup}
+
action
{html.escape(row.get('gap_recommended_action') or '')}
+
status
{html.escape(row['review_status'])}
+
corrected_text
{html.escape(row['corrected_text'])}
+
+ +
+
""" + ) + empty_markup = '
No suspicious line-geometry gaps.
' if not cards else "" + page = f""" + + + + + Limbu Book OCR Gap Review + + + +
+

Limbu Book OCR Gap Review

+

Rows mirror {html.escape(queue_path.name)}; inspect each crop band before deciding whether a missed line must be inserted.

+
+
+ {empty_markup} + {"".join(cards)} +
+ + +""" + path.write_text(page, encoding="utf-8") + return len(cards) + + +def _write_layout_gap_review_packet(out: Path, page_summaries: list[dict[str, Any]]) -> dict[str, Any]: + packet_dir = out / "layout-gap-review" + crops_dir = packet_dir / "crops" + contexts_dir = packet_dir / "page-contexts" + queue_path = packet_dir / "layout-gap-review-queue.tsv" + dashboard_path = packet_dir / "layout-gap-review-dashboard.html" + packet_dir.mkdir(parents=True, exist_ok=True) + rows: list[dict[str, str]] = [] + page_gap_rows: dict[str, list[dict[str, str]]] = {} + for page in page_summaries: + layout_gap = page.get("layout_gap_summary") if isinstance(page.get("layout_gap_summary"), dict) else {} + suspicious_gaps = layout_gap.get("suspicious_gaps") if isinstance(layout_gap.get("suspicious_gaps"), list) else [] + image_path = Path(str(page.get("image_path") or "")) + for gap_index, gap in enumerate(suspicious_gaps, start=1): + if not isinstance(gap, dict): + continue + gap_row_id = "gap-{page_number:04d}-{page_id}-{gap_index:03d}".format( + page_number=_int_or_zero(page.get("page_number")), + page_id=_safe_name(page.get("page_id")), + gap_index=gap_index, + ) + crop_path = crops_dir / f"{gap_row_id}.png" + from_y = float(gap.get("from_y") or 0.0) + to_y = float(gap.get("to_y") or 0.0) + crop_sha256, crop_warning = _write_gap_crop(image_path, crop_path, from_y=from_y, to_y=to_y) + page_context_path = contexts_dir / f"{gap_row_id}.png" + page_context_sha256, page_context_warning = _write_gap_page_context( + image_path=image_path, + context_path=page_context_path, + from_y=from_y, + to_y=to_y, + ) + ink_stats, ink_warning = _gap_ink_stats(image_path, from_y=from_y, to_y=to_y) + candidate_band_paths, candidate_band_sha256s, candidate_band_warnings = _write_gap_candidate_band_crops( + image_path=image_path, + crops_dir=crops_dir, + gap_row_id=gap_row_id, + row_bands_json=ink_stats.get("gap_ink_row_bands", ""), + ) + guidance = _gap_review_guidance(ink_stats) + notes = "; ".join(warning for warning in (crop_warning, page_context_warning, ink_warning, *candidate_band_warnings) if warning) + row = { + "gap_row_id": gap_row_id, + "book_page_number": str(page.get("page_number") or ""), + "book_page_id": str(page.get("page_id") or ""), + "image_path": str(image_path), + "gap_index": str(gap_index), + "from_y": str(gap.get("from_y") or ""), + "to_y": str(gap.get("to_y") or ""), + "gap": str(gap.get("gap") or ""), + "threshold": str(gap.get("threshold") or ""), + "page_height_ratio": str(gap.get("page_height_ratio") or ""), + **ink_stats, + "gap_candidate_text_band_crop_paths": _json_string_list(candidate_band_paths), + "gap_candidate_text_band_crop_sha256s": _json_string_list(candidate_band_sha256s), + **guidance, + "crop_path": str(crop_path) if crop_sha256 else "", + "crop_sha256": crop_sha256 or "", + "page_context_path": str(page_context_path) if page_context_sha256 else "", + "page_context_sha256": page_context_sha256 or "", + "review_status": "pending", + "insert_after_row_index": str(gap.get("after_row_index", "")), + "corrected_text": "", + "reviewer": "", + "notes": notes, + } + rows.append(row) + page_gap_rows.setdefault(str(page.get("page_id") or ""), []).append(row) + with queue_path.open("w", encoding="utf-8", newline="") as handle: + writer = csv.DictWriter(handle, fieldnames=GAP_REVIEW_QUEUE_HEADER, delimiter="\t", lineterminator="\n") + writer.writeheader() + for row in rows: + writer.writerow(row) + dashboard_card_count = _write_gap_review_dashboard(dashboard_path, queue_path, rows) + priority_counts = dict( + sorted( + ( + priority, + sum(1 for row in rows if row.get("gap_review_priority") == priority), + ) + for priority in {row.get("gap_review_priority", "") for row in rows if row.get("gap_review_priority")} + ) + ) + action_counts = dict( + sorted( + ( + action, + sum(1 for row in rows if row.get("gap_recommended_action") == action), + ) + for action in {row.get("gap_recommended_action", "") for row in rows if row.get("gap_recommended_action")} + ) + ) + page_review_summaries: list[dict[str, Any]] = [] + for page in page_summaries: + page_id = str(page.get("page_id") or "") + page_rows = page_gap_rows.get(page_id, []) + page_priority_counts = dict( + sorted( + ( + priority, + sum(1 for row in page_rows if row.get("gap_review_priority") == priority), + ) + for priority in {row.get("gap_review_priority", "") for row in page_rows if row.get("gap_review_priority")} + ) + ) + page_action_counts = dict( + sorted( + ( + action, + sum(1 for row in page_rows if row.get("gap_recommended_action") == action), + ) + for action in {row.get("gap_recommended_action", "") for row in page_rows if row.get("gap_recommended_action")} + ) + ) + page_review_summaries.append( + { + "book_page_id": page_id, + "gap_count": len(page_rows), + "candidate_text_gap_count": sum( + 1 + for row in page_rows + if _int_or_zero(row.get("gap_candidate_text_band_count")) > 0 + ), + "horizontal_rule_gap_count": sum( + 1 + for row in page_rows + if _int_or_zero(row.get("gap_horizontal_rule_count")) > 0 + ), + "priority_counts": page_priority_counts, + "recommended_action_counts": page_action_counts, + } + ) + return { + "layout_gap_review_dir": str(packet_dir), + "layout_gap_review_queue": str(queue_path), + "layout_gap_review_queue_sha256": sha256_file(queue_path), + "layout_gap_review_dashboard": str(dashboard_path), + "layout_gap_review_dashboard_sha256": sha256_file(dashboard_path), + "layout_gap_review_row_count": len(rows), + "layout_gap_review_dashboard_card_count": dashboard_card_count, + "layout_gap_review_page_context_count": sum(1 for row in rows if row.get("page_context_path")), + "layout_gap_review_priority_counts": priority_counts, + "layout_gap_review_recommended_action_counts": action_counts, + "layout_gap_review_page_summaries": page_review_summaries, + } + + +def _source_page_manifest(args: argparse.Namespace, out: Path) -> tuple[Path, dict[str, Any] | None]: + if args.page_manifest is not None: + return Path(args.page_manifest), None + manifest_tool = _load_sibling_module("build_limbu_book_page_manifest") + manifest_path = out / "raw-page-manifest" / "book-pages.jsonl" + manifest_summary = manifest_tool.build_limbu_book_page_manifest( + argparse.Namespace( + image_dir=args.image_dir, + pdf=args.pdf, + rendered_image_dir=args.rendered_image_dir, + pdf_dpi=args.pdf_dpi, + pdf_start_page=args.pdf_start_page, + pdf_end_page=args.pdf_end_page, + out=manifest_path, + page_id_prefix=args.page_id_prefix, + start_index=args.start_index, + zero_pad=args.zero_pad, + recursive=args.recursive, + relative_paths=True, + include_filename_regex=args.include_filename_regex, + exclude_filename_regex=args.exclude_filename_regex, + skip_duplicate_images=args.skip_duplicate_images, + ) + ) + return manifest_path, manifest_summary + + +def _read_jsonl_rows(path: Path, *, label: str) -> list[dict[str, Any]]: + rows: list[dict[str, Any]] = [] + try: + handle = path.open("r", encoding="utf-8") + except FileNotFoundError as exc: + raise ValueError(f"{label} does not exist: {path}") from exc + with handle: + for line_number, line in enumerate(handle, start=1): + if not line.strip(): + continue + try: + payload = json.loads(line) + except json.JSONDecodeError as exc: + raise ValueError(f"{label} has invalid JSON at {path}:{line_number}: {exc}") from exc + if not isinstance(payload, dict): + raise ValueError(f"{label} row must be an object at {path}:{line_number}") + rows.append(payload) + if not rows: + raise ValueError(f"{label} is empty: {path}") + return rows + + +def _resolve_manifest_path(value: object, manifest_dir: Path) -> Path: + path = Path(str(value or "")) + if path.is_absolute() or path.exists(): + return path + return manifest_dir / path + + +def _detector_profile_payload(name: str) -> dict[str, Any]: + try: + profile = DETECTOR_PROFILES[name] + except KeyError as exc: + raise ValueError(f"unknown detector profile: {name!r}") from exc + parse_kwargs = profile.get("parse_kwargs") + if not isinstance(parse_kwargs, dict): + raise ValueError(f"detector profile has invalid parse_kwargs: {name}") + return profile + + +def _merge_detector_profile_parse_kwargs( + row: dict[str, Any], + *, + row_number: int, + profile_name: str, + profile_parse_kwargs: dict[str, Any], +) -> dict[str, Any]: + raw = row.get("parse_kwargs", {}) + if raw is None: + raw = {} + if not isinstance(raw, dict): + raise ValueError(f"page manifest row {row_number} parse_kwargs must be an object") + merged = dict(raw) + conflicts = [ + key + for key, value in profile_parse_kwargs.items() + if key in merged and merged[key] != value + ] + if conflicts: + raise ValueError( + f"detector profile {profile_name!r} conflicts with page manifest row {row_number} " + f"parse_kwargs keys: {conflicts}" + ) + merged.update(profile_parse_kwargs) + return merged + + +def _page_manifest_with_detector_profile( + args: argparse.Namespace, + page_manifest: Path, + out: Path, +) -> tuple[Path, dict[str, Any] | None]: + profile_name = str(getattr(args, "detector_profile", "current") or "current") + profile = _detector_profile_payload(profile_name) + profile_parse_kwargs = dict(profile["parse_kwargs"]) + if not profile_parse_kwargs: + return page_manifest, { + "detector_profile": profile_name, + "detector_profile_description": profile["description"], + "detector_profile_usage_note": profile["usage_note"], + "detector_profile_parse_kwargs": {}, + "profiled_page_manifest": None, + "profiled_page_manifest_sha256": None, + } + rows = _read_jsonl_rows(page_manifest, label="page manifest") + manifest_dir = page_manifest.parent + profiled_dir = out / "profiled-page-manifest" + profiled_dir.mkdir(parents=True, exist_ok=True) + profiled_manifest = profiled_dir / "book-pages.jsonl" + with profiled_manifest.open("w", encoding="utf-8") as handle: + for row_number, row in enumerate(rows, start=1): + profiled = dict(row) + profiled["parse_kwargs"] = _merge_detector_profile_parse_kwargs( + profiled, + row_number=row_number, + profile_name=profile_name, + profile_parse_kwargs=profile_parse_kwargs, + ) + if "image_path" in profiled: + profiled["image_path"] = str(_resolve_manifest_path(profiled["image_path"], manifest_dir).resolve()) + handle.write(json.dumps(profiled, ensure_ascii=False, separators=(",", ":")) + "\n") + profile_summary = { + "detector_profile": profile_name, + "detector_profile_description": profile["description"], + "detector_profile_usage_note": profile["usage_note"], + "detector_profile_parse_kwargs": profile_parse_kwargs, + "source_page_manifest": str(page_manifest), + "source_page_manifest_sha256": _hash_if_file(page_manifest), + "profiled_page_manifest": str(profiled_manifest), + "profiled_page_manifest_sha256": sha256_file(profiled_manifest), + } + summary_path = profiled_dir / "detector-profile-summary.json" + profile_summary["detector_profile_summary"] = str(summary_path) + summary_path.write_text(json.dumps(profile_summary, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + profile_summary["detector_profile_summary_sha256"] = sha256_file(summary_path) + return profiled_manifest, profile_summary + + +def run_limbu_book_ocr(args: argparse.Namespace) -> dict[str, Any]: + out = Path(args.out) + capture_out = out / "capture-prep" + book_out = out / "book-ocr" + out.mkdir(parents=True, exist_ok=True) + source_page_manifest, manifest_summary = _source_page_manifest(args, out) + page_manifest, detector_profile_summary = _page_manifest_with_detector_profile(args, source_page_manifest, out) + + capture_tool = _load_sibling_module("prepare_limbu_book_captures") + parse_tool = _load_sibling_module("parse_limbu_book_pages") + audit_tool = _load_sibling_module("audit_limbu_book_output") + + capture_run = capture_tool.prepare_book_captures(_capture_args(args, page_manifest, capture_out)) + prepared_manifest = Path(str(capture_run["prepared_page_manifest"])) + book_run = parse_tool.parse_book(_parse_args(args, prepared_manifest, book_out)) + + book_audit: dict[str, Any] | None = None + if not args.skip_book_audit: + book_audit = audit_tool.audit_book_output(book_out, out / "book-output-audit") + + summary_path = out / "limbu-book-ocr-run.json" + page_summaries = _page_summaries(book_run) + page_layout_packet = _write_page_layout_review_packet(out, page_summaries) + layout_gap_packet = _write_layout_gap_review_packet(out, page_summaries) + _apply_layout_gap_review_guidance(page_summaries, layout_gap_packet) + page_triage_packet = _write_page_triage_review_packet(out, page_summaries) + attention_pages = _operator_attention_pages(page_summaries) + source_counts = _source_manifest_counts(manifest_summary) + source_flags = _source_attention_flags(source_counts) + summary = { + "tool": "tools/run_limbu_book_ocr.py", + "created_at_utc": datetime.now(UTC).isoformat(), + "machine": platform.node(), + "source_image_dir": str(args.image_dir) if args.image_dir is not None else None, + "source_pdf": str(args.pdf) if args.pdf is not None else None, + "generated_page_manifest_source_counts": source_counts, + "source_attention_required": bool(source_flags), + "source_attention_flags": source_flags, + "generated_page_manifest_summary": manifest_summary.get("summary_path") if manifest_summary is not None else None, + "generated_page_manifest_summary_sha256": _hash_if_file(Path(str(manifest_summary.get("summary_path")))) if manifest_summary is not None else None, + "source_page_manifest": str(source_page_manifest), + "source_page_manifest_sha256": _hash_if_file(source_page_manifest), + "raw_page_manifest": str(page_manifest), + "raw_page_manifest_sha256": _hash_if_file(page_manifest), + **(detector_profile_summary or {}), + "output_dir": str(out), + "capture_prep_dir": str(capture_out), + "capture_prep_run": capture_run.get("book_capture_prep_run"), + "capture_prep_run_sha256": _hash_if_file(Path(str(capture_run.get("book_capture_prep_run") or ""))), + "capture_prep_dashboard": capture_run.get("capture_prep_dashboard"), + "capture_prep_dashboard_sha256": _hash_if_file(Path(str(capture_run.get("capture_prep_dashboard") or ""))), + "capture_prep_dashboard_card_count": capture_run.get("capture_prep_dashboard_card_count"), + "prepared_page_manifest": str(prepared_manifest), + "prepared_page_manifest_sha256": _hash_if_file(prepared_manifest), + "book_ocr_dir": str(book_out), + "book_run": book_run.get("book_run"), + "book_run_sha256": _hash_if_file(Path(str(book_run.get("book_run") or ""))), + "book_audit": str(out / "book-output-audit" / "limbu-book-output-audit.json") if book_audit is not None else None, + "book_audit_passed": bool(book_audit.get("passed")) if book_audit is not None else None, + "engine": args.engine, + "model_config": args.model_config, + "model_config_sha256": _hash_if_file(Path(args.model_config)) if args.model_config else None, + "fallback_engine": args.fallback_engine, + "fallback_model_config": args.fallback_model_config, + "page_count": book_run.get("page_count"), + "line_count": book_run.get("line_count"), + "review_line_count": book_run.get("review_line_count"), + "book_line_review_row_count": book_run.get("book_line_review_row_count"), + "script_counts": book_run.get("script_counts"), + "pages": page_summaries, + "operator_attention_page_count": len(attention_pages), + "operator_attention_pages": attention_pages, + **page_layout_packet, + **layout_gap_packet, + **page_triage_packet, + "book_md": book_run.get("book_md"), + "book_body_md": book_run.get("book_body_md"), + "book_review_queue": book_run.get("book_review_queue"), + "book_line_review_queue": book_run.get("book_line_review_queue"), + "book_line_priority_review_queue": book_run.get("book_line_priority_review_queue"), + "book_line_focused_review_queue": book_run.get("book_line_focused_review_queue"), + "book_line_focused_review_summary": book_run.get("book_line_focused_review_summary"), + "book_line_review_priority_counts": book_run.get("book_line_review_priority_counts"), + "book_line_review_recommended_action_counts": book_run.get("book_line_review_recommended_action_counts"), + "book_review_dashboard": book_run.get("book_review_dashboard"), + "book_priority_review_dashboard": book_run.get("book_priority_review_dashboard"), + "book_focused_review_dashboard": book_run.get("book_focused_review_dashboard"), + "review_application_command": _review_application_command(out), + "training_pack_command": _training_pack_command(out), + "detector_profile_probe_command": _detector_profile_probe_command(args, raw_page_manifest=source_page_manifest, out=out), + "detector_profile_probe_compare_command": _detector_profile_probe_compare_command(args, out=out), + "claim_boundary": "operational Limbu book OCR run; this preserves pages and review queues but is not an OCR quality claim", + } + summary["browser_review_station_command"] = _review_station_command(summary, out=out) + summary["browser_review_station_apply_command"] = _browser_review_station_apply_command(summary, out=out) + summary["browser_review_station_training_pack_command"] = _browser_review_station_training_pack_command(summary, out=out) + summary["run_summary"] = str(summary_path) + summary_path.write_text(json.dumps(summary, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + + readme = out / "README.md" + readme_lines = [ + "# Limbu Book OCR Run", + "", + f"- raw page manifest: `{summary['raw_page_manifest']}`", + f"- detector profile: `{summary.get('detector_profile')}`", + f"- prepared page manifest: `{summary['prepared_page_manifest']}`", + f"- capture prep dashboard: `{summary['capture_prep_dashboard']}`", + f"- book OCR output: `{summary['book_ocr_dir']}`", + f"- pages: `{summary['page_count']}`", + f"- lines: `{summary['line_count']}`", + f"- review rows: `{summary['book_line_review_row_count']}`", + f"- page layout review rows: `{summary['page_layout_review_row_count']}`", + f"- page triage rows: `{summary['page_triage_review_row_count']}`", + f"- suspicious layout gaps: `{summary['layout_gap_review_row_count']}`", + f"- book audit passed: `{summary['book_audit_passed']}`", + "", + "Primary outputs:", + "", + f"- editable text: `{summary['book_md']}`", + f"- editable body text: `{summary['book_body_md']}`", + f"- capture prep dashboard: `{summary['capture_prep_dashboard']}`", + f"- review queue: `{summary['book_line_review_queue']}`", + f"- priority review queue: `{summary['book_line_priority_review_queue']}`", + f"- focused review queue: `{summary['book_line_focused_review_queue']}`", + f"- review dashboard: `{summary['book_review_dashboard']}`", + f"- priority review dashboard: `{summary['book_priority_review_dashboard']}`", + f"- focused review dashboard: `{summary['book_focused_review_dashboard']}`", + f"- page layout review manifest: `{summary['page_layout_review_manifest']}`", + f"- page layout review dashboard: `{summary['page_layout_review_dashboard']}`", + f"- page triage queue: `{summary['page_triage_review_queue']}`", + f"- page triage dashboard: `{summary['page_triage_review_dashboard']}`", + f"- layout gap review queue: `{summary['layout_gap_review_queue']}`", + f"- layout gap review dashboard: `{summary['layout_gap_review_dashboard']}`", + "", + ] + readme_lines.extend(_readme_source_selection(source_counts, source_flags)) + readme_lines.extend(_readme_detector_profile(summary)) + readme_lines.extend(_readme_page_layout(summary)) + readme_lines.extend(_readme_page_triage(summary)) + readme_lines.extend(_readme_layout_gap_review(summary)) + readme_lines.extend(_readme_review_priority(summary)) + readme_lines.extend(_readme_operator_attention(attention_pages)) + readme_lines.extend(_readme_browser_review_station(summary)) + readme_lines.extend(_readme_review_application(summary)) + readme_lines.extend(_readme_page_table(page_summaries)) + readme.write_text("\n".join(readme_lines) + "\n", encoding="utf-8") + return summary + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + source = parser.add_mutually_exclusive_group(required=True) + source.add_argument("--page-manifest", type=Path, help="raw book page JSONL manifest with page_id and image_path") + source.add_argument("--image-dir", type=Path, help="directory of raw page photos/scans; a page manifest is generated inside --out") + source.add_argument("--pdf", type=Path, help="PDF book to render into page images before OCR") + parser.add_argument("--out", type=Path, required=True, help="output directory for capture prep, OCR, audit, and run summary") + parser.add_argument("--rendered-image-dir", type=Path, help="where rendered PDF page PNGs should be written when --pdf is used") + parser.add_argument("--pdf-dpi", type=int, default=300, help="DPI for rendering PDF pages when --pdf is used") + parser.add_argument("--pdf-start-page", type=int, default=1, help="first 1-based PDF page number to render when --pdf is used") + parser.add_argument("--pdf-end-page", type=int, help="last 1-based PDF page number to render when --pdf is used") + parser.add_argument("--page-id-prefix", default="book-p", help="page ID prefix when --image-dir is used") + parser.add_argument("--start-index", type=int, default=1, help="first generated page number when --image-dir is used") + parser.add_argument("--zero-pad", type=int, default=4, help="generated page ID zero padding when --image-dir is used") + parser.add_argument("--recursive", action=argparse.BooleanOptionalAction, default=False, help="recursively scan --image-dir") + parser.add_argument("--include-filename-regex", help="when --image-dir is used, keep only image filenames matching this regex") + parser.add_argument("--exclude-filename-regex", help="when --image-dir is used, skip image filenames matching this regex") + parser.add_argument("--skip-duplicate-images", action=argparse.BooleanOptionalAction, default=False, help="when --image-dir is used, skip later image files with duplicate SHA-256 content") + parser.add_argument("--engine", default="candidate") + parser.add_argument("--model-config", default=DEFAULT_MODEL_CONFIG) + parser.add_argument("--fallback-engine") + parser.add_argument("--fallback-model-config") + parser.add_argument( + "--detector-profile", + choices=sorted(DETECTOR_PROFILES), + default="current", + help="global image-line detector profile to merge into page parse_kwargs before capture prep", + ) + parser.add_argument("--rotate-degrees", type=float, default=0.0) + parser.add_argument("--crop-box") + parser.add_argument("--perspective-quad") + parser.add_argument("--auto-detect-page", action=argparse.BooleanOptionalAction, default=False) + parser.add_argument("--auto-deskew", action=argparse.BooleanOptionalAction, default=True) + parser.add_argument("--max-auto-deskew-degrees", type=float, default=8.0) + parser.add_argument("--no-autocontrast", action="store_true") + parser.add_argument("--no-grayscale", action="store_true") + parser.add_argument("--min-prepared-width", type=int) + parser.add_argument("--min-prepared-height", type=int) + parser.add_argument("--min-prepared-entropy", type=float) + parser.add_argument("--min-prepared-luminance-stddev", type=float) + parser.add_argument("--min-prepared-edge-stddev", type=float) + parser.add_argument("--min-prepared-laplacian-variance", type=float) + parser.add_argument("--require-auto-detect-page", action=argparse.BooleanOptionalAction, default=False) + parser.add_argument("--min-auto-detect-page-area-ratio", type=float) + parser.add_argument("--fail-on-auto-detect-page-border-touch", action=argparse.BooleanOptionalAction, default=False) + parser.add_argument("--require-auto-deskew-applied", action=argparse.BooleanOptionalAction, default=False) + parser.add_argument("--max-abs-auto-deskew-degrees", type=float) + parser.add_argument( + "--preserve-page-lines", + action=argparse.BooleanOptionalAction, + default=True, + help="set prepared manifest parse defaults to image-line mode with empty detected lines preserved", + ) + parser.add_argument("--line-assembly", action=argparse.BooleanOptionalAction, default=False) + parser.add_argument("--line-assembly-y-tolerance", type=float, default=25.0) + parser.add_argument("--line-assembly-max-gap", type=float, default=160.0) + parser.add_argument("--line-assembly-max-merged-width", type=float, default=500.0) + parser.add_argument("--line-assembly-max-merged-width-ratio", type=float) + parser.add_argument("--line-assembly-max-component-width", type=float, default=250.0) + parser.add_argument("--line-assembly-max-component-width-ratio", type=float) + parser.add_argument("--line-assembly-min-vertical-overlap-ratio", type=float, default=0.30) + parser.add_argument("--line-assembly-joiner", default=r"\n") + parser.add_argument("--line-assembly-require-text-structural-role", action=argparse.BooleanOptionalAction, default=True) + parser.add_argument("--reading-order-profile-map", type=Path) + parser.add_argument("--reading-order-profile-map-audit", type=Path) + parser.add_argument("--require-reading-order-profile-safe", action=argparse.BooleanOptionalAction, default=False) + parser.add_argument("--require-reading-order-profile-map-safe", action=argparse.BooleanOptionalAction, default=False) + parser.add_argument("--reading-order-profile-x-scale", type=float, default=1.0) + parser.add_argument("--reading-order-profile-y-scale", type=float, default=80.0) + parser.add_argument("--reading-order-profile-outside-weight", type=float, default=2.0) + parser.add_argument("--skip-book-audit", action=argparse.BooleanOptionalAction, default=False) + args = parser.parse_args(argv) + if args.start_index < 0: + raise ValueError("--start-index must be non-negative") + if args.zero_pad < 1: + raise ValueError("--zero-pad must be at least 1") + try: + summary = run_limbu_book_ocr(args) + except OcrTechError as exc: + print(f"run_limbu_book_ocr: error: {exc}", file=sys.stderr) + return 2 + print(summary["run_summary"]) + print(f"book_ocr={summary['book_ocr_dir']}") + print(f"pages={summary['page_count']} lines={summary['line_count']} review_rows={summary['book_line_review_row_count']}") + print(f"operator_attention_pages={summary.get('operator_attention_page_count', 0)}") + print(f"suspicious_layout_gaps={summary.get('layout_gap_review_row_count', 0)}") + source_counts = summary.get("generated_page_manifest_source_counts") + if isinstance(source_counts, dict): + print( + "source_images=discovered:{discovered} kept:{kept} skipped:{skipped} duplicate_groups:{duplicates}".format( + discovered=source_counts.get("discovered_image_count"), + kept=source_counts.get("page_count"), + skipped=source_counts.get("skipped_image_count"), + duplicates=source_counts.get("duplicate_image_group_count"), + ) + ) + print(f"source_attention_flags={','.join(summary.get('source_attention_flags') or []) or 'none'}") + if summary["book_audit_passed"] is not None: + print(f"book_audit_passed={summary['book_audit_passed']}") + return 0 if summary["book_audit_passed"] is not False else 1 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ocr-tech-mps-integration/tools/run_limbu_paddle_space_page_eval.py b/ocr-tech-mps-integration/tools/run_limbu_paddle_space_page_eval.py new file mode 100644 index 0000000000000000000000000000000000000000..9b871b9d9ef5bc1e142d2ec2d6cec2d284d49372 --- /dev/null +++ b/ocr-tech-mps-integration/tools/run_limbu_paddle_space_page_eval.py @@ -0,0 +1,441 @@ +#!/usr/bin/env python3 +"""Score the Limbu OCR Space Paddle page path with the page OCR eval harness.""" + +from __future__ import annotations + +import argparse +import importlib.util +import json +import shutil +import sys +from argparse import Namespace +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +from PIL import Image + +from ocrtech.manifest import ManifestEntry, load_manifest, sha256_file +from ocrtech.schemas import BBox, Block, Document, Page, TextLine, union_bbox + + +DEFAULT_EVAL_MANIFEST = Path( + "outputs/limbu-page-eval-drafts/gorkhapatra-limbu-sirijonga-2026-06-21/" + "manifests/eval-current-schema-gorkhapatra-sirijonga.jsonl" +) +DEFAULT_SUMMARY_FILE = Path( + "outputs/limbu-page-eval-drafts/gorkhapatra-limbu-sirijonga-2026-06-21/" + "summary-current-schema-input.json" +) +DEFAULT_SCRIPT_INVENTORY = Path( + "outputs/limbu-page-eval-drafts/gorkhapatra-limbu-sirijonga-2026-06-21/" + "script-inventory.json" +) +DEFAULT_SPACE_APP = Path("spaces/limbu-ocr/app.py") +DEFAULT_MODEL_DIR = Path("spaces/limbu-ocr/models/limbu-sirijonga-real-heavy") + + +def _load_module(path: Path, name: str) -> Any: + spec = importlib.util.spec_from_file_location(name, path) + if spec is None or spec.loader is None: + raise RuntimeError(f"unable to load module from {path}") + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + spec.loader.exec_module(module) + return module + + +def _resolve_manifest_path(path_value: str, manifest_dir: Path) -> Path: + path = Path(path_value) + if path.is_absolute() or path.exists(): + return path + candidate = manifest_dir / path + if candidate.exists(): + return candidate + return path + + +def _confidence(value: object) -> float | None: + if value is None: + return None + try: + number = float(value) + except (TypeError, ValueError): + return None + return min(1.0, max(0.0, number)) + + +def _line_from_row(row: dict[str, Any]) -> TextLine: + raw_box = row.get("box") + if not isinstance(raw_box, dict): + raise ValueError(f"candidate row is missing a box object: {row!r}") + left = float(raw_box["left"]) + top = float(raw_box["top"]) + right = float(raw_box["right"]) + bottom = float(raw_box["bottom"]) + line_id = f"p{int(row.get('page_index', 0)):04d}-l{int(row.get('index', 0)):04d}" + return TextLine( + text=str(row.get("text") or ""), + bbox=BBox(left, top, max(0.0, right - left), max(0.0, bottom - top)), + confidence=_confidence(row.get("selected_confidence")), + page_index=int(row.get("page_index", 0)), + line_id=line_id, + metadata={ + "source": row.get("source"), + "paddle_seed_recognizer": row.get("paddle_seed_recognizer"), + "paddle_seed_text": row.get("paddle_seed_text"), + "paddle_seed_confidence": row.get("paddle_seed_confidence"), + "selected_engine": row.get("selected_engine"), + }, + ) + + +def _document_from_rows( + *, + image_path: Path, + image: Image.Image, + rows: list[dict[str, Any]], + metadata: dict[str, Any], +) -> Document: + text_lines = [_line_from_row(row) for row in rows] + blocks = [ + Block( + block_id=f"{line.line_id or f'p0000-l{index:04d}'}-block", + block_type="text", + page_index=line.page_index, + bbox=line.bbox, + order=index, + text=line.text, + confidence=line.confidence, + line_ids=[line.line_id] if line.line_id else [], + metadata={"source": "space-paddle-page-eval-adapter", "block_granularity": "line"}, + ) + for index, line in enumerate(text_lines, start=1) + ] + if not blocks: + page_bbox = union_bbox([line.bbox for line in text_lines]) if text_lines else BBox(0, 0, 0, 0) + blocks = [ + Block( + block_id="p0000-empty-block", + block_type="text", + page_index=0, + bbox=page_bbox, + order=1, + text="", + confidence=None, + line_ids=[], + metadata={"source": "space-paddle-page-eval-adapter", "block_granularity": "empty"}, + ) + ] + return Document( + source_path=str(image_path), + pages=[ + Page( + page_index=0, + width=image.width, + height=image.height, + text_lines=text_lines, + blocks=blocks, + metadata=metadata, + ) + ], + metadata=metadata, + ) + + +def _ordered_seed_rows(app: Any, image: Image.Image, args: argparse.Namespace) -> list[dict[str, Any]]: + normalized = app._normalize_image(image) + detections = app._predict_paddle_page_detections( + normalized, + seed_recognizer=args.seed_recognizer, + text_det_limit_side_len=args.text_det_limit_side_len, + text_det_thresh=args.text_det_thresh, + text_det_box_thresh=args.text_det_box_thresh, + text_det_unclip_ratio=args.text_det_unclip_ratio, + ) + ordered_boxes = app._order_image_line_boxes( + [detection.box for detection in detections], + args.reading_order, + normalized.width, + ) + detections_by_box = { + (detection.box.left, detection.box.top, detection.box.right, detection.box.bottom): detection + for detection in detections + } + ordered_detections = [ + detections_by_box[(box.left, box.top, box.right, box.bottom)] + for box in ordered_boxes + if (box.left, box.top, box.right, box.bottom) in detections_by_box + ] + if args.max_lines > 0: + ordered_detections = ordered_detections[: args.max_lines] + rows: list[dict[str, Any]] = [] + for index, detection in enumerate(ordered_detections, start=1): + rows.append( + { + "page_index": 0, + "index": index, + "box": detection.box.as_dict(), + "source": "paddle_seed", + "paddle_seed_recognizer": args.seed_recognizer, + "paddle_seed_text": detection.seed_text, + "paddle_seed_confidence": detection.seed_confidence, + "selected_engine": f"paddle-{args.seed_recognizer.lower()}-seed", + "selected_confidence": detection.seed_confidence, + "text": detection.seed_text, + "candidates": [ + { + "engine": f"paddle-{args.seed_recognizer.lower()}-seed", + "confidence": detection.seed_confidence, + "text": detection.seed_text, + } + ], + } + ) + return rows + + +def _rerouted_rows(app: Any, image: Image.Image, args: argparse.Namespace, doc_dir: Path) -> list[dict[str, Any]]: + result = app._recognize_page_paddle_core( + image, + mode=args.mode, + seed_recognizer=args.seed_recognizer, + reading_order=args.reading_order, + text_det_limit_side_len=args.text_det_limit_side_len, + text_det_thresh=args.text_det_thresh, + text_det_box_thresh=args.text_det_box_thresh, + text_det_unclip_ratio=args.text_det_unclip_ratio, + crop_padding=args.crop_padding, + max_lines=args.max_lines, + artifact_dir=doc_dir, + page_index=0, + ) + rows = result.get("rows") + if not isinstance(rows, list): + raise ValueError("Space Paddle page OCR returned no rows list") + for row in rows: + if isinstance(row, dict): + row["source"] = "paddle_reroute" + return [row for row in rows if isinstance(row, dict)] + + +def _write_candidate( + *, + app: Any, + entry: ManifestEntry, + manifest_dir: Path, + documents_dir: Path, + args: argparse.Namespace, +) -> dict[str, Any]: + image_path = _resolve_manifest_path(entry.image_path, manifest_dir) + if not image_path.is_file(): + raise FileNotFoundError(f"eval image is missing for {entry.sample_id}: {image_path}") + actual_sha256 = sha256_file(image_path) + if entry.sha256 and entry.sha256 != actual_sha256: + raise ValueError( + f"eval image sha256 mismatch for {entry.sample_id}: " + f"manifest={entry.sha256} actual={actual_sha256}" + ) + doc_dir = documents_dir / entry.sample_id + doc_dir.mkdir(parents=True, exist_ok=True) + image = Image.open(image_path).convert("RGB") + if args.recognition_source == "seed": + rows = _ordered_seed_rows(app, image, args) + elif args.recognition_source == "reroute": + rows = _rerouted_rows(app, image, args, doc_dir) + else: + raise ValueError(f"unsupported recognition source: {args.recognition_source}") + metadata = { + "created_at_utc": datetime.now(timezone.utc).isoformat(), + "system": "limbu-space-paddle-page-eval", + "recognition_source": args.recognition_source, + "mode": args.mode, + "seed_recognizer": args.seed_recognizer, + "reading_order": args.reading_order, + "text_det_limit_side_len": args.text_det_limit_side_len, + "text_det_thresh": args.text_det_thresh, + "text_det_box_thresh": args.text_det_box_thresh, + "text_det_unclip_ratio": args.text_det_unclip_ratio, + "crop_padding": args.crop_padding, + "max_lines": args.max_lines, + "line_count": len(rows), + } + document = _document_from_rows(image_path=image_path, image=image, rows=rows, metadata=metadata) + document_path = doc_dir / "document.json" + document_path.write_text(json.dumps(document.to_dict(), ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + (doc_dir / "candidate-rows.jsonl").write_text( + "".join(json.dumps(row, ensure_ascii=False) + "\n" for row in rows), + encoding="utf-8", + ) + (doc_dir / "candidate-text.txt").write_text(document.text + ("\n" if document.text else ""), encoding="utf-8") + audit = { + "passed": True, + "issues": [], + "sample_id": entry.sample_id, + "document_path": str(document_path), + "recognition_source": args.recognition_source, + "line_count": len(rows), + "note": "Adapter sanity only. Claim safety is determined by the page eval harness.", + } + (doc_dir / "limbu-output-audit.json").write_text(json.dumps(audit, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + return { + "sample_id": entry.sample_id, + "image_path": str(image_path), + "document_path": str(document_path), + "line_count": len(rows), + "text_length": len(document.text), + } + + +def _artifact_or_empty(path: Path) -> str: + return str(path) if path.is_file() else "" + + +def _infer_dictionary(model_dir: Path) -> str: + artifacts_dir = model_dir / "artifacts" + for name in ("limbu-sirijonga-v2.txt", "nep_eng_dict.txt", "dict.txt"): + candidate = artifacts_dir / name + if candidate.is_file(): + return str(candidate) + return "" + + +def _score_args(args: argparse.Namespace, documents_dir: Path, score_out: Path) -> Namespace: + model_dir = args.model_dir + return Namespace( + eval_manifest=args.eval_manifest, + documents_dir=documents_dir, + ocr_output_kind="live_detector", + require_output_audit=False, + output_audit_filename="limbu-output-audit.json", + output_audit_passed_field="passed", + out=score_out, + summary_file=args.summary_file, + script_inventory_file=args.script_inventory_file, + spotcheck_calibration_file=None, + train_manifest=args.train_manifest, + system_name=args.system_name, + model_name=args.model_name, + checkpoint=args.checkpoint or _artifact_or_empty(model_dir / "artifacts" / "inference.pdiparams"), + config=args.config or _artifact_or_empty(model_dir / "model-card.json"), + dictionary=args.dictionary or _infer_dictionary(model_dir), + language=args.language, + script=args.script, + domain=args.domain, + gt_status=args.gt_status, + eval_pack_version=args.eval_pack_version, + frozen_eval_pack=False, + unseen_for_selection=True, + selected_checkpoint_on_test=False, + claim_eligible=False, + line_iou_threshold=args.line_iou_threshold, + review_sample_size=args.review_sample_size, + require_claim_safe=False, + force=args.force, + ) + + +def run(args: argparse.Namespace) -> dict[str, Any]: + if not args.space_app.is_file(): + raise FileNotFoundError(f"Space app is missing: {args.space_app}") + if not args.eval_manifest.is_file(): + raise FileNotFoundError(f"eval manifest is missing: {args.eval_manifest}") + if not args.summary_file.is_file(): + raise FileNotFoundError(f"summary file is missing: {args.summary_file}") + if not args.script_inventory_file.is_file(): + raise FileNotFoundError(f"script inventory file is missing: {args.script_inventory_file}") + if args.out.exists() and any(args.out.iterdir()): + if not args.force: + raise FileExistsError(f"output directory exists and is not empty: {args.out}") + if args.out.resolve() in {Path.cwd().resolve(), Path("/")}: + raise ValueError(f"refusing to remove unsafe output directory: {args.out}") + shutil.rmtree(args.out) + args.out.mkdir(parents=True, exist_ok=True) + app = _load_module(args.space_app, "limbu_ocr_space_app_for_eval") + entries = load_manifest(args.eval_manifest) + if not entries: + raise ValueError(f"eval manifest has no rows: {args.eval_manifest}") + documents_dir = args.out / "documents" + documents_dir.mkdir(parents=True, exist_ok=True) + manifest_dir = args.eval_manifest.parent + candidate_rows = [ + _write_candidate(app=app, entry=entry, manifest_dir=manifest_dir, documents_dir=documents_dir, args=args) + for entry in entries + ] + score_out = args.out / "score" + scorer = _load_module(Path("tools/run_page_ocr_eval.py"), "run_page_ocr_eval_for_limbu_space") + score_result = scorer.run_eval(_score_args(args, documents_dir, score_out)) + result = { + "created_at_utc": datetime.now(timezone.utc).isoformat(), + "eval_manifest": str(args.eval_manifest), + "documents_dir": str(documents_dir), + "score_dir": str(score_out), + "recognition_source": args.recognition_source, + "candidates": candidate_rows, + "metrics": score_result["metrics"], + } + (args.out / "limbu-paddle-space-page-eval-run.json").write_text( + json.dumps(result, ensure_ascii=False, indent=2) + "\n", + encoding="utf-8", + ) + return result + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--eval-manifest", type=Path, default=DEFAULT_EVAL_MANIFEST) + parser.add_argument("--space-app", type=Path, default=DEFAULT_SPACE_APP) + parser.add_argument("--out", type=Path, required=True) + parser.add_argument("--summary-file", type=Path, default=DEFAULT_SUMMARY_FILE) + parser.add_argument("--script-inventory-file", type=Path, default=DEFAULT_SCRIPT_INVENTORY) + parser.add_argument("--model-dir", type=Path, default=DEFAULT_MODEL_DIR) + parser.add_argument("--train-manifest", type=Path, action="append", default=[]) + parser.add_argument("--recognition-source", choices=["seed", "reroute"], default="seed") + parser.add_argument("--mode", choices=["Auto", "Sirijonga", "Devanagari"], default="Sirijonga") + parser.add_argument("--seed-recognizer", choices=["Sirijonga", "Devanagari"], default="Sirijonga") + parser.add_argument("--reading-order", choices=["Auto", "Rows LTR", "Columns LTR", "Columns RTL"], default="Auto") + parser.add_argument("--text-det-limit-side-len", type=int, default=1280) + parser.add_argument("--text-det-thresh", type=float, default=0.30) + parser.add_argument("--text-det-box-thresh", type=float, default=0.60) + parser.add_argument("--text-det-unclip-ratio", type=float, default=1.5) + parser.add_argument("--crop-padding", type=int, default=12) + parser.add_argument("--max-lines", type=int, default=0) + parser.add_argument("--line-iou-threshold", type=float, default=0.5) + parser.add_argument("--review-sample-size", type=int, default=50) + parser.add_argument("--system-name", default="limbu-space-paddle-page-v1") + parser.add_argument("--model-name", default="limbu-space-paddle-first") + parser.add_argument("--checkpoint", default="") + parser.add_argument("--config", default="") + parser.add_argument("--dictionary", default="") + parser.add_argument("--language", default="limbu") + parser.add_argument("--script", default="Limbu") + parser.add_argument("--domain", default="real_print") + parser.add_argument("--gt-status", default="machine_converted_unreviewed") + parser.add_argument( + "--eval-pack-version", + default="gorkhapatra-limbu-sirijonga-page-draft-v1-current-schema-input", + ) + parser.add_argument("--force", action="store_true") + args = parser.parse_args(argv) + result = run(args) + metrics = result["metrics"] + print( + "wrote {score_dir} source={source} scored={scored}/{samples} " + "page_cp_CER={cp:.6f} page_graph_CER={graph:.6f} " + "line_F1={line_f1:.6f} matched_cp_CER={matched_cp:.6f} order_acc={order:.6f}".format( + score_dir=result["score_dir"], + source=result["recognition_source"], + scored=metrics["scored_pages"], + samples=metrics["manifest_samples"], + cp=metrics["text_cer_codepoint_micro"], + graph=metrics["text_cer_grapheme_micro"], + line_f1=metrics.get("line_detection_f1_micro", 0.0), + matched_cp=metrics.get("matched_line_text_cer_codepoint_micro", 0.0), + order=metrics.get("matched_line_reading_order_pair_accuracy", 0.0), + ) + ) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ocr-tech-mps-integration/tools/run_limbu_phone_page_ocr.py b/ocr-tech-mps-integration/tools/run_limbu_phone_page_ocr.py new file mode 100644 index 0000000000000000000000000000000000000000..d68102591ad3a76f02d512747bd444496dadf30e --- /dev/null +++ b/ocr-tech-mps-integration/tools/run_limbu_phone_page_ocr.py @@ -0,0 +1,430 @@ +#!/usr/bin/env python3 +"""Run Limbu phone-page OCR from raw captures through trained detector materialization.""" + +from __future__ import annotations + +import argparse +import importlib.util +import json +import platform +import sys +from datetime import UTC, datetime +from pathlib import Path +from types import ModuleType +from typing import Any + +from ocrtech.manifest import sha256_file + + +SOURCE_PROVENANCE_KEYS = ( + "page_sequence_number", + "book_page_number", + "source_filename", + "source_document_path", + "source_document_sha256", + "source_document_page_number", + "source_document_page_index", + "source_kind", + "rendered_pdf_dpi", + "source_url", + "publication_date", + "edition", + "pdf_page_number", +) + + +def _load_sibling_module(name: str) -> ModuleType: + path = Path(__file__).resolve().parent / f"{name}.py" + spec = importlib.util.spec_from_file_location(name, path) + if spec is None or spec.loader is None: + raise RuntimeError(f"could not load tool module: {path}") + module = importlib.util.module_from_spec(spec) + sys.modules[spec.name] = module + spec.loader.exec_module(module) + return module + + +def _hash_if_file(path: Path | None) -> str | None: + if path is None or not path.is_file(): + return None + return sha256_file(path) + + +def _read_jsonl_objects(path: Path) -> list[dict[str, Any]]: + rows: list[dict[str, Any]] = [] + try: + handle = path.open("r", encoding="utf-8") + except FileNotFoundError as exc: + raise ValueError(f"manifest does not exist: {path}") from exc + with handle: + for line_number, line in enumerate(handle, start=1): + if not line.strip(): + continue + try: + payload = json.loads(line) + except json.JSONDecodeError as exc: + raise ValueError(f"invalid JSON at {path}:{line_number}: {exc}") from exc + if not isinstance(payload, dict): + raise ValueError(f"manifest row must be an object at {path}:{line_number}") + rows.append(payload) + if not rows: + raise ValueError(f"manifest is empty: {path}") + return rows + + +def _prepared_row_source_metadata(row: dict[str, Any]) -> dict[str, Any] | None: + source_metadata = row.get("source_metadata") + if isinstance(source_metadata, dict): + return dict(source_metadata) + return None + + +def _prepared_row_provenance(row: dict[str, Any]) -> dict[str, Any]: + provenance: dict[str, Any] = {} + for key in SOURCE_PROVENANCE_KEYS: + if key in row: + provenance[key] = row.get(key) + source_metadata = _prepared_row_source_metadata(row) + if source_metadata is not None: + provenance["source_metadata"] = source_metadata + return provenance + + +def _capture_args(args: argparse.Namespace, *, page_manifest: Path, capture_out: Path) -> argparse.Namespace: + return argparse.Namespace( + page_manifest=page_manifest, + out=capture_out, + rotate_degrees=args.rotate_degrees, + crop_box=args.crop_box, + perspective_quad=args.perspective_quad, + auto_detect_page=args.auto_detect_page, + auto_deskew=args.auto_deskew, + max_auto_deskew_degrees=args.max_auto_deskew_degrees, + no_autocontrast=args.no_autocontrast, + no_grayscale=args.no_grayscale, + preserve_parse_defaults=False, + require_metadata_path_self=True, + allow_failed_capture_audit=args.allow_failed_capture_audit, + min_prepared_width=args.min_prepared_width, + min_prepared_height=args.min_prepared_height, + min_prepared_entropy=args.min_prepared_entropy, + min_prepared_luminance_stddev=args.min_prepared_luminance_stddev, + min_prepared_edge_stddev=args.min_prepared_edge_stddev, + min_prepared_laplacian_variance=args.min_prepared_laplacian_variance, + require_auto_detect_page=args.require_auto_detect_page, + min_auto_detect_page_area_ratio=args.min_auto_detect_page_area_ratio, + fail_on_auto_detect_page_border_touch=args.fail_on_auto_detect_page_border_touch, + require_auto_deskew_applied=args.require_auto_deskew_applied, + max_abs_auto_deskew_degrees=args.max_abs_auto_deskew_degrees, + ) + + +def _materializer_args(args: argparse.Namespace, *, eval_manifest: Path, documents_out: Path) -> argparse.Namespace: + return argparse.Namespace( + eval_manifest=eval_manifest, + model_config=args.model_config, + out=documents_out, + engine=args.engine, + crops_dir=None, + recognition_mode=args.recognition_mode, + line_detector=args.line_detector, + yolo_labels_dir=args.yolo_labels_dir, + yolo_model_path=args.yolo_model_path, + yolo_imgsz=args.yolo_imgsz, + yolo_device=args.yolo_device, + yolo_max_det=args.yolo_max_det, + yolo_min_confidence=args.yolo_min_confidence, + yolo_min_width_ratio=args.yolo_min_width_ratio, + yolo_min_height_ratio=args.yolo_min_height_ratio, + yolo_max_height_ratio=args.yolo_max_height_ratio, + yolo_min_area_ratio=args.yolo_min_area_ratio, + yolo_header_min_width_ratio=args.yolo_header_min_width_ratio, + yolo_header_max_y_ratio=args.yolo_header_max_y_ratio, + yolo_header_min_confidence=args.yolo_header_min_confidence, + yolo_region_min_x_ratio=args.yolo_region_min_x_ratio, + yolo_region_max_x_ratio=args.yolo_region_max_x_ratio, + yolo_region_min_y_ratio=args.yolo_region_min_y_ratio, + yolo_region_max_y_ratio=args.yolo_region_max_y_ratio, + yolo_same_row_overlap_suppression=args.yolo_same_row_overlap_suppression, + yolo_same_row_overlap_threshold=args.yolo_same_row_overlap_threshold, + yolo_same_row_wider_preference_ratio=args.yolo_same_row_wider_preference_ratio, + yolo_same_row_y_tolerance=args.yolo_same_row_y_tolerance, + threshold=args.threshold, + bbox_source=args.bbox_source, + reading_order=args.reading_order, + horizontal_kernel=args.horizontal_kernel, + vertical_kernel=args.vertical_kernel, + dilation_iterations=args.dilation_iterations, + min_width=args.min_width, + min_height=args.min_height, + min_area=args.min_area, + max_height=args.max_height, + min_aspect_ratio=args.min_aspect_ratio, + max_aspect_ratio=args.max_aspect_ratio, + detector_padding=args.detector_padding, + crop_padding=args.crop_padding, + split_tall_components=args.split_tall_components, + split_tall_row_min_ink=args.split_tall_row_min_ink, + split_tall_max_row_gap=args.split_tall_max_row_gap, + split_wide_components=args.split_wide_components, + split_wide_col_min_ink=args.split_wide_col_min_ink, + split_wide_max_col_gap=args.split_wide_max_col_gap, + split_wide_min_width=args.split_wide_min_width, + split_detected_row_components=args.split_detected_row_components, + split_detected_row_col_min_ink=args.split_detected_row_col_min_ink, + split_detected_row_max_col_gap=args.split_detected_row_max_col_gap, + split_detected_row_min_width=args.split_detected_row_min_width, + split_detected_row_min_segment_width=args.split_detected_row_min_segment_width, + merge_same_row_components=args.merge_same_row_components, + merge_same_row_y_tolerance=args.merge_same_row_y_tolerance, + merge_same_row_max_gap=args.merge_same_row_max_gap, + merge_same_row_max_center_delta=args.merge_same_row_max_center_delta, + merge_same_row_max_width=args.merge_same_row_max_width, + merge_same_row_auto_fragmented_top_to_bottom=args.merge_same_row_auto_fragmented_top_to_bottom, + merge_same_row_auto_min_reduction_ratio=args.merge_same_row_auto_min_reduction_ratio, + merge_same_row_auto_min_reduction_count=args.merge_same_row_auto_min_reduction_count, + rescue_detector_pass=args.rescue_detector_pass, + merge_iou_threshold=args.merge_iou_threshold, + allow_empty_lines=args.allow_empty_lines, + ) + + +def _write_materializer_eval_manifest( + prepared_manifest: Path, + *, + out: Path, + dataset: str, + split: str, +) -> Path: + rows = _read_jsonl_objects(prepared_manifest) + eval_manifest = out / "materializer-eval-manifest.jsonl" + with eval_manifest.open("w", encoding="utf-8") as handle: + for index, row in enumerate(rows, start=1): + page_id = row.get("page_id") or row.get("sample_id") or f"page-{index:04d}" + image_path = row.get("image_path") + if not isinstance(image_path, str) or not image_path: + raise ValueError(f"prepared manifest row {index} is missing image_path") + metadata = { + "page_id": page_id, + "source_image_path": row.get("source_image_path"), + "source_image_sha256": row.get("source_image_sha256"), + "raw_copy_path": row.get("raw_copy_path"), + "prepared_image_sha256": row.get("prepared_image_sha256"), + "capture_prep_metadata": row.get("capture_prep_metadata"), + "capture_audit": row.get("capture_audit"), + "language": row.get("language") or "limbu", + "script": row.get("script") or "Limbu", + } + metadata.update(_prepared_row_provenance(row)) + payload = { + "sample_id": str(page_id), + "dataset": dataset, + "split": split, + "image_path": image_path, + "text": "", + "sha256": row.get("prepared_image_sha256"), + "metadata": metadata, + } + handle.write(json.dumps(payload, ensure_ascii=False, separators=(",", ":")) + "\n") + return eval_manifest + + +def _write_readme(path: Path, summary: dict[str, Any]) -> None: + path.write_text( + "\n".join( + [ + "# Limbu Phone Page OCR Harness Run", + "", + f"- source raw page manifest: `{summary['source_page_manifest']}`", + f"- capture prep run: `{summary['capture_prep_run']}`", + f"- materializer eval manifest: `{summary['materializer_eval_manifest']}`", + f"- documents dir: `{summary['documents_dir']}`", + f"- detector: `{summary['line_detector']}`", + f"- pages: `{summary['page_count']}`", + f"- OCR lines: `{summary['line_count']}`", + f"- empty OCR lines: `{summary['empty_line_count']}`", + "", + ] + ), + encoding="utf-8", + ) + + +def run_limbu_phone_page_ocr(args: argparse.Namespace) -> dict[str, Any]: + out = Path(args.out) + out.mkdir(parents=True, exist_ok=True) + page_manifest = Path(args.page_manifest) + capture_out = out / "capture-prep" + documents_out = out / "documents" + + capture_tool = _load_sibling_module("prepare_limbu_book_captures") + materializer_tool = _load_sibling_module("materialize_page_image_line_boxes") + + capture_run = capture_tool.prepare_book_captures(_capture_args(args, page_manifest=page_manifest, capture_out=capture_out)) + prepared_manifest = Path(str(capture_run.get("prepared_page_manifest") or "")) + eval_manifest = _write_materializer_eval_manifest( + prepared_manifest, + out=out, + dataset=args.dataset, + split=args.split, + ) + materializer_run = materializer_tool.materialize(_materializer_args(args, eval_manifest=eval_manifest, documents_out=documents_out)) + + summary_path = out / "limbu-phone-page-ocr-run.json" + materializer_run_path = documents_out / "image-line-box-run.json" + summary = { + "tool": "tools/run_limbu_phone_page_ocr.py", + "created_at_utc": datetime.now(UTC).isoformat(), + "machine": platform.node(), + "source_page_manifest": str(page_manifest), + "source_page_manifest_sha256": _hash_if_file(page_manifest), + "output_dir": str(out), + "capture_prep_dir": str(capture_out), + "capture_prep_run": capture_run.get("book_capture_prep_run"), + "capture_prep_run_sha256": _hash_if_file(Path(str(capture_run.get("book_capture_prep_run") or ""))), + "capture_prep_dashboard": capture_run.get("capture_prep_dashboard"), + "capture_prep_dashboard_sha256": _hash_if_file(Path(str(capture_run.get("capture_prep_dashboard") or ""))), + "prepared_page_manifest": str(prepared_manifest), + "prepared_page_manifest_sha256": _hash_if_file(prepared_manifest), + "materializer_eval_manifest": str(eval_manifest), + "materializer_eval_manifest_sha256": _hash_if_file(eval_manifest), + "documents_dir": str(documents_out), + "materializer_run": str(materializer_run_path), + "materializer_run_sha256": _hash_if_file(materializer_run_path), + "line_detector": args.line_detector, + "yolo_model_path": str(args.yolo_model_path) if args.yolo_model_path is not None else None, + "yolo_model_sha256": _hash_if_file(args.yolo_model_path) if args.yolo_model_path is not None else None, + "yolo_labels_dir": str(args.yolo_labels_dir) if args.yolo_labels_dir is not None else None, + "model_config": str(args.model_config), + "model_config_sha256": _hash_if_file(args.model_config), + "reading_order": args.reading_order, + "page_count": materializer_run.get("sample_count"), + "line_count": materializer_run.get("line_count"), + "empty_line_count": materializer_run.get("empty_line_count"), + "materializer_detector": materializer_run.get("detector"), + "reading_order_selection_counts": materializer_run.get("reading_order_selection_counts"), + "detector_source_pass_counts": materializer_run.get("detector_source_pass_counts"), + "capture_failed_audit_count": capture_run.get("failed_capture_audit_count"), + "capture_failed_audit_page_ids": capture_run.get("failed_capture_audit_page_ids"), + } + summary["run_summary"] = str(summary_path) + summary_path.write_text(json.dumps(summary, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + _write_readme(out / "README.md", summary) + summary["run_summary_sha256"] = _hash_if_file(summary_path) + return summary + + +def _build_parser() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--page-manifest", type=Path, required=True) + parser.add_argument("--out", type=Path, required=True) + parser.add_argument("--dataset", default="limbu-phone-page-ocr") + parser.add_argument("--split", default="eval") + parser.add_argument("--model-config", type=Path, required=True) + parser.add_argument("--engine", default="candidate") + parser.add_argument("--recognition-mode", choices=["full_page", "line", "auto"], default="line") + + parser.add_argument("--rotate-degrees", type=float, default=0.0) + parser.add_argument("--crop-box") + parser.add_argument("--perspective-quad") + parser.add_argument("--auto-detect-page", action=argparse.BooleanOptionalAction, default=True) + parser.add_argument("--auto-deskew", action=argparse.BooleanOptionalAction, default=True) + parser.add_argument("--max-auto-deskew-degrees", type=float, default=8.0) + parser.add_argument("--no-autocontrast", action="store_true") + parser.add_argument("--no-grayscale", action="store_true") + parser.add_argument("--allow-failed-capture-audit", action=argparse.BooleanOptionalAction, default=False) + parser.add_argument("--min-prepared-width", type=int) + parser.add_argument("--min-prepared-height", type=int) + parser.add_argument("--min-prepared-entropy", type=float) + parser.add_argument("--min-prepared-luminance-stddev", type=float) + parser.add_argument("--min-prepared-edge-stddev", type=float) + parser.add_argument("--min-prepared-laplacian-variance", type=float) + parser.add_argument("--require-auto-detect-page", action=argparse.BooleanOptionalAction, default=False) + parser.add_argument("--min-auto-detect-page-area-ratio", type=float) + parser.add_argument("--fail-on-auto-detect-page-border-touch", action=argparse.BooleanOptionalAction, default=False) + parser.add_argument("--require-auto-deskew-applied", action=argparse.BooleanOptionalAction, default=False) + parser.add_argument("--max-abs-auto-deskew-degrees", type=float) + + parser.add_argument("--line-detector", choices=["morph", "yolo-labels", "yolo-model"], default="yolo-model") + parser.add_argument("--yolo-labels-dir", type=Path) + parser.add_argument("--yolo-model-path", type=Path) + parser.add_argument("--yolo-imgsz", type=int, default=1280) + parser.add_argument("--yolo-device") + parser.add_argument("--yolo-max-det", type=int) + parser.add_argument("--yolo-min-confidence", type=float, default=0.50) + parser.add_argument("--yolo-min-width-ratio", type=float, default=0.04) + parser.add_argument("--yolo-min-height-ratio", type=float, default=0.0) + parser.add_argument("--yolo-max-height-ratio", type=float, default=1.0) + parser.add_argument("--yolo-min-area-ratio", type=float, default=0.0) + parser.add_argument("--yolo-header-min-width-ratio", type=float, default=0.0) + parser.add_argument("--yolo-header-max-y-ratio", type=float, default=0.0) + parser.add_argument("--yolo-header-min-confidence", type=float, default=1.0) + parser.add_argument("--yolo-region-min-x-ratio", type=float, default=0.0) + parser.add_argument("--yolo-region-max-x-ratio", type=float, default=1.0) + parser.add_argument("--yolo-region-min-y-ratio", type=float, default=0.05) + parser.add_argument("--yolo-region-max-y-ratio", type=float, default=1.0) + parser.add_argument( + "--no-yolo-same-row-overlap-suppression", + action="store_false", + dest="yolo_same_row_overlap_suppression", + default=True, + ) + parser.add_argument("--yolo-same-row-overlap-threshold", type=float, default=0.75) + parser.add_argument("--yolo-same-row-wider-preference-ratio", type=float, default=1.12) + parser.add_argument("--yolo-same-row-y-tolerance", type=float, default=0.0) + + parser.add_argument("--threshold", default="otsu") + parser.add_argument("--bbox-source", choices=["ink", "dilated"], default="ink") + parser.add_argument("--reading-order", default="auto_layout_left_to_right") + parser.add_argument("--horizontal-kernel", type=int, default=41) + parser.add_argument("--vertical-kernel", type=int, default=7) + parser.add_argument("--dilation-iterations", type=int, default=1) + parser.add_argument("--min-width", type=int, default=35) + parser.add_argument("--min-height", type=int, default=10) + parser.add_argument("--min-area", type=int, default=100) + parser.add_argument("--max-height", type=int, default=260) + parser.add_argument("--min-aspect-ratio", type=float, default=0.0) + parser.add_argument("--max-aspect-ratio", type=float, default=0.0) + parser.add_argument("--detector-padding", type=int, default=2) + parser.add_argument("--crop-padding", type=int, default=8) + parser.add_argument("--split-tall-components", action="store_true") + parser.add_argument("--split-tall-row-min-ink", type=int, default=2) + parser.add_argument("--split-tall-max-row-gap", type=int, default=4) + parser.add_argument("--split-wide-components", action="store_true") + parser.add_argument("--split-wide-col-min-ink", type=int, default=2) + parser.add_argument("--split-wide-max-col-gap", type=int, default=24) + parser.add_argument("--split-wide-min-width", type=int, default=600) + parser.add_argument("--split-detected-row-components", action="store_true") + parser.add_argument("--split-detected-row-col-min-ink", type=int, default=2) + parser.add_argument("--split-detected-row-max-col-gap", type=int, default=24) + parser.add_argument("--split-detected-row-min-width", type=int, default=600) + parser.add_argument("--split-detected-row-min-segment-width", type=int, default=40) + parser.add_argument("--merge-same-row-components", action="store_true") + parser.add_argument("--merge-same-row-y-tolerance", type=float, default=8.0) + parser.add_argument("--merge-same-row-max-gap", type=float, default=120.0) + parser.add_argument("--merge-same-row-max-center-delta", type=float, default=300.0) + parser.add_argument("--merge-same-row-max-width", type=float, default=420.0) + parser.add_argument("--merge-same-row-auto-fragmented-top-to-bottom", action="store_true") + parser.add_argument("--merge-same-row-auto-min-reduction-ratio", type=float, default=0.18) + parser.add_argument("--merge-same-row-auto-min-reduction-count", type=int, default=8) + parser.add_argument("--rescue-detector-pass", action="append", default=[]) + parser.add_argument("--merge-iou-threshold", type=float, default=0.80) + parser.add_argument("--allow-empty-lines", action=argparse.BooleanOptionalAction, default=True) + return parser + + +def main(argv: list[str] | None = None) -> int: + parser = _build_parser() + args = parser.parse_args(argv) + try: + result = run_limbu_phone_page_ocr(args) + except Exception as exc: + print(f"run_limbu_phone_page_ocr: error: {exc}", file=sys.stderr) + return 2 + print(result["run_summary"]) + print(f"pages={result['page_count']} lines={result['line_count']} empty={result['empty_line_count']}") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ocr-tech-mps-integration/tools/run_page_ocr_eval.py b/ocr-tech-mps-integration/tools/run_page_ocr_eval.py new file mode 100644 index 0000000000000000000000000000000000000000..dff1bb8e5ceb52f08aea18fb51ec9977db223bd6 --- /dev/null +++ b/ocr-tech-mps-integration/tools/run_page_ocr_eval.py @@ -0,0 +1,2278 @@ +#!/usr/bin/env python3 +"""Run a claim-grade page-level OCR evaluation from exported document JSON.""" + +from __future__ import annotations + +import argparse +import csv +import hashlib +import html +import json +import platform +import random +import sys +import unicodedata +from dataclasses import dataclass, field +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +import regex +from rapidfuzz.distance import Levenshtein + +from ocrtech.manifest import ManifestEntry, load_manifest, read_jsonl, sha256_file +from ocrtech.metrics import bbox_iou, detection_score +from ocrtech.references import ReferenceDocument, load_reference, score_document +from ocrtech.schemas import BBox, Document, TextLine + + +DEFAULT_NORMALIZATION = "NFC_preserve_whitespace" +PAGE_OCR_OUTPUT_KINDS = {"live_detector", "oracle_line_boxes", "sidecar_fixture", "unknown"} +CLAIM_SAFE_DOMAINS = {"real_print", "real_handwritten"} +CLAIM_SAFE_GT_STATUSES = {"human_verified", "machine_converted_spot_checked"} +UNCERTAINTY_BOOTSTRAP_SAMPLES = 200 +UNCERTAINTY_BOOTSTRAP_SEED = 1729 +MIN_CLAIM_SCORING_UNITS = 30 +SOURCE_DOCUMENT_KEYS = ("source_document", "source_doc", "source_pdf", "source_image", "source_xml", "document", "doc_id") +PAGE_KEYS = ("page", "page_index", "page_number", "source_page", "page_id") +BBOX_KEYS = ("bbox", "bounding_box", "coords", "polygon") +CLAIM_ELIGIBLE_KEYS = ("claim_evidence_eligible", "claim_eligible", "paper_claim_eligible") +HUMAN_REVIEW_EVIDENCE_KEYS = ( + "reviewed_by", + "reviewer", + "native_reviewer", + "gt_reviewer", + "review_artifact", + "gt_review_artifact", + "review_batch", + "double_reviewed_by", + "inter_annotator_agreement", + "correction_rate", +) +PROVENANCE_SIGNAL_KEYS = ( + "label_provenance", + "gt_source", + "source_gt_status", + "source_label_status", + "reference_status", + "assisted_source", + "source_type", + "data_origin", + "evidence_type", + "dataset_type", + "slices", +) + + +@dataclass +class PageEvalRow: + sample_id: str + input_path: str + input_sha256: str + document_path: str + document_sha256: str + document_source_path: str + language: str + script: str + domain: str + gt_status: str + split: str + claim_eligible: bool + source_document: str = "" + source_page: str = "" + source_bbox: str = "" + reference_path: str = "" + reference_sha256: str = "" + reference_status: str = "" + reference_claim_eligible: str = "" + slices: list[str] = field(default_factory=list) + metrics: dict[str, float] = field(default_factory=dict) + text_codepoint_edits: int = 0 + text_codepoint_ref_len: int = 0 + text_grapheme_edits: int = 0 + text_grapheme_ref_len: int = 0 + text_exact: bool = False + prediction_text: str = "" + reference_text: str = "" + reference_fields: list[str] = field(default_factory=list) + line_alignment: dict[str, float | int] = field(default_factory=dict) + ocr_output_kind: str = "unknown" + + +@dataclass(frozen=True) +class LeakageRow: + sample_id: str + image_path: str + image_sha256: str + text_sha256: str + sample_sha256: str + source_sample_id: str = "" + + +@dataclass(frozen=True) +class ReferenceLine: + line_id: str + text: str + bbox: BBox + page_index: int = 0 + + +@dataclass(frozen=True) +class LineAlignmentRow: + sample_id: str + kind: str + reference_line_id: str + predicted_line_id: str + reference_bbox: str + predicted_bbox: str + page_index: int + iou: float + reference_text: str + predicted_text: str + text_codepoint_edits: int + text_codepoint_ref_len: int + text_cer_codepoint: float + text_grapheme_edits: int + text_grapheme_ref_len: int + text_cer_grapheme: float + + +def _nfc(value: str) -> str: + return unicodedata.normalize("NFC", value or "") + + +def _graphemes(value: str) -> list[str]: + return regex.findall(r"\X", _nfc(value)) + + +def _codepoint_id(ch: str) -> str: + return f"U+{ord(ch):04X}" + + +def _read_script_inventory(path: Path | None) -> dict[str, Any]: + if path is None: + return {} + if not path.exists(): + raise FileNotFoundError(f"script inventory file does not exist: {path}") + payload = json.loads(path.read_text(encoding="utf-8")) + if not isinstance(payload, dict): + raise ValueError(f"script inventory file must contain a JSON object: {path}") + return payload + + +def _required_codepoints(payload: dict[str, Any]) -> list[str]: + raw = payload.get("required_codepoints", []) + if not isinstance(raw, list): + raise ValueError("script inventory required_codepoints must be a list") + required: set[str] = set() + for item in raw: + if not isinstance(item, str): + raise ValueError(f"script inventory codepoint entry must be a string: {item!r}") + value = item.strip() + if not value: + continue + if value.upper().startswith("U+"): + try: + required.add(f"U+{int(value[2:], 16):04X}") + except ValueError as exc: + raise ValueError(f"script inventory codepoint entry is not valid hex: {item!r}") from exc + continue + normalized = _nfc(value) + if len(normalized) != 1: + raise ValueError(f"script inventory codepoint entry must be one character or U+XXXX: {item!r}") + required.add(_codepoint_id(normalized)) + return sorted(required) + + +def _required_graphemes(payload: dict[str, Any]) -> list[str]: + raw = payload.get("required_graphemes", []) + if not isinstance(raw, list): + raise ValueError("script inventory required_graphemes must be a list") + required: set[str] = set() + for item in raw: + if not isinstance(item, str): + raise ValueError(f"script inventory grapheme entry must be a string: {item!r}") + value = _nfc(item) + if value.strip(): + required.add(value) + return sorted(required) + + +def _script_inventory_summary(texts: list[str], inventory_file: Path | None) -> dict[str, Any]: + payload = _read_script_inventory(inventory_file) + text = _nfc("\n".join(texts)) + codepoints = sorted({_codepoint_id(ch) for ch in text if not ch.isspace()}) + graphemes = sorted({cluster for cluster in _graphemes(text) if cluster.strip()}) + required_cps = _required_codepoints(payload) + required_graphs = _required_graphemes(payload) + categories = [unicodedata.category(ch) for ch in text if not ch.isspace()] + return { + "inventory_file": str(inventory_file) if inventory_file else None, + "inventory_file_sha256": sha256_file(inventory_file) if inventory_file else None, + "observed_codepoint_count": len(codepoints), + "observed_grapheme_count": len(graphemes), + "observed_codepoints": codepoints, + "observed_graphemes": graphemes, + "required_codepoints": required_cps, + "required_graphemes": required_graphs, + "missing_required_codepoints": sorted(set(required_cps) - set(codepoints)), + "missing_required_graphemes": sorted(set(required_graphs) - set(graphemes)), + "digit_codepoint_count": sum(1 for ch in text if not ch.isspace() and unicodedata.category(ch) == "Nd"), + "punctuation_codepoint_count": sum(1 for category in categories if category.startswith("P")), + "combining_mark_codepoint_count": sum(1 for category in categories if category.startswith("M")), + } + + +def _dictionary_codepoints(dictionary: str) -> set[str] | None: + path = Path(str(dictionary or "")) + if not path.exists() or not path.is_file(): + return None + codepoints: set[str] = set() + for line in path.read_text(encoding="utf-8").splitlines(): + token = _nfc(line.strip()) + if not token: + continue + for ch in token: + if not ch.isspace(): + codepoints.add(_codepoint_id(ch)) + return codepoints + + +def _dictionary_coverage(texts: list[str], dictionary: str) -> dict[str, Any]: + dictionary_path = Path(str(dictionary or "")) + gt_codepoints = sorted({_codepoint_id(ch) for text in texts for ch in _nfc(text) if not ch.isspace()}) + dictionary_codepoints = _dictionary_codepoints(dictionary) + if dictionary_codepoints is None: + return { + "dictionary": str(dictionary or ""), + "dictionary_file_sha256": None, + "checked": False, + "gt_codepoint_count": len(gt_codepoints), + "missing_gt_codepoints": [], + "missing_gt_codepoint_count": 0, + "reason": "dictionary file is not readable", + } + missing = sorted(set(gt_codepoints) - dictionary_codepoints) + return { + "dictionary": str(dictionary or ""), + "dictionary_file_sha256": sha256_file(dictionary_path), + "checked": True, + "dictionary_codepoint_count": len(dictionary_codepoints), + "gt_codepoint_count": len(gt_codepoints), + "missing_gt_codepoints": missing, + "missing_gt_codepoint_count": len(missing), + } + + +def _normalization_summary(rows: list[PageEvalRow]) -> dict[str, Any]: + prediction_changed = sum(1 for row in rows if row.prediction_text != _nfc(row.prediction_text)) + reference_changed = sum(1 for row in rows if row.reference_text != _nfc(row.reference_text)) + return { + "profile": DEFAULT_NORMALIZATION, + "unit": "page", + "total": len(rows), + "prediction_changed": prediction_changed, + "reference_changed": reference_changed, + "any_changed": sum( + 1 + for row in rows + if row.prediction_text != _nfc(row.prediction_text) or row.reference_text != _nfc(row.reference_text) + ), + } + + +def _text_hash(value: str) -> str: + return hashlib.sha256(_nfc(value).encode("utf-8")).hexdigest() + + +def _sample_hash(image_sha256: str, text_sha256: str) -> str: + return hashlib.sha256(f"{image_sha256}\0{text_sha256}".encode("utf-8")).hexdigest() + + +def _artifact_identity(value: str) -> dict[str, Any]: + value = str(value or "") + if not value: + return {"value": "", "verified": False, "reason": "missing"} + path = Path(value) + if path.exists() and path.is_file(): + return { + "value": value, + "path": str(path), + "sha256": sha256_file(path), + "size_bytes": path.stat().st_size, + "verified": True, + } + return {"value": value, "verified": False, "reason": "not a readable local file"} + + +def _artifact_identities(args: argparse.Namespace) -> dict[str, dict[str, Any]]: + return { + "checkpoint": _artifact_identity(args.checkpoint), + "config": _artifact_identity(args.config), + "dictionary": _artifact_identity(args.dictionary), + } + + +def _ocr_output_kind(args: argparse.Namespace) -> str: + value = str(getattr(args, "ocr_output_kind", "") or "").strip() + if not value: + return "unknown" + if value not in PAGE_OCR_OUTPUT_KINDS: + raise ValueError( + f"unsupported OCR output kind: {value!r}; expected one of {sorted(PAGE_OCR_OUTPUT_KINDS)}" + ) + return value + + +def _resolve_manifest_path(path_value: str, manifest_dir: Path) -> Path: + path = Path(path_value) + if path.is_absolute() or path.exists(): + return path + candidate = manifest_dir / path + if candidate.exists(): + return candidate + return path + + +def _duplicate_values(values: list[str]) -> list[str]: + seen: set[str] = set() + duplicates: set[str] = set() + for value in values: + if value in seen: + duplicates.add(value) + seen.add(value) + return sorted(duplicates) + + +def _validate_manifest_identity(manifest: list[ManifestEntry]) -> None: + sample_ids = [entry.sample_id for entry in manifest if entry.sample_id] + duplicate_sample_ids = _duplicate_values(sample_ids) + if duplicate_sample_ids: + raise ValueError(f"duplicate eval manifest sample_id values: {duplicate_sample_ids[:20]}") + image_paths = [entry.image_path for entry in manifest if entry.image_path] + duplicate_image_paths = _duplicate_values(image_paths) + if duplicate_image_paths: + raise ValueError(f"duplicate eval manifest image_path values: {duplicate_image_paths[:20]}") + + +def _validate_manifest_image_hash(entry: ManifestEntry, input_path: Path) -> str: + actual = sha256_file(input_path) + if entry.sha256 and entry.sha256 != actual: + raise ValueError( + f"eval manifest sha256 mismatch for {entry.sample_id}: " + f"manifest={entry.sha256} actual={actual}" + ) + return actual + + +def _document_candidates(entry: ManifestEntry, input_path: Path, documents_dir: Path) -> list[Path]: + return [ + documents_dir / entry.sample_id / "document.json", + documents_dir / input_path.stem / "document.json", + documents_dir / f"{entry.sample_id}.json", + documents_dir / f"{input_path.stem}.json", + ] + + +def _load_document(entry: ManifestEntry, input_path: Path, documents_dir: Path) -> tuple[Document | None, Path | None]: + for candidate in _document_candidates(entry, input_path, documents_dir): + if not candidate.exists(): + continue + try: + payload = json.loads(candidate.read_text(encoding="utf-8")) + except json.JSONDecodeError as exc: + raise ValueError(f"document JSON is invalid for {entry.sample_id}: {candidate}: {exc}") from exc + if not isinstance(payload, dict): + raise ValueError(f"document JSON must contain an object for {entry.sample_id}: {candidate}") + return Document.from_dict(payload), candidate + return None, None + + +def _page_output_audit_filename(args: argparse.Namespace) -> str: + return str(getattr(args, "output_audit_filename", "") or "limbu-output-audit.json") + + +def _page_output_audit_passed_field(args: argparse.Namespace) -> str: + return str(getattr(args, "output_audit_passed_field", "") or "passed") + + +def _requires_page_output_audit(args: argparse.Namespace, ocr_output_kind: str) -> bool: + return bool(getattr(args, "require_output_audit", False)) or (bool(getattr(args, "require_claim_safe", False)) and ocr_output_kind == "live_detector") + + +def _read_page_output_audit( + sample_id: str, + output_dir: Path, + *, + filename: str, + passed_field: str, +) -> dict[str, Any]: + audit_path = output_dir / filename + row: dict[str, Any] = { + "sample_id": sample_id, + "output_dir": str(output_dir), + "audit_path": str(audit_path), + "exists": audit_path.is_file(), + "passed": False, + "sha256": None, + "size_bytes": None, + "issue": "", + } + if not audit_path.is_file(): + row["issue"] = f"missing page output audit: {audit_path}" + return row + row["sha256"] = sha256_file(audit_path) + row["size_bytes"] = audit_path.stat().st_size + try: + payload = json.loads(audit_path.read_text(encoding="utf-8")) + except json.JSONDecodeError as exc: + row["issue"] = f"page output audit is invalid JSON: {audit_path}: {exc}" + return row + if not isinstance(payload, dict): + row["issue"] = f"page output audit must contain a JSON object: {audit_path}" + return row + passed = payload.get(passed_field) + row["passed"] = passed is True + if passed is not True: + row["issue"] = f"page output audit did not pass: {audit_path} {passed_field}={passed!r}" + return row + + +def _reference_for(entry: ManifestEntry, input_path: Path, manifest_dir: Path) -> ReferenceDocument | None: + explicit = entry.metadata.get("reference_path") if entry.metadata else None + explicit_path = _resolve_manifest_path(explicit, manifest_dir) if isinstance(explicit, str) and explicit else None + return load_reference(input_path, explicit_path=explicit_path) + + +def _reference_path_for(entry: ManifestEntry, input_path: Path, manifest_dir: Path) -> Path | None: + explicit = entry.metadata.get("reference_path") if entry.metadata else None + candidates: list[Path] = [] + if isinstance(explicit, str) and explicit: + candidates.append(_resolve_manifest_path(explicit, manifest_dir)) + candidates.extend( + [ + input_path.with_suffix(input_path.suffix + ".ref.json"), + input_path.with_suffix(".ref.json"), + input_path.with_suffix(input_path.suffix + ".ref.txt"), + input_path.with_suffix(".ref.txt"), + ] + ) + for candidate in candidates: + if candidate.exists(): + return candidate + return None + + +def _reference_payload_for(entry: ManifestEntry, input_path: Path, manifest_dir: Path) -> dict[str, Any] | None: + explicit = entry.metadata.get("reference_path") if entry.metadata else None + candidates: list[Path] = [] + if isinstance(explicit, str) and explicit: + candidates.append(_resolve_manifest_path(explicit, manifest_dir)) + candidates.extend([input_path.with_suffix(input_path.suffix + ".ref.json"), input_path.with_suffix(".ref.json")]) + for candidate in candidates: + if not candidate.exists() or candidate.suffix.lower() != ".json": + continue + try: + payload = json.loads(candidate.read_text(encoding="utf-8")) + except json.JSONDecodeError as exc: + raise ValueError(f"reference JSON is invalid for {entry.sample_id}: {candidate}: {exc}") from exc + if not isinstance(payload, dict): + raise ValueError(f"reference JSON must contain an object for {entry.sample_id}: {candidate}") + return payload + return None + + +def _reference_fields(reference: ReferenceDocument | None) -> list[str]: + if reference is None: + return [] + fields: list[str] = [] + if reference.text is not None: + fields.append("text") + if reference.markdown is not None: + fields.append("markdown") + if reference.reading_order: + fields.append("reading_order") + if reference.tables: + fields.append("tables") + if reference.figures: + fields.append("figures") + return fields + + +def _reference_lines(payload: dict[str, Any] | None) -> list[ReferenceLine]: + if payload is None: + return [] + candidates = payload.get("reading_order") + if candidates is None: + candidates = payload.get("lines") + if not isinstance(candidates, list): + return [] + rows: list[ReferenceLine] = [] + for index, item in enumerate(candidates): + if not isinstance(item, dict): + continue + raw_id = item.get("id") or item.get("line_id") or f"ref-{index:04d}" + raw_bbox = item.get("bbox") + if raw_bbox is None: + continue + try: + bbox = BBox.from_any(raw_bbox) + except Exception: + continue + if bbox.w <= 0 or bbox.h <= 0: + continue + rows.append( + ReferenceLine( + line_id=str(raw_id), + text=str(item.get("text") or ""), + bbox=bbox, + page_index=int(item.get("page_index", 0)), + ) + ) + return rows + + +def _predicted_lines(document: Document) -> list[TextLine]: + lines: list[TextLine] = [] + for page in document.pages: + lines.extend(page.text_lines) + return lines + + +def _predicted_reading_order_ids(document: Document) -> list[str]: + ordered: list[str] = [] + for page in sorted(document.pages, key=lambda item: item.page_index): + for block in sorted(page.blocks, key=lambda item: item.order): + ordered.extend(line_id for line_id in block.line_ids if line_id) + return ordered + + +def _line_structural_role(line: TextLine) -> str: + metadata = line.metadata if isinstance(line.metadata, dict) else {} + role = metadata.get("structural_role") + if not isinstance(role, str) or not role.strip(): + return "text" + return role.strip() + + +def _is_structural_line(line: TextLine) -> bool: + return _line_structural_role(line) not in {"", "text"} + + +def _metric_safe_role(role: str) -> str: + cleaned = "".join(ch if ch.isalnum() else "_" for ch in role.strip().lower()) + return cleaned.strip("_") or "unknown" + + +def _matched_reading_order_counts(predicted_positions: list[int]) -> tuple[int, int]: + correct = 0 + total = 0 + for left_index, left_position in enumerate(predicted_positions): + for right_position in predicted_positions[left_index + 1 :]: + total += 1 + if left_position < right_position: + correct += 1 + return correct, total + + +def _align_lines( + sample_id: str, + reference_lines: list[ReferenceLine], + predicted_lines: list[TextLine], + iou_threshold: float, + *, + predicted_reading_order_ids: list[str] | None = None, +) -> tuple[dict[str, float | int], list[LineAlignmentRow]]: + unmatched_predicted = set(range(len(predicted_lines))) + rows: list[LineAlignmentRow] = [] + matched_ious: list[float] = [] + matched_cp_edits = 0 + matched_cp_len = 0 + matched_gr_edits = 0 + matched_gr_len = 0 + matched_exact = 0 + structural_prediction_count = sum(1 for predicted in predicted_lines if _is_structural_line(predicted)) + structural_role_counts: dict[str, int] = {} + for predicted in predicted_lines: + if not _is_structural_line(predicted): + continue + role_key = _metric_safe_role(_line_structural_role(predicted)) + structural_role_counts[role_key] = structural_role_counts.get(role_key, 0) + 1 + matched_structural_count = 0 + matched_structural_exact = 0 + fallback_positions = { + predicted.line_id or f"__predicted_index_{index}": index + for index, predicted in enumerate(predicted_lines) + } + reading_order_positions = { + line_id: index for index, line_id in enumerate(predicted_reading_order_ids or []) + } + matched_predicted_positions: list[int] = [] + for reference in reference_lines: + best_index: int | None = None + best_iou = 0.0 + for predicted_index in sorted(unmatched_predicted): + predicted = predicted_lines[predicted_index] + if predicted.page_index != reference.page_index: + continue + overlap = bbox_iou(predicted.bbox, reference.bbox) + if overlap > best_iou: + best_iou = overlap + best_index = predicted_index + if best_index is None or best_iou < iou_threshold: + cp_edits, cp_len, gr_edits, gr_len = _score_text_micro("", reference.text) + rows.append( + LineAlignmentRow( + sample_id=sample_id, + kind="reference_unmatched", + reference_line_id=reference.line_id, + predicted_line_id="", + reference_bbox=_bbox_text(reference.bbox), + predicted_bbox="", + page_index=reference.page_index, + iou=best_iou, + reference_text=reference.text, + predicted_text="", + text_codepoint_edits=cp_edits, + text_codepoint_ref_len=cp_len, + text_cer_codepoint=cp_edits / max(cp_len, 1), + text_grapheme_edits=gr_edits, + text_grapheme_ref_len=gr_len, + text_cer_grapheme=gr_edits / max(gr_len, 1), + ) + ) + continue + predicted = predicted_lines[best_index] + unmatched_predicted.remove(best_index) + matched_ious.append(best_iou) + cp_edits, cp_len, gr_edits, gr_len = _score_text_micro(predicted.text, reference.text) + matched_cp_edits += cp_edits + matched_cp_len += cp_len + matched_gr_edits += gr_edits + matched_gr_len += gr_len + matched_exact += int(_nfc(predicted.text) == _nfc(reference.text)) + if _is_structural_line(predicted): + matched_structural_count += 1 + matched_structural_exact += int(_nfc(predicted.text) == _nfc(reference.text)) + predicted_key = predicted.line_id or f"__predicted_index_{best_index}" + matched_predicted_positions.append( + reading_order_positions.get(predicted_key, fallback_positions.get(predicted_key, best_index)) + ) + rows.append( + LineAlignmentRow( + sample_id=sample_id, + kind="matched", + reference_line_id=reference.line_id, + predicted_line_id=predicted.line_id or "", + reference_bbox=_bbox_text(reference.bbox), + predicted_bbox=_bbox_text(predicted.bbox), + page_index=reference.page_index, + iou=best_iou, + reference_text=reference.text, + predicted_text=predicted.text, + text_codepoint_edits=cp_edits, + text_codepoint_ref_len=cp_len, + text_cer_codepoint=cp_edits / max(cp_len, 1), + text_grapheme_edits=gr_edits, + text_grapheme_ref_len=gr_len, + text_cer_grapheme=gr_edits / max(gr_len, 1), + ) + ) + for predicted_index in sorted(unmatched_predicted): + predicted = predicted_lines[predicted_index] + cp_edits, cp_len, gr_edits, gr_len = _score_text_micro(predicted.text, "") + rows.append( + LineAlignmentRow( + sample_id=sample_id, + kind="prediction_unmatched", + reference_line_id="", + predicted_line_id=predicted.line_id or "", + reference_bbox="", + predicted_bbox=_bbox_text(predicted.bbox), + page_index=predicted.page_index, + iou=0.0, + reference_text="", + predicted_text=predicted.text, + text_codepoint_edits=cp_edits, + text_codepoint_ref_len=cp_len, + text_cer_codepoint=1.0 if predicted.text else 0.0, + text_grapheme_edits=gr_edits, + text_grapheme_ref_len=gr_len, + text_cer_grapheme=1.0 if predicted.text else 0.0, + ) + ) + score = detection_score(len(predicted_lines), len(reference_lines), len(matched_ious)) + unmatched_reference_count = len(reference_lines) - len(matched_ious) + unmatched_prediction_count = len(unmatched_predicted) + blank_prediction_count = sum(1 for predicted in predicted_lines if not _nfc(predicted.text).strip()) + blank_unmatched_prediction_count = sum( + 1 for predicted_index in unmatched_predicted if not _nfc(predicted_lines[predicted_index].text).strip() + ) + matched_order_correct, matched_order_pairs = _matched_reading_order_counts(matched_predicted_positions) + alignment = { + "line_reference_count": len(reference_lines), + "line_prediction_count": len(predicted_lines), + "line_match_count": len(matched_ious), + "line_unmatched_reference_count": unmatched_reference_count, + "line_unmatched_prediction_count": unmatched_prediction_count, + "line_blank_prediction_count": blank_prediction_count, + "line_blank_unmatched_prediction_count": blank_unmatched_prediction_count, + "line_missed_reference_rate": unmatched_reference_count / max(len(reference_lines), 1), + "line_extra_prediction_rate": unmatched_prediction_count / max(len(predicted_lines), 1), + "line_blank_prediction_rate": blank_prediction_count / max(len(predicted_lines), 1), + "line_detection_precision": score.precision, + "line_detection_recall": score.recall, + "line_detection_f1": score.f1, + "line_mean_iou": sum(matched_ious) / len(matched_ious) if matched_ious else 0.0, + "matched_line_text_codepoint_edits": matched_cp_edits, + "matched_line_text_codepoint_ref_len": matched_cp_len, + "matched_line_text_cer_codepoint_micro": matched_cp_edits / max(matched_cp_len, 1), + "matched_line_text_grapheme_edits": matched_gr_edits, + "matched_line_text_grapheme_ref_len": matched_gr_len, + "matched_line_text_cer_grapheme_micro": matched_gr_edits / max(matched_gr_len, 1), + "matched_line_text_exact_count": matched_exact, + "matched_line_text_exact_accuracy": matched_exact / max(len(matched_ious), 1), + "matched_line_reading_order_correct_pairs": matched_order_correct, + "matched_line_reading_order_total_pairs": matched_order_pairs, + "matched_line_reading_order_pair_accuracy": matched_order_correct / matched_order_pairs + if matched_order_pairs + else 1.0, + "structural_line_prediction_count": structural_prediction_count, + "structural_line_matched_count": matched_structural_count, + "structural_line_unmatched_count": structural_prediction_count - matched_structural_count, + "structural_line_match_rate": matched_structural_count / max(structural_prediction_count, 1), + "structural_line_exact_text_match_count": matched_structural_exact, + "structural_line_exact_text_match_rate": matched_structural_exact / max(matched_structural_count, 1), + } + for role, count in sorted(structural_role_counts.items()): + alignment[f"structural_role_{role}_prediction_count"] = count + return alignment, rows + + +def _score_text_micro(prediction: str, reference: str) -> tuple[int, int, int, int]: + pred_nfc = _nfc(prediction) + ref_nfc = _nfc(reference) + pred_graph = _graphemes(pred_nfc) + ref_graph = _graphemes(ref_nfc) + return ( + Levenshtein.distance(pred_nfc, ref_nfc), + len(ref_nfc), + Levenshtein.distance(pred_graph, ref_graph), + len(ref_graph), + ) + + +def _entry_slices(entry: ManifestEntry) -> list[str]: + metadata = entry.metadata or {} + slices = metadata.get("slices") + if isinstance(slices, list): + return [str(item) for item in slices] + return [entry.split] + + +def _metadata_value(entry: ManifestEntry, key: str, fallback: str) -> str: + metadata = entry.metadata or {} + value = metadata.get(key) + if value in (None, ""): + return fallback + return str(value) + + +def _entry_language(entry: ManifestEntry, fallback: str) -> str: + return _metadata_value(entry, "language", fallback) + + +def _entry_script(entry: ManifestEntry, fallback: str) -> str: + return _metadata_value(entry, "script", fallback) + + +def _entry_domain(entry: ManifestEntry, fallback: str) -> str: + return _metadata_value(entry, "domain", fallback) + + +def _entry_gt_status(entry: ManifestEntry, fallback: str) -> str: + return _metadata_value(entry, "gt_status", fallback) + + +def _entry_split(entry: ManifestEntry) -> str: + metadata = entry.metadata or {} + value = metadata.get("split") or metadata.get("split_role") or entry.split + return str(value) + + +def _entry_claim_eligible(entry: ManifestEntry, fallback: bool) -> bool: + metadata = entry.metadata or {} + value = next((metadata.get(key) for key in CLAIM_ELIGIBLE_KEYS if metadata.get(key) is not None), None) + if value is None: + return fallback + if isinstance(value, bool): + return value + if isinstance(value, str): + lowered = value.strip().lower() + if lowered in {"1", "true", "yes", "y"}: + return True + if lowered in {"0", "false", "no", "n"}: + return False + return bool(value) + + +def _metadata_signal_text(metadata: dict[str, Any]) -> str: + values: list[str] = [] + for key in PROVENANCE_SIGNAL_KEYS: + value = metadata.get(key) + if value in (None, "", [], {}): + continue + if isinstance(value, list): + values.extend(str(item) for item in value) + elif isinstance(value, dict): + values.extend(f"{item_key}:{item_value}" for item_key, item_value in value.items()) + else: + values.append(str(value)) + return " ".join(values).lower().replace("_", " ").replace("-", " ") + + +def _metadata_contradictions(sample_id: str, metadata: dict[str, Any], domain: str, gt_status: str) -> list[str]: + signal_text = _metadata_signal_text(metadata) + if not signal_text: + return [] + contradictions: list[str] = [] + if domain in CLAIM_SAFE_DOMAINS and any(term in signal_text for term in ("synthetic", "transliterated", "transliteration")): + contradictions.append(f"{sample_id}: synthetic/transliterated provenance is declared as real domain {domain}") + if gt_status == "human_verified" and any( + term in signal_text + for term in ("machine converted", "machine", "synthetic", "transliterated", "transliteration") + ): + contradictions.append(f"{sample_id}: machine/synthetic provenance is declared as human_verified GT") + return contradictions + + +def _read_summary(path: Path | None) -> dict[str, Any]: + if path is None: + return {} + if not path.exists(): + raise FileNotFoundError(f"summary/datasheet file does not exist: {path}") + try: + payload = json.loads(path.read_text(encoding="utf-8")) + except json.JSONDecodeError as exc: + raise ValueError(f"summary/datasheet file is invalid JSON: {path}: {exc}") from exc + if not isinstance(payload, dict): + raise ValueError(f"summary/datasheet file must contain a JSON object: {path}") + return payload + + +def _read_spotcheck_calibration(path: Path | None) -> dict[str, Any]: + if path is None: + return {} + if not path.exists(): + raise FileNotFoundError(f"native spot-check calibration file does not exist: {path}") + try: + payload = json.loads(path.read_text(encoding="utf-8")) + except json.JSONDecodeError as exc: + raise ValueError(f"native spot-check calibration file is invalid JSON: {path}: {exc}") from exc + if not isinstance(payload, dict): + raise ValueError(f"native spot-check calibration file must contain a JSON object: {path}") + return payload + + +def _spotcheck_calibration_summary(payload: dict[str, Any]) -> dict[str, Any]: + return { + "claim_evidence_eligible": payload.get("claim_evidence_eligible"), + "recommended_pack_gt_status": payload.get("recommended_pack_gt_status"), + "language": payload.get("language"), + "script": payload.get("script"), + "domain": payload.get("domain"), + "source_gt_status": payload.get("source_gt_status"), + "counts": payload.get("counts", {}), + "machine_label_metrics": payload.get("machine_label_metrics", {}), + "eligibility_reasons": payload.get("eligibility_reasons", []), + } + + +def _leakage_rows_from_manifest(path: Path, manifest_dir: Path | None = None) -> list[LeakageRow]: + rows: list[LeakageRow] = [] + for payload in read_jsonl(path): + metadata = dict(payload.get("metadata") or {}) + sample_id = str(payload.get("sample_id") or payload.get("id") or metadata.get("sample_id") or "") + image_path_value = str(payload.get("image_path") or payload.get("image") or metadata.get("image_path") or "") + text_value = payload.get("text") if payload.get("text") is not None else metadata.get("text") + text = str(text_value or "") + image_path = _resolve_manifest_path(image_path_value, manifest_dir or path.parent) + image_sha256 = str( + payload.get("sha256") + or payload.get("image_sha256") + or metadata.get("image_sha256") + or metadata.get("sha256") + or metadata.get("source_image_sha256") + or (sha256_file(image_path) if image_path.exists() else "") + ) + text_sha256 = str(payload.get("text_sha256") or metadata.get("text_sha256") or (_text_hash(text) if text else "")) + sample_sha256 = str( + payload.get("sample_sha256") + or metadata.get("sample_sha256") + or (_sample_hash(image_sha256, text_sha256) if image_sha256 and text_sha256 else "") + ) + source_sample_id = str(payload.get("source_sample_id") or metadata.get("source_sample_id") or sample_id) + rows.append( + LeakageRow( + sample_id=sample_id, + image_path=image_path_value, + image_sha256=image_sha256, + text_sha256=text_sha256, + sample_sha256=sample_sha256, + source_sample_id=source_sample_id, + ) + ) + return rows + + +def _overlap(left: list[LeakageRow], right: list[LeakageRow], field_name: str) -> list[str]: + left_values = {str(getattr(row, field_name)) for row in left if getattr(row, field_name)} + right_values = {str(getattr(row, field_name)) for row in right if getattr(row, field_name)} + return sorted(left_values & right_values) + + +def _leakage_report(train_manifests: list[Path], eval_manifest: Path) -> dict[str, Any]: + eval_rows = _leakage_rows_from_manifest(eval_manifest, eval_manifest.parent) + train_rows: list[LeakageRow] = [] + for manifest in train_manifests: + train_rows.extend(_leakage_rows_from_manifest(manifest, manifest.parent)) + overlaps = { + "sample_id": _overlap(train_rows, eval_rows, "sample_id"), + "source_sample_id": _overlap(train_rows, eval_rows, "source_sample_id"), + "image_sha256": _overlap(train_rows, eval_rows, "image_sha256"), + "sample_sha256": _overlap(train_rows, eval_rows, "sample_sha256"), + "image_path": _overlap(train_rows, eval_rows, "image_path"), + "text_sha256": _overlap(train_rows, eval_rows, "text_sha256"), + } + return { + "train_manifests": [str(path) for path in train_manifests], + "checked": bool(train_manifests), + "train_rows": len(train_rows), + "eval_rows": len(eval_rows), + "overlaps": overlaps, + } + + +def _percentile(values: list[float], q: float) -> float: + if not values: + return 0.0 + ordered = sorted(values) + if len(ordered) == 1: + return ordered[0] + position = (len(ordered) - 1) * q + lower = int(position) + upper = min(lower + 1, len(ordered) - 1) + weight = position - lower + return ordered[lower] * (1.0 - weight) + ordered[upper] * weight + + +def _confidence_interval(values: list[float]) -> dict[str, float]: + return { + "low": _percentile(values, 0.025), + "high": _percentile(values, 0.975), + } + + +def _uncertainty(rows: list[PageEvalRow]) -> dict[str, Any]: + n = len(rows) + cp_points: list[float] = [] + gr_points: list[float] = [] + exact_points: list[float] = [] + if n: + rng = random.Random(UNCERTAINTY_BOOTSTRAP_SEED) + for _ in range(UNCERTAINTY_BOOTSTRAP_SAMPLES): + cp_edits = cp_len = gr_edits = gr_len = 0 + exact = text_refs = 0 + for _ in range(n): + row = rows[rng.randrange(n)] + cp_edits += row.text_codepoint_edits + cp_len += row.text_codepoint_ref_len + gr_edits += row.text_grapheme_edits + gr_len += row.text_grapheme_ref_len + if "text" in row.reference_fields: + text_refs += 1 + exact += int(row.text_exact) + cp_points.append(cp_edits / max(cp_len, 1)) + gr_points.append(gr_edits / max(gr_len, 1)) + exact_points.append(exact / max(text_refs, 1)) + return { + "method": "deterministic_page_bootstrap", + "confidence_level": 0.95, + "bootstrap_samples": UNCERTAINTY_BOOTSTRAP_SAMPLES, + "seed": UNCERTAINTY_BOOTSTRAP_SEED, + "scoring_units": n, + "effective_sample_size": n, + "min_claim_scoring_units": MIN_CLAIM_SCORING_UNITS, + "claim_sample_size_ok": n >= MIN_CLAIM_SCORING_UNITS, + "metrics": { + "text_cer_codepoint_micro": _confidence_interval(cp_points), + "text_cer_grapheme_micro": _confidence_interval(gr_points), + "text_exact_accuracy": _confidence_interval(exact_points), + }, + } + + +def _aggregate(rows: list[PageEvalRow]) -> dict[str, Any]: + metric_values: dict[str, list[float]] = {} + for row in rows: + for key, value in row.metrics.items(): + metric_values.setdefault(key, []).append(value) + for key, value in row.line_alignment.items(): + metric_values.setdefault(key, []).append(float(value)) + cp_edits = sum(row.text_codepoint_edits for row in rows) + cp_len = sum(row.text_codepoint_ref_len for row in rows) + gr_edits = sum(row.text_grapheme_edits for row in rows) + gr_len = sum(row.text_grapheme_ref_len for row in rows) + text_reference_pages = sum(1 for row in rows if "text" in row.reference_fields) + text_exact_pages = sum(1 for row in rows if "text" in row.reference_fields and row.text_exact) + zero_length_references = sum(1 for row in rows if "text" in row.reference_fields and len(_nfc(row.reference_text)) == 0) + matched_cp_edits = sum(int(row.line_alignment.get("matched_line_text_codepoint_edits", 0) or 0) for row in rows) + matched_cp_len = sum(int(row.line_alignment.get("matched_line_text_codepoint_ref_len", 0) or 0) for row in rows) + matched_gr_edits = sum(int(row.line_alignment.get("matched_line_text_grapheme_edits", 0) or 0) for row in rows) + matched_gr_len = sum(int(row.line_alignment.get("matched_line_text_grapheme_ref_len", 0) or 0) for row in rows) + matched_exact_count = sum(int(row.line_alignment.get("matched_line_text_exact_count", 0) or 0) for row in rows) + matched_line_count = sum(int(row.line_alignment.get("line_match_count", 0) or 0) for row in rows) + line_reference_count = sum(int(row.line_alignment.get("line_reference_count", 0) or 0) for row in rows) + line_prediction_count = sum(int(row.line_alignment.get("line_prediction_count", 0) or 0) for row in rows) + line_unmatched_reference_count = sum( + int(row.line_alignment.get("line_unmatched_reference_count", 0) or 0) for row in rows + ) + line_unmatched_prediction_count = sum( + int(row.line_alignment.get("line_unmatched_prediction_count", 0) or 0) for row in rows + ) + line_blank_prediction_count = sum(int(row.line_alignment.get("line_blank_prediction_count", 0) or 0) for row in rows) + line_blank_unmatched_prediction_count = sum( + int(row.line_alignment.get("line_blank_unmatched_prediction_count", 0) or 0) for row in rows + ) + line_detection_micro = detection_score(line_prediction_count, line_reference_count, matched_line_count) + matched_order_correct = sum( + int(row.line_alignment.get("matched_line_reading_order_correct_pairs", 0) or 0) for row in rows + ) + matched_order_pairs = sum( + int(row.line_alignment.get("matched_line_reading_order_total_pairs", 0) or 0) for row in rows + ) + structural_prediction_count = sum(int(row.line_alignment.get("structural_line_prediction_count", 0) or 0) for row in rows) + structural_matched_count = sum(int(row.line_alignment.get("structural_line_matched_count", 0) or 0) for row in rows) + structural_unmatched_count = sum(int(row.line_alignment.get("structural_line_unmatched_count", 0) or 0) for row in rows) + structural_exact_count = sum(int(row.line_alignment.get("structural_line_exact_text_match_count", 0) or 0) for row in rows) + structural_role_totals: dict[str, int] = {} + for row in rows: + for key, value in row.line_alignment.items(): + if key.startswith("structural_role_") and key.endswith("_prediction_count"): + structural_role_totals[key] = structural_role_totals.get(key, 0) + int(value or 0) + result = { + "scored_pages": len(rows), + "metric_means": {key: sum(values) / len(values) for key, values in sorted(metric_values.items()) if values}, + "zero_length_text_references": zero_length_references, + "text_codepoint_edits": cp_edits, + "text_codepoint_ref_len": cp_len, + "text_cer_codepoint_micro": cp_edits / max(cp_len, 1), + "text_grapheme_edits": gr_edits, + "text_grapheme_ref_len": gr_len, + "text_cer_grapheme_micro": gr_edits / max(gr_len, 1), + "text_reference_pages": text_reference_pages, + "text_exact_pages": text_exact_pages, + "text_exact_accuracy": text_exact_pages / max(text_reference_pages, 1), + "matched_line_text_codepoint_edits": matched_cp_edits, + "matched_line_text_codepoint_ref_len": matched_cp_len, + "matched_line_text_cer_codepoint_micro": matched_cp_edits / max(matched_cp_len, 1), + "matched_line_text_grapheme_edits": matched_gr_edits, + "matched_line_text_grapheme_ref_len": matched_gr_len, + "matched_line_text_cer_grapheme_micro": matched_gr_edits / max(matched_gr_len, 1), + "matched_line_text_exact_count": matched_exact_count, + "matched_line_text_exact_accuracy": matched_exact_count / max(matched_line_count, 1), + "line_reference_count": line_reference_count, + "line_prediction_count": line_prediction_count, + "line_match_count": matched_line_count, + "line_unmatched_reference_count": line_unmatched_reference_count, + "line_unmatched_prediction_count": line_unmatched_prediction_count, + "line_blank_prediction_count": line_blank_prediction_count, + "line_blank_unmatched_prediction_count": line_blank_unmatched_prediction_count, + "line_detection_precision_micro": line_detection_micro.precision, + "line_detection_recall_micro": line_detection_micro.recall, + "line_detection_f1_micro": line_detection_micro.f1, + "line_missed_reference_rate": line_unmatched_reference_count / max(line_reference_count, 1), + "line_extra_prediction_rate": line_unmatched_prediction_count / max(line_prediction_count, 1), + "line_blank_prediction_rate": line_blank_prediction_count / max(line_prediction_count, 1), + "line_blank_unmatched_prediction_rate": line_blank_unmatched_prediction_count / max(line_prediction_count, 1), + "matched_line_reading_order_correct_pairs": matched_order_correct, + "matched_line_reading_order_total_pairs": matched_order_pairs, + "matched_line_reading_order_pair_accuracy": matched_order_correct / matched_order_pairs + if matched_order_pairs + else 1.0, + "structural_line_prediction_count": structural_prediction_count, + "structural_line_matched_count": structural_matched_count, + "structural_line_unmatched_count": structural_unmatched_count, + "structural_line_match_rate": structural_matched_count / max(structural_prediction_count, 1), + "structural_line_exact_text_match_count": structural_exact_count, + "structural_line_exact_text_match_rate": structural_exact_count / max(structural_matched_count, 1), + "uncertainty": _uncertainty(rows), + } + result.update(structural_role_totals) + return result + + +def _slice_metrics(rows: list[PageEvalRow]) -> list[dict[str, Any]]: + groups: dict[tuple[str, str, str, str, str], list[PageEvalRow]] = {} + for row in rows: + key = (row.language, row.script, row.domain, row.gt_status, row.split) + groups.setdefault(key, []).append(row) + slices: list[dict[str, Any]] = [] + for key, group in sorted(groups.items()): + language, script, domain, gt_status, split = key + metrics = _aggregate(group) + metrics.update( + { + "language": language, + "script": script, + "domain": domain, + "gt_status": gt_status, + "split": split, + } + ) + slices.append(metrics) + return slices + + +def _coverage(rows: list[PageEvalRow]) -> dict[str, int]: + fields = ("text", "markdown", "reading_order", "tables", "figures", "line_bboxes") + coverage = {field: sum(1 for row in rows if field in row.reference_fields) for field in fields} + coverage["line_alignment_scored"] = sum(1 for row in rows if row.line_alignment.get("line_reference_count", 0)) + return coverage + + +def _reference_claim_ready(row: PageEvalRow) -> bool: + return row.reference_status == "verified" and row.reference_claim_eligible.strip().lower() == "true" + + +def _reference_claim_readiness(rows: list[PageEvalRow]) -> dict[str, Any]: + status_counts: dict[str, int] = {} + claim_eligible_counts: dict[str, int] = {} + not_ready: list[str] = [] + for row in rows: + status = row.reference_status or "(missing)" + claim_eligible = row.reference_claim_eligible or "(missing)" + status_counts[status] = status_counts.get(status, 0) + 1 + claim_eligible_counts[claim_eligible] = claim_eligible_counts.get(claim_eligible, 0) + 1 + if not _reference_claim_ready(row): + not_ready.append(row.sample_id) + return { + "ready_count": len(rows) - len(not_ready), + "scored_pages": len(rows), + "status_counts": dict(sorted(status_counts.items())), + "claim_eligible_counts": dict(sorted(claim_eligible_counts.items())), + "not_ready_count": len(not_ready), + "not_ready_sample_ids": not_ready[:50], + } + + +def _metadata_coverage(entries: list[ManifestEntry]) -> dict[str, int]: + def missing(key: str) -> int: + return sum(1 for entry in entries if (entry.metadata or {}).get(key) in (None, "")) + + def has_any(metadata: dict[str, Any], keys: tuple[str, ...]) -> bool: + return any(metadata.get(key) not in (None, "", [], {}) for key in keys) + + def missing_any(keys: tuple[str, ...]) -> int: + return sum(1 for entry in entries if not has_any(entry.metadata or {}, keys)) + + def missing_human_review_evidence() -> int: + return sum( + 1 + for entry in entries + if (entry.metadata or {}).get("gt_status") == "human_verified" + and not has_any(entry.metadata or {}, HUMAN_REVIEW_EVIDENCE_KEYS) + ) + + return { + "missing_source_document": missing_any(SOURCE_DOCUMENT_KEYS), + "missing_page": missing_any(PAGE_KEYS), + "missing_bbox": missing_any(BBOX_KEYS), + "missing_claim_eligibility": missing_any(CLAIM_ELIGIBLE_KEYS), + "missing_human_review_evidence": missing_human_review_evidence(), + "missing_language": missing("language"), + "missing_script": missing("script"), + "missing_domain": missing("domain"), + "missing_gt_status": missing("gt_status"), + } + + +def _metadata_value_for_keys(metadata: dict[str, Any], keys: tuple[str, ...]) -> str: + for key in keys: + value = metadata.get(key) + if value not in (None, "", [], {}): + if isinstance(value, (list, dict)): + return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":")) + return str(value) + return "" + + +def _same_source_path(document_source: str, input_path: Path) -> bool: + if not document_source: + return False + source = Path(document_source) + try: + if source.resolve() == input_path.resolve(): + return True + except OSError: + if document_source == str(input_path): + return True + if source.is_file() and input_path.is_file(): + return sha256_file(source) == sha256_file(input_path) + return False + + +def _document_source_path_mismatch(sample_id: str, document: Document, input_path: Path) -> str | None: + if not _same_source_path(document.source_path, input_path): + return f"{sample_id}: document.source_path {document.source_path!r} does not match eval input {str(input_path)!r}" + return None + + +def _bbox_text(bbox: BBox | None) -> str: + if bbox is None: + return "" + return json.dumps(bbox.to_list(), ensure_ascii=False, separators=(",", ":")) + + +def _warnings( + args: argparse.Namespace, + metrics: dict[str, Any], + leakage: dict[str, Any], + summary: dict[str, Any], + spotcheck_calibration: dict[str, Any], + artifacts: dict[str, dict[str, Any]], + metadata_contradictions: list[str], +) -> list[str]: + warnings: list[str] = [] + if metrics.get("ocr_output_kind") == "unknown": + warnings.append("OCR output kind is not recorded") + page_output_audit = metrics.get("page_output_audit") if isinstance(metrics.get("page_output_audit"), dict) else {} + if page_output_audit.get("required") and page_output_audit.get("passed_count") != page_output_audit.get("expected_count"): + warnings.append( + "page output audits are not all passing: " + f"{page_output_audit.get('passed_count')}/{page_output_audit.get('expected_count')} " + f"filename={page_output_audit.get('filename')!r}" + ) + if metrics["missing_documents"]: + warnings.append(f"missing document outputs: {metrics['missing_documents']}/{metrics['manifest_samples']}") + if metrics["missing_references"]: + warnings.append(f"missing references: {metrics['missing_references']}/{metrics['manifest_samples']}") + if metrics["scored_pages"] < metrics["manifest_samples"]: + warnings.append(f"incomplete page scoring coverage: {metrics['scored_pages']}/{metrics['manifest_samples']}") + document_source_path_mismatches = metrics.get("document_source_path_mismatches") + if isinstance(document_source_path_mismatches, list) and document_source_path_mismatches: + warnings.append( + "document source_path mismatches detected: " + + "; ".join(str(item) for item in document_source_path_mismatches[:10]) + + (f"; ... {len(document_source_path_mismatches) - 10} more" if len(document_source_path_mismatches) > 10 else "") + ) + if not args.eval_pack_version: + warnings.append("eval pack version not recorded") + if not str(args.system_name or "").strip(): + warnings.append("system name not recorded") + if not str(args.model_name or "").strip(): + warnings.append("model name not recorded") + for name, identity in artifacts.items(): + if not identity.get("verified"): + warnings.append(f"{name} artifact is not hash-verifiable: {identity.get('reason') or 'unverified'}") + if not args.frozen_eval_pack: + warnings.append("eval pack is not declared frozen") + if not args.unseen_for_selection: + warnings.append("eval pack is not declared unseen for model/checkpoint selection") + if args.selected_checkpoint_on_test: + warnings.append("checkpoint/model selection on this test pack is declared") + if not args.claim_eligible: + warnings.append("eval pack is not declared claim eligible") + if metrics["claim_eligible_rows"] != metrics["manifest_samples"]: + warnings.append(f"not all manifest rows are claim eligible: {metrics['claim_eligible_rows']}/{metrics['manifest_samples']}") + if args.summary_file is None: + warnings.append("eval pack summary/datasheet missing") + if summary and not any(key in summary for key in ("dataset", "datasheet", "eval_pack", "version", "eval_pack_version")): + warnings.append("eval pack summary lacks dataset/version/eval_pack metadata") + if summary: + summary_pack_content_sha256 = _summary_pack_content_sha256(summary) + pack_content_sha256 = metrics.get("pack_content_sha256") + if not summary_pack_content_sha256: + warnings.append("eval pack summary missing pack_content_sha256") + elif summary_pack_content_sha256 != pack_content_sha256: + warnings.append( + "pack content digest mismatch: " + f"summary={summary_pack_content_sha256} actual={pack_content_sha256}" + ) + metadata_coverage = metrics.get("metadata_coverage") or {} + for key, count in metadata_coverage.items(): + if count: + warnings.append(f"{key}: {count}/{metrics['manifest_samples']}") + if metadata_contradictions: + warnings.append( + "metadata contradictions detected: " + + "; ".join(metadata_contradictions[:10]) + + (f"; ... {len(metadata_contradictions) - 10} more" if len(metadata_contradictions) > 10 else "") + ) + script_inventory = metrics.get("script_inventory") if isinstance(metrics.get("script_inventory"), dict) else {} + if not script_inventory.get("inventory_file"): + warnings.append("script inventory file missing") + if script_inventory.get("missing_required_codepoints"): + warnings.append(f"missing required script codepoints: {script_inventory['missing_required_codepoints'][:20]}") + if script_inventory.get("missing_required_graphemes"): + warnings.append(f"missing required script graphemes: {script_inventory['missing_required_graphemes'][:20]}") + dictionary_coverage = metrics.get("dictionary_coverage") if isinstance(metrics.get("dictionary_coverage"), dict) else {} + if dictionary_coverage.get("checked") and dictionary_coverage.get("missing_gt_codepoints"): + warnings.append(f"GT codepoints missing from dictionary: {dictionary_coverage['missing_gt_codepoints'][:20]}") + if int(metrics.get("zero_length_text_references", 0) or 0): + warnings.append(f"zero-length text references present: {metrics['zero_length_text_references']}/{metrics['text_reference_pages']}") + reference_readiness = metrics.get("reference_claim_readiness") if isinstance(metrics.get("reference_claim_readiness"), dict) else {} + if reference_readiness.get("ready_count") != metrics.get("scored_pages"): + warnings.append( + "references are not all claim-ready: " + f"{reference_readiness.get('ready_count', 0)}/{metrics.get('scored_pages', 0)} " + "have reference_status=verified and claim_evidence_eligible=true; " + f"not_ready={reference_readiness.get('not_ready_sample_ids', [])[:10]}" + ) + uncertainty = metrics.get("uncertainty") if isinstance(metrics.get("uncertainty"), dict) else {} + effective_sample_size = int(uncertainty.get("effective_sample_size", metrics.get("scored_pages", 0)) or 0) + min_claim_scoring_units = int(uncertainty.get("min_claim_scoring_units", MIN_CLAIM_SCORING_UNITS) or MIN_CLAIM_SCORING_UNITS) + if effective_sample_size < min_claim_scoring_units: + warnings.append(f"claim-facing sample size too small: {effective_sample_size} scoring units, minimum {min_claim_scoring_units}") + slices = metrics.get("slices") or [] + for row in slices: + if not isinstance(row, dict): + continue + count = int(row.get("scored_pages", 0) or 0) + if count < min_claim_scoring_units: + warnings.append( + "slice sample size too small: " + f"{row.get('language')}/{row.get('script')}/{row.get('domain')}/{row.get('gt_status')}/{row.get('split')} " + f"has {count} scoring units, minimum {min_claim_scoring_units}" + ) + languages = {str(row.get("language")) for row in slices if isinstance(row, dict)} + scripts = {str(row.get("script")) for row in slices if isinstance(row, dict)} + domains = {str(row.get("domain")) for row in slices if isinstance(row, dict)} + gt_statuses = {str(row.get("gt_status")) for row in slices if isinstance(row, dict)} + splits = {str(row.get("split")) for row in slices if isinstance(row, dict)} + if len(languages) > 1: + warnings.append(f"mixed languages: {sorted(languages)}") + if len(scripts) > 1: + warnings.append(f"mixed scripts: {sorted(scripts)}") + if len(domains) > 1: + warnings.append(f"mixed eval domains: {sorted(domains)}") + if len(gt_statuses) > 1: + warnings.append(f"mixed GT statuses: {sorted(gt_statuses)}") + if len(splits) > 1: + warnings.append(f"mixed split statuses: {sorted(splits)}") + if not splits <= {"eval", "test", "heldout", "held_out", "validation"}: + warnings.append(f"unexpected split status for claim evaluation: {sorted(splits)}") + if not domains <= CLAIM_SAFE_DOMAINS: + warnings.append(f"not claim-safe real domain: {sorted(domains)}") + if not gt_statuses <= CLAIM_SAFE_GT_STATUSES: + warnings.append(f"not human-verified/spot-checked GT: {sorted(gt_statuses)}") + if "machine_converted_spot_checked" in gt_statuses: + if args.spotcheck_calibration_file is None: + warnings.append("machine_converted_spot_checked GT declared without native spot-check calibration artifact") + else: + if not spotcheck_calibration.get("claim_evidence_eligible"): + warnings.append("native spot-check calibration artifact is not claim evidence eligible") + if spotcheck_calibration.get("recommended_pack_gt_status") != "machine_converted_spot_checked": + warnings.append("native spot-check calibration does not recommend machine_converted_spot_checked GT") + if spotcheck_calibration.get("source_gt_status") != "machine_converted": + warnings.append("native spot-check calibration source_gt_status is not machine_converted") + for field, values in (("language", languages), ("script", scripts), ("domain", domains)): + value = spotcheck_calibration.get(field) + if not isinstance(value, str) or not value: + warnings.append(f"native spot-check calibration missing {field}") + elif value not in values: + warnings.append(f"native spot-check calibration {field} mismatch: {value!r} not in {sorted(values)}") + coverage = metrics["reference_coverage"] + if not coverage["text"]: + warnings.append("no text references scored") + if not coverage["reading_order"]: + warnings.append("no reading-order references scored") + if not coverage["line_alignment_scored"]: + warnings.append("no line-bbox alignment references scored") + if not (coverage["tables"] or coverage["figures"]): + warnings.append("no layout detection references scored") + leakage_overlaps = leakage.get("overlaps", {}) + hard_leakage = {key: values for key, values in leakage_overlaps.items() if key != "text_sha256" and values} + text_overlap = leakage_overlaps.get("text_sha256") or [] + if hard_leakage: + warnings.append("train/dev/eval leakage detected: " + json.dumps({key: values[:10] for key, values in hard_leakage.items()}, ensure_ascii=False)) + if text_overlap: + warnings.append(f"train/dev/eval text overlap detected: {len(text_overlap)} text hashes") + if not args.train_manifest: + warnings.append("train/dev leakage check not run") + return warnings + + +def _write_rows(path: Path, rows: list[PageEvalRow]) -> None: + metric_names = sorted({name for row in rows for name in row.metrics}) + alignment_names = sorted({name for row in rows for name in row.line_alignment}) + fields = [ + "sample_id", + "input_path", + "input_sha256", + "document_path", + "document_sha256", + "document_source_path", + "ocr_output_kind", + "language", + "script", + "domain", + "gt_status", + "split", + "claim_eligible", + "source_document", + "source_page", + "source_bbox", + "reference_fields", + "text_codepoint_edits", + "text_codepoint_ref_len", + "text_cer_codepoint", + "text_grapheme_edits", + "text_grapheme_ref_len", + "text_cer_grapheme", + "text_exact", + *metric_names, + *alignment_names, + ] + with path.open("w", encoding="utf-8", newline="") as handle: + writer = csv.DictWriter(handle, fieldnames=fields) + writer.writeheader() + for row in rows: + payload: dict[str, Any] = { + "sample_id": row.sample_id, + "input_path": row.input_path, + "input_sha256": row.input_sha256, + "document_path": row.document_path, + "document_sha256": row.document_sha256, + "document_source_path": row.document_source_path, + "ocr_output_kind": row.ocr_output_kind, + "language": row.language, + "script": row.script, + "domain": row.domain, + "gt_status": row.gt_status, + "split": row.split, + "claim_eligible": row.claim_eligible, + "source_document": row.source_document, + "source_page": row.source_page, + "source_bbox": row.source_bbox, + "reference_fields": ";".join(row.reference_fields), + "text_codepoint_edits": row.text_codepoint_edits, + "text_codepoint_ref_len": row.text_codepoint_ref_len, + "text_cer_codepoint": row.text_codepoint_edits / max(row.text_codepoint_ref_len, 1), + "text_grapheme_edits": row.text_grapheme_edits, + "text_grapheme_ref_len": row.text_grapheme_ref_len, + "text_cer_grapheme": row.text_grapheme_edits / max(row.text_grapheme_ref_len, 1), + "text_exact": row.text_exact, + } + payload.update(row.metrics) + payload.update(row.line_alignment) + writer.writerow(payload) + + +def _text_sha256(text: str) -> str: + return hashlib.sha256(text.encode("utf-8")).hexdigest() + + +def _page_pack_content_digest(rows: list[PageEvalRow]) -> str: + canonical_rows = [ + { + "sample_id": row.sample_id, + "input_sha256": row.input_sha256, + "reference_sha256": row.reference_sha256, + "reference_text_sha256": _text_sha256(row.reference_text), + "language": row.language, + "script": row.script, + "domain": row.domain, + "gt_status": row.gt_status, + "split": row.split, + "claim_eligible": bool(row.claim_eligible), + "source_document": row.source_document, + "source_page": row.source_page, + "source_bbox": row.source_bbox, + "reference_fields": ";".join(row.reference_fields), + "reference_status": row.reference_status, + "reference_claim_eligible": row.reference_claim_eligible, + } + for row in rows + ] + payload = "\n".join( + json.dumps(row, ensure_ascii=False, sort_keys=True, separators=(",", ":")) + for row in sorted(canonical_rows, key=lambda item: item["sample_id"]) + ) + return hashlib.sha256(payload.encode("utf-8")).hexdigest() + + +def _summary_pack_content_sha256(summary: dict[str, Any]) -> str: + value = summary.get("pack_content_sha256") + if isinstance(value, str) and value: + return value + eval_pack = summary.get("eval_pack") + if isinstance(eval_pack, dict): + nested = eval_pack.get("pack_content_sha256") + if isinstance(nested, str) and nested: + return nested + return "" + + +def _write_text_pairs(path: Path, rows: list[PageEvalRow]) -> None: + fields = [ + "sample_id", + "input_path", + "document_path", + "prediction_text_sha256", + "reference_text_sha256", + "prediction_text", + "reference_text", + "text_codepoint_edits", + "text_codepoint_ref_len", + "text_grapheme_edits", + "text_grapheme_ref_len", + "text_exact", + ] + with path.open("w", encoding="utf-8", newline="") as handle: + writer = csv.DictWriter(handle, fieldnames=fields, delimiter="\t") + writer.writeheader() + for row in rows: + writer.writerow( + { + "sample_id": row.sample_id, + "input_path": row.input_path, + "document_path": row.document_path, + "prediction_text_sha256": _text_sha256(row.prediction_text), + "reference_text_sha256": _text_sha256(row.reference_text), + "prediction_text": row.prediction_text, + "reference_text": row.reference_text, + "text_codepoint_edits": row.text_codepoint_edits, + "text_codepoint_ref_len": row.text_codepoint_ref_len, + "text_grapheme_edits": row.text_grapheme_edits, + "text_grapheme_ref_len": row.text_grapheme_ref_len, + "text_exact": row.text_exact, + } + ) + + +def _write_reference_artifacts(path: Path, rows: list[PageEvalRow]) -> None: + fields = [ + "sample_id", + "input_path", + "reference_path", + "reference_sha256", + "reference_fields", + "reference_text_sha256", + "reference_status", + "reference_claim_eligible", + ] + with path.open("w", encoding="utf-8", newline="") as handle: + writer = csv.DictWriter(handle, fieldnames=fields, delimiter="\t") + writer.writeheader() + for row in rows: + writer.writerow( + { + "sample_id": row.sample_id, + "input_path": row.input_path, + "reference_path": row.reference_path, + "reference_sha256": row.reference_sha256, + "reference_fields": ";".join(row.reference_fields), + "reference_text_sha256": _text_sha256(row.reference_text), + "reference_status": row.reference_status, + "reference_claim_eligible": row.reference_claim_eligible, + } + ) + + +def _write_missing(path: Path, missing_documents: list[str], missing_references: list[str]) -> None: + with path.open("w", encoding="utf-8", newline="") as handle: + writer = csv.DictWriter(handle, fieldnames=["kind", "sample_id"]) + writer.writeheader() + for sample_id in missing_documents: + writer.writerow({"kind": "missing_document", "sample_id": sample_id}) + for sample_id in missing_references: + writer.writerow({"kind": "missing_reference", "sample_id": sample_id}) + + +def _confusions(rows: list[PageEvalRow], limit: int = 200) -> dict[str, int]: + counts: dict[str, int] = {} + for row in rows: + prediction = _nfc(row.prediction_text) + reference = _nfc(row.reference_text) + for opcode in Levenshtein.opcodes(prediction, reference): + tag, i1, i2, j1, j2 = opcode + if tag == "equal": + continue + left = prediction[i1:i2] or "" + right = reference[j1:j2] or "" + key = f"{left}->{right}" + counts[key] = counts.get(key, 0) + 1 + return dict(sorted(counts.items(), key=lambda item: item[1], reverse=True)[:limit]) + + +def _write_worst(path: Path, rows: list[PageEvalRow], limit: int) -> list[PageEvalRow]: + worst = sorted(rows, key=lambda row: row.text_grapheme_edits / max(row.text_grapheme_ref_len, 1), reverse=True)[:limit] + fields = [ + "sample_id", + "input_path", + "input_sha256", + "document_path", + "document_sha256", + "document_source_path", + "language", + "script", + "domain", + "gt_status", + "split", + "claim_eligible", + "source_document", + "source_page", + "source_bbox", + "reference_path", + "reference_sha256", + "reference_status", + "reference_claim_eligible", + "text_cer_grapheme", + "text_cer_codepoint", + "reference_fields", + ] + with path.open("w", encoding="utf-8", newline="") as handle: + writer = csv.DictWriter(handle, fieldnames=fields) + writer.writeheader() + for row in worst: + writer.writerow( + { + "sample_id": row.sample_id, + "input_path": row.input_path, + "input_sha256": row.input_sha256, + "document_path": row.document_path, + "document_sha256": row.document_sha256, + "document_source_path": row.document_source_path, + "language": row.language, + "script": row.script, + "domain": row.domain, + "gt_status": row.gt_status, + "split": row.split, + "claim_eligible": row.claim_eligible, + "source_document": row.source_document, + "source_page": row.source_page, + "source_bbox": row.source_bbox, + "reference_path": row.reference_path, + "reference_sha256": row.reference_sha256, + "reference_status": row.reference_status, + "reference_claim_eligible": row.reference_claim_eligible, + "text_cer_grapheme": row.text_grapheme_edits / max(row.text_grapheme_ref_len, 1), + "text_cer_codepoint": row.text_codepoint_edits / max(row.text_codepoint_ref_len, 1), + "reference_fields": ";".join(row.reference_fields), + } + ) + return worst + + +def _write_review_csv(path: Path, rows: list[PageEvalRow]) -> None: + fields = [ + "sample_id", + "input_path", + "document_path", + "document_source_path", + "text_cer_grapheme", + "text_cer_codepoint", + "reference_fields", + "review_status", + "reviewer", + "notes", + ] + with path.open("w", encoding="utf-8", newline="") as handle: + writer = csv.DictWriter(handle, fieldnames=fields) + writer.writeheader() + for row in rows: + writer.writerow( + { + "sample_id": row.sample_id, + "input_path": row.input_path, + "document_path": row.document_path, + "document_source_path": row.document_source_path, + "text_cer_grapheme": row.text_grapheme_edits / max(row.text_grapheme_ref_len, 1), + "text_cer_codepoint": row.text_codepoint_edits / max(row.text_codepoint_ref_len, 1), + "reference_fields": ";".join(row.reference_fields), + "review_status": "", + "reviewer": "", + "notes": "", + } + ) + + +def _write_review_html(path: Path, rows: list[PageEvalRow]) -> None: + cards = [] + for row in rows: + image_uri = Path(row.input_path).resolve().as_uri() + cards.append( + f""" +
+

{html.escape(row.sample_id)}

+ {html.escape(row.sample_id)} +
+
Document JSON
{html.escape(row.document_path)}
+
Document source
{html.escape(row.document_source_path)}
+
Language / script
{html.escape(row.language)} / {html.escape(row.script)}
+
Domain / GT / split
{html.escape(row.domain)} / {html.escape(row.gt_status)} / {html.escape(row.split)}
+
Text grapheme CER
{row.text_grapheme_edits / max(row.text_grapheme_ref_len, 1):.6f}
+
Text codepoint CER
{row.text_codepoint_edits / max(row.text_codepoint_ref_len, 1):.6f}
+
Reference fields
{html.escape(';'.join(row.reference_fields))}
+
+
+""" + ) + path.write_text( + """ +

Page OCR Eval Review Sample

""" + + "\n".join(cards) + + "\n", + encoding="utf-8", + ) + + +def _write_line_alignment(path: Path, rows: list[LineAlignmentRow]) -> None: + fields = [ + "sample_id", + "kind", + "reference_line_id", + "predicted_line_id", + "reference_bbox", + "predicted_bbox", + "page_index", + "iou", + "reference_text", + "predicted_text", + "text_codepoint_edits", + "text_codepoint_ref_len", + "text_cer_codepoint", + "text_grapheme_edits", + "text_grapheme_ref_len", + "text_cer_grapheme", + ] + with path.open("w", encoding="utf-8", newline="") as handle: + writer = csv.DictWriter(handle, fieldnames=fields) + writer.writeheader() + for row in rows: + writer.writerow( + { + "sample_id": row.sample_id, + "kind": row.kind, + "reference_line_id": row.reference_line_id, + "predicted_line_id": row.predicted_line_id, + "reference_bbox": row.reference_bbox, + "predicted_bbox": row.predicted_bbox, + "page_index": row.page_index, + "iou": row.iou, + "reference_text": row.reference_text, + "predicted_text": row.predicted_text, + "text_codepoint_edits": row.text_codepoint_edits, + "text_codepoint_ref_len": row.text_codepoint_ref_len, + "text_cer_codepoint": row.text_cer_codepoint, + "text_grapheme_edits": row.text_grapheme_edits, + "text_grapheme_ref_len": row.text_grapheme_ref_len, + "text_cer_grapheme": row.text_cer_grapheme, + } + ) + + +def _write_metrics_md(path: Path, metrics: dict[str, Any], warnings: list[str]) -> None: + uncertainty = metrics.get("uncertainty") if isinstance(metrics.get("uncertainty"), dict) else {} + intervals = uncertainty.get("metrics") if isinstance(uncertainty.get("metrics"), dict) else {} + graph_interval = intervals.get("text_cer_grapheme_micro") if isinstance(intervals.get("text_cer_grapheme_micro"), dict) else {} + inventory = metrics.get("script_inventory") if isinstance(metrics.get("script_inventory"), dict) else {} + normalization = metrics.get("normalization_summary") if isinstance(metrics.get("normalization_summary"), dict) else {} + dictionary_coverage = metrics.get("dictionary_coverage") if isinstance(metrics.get("dictionary_coverage"), dict) else {} + page_output_audit = metrics.get("page_output_audit") if isinstance(metrics.get("page_output_audit"), dict) else {} + reference_readiness = metrics.get("reference_claim_readiness") if isinstance(metrics.get("reference_claim_readiness"), dict) else {} + lines = [ + "# Page OCR Eval Metrics", + "", + f"- manifest samples: {metrics['manifest_samples']}", + f"- scored pages: {metrics['scored_pages']}", + f"- missing documents: {metrics['missing_documents']}", + f"- missing references: {metrics['missing_references']}", + f"- OCR output kind: {metrics.get('ocr_output_kind')}", + f"- page output audit required: {page_output_audit.get('required', False)}", + f"- page output audit passed: {page_output_audit.get('passed_count', 0)}/{page_output_audit.get('expected_count', 0)}", + f"- text codepoint CER micro: {metrics['text_cer_codepoint_micro']:.6f}", + f"- text grapheme CER micro: {metrics['text_cer_grapheme_micro']:.6f}", + f"- text exact accuracy: {metrics['text_exact_accuracy']:.6f}", + f"- text codepoint edits/ref: {metrics['text_codepoint_edits']}/{metrics['text_codepoint_ref_len']}", + f"- text grapheme edits/ref: {metrics['text_grapheme_edits']}/{metrics['text_grapheme_ref_len']}", + f"- text exact pages/ref pages: {metrics['text_exact_pages']}/{metrics['text_reference_pages']}", + f"- zero-length text references: {metrics.get('zero_length_text_references')}", + f"- reference claim-ready: {reference_readiness.get('ready_count')}/{reference_readiness.get('scored_pages')}", + f"- reference status counts: {reference_readiness.get('status_counts')}", + f"- reference claim-eligible counts: {reference_readiness.get('claim_eligible_counts')}", + f"- normalization profile: {normalization.get('profile')}", + f"- normalization changed reference/prediction/any: {normalization.get('reference_changed')}/{normalization.get('prediction_changed')}/{normalization.get('any_changed')} of {normalization.get('total')}", + f"- dictionary coverage checked: {dictionary_coverage.get('checked')}", + f"- dictionary reference codepoints/dictionary codepoints: {dictionary_coverage.get('gt_codepoint_count')}/{dictionary_coverage.get('dictionary_codepoint_count')}", + f"- dictionary missing reference codepoints: {dictionary_coverage.get('missing_gt_codepoints')}", + f"- line detection F1 mean: {metrics['metric_means'].get('line_detection_f1', 0.0):.6f}", + f"- line detection precision/recall/F1 micro: {metrics.get('line_detection_precision_micro', 0.0):.6f}/{metrics.get('line_detection_recall_micro', 0.0):.6f}/{metrics.get('line_detection_f1_micro', 0.0):.6f}", + f"- line reference/prediction/match counts: {metrics.get('line_reference_count')}/{metrics.get('line_prediction_count')}/{metrics.get('line_match_count')}", + f"- missed/extra/blank line rates: {metrics.get('line_missed_reference_rate', 0.0):.6f}/{metrics.get('line_extra_prediction_rate', 0.0):.6f}/{metrics.get('line_blank_prediction_rate', 0.0):.6f}", + f"- unmatched reference/prediction counts: {metrics.get('line_unmatched_reference_count')}/{metrics.get('line_unmatched_prediction_count')}", + f"- blank prediction/unmatched blank prediction counts: {metrics.get('line_blank_prediction_count')}/{metrics.get('line_blank_unmatched_prediction_count')}", + f"- line mean IoU: {metrics['metric_means'].get('line_mean_iou', 0.0):.6f}", + f"- matched-line text codepoint CER micro: {metrics.get('matched_line_text_cer_codepoint_micro', 0.0):.6f}", + f"- matched-line text grapheme CER micro: {metrics.get('matched_line_text_cer_grapheme_micro', 0.0):.6f}", + f"- matched-line exact accuracy: {metrics.get('matched_line_text_exact_accuracy', 0.0):.6f}", + f"- matched-line reading-order pair accuracy: {metrics.get('matched_line_reading_order_pair_accuracy', 0.0):.6f}", + f"- matched-line reading-order correct/total pairs: {metrics.get('matched_line_reading_order_correct_pairs')}/{metrics.get('matched_line_reading_order_total_pairs')}", + f"- matched-line text codepoint edits/ref: {metrics.get('matched_line_text_codepoint_edits')}/{metrics.get('matched_line_text_codepoint_ref_len')}", + f"- matched-line text grapheme edits/ref: {metrics.get('matched_line_text_grapheme_edits')}/{metrics.get('matched_line_text_grapheme_ref_len')}", + f"- structural line prediction/matched/unmatched counts: {metrics.get('structural_line_prediction_count')}/{metrics.get('structural_line_matched_count')}/{metrics.get('structural_line_unmatched_count')}", + f"- structural line match/exact-text rates: {metrics.get('structural_line_match_rate', 0.0):.6f}/{metrics.get('structural_line_exact_text_match_rate', 0.0):.6f}", + f"- uncertainty method: {uncertainty.get('method')}", + f"- uncertainty scoring units: {uncertainty.get('effective_sample_size')}/{uncertainty.get('min_claim_scoring_units')}", + f"- text grapheme CER 95% CI: {_fmt_metric(graph_interval.get('low'))}..{_fmt_metric(graph_interval.get('high'))}", + f"- script inventory file: {inventory.get('inventory_file')}", + f"- observed codepoints/graphemes: {inventory.get('observed_codepoint_count')}/{inventory.get('observed_grapheme_count')}", + f"- missing required codepoints: {inventory.get('missing_required_codepoints')}", + f"- missing required graphemes: {inventory.get('missing_required_graphemes')}", + "", + "## Mean Page Metrics", + "", + ] + lines.extend([f"- {key}: {value:.6f}" for key, value in metrics["metric_means"].items()] or ["- none"]) + lines.extend(["", "## Slices", ""]) + for row in metrics["slices"]: + lines.append( + f"- {row['language']} / {row['script']} / {row['domain']} / {row['gt_status']} / {row['split']}: " + f"pages={row['scored_pages']} text_graph_CER={row['text_cer_grapheme_micro']:.6f} " + f"text_cp_CER={row['text_cer_codepoint_micro']:.6f} " + f"line_F1={row['metric_means'].get('line_detection_f1', 0.0):.6f}" + ) + lines.extend(["", "## Reference Coverage", ""]) + lines.extend([f"- {key}: {value}" for key, value in metrics["reference_coverage"].items()]) + lines.extend(["", "## Warnings", ""]) + lines.extend([f"- {warning}" for warning in warnings] or ["- none"]) + path.write_text("\n".join(lines) + "\n", encoding="utf-8") + + +def _fmt_metric(value: Any) -> str: + if isinstance(value, int | float) and not isinstance(value, bool): + return f"{float(value):.6f}" + return str(value) + + +def _write_claim_safety_report(path: Path, eval_run: dict[str, Any], metrics: dict[str, Any]) -> None: + warnings = eval_run.get("warnings") or [] + machine = eval_run.get("machine") if isinstance(eval_run.get("machine"), dict) else {} + coverage = metrics.get("reference_coverage") if isinstance(metrics.get("reference_coverage"), dict) else {} + metadata_coverage = metrics.get("metadata_coverage") if isinstance(metrics.get("metadata_coverage"), dict) else {} + leakage = metrics.get("leakage") if isinstance(metrics.get("leakage"), dict) else {} + metric_means = metrics.get("metric_means") if isinstance(metrics.get("metric_means"), dict) else {} + uncertainty = metrics.get("uncertainty") if isinstance(metrics.get("uncertainty"), dict) else {} + intervals = uncertainty.get("metrics") if isinstance(uncertainty.get("metrics"), dict) else {} + graph_interval = intervals.get("text_cer_grapheme_micro") if isinstance(intervals.get("text_cer_grapheme_micro"), dict) else {} + inventory = metrics.get("script_inventory") if isinstance(metrics.get("script_inventory"), dict) else {} + normalization = metrics.get("normalization_summary") if isinstance(metrics.get("normalization_summary"), dict) else {} + dictionary_coverage = metrics.get("dictionary_coverage") if isinstance(metrics.get("dictionary_coverage"), dict) else {} + page_output_audit = eval_run.get("page_output_audit") if isinstance(eval_run.get("page_output_audit"), dict) else {} + reference_readiness = metrics.get("reference_claim_readiness") if isinstance(metrics.get("reference_claim_readiness"), dict) else {} + lines = [ + "# Eval Claim Safety Report", + "", + f"- eval mode: {eval_run.get('eval_mode')}", + f"- claim safe: {eval_run.get('claim_safe')}", + f"- created at: {eval_run.get('created_at')}", + f"- machine platform: {machine.get('platform')}", + f"- machine python: {machine.get('python')}", + f"- command: {eval_run.get('command')}", + "", + "## What Was Scored", + "", + f"- system: {eval_run.get('system_name')}", + f"- model: {eval_run.get('model_name')}", + f"- checkpoint: {eval_run.get('checkpoint') or '(not recorded)'}", + f"- config: {eval_run.get('config') or '(not recorded)'}", + f"- dictionary: {eval_run.get('dictionary') or '(not recorded)'}", + f"- artifact identity: {json.dumps(eval_run.get('artifact_identity', {}), ensure_ascii=False, sort_keys=True)}", + f"- eval manifest: {eval_run.get('eval_manifest')}", + f"- documents dir: {eval_run.get('documents_dir')}", + f"- OCR output kind: {eval_run.get('ocr_output_kind')}", + f"- page output audit required: {eval_run.get('require_output_audit')}", + f"- page output audit passed: {page_output_audit.get('passed_count', 0)}/{page_output_audit.get('expected_count', 0)}", + f"- manifest samples: {metrics.get('manifest_samples')}", + f"- scored pages: {metrics.get('scored_pages')}", + f"- missing documents: {metrics.get('missing_documents')}", + f"- missing references: {metrics.get('missing_references')}", + f"- review CSV: sample-review.csv", + f"- review HTML: sample-review.html", + "", + "## Ground Truth And Pack", + "", + f"- eval pack version: {eval_run.get('eval_pack_version') or '(missing)'}", + f"- frozen eval pack: {eval_run.get('frozen_eval_pack')}", + f"- unseen for selection: {eval_run.get('unseen_for_selection')}", + f"- selected checkpoint on test: {eval_run.get('selected_checkpoint_on_test')}", + f"- languages: {eval_run.get('languages')}", + f"- scripts: {eval_run.get('scripts')}", + f"- domains: {eval_run.get('domains')}", + f"- GT statuses: {eval_run.get('gt_statuses')}", + f"- splits: {eval_run.get('splits')}", + f"- reference coverage: {coverage}", + f"- reference claim-ready: {reference_readiness.get('ready_count')}/{reference_readiness.get('scored_pages')}", + f"- reference status counts: {reference_readiness.get('status_counts')}", + f"- reference claim-eligible counts: {reference_readiness.get('claim_eligible_counts')}", + f"- metadata coverage: {metadata_coverage}", + f"- script inventory file: {inventory.get('inventory_file')}", + f"- observed codepoints/graphemes: {inventory.get('observed_codepoint_count')}/{inventory.get('observed_grapheme_count')}", + f"- missing required codepoints: {inventory.get('missing_required_codepoints')}", + f"- missing required graphemes: {inventory.get('missing_required_graphemes')}", + f"- metadata contradictions: {metrics.get('metadata_contradictions', [])}", + f"- normalization profile: {normalization.get('profile')}", + f"- normalization changed reference/prediction/any: {normalization.get('reference_changed')}/{normalization.get('prediction_changed')}/{normalization.get('any_changed')} of {normalization.get('total')}", + f"- dictionary coverage checked: {dictionary_coverage.get('checked')}", + f"- dictionary reference codepoints/dictionary codepoints: {dictionary_coverage.get('gt_codepoint_count')}/{dictionary_coverage.get('dictionary_codepoint_count')}", + f"- dictionary missing reference codepoints: {dictionary_coverage.get('missing_gt_codepoints')}", + f"- leakage checked: {leakage.get('checked')}", + "", + "## Metrics", + "", + f"- text codepoint CER micro: {_fmt_metric(metrics.get('text_cer_codepoint_micro'))}", + f"- text grapheme CER micro: {_fmt_metric(metrics.get('text_cer_grapheme_micro'))}", + f"- text exact accuracy: {_fmt_metric(metrics.get('text_exact_accuracy'))}", + f"- line detection F1 mean: {_fmt_metric(metric_means.get('line_detection_f1'))}", + f"- line detection precision/recall/F1 micro: {_fmt_metric(metrics.get('line_detection_precision_micro'))}/{_fmt_metric(metrics.get('line_detection_recall_micro'))}/{_fmt_metric(metrics.get('line_detection_f1_micro'))}", + f"- line reference/prediction/match counts: {metrics.get('line_reference_count')}/{metrics.get('line_prediction_count')}/{metrics.get('line_match_count')}", + f"- missed/extra/blank line rates: {_fmt_metric(metrics.get('line_missed_reference_rate'))}/{_fmt_metric(metrics.get('line_extra_prediction_rate'))}/{_fmt_metric(metrics.get('line_blank_prediction_rate'))}", + f"- unmatched reference/prediction counts: {metrics.get('line_unmatched_reference_count')}/{metrics.get('line_unmatched_prediction_count')}", + f"- blank prediction/unmatched blank prediction counts: {metrics.get('line_blank_prediction_count')}/{metrics.get('line_blank_unmatched_prediction_count')}", + f"- line mean IoU: {_fmt_metric(metric_means.get('line_mean_iou'))}", + f"- matched-line text codepoint CER micro: {_fmt_metric(metrics.get('matched_line_text_cer_codepoint_micro'))}", + f"- matched-line text grapheme CER micro: {_fmt_metric(metrics.get('matched_line_text_cer_grapheme_micro'))}", + f"- matched-line exact accuracy: {_fmt_metric(metrics.get('matched_line_text_exact_accuracy'))}", + f"- matched-line reading-order pair accuracy: {_fmt_metric(metrics.get('matched_line_reading_order_pair_accuracy'))}", + f"- reading-order pair accuracy: {_fmt_metric(metric_means.get('reading_order_pair_accuracy'))}", + f"- text codepoint edits/ref: {metrics.get('text_codepoint_edits')}/{metrics.get('text_codepoint_ref_len')}", + f"- text grapheme edits/ref: {metrics.get('text_grapheme_edits')}/{metrics.get('text_grapheme_ref_len')}", + f"- text exact pages/ref pages: {metrics.get('text_exact_pages')}/{metrics.get('text_reference_pages')}", + f"- matched-line text codepoint edits/ref: {metrics.get('matched_line_text_codepoint_edits')}/{metrics.get('matched_line_text_codepoint_ref_len')}", + f"- matched-line text grapheme edits/ref: {metrics.get('matched_line_text_grapheme_edits')}/{metrics.get('matched_line_text_grapheme_ref_len')}", + f"- matched-line reading-order correct/total pairs: {metrics.get('matched_line_reading_order_correct_pairs')}/{metrics.get('matched_line_reading_order_total_pairs')}", + f"- structural line prediction/matched/unmatched counts: {metrics.get('structural_line_prediction_count')}/{metrics.get('structural_line_matched_count')}/{metrics.get('structural_line_unmatched_count')}", + f"- structural line match/exact-text rates: {_fmt_metric(metrics.get('structural_line_match_rate'))}/{_fmt_metric(metrics.get('structural_line_exact_text_match_rate'))}", + f"- zero-length text references: {metrics.get('zero_length_text_references')}", + f"- uncertainty method: {uncertainty.get('method')}", + f"- uncertainty scoring units: {uncertainty.get('effective_sample_size')}/{uncertainty.get('min_claim_scoring_units')}", + f"- text grapheme CER 95% CI: {_fmt_metric(graph_interval.get('low'))}..{_fmt_metric(graph_interval.get('high'))}", + "", + "## Slices", + "", + ] + for row in metrics.get("slices", []): + if not isinstance(row, dict): + continue + row_means = row.get("metric_means") if isinstance(row.get("metric_means"), dict) else {} + lines.append( + f"- {row.get('language')} / {row.get('script')} / {row.get('domain')} / {row.get('gt_status')} / {row.get('split')}: " + f"pages={row.get('scored_pages')} text_graph_CER={_fmt_metric(row.get('text_cer_grapheme_micro'))} " + f"text_cp_CER={_fmt_metric(row.get('text_cer_codepoint_micro'))} " + f"exact={_fmt_metric(row.get('text_exact_accuracy'))} line_F1={_fmt_metric(row_means.get('line_detection_f1', 0.0))}" + ) + lines.extend( + [ + "", + "## Warnings", + "", + ] + ) + lines.extend([f"- {warning}" for warning in warnings] or ["- none"]) + lines.extend( + [ + "", + "## Review Artifacts", + "", + "- command.txt", + "- page-metrics.csv", + "- reference-artifacts.tsv", + "- text-pairs.tsv", + "- missing.tsv", + "- worst-pages.csv", + "- sample-review.csv", + "- sample-review.html", + "- confusions.json", + "- line-alignment.csv", + ] + ) + path.write_text("\n".join(lines) + "\n", encoding="utf-8") + + +def run_eval(args: argparse.Namespace) -> dict[str, Any]: + manifest = load_manifest(args.eval_manifest) + if not manifest: + raise ValueError(f"eval manifest contains no rows: {args.eval_manifest}") + _validate_manifest_identity(manifest) + summary = _read_summary(args.summary_file) + spotcheck_calibration = _read_spotcheck_calibration(args.spotcheck_calibration_file) + manifest_dir = args.eval_manifest.parent + rows: list[PageEvalRow] = [] + line_alignment_rows: list[LineAlignmentRow] = [] + reference_texts: list[str] = [] + metadata_contradictions: list[str] = [] + document_source_path_mismatches: list[str] = [] + missing_documents: list[str] = [] + missing_references: list[str] = [] + ocr_output_kind = _ocr_output_kind(args) + require_output_audit = _requires_page_output_audit(args, ocr_output_kind) + output_audit_filename = _page_output_audit_filename(args) + output_audit_passed_field = _page_output_audit_passed_field(args) + output_audit_rows: list[dict[str, Any]] = [] + for entry in manifest: + input_path = _resolve_manifest_path(entry.image_path, manifest_dir) + if not input_path.exists(): + raise FileNotFoundError(f"eval manifest input is missing for {entry.sample_id}: {input_path}") + input_sha256 = _validate_manifest_image_hash(entry, input_path) + entry_domain = _entry_domain(entry, args.domain) + entry_gt_status = _entry_gt_status(entry, args.gt_status) + metadata_contradictions.extend(_metadata_contradictions(entry.sample_id, entry.metadata or {}, entry_domain, entry_gt_status)) + document, document_path = _load_document(entry, input_path, args.documents_dir) + if document is None or document_path is None: + missing_documents.append(entry.sample_id) + continue + if require_output_audit: + output_audit_rows.append( + _read_page_output_audit( + entry.sample_id, + document_path.parent, + filename=output_audit_filename, + passed_field=output_audit_passed_field, + ) + ) + source_path_mismatch = _document_source_path_mismatch(entry.sample_id, document, input_path) + if source_path_mismatch: + document_source_path_mismatches.append(source_path_mismatch) + reference = _reference_for(entry, input_path, manifest_dir) + if reference is None: + missing_references.append(entry.sample_id) + continue + reference_path = _reference_path_for(entry, input_path, manifest_dir) + reference_payload = _reference_payload_for(entry, input_path, manifest_dir) + if isinstance(reference_payload, dict) and isinstance(reference_payload.get("metadata"), dict): + metadata_contradictions.extend( + _metadata_contradictions(entry.sample_id, reference_payload["metadata"], entry_domain, entry_gt_status) + ) + reference_lines = _reference_lines(reference_payload) + predicted_lines = _predicted_lines(document) + line_alignment, line_rows = _align_lines( + entry.sample_id, + reference_lines, + predicted_lines, + args.line_iou_threshold, + predicted_reading_order_ids=_predicted_reading_order_ids(document), + ) + line_alignment_rows.extend(line_rows) + reference_fields = _reference_fields(reference) + if reference_lines: + reference_fields.append("line_bboxes") + metrics = score_document(document, document.text, reference) + cp_edits = cp_len = gr_edits = gr_len = 0 + if reference.text is not None: + reference_texts.append(reference.text) + cp_edits, cp_len, gr_edits, gr_len = _score_text_micro(document.text, reference.text) + text_exact = _nfc(document.text) == _nfc(reference.text) + else: + text_exact = False + rows.append( + PageEvalRow( + sample_id=entry.sample_id, + input_path=str(input_path), + input_sha256=input_sha256, + document_path=str(document_path), + document_sha256=sha256_file(document_path), + document_source_path=document.source_path, + ocr_output_kind=ocr_output_kind, + language=_entry_language(entry, args.language), + script=_entry_script(entry, args.script), + domain=entry_domain, + gt_status=entry_gt_status, + split=_entry_split(entry), + claim_eligible=_entry_claim_eligible(entry, args.claim_eligible), + source_document=_metadata_value_for_keys(entry.metadata or {}, SOURCE_DOCUMENT_KEYS), + source_page=_metadata_value_for_keys(entry.metadata or {}, PAGE_KEYS), + source_bbox=_metadata_value_for_keys(entry.metadata or {}, BBOX_KEYS), + reference_path=str(reference_path) if reference_path else "", + reference_sha256=sha256_file(reference_path) if reference_path else "", + reference_status=str((reference.metadata or {}).get("reference_status") or ""), + reference_claim_eligible=str((reference.metadata or {}).get("claim_evidence_eligible")) + if (reference.metadata or {}).get("claim_evidence_eligible") is not None + else "", + slices=_entry_slices(entry), + metrics=metrics, + text_codepoint_edits=cp_edits, + text_codepoint_ref_len=cp_len, + text_grapheme_edits=gr_edits, + text_grapheme_ref_len=gr_len, + text_exact=text_exact, + prediction_text=document.text, + reference_text=reference.text or "", + reference_fields=reference_fields, + line_alignment=line_alignment, + ) + ) + metrics = _aggregate(rows) + metrics["manifest_samples"] = len(manifest) + metrics["ocr_output_kind"] = ocr_output_kind + metrics["page_output_audit"] = { + "required": require_output_audit, + "filename": output_audit_filename, + "passed_field": output_audit_passed_field, + "expected_count": metrics["scored_pages"] if require_output_audit else 0, + "checked_count": len(output_audit_rows), + "passed_count": sum(1 for row in output_audit_rows if row.get("passed") is True), + "missing_count": sum(1 for row in output_audit_rows if row.get("exists") is not True), + "failed_count": sum(1 for row in output_audit_rows if row.get("exists") is True and row.get("passed") is not True), + "issues": [str(row.get("issue")) for row in output_audit_rows if row.get("issue")], + "artifacts": output_audit_rows, + } + metrics["missing_documents"] = len(missing_documents) + metrics["missing_references"] = len(missing_references) + metrics["document_source_path_mismatch_count"] = len(document_source_path_mismatches) + metrics["document_source_path_mismatches"] = document_source_path_mismatches + metrics["claim_eligible_rows"] = sum(1 for entry in manifest if _entry_claim_eligible(entry, args.claim_eligible)) + metrics["slices"] = _slice_metrics(rows) + metrics["reference_coverage"] = _coverage(rows) + metrics["reference_claim_readiness"] = _reference_claim_readiness(rows) + metrics["metadata_coverage"] = _metadata_coverage(manifest) + metrics["metadata_contradictions"] = metadata_contradictions + metrics["normalization_summary"] = _normalization_summary(rows) + metrics["pack_content_sha256"] = _page_pack_content_digest(rows) + script_inventory = _script_inventory_summary(reference_texts, args.script_inventory_file) + metrics["script_inventory"] = script_inventory + metrics["dictionary_coverage"] = _dictionary_coverage(reference_texts, args.dictionary) + leakage = _leakage_report(args.train_manifest or [], args.eval_manifest) + metrics["leakage"] = leakage + if spotcheck_calibration: + metrics["spotcheck_calibration"] = _spotcheck_calibration_summary(spotcheck_calibration) + artifacts = _artifact_identities(args) + warnings = _warnings(args, metrics, leakage, summary, spotcheck_calibration, artifacts, metadata_contradictions) + claim_safe = not warnings + if args.require_claim_safe and not claim_safe: + raise ValueError("claim-safe page eval requested but warnings are present: " + "; ".join(warnings)) + out = args.out + if out.exists() and any(out.iterdir()) and not args.force: + raise FileExistsError(f"output directory exists and is not empty: {out}") + out.mkdir(parents=True, exist_ok=True) + languages = sorted({row.language for row in rows}) + scripts = sorted({row.script for row in rows}) + domains = sorted({row.domain for row in rows}) + gt_statuses = sorted({row.gt_status for row in rows}) + splits = sorted({row.split for row in rows}) + eval_run = { + "created_at": datetime.now(timezone.utc).isoformat(), + "eval_mode": "page_level_ocr", + "system_name": args.system_name, + "model_name": args.model_name, + "checkpoint": args.checkpoint, + "config": args.config, + "dictionary": args.dictionary, + "artifact_identity": artifacts, + "eval_manifest": str(args.eval_manifest), + "eval_manifest_sha256": sha256_file(args.eval_manifest), + "summary_file": str(args.summary_file) if args.summary_file else None, + "summary_file_sha256": sha256_file(args.summary_file) if args.summary_file else None, + "script_inventory_file": str(args.script_inventory_file) if args.script_inventory_file else None, + "script_inventory_file_sha256": sha256_file(args.script_inventory_file) if args.script_inventory_file else None, + "spotcheck_calibration_file": str(args.spotcheck_calibration_file) if args.spotcheck_calibration_file else None, + "spotcheck_calibration_file_sha256": sha256_file(args.spotcheck_calibration_file) if args.spotcheck_calibration_file else None, + "spotcheck_calibration": metrics.get("spotcheck_calibration"), + "train_manifests": [{"path": str(path), "sha256": sha256_file(path)} for path in (args.train_manifest or [])], + "documents_dir": str(args.documents_dir), + "ocr_output_kind": ocr_output_kind, + "require_output_audit": require_output_audit, + "output_audit_filename": output_audit_filename, + "output_audit_passed_field": output_audit_passed_field, + "page_output_audit": metrics["page_output_audit"], + "eval_pack_version": args.eval_pack_version, + "pack_content_sha256": metrics["pack_content_sha256"], + "frozen_eval_pack": args.frozen_eval_pack, + "unseen_for_selection": args.unseen_for_selection, + "selected_checkpoint_on_test": args.selected_checkpoint_on_test, + "claim_eligible_default": args.claim_eligible, + "language_default": args.language, + "script_default": args.script, + "domain_default": args.domain, + "gt_status_default": args.gt_status, + "line_iou_threshold": args.line_iou_threshold, + "normalization_profile": DEFAULT_NORMALIZATION, + "languages": languages, + "scripts": scripts, + "domains": domains, + "gt_statuses": gt_statuses, + "splits": splits, + "script_inventory": metrics["script_inventory"], + "claim_safe": claim_safe, + "warnings": warnings, + "machine": {"platform": platform.platform(), "python": sys.version}, + "command": " ".join(sys.argv), + } + (out / "page-eval-run.json").write_text(json.dumps(eval_run, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + (out / "metrics.json").write_text(json.dumps(metrics, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + _write_metrics_md(out / "metrics.md", metrics, warnings) + _write_claim_safety_report(out / "claim-safety.md", eval_run, metrics) + _write_rows(out / "page-metrics.csv", rows) + _write_reference_artifacts(out / "reference-artifacts.tsv", rows) + _write_text_pairs(out / "text-pairs.tsv", rows) + _write_missing(out / "missing.tsv", missing_documents, missing_references) + (out / "confusions.json").write_text(json.dumps(_confusions(rows), ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + worst = _write_worst(out / "worst-pages.csv", rows, args.review_sample_size) + _write_review_csv(out / "sample-review.csv", worst) + _write_review_html(out / "sample-review.html", worst) + _write_line_alignment(out / "line-alignment.csv", line_alignment_rows) + (out / "command.txt").write_text(eval_run["command"] + "\n", encoding="utf-8") + return {"metrics": metrics, "eval_run": eval_run} + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--eval-manifest", type=Path, required=True) + parser.add_argument("--documents-dir", type=Path, required=True) + parser.add_argument( + "--ocr-output-kind", + choices=sorted(PAGE_OCR_OUTPUT_KINDS), + default="unknown", + help="What kind of OCR document outputs are being scored: live detector boxes, oracle line boxes, sidecar fixture, or unknown.", + ) + parser.add_argument("--require-output-audit", action="store_true", help="require every scored page output directory to contain a passing output audit JSON") + parser.add_argument("--output-audit-filename", default="limbu-output-audit.json", help="per-page output audit JSON filename under each document output directory") + parser.add_argument("--output-audit-passed-field", default="passed", help="boolean JSON field that must be true in each per-page output audit") + parser.add_argument("--out", type=Path, required=True) + parser.add_argument("--summary-file", type=Path) + parser.add_argument("--script-inventory-file", type=Path) + parser.add_argument("--spotcheck-calibration-file", type=Path) + parser.add_argument("--train-manifest", type=Path, action="append", default=[]) + parser.add_argument("--system-name", required=True) + parser.add_argument("--model-name", default="") + parser.add_argument("--checkpoint", default="") + parser.add_argument("--config", default="") + parser.add_argument("--dictionary", default="") + parser.add_argument("--language", default="unknown") + parser.add_argument("--script", default="unknown") + parser.add_argument("--domain", default="unknown") + parser.add_argument("--gt-status", default="unknown") + parser.add_argument("--eval-pack-version", default="") + parser.add_argument("--frozen-eval-pack", action=argparse.BooleanOptionalAction, default=False) + parser.add_argument("--unseen-for-selection", action=argparse.BooleanOptionalAction, default=False) + parser.add_argument("--selected-checkpoint-on-test", action=argparse.BooleanOptionalAction, default=False) + parser.add_argument("--claim-eligible", action=argparse.BooleanOptionalAction, default=False) + parser.add_argument("--line-iou-threshold", type=float, default=0.5) + parser.add_argument("--review-sample-size", type=int, default=50) + parser.add_argument("--require-claim-safe", action="store_true") + parser.add_argument("--force", action="store_true") + args = parser.parse_args(argv) + result = run_eval(args) + metrics = result["metrics"] + print( + f"wrote {args.out} page_text_graph_CER={metrics['text_cer_grapheme_micro']:.3f} " + f"page_text_cp_CER={metrics['text_cer_codepoint_micro']:.3f} scored={metrics['scored_pages']}/{metrics['manifest_samples']}" + ) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ocr-tech-mps-integration/tools/run_recognizer_eval.py b/ocr-tech-mps-integration/tools/run_recognizer_eval.py new file mode 100644 index 0000000000000000000000000000000000000000..5051e4399f6602b8bb2c1f7e805b9ad7944c47b4 --- /dev/null +++ b/ocr-tech-mps-integration/tools/run_recognizer_eval.py @@ -0,0 +1,1598 @@ +#!/usr/bin/env python3 +"""Run a claim-grade recognizer evaluation from labels and predictions. + +This harness scores an existing recognizer prediction file against a frozen +PaddleOCR-style eval pack. It does not run model inference yet; the contract is +deliberately narrow so metrics, provenance, matching, and artifact generation are +stable before model runners are added. +""" + +from __future__ import annotations + +import argparse +import csv +import hashlib +import html +import json +import platform +import random +import sys +import unicodedata +from dataclasses import dataclass, field +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +import regex +from rapidfuzz.distance import Levenshtein + + +CLAIM_SAFE_GT_STATUSES = {"human_verified", "machine_converted_spot_checked"} +CLAIM_SAFE_DOMAINS = {"real_print", "real_handwritten"} +DEFAULT_NORMALIZATION = "NFC_preserve_whitespace" +UNCERTAINTY_BOOTSTRAP_SAMPLES = 200 +UNCERTAINTY_BOOTSTRAP_SEED = 1729 +MIN_CLAIM_SCORING_UNITS = 30 +SOURCE_DOCUMENT_KEYS = ("source_document", "source_doc", "source_pdf", "source_image", "source_xml", "document", "doc_id") +PAGE_KEYS = ("page", "page_index", "page_number", "source_page", "page_id") +BBOX_KEYS = ("bbox", "bounding_box", "coords", "polygon") +CLAIM_ELIGIBLE_KEYS = ("claim_eligible", "claim_evidence_eligible", "paper_claim_eligible") +HUMAN_REVIEW_EVIDENCE_KEYS = ( + "reviewed_by", + "reviewer", + "native_reviewer", + "gt_reviewer", + "review_artifact", + "gt_review_artifact", + "review_batch", + "double_reviewed_by", + "inter_annotator_agreement", + "correction_rate", +) +PROVENANCE_SIGNAL_KEYS = ( + "label_provenance", + "gt_source", + "source_gt_status", + "source_label_status", + "reference_status", + "assisted_source", + "source_type", + "data_origin", + "evidence_type", + "dataset_type", + "slices", +) + + +@dataclass(frozen=True) +class LabelRow: + index: int + rel_path: str + text: str + + @property + def image_key(self) -> str: + return Path(self.rel_path).name + + +@dataclass(frozen=True) +class PredictionRow: + image_path: str + text: str + score: str = "" + + @property + def image_key(self) -> str: + return Path(self.image_path).name + + +@dataclass +class EvalLine: + sample_id: str + image_path: str + image_sha256: str + gt_text: str + prediction: str + prediction_score: str + metadata: dict[str, Any] = field(default_factory=dict) + codepoint_edits: int = 0 + codepoint_len: int = 0 + grapheme_edits: int = 0 + grapheme_len: int = 0 + exact: bool = False + + +@dataclass(frozen=True) +class LeakageRow: + source: str + sample_id: str + source_sample_id: str + image_path: str + image_sha256: str + text_sha256: str + sample_sha256: str + + +def _nfc(value: str) -> str: + return unicodedata.normalize("NFC", value or "") + + +def _graphemes(value: str) -> list[str]: + return regex.findall(r"\X", _nfc(value)) + + +def _codepoint_id(ch: str) -> str: + return f"U+{ord(ch):04X}" + + +def _read_script_inventory(path: Path | None) -> dict[str, Any]: + if path is None: + return {} + if not path.exists(): + raise FileNotFoundError(f"script inventory file does not exist: {path}") + payload = json.loads(path.read_text(encoding="utf-8")) + if not isinstance(payload, dict): + raise ValueError(f"script inventory file must contain a JSON object: {path}") + return payload + + +def _required_codepoints(payload: dict[str, Any]) -> list[str]: + raw = payload.get("required_codepoints", []) + if not isinstance(raw, list): + raise ValueError("script inventory required_codepoints must be a list") + required: set[str] = set() + for item in raw: + if not isinstance(item, str): + raise ValueError(f"script inventory codepoint entry must be a string: {item!r}") + value = item.strip() + if not value: + continue + if value.upper().startswith("U+"): + try: + required.add(f"U+{int(value[2:], 16):04X}") + except ValueError as exc: + raise ValueError(f"script inventory codepoint entry is not valid hex: {item!r}") from exc + continue + normalized = _nfc(value) + if len(normalized) != 1: + raise ValueError(f"script inventory codepoint entry must be one character or U+XXXX: {item!r}") + required.add(_codepoint_id(normalized)) + return sorted(required) + + +def _required_graphemes(payload: dict[str, Any]) -> list[str]: + raw = payload.get("required_graphemes", []) + if not isinstance(raw, list): + raise ValueError("script inventory required_graphemes must be a list") + required: set[str] = set() + for item in raw: + if not isinstance(item, str): + raise ValueError(f"script inventory grapheme entry must be a string: {item!r}") + value = _nfc(item) + if value.strip(): + required.add(value) + return sorted(required) + + +def _script_inventory_summary(texts: list[str], inventory_file: Path | None) -> dict[str, Any]: + payload = _read_script_inventory(inventory_file) + text = _nfc("\n".join(texts)) + codepoints = sorted({_codepoint_id(ch) for ch in text if not ch.isspace()}) + graphemes = sorted({cluster for cluster in _graphemes(text) if cluster.strip()}) + required_cps = _required_codepoints(payload) + required_graphs = _required_graphemes(payload) + categories = [unicodedata.category(ch) for ch in text if not ch.isspace()] + return { + "inventory_file": str(inventory_file) if inventory_file else None, + "inventory_file_sha256": _hash_file(inventory_file) if inventory_file else None, + "observed_codepoint_count": len(codepoints), + "observed_grapheme_count": len(graphemes), + "observed_codepoints": codepoints, + "observed_graphemes": graphemes, + "required_codepoints": required_cps, + "required_graphemes": required_graphs, + "missing_required_codepoints": sorted(set(required_cps) - set(codepoints)), + "missing_required_graphemes": sorted(set(required_graphs) - set(graphemes)), + "digit_codepoint_count": sum(1 for ch in text if not ch.isspace() and unicodedata.category(ch) == "Nd"), + "punctuation_codepoint_count": sum(1 for category in categories if category.startswith("P")), + "combining_mark_codepoint_count": sum(1 for category in categories if category.startswith("M")), + } + + +def _read_labels(path: Path) -> list[LabelRow]: + if not path.exists(): + raise FileNotFoundError(f"label file does not exist: {path}") + rows: list[LabelRow] = [] + seen: set[str] = set() + with path.open("r", encoding="utf-8", newline="") as handle: + for line_no, line in enumerate(handle, 1): + line = line.rstrip("\n") + if not line: + continue + if "\t" not in line: + raise ValueError(f"{path}:{line_no}: expected image path and label separated by a tab") + rel_path, text = line.split("\t", 1) + if not rel_path: + raise ValueError(f"{path}:{line_no}: empty image path") + key = Path(rel_path).name + if key in seen: + raise ValueError(f"duplicate label image basename: {key}") + seen.add(key) + rows.append(LabelRow(index=len(rows), rel_path=rel_path, text=text)) + if not rows: + raise ValueError(f"label file contains no rows: {path}") + return rows + + +def _read_predictions(path: Path) -> dict[str, PredictionRow]: + if not path.exists(): + raise FileNotFoundError(f"prediction file does not exist: {path}") + rows: dict[str, PredictionRow] = {} + with path.open("r", encoding="utf-8", newline="") as handle: + for line_no, line in enumerate(handle, 1): + line = line.rstrip("\n") + if not line: + continue + parts = line.split("\t") + if len(parts) < 2: + raise ValueError(f"{path}:{line_no}: expected at least image path and prediction separated by tabs") + pred = PredictionRow(image_path=parts[0], text=parts[1], score=parts[2] if len(parts) > 2 else "") + key = pred.image_key + if key in rows: + raise ValueError(f"duplicate prediction image basename: {key}") + rows[key] = pred + if not rows: + raise ValueError(f"prediction file contains no rows: {path}") + return rows + + +def _read_manifest(path: Path | None) -> dict[str, dict[str, Any]]: + if path is None: + return {} + if not path.exists(): + raise FileNotFoundError(f"manifest file does not exist: {path}") + rows: dict[str, dict[str, Any]] = {} + seen_ids: set[str] = set() + seen_image_paths: set[str] = set() + seen_image_basenames: set[str] = set() + with path.open("r", encoding="utf-8") as handle: + for line_no, line in enumerate(handle, 1): + line = line.strip() + if not line: + continue + try: + payload = json.loads(line) + except json.JSONDecodeError as exc: + raise ValueError(f"{path}:{line_no}: invalid JSON: {exc}") from exc + sample_id = str(payload.get("sample_id") or "") + if sample_id: + if sample_id in seen_ids: + raise ValueError(f"duplicate manifest sample_id: {sample_id}") + seen_ids.add(sample_id) + rows[sample_id] = payload + image_path = str(payload.get("image_path") or payload.get("image") or "") + if image_path: + if image_path in seen_image_paths: + raise ValueError(f"duplicate manifest image path: {image_path}") + seen_image_paths.add(image_path) + image_basename = Path(image_path).name + if image_basename in seen_image_basenames: + raise ValueError(f"duplicate manifest image basename: {image_basename}") + seen_image_basenames.add(image_basename) + rows[image_path] = payload + rows[image_basename] = payload + return rows + + +def _hash_file(path: Path) -> str: + digest = hashlib.sha256() + with path.open("rb") as handle: + for chunk in iter(lambda: handle.read(1024 * 1024), b""): + digest.update(chunk) + return digest.hexdigest() + + +def _dictionary_codepoints(dictionary: str) -> set[str] | None: + path = Path(str(dictionary or "")) + if not path.exists() or not path.is_file(): + return None + codepoints: set[str] = set() + for line in path.read_text(encoding="utf-8").splitlines(): + token = _nfc(line.strip()) + if not token: + continue + for ch in token: + if not ch.isspace(): + codepoints.add(_codepoint_id(ch)) + return codepoints + + +def _dictionary_coverage(texts: list[str], dictionary: str) -> dict[str, Any]: + dictionary_path = Path(str(dictionary or "")) + gt_codepoints = sorted({_codepoint_id(ch) for text in texts for ch in _nfc(text) if not ch.isspace()}) + dictionary_codepoints = _dictionary_codepoints(dictionary) + if dictionary_codepoints is None: + return { + "dictionary": str(dictionary or ""), + "dictionary_file_sha256": None, + "checked": False, + "gt_codepoint_count": len(gt_codepoints), + "missing_gt_codepoints": [], + "missing_gt_codepoint_count": 0, + "reason": "dictionary file is not readable", + } + missing = sorted(set(gt_codepoints) - dictionary_codepoints) + return { + "dictionary": str(dictionary or ""), + "dictionary_file_sha256": _hash_file(dictionary_path), + "checked": True, + "dictionary_codepoint_count": len(dictionary_codepoints), + "gt_codepoint_count": len(gt_codepoints), + "missing_gt_codepoints": missing, + "missing_gt_codepoint_count": len(missing), + } + + +def _normalization_summary(lines: list[EvalLine]) -> dict[str, Any]: + gt_changed = sum(1 for line in lines if line.gt_text != _nfc(line.gt_text)) + prediction_changed = sum(1 for line in lines if line.prediction != _nfc(line.prediction)) + return { + "profile": DEFAULT_NORMALIZATION, + "unit": "line", + "total": len(lines), + "gt_changed": gt_changed, + "prediction_changed": prediction_changed, + "any_changed": sum(1 for line in lines if line.gt_text != _nfc(line.gt_text) or line.prediction != _nfc(line.prediction)), + } + + +def _artifact_identity(value: str) -> dict[str, Any]: + value = str(value or "") + if not value: + return {"value": "", "verified": False, "reason": "missing"} + path = Path(value) + if path.exists() and path.is_file(): + return { + "value": value, + "path": str(path), + "sha256": _hash_file(path), + "size_bytes": path.stat().st_size, + "verified": True, + } + return {"value": value, "verified": False, "reason": "not a readable local file"} + + +def _artifact_identities(args: argparse.Namespace) -> dict[str, dict[str, Any]]: + return { + "checkpoint": _artifact_identity(args.checkpoint), + "config": _artifact_identity(args.config), + "dictionary": _artifact_identity(args.dictionary), + } + + +def _resolve_image(data_dir: Path, rel_path: str) -> Path: + path = data_dir / rel_path + if not path.exists(): + raise FileNotFoundError(f"label references missing image: {path}") + return path + + +def _metadata_for(row: LabelRow, manifest: dict[str, dict[str, Any]]) -> dict[str, Any]: + payload = manifest.get(row.rel_path) or manifest.get(row.image_key) or {} + metadata = dict(payload.get("metadata") or {}) + for key, value in payload.items(): + if key == "metadata": + continue + if key not in metadata: + metadata[key] = value + for key in ("sample_id", "dataset", "split", "image_path", "sha256"): + if key in payload and key not in metadata: + metadata[key] = payload[key] + return metadata + + +def _declared_image_sha256(metadata: dict[str, Any]) -> str: + return str(metadata.get("sha256") or metadata.get("image_sha256") or "") + + +def _declared_text_sha256(metadata: dict[str, Any]) -> str: + return str(metadata.get("text_sha256") or "") + + +def _declared_sample_sha256(metadata: dict[str, Any]) -> str: + return str(metadata.get("sample_sha256") or "") + + +def _validate_manifest_hashes(sample_id: str, image_path: Path, gt_text: str, metadata: dict[str, Any]) -> str: + actual = _hash_file(image_path) + declared = _declared_image_sha256(metadata) + if declared and declared != actual: + raise ValueError( + f"eval manifest sha256 mismatch for {sample_id}: " + f"manifest={declared} actual={actual}" + ) + actual_text = _hash_text(gt_text) + declared_text = _declared_text_sha256(metadata) + if declared_text and declared_text != actual_text: + raise ValueError( + f"eval manifest text_sha256 mismatch for {sample_id}: " + f"manifest={declared_text} actual={actual_text}" + ) + actual_sample = _sample_hash(actual, actual_text) + declared_sample = _declared_sample_sha256(metadata) + if declared_sample and declared_sample != actual_sample: + raise ValueError( + f"eval manifest sample_sha256 mismatch for {sample_id}: " + f"manifest={declared_sample} actual={actual_sample}" + ) + return actual + + +def _sample_id(row: LabelRow, metadata: dict[str, Any]) -> str: + return str(metadata.get("sample_id") or f"row-{row.index:06d}") + + +def _metadata_value_for_keys(metadata: dict[str, Any], keys: tuple[str, ...]) -> str: + for key in keys: + value = metadata.get(key) + if value not in (None, "", [], {}): + if isinstance(value, (list, dict)): + return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":")) + return str(value) + return "" + + +def _score_line(gt: str, pred: str) -> tuple[int, int, int, int, bool]: + gt_nfc = _nfc(gt) + pred_nfc = _nfc(pred) + cp_edits = Levenshtein.distance(pred_nfc, gt_nfc) + gt_graph = _graphemes(gt_nfc) + pred_graph = _graphemes(pred_nfc) + gr_edits = Levenshtein.distance(pred_graph, gt_graph) + return cp_edits, len(gt_nfc), gr_edits, len(gt_graph), pred_nfc == gt_nfc + + +def _build_lines(labels: list[LabelRow], predictions: dict[str, PredictionRow], manifest: dict[str, dict[str, Any]], data_dir: Path) -> tuple[list[EvalLine], list[LabelRow], list[PredictionRow]]: + lines: list[EvalLine] = [] + unmatched_labels: list[LabelRow] = [] + used_predictions: set[str] = set() + seen_sample_ids: set[str] = set() + for label in labels: + image_path = _resolve_image(data_dir, label.rel_path) + pred = predictions.get(label.image_key) + if pred is None: + unmatched_labels.append(label) + continue + used_predictions.add(label.image_key) + metadata = _metadata_for(label, manifest) + sample_id = _sample_id(label, metadata) + if sample_id in seen_sample_ids: + raise ValueError(f"duplicate resolved sample_id: {sample_id}") + seen_sample_ids.add(sample_id) + image_sha256 = _validate_manifest_hashes(sample_id, image_path, label.text, metadata) + cp_ed, cp_len, gr_ed, gr_len, exact = _score_line(label.text, pred.text) + lines.append( + EvalLine( + sample_id=sample_id, + image_path=label.rel_path, + image_sha256=image_sha256, + gt_text=label.text, + prediction=pred.text, + prediction_score=pred.score, + metadata=metadata, + codepoint_edits=cp_ed, + codepoint_len=cp_len, + grapheme_edits=gr_ed, + grapheme_len=gr_len, + exact=exact, + ) + ) + unmatched_predictions = [row for key, row in predictions.items() if key not in used_predictions] + return lines, unmatched_labels, unmatched_predictions + + +def _domain(metadata: dict[str, Any], fallback: str) -> str: + for key in ("domain", "eval_domain"): + if metadata.get(key): + return str(metadata[key]) + slices = metadata.get("slices") + if isinstance(slices, list): + if "synthetic" in slices: + return "synthetic" + if "real" in slices: + return fallback + return fallback + + +def _gt_status(metadata: dict[str, Any], fallback: str) -> str: + for key in ("gt_status", "label_status"): + if metadata.get(key): + return str(metadata[key]) + provenance = str(metadata.get("label_provenance") or "").lower() + if "human" in provenance and "pending" not in provenance: + return "human_verified" + if "machine" in provenance: + return fallback + return fallback + + +def _language(metadata: dict[str, Any], fallback: str) -> str: + return str(metadata.get("language") or fallback) + + +def _script(metadata: dict[str, Any], fallback: str) -> str: + return str(metadata.get("script") or fallback) + + +def _split(metadata: dict[str, Any], fallback: str) -> str: + return str(metadata.get("split") or metadata.get("split_role") or fallback) + + +def _metadata_bool(metadata: dict[str, Any], keys: tuple[str, ...], fallback: bool) -> bool: + for key in keys: + if key not in metadata: + continue + value = metadata[key] + if isinstance(value, bool): + return value + if isinstance(value, str): + lowered = value.strip().lower() + if lowered in {"1", "true", "yes", "y"}: + return True + if lowered in {"0", "false", "no", "n"}: + return False + return bool(value) + return fallback + + +def _claim_eligible(metadata: dict[str, Any], fallback: bool) -> bool: + return _metadata_bool(metadata, CLAIM_ELIGIBLE_KEYS, fallback) + + +def _has_any(metadata: dict[str, Any], keys: tuple[str, ...]) -> bool: + for key in keys: + value = metadata.get(key) + if value not in (None, "", [], {}): + return True + return False + + +def _provenance_coverage(lines: list[EvalLine]) -> dict[str, int]: + return { + "missing_source_document": sum(1 for line in lines if not _has_any(line.metadata, SOURCE_DOCUMENT_KEYS)), + "missing_page": sum(1 for line in lines if not _has_any(line.metadata, PAGE_KEYS)), + "missing_bbox": sum(1 for line in lines if not _has_any(line.metadata, BBOX_KEYS)), + "missing_claim_eligibility": sum(1 for line in lines if not any(key in line.metadata for key in CLAIM_ELIGIBLE_KEYS)), + "missing_human_review_evidence": sum( + 1 + for line in lines + if _gt_status(line.metadata, "") == "human_verified" and not _has_any(line.metadata, HUMAN_REVIEW_EVIDENCE_KEYS) + ), + } + + +def _metadata_signal_text(metadata: dict[str, Any]) -> str: + values: list[str] = [] + for key in PROVENANCE_SIGNAL_KEYS: + value = metadata.get(key) + if value in (None, "", [], {}): + continue + if isinstance(value, list): + values.extend(str(item) for item in value) + elif isinstance(value, dict): + values.extend(f"{item_key}:{item_value}" for item_key, item_value in value.items()) + else: + values.append(str(value)) + return " ".join(values).lower().replace("_", " ").replace("-", " ") + + +def _metadata_contradictions(lines: list[EvalLine], args: argparse.Namespace) -> list[str]: + contradictions: list[str] = [] + for line in lines: + signal_text = _metadata_signal_text(line.metadata) + if not signal_text: + continue + domain = _domain(line.metadata, args.domain) + gt_status = _gt_status(line.metadata, args.gt_status) + if domain in CLAIM_SAFE_DOMAINS and any(term in signal_text for term in ("synthetic", "transliterated", "transliteration")): + contradictions.append(f"{line.sample_id}: synthetic/transliterated provenance is declared as real domain {domain}") + if gt_status == "human_verified" and any( + term in signal_text + for term in ("machine converted", "machine", "synthetic", "transliterated", "transliteration") + ): + contradictions.append(f"{line.sample_id}: machine/synthetic provenance is declared as human_verified GT") + return contradictions + + +def _read_summary(path: Path | None) -> dict[str, Any]: + if path is None: + return {} + if not path.exists(): + raise FileNotFoundError(f"summary/datasheet file does not exist: {path}") + try: + payload = json.loads(path.read_text(encoding="utf-8")) + except json.JSONDecodeError as exc: + raise ValueError(f"summary/datasheet file is invalid JSON: {path}: {exc}") from exc + if not isinstance(payload, dict): + raise ValueError(f"summary/datasheet file must contain a JSON object: {path}") + return payload + + +def _summary_counts(summary: dict[str, Any]) -> dict[str, Any]: + counts = summary.get("counts") + return counts if isinstance(counts, dict) else {} + + +def _int_summary_count(summary_counts: dict[str, Any], key: str, warnings: list[str]) -> int: + value = summary_counts.get(key, 0) or 0 + try: + return int(value) + except (TypeError, ValueError): + warnings.append(f"normalizer_{key} is not an integer: {value!r}") + return 0 + + +def _read_spotcheck_calibration(path: Path | None) -> dict[str, Any]: + if path is None: + return {} + if not path.exists(): + raise FileNotFoundError(f"native spot-check calibration file does not exist: {path}") + try: + payload = json.loads(path.read_text(encoding="utf-8")) + except json.JSONDecodeError as exc: + raise ValueError(f"native spot-check calibration file is invalid JSON: {path}: {exc}") from exc + if not isinstance(payload, dict): + raise ValueError(f"native spot-check calibration file must contain a JSON object: {path}") + return payload + + +def _spotcheck_calibration_summary(payload: dict[str, Any]) -> dict[str, Any]: + return { + "claim_evidence_eligible": payload.get("claim_evidence_eligible"), + "recommended_pack_gt_status": payload.get("recommended_pack_gt_status"), + "language": payload.get("language"), + "script": payload.get("script"), + "domain": payload.get("domain"), + "source_gt_status": payload.get("source_gt_status"), + "counts": payload.get("counts", {}), + "machine_label_metrics": payload.get("machine_label_metrics", {}), + "eligibility_reasons": payload.get("eligibility_reasons", []), + } + + +def _hash_text(value: str) -> str: + return hashlib.sha256(_nfc(value).encode("utf-8")).hexdigest() + + +def _sample_hash(image_sha256: str, text_sha256: str) -> str: + return hashlib.sha256(f"{image_sha256}\0{text_sha256}".encode("utf-8")).hexdigest() + + +def _pack_content_digest(lines: list[EvalLine], args: argparse.Namespace) -> str: + canonical_rows = [ + { + "sample_id": line.sample_id, + "image_sha256": line.image_sha256, + "gt_text_sha256_nfc": _hash_text(line.gt_text), + "language": _language(line.metadata, args.language), + "script": _script(line.metadata, args.script), + "domain": _domain(line.metadata, args.domain), + "gt_status": _gt_status(line.metadata, args.gt_status), + "split": _split(line.metadata, args.split), + "claim_eligible": _claim_eligible(line.metadata, args.claim_eligible), + } + for line in lines + ] + payload = "\n".join( + json.dumps(row, ensure_ascii=False, sort_keys=True, separators=(",", ":")) + for row in sorted(canonical_rows, key=lambda item: item["sample_id"]) + ) + return hashlib.sha256(payload.encode("utf-8")).hexdigest() + + +def _summary_pack_content_sha256(summary: dict[str, Any]) -> str: + value = summary.get("pack_content_sha256") + if isinstance(value, str) and value: + return value + eval_pack = summary.get("eval_pack") + if isinstance(eval_pack, dict): + nested = eval_pack.get("pack_content_sha256") + if isinstance(nested, str) and nested: + return nested + return "" + + +def _jsonl_leakage_rows(path: Path) -> list[LeakageRow]: + if not path.exists(): + raise FileNotFoundError(f"train/dev manifest does not exist: {path}") + rows: list[LeakageRow] = [] + with path.open("r", encoding="utf-8") as handle: + for line_no, line in enumerate(handle, 1): + line = line.strip() + if not line: + continue + try: + payload = json.loads(line) + except json.JSONDecodeError as exc: + raise ValueError(f"{path}:{line_no}: invalid JSON: {exc}") from exc + if not isinstance(payload, dict): + raise ValueError(f"{path}:{line_no}: expected a JSON object") + metadata = dict(payload.get("metadata") or {}) + sample_id = str(payload.get("sample_id") or payload.get("id") or metadata.get("sample_id") or "") + image_path = str(payload.get("image_path") or payload.get("image") or metadata.get("image_path") or "") + image_sha256 = str(payload.get("sha256") or payload.get("image_sha256") or metadata.get("sha256") or "") + text = str(payload.get("text") if payload.get("text") is not None else metadata.get("text") or "") + text_sha256 = str(payload.get("text_sha256") or metadata.get("text_sha256") or (_hash_text(text) if text else "")) + sample_sha256 = str(payload.get("sample_sha256") or metadata.get("sample_sha256") or "") + if not sample_sha256 and image_sha256 and text_sha256: + sample_sha256 = _sample_hash(image_sha256, text_sha256) + source_sample_id = str(payload.get("source_sample_id") or metadata.get("source_sample_id") or sample_id) + rows.append( + LeakageRow( + source=str(path), + sample_id=sample_id, + source_sample_id=source_sample_id, + image_path=image_path, + image_sha256=image_sha256, + text_sha256=text_sha256, + sample_sha256=sample_sha256, + ) + ) + return rows + + +def _eval_leakage_rows(lines: list[EvalLine], data_dir: Path) -> list[LeakageRow]: + rows: list[LeakageRow] = [] + for line in lines: + image_path = str(line.metadata.get("image_path") or line.metadata.get("image") or line.image_path) + image_sha256 = str(line.metadata.get("sha256") or line.metadata.get("image_sha256") or "") + if not image_sha256: + image_sha256 = _hash_file(data_dir / line.image_path) + text_sha256 = _hash_text(line.gt_text) + rows.append( + LeakageRow( + source="eval", + sample_id=line.sample_id, + source_sample_id=str(line.metadata.get("source_sample_id") or line.sample_id), + image_path=image_path, + image_sha256=image_sha256, + text_sha256=text_sha256, + sample_sha256=_sample_hash(image_sha256, text_sha256), + ) + ) + return rows + + +def _overlap_values(train_rows: list[LeakageRow], eval_rows: list[LeakageRow], field: str) -> list[str]: + train_values = {str(getattr(row, field)) for row in train_rows if getattr(row, field)} + eval_values = {str(getattr(row, field)) for row in eval_rows if getattr(row, field)} + return sorted(train_values & eval_values) + + +def _leakage_report(train_manifests: list[Path], lines: list[EvalLine], data_dir: Path) -> dict[str, Any]: + train_rows: list[LeakageRow] = [] + for manifest in train_manifests: + train_rows.extend(_jsonl_leakage_rows(manifest)) + eval_rows = _eval_leakage_rows(lines, data_dir) if train_rows else [] + overlaps = { + "sample_id": _overlap_values(train_rows, eval_rows, "sample_id"), + "source_sample_id": _overlap_values(train_rows, eval_rows, "source_sample_id"), + "image_sha256": _overlap_values(train_rows, eval_rows, "image_sha256"), + "sample_sha256": _overlap_values(train_rows, eval_rows, "sample_sha256"), + "image_path": _overlap_values(train_rows, eval_rows, "image_path"), + "text_sha256": _overlap_values(train_rows, eval_rows, "text_sha256"), + } + return { + "train_manifests": [str(path) for path in train_manifests], + "checked": bool(train_rows), + "train_rows": len(train_rows), + "eval_rows": len(eval_rows), + "overlaps": overlaps, + } + + +def _claim_warnings( + lines: list[EvalLine], + slices: list[dict[str, Any]], + args: argparse.Namespace, + unmatched_count: int, + match_rate: float, + summary: dict[str, Any], + leakage: dict[str, Any], + spotcheck_calibration: dict[str, Any], + artifacts: dict[str, dict[str, Any]], + metadata_contradictions: list[str], + script_inventory: dict[str, Any], + dictionary_coverage: dict[str, Any], + pack_content_sha256: str, +) -> list[str]: + warnings: list[str] = [] + if not lines: + warnings.append("no matched rows scored") + if unmatched_count: + warnings.append(f"unmatched rows present: {unmatched_count}") + if match_rate < args.min_match_rate: + warnings.append(f"low prediction match rate: {match_rate:.6f} below required {args.min_match_rate:.6f}") + if args.manifest_file is None: + warnings.append("eval manifest missing") + if args.summary_file is None: + warnings.append("eval pack summary/datasheet missing") + if summary and not any(key in summary for key in ("dataset", "datasheet", "eval_pack", "version", "eval_pack_version")): + warnings.append("eval pack summary lacks dataset/version/eval_pack metadata") + if summary: + summary_pack_content_sha256 = _summary_pack_content_sha256(summary) + if not summary_pack_content_sha256: + warnings.append("eval pack summary missing pack_content_sha256") + elif summary_pack_content_sha256 != pack_content_sha256: + warnings.append( + "pack content digest mismatch: " + f"summary={summary_pack_content_sha256} actual={pack_content_sha256}" + ) + normalizer_counts = _summary_counts(summary) + for key in ( + "defaulted_language", + "defaulted_script", + "defaulted_domain", + "defaulted_gt_status", + "defaulted_split", + "defaulted_claim_eligible", + ): + count = _int_summary_count(normalizer_counts, key, warnings) + if count: + warnings.append(f"normalizer_{key}: {count}/{len(lines)}") + if not args.eval_pack_version: + warnings.append("eval pack version not recorded") + if not str(args.model_name or "").strip(): + warnings.append("model name not recorded") + for name, identity in artifacts.items(): + if not identity.get("verified"): + warnings.append(f"{name} artifact is not hash-verifiable: {identity.get('reason') or 'unverified'}") + if not args.frozen_eval_pack: + warnings.append("eval pack is not declared frozen") + if not args.unseen_for_selection: + warnings.append("eval pack is not declared unseen for model/checkpoint selection") + if args.selected_checkpoint_on_test: + warnings.append("checkpoint/model selection on this test pack is declared") + domains = {_domain(line.metadata, args.domain) for line in lines} + gt_statuses = {_gt_status(line.metadata, args.gt_status) for line in lines} + languages = {_language(line.metadata, args.language) for line in lines} + scripts = {_script(line.metadata, args.script) for line in lines} + splits = {_split(line.metadata, args.split) for line in lines} + claim_eligible_values = {_claim_eligible(line.metadata, args.claim_eligible) for line in lines} + if len(domains) > 1: + warnings.append(f"mixed eval domains: {sorted(domains)}") + if len(gt_statuses) > 1: + warnings.append(f"mixed GT statuses: {sorted(gt_statuses)}") + if len(languages) > 1: + warnings.append(f"mixed languages: {sorted(languages)}") + if len(scripts) > 1: + warnings.append(f"mixed scripts: {sorted(scripts)}") + if len(splits) > 1: + warnings.append(f"mixed split statuses: {sorted(splits)}") + if not splits <= {"eval", "test", "heldout", "held_out", "validation"}: + warnings.append(f"unexpected split status for claim evaluation: {sorted(splits)}") + if not domains <= CLAIM_SAFE_DOMAINS: + warnings.append(f"not claim-safe real domain: {sorted(domains)}") + if not gt_statuses <= CLAIM_SAFE_GT_STATUSES: + warnings.append(f"not human-verified/spot-checked GT: {sorted(gt_statuses)}") + if "machine_converted_spot_checked" in gt_statuses: + if args.spotcheck_calibration_file is None: + warnings.append("machine_converted_spot_checked GT declared without native spot-check calibration artifact") + else: + if not spotcheck_calibration.get("claim_evidence_eligible"): + warnings.append("native spot-check calibration artifact is not claim evidence eligible") + if spotcheck_calibration.get("recommended_pack_gt_status") != "machine_converted_spot_checked": + warnings.append("native spot-check calibration does not recommend machine_converted_spot_checked GT") + if spotcheck_calibration.get("source_gt_status") != "machine_converted": + warnings.append("native spot-check calibration source_gt_status is not machine_converted") + for field, values in (("language", languages), ("script", scripts), ("domain", domains)): + value = spotcheck_calibration.get(field) + if not isinstance(value, str) or not value: + warnings.append(f"native spot-check calibration missing {field}") + elif value not in values: + warnings.append(f"native spot-check calibration {field} mismatch: {value!r} not in {sorted(values)}") + if claim_eligible_values != {True}: + warnings.append(f"not all rows are claim eligible: {sorted(claim_eligible_values)}") + coverage = _provenance_coverage(lines) + for key, count in coverage.items(): + if count: + warnings.append(f"{key}: {count}/{len(lines)}") + if metadata_contradictions: + warnings.append( + "metadata contradictions detected: " + + "; ".join(metadata_contradictions[:10]) + + (f"; ... {len(metadata_contradictions) - 10} more" if len(metadata_contradictions) > 10 else "") + ) + if not script_inventory.get("inventory_file"): + warnings.append("script inventory file missing") + if script_inventory.get("missing_required_codepoints"): + warnings.append(f"missing required script codepoints: {script_inventory['missing_required_codepoints'][:20]}") + if script_inventory.get("missing_required_graphemes"): + warnings.append(f"missing required script graphemes: {script_inventory['missing_required_graphemes'][:20]}") + if dictionary_coverage.get("checked") and dictionary_coverage.get("missing_gt_codepoints"): + warnings.append(f"GT codepoints missing from dictionary: {dictionary_coverage['missing_gt_codepoints'][:20]}") + zero_length_gt = sum(1 for line in lines if len(_nfc(line.gt_text)) == 0) + if zero_length_gt: + warnings.append(f"zero-length GT rows present: {zero_length_gt}/{len(lines)}") + if len(lines) < MIN_CLAIM_SCORING_UNITS: + warnings.append(f"claim-facing sample size too small: {len(lines)} scoring units, minimum {MIN_CLAIM_SCORING_UNITS}") + for row in slices: + count = int(row.get("n_lines", 0) or 0) + if count < MIN_CLAIM_SCORING_UNITS: + warnings.append( + "slice sample size too small: " + f"{row.get('language')}/{row.get('script')}/{row.get('domain')}/{row.get('gt_status')}/{row.get('split')} " + f"has {count} scoring units, minimum {MIN_CLAIM_SCORING_UNITS}" + ) + leakage_overlaps = leakage.get("overlaps", {}) + hard_leakage = { + key: values + for key, values in leakage_overlaps.items() + if key != "text_sha256" and values + } + text_overlap = leakage_overlaps.get("text_sha256") or [] + if hard_leakage: + warnings.append("train/dev/eval leakage detected: " + json.dumps({key: values[:10] for key, values in hard_leakage.items()}, ensure_ascii=False)) + if text_overlap: + warnings.append(f"train/dev/eval text overlap detected: {len(text_overlap)} text hashes") + if args.train_manifest and not leakage.get("checked"): + warnings.append("train/dev leakage manifests were provided but no train rows were checked") + if not args.train_manifest: + warnings.append("train/dev leakage check not run") + if args.known_leakage: + warnings.append(f"known leakage acknowledged: {args.known_leakage}") + return warnings + + +def _percentile(values: list[float], q: float) -> float: + if not values: + return 0.0 + ordered = sorted(values) + if len(ordered) == 1: + return ordered[0] + position = (len(ordered) - 1) * q + lower = int(position) + upper = min(lower + 1, len(ordered) - 1) + weight = position - lower + return ordered[lower] * (1.0 - weight) + ordered[upper] * weight + + +def _confidence_interval(values: list[float]) -> dict[str, float]: + return { + "low": _percentile(values, 0.025), + "high": _percentile(values, 0.975), + } + + +def _uncertainty(lines: list[EvalLine]) -> dict[str, Any]: + n = len(lines) + cp_points: list[float] = [] + gr_points: list[float] = [] + exact_points: list[float] = [] + if n: + rng = random.Random(UNCERTAINTY_BOOTSTRAP_SEED) + for _ in range(UNCERTAINTY_BOOTSTRAP_SAMPLES): + cp_edits = cp_len = gr_edits = gr_len = exact = 0 + for _ in range(n): + line = lines[rng.randrange(n)] + cp_edits += line.codepoint_edits + cp_len += line.codepoint_len + gr_edits += line.grapheme_edits + gr_len += line.grapheme_len + exact += int(line.exact) + cp_points.append(cp_edits / max(cp_len, 1)) + gr_points.append(gr_edits / max(gr_len, 1)) + exact_points.append(exact / max(n, 1)) + return { + "method": "deterministic_row_bootstrap", + "confidence_level": 0.95, + "bootstrap_samples": UNCERTAINTY_BOOTSTRAP_SAMPLES, + "seed": UNCERTAINTY_BOOTSTRAP_SEED, + "scoring_units": n, + "effective_sample_size": n, + "min_claim_scoring_units": MIN_CLAIM_SCORING_UNITS, + "claim_sample_size_ok": n >= MIN_CLAIM_SCORING_UNITS, + "metrics": { + "cer_codepoint_micro": _confidence_interval(cp_points), + "cer_grapheme_micro": _confidence_interval(gr_points), + "exact_line_accuracy": _confidence_interval(exact_points), + }, + } + + +def _aggregate(lines: list[EvalLine]) -> dict[str, Any]: + cp_edits = sum(line.codepoint_edits for line in lines) + cp_len = sum(line.codepoint_len for line in lines) + gr_edits = sum(line.grapheme_edits for line in lines) + gr_len = sum(line.grapheme_len for line in lines) + exact = sum(1 for line in lines if line.exact) + zero_length_gt = sum(1 for line in lines if len(_nfc(line.gt_text)) == 0) + n = len(lines) + return { + "n_lines": n, + "matched_lines": n, + "zero_length_gt_lines": zero_length_gt, + "codepoint_edits": cp_edits, + "codepoint_ref_len": cp_len, + "cer_codepoint_micro": cp_edits / max(cp_len, 1), + "grapheme_edits": gr_edits, + "grapheme_ref_len": gr_len, + "cer_grapheme_micro": gr_edits / max(gr_len, 1), + "exact_line_accuracy": exact / max(n, 1), + "uncertainty": _uncertainty(lines), + } + + +def _slice_metrics(lines: list[EvalLine], args: argparse.Namespace) -> list[dict[str, Any]]: + groups: dict[tuple[str, str, str, str, str], list[EvalLine]] = {} + for line in lines: + key = ( + _language(line.metadata, args.language), + _script(line.metadata, args.script), + _domain(line.metadata, args.domain), + _gt_status(line.metadata, args.gt_status), + _split(line.metadata, args.split), + ) + groups.setdefault(key, []).append(line) + slices: list[dict[str, Any]] = [] + for key, group in sorted(groups.items()): + language, script, domain, gt_status, split = key + metrics = _aggregate(group) + metrics.update( + { + "language": language, + "script": script, + "domain": domain, + "gt_status": gt_status, + "split": split, + } + ) + slices.append(metrics) + return slices + + +def _line_dict(line: EvalLine) -> dict[str, Any]: + return { + "sample_id": line.sample_id, + "image_path": line.image_path, + "image_sha256": line.image_sha256, + "gt_text": line.gt_text, + "prediction": line.prediction, + "prediction_score": line.prediction_score, + "codepoint_edits": line.codepoint_edits, + "codepoint_ref_len": line.codepoint_len, + "cer_codepoint": line.codepoint_edits / max(line.codepoint_len, 1), + "grapheme_edits": line.grapheme_edits, + "grapheme_ref_len": line.grapheme_len, + "cer_grapheme": line.grapheme_edits / max(line.grapheme_len, 1), + "exact": line.exact, + "metadata": line.metadata, + } + + +def _write_json(path: Path, payload: Any) -> None: + path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + + +def _write_tsv(path: Path, rows: list[EvalLine], args: argparse.Namespace) -> None: + fields = [ + "sample_id", + "image_path", + "image_sha256", + "language", + "script", + "domain", + "gt_status", + "split", + "claim_eligible", + "source_document", + "source_page", + "source_bbox", + "gt_text", + "prediction", + "prediction_score", + "codepoint_edits", + "grapheme_edits", + "exact", + ] + with path.open("w", encoding="utf-8", newline="") as handle: + writer = csv.DictWriter(handle, fieldnames=fields, delimiter="\t") + writer.writeheader() + for line in rows: + row = _line_dict(line) + row.update( + { + "language": _language(line.metadata, args.language), + "script": _script(line.metadata, args.script), + "domain": _domain(line.metadata, args.domain), + "gt_status": _gt_status(line.metadata, args.gt_status), + "split": _split(line.metadata, args.split), + "claim_eligible": _claim_eligible(line.metadata, args.claim_eligible), + "source_document": _metadata_value_for_keys(line.metadata, SOURCE_DOCUMENT_KEYS), + "source_page": _metadata_value_for_keys(line.metadata, PAGE_KEYS), + "source_bbox": _metadata_value_for_keys(line.metadata, BBOX_KEYS), + } + ) + writer.writerow({field: row[field] for field in fields}) + + +def _write_unmatched(path: Path, labels: list[LabelRow], predictions: list[PredictionRow], data_dir: Path) -> None: + fields = ["kind", "image_key", "image_path", "image_sha256", "text", "prediction_score"] + with path.open("w", encoding="utf-8", newline="") as handle: + writer = csv.DictWriter(handle, fieldnames=fields, delimiter="\t") + writer.writeheader() + for label in labels: + image_path = data_dir / label.rel_path + writer.writerow( + { + "kind": "label_without_prediction", + "image_key": label.image_key, + "image_path": label.rel_path, + "image_sha256": _hash_file(image_path) if image_path.exists() else "", + "text": label.text, + "prediction_score": "", + } + ) + for pred in predictions: + writer.writerow( + { + "kind": "prediction_without_label", + "image_key": pred.image_key, + "image_path": pred.image_path, + "image_sha256": "", + "text": pred.text, + "prediction_score": pred.score, + } + ) + + +def _write_worst(path: Path, lines: list[EvalLine], limit: int, args: argparse.Namespace) -> list[EvalLine]: + worst = sorted(lines, key=lambda line: (line.grapheme_edits / max(line.grapheme_len, 1), line.grapheme_edits), reverse=True)[:limit] + fields = [ + "sample_id", + "image_path", + "image_sha256", + "language", + "script", + "domain", + "gt_status", + "split", + "claim_eligible", + "source_document", + "source_page", + "source_bbox", + "cer_grapheme", + "cer_codepoint", + "gt_text", + "prediction", + "prediction_score", + ] + with path.open("w", encoding="utf-8", newline="") as handle: + writer = csv.DictWriter(handle, fieldnames=fields) + writer.writeheader() + for line in worst: + row = _line_dict(line) + row.update( + { + "language": _language(line.metadata, args.language), + "script": _script(line.metadata, args.script), + "domain": _domain(line.metadata, args.domain), + "gt_status": _gt_status(line.metadata, args.gt_status), + "split": _split(line.metadata, args.split), + "claim_eligible": _claim_eligible(line.metadata, args.claim_eligible), + "source_document": _metadata_value_for_keys(line.metadata, SOURCE_DOCUMENT_KEYS), + "source_page": _metadata_value_for_keys(line.metadata, PAGE_KEYS), + "source_bbox": _metadata_value_for_keys(line.metadata, BBOX_KEYS), + } + ) + writer.writerow({field: row[field] for field in fields}) + return worst + + +def _write_review_csv(path: Path, lines: list[EvalLine]) -> None: + fields = ["sample_id", "image_path", "gt_text", "prediction", "prediction_score", "review_status", "corrected_text", "reviewer", "notes"] + with path.open("w", encoding="utf-8", newline="") as handle: + writer = csv.DictWriter(handle, fieldnames=fields) + writer.writeheader() + for line in lines: + writer.writerow( + { + "sample_id": line.sample_id, + "image_path": line.image_path, + "gt_text": line.gt_text, + "prediction": line.prediction, + "prediction_score": line.prediction_score, + "review_status": "", + "corrected_text": "", + "reviewer": "", + "notes": "", + } + ) + + +def _write_review_html(path: Path, data_dir: Path, lines: list[EvalLine]) -> None: + cards = [] + for line in lines: + image_uri = (data_dir / line.image_path).resolve().as_uri() + cards.append( + f""" +
+

{html.escape(line.sample_id)}

+ {html.escape(line.sample_id)} +

GT

{html.escape(line.gt_text)}
+

Prediction

{html.escape(line.prediction)}
+

graph CER {line.grapheme_edits / max(line.grapheme_len, 1):.3f}; cp CER {line.codepoint_edits / max(line.codepoint_len, 1):.3f}

+
+""" + ) + path.write_text( + """ +

Recognizer Eval Review Sample

""" + + "\n".join(cards) + + "\n", + encoding="utf-8", + ) + + +def _confusions(lines: list[EvalLine], limit: int = 200) -> dict[str, int]: + counts: dict[str, int] = {} + for line in lines: + gt = _nfc(line.gt_text) + pred = _nfc(line.prediction) + for opcode in Levenshtein.opcodes(pred, gt): + tag, i1, i2, j1, j2 = opcode + if tag == "equal": + continue + left = pred[i1:i2] or "" + right = gt[j1:j2] or "" + key = f"{left}->{right}" + counts[key] = counts.get(key, 0) + 1 + return dict(sorted(counts.items(), key=lambda item: item[1], reverse=True)[:limit]) + + +def _write_metrics_md(path: Path, metrics: dict[str, Any], warnings: list[str]) -> None: + uncertainty = metrics.get("uncertainty") if isinstance(metrics.get("uncertainty"), dict) else {} + intervals = uncertainty.get("metrics") if isinstance(uncertainty.get("metrics"), dict) else {} + graph_interval = intervals.get("cer_grapheme_micro") if isinstance(intervals.get("cer_grapheme_micro"), dict) else {} + inventory = metrics.get("script_inventory") if isinstance(metrics.get("script_inventory"), dict) else {} + normalization = metrics.get("normalization_summary") if isinstance(metrics.get("normalization_summary"), dict) else {} + dictionary_coverage = metrics.get("dictionary_coverage") if isinstance(metrics.get("dictionary_coverage"), dict) else {} + lines = [ + "# Recognizer Eval Metrics", + "", + f"- lines: {metrics['n_lines']}", + f"- label lines: {metrics['label_lines']}", + f"- prediction match rate: {metrics['prediction_match_rate']:.6f}", + f"- unmatched labels: {metrics['unmatched_labels']}", + f"- unmatched predictions: {metrics['unmatched_predictions']}", + f"- codepoint CER: {metrics['cer_codepoint_micro']:.6f}", + f"- grapheme CER: {metrics['cer_grapheme_micro']:.6f}", + f"- exact-line accuracy: {metrics['exact_line_accuracy']:.6f}", + f"- codepoint edits/ref: {metrics['codepoint_edits']}/{metrics['codepoint_ref_len']}", + f"- grapheme edits/ref: {metrics['grapheme_edits']}/{metrics['grapheme_ref_len']}", + f"- zero-length GT lines: {metrics.get('zero_length_gt_lines')}", + f"- normalization profile: {normalization.get('profile')}", + f"- normalization changed GT/prediction/any: {normalization.get('gt_changed')}/{normalization.get('prediction_changed')}/{normalization.get('any_changed')} of {normalization.get('total')}", + f"- dictionary coverage checked: {dictionary_coverage.get('checked')}", + f"- dictionary GT codepoints/dictionary codepoints: {dictionary_coverage.get('gt_codepoint_count')}/{dictionary_coverage.get('dictionary_codepoint_count')}", + f"- dictionary missing GT codepoints: {dictionary_coverage.get('missing_gt_codepoints')}", + f"- uncertainty method: {uncertainty.get('method')}", + f"- uncertainty scoring units: {uncertainty.get('effective_sample_size')}/{uncertainty.get('min_claim_scoring_units')}", + f"- grapheme CER 95% CI: {_fmt_metric(graph_interval.get('low'))}..{_fmt_metric(graph_interval.get('high'))}", + f"- script inventory file: {inventory.get('inventory_file')}", + f"- observed codepoints/graphemes: {inventory.get('observed_codepoint_count')}/{inventory.get('observed_grapheme_count')}", + f"- missing required codepoints: {inventory.get('missing_required_codepoints')}", + f"- missing required graphemes: {inventory.get('missing_required_graphemes')}", + "", + "## Slices", + "", + ] + for row in metrics["slices"]: + lines.append( + f"- {row['language']} / {row['script']} / {row['domain']} / {row['gt_status']} / {row['split']}: " + f"n={row['n_lines']} graph_CER={row['cer_grapheme_micro']:.6f} " + f"cp_CER={row['cer_codepoint_micro']:.6f} exact={row['exact_line_accuracy']:.6f}" + ) + lines.extend( + [ + "", + "## Warnings", + "", + ] + ) + lines.extend([f"- {warning}" for warning in warnings] or ["- none"]) + path.write_text("\n".join(lines) + "\n", encoding="utf-8") + + +def _fmt_metric(value: Any) -> str: + if isinstance(value, int | float) and not isinstance(value, bool): + return f"{float(value):.6f}" + return str(value) + + +def _write_claim_safety_report(path: Path, eval_run: dict[str, Any], metrics: dict[str, Any]) -> None: + warnings = eval_run.get("warnings") or [] + machine = eval_run.get("machine") if isinstance(eval_run.get("machine"), dict) else {} + provenance = metrics.get("provenance_coverage") if isinstance(metrics.get("provenance_coverage"), dict) else {} + leakage = metrics.get("leakage") if isinstance(metrics.get("leakage"), dict) else {} + uncertainty = metrics.get("uncertainty") if isinstance(metrics.get("uncertainty"), dict) else {} + intervals = uncertainty.get("metrics") if isinstance(uncertainty.get("metrics"), dict) else {} + graph_interval = intervals.get("cer_grapheme_micro") if isinstance(intervals.get("cer_grapheme_micro"), dict) else {} + inventory = metrics.get("script_inventory") if isinstance(metrics.get("script_inventory"), dict) else {} + normalization = metrics.get("normalization_summary") if isinstance(metrics.get("normalization_summary"), dict) else {} + dictionary_coverage = metrics.get("dictionary_coverage") if isinstance(metrics.get("dictionary_coverage"), dict) else {} + lines = [ + "# Eval Claim Safety Report", + "", + f"- eval mode: {eval_run.get('eval_mode')}", + f"- claim safe: {eval_run.get('claim_safe')}", + f"- created at: {eval_run.get('created_at')}", + f"- machine platform: {machine.get('platform')}", + f"- machine python: {machine.get('python')}", + f"- command: {eval_run.get('command')}", + "", + "## What Was Scored", + "", + f"- model: {eval_run.get('model_name')}", + f"- checkpoint: {eval_run.get('checkpoint') or '(not recorded)'}", + f"- config: {eval_run.get('config') or '(not recorded)'}", + f"- dictionary: {eval_run.get('dictionary') or '(not recorded)'}", + f"- artifact identity: {json.dumps(eval_run.get('artifact_identity', {}), ensure_ascii=False, sort_keys=True)}", + f"- label file: {eval_run.get('label_file')}", + f"- prediction file: {eval_run.get('prediction_file')}", + f"- scored lines: {metrics.get('n_lines')}", + f"- unmatched labels: {metrics.get('unmatched_labels')}", + f"- unmatched predictions: {metrics.get('unmatched_predictions')}", + f"- review CSV: sample-review.csv", + f"- review HTML: sample-review.html", + "", + "## Ground Truth And Pack", + "", + f"- eval pack version: {eval_run.get('eval_pack_version') or '(missing)'}", + f"- frozen eval pack: {eval_run.get('frozen_eval_pack')}", + f"- unseen for selection: {eval_run.get('unseen_for_selection')}", + f"- selected checkpoint on test: {eval_run.get('selected_checkpoint_on_test')}", + f"- languages: {eval_run.get('languages')}", + f"- scripts: {eval_run.get('scripts')}", + f"- domains: {eval_run.get('domains')}", + f"- GT statuses: {eval_run.get('gt_statuses')}", + f"- splits: {eval_run.get('splits')}", + f"- provenance coverage: {provenance}", + f"- script inventory file: {inventory.get('inventory_file')}", + f"- observed codepoints/graphemes: {inventory.get('observed_codepoint_count')}/{inventory.get('observed_grapheme_count')}", + f"- missing required codepoints: {inventory.get('missing_required_codepoints')}", + f"- missing required graphemes: {inventory.get('missing_required_graphemes')}", + f"- metadata contradictions: {metrics.get('metadata_contradictions', [])}", + f"- normalizer counts: {metrics.get('normalizer_counts', {})}", + f"- normalization profile: {normalization.get('profile')}", + f"- normalization changed GT/prediction/any: {normalization.get('gt_changed')}/{normalization.get('prediction_changed')}/{normalization.get('any_changed')} of {normalization.get('total')}", + f"- dictionary coverage checked: {dictionary_coverage.get('checked')}", + f"- dictionary GT codepoints/dictionary codepoints: {dictionary_coverage.get('gt_codepoint_count')}/{dictionary_coverage.get('dictionary_codepoint_count')}", + f"- dictionary missing GT codepoints: {dictionary_coverage.get('missing_gt_codepoints')}", + f"- leakage checked: {leakage.get('checked')}", + "", + "## Metrics", + "", + f"- codepoint CER micro: {_fmt_metric(metrics.get('cer_codepoint_micro'))}", + f"- grapheme CER micro: {_fmt_metric(metrics.get('cer_grapheme_micro'))}", + f"- exact-line accuracy: {_fmt_metric(metrics.get('exact_line_accuracy'))}", + f"- prediction match rate: {_fmt_metric(metrics.get('prediction_match_rate'))}", + f"- codepoint edits/ref: {metrics.get('codepoint_edits')}/{metrics.get('codepoint_ref_len')}", + f"- grapheme edits/ref: {metrics.get('grapheme_edits')}/{metrics.get('grapheme_ref_len')}", + f"- zero-length GT lines: {metrics.get('zero_length_gt_lines')}", + f"- uncertainty method: {uncertainty.get('method')}", + f"- uncertainty scoring units: {uncertainty.get('effective_sample_size')}/{uncertainty.get('min_claim_scoring_units')}", + f"- grapheme CER 95% CI: {_fmt_metric(graph_interval.get('low'))}..{_fmt_metric(graph_interval.get('high'))}", + "", + "## Slices", + "", + ] + for row in metrics.get("slices", []): + if not isinstance(row, dict): + continue + lines.append( + f"- {row.get('language')} / {row.get('script')} / {row.get('domain')} / {row.get('gt_status')} / {row.get('split')}: " + f"n={row.get('n_lines')} graph_CER={_fmt_metric(row.get('cer_grapheme_micro'))} " + f"cp_CER={_fmt_metric(row.get('cer_codepoint_micro'))} exact={_fmt_metric(row.get('exact_line_accuracy'))}" + ) + lines.extend( + [ + "", + "## Warnings", + "", + ] + ) + lines.extend([f"- {warning}" for warning in warnings] or ["- none"]) + lines.extend( + [ + "", + "## Review Artifacts", + "", + "- command.txt", + "- predictions.tsv", + "- unmatched.tsv", + "- worst-lines.csv", + "- sample-review.csv", + "- sample-review.html", + "- confusions.json", + ] + ) + path.write_text("\n".join(lines) + "\n", encoding="utf-8") + + +def run_eval(args: argparse.Namespace) -> dict[str, Any]: + labels = _read_labels(args.label_file) + predictions = _read_predictions(args.prediction_file) + manifest = _read_manifest(args.manifest_file) + summary = _read_summary(args.summary_file) + spotcheck_calibration = _read_spotcheck_calibration(args.spotcheck_calibration_file) + lines, unmatched_labels, unmatched_predictions = _build_lines(labels, predictions, manifest, args.data_dir) + unmatched_count = len(unmatched_labels) + len(unmatched_predictions) + match_rate = len(lines) / max(len(labels), 1) + if unmatched_count and args.require_full_match: + raise ValueError( + f"prediction/label mismatch: {len(unmatched_labels)} labels without predictions, " + f"{len(unmatched_predictions)} predictions without labels" + ) + + metrics = _aggregate(lines) + metrics["label_lines"] = len(labels) + metrics["unmatched_labels"] = len(unmatched_labels) + metrics["unmatched_predictions"] = len(unmatched_predictions) + metrics["prediction_match_rate"] = match_rate + metrics["slices"] = _slice_metrics(lines, args) + metrics["provenance_coverage"] = _provenance_coverage(lines) + metadata_contradictions = _metadata_contradictions(lines, args) + metrics["metadata_contradictions"] = metadata_contradictions + metrics["normalizer_counts"] = _summary_counts(summary) + metrics["normalization_summary"] = _normalization_summary(lines) + leakage = _leakage_report(args.train_manifest or [], lines, args.data_dir) + metrics["leakage"] = leakage + pack_content_sha256 = _pack_content_digest(lines, args) + metrics["pack_content_sha256"] = pack_content_sha256 + if spotcheck_calibration: + metrics["spotcheck_calibration"] = _spotcheck_calibration_summary(spotcheck_calibration) + script_inventory = _script_inventory_summary([line.gt_text for line in lines], args.script_inventory_file) + metrics["script_inventory"] = script_inventory + dictionary_coverage = _dictionary_coverage([line.gt_text for line in lines], args.dictionary) + metrics["dictionary_coverage"] = dictionary_coverage + artifacts = _artifact_identities(args) + warnings = _claim_warnings( + lines, + metrics["slices"], + args, + unmatched_count, + match_rate, + summary, + leakage, + spotcheck_calibration, + artifacts, + metadata_contradictions, + script_inventory, + dictionary_coverage, + pack_content_sha256, + ) + claim_safe = not warnings + if args.require_claim_safe and not claim_safe: + raise ValueError("claim-safe eval requested but warnings are present: " + "; ".join(warnings)) + + out = args.out + if out.exists() and any(out.iterdir()) and not args.force: + raise FileExistsError(f"output directory exists and is not empty: {out}") + out.mkdir(parents=True, exist_ok=True) + + domains = sorted({_domain(line.metadata, args.domain) for line in lines}) + gt_statuses = sorted({_gt_status(line.metadata, args.gt_status) for line in lines}) + languages = sorted({_language(line.metadata, args.language) for line in lines}) + scripts = sorted({_script(line.metadata, args.script) for line in lines}) + splits = sorted({_split(line.metadata, args.split) for line in lines}) + eval_run = { + "created_at": datetime.now(timezone.utc).isoformat(), + "model_name": args.model_name, + "checkpoint": args.checkpoint, + "config": args.config, + "dictionary": args.dictionary, + "artifact_identity": artifacts, + "label_file": str(args.label_file), + "label_file_sha256": _hash_file(args.label_file), + "prediction_file": str(args.prediction_file), + "prediction_file_sha256": _hash_file(args.prediction_file), + "manifest_file": str(args.manifest_file) if args.manifest_file else None, + "manifest_file_sha256": _hash_file(args.manifest_file) if args.manifest_file else None, + "summary_file": str(args.summary_file) if args.summary_file else None, + "summary_file_sha256": _hash_file(args.summary_file) if args.summary_file else None, + "script_inventory_file": str(args.script_inventory_file) if args.script_inventory_file else None, + "script_inventory_file_sha256": _hash_file(args.script_inventory_file) if args.script_inventory_file else None, + "spotcheck_calibration_file": str(args.spotcheck_calibration_file) if args.spotcheck_calibration_file else None, + "spotcheck_calibration_file_sha256": _hash_file(args.spotcheck_calibration_file) if args.spotcheck_calibration_file else None, + "spotcheck_calibration": metrics.get("spotcheck_calibration"), + "train_manifests": [{"path": str(path), "sha256": _hash_file(path)} for path in (args.train_manifest or [])], + "data_dir": str(args.data_dir), + "eval_pack_version": args.eval_pack_version, + "pack_content_sha256": pack_content_sha256, + "frozen_eval_pack": args.frozen_eval_pack, + "unseen_for_selection": args.unseen_for_selection, + "selected_checkpoint_on_test": args.selected_checkpoint_on_test, + "normalization_profile": DEFAULT_NORMALIZATION, + "eval_mode": "recognizer_oracle_crop", + "languages": languages, + "scripts": scripts, + "domains": domains, + "gt_statuses": gt_statuses, + "splits": splits, + "claim_eligible_default": args.claim_eligible, + "min_match_rate": args.min_match_rate, + "known_leakage": args.known_leakage, + "provenance_coverage": metrics["provenance_coverage"], + "script_inventory": metrics["script_inventory"], + "normalizer_counts": metrics["normalizer_counts"], + "leakage": leakage, + "claim_safe": claim_safe, + "warnings": warnings, + "machine": { + "platform": platform.platform(), + "python": sys.version, + }, + "command": " ".join(sys.argv), + } + + worst = _write_worst(out / "worst-lines.csv", lines, args.review_sample_size, args) + _write_tsv(out / "predictions.tsv", lines, args) + _write_unmatched(out / "unmatched.tsv", unmatched_labels, unmatched_predictions, args.data_dir) + _write_review_csv(out / "sample-review.csv", worst) + _write_review_html(out / "sample-review.html", args.data_dir, worst) + _write_json(out / "metrics.json", metrics) + _write_metrics_md(out / "metrics.md", metrics, warnings) + _write_json(out / "eval-run.json", eval_run) + _write_claim_safety_report(out / "claim-safety.md", eval_run, metrics) + _write_json(out / "confusions.json", _confusions(lines)) + (out / "command.txt").write_text(eval_run["command"] + "\n", encoding="utf-8") + return {"metrics": metrics, "eval_run": eval_run} + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--label-file", type=Path, required=True) + parser.add_argument("--data-dir", type=Path, required=True) + parser.add_argument("--prediction-file", type=Path, required=True) + parser.add_argument("--out", type=Path, required=True) + parser.add_argument("--manifest-file", type=Path) + parser.add_argument("--summary-file", type=Path) + parser.add_argument("--script-inventory-file", type=Path) + parser.add_argument("--spotcheck-calibration-file", type=Path) + parser.add_argument("--train-manifest", type=Path, action="append", default=[]) + parser.add_argument("--model-name", required=True) + parser.add_argument("--checkpoint", default="") + parser.add_argument("--config", default="") + parser.add_argument("--dictionary", default="") + parser.add_argument("--language", default="unknown") + parser.add_argument("--script", default="unknown") + parser.add_argument("--domain", default="unknown") + parser.add_argument("--gt-status", default="unknown") + parser.add_argument("--split", default="eval") + parser.add_argument("--eval-pack-version", default="") + parser.add_argument("--frozen-eval-pack", action=argparse.BooleanOptionalAction, default=False) + parser.add_argument("--unseen-for-selection", action=argparse.BooleanOptionalAction, default=False) + parser.add_argument("--selected-checkpoint-on-test", action=argparse.BooleanOptionalAction, default=False) + parser.add_argument("--claim-eligible", action=argparse.BooleanOptionalAction, default=False) + parser.add_argument("--known-leakage", default="") + parser.add_argument("--min-match-rate", type=float, default=0.99) + parser.add_argument("--review-sample-size", type=int, default=50) + parser.add_argument("--require-full-match", action=argparse.BooleanOptionalAction, default=True) + parser.add_argument("--require-claim-safe", action="store_true") + parser.add_argument("--force", action="store_true") + args = parser.parse_args(argv) + result = run_eval(args) + metrics = result["metrics"] + print( + f"wrote {args.out} graph_CER={metrics['cer_grapheme_micro']:.3f} " + f"cp_CER={metrics['cer_codepoint_micro']:.3f} exact={metrics['exact_line_accuracy']:.3f}" + ) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ocr-tech-mps-integration/tools/run_recognizer_pack_normalization.py b/ocr-tech-mps-integration/tools/run_recognizer_pack_normalization.py new file mode 100644 index 0000000000000000000000000000000000000000..9a2e97af3a277f1303a1b35f5ec548e59b67399f --- /dev/null +++ b/ocr-tech-mps-integration/tools/run_recognizer_pack_normalization.py @@ -0,0 +1,309 @@ +#!/usr/bin/env python3 +"""Run configured recognizer eval-pack normalizations reproducibly.""" + +from __future__ import annotations + +import argparse +import importlib.util +import json +import platform +import sys +import traceback +from argparse import Namespace +from datetime import datetime, timezone +from pathlib import Path +from types import ModuleType +from typing import Any + + +REQUIRED_PACK_KEYS = ( + "id", + "label_file", + "data_dir", + "out", + "dataset", + "language", + "script", + "domain", + "gt_status", + "split", + "eval_pack_version", + "frozen_eval_pack", + "unseen_for_selection", + "claim_eligible", +) +TOOLS_DIR = Path(__file__).resolve().parent + + +def _load_tool(name: str) -> ModuleType: + path = TOOLS_DIR / f"{name}.py" + spec = importlib.util.spec_from_file_location(name, path) + if spec is None or spec.loader is None: + raise RuntimeError(f"could not load tool module: {path}") + module = importlib.util.module_from_spec(spec) + sys.modules[spec.name] = module + spec.loader.exec_module(module) + return module + + +def _read_config(path: Path) -> dict[str, Any]: + if not path.exists(): + raise FileNotFoundError(f"normalization config does not exist: {path}") + try: + payload = json.loads(path.read_text(encoding="utf-8")) + except json.JSONDecodeError as exc: + raise ValueError(f"normalization config is invalid JSON: {path}: {exc}") from exc + if not isinstance(payload, dict): + raise ValueError(f"normalization config must contain a JSON object: {path}") + packs = payload.get("packs") + if not isinstance(packs, list) or not packs: + raise ValueError("normalization config must contain a non-empty packs list") + return payload + + +def _resolve(root: Path, value: str | None) -> Path | None: + if not value: + return None + path = Path(value) + return path if path.is_absolute() else root / path + + +def _check_path(issues: list[str], root: Path, pack_id: str, field: str, value: Any) -> None: + if not isinstance(value, str) or not value: + issues.append(f"{pack_id}: missing path field {field}") + return + path = _resolve(root, value) + if path is None or not path.exists(): + issues.append(f"{pack_id}: path does not exist for {field}: {value}") + + +def _pack_blockers(pack: dict[str, Any]) -> list[str]: + blockers: list[str] = [] + if not pack.get("frozen_eval_pack"): + blockers.append("eval pack is not frozen") + if not pack.get("unseen_for_selection"): + blockers.append("eval pack is not unseen for selection") + if not pack.get("claim_eligible"): + blockers.append("eval pack rows are not claim eligible by default") + if pack.get("gt_status") not in {"human_verified", "machine_converted_spot_checked"}: + blockers.append(f"GT status is not claim-safe: {pack.get('gt_status')}") + if pack.get("domain") not in {"real_print", "real_handwritten"}: + blockers.append(f"domain is not claim-safe real material: {pack.get('domain')}") + blockers.extend(str(item) for item in pack.get("claim_blockers", []) if item) + return sorted(set(blockers)) + + +def validate_config(path: Path, root: Path) -> dict[str, Any]: + payload = _read_config(path) + results: list[dict[str, Any]] = [] + all_issues: list[str] = [] + ids: set[str] = set() + for index, pack in enumerate(payload["packs"]): + if not isinstance(pack, dict): + issue = f"packs[{index}] must be an object" + all_issues.append(issue) + results.append({"id": f"packs[{index}]", "valid": False, "claim_ready": False, "issues": [issue], "claim_blockers": []}) + continue + pack_id = str(pack.get("id") or f"packs[{index}]") + issues: list[str] = [] + if pack_id in ids: + issues.append(f"{pack_id}: duplicate pack id") + ids.add(pack_id) + for key in REQUIRED_PACK_KEYS: + if key not in pack: + issues.append(f"{pack_id}: missing required key {key}") + _check_path(issues, root, pack_id, "label_file", pack.get("label_file")) + _check_path(issues, root, pack_id, "data_dir", pack.get("data_dir")) + if pack.get("manifest_file"): + _check_path(issues, root, pack_id, "manifest_file", pack.get("manifest_file")) + if pack.get("summary_file"): + _check_path(issues, root, pack_id, "summary_file", pack.get("summary_file")) + blockers = _pack_blockers(pack) + all_issues.extend(issues) + results.append( + { + "id": pack_id, + "language": pack.get("language"), + "script": pack.get("script"), + "valid": not issues, + "claim_ready": not issues and not blockers, + "issues": issues, + "claim_blockers": blockers, + "out": pack.get("out"), + } + ) + return { + "config_file": str(path), + "root": str(root), + "pack_count": len(payload["packs"]), + "valid": not all_issues, + "claim_ready_count": sum(1 for result in results if result["claim_ready"]), + "issues": all_issues, + "packs": results, + } + + +def _selected_packs(config: dict[str, Any], pack_ids: list[str] | None, all_packs: bool) -> list[dict[str, Any]]: + packs = [pack for pack in config["packs"] if isinstance(pack, dict)] + if all_packs: + return packs + if not pack_ids: + raise ValueError("select at least one --pack-id or pass --all") + by_id = {str(pack.get("id")): pack for pack in packs} + selected: list[dict[str, Any]] = [] + for pack_id in pack_ids: + if pack_id not in by_id: + raise ValueError(f"pack id not found: {pack_id}") + selected.append(by_id[pack_id]) + return selected + + +def _normalizer_args(pack: dict[str, Any], root: Path, force: bool) -> Namespace: + return Namespace( + label_file=_resolve(root, pack.get("label_file")), + data_dir=_resolve(root, pack.get("data_dir")), + out=_resolve(root, pack.get("out")), + manifest_file=_resolve(root, pack.get("manifest_file")), + summary_file=_resolve(root, pack.get("summary_file")), + dataset=str(pack["dataset"]), + language=str(pack["language"]), + script=str(pack["script"]), + domain=str(pack["domain"]), + gt_status=str(pack["gt_status"]), + split=str(pack["split"]), + eval_pack_version=str(pack["eval_pack_version"]), + frozen_eval_pack=bool(pack.get("frozen_eval_pack")), + unseen_for_selection=bool(pack.get("unseen_for_selection")), + claim_eligible=bool(pack.get("claim_eligible")), + force=force, + ) + + +def _audit_args(pack: dict[str, Any], normalized_out: Path) -> Namespace: + return Namespace( + label_file=normalized_out / "eval.txt", + data_dir=normalized_out, + manifest_file=normalized_out / "manifests" / "recognizer-eval.jsonl", + summary_file=normalized_out / "summary.json", + out=normalized_out / "audit", + language=str(pack["language"]), + script=str(pack["script"]), + domain=str(pack["domain"]), + gt_status=str(pack["gt_status"]), + split=str(pack["split"]), + eval_pack_version=str(pack["eval_pack_version"]), + frozen_eval_pack=bool(pack.get("frozen_eval_pack")), + unseen_for_selection=bool(pack.get("unseen_for_selection")), + claim_eligible=bool(pack.get("claim_eligible")), + require_claim_ready=False, + ) + + +def _write_pack_audit(audit_tool: ModuleType, pack: dict[str, Any], normalized_out: Path) -> dict[str, Any]: + audit_args = _audit_args(pack, normalized_out) + audit = audit_tool.audit_pack(audit_args) + audit_args.out.mkdir(parents=True, exist_ok=True) + (audit_args.out / "recognizer-eval-pack-audit.json").write_text( + json.dumps(audit, ensure_ascii=False, indent=2) + "\n", + encoding="utf-8", + ) + audit_tool._write_markdown(audit_args.out / "recognizer-eval-pack-audit.md", audit) + return audit + + +def run_normalizations(args: argparse.Namespace) -> dict[str, Any]: + root = args.root.resolve() + config_path = args.config if args.config.is_absolute() else root / args.config + config = _read_config(config_path) + validation = validate_config(config_path, root) + if args.require_valid and not validation["valid"]: + raise ValueError("normalization config is not valid: " + "; ".join(validation["issues"])) + selected = _selected_packs(config, args.pack_id, args.all) + selected_ids = {str(pack["id"]) for pack in selected} + invalid_selected = [ + result + for result in validation["packs"] + if result["id"] in selected_ids and not result["valid"] + ] + if invalid_selected: + issues = [issue for result in invalid_selected for issue in result["issues"]] + raise ValueError("selected normalization packs are invalid: " + "; ".join(issues)) + + out = args.out + if out.exists() and any(out.iterdir()) and not args.force: + raise FileExistsError(f"output directory exists and is not empty: {out}") + out.mkdir(parents=True, exist_ok=True) + (out / "config-validation.json").write_text(json.dumps(validation, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + results: list[dict[str, Any]] = [] + normalizer = None if args.dry_run else _load_tool("normalize_recognizer_eval_pack") + audit_tool = None if args.dry_run else _load_tool("audit_recognizer_eval_pack") + try: + for pack in selected: + pack_id = str(pack["id"]) + if args.dry_run: + results.append({"id": pack_id, "status": "dry_run", "out": pack["out"]}) + continue + normalizer_args = _normalizer_args(pack, root, args.force) + assert normalizer is not None + assert audit_tool is not None + summary = normalizer.normalize_pack(normalizer_args) + audit = _write_pack_audit(audit_tool, pack, normalizer_args.out) + results.append( + { + "id": pack_id, + "status": "normalized", + "out": str(normalizer_args.out), + "audit_file": str(normalizer_args.out / "audit" / "recognizer-eval-pack-audit.json"), + "audit_passed": audit["passed"], + "claim_ready": audit["claim_ready"], + "rows": summary["counts"]["labels"], + "warnings": summary["warnings"], + "audit_warnings": audit["warnings"], + } + ) + run_summary = { + "created_at": datetime.now(timezone.utc).isoformat(), + "config_file": str(config_path), + "root": str(root), + "dry_run": args.dry_run, + "selected_pack_ids": [str(pack["id"]) for pack in selected], + "results": results, + "validation": validation, + "machine": {"platform": platform.platform(), "python": sys.version}, + "command": " ".join(sys.argv), + } + (out / "normalization-run.json").write_text(json.dumps(run_summary, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + return run_summary + except Exception as exc: + error_payload = { + "created_at": datetime.now(timezone.utc).isoformat(), + "config_file": str(config_path), + "error_type": type(exc).__name__, + "error": str(exc), + "traceback": traceback.format_exc(), + } + (out / "normalization-run-error.json").write_text(json.dumps(error_payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + raise + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--config", type=Path, default=Path("configs/recognizer-eval-pack-normalization-v1.json")) + parser.add_argument("--root", type=Path, default=Path(".")) + parser.add_argument("--pack-id", action="append") + parser.add_argument("--all", action="store_true") + parser.add_argument("--out", type=Path, required=True) + parser.add_argument("--dry-run", action="store_true") + parser.add_argument("--require-valid", action="store_true") + parser.add_argument("--force", action="store_true") + args = parser.parse_args(argv) + result = run_normalizations(args) + print( + f"packs={len(result['selected_pack_ids'])} dry_run={result['dry_run']} " + f"valid={result['validation']['valid']}" + ) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ocr-tech-mps-integration/tools/score_limbu_book_ocr_candidate.py b/ocr-tech-mps-integration/tools/score_limbu_book_ocr_candidate.py new file mode 100644 index 0000000000000000000000000000000000000000..ac8cdef9b3b003c205be62cddf57db4f27ef6836 --- /dev/null +++ b/ocr-tech-mps-integration/tools/score_limbu_book_ocr_candidate.py @@ -0,0 +1,384 @@ +#!/usr/bin/env python3 +"""Score and admit a Limbu book OCR candidate projection.""" + +from __future__ import annotations + +import argparse +import importlib.util +import json +import platform +import sys +from argparse import Namespace +from datetime import UTC, datetime +from pathlib import Path +from typing import Any + +from ocrtech.manifest import sha256_file + + +REPORT_JSON = "limbu-book-ocr-score-admission.json" +PROFILE_LIMBU_DEVANAGARI_CDC_CURRENT = "limbu-devanagari-cdc-current" +SCORE_PROFILES: dict[str, dict[str, Any]] = { + PROFILE_LIMBU_DEVANAGARI_CDC_CURRENT: { + "eval_manifest": Path( + "outputs/limbu-book-ocr-missed-line-recovery-2026-06-22/" + "multi-page-cdc-h20-structural-replay-inputs/eval-replay.jsonl" + ), + "ocr_output_kind": "live_detector", + "summary_file": Path( + "outputs/limbu-page-eval-drafts/limbu-devanagari-cdc-curriculum-linebox-2026-06-21/summary.json" + ), + "script_inventory_file": Path( + "outputs/limbu-page-eval-drafts/limbu-devanagari-cdc-curriculum-linebox-2026-06-21/script-inventory.json" + ), + "train_manifest": [ + Path("outputs/limbu-page-eval-drafts/limbu-devanagari-cdc-curriculum-linebox-2026-06-21/train-dev-empty.jsonl") + ], + "system_name": "limbu-devanagari-cdc-reviewed-book-candidate", + "model_name": "limbu-devanagari-cdc-ppocrv5-mobile-devclean-stopped-epoch11", + "checkpoint": ( + "outputs/limbu-devanagari-cdc-ppocrv5-training-completion-audit-stopped-2026-06-22/" + "package/model-card.json" + ), + "config": ( + "outputs/limbu-devanagari-cdc-ppocrv5-training-completion-audit-stopped-2026-06-22/" + "package/model-card.json" + ), + "dictionary": ( + "outputs/limbu-devanagari-cdc-ppocrv5-training-completion-audit-stopped-2026-06-22/" + "package/artifacts/nep_eng_dict.txt" + ), + "language": "limbu", + "script": "Devanagari", + "domain": "real_print", + "gt_status": "curriculum_text_unreviewed", + "eval_pack_version": "limbu-devanagari-cdc-curriculum-linebox-draft-v1", + "frozen_eval_pack": False, + "unseen_for_selection": True, + "selected_checkpoint_on_test": False, + "claim_eligible": False, + "line_iou_threshold": 0.5, + "review_sample_size": 50, + "baseline_codepoint_cer": 0.458432, + "min_codepoint_improvement": 0.0, + "min_line_f1": 0.60, + "min_reading_order_accuracy": 0.60, + "max_blank_line_rate": 0.0, + "max_extra_line_rate": 0.30, + "max_missed_line_rate": 0.30, + "min_scored_pages": 3, + "min_claim_pages": 30, + } +} + + +def _load_sibling_module(module_name: str) -> Any: + path = Path(__file__).with_name(f"{module_name}.py") + spec = importlib.util.spec_from_file_location(module_name, path) + if spec is None or spec.loader is None: + raise ValueError(f"could not load sibling tool module: {path}") + module = importlib.util.module_from_spec(spec) + sys.modules[module_name] = module + spec.loader.exec_module(module) + return module + + +def _read_json(path: Path, label: str) -> dict[str, Any]: + if not path.is_file(): + raise FileNotFoundError(f"{label} does not exist: {path}") + try: + payload = json.loads(path.read_text(encoding="utf-8")) + except json.JSONDecodeError as exc: + raise ValueError(f"{label} is invalid JSON: {path}: {exc}") from exc + if not isinstance(payload, dict): + raise ValueError(f"{label} must contain a JSON object: {path}") + return payload + + +def _write_json(path: Path, payload: dict[str, Any]) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + + +def _file_record(path: Path) -> dict[str, str | None]: + return { + "path": str(path), + "sha256": sha256_file(path) if path.is_file() else None, + } + + +def _profile_value(args: argparse.Namespace, key: str) -> Any: + value = getattr(args, key) + if value is not None: + return value + profile = SCORE_PROFILES.get(args.score_profile) + if not profile: + return None + return profile.get(key) + + +def _profile_bool(args: argparse.Namespace, key: str, *, default: bool = False) -> bool: + value = getattr(args, key) + if value is not None: + return bool(value) + profile = SCORE_PROFILES.get(args.score_profile) + if profile and key in profile: + return bool(profile[key]) + return default + + +def _profile_float(args: argparse.Namespace, key: str, *, default: float) -> float: + value = getattr(args, key) + if value is not None: + return float(value) + profile = SCORE_PROFILES.get(args.score_profile) + if profile and key in profile: + return float(profile[key]) + return default + + +def _profile_int(args: argparse.Namespace, key: str, *, default: int) -> int: + value = getattr(args, key) + if value is not None: + return int(value) + profile = SCORE_PROFILES.get(args.score_profile) + if profile and key in profile: + return int(profile[key]) + return default + + +def _require_path(value: Any, label: str) -> Path: + if value is None or str(value) == "": + raise ValueError(f"{label} is required; pass it explicitly or use a score profile") + path = Path(value) + if not path.is_file(): + raise FileNotFoundError(f"{label} does not exist: {path}") + return path + + +def _optional_path(value: Any, label: str) -> Path | None: + if value is None or str(value) == "": + return None + path = Path(value) + if not path.is_file(): + raise FileNotFoundError(f"{label} does not exist: {path}") + return path + + +def _candidate_documents_dir(book_output: Path, explicit_documents_dir: Path | None) -> Path: + if explicit_documents_dir is not None: + documents_dir = explicit_documents_dir + else: + book_run = _read_json(book_output / "book-run.json", "candidate book-run.json") + recorded = book_run.get("score_documents_dir") or book_run.get("documents_dir") + if not recorded: + raise ValueError( + "candidate book-run.json must record score_documents_dir/documents_dir, " + "or --documents-dir must be supplied" + ) + documents_dir = Path(str(recorded)) + if not documents_dir.is_dir(): + raise FileNotFoundError(f"candidate score documents directory does not exist: {documents_dir}") + document_count = sum(1 for _ in documents_dir.glob("*/document.json")) + if document_count == 0: + raise ValueError(f"candidate score documents directory contains no */document.json files: {documents_dir}") + return documents_dir + + +def _train_manifests(args: argparse.Namespace) -> list[Path]: + values = args.train_manifest + if values: + paths = [Path(value) for value in values] + else: + profile = SCORE_PROFILES.get(args.score_profile, {}) + paths = [Path(value) for value in profile.get("train_manifest", [])] + for path in paths: + if not path.is_file(): + raise FileNotFoundError(f"train manifest does not exist: {path}") + return paths + + +def score_and_admit(args: argparse.Namespace) -> dict[str, Any]: + book_output = Path(args.book_output) + if not (book_output / "book-run.json").is_file(): + raise FileNotFoundError(f"candidate book output is missing book-run.json: {book_output}") + out = Path(args.out) + score_dir = Path(args.score_dir) if args.score_dir else out / "score" + admission_dir = Path(args.admission_dir) if args.admission_dir else out / "admission" + documents_dir = _candidate_documents_dir(book_output, args.documents_dir) + eval_manifest = _require_path(_profile_value(args, "eval_manifest"), "eval manifest") + summary_file = _optional_path(_profile_value(args, "summary_file"), "summary file") + script_inventory_file = _optional_path(_profile_value(args, "script_inventory_file"), "script inventory file") + spotcheck_calibration_file = _optional_path(args.spotcheck_calibration_file, "spotcheck calibration file") + system_name = str(_profile_value(args, "system_name") or "") + if not system_name: + raise ValueError("--system-name is required; pass it explicitly or use a score profile") + + eval_tool = _load_sibling_module("run_page_ocr_eval") + admission_tool = _load_sibling_module("admit_limbu_book_ocr_candidate") + eval_args = Namespace( + eval_manifest=eval_manifest, + documents_dir=documents_dir, + ocr_output_kind=str(_profile_value(args, "ocr_output_kind") or "unknown"), + require_output_audit=bool(args.require_output_audit), + output_audit_filename=str(args.output_audit_filename), + output_audit_passed_field=str(args.output_audit_passed_field), + out=score_dir, + summary_file=summary_file, + script_inventory_file=script_inventory_file, + spotcheck_calibration_file=spotcheck_calibration_file, + train_manifest=_train_manifests(args), + system_name=system_name, + model_name=str(_profile_value(args, "model_name") or ""), + checkpoint=str(_profile_value(args, "checkpoint") or ""), + config=str(_profile_value(args, "config") or ""), + dictionary=str(_profile_value(args, "dictionary") or ""), + language=str(_profile_value(args, "language") or "unknown"), + script=str(_profile_value(args, "script") or "unknown"), + domain=str(_profile_value(args, "domain") or "unknown"), + gt_status=str(_profile_value(args, "gt_status") or "unknown"), + eval_pack_version=str(_profile_value(args, "eval_pack_version") or ""), + frozen_eval_pack=_profile_bool(args, "frozen_eval_pack"), + unseen_for_selection=_profile_bool(args, "unseen_for_selection"), + selected_checkpoint_on_test=_profile_bool(args, "selected_checkpoint_on_test"), + claim_eligible=_profile_bool(args, "claim_eligible"), + line_iou_threshold=_profile_float(args, "line_iou_threshold", default=0.5), + review_sample_size=_profile_int(args, "review_sample_size", default=50), + require_claim_safe=bool(args.require_claim_safe), + force=bool(args.force), + ) + score_result = eval_tool.run_eval(eval_args) + metrics_path = score_dir / "metrics.json" + metrics_sha = sha256_file(metrics_path) + book_audit = Path(args.book_audit) if args.book_audit else book_output / "limbu-book-output-audit.json" + champion_metrics = getattr(args, "champion_metrics", None) + review_coverage_report = getattr(args, "review_coverage_report", None) + admission_args = Namespace( + book_output=book_output, + score_dir=score_dir, + out=admission_dir, + book_audit=book_audit, + metrics_sha256=metrics_sha, + book_audit_sha256=sha256_file(book_audit) if book_audit.is_file() else None, + champion_metrics=champion_metrics, + review_coverage_report=review_coverage_report, + baseline_codepoint_cer=_profile_float(args, "baseline_codepoint_cer", default=0.458432), + baseline_grapheme_cer=args.baseline_grapheme_cer, + baseline_wer=args.baseline_wer, + min_codepoint_improvement=_profile_float(args, "min_codepoint_improvement", default=0.0), + max_grapheme_regression=_profile_float(args, "max_grapheme_regression", default=0.0), + max_wer_regression=_profile_float(args, "max_wer_regression", default=0.0), + max_champion_codepoint_regression=getattr(args, "max_champion_codepoint_regression", 0.0), + max_champion_grapheme_regression=getattr(args, "max_champion_grapheme_regression", 0.0), + max_champion_wer_regression=getattr(args, "max_champion_wer_regression", 0.0), + max_review_uncovered_or_weak_count=getattr(args, "max_review_uncovered_or_weak_count", 0), + max_review_extra_uncovered_or_weak_count=getattr(args, "max_review_extra_uncovered_or_weak_count", 0), + min_line_f1=_profile_float(args, "min_line_f1", default=0.0), + min_reading_order_accuracy=_profile_float(args, "min_reading_order_accuracy", default=0.0), + max_blank_line_rate=_profile_float(args, "max_blank_line_rate", default=0.0), + max_extra_line_rate=_profile_float(args, "max_extra_line_rate", default=1.0), + max_missed_line_rate=_profile_float(args, "max_missed_line_rate", default=1.0), + min_scored_pages=_profile_int(args, "min_scored_pages", default=1), + min_claim_pages=_profile_int(args, "min_claim_pages", default=30), + ) + admission_report = admission_tool.admit_candidate(admission_args) + out.mkdir(parents=True, exist_ok=True) + report = { + "created_at_utc": datetime.now(UTC).isoformat(), + "tool": "tools/score_limbu_book_ocr_candidate.py", + "machine": platform.node(), + "score_profile": args.score_profile, + "book_output": str(book_output), + "book_run": _file_record(book_output / "book-run.json"), + "book_audit": _file_record(book_audit) if book_audit.is_file() else {"path": str(book_audit), "sha256": None}, + "documents_dir": str(documents_dir), + "score_dir": str(score_dir), + "page_eval_run": _file_record(score_dir / "page-eval-run.json"), + "metrics": _file_record(metrics_path), + "champion_metrics": _file_record(champion_metrics) if champion_metrics else None, + "review_coverage_report": _file_record(review_coverage_report) if review_coverage_report else None, + "admission_dir": str(admission_dir), + "admission_report": _file_record(admission_dir / admission_tool.REPORT_JSON), + "admitted_operational": admission_report["admitted_operational"], + "claim_safe": admission_report["claim_safe"], + "codepoint_cer": score_result["metrics"].get("text_cer_codepoint_micro"), + "line_f1": score_result["metrics"].get("line_detection_f1_micro"), + "reading_order_accuracy": score_result["metrics"].get("matched_line_reading_order_pair_accuracy"), + "claim_boundary": ( + "This wrapper scores a candidate against references for evaluation/admission only; " + "it does not make the reviewed text claim-safe unless the underlying eval pack and admission report do." + ), + } + report_path = out / REPORT_JSON + report["report_json"] = str(report_path) + _write_json(report_path, report) + return report + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--book-output", type=Path, required=True) + parser.add_argument("--book-audit", type=Path) + parser.add_argument("--documents-dir", type=Path) + parser.add_argument("--out", type=Path, required=True) + parser.add_argument("--score-dir", type=Path) + parser.add_argument("--admission-dir", type=Path) + parser.add_argument("--score-profile", default=PROFILE_LIMBU_DEVANAGARI_CDC_CURRENT, choices=sorted(SCORE_PROFILES)) + parser.add_argument("--eval-manifest", type=Path) + parser.add_argument("--ocr-output-kind", choices=sorted({"live_detector", "oracle_line_boxes", "sidecar_fixture", "unknown"})) + parser.add_argument("--require-output-audit", action="store_true") + parser.add_argument("--output-audit-filename", default="limbu-output-audit.json") + parser.add_argument("--output-audit-passed-field", default="passed") + parser.add_argument("--summary-file", type=Path) + parser.add_argument("--script-inventory-file", type=Path) + parser.add_argument("--spotcheck-calibration-file", type=Path) + parser.add_argument("--train-manifest", type=Path, action="append", default=[]) + parser.add_argument("--system-name") + parser.add_argument("--model-name") + parser.add_argument("--checkpoint") + parser.add_argument("--config") + parser.add_argument("--dictionary") + parser.add_argument("--language") + parser.add_argument("--script") + parser.add_argument("--domain") + parser.add_argument("--gt-status") + parser.add_argument("--eval-pack-version") + parser.add_argument("--frozen-eval-pack", action=argparse.BooleanOptionalAction, default=None) + parser.add_argument("--unseen-for-selection", action=argparse.BooleanOptionalAction, default=None) + parser.add_argument("--selected-checkpoint-on-test", action=argparse.BooleanOptionalAction, default=None) + parser.add_argument("--claim-eligible", action=argparse.BooleanOptionalAction, default=None) + parser.add_argument("--line-iou-threshold", type=float) + parser.add_argument("--review-sample-size", type=int) + parser.add_argument("--require-claim-safe", action="store_true") + parser.add_argument("--champion-metrics", type=Path) + parser.add_argument("--review-coverage-report", type=Path) + parser.add_argument("--baseline-codepoint-cer", type=float) + parser.add_argument("--baseline-grapheme-cer", type=float) + parser.add_argument("--baseline-wer", type=float) + parser.add_argument("--min-codepoint-improvement", type=float) + parser.add_argument("--max-grapheme-regression", type=float) + parser.add_argument("--max-wer-regression", type=float) + parser.add_argument("--max-champion-codepoint-regression", type=float, default=0.0) + parser.add_argument("--max-champion-grapheme-regression", type=float, default=0.0) + parser.add_argument("--max-champion-wer-regression", type=float, default=0.0) + parser.add_argument("--max-review-uncovered-or-weak-count", type=int, default=0) + parser.add_argument("--max-review-extra-uncovered-or-weak-count", type=int, default=0) + parser.add_argument("--min-line-f1", type=float) + parser.add_argument("--min-reading-order-accuracy", type=float) + parser.add_argument("--max-blank-line-rate", type=float) + parser.add_argument("--max-extra-line-rate", type=float) + parser.add_argument("--max-missed-line-rate", type=float) + parser.add_argument("--min-scored-pages", type=int) + parser.add_argument("--min-claim-pages", type=int) + parser.add_argument("--force", action="store_true") + args = parser.parse_args(argv) + report = score_and_admit(args) + print(report["report_json"]) + print(report["metrics"]["path"]) + print(report["admission_report"]["path"]) + print(f"admitted_operational={report['admitted_operational']} claim_safe={report['claim_safe']}") + return 0 if report["admitted_operational"] else 1 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ocr-tech-mps-integration/tools/score_recognizer_pack.py b/ocr-tech-mps-integration/tools/score_recognizer_pack.py new file mode 100644 index 0000000000000000000000000000000000000000..23107cc2946e0e5f8df58ea7db57ca6b1f18f48e --- /dev/null +++ b/ocr-tech-mps-integration/tools/score_recognizer_pack.py @@ -0,0 +1,341 @@ +#!/usr/bin/env python3 +"""Score a PaddleOCR text recognizer against a PaddleOCR labels.txt pack.""" + +from __future__ import annotations + +import argparse +import json +import os +import subprocess +import sys +import tarfile +import tempfile +from dataclasses import dataclass +from pathlib import Path +from typing import Any + + +TOOLS_DIR = Path(__file__).resolve().parent +if str(TOOLS_DIR) not in sys.path: + sys.path.insert(0, str(TOOLS_DIR)) + +from eval_metrics import evaluate # noqa: E402 + + +EXPORTED_MODEL_FILES = ("inference.json", "inference.pdiparams", "inference.yml") +DEFAULT_MODEL_NAME = "PP-OCRv5_mobile_rec" +DEFAULT_CACHE_ROOT = Path("/tmp/ocrtech-paddle-cache") + + +@dataclass(frozen=True) +class LabelRow: + image: str + image_path: Path + gt: str + + +@dataclass(frozen=True) +class RecognitionResult: + text: str + confidence: float | None + + +@dataclass(frozen=True) +class PredictionRow: + image: str + gt: str + pred: str + confidence: float | None + + +class TextRecognitionRunner: + def __init__(self, model_dir: Path, *, model_name: str, device: str) -> None: + try: + from paddleocr._models.text_recognition import TextRecognition + except ImportError as exc: + raise RuntimeError( + "PaddleOCR TextRecognition is unavailable. Use the documented " + "Python 3.11 PaddleOCR environment." + ) from exc + self._model = TextRecognition( + model_name=model_name, + model_dir=str(model_dir), + device=device, + ) + + def recognize(self, image_path: Path) -> RecognitionResult: + raw_result = self._model.predict(str(image_path)) + best_text = "" + best_confidence: float | None = None + for item in raw_result if isinstance(raw_result, list) else [raw_result]: + payload = _result_mapping(item) + if payload is None: + continue + text = str(payload.get("rec_text") or payload.get("text") or payload.get("transcription") or "") + score = payload.get("rec_score") or payload.get("score") or payload.get("confidence") + confidence = _float_or_none(score) + if best_confidence is None or (confidence is not None and confidence > best_confidence): + best_text = text + best_confidence = confidence + return RecognitionResult(text=best_text, confidence=best_confidence) + + +def _float_or_none(value: Any) -> float | None: + if value is None: + return None + try: + return float(value) + except (TypeError, ValueError): + return None + + +def _result_mapping(item: object) -> dict[str, object] | None: + payload: object = item + if not isinstance(payload, dict): + payload = getattr(item, "json", None) + if not isinstance(payload, dict): + return None + nested = payload.get("res") + return nested if isinstance(nested, dict) else payload + + +def _read_labels(path: Path) -> list[LabelRow]: + if not path.exists(): + raise FileNotFoundError(f"label file does not exist: {path}") + rows: list[LabelRow] = [] + seen: set[str] = set() + with path.open("r", encoding="utf-8", newline="") as handle: + for line_no, line in enumerate(handle, 1): + line = line.rstrip("\n") + if not line: + continue + if "\t" not in line: + raise ValueError(f"{path}:{line_no}: expected image path and label separated by a tab") + image, gt = line.split("\t", 1) + if not image: + raise ValueError(f"{path}:{line_no}: empty image path") + if image in seen: + raise ValueError(f"{path}:{line_no}: duplicate image path in labels: {image}") + seen.add(image) + image_path = Path(image) + if not image_path.is_absolute(): + image_path = path.parent / image_path + if not image_path.exists(): + raise FileNotFoundError(f"{path}:{line_no}: label references missing image: {image_path}") + rows.append(LabelRow(image=image, image_path=image_path, gt=gt)) + if not rows: + raise ValueError(f"label file contains no rows: {path}") + return rows + + +def _is_exported_model_dir(path: Path) -> bool: + return path.is_dir() and all((path / name).exists() for name in EXPORTED_MODEL_FILES) + + +def _is_checkpoint_archive(path: Path) -> bool: + return path.is_file() and path.name.endswith((".tgz", ".tar.gz", ".tar")) + + +def _safe_extract(tar_path: Path, dest: Path) -> None: + dest_resolved = dest.resolve() + with tarfile.open(tar_path) as archive: + for member in archive.getmembers(): + member_path = (dest / member.name).resolve() + if dest_resolved != member_path and dest_resolved not in member_path.parents: + raise ValueError(f"archive member escapes extraction directory: {member.name}") + archive.extractall(dest) + + +def _single_file(root: Path, pattern: str, *, label: str) -> Path: + matches = sorted(root.glob(pattern)) + if len(matches) != 1: + raise ValueError(f"expected exactly one {label} under {root}, found {len(matches)}") + return matches[0] + + +def _resolve_paddleocr_source(path: Path | None) -> Path: + source = path or Path(os.environ.get("PADDLEOCR_SOURCE", "")) + if not str(source): + raise ValueError("--paddleocr-source or PADDLEOCR_SOURCE is required when --model is a checkpoint tgz") + export_script = source / "tools" / "export_model.py" + if not export_script.exists(): + raise FileNotFoundError(f"PaddleOCR export script not found: {export_script}") + return source + + +def _ensure_paddle_cache_env() -> None: + env = _paddle_env(os.environ) + os.environ.update(env) + + +def _paddle_env(base: os._Environ[str] | dict[str, str]) -> dict[str, str]: + env = dict(base) + cache_root = Path(env.get("OCRTECH_PADDLE_CACHE_ROOT", str(DEFAULT_CACHE_ROOT))) + home = Path(env.get("HOME", "")) + if not _directory_is_writable(home / ".cache"): + fallback_home = cache_root / "home" + fallback_home.mkdir(parents=True, exist_ok=True) + env["HOME"] = str(fallback_home) + for key, suffix in (("XDG_CACHE_HOME", "xdg"), ("PADDLE_HOME", "paddle-home")): + if not env.get(key): + target = cache_root / suffix + target.mkdir(parents=True, exist_ok=True) + env[key] = str(target) + return env + + +def _directory_is_writable(path: Path) -> bool: + try: + path.mkdir(parents=True, exist_ok=True) + probe = path / ".ocrtech-write-probe" + with probe.open("w", encoding="utf-8") as handle: + handle.write("") + probe.unlink() + return True + except OSError: + return False + + +def _export_checkpoint_archive( + archive_path: Path, + *, + dictionary: Path, + out_dir: Path, + paddleocr_source: Path, +) -> Path: + export_dir = out_dir / "exported_model" + if _is_exported_model_dir(export_dir): + return export_dir + if export_dir.exists() and any(export_dir.iterdir()): + raise ValueError(f"export directory exists but is incomplete: {export_dir}") + export_dir.mkdir(parents=True, exist_ok=True) + with tempfile.TemporaryDirectory(prefix="ocrtech-recognizer-", dir=str(out_dir)) as tmp: + extracted = Path(tmp) / "artifact" + extracted.mkdir() + _safe_extract(archive_path, extracted) + config = _single_file(extracted, "**/paddle_recognizer.yml", label="paddle_recognizer.yml") + checkpoint = _single_file(extracted, "**/checkpoints/best_accuracy.pdparams", label="best_accuracy.pdparams") + cmd = [ + sys.executable, + "tools/export_model.py", + "-c", + str(config), + "-o", + "Global.use_gpu=False", + f"Global.character_dict_path={dictionary}", + f"Global.pretrained_model={checkpoint}", + f"Global.save_inference_dir={export_dir}", + ] + subprocess.run( + cmd, + cwd=paddleocr_source, + env=_paddle_env(os.environ), + check=True, + ) + if not _is_exported_model_dir(export_dir): + raise RuntimeError(f"export did not produce expected inference files in {export_dir}") + return export_dir + + +def _resolve_model_dir(args: argparse.Namespace) -> tuple[Path, str]: + model = args.model + if _is_exported_model_dir(model): + return model, "exported_dir" + if _is_checkpoint_archive(model): + source = _resolve_paddleocr_source(args.paddleocr_source) + return ( + _export_checkpoint_archive( + model, + dictionary=args.dictionary, + out_dir=args.out, + paddleocr_source=source, + ), + "exported_from_checkpoint_tgz", + ) + raise ValueError( + f"--model must be an exported PaddleOCR dir containing {EXPORTED_MODEL_FILES} " + f"or a checkpoint archive: {model}" + ) + + +def _build_recognizer(model_dir: Path, *, model_name: str, device: str) -> TextRecognitionRunner: + return TextRecognitionRunner(model_dir, model_name=model_name, device=device) + + +def _score_rows(rows: list[LabelRow], recognizer: Any, predictions_path: Path) -> tuple[list[PredictionRow], dict[str, Any]]: + predictions: list[PredictionRow] = [] + predictions_path.parent.mkdir(parents=True, exist_ok=True) + with predictions_path.open("w", encoding="utf-8") as handle: + for row in rows: + result = recognizer.recognize(row.image_path) + prediction = PredictionRow( + image=row.image, + gt=row.gt, + pred=result.text, + confidence=result.confidence, + ) + predictions.append(prediction) + handle.write(json.dumps(prediction.__dict__, ensure_ascii=False) + "\n") + metrics = evaluate([(row.pred, row.gt) for row in predictions]) + return predictions, metrics + + +def run(args: argparse.Namespace) -> dict[str, Any]: + _ensure_paddle_cache_env() + args.model = args.model.expanduser().resolve(strict=False) + args.labels = args.labels.expanduser().resolve(strict=False) + args.dictionary = args.dictionary.expanduser().resolve(strict=False) + args.out = args.out.expanduser().resolve(strict=False) + if args.paddleocr_source is not None: + args.paddleocr_source = args.paddleocr_source.expanduser().resolve(strict=False) + args.out.mkdir(parents=True, exist_ok=True) + if not args.dictionary.exists(): + raise FileNotFoundError(f"dictionary file does not exist: {args.dictionary}") + rows = _read_labels(args.labels) + model_dir, route = _resolve_model_dir(args) + recognizer = _build_recognizer(model_dir, model_name=args.model_name, device=args.device) + predictions_path = args.out / "predictions.jsonl" + _, metrics = _score_rows(rows, recognizer, predictions_path) + summary = { + "route": route, + "model": str(args.model), + "model_dir": str(model_dir), + "labels": str(args.labels), + "dictionary": str(args.dictionary), + "predictions": str(predictions_path), + "metrics": metrics, + } + metrics_path = args.out / "metrics.json" + metrics_path.write_text(json.dumps(summary, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + return summary + + +def parse_args(argv: list[str] | None = None) -> argparse.Namespace: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--model", type=Path, required=True, help="Checkpoint .tgz/.tar.gz or exported PaddleOCR model dir") + parser.add_argument("--labels", type=Path, required=True, help="PaddleOCR labels.txt file") + parser.add_argument("--dictionary", type=Path, required=True, help="Recognizer character dictionary used for checkpoint export") + parser.add_argument("--out", type=Path, required=True, help="Output directory for predictions.jsonl and metrics.json") + parser.add_argument("--paddleocr-source", type=Path, help="PaddleOCR source checkout; required when --model is a checkpoint archive") + parser.add_argument("--model-name", default=DEFAULT_MODEL_NAME) + parser.add_argument("--device", default="cpu") + return parser.parse_args(argv) + + +def main(argv: list[str] | None = None) -> int: + summary = run(parse_args(argv)) + metrics = summary["metrics"] + print( + "scored " + f"{metrics['n_lines']} lines " + f"codepoint_CER={metrics['cer_codepoint']:.6f} " + f"grapheme_CER={metrics['cer_grapheme']:.6f} " + f"exact_line_acc={metrics['exact_line_acc']:.6f}" + ) + print(f"wrote {summary['predictions']}") + print(f"wrote {Path(summary['predictions']).parent / 'metrics.json'}") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ocr-tech-mps-integration/tools/select_candidate_line_reviews.py b/ocr-tech-mps-integration/tools/select_candidate_line_reviews.py new file mode 100644 index 0000000000000000000000000000000000000000..d5a7461d4e2715b8f77beb3ac8c0b3af743f2744 --- /dev/null +++ b/ocr-tech-mps-integration/tools/select_candidate_line_reviews.py @@ -0,0 +1,412 @@ +#!/usr/bin/env python3 +"""Select safe candidate-only review rows for automatic application.""" + +from __future__ import annotations + +import argparse +import csv +import json +import re +from datetime import UTC, datetime +from pathlib import Path +from typing import Any + +from ocrtech.manifest import sha256_file + + +DEVANAGARI_OR_ASCII_DIGITS = re.compile(r"^[0-9०-९]+$") +DEFAULT_ACCEPTED_STATUSES = ("accept", "accepted", "approved", "corrected", "verified", "done") + + +def _read_jsonl(path: Path) -> list[dict[str, Any]]: + try: + lines = path.read_text(encoding="utf-8").splitlines() + except FileNotFoundError as exc: + raise ValueError(f"candidate review JSONL is missing: {path}") from exc + rows: list[dict[str, Any]] = [] + for line_number, line in enumerate(lines, start=1): + if not line.strip(): + continue + try: + payload = json.loads(line) + except json.JSONDecodeError as exc: + raise ValueError(f"candidate review JSONL has invalid JSON at {path}:{line_number}: {exc}") from exc + if not isinstance(payload, dict): + raise ValueError(f"candidate review JSONL row must be an object at {path}:{line_number}") + payload["_row_number"] = line_number + rows.append(payload) + return rows + + +def _maybe_json(value: Any) -> Any: + text = str(value or "").strip() + if not text: + return None + if not (text.startswith("[") or text.startswith("{")): + return value + try: + return json.loads(text) + except json.JSONDecodeError: + return value + + +def _maybe_float(value: Any) -> Any: + if value in (None, ""): + return None + if isinstance(value, int | float) and not isinstance(value, bool): + return float(value) + try: + return float(value) + except (TypeError, ValueError): + return value + + +def _review_reason_max_selected_iou(value: Any) -> float | None: + text = str(value or "") + match = re.search(r"(?:^|[;,\s])max_selected_iou=([0-9.]+)", text) + if not match: + return None + try: + return float(match.group(1)) + except ValueError: + return None + + +def _bbox_overlap_area(left: list[float], right: list[float]) -> float: + left_x1, left_y1, left_w, left_h = left + right_x1, right_y1, right_w, right_h = right + x1 = max(left_x1, right_x1) + y1 = max(left_y1, right_y1) + x2 = min(left_x1 + left_w, right_x1 + right_w) + y2 = min(left_y1 + left_h, right_y1 + right_h) + if x2 <= x1 or y2 <= y1: + return 0.0 + return (x2 - x1) * (y2 - y1) + + +def _bbox_contains(outer: list[float], inner: list[float], *, tolerance: float = 3.0) -> bool: + outer_x, outer_y, outer_w, outer_h = outer + inner_x, inner_y, inner_w, inner_h = inner + return ( + inner_x >= outer_x - tolerance + and inner_y >= outer_y - tolerance + and inner_x + inner_w <= outer_x + outer_w + tolerance + and inner_y + inner_h <= outer_y + outer_h + tolerance + ) + + +def _read_document(path: Path) -> dict[str, Any]: + try: + payload = json.loads(path.read_text(encoding="utf-8")) + except FileNotFoundError as exc: + raise ValueError(f"book document is missing: {path}") from exc + except json.JSONDecodeError as exc: + raise ValueError(f"book document has invalid JSON at {path}: {exc}") from exc + if not isinstance(payload, dict): + raise ValueError(f"book document must contain an object: {path}") + return payload + + +def _derive_image_size_from_document(document: dict[str, Any], *, document_path: Path) -> list[float] | None: + pages = document.get("pages") + if not isinstance(pages, list) or not pages: + return None + page = pages[0] + if not isinstance(page, dict): + raise ValueError(f"book document page entry must be an object: {document_path}") + width = _maybe_float(page.get("width")) + height = _maybe_float(page.get("height")) + if isinstance(width, float) and isinstance(height, float) and width > 0 and height > 0: + return [width, height] + return None + + +def _derive_duplicate_marker_from_document(row: dict[str, Any], document: dict[str, Any]) -> None: + if row.get("best_selected_text"): + return + text = str(row.get("candidate_text") or "").strip() + bbox = _bbox(row) + if not text or bbox is None or not DEVANAGARI_OR_ASCII_DIGITS.fullmatch(text): + return + pages = document.get("pages") + if not isinstance(pages, list): + return + page_index = int(_maybe_float(row.get("page_index")) or 0) + for page in pages: + if not isinstance(page, dict): + continue + if int(_maybe_float(page.get("page_index")) or 0) != page_index: + continue + lines = page.get("text_lines") + if not isinstance(lines, list): + continue + for line in lines: + if not isinstance(line, dict): + continue + line_text = str(line.get("text") or "").strip() + line_bbox_value = line.get("bbox") + line_bbox = line_bbox_value if isinstance(line_bbox_value, list | tuple) else None + if line_bbox is None or len(line_bbox) != 4: + continue + try: + line_box = [float(item) for item in line_bbox] + except (TypeError, ValueError): + continue + if line_text.startswith(text) and (_bbox_contains(line_box, bbox) or _bbox_overlap_area(line_box, bbox) > 0): + row["best_selected_text"] = line_text + row["best_selected_bbox"] = line_box + row["best_selected_line_id"] = str(line.get("line_id") or "") + return + + +def _accepted_existing_line_texts(rows: list[dict[str, str]]) -> dict[tuple[str, str], str]: + accepted_statuses = {status.strip().lower() for status in DEFAULT_ACCEPTED_STATUSES} + accepted: dict[tuple[str, str], str] = {} + for row in rows: + if str(row.get("review_item_type") or "").strip() != "existing_book_line": + continue + status = str(row.get("review_status") or "").strip().lower() + if status not in accepted_statuses: + continue + page_id = str(row.get("book_page_id") or "").strip() + line_id = str(row.get("book_line_id") or "").strip() + if not page_id or not line_id: + continue + accepted[(page_id, line_id)] = str(row.get("corrected_text") or row.get("text") or "").replace(r"\n", "\n").strip() + return accepted + + +def _normalize_tsv_row( + row: dict[str, str], + *, + row_number: int, + source_path: Path, + accepted_existing_texts: dict[tuple[str, str], str], +) -> dict[str, Any] | None: + item_type = str(row.get("review_item_type") or "").strip() + if item_type and item_type != "candidate_missing_line": + return None + payload: dict[str, Any] = {key: value.replace(r"\n", "\n") for key, value in row.items() if key is not None} + payload["_row_number"] = row_number + payload["row_id"] = str(payload.get("row_id") or payload.get("candidate_row_id") or payload.get("packet_row_id") or "").strip() + payload["sample_id"] = str(payload.get("sample_id") or payload.get("candidate_sample_id") or payload.get("book_page_id") or "").strip() + if not payload.get("candidate_structural_role") and str(payload.get("review_category") or "") == "structural_page_marker": + payload["candidate_structural_role"] = "page_marker" + if not payload.get("candidate_confidence") and payload.get("confidence"): + payload["candidate_confidence"] = payload.get("confidence") + if not payload.get("candidate_bbox") and payload.get("bbox"): + payload["candidate_bbox"] = payload.get("bbox") + if not payload.get("candidate_text") and "text" in payload: + payload["candidate_text"] = payload.get("text") + for key in ("candidate_bbox", "image_size", "best_selected_bbox"): + if key in payload: + payload[key] = _maybe_json(payload.get(key)) + for key in ("candidate_confidence", "max_selected_iou"): + if key in payload: + payload[key] = _maybe_float(payload.get(key)) + if payload.get("max_selected_iou") in (None, ""): + max_iou = _review_reason_max_selected_iou(payload.get("review_reasons")) + if max_iou is not None: + payload["max_selected_iou"] = max_iou + document_path_text = str(payload.get("book_document") or "").strip() + if document_path_text: + document_path = Path(document_path_text) + document = _read_document(document_path) + if not payload.get("image_size"): + payload["image_size"] = _derive_image_size_from_document(document, document_path=document_path) + _derive_duplicate_marker_from_document(payload, document) + duplicate_line_id = str(payload.get("best_selected_line_id") or "").strip() + if duplicate_line_id: + reviewed_text = accepted_existing_texts.get((str(payload.get("sample_id") or ""), duplicate_line_id)) + if reviewed_text is not None: + payload["best_selected_text_after_review"] = reviewed_text + if not payload.get("row_id"): + raise ValueError(f"candidate review TSV row {row_number} missing row_id/candidate_row_id/packet_row_id: {source_path}") + if not payload.get("sample_id"): + raise ValueError(f"candidate review TSV row {row_number} missing sample_id/book_page_id: {source_path}") + return payload + + +def _read_tsv(path: Path) -> list[dict[str, Any]]: + try: + handle = path.open("r", encoding="utf-8", newline="") + except FileNotFoundError as exc: + raise ValueError(f"candidate review TSV is missing: {path}") from exc + rows: list[dict[str, Any]] = [] + with handle: + reader = csv.DictReader(handle, delimiter="\t") + if reader.fieldnames is None: + raise ValueError(f"candidate review TSV has no header: {path}") + raw_rows = [dict(row) for row in reader] + accepted_existing_texts = _accepted_existing_line_texts(raw_rows) + for row_number, row in enumerate(raw_rows, start=2): + normalized = _normalize_tsv_row( + row, + row_number=row_number, + source_path=path, + accepted_existing_texts=accepted_existing_texts, + ) + if normalized is not None: + rows.append(normalized) + return rows + + +def _read_review_rows(path: Path) -> list[dict[str, Any]]: + suffix = path.suffix.lower() + if suffix == ".tsv": + return _read_tsv(path) + if suffix in {".jsonl", ".ndjson", ""}: + return _read_jsonl(path) + raise ValueError(f"unsupported candidate review file extension {path.suffix!r}; expected .jsonl or .tsv") + + +def _write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None: + path.write_text("".join(json.dumps(row, ensure_ascii=False, sort_keys=True) + "\n" for row in rows), encoding="utf-8") + + +def _float(value: Any, default: float = 0.0) -> float: + try: + return float(value) + except (TypeError, ValueError): + return default + + +def _bbox(row: dict[str, Any]) -> list[float] | None: + value = row.get("candidate_bbox") + if not isinstance(value, list | tuple) or len(value) != 4: + return None + try: + bbox = [float(item) for item in value] + except (TypeError, ValueError): + return None + if bbox[2] <= 0 or bbox[3] <= 0: + return None + return bbox + + +def _image_size(row: dict[str, Any]) -> tuple[float, float] | None: + value = row.get("image_size") + if not isinstance(value, list | tuple) or len(value) != 2: + return None + try: + width = float(value[0]) + height = float(value[1]) + except (TypeError, ValueError): + return None + if width <= 0 or height <= 0: + return None + return width, height + + +def _select_page_marker(row: dict[str, Any], args: argparse.Namespace) -> tuple[bool, list[str]]: + reasons: list[str] = [] + text = str(row.get("candidate_text") or "").strip() + bbox = _bbox(row) + image_size = _image_size(row) + confidence = _float(row.get("candidate_confidence"), -1.0) + max_iou = _float(row.get("max_selected_iou"), 1.0) + role = str(row.get("candidate_structural_role") or "") + best_selected_text = str(row.get("best_selected_text") or "").strip() + best_selected_text_after_review = row.get("best_selected_text_after_review") + duplicate_check_text = ( + str(best_selected_text_after_review).strip() + if best_selected_text_after_review is not None + else best_selected_text + ) + if role != "page_marker": + reasons.append("candidate_structural_role_not_page_marker") + if not DEVANAGARI_OR_ASCII_DIGITS.fullmatch(text): + reasons.append("candidate_text_not_digit_only") + if text and duplicate_check_text.startswith(text): + reasons.append("candidate_marker_already_in_best_selected_text") + if confidence < float(args.min_confidence): + reasons.append("candidate_confidence_below_threshold") + if max_iou > float(args.max_selected_iou): + reasons.append("max_selected_iou_above_threshold") + if bbox is None: + reasons.append("candidate_bbox_missing_or_invalid") + if image_size is None: + reasons.append("image_size_missing_or_invalid") + if bbox is not None and image_size is not None: + width, height = image_size + x, y, w, h = bbox + if y / height < float(args.min_y_ratio): + reasons.append("candidate_not_in_bottom_margin") + if w / width > float(args.max_width_ratio): + reasons.append("candidate_too_wide") + if h / height > float(args.max_height_ratio): + reasons.append("candidate_too_tall") + return not reasons, reasons + + +def select_reviews(args: argparse.Namespace) -> dict[str, Any]: + input_path = Path(args.input) + out = Path(args.out) + out.mkdir(parents=True, exist_ok=True) + rows = _read_review_rows(input_path) + selected_rows: list[dict[str, Any]] = [] + rejected_rows: list[dict[str, Any]] = [] + for row in rows: + selected, reasons = _select_page_marker(row, args) + output_row = {key: value for key, value in row.items() if not key.startswith("_")} + output_row["selection_policy"] = "page_marker_v2" + output_row["selection_reasons"] = reasons + if selected: + output_row["review_status"] = "accepted" + output_row["reviewer"] = str(args.reviewer) + output_row["notes"] = (str(output_row.get("notes") or "") + " auto-selected page_marker_v2").strip() + output_row["corrected_text"] = str(output_row.get("candidate_text") or "").strip() + selected_rows.append(output_row) + else: + rejected_rows.append(output_row) + selected_path = out / "selected-candidate-line-review.jsonl" + rejected_path = out / "rejected-candidate-line-review.jsonl" + report_path = out / "candidate-line-review-selection.json" + _write_jsonl(selected_path, selected_rows) + _write_jsonl(rejected_path, rejected_rows) + report = { + "tool": "tools/select_candidate_line_reviews.py", + "created_at_utc": datetime.now(UTC).isoformat(), + "input": str(input_path), + "input_sha256": sha256_file(input_path), + "output_dir": str(out), + "policy": "page_marker_v2", + "policy_config": { + "min_confidence": float(args.min_confidence), + "max_selected_iou": float(args.max_selected_iou), + "min_y_ratio": float(args.min_y_ratio), + "max_width_ratio": float(args.max_width_ratio), + "max_height_ratio": float(args.max_height_ratio), + }, + "row_count": len(rows), + "selected_count": len(selected_rows), + "rejected_count": len(rejected_rows), + "selected_jsonl": str(selected_path), + "selected_jsonl_sha256": sha256_file(selected_path), + "rejected_jsonl": str(rejected_path), + "rejected_jsonl_sha256": sha256_file(rejected_path), + "claim_boundary": "deterministic candidate-line review preselection; not human review and not claim evidence", + } + report_path.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + return report + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--input", required=True, type=Path) + parser.add_argument("--out", required=True, type=Path) + parser.add_argument("--reviewer", default="auto-page-marker-v2") + parser.add_argument("--min-confidence", type=float, default=0.80) + parser.add_argument("--max-selected-iou", type=float, default=0.10) + parser.add_argument("--min-y-ratio", type=float, default=0.80) + parser.add_argument("--max-width-ratio", type=float, default=0.03) + parser.add_argument("--max-height-ratio", type=float, default=0.03) + args = parser.parse_args() + report = select_reviews(args) + print(str(Path(report["output_dir"]) / "candidate-line-review-selection.json")) + print(report["selected_jsonl"]) + print(f"selected={report['selected_count']} rejected={report['rejected_count']}") + + +if __name__ == "__main__": + main() diff --git a/ocr-tech-mps-integration/tools/select_candidate_line_reviews_by_geometry_text_features.py b/ocr-tech-mps-integration/tools/select_candidate_line_reviews_by_geometry_text_features.py new file mode 100644 index 0000000000000000000000000000000000000000..f6d74038caa2f1b49923dc2b2837b537f7a391f8 --- /dev/null +++ b/ocr-tech-mps-integration/tools/select_candidate_line_reviews_by_geometry_text_features.py @@ -0,0 +1,240 @@ +#!/usr/bin/env python3 +"""Select candidate-line review rows using non-oracle geometry/text features.""" + +from __future__ import annotations + +import argparse +import json +from datetime import UTC, datetime +from pathlib import Path +from typing import Any + +from ocrtech.manifest import sha256_file + + +REPORT_JSON = "candidate-line-geometry-text-feature-selection.json" +SELECTED_JSONL = "selected-candidate-line-reviews.jsonl" +REJECTED_JSONL = "rejected-candidate-line-reviews.jsonl" + + +def _read_jsonl(path: Path) -> list[dict[str, Any]]: + try: + lines = path.read_text(encoding="utf-8").splitlines() + except FileNotFoundError as exc: + raise ValueError(f"candidate review JSONL is missing: {path}") from exc + rows: list[dict[str, Any]] = [] + for line_number, line in enumerate(lines, start=1): + if not line.strip(): + continue + try: + payload = json.loads(line) + except json.JSONDecodeError as exc: + raise ValueError(f"candidate review JSONL has invalid JSON at {path}:{line_number}: {exc}") from exc + if not isinstance(payload, dict): + raise ValueError(f"candidate review JSONL row must be an object at {path}:{line_number}") + rows.append(payload) + return rows + + +def _write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None: + path.write_text("".join(json.dumps(row, ensure_ascii=False, sort_keys=True) + "\n" for row in rows), encoding="utf-8") + + +def _float(value: Any, default: float = 0.0) -> float: + try: + return float(value) + except (TypeError, ValueError): + return default + + +def _bbox(row: dict[str, Any]) -> list[float]: + value = row.get("candidate_bbox") or [0, 0, 0, 0] + if isinstance(value, str): + try: + value = json.loads(value) + except json.JSONDecodeError: + value = [0, 0, 0, 0] + if not isinstance(value, list) or len(value) != 4: + return [0.0, 0.0, 0.0, 0.0] + return [_float(item) for item in value] + + +def _image_size(row: dict[str, Any]) -> tuple[float, float]: + value = row.get("image_size") + if not isinstance(value, list) or len(value) < 2: + return (0.0, 0.0) + return (_float(value[0]), _float(value[1])) + + +def _band(value: float, size: float) -> str: + if size <= 0: + return "unknown" + ratio = value / size + if ratio < 1 / 3: + return "top_or_left" + if ratio < 2 / 3: + return "middle" + return "bottom_or_right" + + +def _parse_bands(raw: str, *, default: set[str]) -> set[str]: + value = str(raw or "").strip() + if not value: + return set(default) + bands = {item.strip() for item in value.split(",") if item.strip()} + valid = {"top_or_left", "middle", "bottom_or_right", "unknown"} + invalid = bands - valid + if invalid: + raise ValueError(f"invalid band values: {sorted(invalid)}") + return bands + + +def _row_id(row: dict[str, Any]) -> str: + row_id = str(row.get("row_id") or "").strip() + if not row_id: + raise ValueError("candidate review row is missing row_id") + return row_id + + +def _candidate_text(row: dict[str, Any]) -> str: + return str(row.get("candidate_text") or "").strip() + + +def _feature_values(row: dict[str, Any]) -> dict[str, Any]: + x, y, width, height = _bbox(row) + image_width, image_height = _image_size(row) + return { + "candidate_text_length": len(_candidate_text(row)), + "candidate_bbox_width": width, + "candidate_bbox_height": height, + "x_band": _band(x + width / 2, image_width), + "y_band": _band(y + height / 2, image_height), + "max_selected_iou": _float(row.get("max_selected_iou")), + } + + +def _select_row(row: dict[str, Any], args: argparse.Namespace) -> tuple[bool, list[str], dict[str, Any]]: + features = _feature_values(row) + reasons: list[str] = [] + role = str(row.get("candidate_structural_role") or "text").strip() or "text" + if role != "text": + reasons.append("not_text_candidate") + if features["candidate_text_length"] < int(args.min_candidate_text_length): + reasons.append("candidate_text_length_below_threshold") + if features["candidate_bbox_width"] < float(args.min_bbox_width): + reasons.append("candidate_bbox_width_below_threshold") + if features["candidate_bbox_height"] < float(args.min_bbox_height): + reasons.append("candidate_bbox_height_below_threshold") + if features["candidate_bbox_height"] > float(args.max_bbox_height): + reasons.append("candidate_bbox_height_above_threshold") + if features["max_selected_iou"] > float(args.max_selected_iou): + reasons.append("selected_line_iou_above_threshold") + if features["x_band"] not in args.allowed_x_bands: + reasons.append("x_band_not_allowed") + if features["y_band"] not in args.allowed_y_bands: + reasons.append("y_band_not_allowed") + return (not reasons, reasons, features) + + +def select_reviews(args: argparse.Namespace) -> dict[str, Any]: + review_path = Path(args.prioritized_review_jsonl) + out = Path(args.out) + out.mkdir(parents=True, exist_ok=True) + args.allowed_x_bands = _parse_bands(args.allowed_x_bands, default={"top_or_left", "middle", "bottom_or_right", "unknown"}) + args.allowed_y_bands = _parse_bands(args.allowed_y_bands, default={"top_or_left", "middle", "bottom_or_right", "unknown"}) + rows = _read_jsonl(review_path) + selected: list[dict[str, Any]] = [] + rejected: list[dict[str, Any]] = [] + reason_counts: dict[str, int] = {} + for row in rows: + row_id = _row_id(row) + accepted, reasons, features = _select_row(row, args) + payload = dict(row) + payload["selection_policy"] = "candidate_geometry_text_features_v1" + payload["selection_tool"] = "tools/select_candidate_line_reviews_by_geometry_text_features.py" + payload["selection_features"] = features + payload["claim_boundary"] = ( + "non-oracle geometry/text feature selection; candidate text remains machine OCR and requires " + "page-level effect audit before any operational use" + ) + if accepted: + payload["review_status"] = "accepted" + payload["corrected_text"] = _candidate_text(row) + payload["reviewer"] = "machine_geometry_text_feature_selector" + payload["notes"] = ( + f"selected by geometry/text features; text_length={features['candidate_text_length']}; " + f"bbox_width={features['candidate_bbox_width']:.3f}; " + f"x_band={features['x_band']}; y_band={features['y_band']}; page-level audit required" + ) + selected.append(payload) + continue + payload["review_status"] = "rejected" + payload["selection_rejected_reasons"] = reasons + payload["notes"] = "rejected by geometry/text feature selector" + for reason in reasons: + reason_counts[reason] = reason_counts.get(reason, 0) + 1 + rejected.append(payload) + selected_path = out / SELECTED_JSONL + rejected_path = out / REJECTED_JSONL + _write_jsonl(selected_path, selected) + _write_jsonl(rejected_path, rejected) + report_path = out / REPORT_JSON + report = { + "tool": "tools/select_candidate_line_reviews_by_geometry_text_features.py", + "created_at_utc": datetime.now(UTC).isoformat(), + "prioritized_review_jsonl": str(review_path), + "prioritized_review_jsonl_sha256": sha256_file(review_path), + "output_dir": str(out), + "row_count": len(rows), + "selected_count": len(selected), + "rejected_count": len(rejected), + "rejection_reason_counts": reason_counts, + "min_candidate_text_length": int(args.min_candidate_text_length), + "min_bbox_width": float(args.min_bbox_width), + "min_bbox_height": float(args.min_bbox_height), + "max_bbox_height": float(args.max_bbox_height), + "max_selected_iou": float(args.max_selected_iou), + "allowed_x_bands": sorted(args.allowed_x_bands), + "allowed_y_bands": sorted(args.allowed_y_bands), + "selected_jsonl": str(selected_path), + "selected_jsonl_sha256": sha256_file(selected_path), + "rejected_jsonl": str(rejected_path), + "rejected_jsonl_sha256": sha256_file(rejected_path), + "claim_boundary": ( + "non-oracle geometry/text feature selection; selected rows are not OCR-quality claims " + "and must be page-scored/effect-audited" + ), + } + report["report_json"] = str(report_path) + report_path.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + return report + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--prioritized-review-jsonl", required=True, type=Path) + parser.add_argument("--out", required=True, type=Path) + parser.add_argument("--min-candidate-text-length", type=int, default=30) + parser.add_argument("--min-bbox-width", type=float, default=80.0) + parser.add_argument("--min-bbox-height", type=float, default=1.0) + parser.add_argument("--max-bbox-height", type=float, default=80.0) + parser.add_argument("--max-selected-iou", type=float, default=0.1) + parser.add_argument( + "--allowed-x-bands", + default="top_or_left,middle,bottom_or_right,unknown", + help="Comma-separated allowed candidate center x bands.", + ) + parser.add_argument( + "--allowed-y-bands", + default="middle,bottom_or_right", + help="Comma-separated allowed candidate center y bands.", + ) + args = parser.parse_args() + report = select_reviews(args) + print(Path(report["report_json"])) + print(report["selected_jsonl"]) + print(f"selected={report['selected_count']} rejected={report['rejected_count']}") + + +if __name__ == "__main__": + main() diff --git a/ocr-tech-mps-integration/tools/select_candidate_line_reviews_by_oracle_subset.py b/ocr-tech-mps-integration/tools/select_candidate_line_reviews_by_oracle_subset.py new file mode 100644 index 0000000000000000000000000000000000000000..d8ca635071ba05d1c88d3c3faec85d789447c9af --- /dev/null +++ b/ocr-tech-mps-integration/tools/select_candidate_line_reviews_by_oracle_subset.py @@ -0,0 +1,158 @@ +#!/usr/bin/env python3 +"""Build a diagnostic oracle/reference subset for candidate-line review rows.""" + +from __future__ import annotations + +import argparse +import json +from datetime import UTC, datetime +from pathlib import Path +from typing import Any + +from ocrtech.manifest import sha256_file + + +SELECTED_JSONL = "selected-candidate-line-review.jsonl" +REJECTED_JSONL = "rejected-candidate-line-review.jsonl" +REPORT_JSON = "candidate-line-oracle-subset-selection.json" + + +def _read_jsonl(path: Path, *, label: str) -> list[dict[str, Any]]: + try: + lines = path.read_text(encoding="utf-8").splitlines() + except FileNotFoundError as exc: + raise ValueError(f"{label} JSONL is missing: {path}") from exc + rows: list[dict[str, Any]] = [] + for line_number, line in enumerate(lines, start=1): + if not line.strip(): + continue + try: + payload = json.loads(line) + except json.JSONDecodeError as exc: + raise ValueError(f"{label} JSONL has invalid JSON at {path}:{line_number}: {exc}") from exc + if not isinstance(payload, dict): + raise ValueError(f"{label} JSONL row must be an object at {path}:{line_number}") + payload["_row_number"] = line_number + rows.append(payload) + return rows + + +def _write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None: + path.write_text("".join(json.dumps(row, ensure_ascii=False, sort_keys=True) + "\n" for row in rows), encoding="utf-8") + + +def _row_id(row: dict[str, Any], *, label: str) -> str: + row_id = str(row.get("row_id") or "").strip() + if not row_id: + raise ValueError(f"{label} row {row.get('_row_number')} missing row_id") + return row_id + + +def _index_by_row_id(rows: list[dict[str, Any]], *, label: str) -> dict[str, dict[str, Any]]: + indexed: dict[str, dict[str, Any]] = {} + for row in rows: + row_id = _row_id(row, label=label) + if row_id in indexed: + raise ValueError(f"duplicate {label} row_id: {row_id}") + indexed[row_id] = row + return indexed + + +def _copy_public_row(row: dict[str, Any]) -> dict[str, Any]: + return {key: value for key, value in row.items() if not key.startswith("_")} + + +def select_oracle_subset(args: argparse.Namespace) -> dict[str, Any]: + subset_path = Path(args.subset_jsonl) + oracle_path = Path(args.oracle_selected_jsonl) + out = Path(args.out) + out.mkdir(parents=True, exist_ok=True) + + subset_rows = _read_jsonl(subset_path, label="subset") + oracle_rows = _read_jsonl(oracle_path, label="oracle-selected") + oracle_by_row_id = _index_by_row_id(oracle_rows, label="oracle-selected") + + selected_rows: list[dict[str, Any]] = [] + rejected_rows: list[dict[str, Any]] = [] + for subset_row in subset_rows: + row_id = _row_id(subset_row, label="subset") + oracle_row = oracle_by_row_id.get(row_id) + output_row = _copy_public_row(subset_row) + output_row["selection_tool"] = "tools/select_candidate_line_reviews_by_oracle_subset.py" + output_row["selection_policy"] = str(args.policy) + output_row["claim_boundary"] = ( + "diagnostic-only oracle/reference subset; not deployable OCR policy and not human review evidence" + ) + if oracle_row is None: + output_row["review_status"] = "rejected" + output_row["selection_reasons"] = ["row_id_not_present_in_oracle_selected_jsonl"] + rejected_rows.append(output_row) + continue + oracle_reference_text = str(oracle_row.get("oracle_reference_text") or "") + if not oracle_reference_text.strip(): + output_row["review_status"] = "rejected" + output_row["selection_reasons"] = ["oracle_selected_row_missing_reference_text"] + rejected_rows.append(output_row) + continue + output_row["review_status"] = "accepted" + output_row["reviewer"] = str(args.reviewer) + output_row["corrected_text"] = oracle_reference_text + output_row["oracle_reference_line_id"] = oracle_row.get("oracle_reference_line_id") or "" + output_row["oracle_reference_bbox"] = oracle_row.get("oracle_reference_bbox") + output_row["oracle_reference_text"] = oracle_reference_text + output_row["oracle_best_unmatched_reference_iou"] = oracle_row.get("oracle_best_unmatched_reference_iou") + output_row["selection_reasons"] = [] + notes = str(output_row.get("notes") or "").strip() + marker = "oracle_subset_reference_ceiling_v1" + output_row["notes"] = f"{notes}; {marker}" if notes else marker + selected_rows.append(output_row) + + selected_path = out / SELECTED_JSONL + rejected_path = out / REJECTED_JSONL + report_path = out / REPORT_JSON + _write_jsonl(selected_path, selected_rows) + _write_jsonl(rejected_path, rejected_rows) + report = { + "tool": "tools/select_candidate_line_reviews_by_oracle_subset.py", + "created_at_utc": datetime.now(UTC).isoformat(), + "subset_jsonl": str(subset_path), + "subset_jsonl_sha256": sha256_file(subset_path), + "oracle_selected_jsonl": str(oracle_path), + "oracle_selected_jsonl_sha256": sha256_file(oracle_path), + "output_dir": str(out), + "policy": str(args.policy), + "reviewer": str(args.reviewer), + "subset_row_count": len(subset_rows), + "oracle_selected_row_count": len(oracle_rows), + "selected_count": len(selected_rows), + "rejected_count": len(rejected_rows), + "selected_jsonl": str(selected_path), + "selected_jsonl_sha256": sha256_file(selected_path), + "rejected_jsonl": str(rejected_path), + "rejected_jsonl_sha256": sha256_file(rejected_path), + "claim_boundary": ( + "diagnostic-only oracle/reference subset; contains reference text and must not be treated as " + "operational review evidence" + ), + } + report_path.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + return report + + +def main() -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--subset-jsonl", type=Path, required=True) + parser.add_argument("--oracle-selected-jsonl", type=Path, required=True) + parser.add_argument("--out", type=Path, required=True) + parser.add_argument("--reviewer", default="oracle-reference-overlap-v1") + parser.add_argument("--policy", default="oracle_reference_text_for_candidate_subset_ceiling_v1") + args = parser.parse_args() + report = select_oracle_subset(args) + print(str(Path(report["output_dir"]) / REPORT_JSON)) + print(report["selected_jsonl"]) + print(f"selected={report['selected_count']} rejected={report['rejected_count']}") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ocr-tech-mps-integration/tools/select_candidate_line_reviews_by_recognizer_probe.py b/ocr-tech-mps-integration/tools/select_candidate_line_reviews_by_recognizer_probe.py new file mode 100644 index 0000000000000000000000000000000000000000..2b90fa4bafd1c586dea2798c947178459ee43629 --- /dev/null +++ b/ocr-tech-mps-integration/tools/select_candidate_line_reviews_by_recognizer_probe.py @@ -0,0 +1,150 @@ +#!/usr/bin/env python3 +"""Select candidate-line review rows from non-oracle recognizer crop probes.""" + +from __future__ import annotations + +import argparse +import json +from datetime import UTC, datetime +from pathlib import Path +from typing import Any + +from ocrtech.manifest import sha256_file + + +def _read_jsonl(path: Path, *, label: str) -> list[dict[str, Any]]: + try: + lines = path.read_text(encoding="utf-8").splitlines() + except FileNotFoundError as exc: + raise ValueError(f"{label} is missing: {path}") from exc + rows: list[dict[str, Any]] = [] + for line_number, line in enumerate(lines, start=1): + if not line.strip(): + continue + try: + payload = json.loads(line) + except json.JSONDecodeError as exc: + raise ValueError(f"{label} has invalid JSON at {path}:{line_number}: {exc}") from exc + if not isinstance(payload, dict): + raise ValueError(f"{label} row must be an object at {path}:{line_number}") + rows.append(payload) + return rows + + +def _write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None: + path.write_text("".join(json.dumps(row, ensure_ascii=False, sort_keys=True) + "\n" for row in rows), encoding="utf-8") + + +def _float(value: Any, default: float = 0.0) -> float: + try: + return float(value) + except (TypeError, ValueError): + return default + + +def _row_key(row: dict[str, Any]) -> str: + row_id = str(row.get("row_id") or "").strip() + if not row_id: + raise ValueError("row is missing row_id") + return row_id + + +def select_reviews(args: argparse.Namespace) -> dict[str, Any]: + priority_path = Path(args.prioritized_review_jsonl) + comparison_path = Path(args.comparison_jsonl) + out = Path(args.out) + out.mkdir(parents=True, exist_ok=True) + priority_rows = _read_jsonl(priority_path, label="prioritized review JSONL") + comparison_rows = _read_jsonl(comparison_path, label="recognizer probe comparison JSONL") + priority_by_id = {_row_key(row): row for row in priority_rows} + selected: list[dict[str, Any]] = [] + rejected: list[dict[str, Any]] = [] + for comparison in comparison_rows: + row_id = _row_key(comparison) + source = priority_by_id.get(row_id) + if source is None: + raise ValueError(f"comparison row_id not found in prioritized queue: {row_id}") + refined_text = str(comparison.get("refined_prediction_text") or "").strip() + refined_confidence = _float(comparison.get("refined_prediction_confidence")) + delta = _float(comparison.get("refined_minus_original_confidence")) + source_role = str(source.get("candidate_structural_role") or "text") + reasons: list[str] = [] + if source_role != "text": + reasons.append("not_text_candidate") + if not refined_text: + reasons.append("empty_refined_prediction") + if refined_confidence < float(args.min_refined_confidence): + reasons.append("refined_confidence_below_threshold") + if delta < float(args.min_confidence_delta): + reasons.append("confidence_delta_below_threshold") + if bool(comparison.get("automatic_application_safe")): + reasons.append("comparison_unexpectedly_claims_automatic_safe") + payload = dict(source) + payload["selection_policy"] = "refined_crop_recognizer_probe_v1" + payload["selection_tool"] = "tools/select_candidate_line_reviews_by_recognizer_probe.py" + payload["refined_prediction_text"] = refined_text + payload["refined_prediction_confidence"] = refined_confidence + payload["refined_minus_original_confidence"] = delta + payload["original_prediction_text"] = comparison.get("original_prediction_text") or "" + payload["original_prediction_confidence"] = comparison.get("original_prediction_confidence") + payload["recognizer_probe_strategy"] = comparison.get("strategy") or "" + payload["recognizer_probe_review_required_reason"] = comparison.get("review_required_reason") or "" + payload["claim_boundary"] = "non-oracle machine recognizer probe selection; selected rows still require page-level score/admission" + if reasons: + payload["review_status"] = "rejected" + payload["selection_rejected_reasons"] = reasons + rejected.append(payload) + continue + payload["review_status"] = "accepted" + payload["corrected_text"] = refined_text + payload["reviewer"] = "machine_refined_crop_recognizer_probe" + payload["notes"] = ( + f"selected by refined crop recognizer probe; confidence={refined_confidence:.6f}; " + f"delta={delta:.6f}; page-level admission required" + ) + payload["candidate_confidence"] = refined_confidence + selected.append(payload) + selected_path = out / "selected-candidate-line-reviews.jsonl" + rejected_path = out / "rejected-candidate-line-reviews.jsonl" + _write_jsonl(selected_path, selected) + _write_jsonl(rejected_path, rejected) + report = { + "tool": "tools/select_candidate_line_reviews_by_recognizer_probe.py", + "created_at_utc": datetime.now(UTC).isoformat(), + "prioritized_review_jsonl": str(priority_path), + "prioritized_review_jsonl_sha256": sha256_file(priority_path), + "comparison_jsonl": str(comparison_path), + "comparison_jsonl_sha256": sha256_file(comparison_path), + "output_dir": str(out), + "row_count": len(comparison_rows), + "selected_count": len(selected), + "rejected_count": len(rejected), + "min_refined_confidence": float(args.min_refined_confidence), + "min_confidence_delta": float(args.min_confidence_delta), + "selected_jsonl": str(selected_path), + "selected_jsonl_sha256": sha256_file(selected_path), + "rejected_jsonl": str(rejected_path), + "rejected_jsonl_sha256": sha256_file(rejected_path), + "claim_boundary": "non-oracle machine recognizer probe selection; does not certify OCR quality or bypass page-level admission", + } + report_path = out / "candidate-line-recognizer-probe-selection.json" + report_path.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + return report + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--prioritized-review-jsonl", required=True, type=Path) + parser.add_argument("--comparison-jsonl", required=True, type=Path) + parser.add_argument("--out", required=True, type=Path) + parser.add_argument("--min-refined-confidence", type=float, default=0.45) + parser.add_argument("--min-confidence-delta", type=float, default=0.05) + args = parser.parse_args() + report = select_reviews(args) + print(Path(report["output_dir"]) / "candidate-line-recognizer-probe-selection.json") + print(report["selected_jsonl"]) + print(f"selected={report['selected_count']} rejected={report['rejected_count']}") + + +if __name__ == "__main__": + main() diff --git a/ocr-tech-mps-integration/tools/select_candidate_line_reviews_by_reference_overlap.py b/ocr-tech-mps-integration/tools/select_candidate_line_reviews_by_reference_overlap.py new file mode 100644 index 0000000000000000000000000000000000000000..7b029a97fc1093a9881248bf00a9859d1abe9a80 --- /dev/null +++ b/ocr-tech-mps-integration/tools/select_candidate_line_reviews_by_reference_overlap.py @@ -0,0 +1,198 @@ +#!/usr/bin/env python3 +"""Oracle-select candidate-only review rows by overlap with unmatched reference lines.""" + +from __future__ import annotations + +import argparse +import csv +import json +from datetime import UTC, datetime +from pathlib import Path +from typing import Any + +from ocrtech.manifest import sha256_file +from ocrtech.metrics import bbox_iou +from ocrtech.schemas import BBox + + +def _read_jsonl(path: Path) -> list[dict[str, Any]]: + try: + lines = path.read_text(encoding="utf-8").splitlines() + except FileNotFoundError as exc: + raise ValueError(f"candidate review JSONL is missing: {path}") from exc + rows: list[dict[str, Any]] = [] + for line_number, line in enumerate(lines, start=1): + if not line.strip(): + continue + try: + payload = json.loads(line) + except json.JSONDecodeError as exc: + raise ValueError(f"candidate review JSONL has invalid JSON at {path}:{line_number}: {exc}") from exc + if not isinstance(payload, dict): + raise ValueError(f"candidate review JSONL row must be an object at {path}:{line_number}") + payload["_row_number"] = line_number + rows.append(payload) + return rows + + +def _write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None: + path.write_text("".join(json.dumps(row, ensure_ascii=False, sort_keys=True) + "\n" for row in rows), encoding="utf-8") + + +def _bbox_from_value(value: Any, *, context: str) -> BBox: + if isinstance(value, str): + try: + value = json.loads(value) + except json.JSONDecodeError as exc: + raise ValueError(f"{context} bbox is not valid JSON: {value!r}") from exc + try: + bbox = BBox.from_any(value) + except Exception as exc: + raise ValueError(f"{context} bbox is invalid: {value!r}") from exc + if bbox.w <= 0 or bbox.h <= 0: + raise ValueError(f"{context} bbox must have positive width/height: {bbox.to_list()}") + return bbox + + +def _read_unmatched_references(path: Path) -> dict[str, list[dict[str, Any]]]: + try: + handle = path.open("r", encoding="utf-8", newline="") + except FileNotFoundError as exc: + raise ValueError(f"line alignment CSV is missing: {path}") from exc + unmatched: dict[str, list[dict[str, Any]]] = {} + with handle: + reader = csv.DictReader(handle) + if reader.fieldnames is None: + raise ValueError(f"line alignment CSV has no header: {path}") + for row_number, row in enumerate(reader, start=2): + if row.get("kind") != "reference_unmatched": + continue + sample_id = str(row.get("sample_id") or "").strip() + reference_line_id = str(row.get("reference_line_id") or "").strip() + if not sample_id or not reference_line_id: + raise ValueError(f"unmatched reference row missing sample/reference id at {path}:{row_number}") + bbox = _bbox_from_value(row.get("reference_bbox"), context=f"{path}:{row_number} reference") + unmatched.setdefault(sample_id, []).append( + { + "reference_line_id": reference_line_id, + "reference_bbox": bbox, + "reference_text": str(row.get("reference_text") or ""), + "page_index": int(row.get("page_index") or 0), + } + ) + return unmatched + + +def _best_unmatched_reference(row: dict[str, Any], unmatched_by_sample: dict[str, list[dict[str, Any]]]) -> dict[str, Any] | None: + sample_id = str(row.get("sample_id") or "").strip() + if not sample_id: + return None + candidate_bbox = _bbox_from_value(row.get("candidate_bbox"), context=f"{row.get('row_id') or row.get('_row_number')} candidate") + candidate_page_index = int(row.get("page_index") or 0) + best: dict[str, Any] | None = None + best_iou = -1.0 + for reference in unmatched_by_sample.get(sample_id, []): + if int(reference["page_index"]) != candidate_page_index: + continue + overlap = bbox_iou(candidate_bbox, reference["reference_bbox"]) + if overlap > best_iou: + best_iou = overlap + best = dict(reference) + best["iou"] = overlap + return best + + +def select_reviews(args: argparse.Namespace) -> dict[str, Any]: + input_path = Path(args.input) + line_alignment_path = Path(args.line_alignment) + out = Path(args.out) + out.mkdir(parents=True, exist_ok=True) + rows = _read_jsonl(input_path) + unmatched_by_sample = _read_unmatched_references(line_alignment_path) + allowed_roles = {str(role).strip() for role in args.roles if str(role).strip()} + if not allowed_roles: + raise ValueError("--roles must contain at least one structural role") + selected_rows: list[dict[str, Any]] = [] + rejected_rows: list[dict[str, Any]] = [] + for row in rows: + output_row = {key: value for key, value in row.items() if not key.startswith("_")} + output_row["selection_policy"] = "oracle_reference_overlap_v1" + output_row["claim_boundary"] = "diagnostic-only oracle selection against current eval references; not deployable OCR policy" + reasons: list[str] = [] + role = str(row.get("candidate_structural_role") or "text").strip() or "text" + if role not in allowed_roles: + reasons.append("candidate_structural_role_not_allowed") + best = _best_unmatched_reference(row, unmatched_by_sample) + best_iou = float(best["iou"]) if best is not None else 0.0 + if best is None: + reasons.append("no_unmatched_reference_for_sample_page") + elif best_iou < float(args.min_iou): + reasons.append("best_unmatched_reference_iou_below_threshold") + output_row["oracle_best_unmatched_reference_iou"] = best_iou + if best is not None: + output_row["oracle_reference_line_id"] = best["reference_line_id"] + output_row["oracle_reference_bbox"] = best["reference_bbox"].to_list() + output_row["oracle_reference_text"] = best["reference_text"] + output_row["selection_reasons"] = reasons + if reasons: + rejected_rows.append(output_row) + continue + output_row["review_status"] = "accepted" + output_row["reviewer"] = str(args.reviewer) + output_row["notes"] = (str(output_row.get("notes") or "") + " oracle_reference_overlap_v1").strip() + if args.corrected_text_source == "reference": + output_row["corrected_text"] = str(best["reference_text"] if best is not None else "") + else: + output_row["corrected_text"] = str(row.get("candidate_text") or "") + selected_rows.append(output_row) + selected_path = out / "selected-candidate-line-review.jsonl" + rejected_path = out / "rejected-candidate-line-review.jsonl" + report_path = out / "candidate-line-reference-overlap-selection.json" + _write_jsonl(selected_path, selected_rows) + _write_jsonl(rejected_path, rejected_rows) + report = { + "tool": "tools/select_candidate_line_reviews_by_reference_overlap.py", + "created_at_utc": datetime.now(UTC).isoformat(), + "input": str(input_path), + "input_sha256": sha256_file(input_path), + "line_alignment": str(line_alignment_path), + "line_alignment_sha256": sha256_file(line_alignment_path), + "output_dir": str(out), + "policy": "oracle_reference_overlap_v1", + "policy_config": { + "min_iou": float(args.min_iou), + "roles": sorted(allowed_roles), + "corrected_text_source": args.corrected_text_source, + }, + "row_count": len(rows), + "selected_count": len(selected_rows), + "rejected_count": len(rejected_rows), + "unmatched_reference_count": sum(len(items) for items in unmatched_by_sample.values()), + "selected_jsonl": str(selected_path), + "selected_jsonl_sha256": sha256_file(selected_path), + "rejected_jsonl": str(rejected_path), + "rejected_jsonl_sha256": sha256_file(rejected_path), + "claim_boundary": "diagnostic-only oracle selection against current eval references; not human review and not deployable OCR policy", + } + report_path.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + return report + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--input", required=True, type=Path) + parser.add_argument("--line-alignment", required=True, type=Path) + parser.add_argument("--out", required=True, type=Path) + parser.add_argument("--roles", nargs="+", default=["text"]) + parser.add_argument("--min-iou", type=float, default=0.50) + parser.add_argument("--corrected-text-source", choices=["reference", "candidate"], default="reference") + parser.add_argument("--reviewer", default="oracle-reference-overlap-v1") + args = parser.parse_args() + report = select_reviews(args) + print(str(Path(report["output_dir"]) / "candidate-line-reference-overlap-selection.json")) + print(report["selected_jsonl"]) + print(f"selected={report['selected_count']} rejected={report['rejected_count']}") + + +if __name__ == "__main__": + main() diff --git a/ocr-tech-mps-integration/tools/split_limbu_book_unresolved_review_packet.py b/ocr-tech-mps-integration/tools/split_limbu_book_unresolved_review_packet.py new file mode 100644 index 0000000000000000000000000000000000000000..842fce10071a4b8606d3ef2c68318973ac796dbe --- /dev/null +++ b/ocr-tech-mps-integration/tools/split_limbu_book_unresolved_review_packet.py @@ -0,0 +1,288 @@ +#!/usr/bin/env python3 +"""Split a reviewed Limbu unresolved packet into applicator-specific TSV files.""" + +from __future__ import annotations + +import argparse +import csv +import json +from collections import Counter +from datetime import UTC, datetime +from pathlib import Path +from typing import Any + +from ocrtech.manifest import sha256_file +from ocrtech.normalization import normalize_ocr_text + + +DEFAULT_ACCEPTED_STATUSES = ("accept", "accepted", "approved", "corrected", "verified", "done") +DEFAULT_DROP_STATUSES = ("drop", "dropped", "reject", "rejected", "remove", "removed", "delete", "deleted") +REPORT_JSON = "book-unresolved-review-packet-split.json" +BOOK_LINE_TSV = "book-line-review-queue-from-packet.tsv" +CANDIDATE_LINE_TSV = "candidate-line-review-from-packet.tsv" + + +def _read_tsv(path: Path) -> tuple[list[dict[str, str]], list[str]]: + try: + handle = path.open("r", encoding="utf-8", newline="") + except FileNotFoundError as exc: + raise ValueError(f"review packet TSV is missing: {path}") from exc + with handle: + reader = csv.DictReader(handle, delimiter="\t") + if reader.fieldnames is None: + raise ValueError(f"review packet TSV has no header: {path}") + required = { + "packet_row_id", + "review_item_type", + "book_page_id", + "review_status", + "corrected_text", + "text", + "crop_path", + "crop_sha256", + } + missing = sorted(required - set(reader.fieldnames)) + if missing: + raise ValueError(f"review packet TSV missing columns {missing}: {path}") + return [dict(row) for row in reader], list(reader.fieldnames) + + +def _write_tsv(path: Path, rows: list[dict[str, str]], fieldnames: list[str]) -> None: + with path.open("w", encoding="utf-8", newline="") as handle: + writer = csv.DictWriter(handle, fieldnames=fieldnames, delimiter="\t", lineterminator="\n", extrasaction="ignore") + writer.writeheader() + writer.writerows(rows) + + +def _unescape_cell(value: Any) -> str: + return str(value if value is not None else "").replace(r"\n", "\n") + + +def _accepted_status(row: dict[str, str], accepted_statuses: set[str]) -> bool: + return str(row.get("review_status") or "").strip().lower() in accepted_statuses + + +def _validate_crop(row: dict[str, str]) -> None: + crop_path = Path(str(row.get("crop_path") or "")) + if not crop_path.is_file(): + raise ValueError(f"packet row {row.get('packet_row_id')!r} crop is missing: {crop_path}") + recorded_sha = str(row.get("crop_sha256") or "").strip() + actual_sha = sha256_file(crop_path) + if recorded_sha and recorded_sha != actual_sha: + raise ValueError(f"packet row {row.get('packet_row_id')!r} crop SHA mismatch: recorded={recorded_sha} actual={actual_sha}") + + +def _role_from_packet_row(row: dict[str, str]) -> str: + role = str(row.get("candidate_structural_role") or "").strip() + if role: + return role + return "page_marker" if str(row.get("review_category") or "") == "structural_page_marker" else "text" + + +def _book_line_row(row: dict[str, str], accepted_statuses: set[str]) -> dict[str, str]: + page_id = str(row.get("book_page_id") or "").strip() + line_id = str(row.get("book_line_id") or "").strip() + if not page_id or not line_id: + raise ValueError(f"existing book-line packet row {row.get('packet_row_id')!r} must include book_page_id and book_line_id") + corrected = _unescape_cell(row.get("corrected_text")) + if _accepted_status(row, accepted_statuses): + split_texts = str(row.get("split_corrected_texts") or "").strip() + corrected = normalize_ocr_text(corrected) + if not corrected.strip() and not split_texts: + raise ValueError( + f"accepted existing book-line packet row {row.get('packet_row_id')!r} " + "requires explicit corrected_text or split_corrected_texts" + ) + return { + "packet_row_id": str(row.get("packet_row_id") or ""), + "book_page_number": str(row.get("book_page_number") or ""), + "book_page_id": page_id, + "book_document": str(row.get("book_document") or ""), + "book_line_id": line_id, + "confidence": str(row.get("confidence") or ""), + "bbox": str(row.get("bbox") or ""), + "text": _unescape_cell(row.get("text")), + "source_texts": str(row.get("source_texts") or ""), + "source_review_reasons": str(row.get("review_reasons") or ""), + "review_status": str(row.get("review_status") or ""), + "corrected_text": corrected, + "split_corrected_texts": str(row.get("split_corrected_texts") or ""), + "split_bboxes": str(row.get("split_bboxes") or ""), + "source_crop_paths": json.dumps([str(row.get("crop_path") or "")], ensure_ascii=False, separators=(",", ":")), + "source_crop_sha256s": json.dumps([str(row.get("crop_sha256") or "")], ensure_ascii=False, separators=(",", ":")), + "reviewer": str(row.get("reviewer") or ""), + "notes": str(row.get("notes") or ""), + } + + +def _candidate_line_row(row: dict[str, str], accepted_statuses: set[str]) -> dict[str, str]: + page_id = str(row.get("book_page_id") or "").strip() + row_id = str(row.get("candidate_row_id") or "").strip() + if not page_id or not row_id: + raise ValueError(f"candidate packet row {row.get('packet_row_id')!r} must include book_page_id and candidate_row_id") + bbox = str(row.get("bbox") or "").strip() + if not bbox: + raise ValueError(f"candidate packet row {row.get('packet_row_id')!r} must include bbox") + corrected = normalize_ocr_text(_unescape_cell(row.get("corrected_text"))) if _accepted_status(row, accepted_statuses) else _unescape_cell(row.get("corrected_text")) + return { + "packet_row_id": str(row.get("packet_row_id") or ""), + "row_id": row_id, + "sample_id": page_id, + "candidate_row_id": row_id, + "candidate_sample_id": page_id, + "book_page_id": page_id, + "candidate_line_id": str(row.get("candidate_line_id") or ""), + "candidate_structural_role": _role_from_packet_row(row), + "candidate_confidence": str(row.get("confidence") or ""), + "candidate_bbox": bbox, + "candidate_text": _unescape_cell(row.get("text")), + "crop_path": str(row.get("crop_path") or ""), + "crop_sha256": str(row.get("crop_sha256") or ""), + "review_status": str(row.get("review_status") or ""), + "corrected_text": corrected, + "reviewer": str(row.get("reviewer") or ""), + "notes": str(row.get("notes") or ""), + } + + +def split_packet(args: argparse.Namespace) -> dict[str, Any]: + packet_tsv = Path(args.review_packet) + out = Path(args.out) + accepted_statuses = {str(status).strip().lower() for status in args.accepted_statuses if str(status).strip()} + if not accepted_statuses: + raise ValueError("--accepted-statuses must contain at least one status") + drop_statuses = { + str(status).strip().lower() + for status in getattr(args, "drop_statuses", DEFAULT_DROP_STATUSES) + if str(status).strip() + } + if accepted_statuses & drop_statuses: + overlap = ", ".join(sorted(accepted_statuses & drop_statuses)) + raise ValueError(f"accepted and drop statuses overlap: {overlap}") + rows, _fieldnames = _read_tsv(packet_tsv) + out.mkdir(parents=True, exist_ok=True) + + book_rows: list[dict[str, str]] = [] + candidate_rows: list[dict[str, str]] = [] + warnings: list[dict[str, str]] = [] + status_counts: Counter[str] = Counter() + type_counts: Counter[str] = Counter() + accepted_counts: Counter[str] = Counter() + dropped_counts: Counter[str] = Counter() + + for row_number, row in enumerate(rows, start=2): + packet_row_id = str(row.get("packet_row_id") or f"row-{row_number}") + item_type = str(row.get("review_item_type") or "").strip() + status = str(row.get("review_status") or "").strip().lower() or "blank" + status_counts[status] += 1 + type_counts[item_type or "blank"] += 1 + _validate_crop(row) + if item_type == "existing_book_line": + converted = _book_line_row(row, accepted_statuses) + book_rows.append(converted) + elif item_type == "candidate_missing_line": + converted = _candidate_line_row(row, accepted_statuses) + candidate_rows.append(converted) + if status in accepted_statuses and not str(row.get("corrected_text") or "").strip(): + raise ValueError( + f"accepted candidate_missing_line packet row {packet_row_id!r} " + "requires explicit corrected_text" + ) + else: + raise ValueError(f"packet row {packet_row_id!r} has unsupported review_item_type {item_type!r}") + if status in accepted_statuses: + accepted_counts[item_type] += 1 + if status in drop_statuses: + dropped_counts[item_type] += 1 + + book_path = out / BOOK_LINE_TSV + candidate_path = out / CANDIDATE_LINE_TSV + _write_tsv( + book_path, + book_rows, + [ + "packet_row_id", + "book_page_number", + "book_page_id", + "book_document", + "book_line_id", + "confidence", + "bbox", + "text", + "source_texts", + "source_review_reasons", + "review_status", + "corrected_text", + "split_corrected_texts", + "split_bboxes", + "source_crop_paths", + "source_crop_sha256s", + "reviewer", + "notes", + ], + ) + _write_tsv( + candidate_path, + candidate_rows, + [ + "packet_row_id", + "row_id", + "sample_id", + "candidate_row_id", + "candidate_sample_id", + "book_page_id", + "candidate_line_id", + "candidate_structural_role", + "candidate_confidence", + "candidate_bbox", + "candidate_text", + "crop_path", + "crop_sha256", + "review_status", + "corrected_text", + "reviewer", + "notes", + ], + ) + report = { + "tool": "tools/split_limbu_book_unresolved_review_packet.py", + "created_at_utc": datetime.now(UTC).isoformat(), + "review_packet": str(packet_tsv), + "review_packet_sha256": sha256_file(packet_tsv), + "out": str(out), + "accepted_statuses": sorted(accepted_statuses), + "drop_statuses": sorted(drop_statuses), + "packet_rows": len(rows), + "item_type_counts": dict(sorted(type_counts.items())), + "status_counts": dict(sorted(status_counts.items())), + "accepted_counts": dict(sorted(accepted_counts.items())), + "dropped_counts": dict(sorted(dropped_counts.items())), + "book_line_review_tsv": str(book_path), + "book_line_review_tsv_sha256": sha256_file(book_path), + "candidate_line_review_tsv": str(candidate_path), + "candidate_line_review_tsv_sha256": sha256_file(candidate_path), + "warnings": warnings, + "boundary": "Format split only; applying these rows still requires the book-line and candidate-line applicators.", + } + report_path = out / REPORT_JSON + report["report_json"] = str(report_path) + report_path.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + return report + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--review-packet", type=Path, required=True) + parser.add_argument("--out", type=Path, required=True) + parser.add_argument("--accepted-statuses", nargs="+", default=list(DEFAULT_ACCEPTED_STATUSES)) + parser.add_argument("--drop-statuses", nargs="+", default=list(DEFAULT_DROP_STATUSES)) + args = parser.parse_args(argv) + report = split_packet(args) + print(report["report_json"]) + print(report["book_line_review_tsv"]) + print(report["candidate_line_review_tsv"]) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ocr-tech-mps-integration/tools/strip_maiwiki_dump.py b/ocr-tech-mps-integration/tools/strip_maiwiki_dump.py new file mode 100644 index 0000000000000000000000000000000000000000..ebba99acf9a77f49bd9efa7bab23238013ae8801 --- /dev/null +++ b/ocr-tech-mps-integration/tools/strip_maiwiki_dump.py @@ -0,0 +1,224 @@ +#!/usr/bin/env python3 +"""Strip a MediaWiki XML dump (Maithili) -> Devanagari sentences, one per line. + +Streams the bz2-compressed `maiwiki-latest-pages-articles.xml.bz2`, keeps only +main-namespace (ns=0) article pages, drops redirects, removes wikitext markup +(templates, tables, refs, links, HTML, file/category links, headings, magic +words), splits the cleaned text into sentences on Devanagari/Latin terminators, +and writes Devanagari sentences (NFC, deduped) to the output file. + +This mirrors how `newwiki-dump-devanagari.txt` was produced for the Newa build. +No external wikitext parser is required (mwparserfromhell is not installed on +this repo's interpreter); markup is stripped with conservative regexes. The +downstream Tirhuta builder still does its own NFC + codepoint verification + +residue cleanup, so this stage only needs to be a good first pass. + +Run with the repo venv: + python tools/strip_maiwiki_dump.py \ + --dump data/leipzig-maithili/maiwiki-latest-pages-articles.xml.bz2 \ + --out data/leipzig-maithili/maiwiki-dump-devanagari.txt +""" +from __future__ import annotations + +import argparse +import bz2 +import re +import sys +import unicodedata +import xml.sax +from pathlib import Path + +DEVA_LO = 0x0900 +DEVA_HI = 0x097F + +# Sentence terminators (Devanagari danda/double-danda + ASCII . ! ? and newline). +_SENT_SPLIT_RE = re.compile(r"[।॥.!?\n]+") +_WS_RE = re.compile(r"\s+") + +# --- wikitext stripping regexes (applied in order) --------------------------- +_COMMENT_RE = re.compile(r"", re.DOTALL) +_REF_RE = re.compile(r"]*?/>", re.IGNORECASE) +_REF_BLOCK_RE = re.compile(r"]*?>.*?", re.IGNORECASE | re.DOTALL) +# Tags whose entire content is non-prose and should be dropped wholesale. +_DROP_BLOCK_RE = re.compile( + r"<(table|gallery|math|score|timeline|syntaxhighlight|source|pre|code|nowiki)" + r"[^>]*?>.*?", + re.IGNORECASE | re.DOTALL, +) +_HTML_TAG_RE = re.compile(r"<[^>]+>") +# {{...}} templates and {|...|} tables, removed iteratively to handle nesting. +_TEMPLATE_RE = re.compile(r"\{\{[^{}]*\}\}", re.DOTALL) +_TABLE_RE = re.compile(r"\{\|[^{}]*?\|\}", re.DOTALL) +# [[File:...]] / [[Image:...]] / [[Category:...]] in English + Maithili aliases. +_FILE_CAT_RE = re.compile( + r"\[\[\s*(?:File|Image|Category|फाइल|श्रेणी|चित्र)\s*:[^\[\]]*" + r"(?:\[\[[^\[\]]*\]\][^\[\]]*)*\]\]", + re.IGNORECASE, +) +# [[target|label]] -> label ; [[target]] -> target +_LINK_PIPED_RE = re.compile(r"\[\[[^\[\]|]*\|([^\[\]|]+)\]\]") +_LINK_PLAIN_RE = re.compile(r"\[\[([^\[\]|]+)\]\]") +# [http://... label] -> label ; [http://...] -> "" +_EXTLINK_LABEL_RE = re.compile(r"\[(?:https?:|//)[^\s\]]+\s+([^\]]+)\]") +_EXTLINK_BARE_RE = re.compile(r"\[(?:https?:|//)[^\]]*\]") +# bold/italic apostrophe markup +_BOLDITALIC_RE = re.compile(r"'{2,5}") +# headings == ... == +_HEADING_RE = re.compile(r"^=+\s*(.*?)\s*=+\s*$", re.MULTILINE) +# leading list/indent/table markup at line start +_LINE_MARKUP_RE = re.compile(r"^[\s]*[\*#:;|!+{}-]+", re.MULTILINE) +# __MAGIC__ words and remaining stray braces/brackets +_MAGIC_RE = re.compile(r"__[A-Z]+__") +_HTML_ENTITY_RE = re.compile(r"&[a-zA-Z]+;|&#\d+;") +# Bare URLs that survive inside otherwise-Devanagari prose. +_URL_RE = re.compile(r"https?://\S+|//\S+|\b\S+\.(?:com|org|net|html)\b\S*") +# Leftover template `param=value` leaders at a fragment start (image=, name=, ...). +_PARAM_LEADER_RE = re.compile(r"^\s*[A-Za-z_][A-Za-z0-9_]*\s*=\s*") + + +def deva_count(s: str) -> int: + return sum(1 for c in s if DEVA_LO <= ord(c) <= DEVA_HI) + + +def strip_wikitext(text: str) -> str: + text = _COMMENT_RE.sub(" ", text) + text = _REF_RE.sub(" ", text) + text = _REF_BLOCK_RE.sub(" ", text) + text = _DROP_BLOCK_RE.sub(" ", text) + # Iteratively remove nested templates/tables. + for _ in range(12): + new = _TEMPLATE_RE.sub(" ", text) + new = _TABLE_RE.sub(" ", new) + if new == text: + break + text = new + # Drop file/category links before generic link handling. + for _ in range(4): + new = _FILE_CAT_RE.sub(" ", text) + if new == text: + break + text = new + text = _LINK_PIPED_RE.sub(r"\1", text) + text = _LINK_PLAIN_RE.sub(r"\1", text) + text = _EXTLINK_LABEL_RE.sub(r"\1", text) + text = _EXTLINK_BARE_RE.sub(" ", text) + text = _BOLDITALIC_RE.sub("", text) + text = _HEADING_RE.sub(r"\1", text) + text = _MAGIC_RE.sub(" ", text) + text = _DROP_BLOCK_RE.sub(" ", text) # second pass post-template removal + text = _HTML_TAG_RE.sub(" ", text) + text = _HTML_ENTITY_RE.sub(" ", text) + text = _LINE_MARKUP_RE.sub(" ", text) + # Any leftover stray braces/brackets. + text = text.replace("{", " ").replace("}", " ").replace("[", " ").replace("]", " ") + return text + + +class PageHandler(xml.sax.ContentHandler): + """Streaming SAX handler: collects ns=0 non-redirect page texts.""" + + def __init__(self, sink) -> None: + super().__init__() + self.sink = sink + self._buf: list[str] = [] + self._in_text = False + self._cur_ns: str | None = None + self._cur_ns_buf: list[str] = [] + self._in_ns = False + self._is_redirect = False + self._cur_text: list[str] = [] + self.pages_seen = 0 + self.pages_kept = 0 + + def startElement(self, name, attrs): # noqa: N802 (SAX API) + if name == "page": + self._cur_ns = None + self._is_redirect = False + self._cur_text = [] + elif name == "ns": + self._in_ns = True + self._cur_ns_buf = [] + elif name == "redirect": + self._is_redirect = True + elif name == "text": + self._in_text = True + self._buf = [] + + def characters(self, content): # noqa: N802 (SAX API) + if self._in_text: + self._buf.append(content) + elif self._in_ns: + self._cur_ns_buf.append(content) + + def endElement(self, name): # noqa: N802 (SAX API) + if name == "ns": + self._in_ns = False + self._cur_ns = "".join(self._cur_ns_buf).strip() + elif name == "text": + self._in_text = False + self._cur_text = self._buf + self._buf = [] + elif name == "page": + self.pages_seen += 1 + if self._cur_ns == "0" and not self._is_redirect: + raw = "".join(self._cur_text) + if raw.strip(): + self.pages_kept += 1 + self.sink(raw) + + +def main() -> int: + ap = argparse.ArgumentParser() + ap.add_argument("--dump", required=True, help="path to *-pages-articles.xml.bz2") + ap.add_argument("--out", required=True, help="output Devanagari sentences file") + ap.add_argument("--min-deva", type=int, default=3, + help="min Devanagari chars to keep a sentence") + ap.add_argument("--max-chars", type=int, default=400, + help="drop absurdly long sentence fragments (markup residue)") + args = ap.parse_args() + + seen: set[str] = set() + out_lines: list[str] = [] + + def sink(raw_wikitext: str) -> None: + cleaned = strip_wikitext(raw_wikitext) + cleaned = _URL_RE.sub(" ", cleaned) + for chunk in _SENT_SPLIT_RE.split(cleaned): + chunk = _PARAM_LEADER_RE.sub("", chunk) + s = _WS_RE.sub(" ", unicodedata.normalize("NFC", chunk)).strip() + if not s: + continue + if len(s) > args.max_chars: + continue + if deva_count(s) < args.min_deva: + continue + # Require Devanagari to dominate (drop lines that are mostly latin/markup). + if deva_count(s) < len(s.replace(" ", "")) * 0.5: + continue + if s in seen: + continue + seen.add(s) + out_lines.append(s) + + print(f"[strip] streaming {args.dump} ...", file=sys.stderr) + handler = PageHandler(sink) + parser = xml.sax.make_parser() + parser.setContentHandler(handler) + with bz2.open(args.dump, "rb") as fh: + parser.parse(fh) + + print( + f"[strip] pages_seen={handler.pages_seen} ns0_kept={handler.pages_kept} " + f"unique_sentences={len(out_lines)}", + file=sys.stderr, + ) + + outp = Path(args.out) + outp.parent.mkdir(parents=True, exist_ok=True) + outp.write_text("\n".join(out_lines) + "\n", encoding="utf-8") + print(f"[strip] wrote {len(out_lines)} sentences -> {args.out}", file=sys.stderr) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ocr-tech-mps-integration/tools/sweep_limbu_pdf_text_line_detector_params.py b/ocr-tech-mps-integration/tools/sweep_limbu_pdf_text_line_detector_params.py new file mode 100644 index 0000000000000000000000000000000000000000..24aa9dfa1c937fbee458f6eb6b6171bf87c1d8f4 --- /dev/null +++ b/ocr-tech-mps-integration/tools/sweep_limbu_pdf_text_line_detector_params.py @@ -0,0 +1,476 @@ +#!/usr/bin/env python3 +"""Sweep image-line detector parameters against Limbu PDF text-layer boxes. + +This is a detector-only diagnostic for the book OCR loop. It does not run +recognition and it does not use PDF text as OCR truth; it asks whether source +text-layer line boxes are geometrically covered by detected page line boxes. +""" + +from __future__ import annotations + +import argparse +import csv +import json +import platform +from dataclasses import dataclass +from datetime import UTC, datetime +from itertools import product +from pathlib import Path +from typing import Any + +from ocrtech.image_lines import ImageLineDetectionConfig, detect_line_boxes_with_audit +from ocrtech.manifest import sha256_file + + +REPORT_JSON = "limbu-pdf-text-detector-sweep.json" +RANKED_CSV = "ranked-detector-configs.csv" +TOP_ROWS_JSONL = "top-config-page-coverage.jsonl" + + +@dataclass(frozen=True, slots=True) +class BBox: + x: float + y: float + w: float + h: float + + @property + def right(self) -> float: + return self.x + self.w + + @property + def bottom(self) -> float: + return self.y + self.h + + def to_list(self) -> list[float]: + return [self.x, self.y, self.w, self.h] + + +@dataclass(frozen=True, slots=True) +class SweepConfig: + threshold: str + bbox_source: str + reading_order: str + horizontal_kernel: int + vertical_kernel: int + dilation_iterations: int + min_width: int + min_height: int + min_area: int + max_height: int + detector_padding: int + + def to_detection_config(self) -> ImageLineDetectionConfig: + return ImageLineDetectionConfig( + threshold=self.threshold, + bbox_source=self.bbox_source, + reading_order=self.reading_order, + horizontal_kernel=self.horizontal_kernel, + vertical_kernel=self.vertical_kernel, + dilation_iterations=self.dilation_iterations, + min_width=self.min_width, + min_height=self.min_height, + min_area=self.min_area, + max_height=self.max_height, + detector_padding=self.detector_padding, + ) + + def to_dict(self) -> dict[str, Any]: + return { + "threshold": self.threshold, + "bbox_source": self.bbox_source, + "reading_order": self.reading_order, + "horizontal_kernel": self.horizontal_kernel, + "vertical_kernel": self.vertical_kernel, + "dilation_iterations": self.dilation_iterations, + "min_width": self.min_width, + "min_height": self.min_height, + "min_area": self.min_area, + "max_height": self.max_height, + "detector_padding": self.detector_padding, + } + + +def _read_jsonl(path: Path, *, label: str) -> list[dict[str, Any]]: + try: + lines = path.read_text(encoding="utf-8").splitlines() + except FileNotFoundError as exc: + raise ValueError(f"{label} is missing: {path}") from exc + rows: list[dict[str, Any]] = [] + for line_number, line in enumerate(lines, start=1): + if not line.strip(): + continue + try: + payload = json.loads(line) + except json.JSONDecodeError as exc: + raise ValueError(f"{label} line {line_number} is invalid JSON: {path}: {exc}") from exc + if not isinstance(payload, dict): + raise ValueError(f"{label} line {line_number} must contain an object: {path}") + rows.append(payload) + return rows + + +def _resolve_path(path_value: Any, base_dir: Path) -> Path: + path = Path(str(path_value or "")) + if path.is_absolute() or path.exists(): + return path + candidate = base_dir / path + if candidate.exists(): + return candidate + return path + + +def _page_images(page_manifest: Path) -> dict[str, Path]: + rows = _read_jsonl(page_manifest, label="page manifest") + base_dir = page_manifest.parent + pages: dict[str, Path] = {} + for index, row in enumerate(rows, start=1): + page_id = str(row.get("page_id") or row.get("sample_id") or "").strip() + if not page_id: + raise ValueError(f"page manifest row {index} missing page_id/sample_id") + image_path = _resolve_path(row.get("image_path"), base_dir) + if not image_path.is_file(): + raise FileNotFoundError(f"page image does not exist for {page_id}: {image_path}") + if page_id in pages: + raise ValueError(f"duplicate page_id in page manifest: {page_id}") + pages[page_id] = image_path + if not pages: + raise ValueError(f"page manifest has no rows: {page_manifest}") + return pages + + +def _parse_int_list(value: str, *, name: str) -> list[int]: + numbers: list[int] = [] + for item in value.split(","): + item = item.strip() + if not item: + continue + try: + number = int(item) + except ValueError as exc: + raise ValueError(f"{name} must be a comma-separated integer list: {value!r}") from exc + if number <= 0: + raise ValueError(f"{name} values must be positive: {value!r}") + numbers.append(number) + if not numbers: + raise ValueError(f"{name} must contain at least one value") + return sorted(dict.fromkeys(numbers)) + + +def _parse_str_list(value: str, *, name: str, choices: set[str] | None = None) -> list[str]: + values = [item.strip() for item in value.split(",") if item.strip()] + if not values: + raise ValueError(f"{name} must contain at least one value") + if choices is not None: + bad = [item for item in values if item not in choices] + if bad: + raise ValueError(f"{name} has unsupported values {bad!r}; choices are {sorted(choices)}") + return list(dict.fromkeys(values)) + + +def _config_grid(args: argparse.Namespace) -> list[SweepConfig]: + thresholds = _parse_str_list(args.thresholds, name="thresholds") + bbox_sources = _parse_str_list(args.bbox_sources, name="bbox_sources", choices={"ink", "dilated"}) + reading_orders = _parse_str_list( + args.reading_orders, + name="reading_orders", + choices={"top_to_bottom", "column_major", "wide_column_right_to_left", "auto_layout"}, + ) + return [ + SweepConfig(*values) + for values in product( + thresholds, + bbox_sources, + reading_orders, + _parse_int_list(args.horizontal_kernels, name="horizontal_kernels"), + _parse_int_list(args.vertical_kernels, name="vertical_kernels"), + _parse_int_list(args.dilation_iterations, name="dilation_iterations"), + _parse_int_list(args.min_widths, name="min_widths"), + _parse_int_list(args.min_heights, name="min_heights"), + _parse_int_list(args.min_areas, name="min_areas"), + _parse_int_list(args.max_heights, name="max_heights"), + _parse_int_list(args.detector_paddings, name="detector_paddings"), + ) + ] + + +def _rendered_bbox_xywh(value: Any) -> BBox: + if not isinstance(value, list) or len(value) != 4: + raise ValueError(f"rendered_bbox must be [x_min,y_min,x_max,y_max], got {value!r}") + try: + x_min, y_min, x_max, y_max = (float(item) for item in value) + except (TypeError, ValueError) as exc: + raise ValueError(f"rendered_bbox must contain numeric values: {value!r}") from exc + if x_max <= x_min or y_max <= y_min: + raise ValueError(f"rendered_bbox must have positive extent: {value!r}") + return BBox(x=x_min, y=y_min, w=x_max - x_min, h=y_max - y_min) + + +def _axis_overlap(start_a: float, size_a: float, start_b: float, size_b: float) -> float: + return max(0.0, min(start_a + size_a, start_b + size_b) - max(start_a, start_b)) + + +def _has_limbu_text(row: dict[str, Any]) -> bool: + text = str(row.get("unicode_text") or "") + return any(0x1900 <= ord(char) <= 0x194F for char in text) + + +def _source_rows_by_page(pdf_text_context_jsonl: Path) -> tuple[dict[str, list[dict[str, Any]]], int]: + rows = _read_jsonl(pdf_text_context_jsonl, label="PDF text context JSONL") + by_page: dict[str, list[dict[str, Any]]] = {} + skipped = 0 + for row in rows: + if not _has_limbu_text(row): + skipped += 1 + continue + page_id = str(row.get("page_id") or "").strip() + if not page_id: + raise ValueError("PDF text context row missing page_id") + source_bbox = _rendered_bbox_xywh(row.get("rendered_bbox")) + by_page.setdefault(page_id, []).append({**row, "_source_bbox": source_bbox}) + return by_page, skipped + + +def _covered_x_ratio(source: BBox, boxes: list[BBox], *, min_y_overlap_ratio: float) -> float: + intervals: list[tuple[float, float]] = [] + for box in boxes: + y_overlap = _axis_overlap(source.y, source.h, box.y, box.h) + y_ratio = y_overlap / min(source.h, box.h) if min(source.h, box.h) > 0 else 0.0 + if y_ratio < min_y_overlap_ratio: + continue + x_overlap = _axis_overlap(source.x, source.w, box.x, box.w) + if x_overlap <= 0: + continue + intervals.append((max(source.x, box.x), min(source.right, box.right))) + if not intervals or source.w <= 0: + return 0.0 + intervals.sort() + merged: list[list[float]] = [] + for start, end in intervals: + if not merged or start > merged[-1][1]: + merged.append([start, end]) + else: + merged[-1][1] = max(merged[-1][1], end) + return min(1.0, sum(end - start for start, end in merged) / source.w) + + +def _score_page_rows( + rows: list[dict[str, Any]], + boxes: list[BBox], + *, + min_y_overlap_ratio: float, + min_x_coverage_ratio: float, +) -> dict[str, Any]: + counts = {"covered": 0, "pdf_text_line_missing_y_coverage": 0, "pdf_text_line_partial_x_coverage": 0} + max_y_ratios: list[float] = [] + x_coverage_ratios: list[float] = [] + for row in rows: + source = row["_source_bbox"] + max_y = 0.0 + for box in boxes: + y_overlap = _axis_overlap(source.y, source.h, box.y, box.h) + y_ratio = y_overlap / min(source.h, box.h) if min(source.h, box.h) > 0 else 0.0 + max_y = max(max_y, y_ratio) + x_coverage = _covered_x_ratio(source, boxes, min_y_overlap_ratio=min_y_overlap_ratio) + max_y_ratios.append(max_y) + x_coverage_ratios.append(x_coverage) + if max_y < min_y_overlap_ratio: + counts["pdf_text_line_missing_y_coverage"] += 1 + elif x_coverage < min_x_coverage_ratio: + counts["pdf_text_line_partial_x_coverage"] += 1 + else: + counts["covered"] += 1 + return { + **counts, + "source_line_count": len(rows), + "mean_max_y_overlap_ratio": sum(max_y_ratios) / len(max_y_ratios) if max_y_ratios else 0.0, + "mean_x_coverage_ratio": sum(x_coverage_ratios) / len(x_coverage_ratios) if x_coverage_ratios else 0.0, + } + + +def _rank_key(row: dict[str, Any]) -> tuple[int, int, float, float, int]: + return ( + int(row["covered"]), + -int(row["candidate_count"]), + float(row["mean_x_coverage_ratio"]), + float(row["mean_max_y_overlap_ratio"]), + -int(row["detected_line_count"]), + ) + + +def _write_ranked_csv(path: Path, rows: list[dict[str, Any]]) -> None: + fields = [ + "rank", + "covered", + "candidate_count", + "missing_y_count", + "partial_x_count", + "source_line_count", + "detected_line_count", + "mean_max_y_overlap_ratio", + "mean_x_coverage_ratio", + "threshold", + "bbox_source", + "reading_order", + "horizontal_kernel", + "vertical_kernel", + "dilation_iterations", + "min_width", + "min_height", + "min_area", + "max_height", + "detector_padding", + ] + with path.open("w", encoding="utf-8", newline="") as handle: + writer = csv.DictWriter(handle, fieldnames=fields) + writer.writeheader() + for row in rows: + writer.writerow({field: row.get(field, "") for field in fields}) + + +def sweep_detector_params(args: argparse.Namespace) -> dict[str, Any]: + page_manifest = Path(args.page_manifest) + pdf_text_context_jsonl = Path(args.pdf_text_context_jsonl) + out = Path(args.out) + out.mkdir(parents=True, exist_ok=True) + pages = _page_images(page_manifest) + rows_by_page, skipped = _source_rows_by_page(pdf_text_context_jsonl) + unknown_pages = sorted(set(rows_by_page) - set(pages)) + if unknown_pages: + raise ValueError(f"PDF text context contains page IDs not in page manifest: {unknown_pages}") + configs = _config_grid(args) + ranked: list[dict[str, Any]] = [] + top_page_rows: list[dict[str, Any]] = [] + for config_index, config in enumerate(configs, start=1): + detection_config = config.to_detection_config() + aggregate = { + "covered": 0, + "missing_y_count": 0, + "partial_x_count": 0, + "source_line_count": 0, + "detected_line_count": 0, + "mean_max_y_overlap_ratio_weighted": 0.0, + "mean_x_coverage_ratio_weighted": 0.0, + } + per_page: list[dict[str, Any]] = [] + for page_id, source_rows in sorted(rows_by_page.items()): + detected, selection = detect_line_boxes_with_audit(pages[page_id], detection_config) + boxes = [line.bbox for line in detected] + page_score = _score_page_rows( + source_rows, + boxes, + min_y_overlap_ratio=float(args.min_y_overlap_ratio), + min_x_coverage_ratio=float(args.min_x_coverage_ratio), + ) + source_count = int(page_score["source_line_count"]) + aggregate["covered"] += int(page_score["covered"]) + aggregate["missing_y_count"] += int(page_score["pdf_text_line_missing_y_coverage"]) + aggregate["partial_x_count"] += int(page_score["pdf_text_line_partial_x_coverage"]) + aggregate["source_line_count"] += source_count + aggregate["detected_line_count"] += len(detected) + aggregate["mean_max_y_overlap_ratio_weighted"] += float(page_score["mean_max_y_overlap_ratio"]) * source_count + aggregate["mean_x_coverage_ratio_weighted"] += float(page_score["mean_x_coverage_ratio"]) * source_count + per_page.append( + { + "config_index": config_index, + "page_id": page_id, + "detected_line_count": len(detected), + "reading_order_selected": selection.selected, + **page_score, + } + ) + source_total = max(1, int(aggregate["source_line_count"])) + ranked.append( + { + "config_index": config_index, + **config.to_dict(), + "covered": aggregate["covered"], + "candidate_count": aggregate["missing_y_count"] + aggregate["partial_x_count"], + "missing_y_count": aggregate["missing_y_count"], + "partial_x_count": aggregate["partial_x_count"], + "source_line_count": aggregate["source_line_count"], + "detected_line_count": aggregate["detected_line_count"], + "mean_max_y_overlap_ratio": aggregate["mean_max_y_overlap_ratio_weighted"] / source_total, + "mean_x_coverage_ratio": aggregate["mean_x_coverage_ratio_weighted"] / source_total, + "per_page": per_page, + } + ) + ranked.sort(key=_rank_key, reverse=True) + for rank, row in enumerate(ranked, start=1): + row["rank"] = rank + for row in ranked[: int(args.top_k)]: + for page_row in row["per_page"]: + top_page_rows.append({"rank": row["rank"], **page_row}) + ranked_csv = out / RANKED_CSV + _write_ranked_csv(ranked_csv, ranked) + top_rows_jsonl = out / TOP_ROWS_JSONL + with top_rows_jsonl.open("w", encoding="utf-8") as handle: + for row in top_page_rows: + handle.write(json.dumps(row, ensure_ascii=False, separators=(",", ":")) + "\n") + report_path = out / REPORT_JSON + best = ranked[0] if ranked else {} + report = { + "created_at_utc": datetime.now(UTC).isoformat(), + "tool": "tools/sweep_limbu_pdf_text_line_detector_params.py", + "machine": platform.node(), + "page_manifest": str(page_manifest), + "page_manifest_sha256": sha256_file(page_manifest), + "pdf_text_context_jsonl": str(pdf_text_context_jsonl), + "pdf_text_context_jsonl_sha256": sha256_file(pdf_text_context_jsonl), + "out": str(out), + "ranked_csv": str(ranked_csv), + "ranked_csv_sha256": sha256_file(ranked_csv), + "top_rows_jsonl": str(top_rows_jsonl), + "top_rows_jsonl_sha256": sha256_file(top_rows_jsonl), + "config_count": len(ranked), + "page_count": len(pages), + "source_line_count": sum(len(rows) for rows in rows_by_page.values()), + "skipped_no_limbu_text_count": skipped, + "min_y_overlap_ratio": float(args.min_y_overlap_ratio), + "min_x_coverage_ratio": float(args.min_x_coverage_ratio), + "best_config": {key: value for key, value in best.items() if key != "per_page"}, + "current_default_config_note": "Compare against ImageLineDetectionConfig defaults: horizontal_kernel=23, vertical_kernel=3, min_width=35, min_height=10, min_area=100, max_height=140, detector_padding=2.", + "boundary": "Detector-only source-line coverage diagnostic; this does not certify OCR text quality.", + } + report["report_json"] = str(report_path) + report_path.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + return report + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--page-manifest", type=Path, required=True) + parser.add_argument("--pdf-text-context-jsonl", type=Path, required=True) + parser.add_argument("--out", type=Path, required=True) + parser.add_argument("--thresholds", default="otsu") + parser.add_argument("--bbox-sources", default="ink") + parser.add_argument("--reading-orders", default="auto_layout") + parser.add_argument("--horizontal-kernels", default="15,23,31") + parser.add_argument("--vertical-kernels", default="3,5") + parser.add_argument("--dilation-iterations", default="1") + parser.add_argument("--min-widths", default="15,25,35") + parser.add_argument("--min-heights", default="6,10") + parser.add_argument("--min-areas", default="50,100") + parser.add_argument("--max-heights", default="100,140,180") + parser.add_argument("--detector-paddings", default="2") + parser.add_argument("--min-y-overlap-ratio", type=float, default=0.40) + parser.add_argument("--min-x-coverage-ratio", type=float, default=0.20) + parser.add_argument("--top-k", type=int, default=10) + args = parser.parse_args(argv) + report = sweep_detector_params(args) + best = report.get("best_config") if isinstance(report.get("best_config"), dict) else {} + print(report["report_json"]) + print(report["ranked_csv"]) + print( + "configs={configs} best_covered={covered} best_candidates={candidates} best_detected={detected}".format( + configs=report["config_count"], + covered=best.get("covered"), + candidates=best.get("candidate_count"), + detected=best.get("detected_line_count"), + ) + ) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ocr-tech-mps-integration/tools/sweep_limbu_sirijonga_detector_params.py b/ocr-tech-mps-integration/tools/sweep_limbu_sirijonga_detector_params.py new file mode 100644 index 0000000000000000000000000000000000000000..675827660e5907c3572010fab4f2a94f3e0f6b0d --- /dev/null +++ b/ocr-tech-mps-integration/tools/sweep_limbu_sirijonga_detector_params.py @@ -0,0 +1,363 @@ +#!/usr/bin/env python3 +"""Sweep Sirijanga image-line detector parameters against reference line boxes. + +This is a detector-only diagnostic: it does not run OCR recognition. It exists to +rank morphology detector settings for real Limbu/Sirijanga page drafts before +spending time on recognizer inference or claiming text quality. +""" + +from __future__ import annotations + +import argparse +import csv +import importlib.util +import itertools +import json +import platform +import sys +from dataclasses import dataclass +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +from ocrtech.manifest import ManifestEntry, load_manifest, sha256_file +from ocrtech.metrics import detection_score + + +READING_ORDER_MODES = ("top_to_bottom", "column_major") + + +@dataclass(frozen=True) +class DetectorConfig: + threshold: str + bbox_source: str + reading_order: str + horizontal_kernel: int + vertical_kernel: int + dilation_iterations: int + min_width: int + min_height: int + min_area: int + max_height: int + detector_padding: int + + def to_dict(self) -> dict[str, Any]: + return { + "threshold": self.threshold, + "bbox_source": self.bbox_source, + "reading_order": self.reading_order, + "horizontal_kernel": self.horizontal_kernel, + "vertical_kernel": self.vertical_kernel, + "dilation_iterations": self.dilation_iterations, + "min_width": self.min_width, + "min_height": self.min_height, + "min_area": self.min_area, + "max_height": self.max_height, + "detector_padding": self.detector_padding, + } + + +def _load_compare_tool() -> Any: + path = Path(__file__).resolve().parent / "compare_limbu_sirijonga_detector_reading_order.py" + spec = importlib.util.spec_from_file_location("compare_limbu_sirijonga_detector_reading_order", path) + if spec is None or spec.loader is None: + raise RuntimeError(f"could not load detector comparison module: {path}") + module = importlib.util.module_from_spec(spec) + sys.modules[spec.name] = module + spec.loader.exec_module(module) + return module + + +def _parse_int_list(value: str, *, name: str) -> list[int]: + items: list[int] = [] + for raw in value.split(","): + item = raw.strip() + if not item: + continue + try: + number = int(item) + except ValueError as exc: + raise ValueError(f"{name} must be a comma-separated integer list: {value!r}") from exc + if number <= 0: + raise ValueError(f"{name} values must be positive integers: {value!r}") + items.append(number) + if not items: + raise ValueError(f"{name} must contain at least one integer") + return sorted(dict.fromkeys(items)) + + +def _parse_str_list(value: str, *, name: str, choices: tuple[str, ...] | None = None) -> list[str]: + items = [item.strip() for item in value.split(",") if item.strip()] + if not items: + raise ValueError(f"{name} must contain at least one value") + if choices is not None: + invalid = [item for item in items if item not in choices] + if invalid: + raise ValueError(f"{name} has invalid values {invalid!r}; choices are {choices!r}") + return list(dict.fromkeys(items)) + + +def _config_grid(args: argparse.Namespace) -> list[DetectorConfig]: + thresholds = _parse_str_list(args.thresholds, name="thresholds") + bbox_sources = _parse_str_list(args.bbox_sources, name="bbox_sources", choices=("ink", "dilated")) + reading_orders = _parse_str_list(args.reading_orders, name="reading_orders", choices=READING_ORDER_MODES) + horizontal_kernels = _parse_int_list(args.horizontal_kernels, name="horizontal_kernels") + vertical_kernels = _parse_int_list(args.vertical_kernels, name="vertical_kernels") + dilation_iterations = _parse_int_list(args.dilation_iterations, name="dilation_iterations") + min_widths = _parse_int_list(args.min_widths, name="min_widths") + min_heights = _parse_int_list(args.min_heights, name="min_heights") + min_areas = _parse_int_list(args.min_areas, name="min_areas") + max_heights = _parse_int_list(args.max_heights, name="max_heights") + detector_paddings = _parse_int_list(args.detector_paddings, name="detector_paddings") + configs: list[DetectorConfig] = [] + for values in itertools.product( + thresholds, + bbox_sources, + reading_orders, + horizontal_kernels, + vertical_kernels, + dilation_iterations, + min_widths, + min_heights, + min_areas, + max_heights, + detector_paddings, + ): + configs.append(DetectorConfig(*values)) + return configs + + +def _score_config( + config: DetectorConfig, + *, + entries: list[ManifestEntry], + manifest_dir: Path, + compare_tool: Any, + materializer: Any, + iou_threshold: float, +) -> dict[str, Any]: + reference_count = 0 + prediction_count = 0 + match_count = 0 + iou_numerator = 0.0 + order_correct = 0 + order_total = 0 + samples: list[dict[str, Any]] = [] + detector_args = argparse.Namespace(**config.to_dict()) + for entry in entries: + reference_value = entry.metadata.get("reference_path") if isinstance(entry.metadata, dict) else None + if not isinstance(reference_value, str) or not reference_value: + raise ValueError(f"{entry.sample_id}: metadata.reference_path is required") + image_path = compare_tool._resolve_path(entry.image_path, manifest_dir) + if not image_path.exists(): + raise FileNotFoundError(f"{entry.sample_id}: image_path does not exist: {image_path}") + reference_path = compare_tool._resolve_path(reference_value, manifest_dir) + reference_lines, _metadata = compare_tool._read_reference_lines(reference_path) + predicted = compare_tool._detect_lines(materializer, image_path, detector_args, mode=config.reading_order) + summary, _rows = compare_tool._align_detector_lines( + sample_id=entry.sample_id, + mode=config.reading_order, + reference_lines=reference_lines, + predicted_lines=predicted, + iou_threshold=iou_threshold, + ) + reference_count += int(summary["line_reference_count"]) + prediction_count += int(summary["line_prediction_count"]) + match_count += int(summary["line_match_count"]) + iou_numerator += float(summary["line_mean_iou"]) * int(summary["line_match_count"]) + order_correct += int(summary["matched_line_reading_order_correct_pairs"]) + order_total += int(summary["matched_line_reading_order_total_pairs"]) + samples.append({"sample_id": entry.sample_id, **summary}) + score = detection_score(prediction_count, reference_count, match_count) + line_count_abs_error = abs(prediction_count - reference_count) + order_accuracy = order_correct / order_total if order_total else 1.0 + return { + "config": config.to_dict(), + "line_reference_count": reference_count, + "line_prediction_count": prediction_count, + "line_count_abs_error": line_count_abs_error, + "line_match_count": match_count, + "line_detection_precision": score.precision, + "line_detection_recall": score.recall, + "line_detection_f1": score.f1, + "line_mean_iou": iou_numerator / match_count if match_count else 0.0, + "matched_line_reading_order_correct_pairs": order_correct, + "matched_line_reading_order_total_pairs": order_total, + "matched_line_reading_order_pair_accuracy": order_accuracy, + "samples": samples, + } + + +def _rank_key(row: dict[str, Any]) -> tuple[float, float, float, int, int]: + return ( + float(row["line_detection_f1"]), + float(row["matched_line_reading_order_pair_accuracy"]), + float(row["line_mean_iou"]), + -int(row["line_count_abs_error"]), + int(row["line_match_count"]), + ) + + +def _write_csv(path: Path, rows: list[dict[str, Any]]) -> None: + fields = [ + "rank", + "line_detection_f1", + "line_detection_precision", + "line_detection_recall", + "line_mean_iou", + "matched_line_reading_order_pair_accuracy", + "matched_line_reading_order_correct_pairs", + "matched_line_reading_order_total_pairs", + "line_reference_count", + "line_prediction_count", + "line_count_abs_error", + "line_match_count", + "threshold", + "bbox_source", + "reading_order", + "horizontal_kernel", + "vertical_kernel", + "dilation_iterations", + "min_width", + "min_height", + "min_area", + "max_height", + "detector_padding", + ] + with path.open("w", encoding="utf-8", newline="") as handle: + writer = csv.DictWriter(handle, fieldnames=fields) + writer.writeheader() + for rank, row in enumerate(rows, start=1): + config = row["config"] + writer.writerow( + { + "rank": rank, + "line_detection_f1": row["line_detection_f1"], + "line_detection_precision": row["line_detection_precision"], + "line_detection_recall": row["line_detection_recall"], + "line_mean_iou": row["line_mean_iou"], + "matched_line_reading_order_pair_accuracy": row["matched_line_reading_order_pair_accuracy"], + "matched_line_reading_order_correct_pairs": row["matched_line_reading_order_correct_pairs"], + "matched_line_reading_order_total_pairs": row["matched_line_reading_order_total_pairs"], + "line_reference_count": row["line_reference_count"], + "line_prediction_count": row["line_prediction_count"], + "line_count_abs_error": row["line_count_abs_error"], + "line_match_count": row["line_match_count"], + **config, + } + ) + + +def _write_report(path: Path, result: dict[str, Any]) -> None: + best = result["best"] + best_config = best["config"] + path.write_text( + "\n".join( + [ + "# Limbu Sirijanga Detector Parameter Sweep", + "", + "This is detector-only evidence. It does not invoke OCR recognition and cannot support a text-quality claim by itself.", + "", + f"- eval manifest: `{result['eval_manifest']}`", + f"- configs evaluated: {result['config_count']}", + f"- best line F1: {best['line_detection_f1']:.6f}", + f"- best precision/recall: {best['line_detection_precision']:.6f} / {best['line_detection_recall']:.6f}", + f"- best matched reading-order pair accuracy: {best['matched_line_reading_order_pair_accuracy']:.6f}", + f"- best line count: {best['line_prediction_count']} predicted / {best['line_reference_count']} reference", + f"- best config: `{json.dumps(best_config, ensure_ascii=False, sort_keys=True)}`", + f"- all results CSV: `{result['results_csv']}`", + ] + ) + + "\n", + encoding="utf-8", + ) + + +def sweep(args: argparse.Namespace) -> dict[str, Any]: + if args.iou_threshold <= 0 or args.iou_threshold > 1: + raise ValueError("--iou-threshold must be in (0, 1]") + args.out.mkdir(parents=True, exist_ok=True) + entries = load_manifest(args.eval_manifest) + if not entries: + raise ValueError(f"eval manifest is empty: {args.eval_manifest}") + configs = _config_grid(args) + if args.max_configs is not None and len(configs) > args.max_configs: + raise ValueError(f"grid has {len(configs)} configs, above --max-configs {args.max_configs}") + compare_tool = _load_compare_tool() + materializer = compare_tool._load_materializer() + rows = [ + _score_config( + config, + entries=entries, + manifest_dir=args.eval_manifest.parent, + compare_tool=compare_tool, + materializer=materializer, + iou_threshold=args.iou_threshold, + ) + for config in configs + ] + rows.sort(key=_rank_key, reverse=True) + top_rows = rows[: args.top_k] + csv_path = args.out / "detector-sweep-results.csv" + _write_csv(csv_path, rows) + result_path = args.out / "detector-sweep.json" + report_path = args.out / "README.md" + result = { + "created_at": datetime.now(timezone.utc).isoformat(), + "machine": platform.node(), + "tool": "tools/sweep_limbu_sirijonga_detector_params.py", + "eval_manifest": str(args.eval_manifest), + "eval_manifest_sha256": sha256_file(args.eval_manifest), + "sample_count": len(entries), + "config_count": len(configs), + "iou_threshold": args.iou_threshold, + "rank_order": [ + "line_detection_f1 desc", + "matched_line_reading_order_pair_accuracy desc", + "line_mean_iou desc", + "line_count_abs_error asc", + "line_match_count desc", + ], + "best": rows[0], + "top": top_rows, + "results_csv": str(csv_path), + "result_path": str(result_path), + "report_path": str(report_path), + } + result_path.write_text(json.dumps(result, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + _write_report(report_path, result) + return result + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--eval-manifest", type=Path, required=True) + parser.add_argument("--out", type=Path, required=True) + parser.add_argument("--iou-threshold", type=float, default=0.5) + parser.add_argument("--thresholds", default="otsu") + parser.add_argument("--bbox-sources", default="ink") + parser.add_argument("--reading-orders", default="top_to_bottom,column_major") + parser.add_argument("--horizontal-kernels", default="17,23,29,35,41") + parser.add_argument("--vertical-kernels", default="3,5,7,11") + parser.add_argument("--dilation-iterations", default="1") + parser.add_argument("--min-widths", default="35") + parser.add_argument("--min-heights", default="10") + parser.add_argument("--min-areas", default="50,100,200") + parser.add_argument("--max-heights", default="100,140,180,220,260") + parser.add_argument("--detector-paddings", default="2") + parser.add_argument("--top-k", type=int, default=10) + parser.add_argument("--max-configs", type=int, default=1000) + args = parser.parse_args(argv) + result = sweep(args) + best = result["best"] + print( + "wrote " + f"{result['result_path']} configs={result['config_count']} " + f"best_f1={best['line_detection_f1']:.6f} " + f"best_ro={best['matched_line_reading_order_pair_accuracy']:.6f}" + ) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ocr-tech-mps-integration/tools/sweep_page_ocr_line_pruning.py b/ocr-tech-mps-integration/tools/sweep_page_ocr_line_pruning.py new file mode 100644 index 0000000000000000000000000000000000000000..ced243220103b84347062e84635942835a1cea04 --- /dev/null +++ b/ocr-tech-mps-integration/tools/sweep_page_ocr_line_pruning.py @@ -0,0 +1,410 @@ +#!/usr/bin/env python3 +"""Sweep non-oracle OCR-line pruning thresholds for page OCR outputs. + +The sweep reuses the existing page eval and paired-comparison harness. For each +confidence threshold it filters exported page OCR `document.json` files using live +OCR line attributes, scores the filtered documents, compares against a baseline score +directory, and writes an auditable threshold summary. +""" + +from __future__ import annotations + +import argparse +import csv +import importlib.util +import json +import platform +import sys +from datetime import datetime, timezone +from pathlib import Path +from types import ModuleType +from typing import Any + +from ocrtech.manifest import sha256_file + + +def _load_sibling_tool(name: str) -> ModuleType: + path = Path(__file__).resolve().parent / f"{name}.py" + spec = importlib.util.spec_from_file_location(name, path) + if spec is None or spec.loader is None: + raise RuntimeError(f"cannot load sibling tool: {path}") + module = importlib.util.module_from_spec(spec) + sys.modules[spec.name] = module + spec.loader.exec_module(module) + return module + + +_FILTER_TOOL = _load_sibling_tool("filter_page_ocr_documents") +_AUDIT_FILTER_TOOL = _load_sibling_tool("audit_page_ocr_line_filter") +_EVAL_TOOL = _load_sibling_tool("run_page_ocr_eval") +_COMPARE_TOOL = _load_sibling_tool("compare_page_ocr_eval_runs") + + +def _read_json(path: Path) -> dict[str, Any]: + payload = json.loads(path.read_text(encoding="utf-8")) + if not isinstance(payload, dict): + raise ValueError(f"expected JSON object: {path}") + return payload + + +def _read_csv_first_row(path: Path) -> dict[str, str]: + with path.open("r", encoding="utf-8", newline="") as handle: + rows = list(csv.DictReader(handle)) + if not rows: + raise ValueError(f"CSV has no rows: {path}") + return rows[0] + + +def _parse_thresholds(value: str) -> list[float]: + thresholds: list[float] = [] + for item in value.split(","): + stripped = item.strip() + if not stripped: + continue + threshold = float(stripped) + if threshold < 0 or threshold > 1: + raise ValueError(f"threshold must be between 0 and 1: {threshold}") + thresholds.append(threshold) + if not thresholds: + raise ValueError("at least one threshold is required") + return thresholds + + +def _threshold_id(threshold: float) -> str: + return f"conf{int(round(threshold * 100)):03d}" + + +def _score_context_from_baseline(score_dir: Path) -> dict[str, Any]: + run = _read_json(score_dir / "page-eval-run.json") + first_row = _read_csv_first_row(score_dir / "page-metrics.csv") + return { + "ocr_output_kind": run.get("ocr_output_kind") or first_row.get("ocr_output_kind") or "unknown", + "system_name": run.get("system_name") or "unknown-system", + "model_name": run.get("model_name") or "", + "checkpoint": run.get("checkpoint") or "", + "config": run.get("config") or "", + "dictionary": run.get("dictionary") or "", + "language": first_row.get("language") or run.get("language") or "unknown", + "script": first_row.get("script") or run.get("script") or "unknown", + "domain": first_row.get("domain") or run.get("domain") or "unknown", + "gt_status": first_row.get("gt_status") or run.get("gt_status") or "unknown", + "eval_pack_version": run.get("eval_pack_version") or "", + "summary_file": Path(run["summary_file"]) if run.get("summary_file") else None, + "script_inventory_file": Path(run["script_inventory_file"]) if run.get("script_inventory_file") else None, + "spotcheck_calibration_file": Path(run["spotcheck_calibration_file"]) + if run.get("spotcheck_calibration_file") + else None, + "frozen_eval_pack": bool(run.get("frozen_eval_pack")), + "unseen_for_selection": bool(run.get("unseen_for_selection")), + "selected_checkpoint_on_test": bool(run.get("selected_checkpoint_on_test")), + "claim_eligible": bool(run.get("claim_eligible")), + "line_iou_threshold": float(run.get("line_iou_threshold") or 0.5), + "review_sample_size": int(run.get("review_sample_size") or 50), + } + + +def _namespace(**kwargs: Any) -> argparse.Namespace: + return argparse.Namespace(**kwargs) + + +def _metric_by_name(comparison: dict[str, Any], name: str) -> dict[str, Any]: + for metric in comparison.get("metrics", []): + if metric.get("metric") == name: + return metric + raise ValueError(f"comparison missing metric {name!r}") + + +def _score_metrics(score_dir: Path) -> dict[str, Any]: + metrics = _read_json(score_dir / "metrics.json") + return { + "text_cer_codepoint_micro": metrics.get("text_cer_codepoint_micro"), + "text_cer_grapheme_micro": metrics.get("text_cer_grapheme_micro"), + "matched_line_text_cer_codepoint_micro": (metrics.get("metric_means") or {}).get( + "matched_line_text_cer_codepoint_micro" + ), + "matched_line_text_cer_grapheme_micro": (metrics.get("metric_means") or {}).get( + "matched_line_text_cer_grapheme_micro" + ), + "line_prediction_count": (metrics.get("metric_means") or {}).get("line_prediction_count"), + "line_match_count": (metrics.get("metric_means") or {}).get("line_match_count"), + } + + +def _write_summary_tsv(path: Path, rows: list[dict[str, Any]]) -> None: + fieldnames = [ + "threshold", + "threshold_id", + "kept_line_count", + "removed_line_count", + "documents_audit_passed", + "text_cer_codepoint_micro", + "text_cer_grapheme_micro", + "codepoint_absolute_improvement", + "grapheme_absolute_improvement", + "codepoint_improvement_claim_safe", + "grapheme_improvement_claim_safe", + "comparison_claim_safe", + ] + with path.open("w", encoding="utf-8", newline="") as handle: + writer = csv.DictWriter(handle, fieldnames=fieldnames, delimiter="\t") + writer.writeheader() + for row in rows: + writer.writerow({field: row.get(field, "") for field in fieldnames}) + + +def _best_row(rows: list[dict[str, Any]], metric: str) -> dict[str, Any] | None: + valid = [row for row in rows if isinstance(row.get(metric), int | float)] + if not valid: + return None + return min(valid, key=lambda row: float(row[metric])) + + +def run_sweep(args: argparse.Namespace) -> dict[str, Any]: + thresholds = _parse_thresholds(args.thresholds) + if args.out.exists() and any(args.out.iterdir()) and not args.force: + raise FileExistsError(f"output directory exists and is not empty: {args.out}") + args.out.mkdir(parents=True, exist_ok=True) + score_context = _score_context_from_baseline(args.baseline_score_dir) + baseline_metrics = _score_metrics(args.baseline_score_dir) + rows: list[dict[str, Any]] = [] + for threshold in thresholds: + threshold_id = _threshold_id(threshold) + variant_dir = args.out / threshold_id + documents_dir = variant_dir / "documents" + score_dir = variant_dir / "score" + comparison_dir = variant_dir / "comparison" + filter_run = _FILTER_TOOL.filter_documents( + _namespace( + eval_manifest=args.eval_manifest, + documents_dir=args.documents_dir, + out=documents_dir, + drop_empty=args.drop_empty, + min_confidence=threshold, + require_script=args.require_script, + script_ratio_threshold=args.script_ratio_threshold, + min_height=args.min_height, + max_height=args.max_height, + min_width=args.min_width, + max_width=args.max_width, + min_width_ratio=args.min_width_ratio, + max_width_ratio=args.max_width_ratio, + min_height_ratio=args.min_height_ratio, + max_height_ratio=args.max_height_ratio, + ) + ) + filter_audit = _AUDIT_FILTER_TOOL.audit_filter_output(documents_dir) + _EVAL_TOOL.run_eval( + _namespace( + eval_manifest=args.eval_manifest, + documents_dir=documents_dir, + ocr_output_kind=score_context["ocr_output_kind"], + out=score_dir, + summary_file=score_context["summary_file"], + script_inventory_file=score_context["script_inventory_file"], + spotcheck_calibration_file=score_context["spotcheck_calibration_file"], + train_manifest=[], + system_name=f"{score_context['system_name']}-prune-{threshold_id}", + model_name=score_context["model_name"], + checkpoint=score_context["checkpoint"], + config=score_context["config"], + dictionary=score_context["dictionary"], + language=score_context["language"], + script=score_context["script"], + domain=score_context["domain"], + gt_status=score_context["gt_status"], + eval_pack_version=score_context["eval_pack_version"], + frozen_eval_pack=score_context["frozen_eval_pack"], + unseen_for_selection=score_context["unseen_for_selection"], + selected_checkpoint_on_test=score_context["selected_checkpoint_on_test"], + claim_eligible=score_context["claim_eligible"], + line_iou_threshold=score_context["line_iou_threshold"], + review_sample_size=score_context["review_sample_size"], + require_claim_safe=False, + force=True, + ) + ) + comparison = _COMPARE_TOOL.run_comparison( + _namespace( + baseline_score_dir=args.baseline_score_dir, + candidate_score_dir=score_dir, + baseline_name=args.baseline_name, + candidate_name=f"{args.candidate_prefix}-{threshold_id}", + out=comparison_dir, + bootstrap_samples=args.bootstrap_samples, + bootstrap_confidence=args.bootstrap_confidence, + bootstrap_seed=args.bootstrap_seed, + alpha=args.alpha, + min_pairs=args.min_pairs, + require_claim_safe=False, + force=True, + ) + ) + score_metrics = _score_metrics(score_dir) + codepoint = _metric_by_name(comparison, "text_codepoint_cer") + grapheme = _metric_by_name(comparison, "text_grapheme_cer") + rows.append( + { + "threshold": threshold, + "threshold_id": threshold_id, + "documents_dir": str(documents_dir), + "documents_filter_run_sha256": sha256_file(documents_dir / "ocr-line-filter-run.json"), + "documents_line_report_sha256": sha256_file(documents_dir / "ocr-line-filter-lines.jsonl"), + "documents_audit_passed": filter_audit["passed"], + "documents_audit_sha256": sha256_file(documents_dir / "ocr-line-filter-audit.json"), + "score_dir": str(score_dir), + "metrics_sha256": sha256_file(score_dir / "metrics.json"), + "page_eval_run_sha256": sha256_file(score_dir / "page-eval-run.json"), + "comparison_dir": str(comparison_dir), + "comparison_sha256": sha256_file(comparison_dir / "comparison.json"), + "kept_line_count": filter_run["kept_line_count"], + "removed_line_count": filter_run["removed_line_count"], + "removal_counts": filter_run["removal_counts"], + "comparison_claim_safe": comparison["claim_safe"], + "comparison_warnings": comparison.get("warnings", []), + "text_cer_codepoint_micro": score_metrics["text_cer_codepoint_micro"], + "text_cer_grapheme_micro": score_metrics["text_cer_grapheme_micro"], + "matched_line_text_cer_codepoint_micro": score_metrics["matched_line_text_cer_codepoint_micro"], + "matched_line_text_cer_grapheme_micro": score_metrics["matched_line_text_cer_grapheme_micro"], + "codepoint_absolute_improvement": codepoint["absolute_improvement"], + "codepoint_relative_improvement": codepoint["relative_improvement"], + "codepoint_improvement_claim_safe": codepoint["improvement_claim_safe"], + "codepoint_warnings": codepoint.get("warnings", []), + "grapheme_absolute_improvement": grapheme["absolute_improvement"], + "grapheme_relative_improvement": grapheme["relative_improvement"], + "grapheme_improvement_claim_safe": grapheme["improvement_claim_safe"], + "grapheme_warnings": grapheme.get("warnings", []), + } + ) + best_codepoint = _best_row(rows, "text_cer_codepoint_micro") + best_grapheme = _best_row(rows, "text_cer_grapheme_micro") + result = { + "created_at": datetime.now(timezone.utc).isoformat(), + "machine": platform.node(), + "tool": "tools/sweep_page_ocr_line_pruning.py", + "eval_manifest": str(args.eval_manifest), + "eval_manifest_sha256": sha256_file(args.eval_manifest), + "source_documents_dir": str(args.documents_dir), + "baseline_score_dir": str(args.baseline_score_dir), + "baseline_metrics": baseline_metrics, + "out": str(args.out), + "filter": { + "drop_empty": args.drop_empty, + "require_script": args.require_script, + "script_ratio_threshold": args.script_ratio_threshold, + "min_height": args.min_height, + "max_height": args.max_height, + "min_width": args.min_width, + "max_width": args.max_width, + "min_width_ratio": args.min_width_ratio, + "max_width_ratio": args.max_width_ratio, + "min_height_ratio": args.min_height_ratio, + "max_height_ratio": args.max_height_ratio, + }, + "thresholds": thresholds, + "candidate_count": len(rows), + "best_codepoint_threshold": best_codepoint["threshold"] if best_codepoint else None, + "best_codepoint_text_cer": best_codepoint["text_cer_codepoint_micro"] if best_codepoint else None, + "best_codepoint_absolute_improvement": best_codepoint["codepoint_absolute_improvement"] if best_codepoint else None, + "best_grapheme_threshold": best_grapheme["threshold"] if best_grapheme else None, + "best_grapheme_text_cer": best_grapheme["text_cer_grapheme_micro"] if best_grapheme else None, + "claim_safe": False, + "claim_boundary": "threshold sweep over existing draft page-eval outputs; use for admission diagnostics only unless the baseline and comparisons are claim-safe", + "candidates": rows, + } + result_path = args.out / "ocr-line-pruning-sweep.json" + result["result_path"] = str(result_path) + summary_path = args.out / "ocr-line-pruning-sweep.tsv" + result["summary_tsv"] = str(summary_path) + report_path = args.out / "README.md" + result["report_path"] = str(report_path) + _write_summary_tsv(summary_path, rows) + result_path.write_text(json.dumps(result, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8") + report_path.write_text(_render_report(result), encoding="utf-8") + return result + + +def _fmt(value: Any) -> str: + if isinstance(value, float): + return f"{value:.6f}" + return str(value) + + +def _render_report(result: dict[str, Any]) -> str: + lines = [ + "# OCR-Line Pruning Sweep", + "", + f"- source documents: `{result['source_documents_dir']}`", + f"- baseline score dir: `{result['baseline_score_dir']}`", + f"- candidate count: {result['candidate_count']}", + f"- best codepoint threshold: {result['best_codepoint_threshold']} ({_fmt(result['best_codepoint_text_cer'])})", + f"- best grapheme threshold: {result['best_grapheme_threshold']} ({_fmt(result['best_grapheme_text_cer'])})", + f"- claim safe: {result['claim_safe']}", + "", + "| threshold | kept | removed | cp CER | cp improvement | graph CER | graph improvement | safe |", + "| ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- |", + ] + for row in result["candidates"]: + lines.append( + "| {threshold:.2f} | {kept} | {removed} | {cp} | {cp_imp} | {graph} | {graph_imp} | {safe} |".format( + threshold=row["threshold"], + kept=row["kept_line_count"], + removed=row["removed_line_count"], + cp=_fmt(row["text_cer_codepoint_micro"]), + cp_imp=_fmt(row["codepoint_absolute_improvement"]), + graph=_fmt(row["text_cer_grapheme_micro"]), + graph_imp=_fmt(row["grapheme_absolute_improvement"]), + safe=row["comparison_claim_safe"], + ) + ) + lines.extend( + [ + "", + "This sweep uses live OCR line attributes only. It does not inspect reference text or reference boxes while filtering.", + "", + ] + ) + return "\n".join(lines) + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--eval-manifest", type=Path, required=True) + parser.add_argument("--documents-dir", type=Path, required=True) + parser.add_argument("--baseline-score-dir", type=Path, required=True) + parser.add_argument("--out", type=Path, required=True) + parser.add_argument("--thresholds", required=True, help="Comma-separated confidence thresholds, e.g. 0.5,0.7,0.85") + parser.add_argument("--baseline-name", default="baseline") + parser.add_argument("--candidate-prefix", default="candidate") + parser.add_argument("--drop-empty", action="store_true") + parser.add_argument( + "--require-script", + choices=["any", "sirijonga", "devanagari", "limbu_or_devanagari"], + default="any", + ) + parser.add_argument("--script-ratio-threshold", type=float, default=0.20) + parser.add_argument("--min-height", type=float) + parser.add_argument("--max-height", type=float) + parser.add_argument("--min-width", type=float) + parser.add_argument("--max-width", type=float) + parser.add_argument("--min-width-ratio", type=float) + parser.add_argument("--max-width-ratio", type=float) + parser.add_argument("--min-height-ratio", type=float) + parser.add_argument("--max-height-ratio", type=float) + parser.add_argument("--bootstrap-samples", type=int, default=1000) + parser.add_argument("--bootstrap-confidence", type=float, default=0.95) + parser.add_argument("--bootstrap-seed", type=int, default=271828) + parser.add_argument("--alpha", type=float, default=0.05) + parser.add_argument("--min-pairs", type=int, default=30) + parser.add_argument("--force", action="store_true") + args = parser.parse_args(argv) + result = run_sweep(args) + print( + f"wrote {result['out']} candidates={result['candidate_count']} " + f"best_cp_threshold={result['best_codepoint_threshold']} " + f"best_cp_CER={result['best_codepoint_text_cer']:.6f}" + ) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ocr-tech-mps-integration/tools/synthesize_script_corpus.py b/ocr-tech-mps-integration/tools/synthesize_script_corpus.py new file mode 100644 index 0000000000000000000000000000000000000000..7e225692d4b2c73aa4ca083f576df49ff9c203b1 --- /dev/null +++ b/ocr-tech-mps-integration/tools/synthesize_script_corpus.py @@ -0,0 +1,613 @@ +#!/usr/bin/env python3 +"""Synthesize a PaddleOCR recognizer training corpus for a Unicode-encoded script. + +The novel Nepal/Himalayan scripts (Kirat Rai, Sunuwar, Lepcha, Tirhuta, Newa) +have no usable real-text corpus, so training data is synthesized: structurally +valid character sequences are rendered to line images through HarfBuzz/libraqm +shaping (mandatory for correct Brahmic combining-mark placement) and written in +PaddleOCR recognition-label format (``relative_image_pathlabel``). + +Text is generated generically from the recognizer dictionary, classifying each +codepoint by its Unicode general category: + +* base letters (L*) -> start every syllable +* combining marks (Mn/Mc) -> optional vowel-sign / diacritic on a base +* digits (Nd) -> occasional numeric tokens +* punctuation (P*) -> occasional sentence punctuation + +A combining mark never appears without a preceding base, so raqm never emits a +dotted-circle placeholder. Validation data is sourced separately (real pages); +this corpus teaches the glyph -> Unicode mapping, which is the core OCR task. +""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import random +import sys +import unicodedata +from dataclasses import dataclass, field +from pathlib import Path + +try: + from PIL import Image, ImageDraw, ImageEnhance, ImageFilter, ImageFont, features +except ImportError as exc: # pragma: no cover - environment guard + raise SystemExit(f"Pillow is required: {exc}") + +try: + import albumentations as _alb + import cv2 as _cv2 + import numpy as _np + + _HAS_ALBUMENTATIONS = True +except ImportError: # pragma: no cover - optional dependency + _HAS_ALBUMENTATIONS = False + +try: + import augraphy as _aug + + _HAS_AUGRAPHY = True +except ImportError: # pragma: no cover - optional dependency + _HAS_AUGRAPHY = False + + +class ShapeChecker: + """Validate that a string shapes without dotted-circle / .notdef glyphs. + + HarfBuzz (the engine Pillow's raqm layout wraps) inserts U+25CC when a combining + sequence is defective; that placeholder glyph is not in our label, so any line + that produces it must be rejected to keep (image, label) pairs faithful. Lines + are validated against every render font so whichever is picked shapes cleanly. + """ + + def __init__(self, font_path: Path): + import uharfbuzz as hb # local import: optional dependency + from fontTools.ttLib import TTFont + + self._hb = hb + data = Path(font_path).read_bytes() + self._font = hb.Font(hb.Face(data)) + tt = TTFont(str(font_path)) + cmap = tt.getBestCmap() + order = tt.getGlyphOrder() + self._bad: set[int] = {0} # .notdef + if 0x25CC in cmap: # the font's own dotted-circle glyph + self._bad.add(order.index(cmap[0x25CC])) + + def is_clean(self, text: str) -> bool: + buf = self._hb.Buffer() + buf.add_str(text) + buf.guess_segment_properties() + self._hb.shape(self._font, buf, {}) + return all(info.codepoint not in self._bad for info in buf.glyph_infos) + + +def build_checkers(font_paths: list[Path]) -> list[ShapeChecker]: + try: + return [ShapeChecker(fp) for fp in font_paths] + except ImportError: + print(" WARN uharfbuzz unavailable — skipping shaping validation", file=sys.stderr) + return [] + + +@dataclass +class DictClasses: + """Recognizer-dictionary codepoints grouped by role in syllable formation.""" + + bases: list[str] = field(default_factory=list) + marks: list[str] = field(default_factory=list) + digits: list[str] = field(default_factory=list) + puncts: list[str] = field(default_factory=list) + + def validate(self) -> None: + if not self.bases: + raise ValueError("dictionary contains no base letters (category L*) — cannot synthesize text") + + +def classify_dictionary(dict_path: Path) -> DictClasses: + """Split a one-character-per-line recognizer dict by Unicode general category.""" + + classes = DictClasses() + for raw in dict_path.read_text(encoding="utf-8").splitlines(): + if raw == "": + continue + ch = raw + if len(ch) != 1: + # Defensive: dict files are one codepoint per line; skip anything else loudly. + print(f" WARN skipping multi-codepoint dict entry {ch!r}", file=sys.stderr) + continue + cat = unicodedata.category(ch) + if cat in ("Mn", "Mc"): + classes.marks.append(ch) + elif cat[0] == "L": + classes.bases.append(ch) + elif cat[0] == "N": + classes.digits.append(ch) + else: + classes.puncts.append(ch) + classes.validate() + return classes + + +def make_syllable(rng: random.Random, dc: DictClasses, mark_prob: float) -> str: + """A base letter with at most ONE optional combining mark. + + A single combining mark on a base consonant is a valid USE cluster across these + abugidas, so HarfBuzz/raqm never emits a U+25CC dotted-circle placeholder. Two + stacked marks can form an invalid sequence whose dotted-circle glyph would not + appear in the label — corrupting the (image, label) pair — so we never stack two. + """ + + syll = rng.choice(dc.bases) + if dc.marks and rng.random() < mark_prob: + syll += rng.choice(dc.marks) + return syll + + +def make_word(rng: random.Random, dc: DictClasses, mark_prob: float) -> str: + n = rng.randint(1, 5) + return "".join(make_syllable(rng, dc, mark_prob) for _ in range(n)) + + +def make_line(rng: random.Random, dc: DictClasses, mark_prob: float) -> str: + """A newspaper-length line (~25-45 chars) of space-separated words.""" + + target = rng.randint(22, 46) + parts: list[str] = [] + total = 0 + while total < target: + if dc.digits and rng.random() < 0.06: + token = "".join(rng.choice(dc.digits) for _ in range(rng.randint(1, 4))) + else: + token = make_word(rng, dc, mark_prob) + parts.append(token) + total += len(token) + 1 + line = " ".join(parts) + if dc.puncts and rng.random() < 0.45: + line += rng.choice(dc.puncts) + return unicodedata.normalize("NFC", line) + + +# --- rendering ------------------------------------------------------------- + +DEGRADATIONS = ["clean", "clean", "scan", "low_light", "bright_uneven", "rotate"] + + +def _layout_engine(): + if features.check("raqm"): + return ImageFont.Layout.RAQM + print(" WARN libraqm not available — complex-script shaping will be WRONG", file=sys.stderr) + return ImageFont.Layout.BASIC + + +def degrade(img: "Image.Image", profile: str, rng: random.Random) -> "Image.Image": + if profile == "clean": + return img + if profile == "scan": + img = img.filter(ImageFilter.GaussianBlur(radius=rng.uniform(0.4, 1.1))) + return ImageEnhance.Contrast(img).enhance(rng.uniform(0.8, 0.95)) + if profile == "low_light": + return ImageEnhance.Brightness(img).enhance(rng.uniform(0.55, 0.8)) + if profile == "bright_uneven": + w, h = img.size + grad = Image.new("L", (w, h), 0) + gd = ImageDraw.Draw(grad) + x0 = rng.randint(0, w) + for x in range(w): + gd.line([(x, 0), (x, h)], fill=int(60 * abs(x - x0) / max(w, 1))) + white = Image.new("RGB", (w, h), "white") + return Image.composite(white, img, grad) + if profile == "rotate": + return img.rotate(rng.uniform(-2.5, 2.5), expand=True, fillcolor="white", resample=Image.BICUBIC) + return img + + +def build_augmenter(): + """Rich render-time augmentation targeting the synthetic->real gap. + + Deliberately adds what PaddleOCR's per-batch RecAug does NOT: random affine + (rotation/shear/scale/translate), morphological stroke-weight (ink bleed / + thin print), JPEG + downscale resolution loss, and paper-like lighting. These + stack with RecAug's per-epoch perspective/blur/noise/jitter, so each crop the + model sees is geometrically and photometrically varied like a real newspaper + scan. Returns None if albumentations is unavailable (caller falls back). + """ + if not _HAS_ALBUMENTATIONS: + return None + A = _alb + # Tuned MODERATE: enough geometric/photometric variety to help real-world + # robustness, but never so extreme it renders a crop illegible (which corrupts + # the (image,label) pair and degrades learning). An earlier aggressive version + # — Downscale 0.5, JPEG q32, stacked elastic/grid/perspective — slowed + # from-scratch convergence and degraded warm-started models, so it was dialed back. + return A.Compose( + [ + A.Affine( + rotate=(-3, 3), + shear={"x": (-4, 4), "y": (-1, 1)}, + scale=(0.93, 1.07), + translate_percent=(0.0, 0.012), + fill=255, + border_mode=_cv2.BORDER_CONSTANT, + p=0.8, + ), + A.Perspective(scale=(0.02, 0.04), fill=255, p=0.25), + A.OneOf( + [ + A.Morphological(scale=(1, 2), operation="dilation"), + A.Morphological(scale=(1, 2), operation="erosion"), + ], + p=0.3, + ), + A.OneOf([A.GaussianBlur(blur_limit=(3, 3)), A.MotionBlur(blur_limit=3)], p=0.3), + A.OneOf([A.GaussNoise(), A.ISONoise()], p=0.3), + A.RandomBrightnessContrast(brightness_limit=0.18, contrast_limit=0.18, p=0.4), + A.ImageCompression(quality_range=(55, 92), p=0.3), + ] + ) + + +def build_handwriting_augmenter(): + """Strong, handwriting-like augmentation. + + Two jobs: (1) simulate the irregularity of a written hand (non-rigid warps, + slant, variable stroke), and (2) for FONT-POOR scripts — the minority scripts + where only one Unicode typeface exists — manufacture the visual diversity that + extra fonts would otherwise provide: faux weight (morphological dilation/erosion), + faux slant (shear), and elastic/grid warps that change letter shapes per sample. + """ + if not _HAS_ALBUMENTATIONS: + return None + A = _alb + return A.Compose( + [ + A.Affine( + rotate=(-5, 5), + shear={"x": (-16, 16), "y": (-3, 3)}, + scale=(0.85, 1.15), + translate_percent=(0.0, 0.02), + fill=255, + border_mode=_cv2.BORDER_CONSTANT, + p=0.95, + ), + A.OneOf( + [ + A.ElasticTransform(alpha=40, sigma=5), + A.GridDistortion(num_steps=5, distort_limit=0.3), + ], + p=0.7, + ), + A.OneOf( + [ + A.Morphological(scale=(1, 3), operation="dilation"), # heavy pen / faux-bold + A.Morphological(scale=(1, 2), operation="erosion"), # light pen / faux-thin + ], + p=0.6, + ), + A.Perspective(scale=(0.02, 0.06), fill=255, p=0.3), + A.OneOf([A.GaussianBlur(blur_limit=(3, 5)), A.MotionBlur(blur_limit=5)], p=0.4), + A.OneOf([A.GaussNoise(), A.ISONoise()], p=0.4), + A.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=0.5), + A.ImageCompression(quality_range=(40, 90), p=0.3), + ] + ) + + +def _paper_background(w: int, h: int, rng: random.Random) -> "Image.Image": + """Procedural paper-like background: off-white base, occasional aged tint, grain.""" + base = rng.randint(236, 255) + if rng.random() < 0.4: # warm / aged (sepia-ish) sometimes + r, g, b = base, max(0, base - rng.randint(0, 14)), max(0, base - rng.randint(4, 26)) + else: + r = g = b = base + arr = _np.full((h, w, 3), (r, g, b), dtype=_np.uint8) + if rng.random() < 0.7: # paper grain + noise = _np.random.normal(0, rng.uniform(2, 9), (h, w, 1)).astype(_np.int16) + arr = _np.clip(arr.astype(_np.int16) + noise, 0, 255).astype(_np.uint8) + return Image.fromarray(arr) + + +def build_augraphy_pipeline(profile: str): + """Document-realistic degradation profiles (Augraphy). Returns a pipeline or None. + + Deployment-matched conditions a recognizer actually meets: + scan — photocopier/scanner: ink bleed, drum/dither marks, subtle noise, JPEG + photo — phone photo of a page: lighting gradient, glare/shadow, brightness, JPEG + aged — old document: paper texture, bleed-through, faded low-ink lines, folds + """ + if not _HAS_AUGRAPHY or profile in (None, "clean"): + return None + A = _aug + if profile == "scan": + return A.AugraphyPipeline( + ink_phase=[A.InkBleed(p=0.4)], + paper_phase=[A.NoiseTexturize(p=0.4)], + post_phase=[A.DirtyDrum(p=0.3), A.Dithering(p=0.2), A.SubtleNoise(p=0.5), A.Jpeg(p=0.5)], + ) + if profile == "photo": + return A.AugraphyPipeline( + ink_phase=[A.InkBleed(p=0.3)], + paper_phase=[], + post_phase=[A.LightingGradient(p=0.6), A.ShadowCast(p=0.4), A.Brightness(p=0.5), A.Jpeg(p=0.6)], + ) + if profile == "aged": + return A.AugraphyPipeline( + ink_phase=[A.InkBleed(p=0.5), A.LowInkRandomLines(p=0.4), A.Letterpress(p=0.3)], + paper_phase=[A.NoiseTexturize(p=0.5), A.BleedThrough(p=0.5), A.ColorPaper(p=0.3)], + post_phase=[A.Folding(p=0.4), A.Brightness(p=0.4), A.SubtleNoise(p=0.4)], + ) + return None + + +def apply_augraphy(img: "Image.Image", pipe, rng: random.Random, prob: float) -> "Image.Image": + """Apply a document-degradation pipeline to a fraction of crops (keeps it fast + mixed).""" + if pipe is None or rng.random() >= prob: + return img + arr = _np.asarray(img.convert("RGB")) + try: + out = pipe(arr) + except Exception: # one degradation failure must not kill the render + return img + out = out if isinstance(out, _np.ndarray) else out.get("output", arr) + if out.ndim == 2: + out = _cv2.cvtColor(out, _cv2.COLOR_GRAY2RGB) + return Image.fromarray(out) + + +def apply_augment(img: "Image.Image", augmenter, rng: random.Random, clean_prob: float) -> "Image.Image": + """Apply the albumentations augmenter, keeping a clean fraction untouched.""" + if augmenter is None or rng.random() < clean_prob: + return img + arr = _np.asarray(img.convert("RGB")) + out = augmenter(image=arr)["image"] + return Image.fromarray(out) + + +def render_line( + text: str, + font: "ImageFont.FreeTypeFont", + rng: random.Random, + augmenter=None, + clean_prob: float = 0.15, + padding: int = 18, + bg_prob: float = 0.0, + augraphy_pipes=None, + augraphy_prob: float = 0.0, +) -> "Image.Image": + probe = Image.new("RGB", (8, 8), "white") + bbox = ImageDraw.Draw(probe).textbbox((0, 0), text, font=font) + w = max(bbox[2] - bbox[0], 1) + h = max(bbox[3] - bbox[1], 1) + img = Image.new("RGB", (w + 2 * padding, h + 2 * padding), "white") + # occasionally use a dark ink colour rather than pure black (pen/print variety) + ink = (0, 0, 0) if rng.random() > 0.25 else tuple(rng.randint(0, 55) for _ in range(3)) + ImageDraw.Draw(img).text((padding - bbox[0], padding - bbox[1]), text, font=font, fill=ink) + # composite onto a paper-like background (text-on-white multiply-blended onto paper) + if bg_prob and _HAS_ALBUMENTATIONS and rng.random() < bg_prob: + bg = _paper_background(img.width, img.height, rng) + img = Image.fromarray( + (_np.asarray(bg).astype(_np.float32) * (_np.asarray(img).astype(_np.float32) / 255.0)).astype(_np.uint8) + ) + # geometric/photometric augmentation (albumentations) or the lightweight fallback + if augmenter is not None: + img = apply_augment(img, augmenter, rng, clean_prob) + else: + img = degrade(img, rng.choice(DEGRADATIONS), rng) + # document-realistic degradation (Augraphy) on a fraction of crops + if augraphy_pipes: + img = apply_augraphy(img, rng.choice(augraphy_pipes), rng, augraphy_prob) + return img + + +def load_fonts(font_paths: list[Path], font_size: int) -> list["ImageFont.FreeTypeFont"]: + engine = _layout_engine() + fonts = [] + for fp in font_paths: + if not fp.exists(): + raise FileNotFoundError(f"font not found: {fp}") + fonts.append(ImageFont.truetype(str(fp), font_size, layout_engine=engine)) + if not fonts: + raise ValueError("no fonts provided") + return fonts + + +def _load_text_lines(path: Path, dc: "DictClasses", checkers: list, mark_unused: bool = True) -> tuple[list[str], int]: + """Load real text lines from a file: NFC, dedup, shaping-checked, non-empty.""" + seen: set[str] = set() + out: list[str] = [] + rejected = 0 + for raw in path.read_text(encoding="utf-8").splitlines(): + line = unicodedata.normalize("NFC", raw.strip()) + if not line or line in seen: + continue + if checkers and not all(c.is_clean(line) for c in checkers): + rejected += 1 + continue + seen.add(line) + out.append(line) + return out, rejected + + +def synthesize( + *, + script: str, + dict_path: Path, + font_paths: list[Path], + out_dir: Path, + n_train: int, + n_eval: int, + font_size: int, + mark_prob: float, + seed: int, + text_file: Path | None = None, + aug_per_line: int = 1, + use_augment: bool = True, + clean_prob: float = 0.15, + style: str = "print", + bg_prob: float = 0.0, + augraphy: str = "off", + augraphy_prob: float = 0.0, +) -> dict: + rng = random.Random(seed) + if use_augment and _HAS_ALBUMENTATIONS: + _np.random.seed(seed) # make albumentations' internal randomness reproducible + dc = classify_dictionary(dict_path) + fonts = load_fonts(font_paths, font_size) + checkers = build_checkers(font_paths) + if not use_augment: + augmenter = None + elif style == "handwriting": + augmenter = build_handwriting_augmenter() + else: + augmenter = build_augmenter() + # document-realistic degradation profiles (Augraphy) + if augraphy == "mixed": + augraphy_pipes = [build_augraphy_pipeline(p) for p in ("scan", "photo", "aged")] + elif augraphy not in ("off", "", None): + augraphy_pipes = [build_augraphy_pipeline(augraphy)] + else: + augraphy_pipes = [] + augraphy_pipes = [p for p in augraphy_pipes if p is not None] + + images_dir = out_dir / "images" + images_dir.mkdir(parents=True, exist_ok=True) + + seen: set[str] = set() + texts: list[str] = [] + rejected = 0 + if text_file is not None: + # Render REAL text (e.g. Sikkim Herald / Limbu prose) instead of generating. + texts, rejected = _load_text_lines(text_file, dc, checkers) + rng.shuffle(texts) + text_source = str(text_file) + else: + # Generate de-duplicated structurally-valid text (leakage-safe by line). + target_total = n_train + n_eval + attempts = 0 + while len(texts) < target_total and attempts < target_total * 40: + attempts += 1 + line = make_line(rng, dc, mark_prob) + if line in seen or not line.strip(): + continue + if checkers and not all(c.is_clean(line) for c in checkers): + rejected += 1 + continue + seen.add(line) + texts.append(line) + if len(texts) < target_total: + print(f" WARN only {len(texts)} unique lines generated (wanted {target_total})", file=sys.stderr) + rng.shuffle(texts) + text_source = "generated" + + # Hold out eval by LINE (no text leakage); the rest train, each rendered aug_per_line times. + n_eval_eff = min(n_eval, max(0, len(texts) // 5)) if text_file is not None else n_eval + eval_texts = texts[:n_eval_eff] + train_texts = texts[n_eval_eff:] if text_file is not None else texts[n_eval_eff : n_eval_eff + n_train] + + def emit(split: str, lines: list[str], reps: int, bg: float, augra: float) -> int: + label_path = out_dir / f"{split}.txt" + count = 0 + with label_path.open("w", encoding="utf-8") as lf: + for i, text in enumerate(lines): + for r in range(reps): + font = rng.choice(fonts) + try: + img = render_line( + text, font, rng, augmenter=augmenter, clean_prob=clean_prob, bg_prob=bg, + augraphy_pipes=augraphy_pipes, augraphy_prob=augra, + ) + except Exception as exc: # one bad line must not kill the run + print(f" WARN render failed for {split} line {i} rep {r}: {exc}", file=sys.stderr) + continue + name = f"{script}_{split}_{i:06d}_{r}.png" + rel = f"images/{name}" + img.save(images_dir / name) + lf.write(f"{rel}\t{text}\n") + count += 1 + return count + + # Eval is rendered mostly clean (measure on clean held-out); train gets full aug x multiplicity. + n_tr = emit("train", train_texts, aug_per_line, bg_prob, augraphy_prob) + n_ev = emit("eval", eval_texts, 1, 0.0, 0.0) + + summary = { + "script": script, + "dict_path": str(dict_path), + "dict_chars": len(dc.bases) + len(dc.marks) + len(dc.digits) + len(dc.puncts), + "bases": len(dc.bases), + "marks": len(dc.marks), + "digits": len(dc.digits), + "puncts": len(dc.puncts), + "fonts": [str(p) for p in font_paths], + "font_size": font_size, + "mark_prob": mark_prob, + "seed": seed, + "text_source": text_source, + "aug_per_line": aug_per_line, + "style": style, + "augmentation": ("handwriting" if style == "handwriting" else "rich_albumentations") if augmenter is not None else "simple_fallback", + "background_prob": bg_prob, + "augraphy": augraphy if augraphy_pipes else "off", + "augraphy_prob": augraphy_prob if augraphy_pipes else 0.0, + "clean_prob": clean_prob, + "train_images": n_tr, + "eval_images": n_ev, + "unique_train_lines": len(train_texts), + "unique_eval_lines": len(eval_texts), + "lines_rejected_by_shaping": rejected, + "shaping_validated": bool(checkers), + "raqm": bool(features.check("raqm")), + "sample_lines": train_texts[:5], + } + (out_dir / "summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8") + return summary + + +def main(argv: list[str] | None = None) -> int: + p = argparse.ArgumentParser(description=__doc__) + p.add_argument("--script", required=True, help="script id (e.g. kiratrai, sunuwar, lepcha)") + p.add_argument("--dict", required=True, type=Path, help="recognizer dictionary (one char per line)") + p.add_argument("--font", required=True, type=Path, action="append", help="font TTF/OTF (repeatable for diversity)") + p.add_argument("--out", required=True, type=Path, help="output corpus directory") + p.add_argument("--n-train", type=int, default=7000) + p.add_argument("--n-eval", type=int, default=900) + p.add_argument("--font-size", type=int, default=38) + p.add_argument("--mark-prob", type=float, default=0.6, help="P(attach a combining mark) for abugidas; ignored if no marks") + p.add_argument("--seed", type=int, default=13) + p.add_argument("--text-file", type=Path, default=None, help="render REAL text lines from this file instead of generating") + p.add_argument("--aug-per-line", type=int, default=1, help="render each train line N times with different augmentation") + p.add_argument("--no-augment", action="store_true", help="disable rich albumentations augmentation (use simple profiles)") + p.add_argument("--clean-prob", type=float, default=0.15, help="fraction of train crops left un-augmented") + p.add_argument("--style", choices=["print", "handwriting"], default="print", help="augmentation style; handwriting = strong elastic/slant/stroke (manufactures visual diversity for font-poor scripts)") + p.add_argument("--bg-prob", type=float, default=0.0, help="fraction of train crops composited onto a paper-like background") + p.add_argument("--augraphy", choices=["off", "scan", "photo", "aged", "mixed"], default="off", help="document-realistic degradation profile (Augraphy); 'mixed' picks scan/photo/aged per crop") + p.add_argument("--augraphy-prob", type=float, default=0.5, help="fraction of train crops that get an Augraphy degradation pass") + args = p.parse_args(argv) + + summary = synthesize( + script=args.script, + dict_path=args.dict, + font_paths=args.font, + out_dir=args.out, + n_train=args.n_train, + n_eval=args.n_eval, + font_size=args.font_size, + mark_prob=args.mark_prob, + seed=args.seed, + style=args.style, + bg_prob=args.bg_prob, + augraphy=args.augraphy, + augraphy_prob=args.augraphy_prob, + text_file=args.text_file, + aug_per_line=args.aug_per_line, + use_augment=not args.no_augment, + clean_prob=args.clean_prob, + ) + print(json.dumps(summary, ensure_ascii=False, indent=2)) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ocr-tech-mps-integration/tools/tirhuta_translit_build.py b/ocr-tech-mps-integration/tools/tirhuta_translit_build.py new file mode 100644 index 0000000000000000000000000000000000000000..b54ca6b56dd21e072ae72c2220f4a082f4dd1e4d --- /dev/null +++ b/ocr-tech-mps-integration/tools/tirhuta_translit_build.py @@ -0,0 +1,410 @@ +#!/usr/bin/env python3 +"""Transliterate Devanagari Maithili corpora -> Tirhuta (U+11480) at scale. + +Maithili is written mostly in Devanagari today, but Tirhuta is its historical +native script. Aksharamukha transliterates Devanagari -> Tirhuta faithfully, so +real Devanagari Maithili text becomes real-shaped Tirhuta text. This is the same +lever that took Newa to 468k real lines (see tools/newa_translit_build.py). + +Sources (Devanagari Maithili): + * Maithili Wikipedia dump, stripped to Devanagari sentences + (data/leipzig-maithili/maiwiki-dump-devanagari.txt via tools/strip_maiwiki_dump.py). + * Leipzig Corpora Collection Maithili ("mai") editions, e.g. + mai_wikipedia_2021_10K -sentences.txt. + +Aksharamukha's pip package breaks on this repo's Python 3.14 (`ast.Str` +removed), so transliteration runs in a Python 3.10 sidecar venv (/tmp/aksh310). +This orchestrator (run with the repo venv) shells out to that sidecar for the +actual transliteration; everything else (dedup, verification, NFC, splitting) +runs in the main interpreter. + +IMPORTANT Tirhuta vs Newa difference: + * Newa has its own danda (U+1144B/C). Tirhuta does NOT — Aksharamukha leaves + the sentence terminator as the DEVANAGARI DANDA (U+0964) / DOUBLE DANDA + (U+0965). So the "leftover Devanagari => drop" check must IGNORE the danda + pair; otherwise every sentence-final danda would falsely flag a line. + * Tirhuta has its own digits (U+114D0..U+114D9), inside the block, which count + as Tirhuta characters. + +Pipeline: + 1. Collect Devanagari sentences from Leipzig -sentences.txt files + extra + plain-text Devanagari files, NFC-normalize, whitespace-collapse, dedupe. + 2. Transliterate Devanagari -> Tirhuta via the sidecar (newline-batched). + 3. NFC-normalize, verify each line carries >= min_tirhuta chars in + U+11480..U+114DF, drop lines with leftover *non-danda* Devanagari, drop + other-Indic-script residue and Latin-heavy markup residue. + 4. Split long lines (> max_chars) on sentence punctuation into OCR-sized + sub-lines; dedupe again (and against any --exclude file). + 5. Write the output Tirhuta file and report counts + block coverage. + +Honest provenance: this is a faithful SCRIPT CONVERSION of real Maithili text +(Devanagari -> Tirhuta). It is transliterated, not natively-typed Tirhuta. +""" +from __future__ import annotations + +import argparse +import glob +import os +import re +import subprocess +import sys +import tempfile +import unicodedata +from pathlib import Path + +TIRHUTA_LO = 0x11480 +TIRHUTA_HI = 0x114DF +DEVA_LO = 0x0900 +DEVA_HI = 0x097F +# Danda / double danda are shared by Tirhuta (it has no danda of its own), so +# they are legitimate output, NOT "leftover Devanagari". +DEVA_DANDA = 0x0964 +DEVA_DOUBLE_DANDA = 0x0965 + +# Sentence terminators used as split points for long lines: +# U+0964 DANDA, U+0965 DOUBLE DANDA (Tirhuta uses these), U+114C6 TIRHUTA +# ABBREVIATION SIGN, plus ASCII . ! ? and newline. +SPLIT_CHARS = "।॥\U000114C6.!?\n" +_SPLIT_RE = re.compile("[" + re.escape(SPLIT_CHARS) + "]") +_WS_RE = re.compile(r"\s+") + + +def tirhuta_count(s: str) -> int: + return sum(1 for c in s if TIRHUTA_LO <= ord(c) <= TIRHUTA_HI) + + +def deva_leftover_count(s: str) -> int: + """Devanagari chars that are NOT the shared danda/double-danda.""" + n = 0 + for c in s: + o = ord(c) + if DEVA_LO <= o <= DEVA_HI and o not in (DEVA_DANDA, DEVA_DOUBLE_DANDA): + n += 1 + return n + + +def latin_count(s: str) -> int: + return sum(1 for c in s if ("a" <= c <= "z") or ("A" <= c <= "Z")) + + +# Other-Indic-script ranges that occasionally leak via multilingual Wikipedia +# templates. These are neither the Devanagari source nor the Tirhuta target, so +# lines carrying them are template residue and get dropped. +_OTHER_INDIC = [ + (0x0980, 0x09FF), # Bengali + (0x0A00, 0x0A7F), # Gurmukhi + (0x0A80, 0x0AFF), # Gujarati + (0x0B00, 0x0B7F), # Oriya + (0x0B80, 0x0BFF), # Tamil + (0x0C00, 0x0C7F), # Telugu + (0x0C80, 0x0CFF), # Kannada + (0x0D00, 0x0D7F), # Malayalam +] + + +def other_indic_count(s: str) -> int: + n = 0 + for c in s: + o = ord(c) + for lo, hi in _OTHER_INDIC: + if lo <= o <= hi: + n += 1 + break + return n + + +# Leading wikitext residue tokens (image params, redirect markers, table attrs) +# that Aksharamukha passes through untransliterated. Stripped from line starts. +_RESIDUE_RE = re.compile( + r"^(?:#\s*)?(?:REDIRECT|redirect|thumb|jpg|JPG|png|PNG|svg|SVG|gif|GIF|" + r"left|right|center|label\d*|alt|class|style|align|valign|width|height|" + r"color|bgcolor|colspan|rowspan|border|cellpadding|cellspacing|image|name)" + r"[\s|=:]*", + re.IGNORECASE, +) +_GLUED_REDIRECT_RE = re.compile(r"^#?\s*(?:REDIRECT|redirect)\s*", re.IGNORECASE) + + +def strip_residue(s: str) -> str: + prev = None + while s != prev: + prev = s + s = _RESIDUE_RE.sub("", s).strip() + s = _GLUED_REDIRECT_RE.sub("", s).strip() + return s + + +def norm(s: str) -> str: + return _WS_RE.sub(" ", unicodedata.normalize("NFC", s)).strip() + + +def read_leipzig_sentences(corpus_dirs: list[str]) -> list[str]: + """Read the second (text) column of every Leipzig -sentences.txt file.""" + out: list[str] = [] + pats = [] + for d in corpus_dirs: + pats.extend(glob.glob(os.path.join(d, "*-sentences.txt"))) + pats.extend(glob.glob(os.path.join(d, "**", "*-sentences.txt"), recursive=True)) + for f in sorted(set(pats)): + with open(f, encoding="utf-8") as fh: + for line in fh: + parts = line.rstrip("\n").split("\t", 1) + if len(parts) == 2: + out.append(parts[1]) + return out + + +def read_plain_text(paths: list[str]) -> list[str]: + out: list[str] = [] + for p in paths: + with open(p, encoding="utf-8") as fh: + for line in fh: + out.append(line.rstrip("\n")) + return out + + +def collect_devanagari(corpus_dirs, extra_files, min_deva: int) -> list[str]: + raw = read_leipzig_sentences(corpus_dirs) + read_plain_text(extra_files) + seen: set[str] = set() + kept: list[str] = [] + for s in raw: + t = norm(s) + if not t: + continue + # require real Devanagari content (drop pure-number / pure-latin lines) + if deva_leftover_count(t) < min_deva: + continue + if t in seen: + continue + seen.add(t) + kept.append(t) + return kept + + +def transliterate_sidecar(lines: list[str], sidecar_python: str) -> list[str]: + """Transliterate Devanagari -> Tirhuta via the py3.10 aksharamukha sidecar. + + The sidecar reads newline-separated Devanagari from a temp file and writes + newline-separated Tirhuta to another temp file. Newlines are preserved 1:1 + by Aksharamukha, but we still guard the count. + """ + worker = r""" +import sys, unicodedata +import warnings +warnings.filterwarnings("ignore") +from aksharamukha import transliterate +inp, outp = sys.argv[1], sys.argv[2] +lines = open(inp, encoding="utf-8").read().split("\n") +CHUNK = 2000 +res = [] +for i in range(0, len(lines), CHUNK): + chunk = lines[i:i+CHUNK] + out = transliterate.process("Devanagari", "Tirhuta", "\n".join(chunk)) + parts = out.split("\n") + if len(parts) != len(chunk): + parts = [transliterate.process("Devanagari", "Tirhuta", x) for x in chunk] + res.extend(parts) +with open(outp, "w", encoding="utf-8") as fh: + fh.write("\n".join(res)) +""" + with tempfile.TemporaryDirectory() as td: + inp = os.path.join(td, "in.txt") + outp = os.path.join(td, "out.txt") + wpy = os.path.join(td, "worker.py") + Path(inp).write_text("\n".join(lines), encoding="utf-8") + Path(wpy).write_text(worker, encoding="utf-8") + subprocess.run( + [sidecar_python, wpy, inp, outp], + check=True, + capture_output=True, + text=True, + ) + res = Path(outp).read_text(encoding="utf-8").split("\n") + if len(res) != len(lines): + raise RuntimeError( + f"sidecar line-count mismatch: in={len(lines)} out={len(res)}" + ) + return res + + +def split_long(line: str, max_chars: int) -> list[str]: + """Split a long Tirhuta line on sentence punctuation into <= max_chars subs.""" + if len(line) <= max_chars: + return [line] + pieces: list[str] = [] + last = 0 + for m in _SPLIT_RE.finditer(line): + end = m.end() + seg = line[last:end].strip() + if seg: + pieces.append(seg) + last = end + tail = line[last:].strip() + if tail: + pieces.append(tail) + if not pieces: + pieces = [line] + out: list[str] = [] + for p in pieces: + while len(p) > max_chars: + cut = p.rfind(" ", 0, max_chars) + if cut <= 0: + cut = max_chars + head = p[:cut].strip() + if head: + out.append(head) + p = p[cut:].strip() + if p: + out.append(p) + return out + + +def main() -> int: + ap = argparse.ArgumentParser() + ap.add_argument( + "--corpus-dir", + action="append", + default=[], + help="Leipzig corpus directory containing *-sentences.txt (repeatable)", + ) + ap.add_argument( + "--extra-file", + action="append", + default=[], + help="extra plain Devanagari text file, one sentence per line (repeatable)", + ) + ap.add_argument( + "--sidecar-python", + default="/tmp/aksh310/bin/python", + help="python interpreter of the py3.10 aksharamukha sidecar venv", + ) + ap.add_argument("--out", required=True, help="output Tirhuta text file") + ap.add_argument("--max-chars", type=int, default=100) + ap.add_argument("--min-deva", type=int, default=2) + ap.add_argument("--min-tirhuta", type=int, default=2) + ap.add_argument( + "--max-latin", + type=int, + default=0, + help="drop lines with more than this many Latin a-zA-Z chars " + "(default 0 => drop any line carrying Latin, since a first-ever Tirhuta " + "recognizer should not be trained on embedded Latin glyphs)", + ) + ap.add_argument( + "--exclude", + action="append", + default=[], + help="existing Tirhuta text file whose lines to exclude from output (repeatable)", + ) + args = ap.parse_args() + + if not os.path.exists(args.sidecar_python): + print(f"ERROR: sidecar python not found at {args.sidecar_python}", file=sys.stderr) + return 2 + + print("[1/5] collecting Devanagari sentences ...", file=sys.stderr) + deva = collect_devanagari(args.corpus_dir, args.extra_file, args.min_deva) + print(f" unique Devanagari sentences: {len(deva)}", file=sys.stderr) + if not deva: + print("ERROR: no Devanagari input collected", file=sys.stderr) + return 2 + + print("[2/5] transliterating Devanagari -> Tirhuta (sidecar) ...", file=sys.stderr) + tirhuta = transliterate_sidecar(deva, args.sidecar_python) + + print("[3/5] verifying codepoints + NFC + residue cleanup ...", file=sys.stderr) + verified: list[str] = [] + dropped_no_tirhuta = 0 + dropped_deva_left = 0 + dropped_other_indic = 0 + dropped_latin_heavy = 0 + for o in tirhuta: + t = norm(strip_residue(norm(o))) + if not t: + continue + if tirhuta_count(t) < args.min_tirhuta: + dropped_no_tirhuta += 1 + continue + if deva_leftover_count(t) > 0: + # leftover (non-danda) Devanagari => incomplete transliteration + dropped_deva_left += 1 + continue + if other_indic_count(t) > 0: + dropped_other_indic += 1 + continue + if latin_count(t) > args.max_latin: + dropped_latin_heavy += 1 + continue + verified.append(t) + print( + f" verified={len(verified)} dropped_no_tirhuta={dropped_no_tirhuta} " + f"dropped_deva_leftover={dropped_deva_left} " + f"dropped_other_indic={dropped_other_indic} " + f"dropped_latin_heavy={dropped_latin_heavy}", + file=sys.stderr, + ) + + print("[4/5] splitting long lines + dedupe ...", file=sys.stderr) + exclude: set[str] = set() + for ex in args.exclude: + if os.path.exists(ex): + for line in open(ex, encoding="utf-8"): + exclude.add(norm(line)) + final: list[str] = [] + seen: set[str] = set() + for line in verified: + for sub in split_long(line, args.max_chars): + sub = strip_residue(sub.strip()).strip() + if not sub or tirhuta_count(sub) < args.min_tirhuta: + continue + if deva_leftover_count(sub) > 0: + continue + if latin_count(sub) > args.max_latin or other_indic_count(sub) > 0: + continue + if sub in seen or sub in exclude: + continue + seen.add(sub) + final.append(sub) + + print("[5/5] writing output ...", file=sys.stderr) + os.makedirs(os.path.dirname(os.path.abspath(args.out)), exist_ok=True) + with open(args.out, "w", encoding="utf-8") as fh: + fh.write("\n".join(final) + "\n") + + total_chars = sum(len(l) for l in final) + total_tirhuta = sum(tirhuta_count(l) for l in final) + lengths = sorted(len(l) for l in final) + median = lengths[len(lengths) // 2] if lengths else 0 + # Block coverage: how many of the 82 assigned Tirhuta codepoints appear. + assigned = [] + for cp in range(TIRHUTA_LO, TIRHUTA_HI + 1): + try: + unicodedata.name(chr(cp)) + assigned.append(cp) + except ValueError: + pass + seen_cp = set() + for l in final: + for c in l: + o = ord(c) + if TIRHUTA_LO <= o <= TIRHUTA_HI: + seen_cp.add(o) + covered = sum(1 for cp in assigned if cp in seen_cp) + missing = [hex(cp) for cp in assigned if cp not in seen_cp] + print("=" * 60) + print(f"OUT: {args.out}") + print(f"lines: {len(final)}") + print(f"total chars: {total_chars}") + print(f"total Tirhuta (U+11480..U+114DF) chars: {total_tirhuta}") + print(f"median line length (chars): {median}") + print(f"Tirhuta block coverage: {covered}/{len(assigned)} assigned codepoints") + if missing: + print(f" uncovered: {' '.join(missing)}") + print("samples:") + for s in final[:6]: + print(" " + s) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ocr-tech-mps-integration/tools/validate_eval_harness_recipes.py b/ocr-tech-mps-integration/tools/validate_eval_harness_recipes.py new file mode 100644 index 0000000000000000000000000000000000000000..b8a3322dfc9aa3cc7b4576c1cad76626b8917f1b --- /dev/null +++ b/ocr-tech-mps-integration/tools/validate_eval_harness_recipes.py @@ -0,0 +1,1310 @@ +#!/usr/bin/env python3 +"""Validate eval harness recipe registry paths and claim blockers.""" + +from __future__ import annotations + +import argparse +import importlib.util +import json +import shlex +import string +import sys +import unicodedata +from argparse import Namespace +from pathlib import Path +from types import ModuleType +from typing import Any + +from ocrtech.manifest import load_manifest, sha256_file +from ocrtech.references import load_reference + + +TOOLS_DIR = Path(__file__).resolve().parent +SUPPORTED_NORMALIZATION_PROFILE = "NFC_preserve_whitespace" +MIN_CLAIM_SCORING_UNITS = 30 +RECOGNIZER_TASK = "recognizer_oracle_crop" +PAGE_TASK = "page_level_ocr" +PAGE_OCR_OUTPUT_KINDS = {"live_detector", "oracle_line_boxes", "sidecar_fixture"} +RECOGNIZER_COMMAND_PLACEHOLDERS = {"label_file", "data_dir", "prediction_file", "out_dir"} +PAGE_COMMAND_PLACEHOLDERS = {"input_path", "sample_id", "output_dir", "document_json", "documents_dir", "out_dir"} +PAGE_OUTPUT_AUDIT_COMMAND_PLACEHOLDERS = {"output_dir", "documents_dir", "out_dir"} +PAGE_LIVE_OUTPUT_AUDIT_REQUIRED_FLAGS = ( + "--require-capture-prep", + "--min-capture-prepared-width", + "--min-capture-prepared-height", + "--min-capture-prepared-entropy", + "--min-capture-prepared-luminance-stddev", + "--min-capture-prepared-edge-stddev", + "--require-no-pending-review", + "--require-no-dropped-image-lines", + "--min-line-count", + "--min-average-line-confidence", + "--min-quality-score", +) +LIMBU_SCRIPT_STRICT_AUDIT_NAMES = { + "Limbu": "limbu_sirijonga", + "Devanagari": "devanagari_limbu", +} +REQUIRED_RECIPE_KEYS = ("id", "task", "language", "script", "model_family", "runner", "eval_pack", "leakage_sources") +RECOGNIZER_REQUIRED_EVAL_KEYS = ( + "label_file", + "data_dir", + "normalization_profile", + "dataset", + "domain", + "gt_status", + "split", + "eval_pack_version", + "frozen_eval_pack", + "unseen_for_selection", + "claim_eligible", +) +PAGE_REQUIRED_EVAL_KEYS = ( + "eval_manifest", + "ocr_output_kind", + "normalization_profile", + "dataset", + "domain", + "gt_status", + "split", + "eval_pack_version", + "frozen_eval_pack", + "unseen_for_selection", + "claim_eligible", +) +SOURCE_DOCUMENT_KEYS = ("source_document", "source_doc", "document", "source_file") +PAGE_KEYS = ("page", "page_index", "source_page") +BBOX_KEYS = ("bbox", "source_bbox", "crop_bbox") +CLAIM_ELIGIBLE_KEYS = ("claim_evidence_eligible", "claim_eligible", "paper_claim_eligible") +HUMAN_REVIEW_EVIDENCE_KEYS = ("reviewed_by", "reviewed_at", "review_artifact", "review_batch", "native_reviewer") + + +def _load_json(path: Path) -> dict[str, Any]: + if not path.exists(): + raise FileNotFoundError(f"recipe file does not exist: {path}") + try: + payload = json.loads(path.read_text(encoding="utf-8")) + except json.JSONDecodeError as exc: + raise ValueError(f"recipe file is invalid JSON: {path}: {exc}") from exc + if not isinstance(payload, dict): + raise ValueError(f"recipe file must contain a JSON object: {path}") + return payload + + +def _load_tool(name: str) -> ModuleType: + path = TOOLS_DIR / f"{name}.py" + spec = importlib.util.spec_from_file_location(name, path) + if spec is None or spec.loader is None: + raise RuntimeError(f"could not load tool module: {path}") + module = importlib.util.module_from_spec(spec) + sys.modules[spec.name] = module + spec.loader.exec_module(module) + return module + + +def _resolve_path(root: Path, value: str) -> Path: + path = Path(value) + if path.is_absolute(): + return path + return root / path + + +def _resolve_manifest_path(path_value: str, manifest_dir: Path) -> Path: + path = Path(path_value) + if path.is_absolute() or path.exists(): + return path + candidate = manifest_dir / path + if candidate.exists(): + return candidate + return path + + +def _nfc(value: str) -> str: + return unicodedata.normalize("NFC", value or "") + + +def _codepoint_id(ch: str) -> str: + return f"U+{ord(ch):04X}" + + +def _text_codepoints(texts: list[str]) -> list[str]: + return sorted({_codepoint_id(ch) for text in texts for ch in _nfc(text) if not ch.isspace()}) + + +def _metadata_has_any(metadata: dict[str, Any], keys: tuple[str, ...]) -> bool: + return any(metadata.get(key) not in (None, "", [], {}) for key in keys) + + +def _path_exists(root: Path, value: str) -> bool: + return _resolve_path(root, value).exists() + + +def _check_path(issues: list[str], root: Path, recipe_id: str, field: str, value: Any) -> None: + if not isinstance(value, str) or not value: + issues.append(f"{recipe_id}: missing path field {field}") + return + if not _path_exists(root, value): + issues.append(f"{recipe_id}: path does not exist for {field}: {value}") + + +def _check_script_inventory(issues: list[str], root: Path, recipe_id: str, value: Any) -> None: + if not isinstance(value, str) or not value or not _path_exists(root, value): + return + path = _resolve_path(root, value) + try: + payload = json.loads(path.read_text(encoding="utf-8")) + except json.JSONDecodeError as exc: + issues.append(f"{recipe_id}: script inventory file is invalid JSON: {value}: {exc}") + return + if not isinstance(payload, dict): + issues.append(f"{recipe_id}: script inventory file must contain a JSON object: {value}") + return + required_codepoints = payload.get("required_codepoints", []) + if not isinstance(required_codepoints, list): + issues.append(f"{recipe_id}: script inventory required_codepoints must be a list: {value}") + else: + for item in required_codepoints: + if not isinstance(item, str): + issues.append(f"{recipe_id}: script inventory codepoint entry must be a string: {item!r}") + continue + if item.startswith("U+"): + try: + int(item[2:], 16) + except ValueError: + issues.append(f"{recipe_id}: script inventory codepoint entry is not valid hex: {item!r}") + elif len(item) != 1: + issues.append(f"{recipe_id}: script inventory codepoint entry must be one character or U+XXXX: {item!r}") + required_graphemes = payload.get("required_graphemes", []) + if not isinstance(required_graphemes, list): + issues.append(f"{recipe_id}: script inventory required_graphemes must be a list: {value}") + else: + for item in required_graphemes: + if not isinstance(item, str): + issues.append(f"{recipe_id}: script inventory grapheme entry must be a string: {item!r}") + + +def _count_loose_jsonl_manifest(issues: list[str], path: Path, recipe_id: str, field: str) -> int | None: + rows = 0 + try: + with path.open("r", encoding="utf-8") as handle: + for line_no, line in enumerate(handle, 1): + if not line.strip(): + continue + try: + payload = json.loads(line) + except json.JSONDecodeError as exc: + issues.append(f"{recipe_id}: {field} invalid JSONL at line {line_no}: {exc}") + return None + if not isinstance(payload, dict): + issues.append(f"{recipe_id}: {field} row {line_no} must be a JSON object") + return None + rows += 1 + except OSError as exc: + issues.append(f"{recipe_id}: could not read {field}: {path}: {exc}") + return None + return rows + + +def _check_leakage_manifest( + issues: list[str], + blockers: list[str], + root: Path, + recipe_id: str, + task: Any, + field: str, + value: Any, +) -> None: + if not isinstance(value, str) or not value or not _path_exists(root, value): + return + path = _resolve_path(root, value) + row_count = _count_loose_jsonl_manifest(issues, path, recipe_id, field) + if row_count == 0: + blockers.append(f"{field} has no rows") + if task == PAGE_TASK: + try: + entries = load_manifest(path) + except Exception as exc: + issues.append(f"{recipe_id}: {field} is not a valid page leakage manifest: {type(exc).__name__}: {exc}") + return + if not entries: + blockers.append(f"{field} has no page manifest rows") + + +def _check_leakage_label_source( + issues: list[str], + blockers: list[str], + root: Path, + recipe_id: str, + label_field: str, + label_value: Any, + data_dir_value: Any, +) -> None: + if ( + not isinstance(label_value, str) + or not label_value + or not isinstance(data_dir_value, str) + or not data_dir_value + or not _path_exists(root, label_value) + or not _path_exists(root, data_dir_value) + ): + return + label_path = _resolve_path(root, label_value) + data_dir = _resolve_path(root, data_dir_value) + row_count = 0 + missing_images: list[str] = [] + try: + with label_path.open("r", encoding="utf-8", newline="") as handle: + for line_no, line in enumerate(handle, 1): + line = line.rstrip("\n") + if not line: + continue + if "\t" not in line: + issues.append(f"{recipe_id}: {label_field}:{line_no}: expected image path and label separated by a tab") + continue + rel_path, _text = line.split("\t", 1) + if not rel_path: + issues.append(f"{recipe_id}: {label_field}:{line_no}: empty image path") + continue + row_count += 1 + image_path = data_dir / rel_path + if not image_path.exists() and len(missing_images) < 20: + missing_images.append(f"{line_no}:{image_path}") + except OSError as exc: + issues.append(f"{recipe_id}: could not read {label_field}: {label_path}: {exc}") + return + if row_count == 0: + blockers.append(f"{label_field} has no rows") + if missing_images: + issues.append(f"{recipe_id}: leakage label source references missing images: {missing_images}") + + +def _read_summary(issues: list[str], root: Path, recipe_id: str, value: Any) -> dict[str, Any] | None: + if not isinstance(value, str) or not value or not _path_exists(root, value): + return None + path = _resolve_path(root, value) + try: + payload = json.loads(path.read_text(encoding="utf-8")) + except json.JSONDecodeError as exc: + issues.append(f"{recipe_id}: summary/datasheet file is invalid JSON: {value}: {exc}") + return None + if not isinstance(payload, dict): + issues.append(f"{recipe_id}: summary/datasheet file must contain a JSON object: {value}") + return None + return payload + + +def _read_json_artifact( + issues: list[str], + root: Path, + recipe_id: str, + field: str, + value: Any, +) -> tuple[dict[str, Any] | None, Path | None, str]: + if not isinstance(value, str) or not value: + issues.append(f"{recipe_id}: missing evidence path {field}") + return None, None, "" + path = _resolve_path(root, value) + if not path.is_file(): + issues.append(f"{recipe_id}: evidence path does not exist for {field}: {value}") + return None, path, "" + try: + payload = json.loads(path.read_text(encoding="utf-8")) + except json.JSONDecodeError as exc: + issues.append(f"{recipe_id}: evidence JSON is invalid for {field}: {value}: {exc}") + return None, path, "" + if not isinstance(payload, dict): + issues.append(f"{recipe_id}: evidence JSON must contain an object for {field}: {value}") + return None, path, "" + return payload, path, sha256_file(path) + + +def _artifact_path_sha_matches( + blockers: list[str], + root: Path, + recipe_id: str, + field: str, + record: Any, + expected_value: Any, +) -> None: + if not isinstance(record, dict): + blockers.append(f"{field} evidence record is missing or malformed") + return + path_value = record.get("path") + sha_value = record.get("sha256") + if not isinstance(path_value, str) or not path_value: + blockers.append(f"{field} evidence record missing path") + return + if isinstance(expected_value, str) and expected_value and path_value != expected_value: + blockers.append(f"{field} evidence path mismatch: wrapper={path_value!r} recipe={expected_value!r}") + path = _resolve_path(root, path_value) + if not path.is_file(): + blockers.append(f"{field} evidence path is missing: {path_value}") + return + actual_sha = sha256_file(path) + if sha_value != actual_sha: + blockers.append(f"{field} evidence SHA-256 mismatch: recorded={sha_value!r} actual={actual_sha}") + + +def _command_flag_values(command: str, flag: str) -> list[str]: + try: + tokens = shlex.split(command, comments=False, posix=True) + except ValueError: + tokens = command.split() + values: list[str] = [] + prefix = f"{flag}=" + for index, token in enumerate(tokens): + if token == flag: + if index + 1 < len(tokens): + values.append(tokens[index + 1]) + continue + if token.startswith(prefix): + values.append(token[len(prefix) :]) + return values + + +def _require_command_flag_binding( + blockers: list[str], + command: str, + flag: str, + expected_label: str, + expected_path: Any, +) -> None: + values = _command_flag_values(command, flag) + if not values: + blockers.append(f"book candidate command_template missing {flag}") + return + if not isinstance(expected_path, str) or not expected_path: + blockers.append(f"book candidate command_template cannot verify {flag}; {expected_label} is missing") + return + if expected_path not in values: + blockers.append( + f"book candidate command_template {flag} does not bind {expected_label}: expected={expected_path!r}" + ) + + +def _validate_page_candidate_evidence(root: Path, recipe_id: str, recipe: dict[str, Any]) -> tuple[list[str], list[str], dict[str, Any] | None]: + if recipe.get("task") != PAGE_TASK: + return [], [], None + runner = recipe.get("runner") + evidence = recipe.get("evidence") + command = runner.get("command_template") if isinstance(runner, dict) else "" + book_candidate_recipe = isinstance(command, str) and "tools/score_limbu_book_ocr_candidate.py" in command + if evidence is None and not book_candidate_recipe: + return [], [], None + issues: list[str] = [] + blockers: list[str] = [] + if not isinstance(evidence, dict): + return [f"{recipe_id}: page candidate evidence must be an object"], [], None + + score_admission, score_admission_path, score_admission_sha = _read_json_artifact( + issues, + root, + recipe_id, + "evidence.score_admission", + evidence.get("score_admission"), + ) + admission, admission_path, admission_sha = _read_json_artifact( + issues, + root, + recipe_id, + "evidence.admission_report", + evidence.get("admission_report"), + ) + metrics, metrics_path, metrics_sha = _read_json_artifact( + issues, + root, + recipe_id, + "evidence.metrics", + evidence.get("metrics"), + ) + coverage, coverage_path, coverage_sha = _read_json_artifact( + issues, + root, + recipe_id, + "evidence.review_coverage_report", + evidence.get("review_coverage_report"), + ) + unresolved_packet = evidence.get("unresolved_review_packet") + if isinstance(unresolved_packet, str) and unresolved_packet: + packet_path = _resolve_path(root, unresolved_packet) + if not packet_path.is_file(): + issues.append(f"{recipe_id}: evidence path does not exist for evidence.unresolved_review_packet: {unresolved_packet}") + elif book_candidate_recipe: + blockers.append("book candidate evidence missing unresolved_review_packet") + book_output = evidence.get("book_output") + if isinstance(book_output, str) and book_output: + if not _resolve_path(root, book_output).is_dir(): + issues.append(f"{recipe_id}: evidence book_output is not a directory: {book_output}") + elif book_candidate_recipe: + blockers.append("book candidate evidence missing book_output") + + if score_admission is not None: + if score_admission.get("tool") != "tools/score_limbu_book_ocr_candidate.py": + blockers.append("score admission evidence was not produced by tools/score_limbu_book_ocr_candidate.py") + if score_admission.get("admitted_operational") is not True: + blockers.append("score admission did not pass admitted_operational=true") + if isinstance(book_output, str) and book_output and score_admission.get("book_output") != book_output: + blockers.append( + f"score admission book_output mismatch: wrapper={score_admission.get('book_output')!r} recipe={book_output!r}" + ) + _artifact_path_sha_matches(blockers, root, recipe_id, "book_audit", score_admission.get("book_audit"), None) + _artifact_path_sha_matches(blockers, root, recipe_id, "admission_report", score_admission.get("admission_report"), evidence.get("admission_report")) + _artifact_path_sha_matches(blockers, root, recipe_id, "metrics", score_admission.get("metrics"), evidence.get("metrics")) + _artifact_path_sha_matches( + blockers, + root, + recipe_id, + "review_coverage_report", + score_admission.get("review_coverage_report"), + evidence.get("review_coverage_report"), + ) + champion_record = score_admission.get("champion_metrics") + if not isinstance(champion_record, dict) or not champion_record.get("path"): + blockers.append("score admission evidence missing champion_metrics") + else: + _artifact_path_sha_matches(blockers, root, recipe_id, "champion_metrics", champion_record, None) + if book_candidate_recipe and isinstance(command, str): + book_audit_record = score_admission.get("book_audit") + _require_command_flag_binding(blockers, command, "--book-output", "evidence.book_output", book_output) + _require_command_flag_binding( + blockers, + command, + "--book-audit", + "score_admission.book_audit.path", + book_audit_record.get("path") if isinstance(book_audit_record, dict) else None, + ) + _require_command_flag_binding( + blockers, + command, + "--champion-metrics", + "score_admission.champion_metrics.path", + champion_record.get("path") if isinstance(champion_record, dict) else None, + ) + _require_command_flag_binding( + blockers, + command, + "--review-coverage-report", + "evidence.review_coverage_report", + evidence.get("review_coverage_report"), + ) + + if admission is not None: + if admission.get("tool") != "tools/admit_limbu_book_ocr_candidate.py": + blockers.append("admission evidence was not produced by tools/admit_limbu_book_ocr_candidate.py") + if admission.get("admitted_operational") is not True: + blockers.append("book candidate admission did not pass admitted_operational=true") + if admission.get("issues"): + blockers.append(f"book candidate admission contains issues: {len(admission.get('issues', []))}") + if admission.get("metrics_sha256") != metrics_sha: + blockers.append("book candidate admission metrics_sha256 does not match evidence.metrics") + if admission.get("review_coverage_report_sha256") != coverage_sha: + blockers.append("book candidate admission review_coverage_report_sha256 does not match evidence.review_coverage_report") + if not admission.get("champion_metrics") or not admission.get("champion_metrics_sha256"): + blockers.append("book candidate admission missing champion metrics evidence") + if admission.get("champion_codepoint_absolute_improvement") is None: + blockers.append("book candidate admission missing champion codepoint comparison") + for key in ( + "champion_codepoint_absolute_improvement", + "champion_grapheme_absolute_improvement", + "champion_wer_absolute_improvement", + ): + value = admission.get(key) + if isinstance(value, (int, float)) and value < -1e-12: + blockers.append(f"book candidate admission reports champion regression: {key}={value}") + review_values = admission.get("review_coverage_values") + if not isinstance(review_values, dict): + blockers.append("book candidate admission missing review_coverage_values") + else: + for field in ( + "missed_reference_count", + "uncovered_or_weak_count", + "extra_prediction_count", + "extra_uncovered_or_weak_count", + ): + if not isinstance(review_values.get(field), int): + blockers.append(f"book candidate admission missing review coverage count: {field}") + if int(review_values.get("uncovered_or_weak_count") or 0) > int(admission.get("max_review_uncovered_or_weak_count") or 0): + blockers.append("book candidate admission has uncovered/weak missed-reference review coverage") + if int(review_values.get("extra_uncovered_or_weak_count") or 0) > int(admission.get("max_review_extra_uncovered_or_weak_count") or 0): + blockers.append("book candidate admission has uncovered/weak extra-prediction review coverage") + + if coverage is not None: + if coverage.get("tool") != "tools/audit_limbu_book_missed_line_review_coverage.py": + blockers.append("review coverage evidence was not produced by tools/audit_limbu_book_missed_line_review_coverage.py") + if int(coverage.get("uncovered_or_weak_count") or 0) > 0: + blockers.append("review coverage report has uncovered_or_weak_count > 0") + if int(coverage.get("extra_uncovered_or_weak_count") or 0) > 0: + blockers.append("review coverage report has extra_uncovered_or_weak_count > 0") + if isinstance(unresolved_packet, str) and unresolved_packet: + coverage_packet = coverage.get("review_packet") + if isinstance(coverage_packet, str) and coverage_packet != unresolved_packet: + blockers.append(f"review coverage packet mismatch: coverage={coverage_packet!r} recipe={unresolved_packet!r}") + packet_path = _resolve_path(root, unresolved_packet) + if packet_path.is_file() and coverage.get("review_packet_sha256") != sha256_file(packet_path): + blockers.append("review coverage packet SHA-256 does not match evidence.unresolved_review_packet") + + evidence_audit = { + "score_admission": str(score_admission_path) if score_admission_path else "", + "score_admission_sha256": score_admission_sha, + "admission_report": str(admission_path) if admission_path else "", + "admission_report_sha256": admission_sha, + "metrics": str(metrics_path) if metrics_path else "", + "metrics_sha256": metrics_sha, + "review_coverage_report": str(coverage_path) if coverage_path else "", + "review_coverage_report_sha256": coverage_sha, + "admitted_operational": admission.get("admitted_operational") if admission else None, + "claim_safe": admission.get("claim_safe") if admission else None, + "review_coverage_values": admission.get("review_coverage_values") if admission else None, + } + return issues, blockers, evidence_audit + + +def _summary_lacks_metadata(summary: dict[str, Any] | None) -> bool: + if not summary: + return True + return not any(key in summary for key in ("dataset", "datasheet", "eval_pack", "version", "eval_pack_version")) + + +def _summary_consistency_blockers( + summary: dict[str, Any] | None, + recipe: dict[str, Any], + eval_pack: dict[str, Any], + task: Any, +) -> list[str]: + if not summary: + return [] + blockers: list[str] = [] + string_expectations = { + "language": recipe.get("language"), + "script": recipe.get("script"), + "dataset": eval_pack.get("dataset"), + "domain": eval_pack.get("domain"), + "gt_status": eval_pack.get("gt_status"), + "split": eval_pack.get("split"), + "eval_pack_version": eval_pack.get("eval_pack_version"), + } + for field, recipe_value in string_expectations.items(): + summary_value = summary.get(field) + if summary_value in (None, "") or recipe_value in (None, ""): + continue + if str(summary_value) != str(recipe_value): + blockers.append( + f"eval pack summary {field} mismatch: summary={summary_value!r} recipe={recipe_value!r}" + ) + boolean_fields = ( + ("frozen_eval_pack", "frozen_eval_pack"), + ("unseen_for_selection", "unseen_for_selection"), + ("claim_eligible_default", "claim_eligible"), + ) + for summary_field, recipe_field in boolean_fields: + if summary_field not in summary or recipe_field not in eval_pack: + continue + summary_value = summary.get(summary_field) + recipe_value = eval_pack.get(recipe_field) + if isinstance(summary_value, bool) and isinstance(recipe_value, bool) and summary_value != recipe_value: + blockers.append( + f"eval pack summary {summary_field} mismatch: summary={summary_value!r} recipe={recipe_value!r}" + ) + summary_eval_pack = summary.get("eval_pack") + if isinstance(summary_eval_pack, dict): + summary_task = summary_eval_pack.get("task") + if summary_task not in (None, "") and task not in (None, "") and str(summary_task) != str(task): + blockers.append(f"eval pack summary task mismatch: summary={summary_task!r} recipe={task!r}") + return blockers + + +def _read_spotcheck_calibration(issues: list[str], root: Path, recipe_id: str, value: Any) -> dict[str, Any] | None: + if not isinstance(value, str) or not value or not _path_exists(root, value): + return None + path = _resolve_path(root, value) + try: + payload = json.loads(path.read_text(encoding="utf-8")) + except json.JSONDecodeError as exc: + issues.append(f"{recipe_id}: native spot-check calibration file is invalid JSON: {value}: {exc}") + return None + if not isinstance(payload, dict): + issues.append(f"{recipe_id}: native spot-check calibration file must contain a JSON object: {value}") + return None + return payload + + +def _audit_values(audit: dict[str, Any] | None, key: str, fallback: str) -> set[str]: + if audit: + values = audit.get(key) + if isinstance(values, dict) and values: + return {str(value) for value in values} + if isinstance(values, list) and values: + return {str(value) for value in values} + return {fallback} + + +def _spotcheck_calibration_blockers( + payload: dict[str, Any] | None, + recipe: dict[str, Any], + eval_pack: dict[str, Any], + audit: dict[str, Any] | None, +) -> list[str]: + if payload is None: + return [] + if not (eval_pack.get("gt_status") == "machine_converted_spot_checked" or _audit_declares_spotchecked_gt(audit)): + return [] + blockers: list[str] = [] + if payload.get("claim_evidence_eligible") is not True: + blockers.append("native spot-check calibration artifact is not claim evidence eligible") + if payload.get("recommended_pack_gt_status") != "machine_converted_spot_checked": + blockers.append("native spot-check calibration does not recommend machine_converted_spot_checked GT") + if payload.get("source_gt_status") != "machine_converted": + blockers.append("native spot-check calibration source_gt_status is not machine_converted") + expected_values = { + "language": _audit_values(audit, "languages", str(recipe.get("language") or "unknown")), + "script": _audit_values(audit, "scripts", str(recipe.get("script") or "unknown")), + "domain": _audit_values(audit, "domains", str(eval_pack.get("domain") or "unknown")), + } + for field, values in expected_values.items(): + value = payload.get(field) + if not isinstance(value, str) or not value: + blockers.append(f"native spot-check calibration missing {field}") + elif value not in values: + blockers.append(f"native spot-check calibration {field} mismatch: {value!r} not in {sorted(values)}") + return blockers + + +def _artifact_blocker(root: Path, field: str, value: Any) -> str | None: + if not isinstance(value, str) or not value: + return f"{field} artifact is not hash-verifiable: missing" + path = _resolve_path(root, value) + if not path.exists() or not path.is_file(): + return f"{field} artifact is not hash-verifiable: not a readable local file" + return None + + +def _dictionary_codepoints(root: Path, value: Any) -> set[str] | None: + if not isinstance(value, str) or not value: + return None + path = _resolve_path(root, value) + if not path.exists() or not path.is_file(): + return None + codepoints: set[str] = set() + for line in path.read_text(encoding="utf-8").splitlines(): + token = _nfc(line.strip()) + if not token: + continue + for ch in token: + if not ch.isspace(): + codepoints.add(_codepoint_id(ch)) + return codepoints + + +def _recognizer_label_texts(root: Path, eval_pack: dict[str, Any]) -> tuple[list[str], list[str]]: + value = eval_pack.get("label_file") + if not isinstance(value, str) or not value: + return [], [] + path = _resolve_path(root, value) + if not path.exists(): + return [], [] + texts: list[str] = [] + issues: list[str] = [] + for row_index, line in enumerate(path.read_text(encoding="utf-8").splitlines(), 1): + if not line: + continue + parts = line.split("\t", 1) + if len(parts) != 2: + issues.append(f"label_file row {row_index} is not imagetext") + continue + texts.append(parts[1]) + return texts, issues + + +def _page_reference_texts(root: Path, eval_pack: dict[str, Any]) -> tuple[list[str], list[str]]: + value = eval_pack.get("eval_manifest") + if not isinstance(value, str) or not value: + return [], [] + manifest_path = _resolve_path(root, value) + if not manifest_path.exists(): + return [], [] + try: + entries = load_manifest(manifest_path) + except Exception as exc: + return [], [f"page eval manifest failed to load for dictionary coverage: {type(exc).__name__}: {exc}"] + texts: list[str] = [] + issues: list[str] = [] + manifest_dir = manifest_path.parent + for entry in entries: + metadata = entry.metadata or {} + input_path = _resolve_manifest_path(entry.image_path, manifest_dir) + explicit = metadata.get("reference_path") + explicit_path = _resolve_manifest_path(explicit, manifest_dir) if isinstance(explicit, str) and explicit else None + if isinstance(explicit, str) and explicit and not explicit_path.exists(): + continue + try: + reference = load_reference(input_path, explicit_path=explicit_path) + except Exception as exc: + issues.append(f"{entry.sample_id}: reference failed to parse for dictionary coverage: {type(exc).__name__}: {exc}") + continue + if reference is not None and reference.text is not None: + texts.append(reference.text) + return texts, issues + + +def _dictionary_coverage_blockers(root: Path, recipe: dict[str, Any]) -> tuple[list[str], list[str]]: + runner = recipe.get("runner") + eval_pack = recipe.get("eval_pack") + if not isinstance(runner, dict) or not isinstance(eval_pack, dict): + return [], [] + dictionary_value = runner.get("dictionary") or runner.get("dictionary_path") + dictionary_codepoints = _dictionary_codepoints(root, dictionary_value) + if dictionary_codepoints is None: + return [], [] + if recipe.get("task") == PAGE_TASK: + texts, issues = _page_reference_texts(root, eval_pack) + label = "reference" + else: + texts, issues = _recognizer_label_texts(root, eval_pack) + label = "GT" + if not texts: + return issues, [] + missing = sorted(set(_text_codepoints(texts)) - dictionary_codepoints) + if not missing: + return issues, [] + return issues, [f"{label} codepoints missing from runner dictionary: {missing[:20]}"] + + +def _unresolved_external_command(template: str) -> bool: + return "REPLACE_WITH" in template or "<" in template or ">" in template + + +def _command_placeholder_issues(recipe_id: str, task: Any, template: str) -> list[str]: + allowed = RECOGNIZER_COMMAND_PLACEHOLDERS if task == RECOGNIZER_TASK else PAGE_COMMAND_PLACEHOLDERS + issues: list[str] = [] + try: + parsed = list(string.Formatter().parse(template)) + except ValueError as exc: + return [f"{recipe_id}: external command_template has invalid format syntax: {exc}"] + for _literal, field_name, _format_spec, _conversion in parsed: + if field_name is None: + continue + root_name = field_name.split(".", 1)[0].split("[", 1)[0] + if root_name not in allowed: + issues.append(f"{recipe_id}: external command_template has unknown placeholder {{{field_name}}}") + return issues + + +def _output_audit_placeholder_issues(recipe_id: str, template: str) -> list[str]: + issues: list[str] = [] + try: + parsed = list(string.Formatter().parse(template)) + except ValueError as exc: + return [f"{recipe_id}: page output_audit command_template has invalid format syntax: {exc}"] + for _literal, field_name, _format_spec, _conversion in parsed: + if field_name is None: + continue + root_name = field_name.split(".", 1)[0].split("[", 1)[0] + if root_name not in PAGE_OUTPUT_AUDIT_COMMAND_PLACEHOLDERS: + issues.append(f"{recipe_id}: page output_audit command_template has unknown placeholder {{{field_name}}}") + return issues + + +def _audit_declares_spotchecked_gt(audit: dict[str, Any] | None) -> bool: + if not audit: + return False + gt_statuses = audit.get("gt_statuses") + if isinstance(gt_statuses, dict): + return "machine_converted_spot_checked" in gt_statuses + if isinstance(gt_statuses, list): + return "machine_converted_spot_checked" in gt_statuses + return False + + +def _validate_runner(root: Path, recipe_id: str, task: Any, runner: Any) -> tuple[list[str], list[str]]: + issues: list[str] = [] + blockers: list[str] = [] + if not isinstance(runner, dict): + return [f"{recipe_id}: runner must be an object"], blockers + if task not in {RECOGNIZER_TASK, PAGE_TASK}: + issues.append(f"{recipe_id}: unsupported task {task!r}") + runner_type = runner.get("type") + if runner_type == "model_config": + _check_path(issues, root, recipe_id, "runner.model_config", runner.get("model_config")) + elif runner_type == "external_command": + template = runner.get("command_template") + if not isinstance(template, str) or not template: + issues.append(f"{recipe_id}: external command_template is required") + else: + issues.extend(_command_placeholder_issues(recipe_id, task, template)) + if task == RECOGNIZER_TASK: + for placeholder in ("{label_file}", "{data_dir}", "{prediction_file}"): + if placeholder not in template: + issues.append(f"{recipe_id}: external recognizer command_template must contain {placeholder}") + elif task == PAGE_TASK: + if "{input_path}" not in template: + issues.append(f"{recipe_id}: external page command_template must contain {{input_path}}") + if "{document_json}" not in template and "{output_dir}" not in template: + issues.append(f"{recipe_id}: external page command_template must contain {{document_json}} or {{output_dir}}") + if _unresolved_external_command(template): + blockers.append("external prediction command template is unresolved") + if "requires_operator_resolution" not in runner: + issues.append(f"{recipe_id}: external_command must declare requires_operator_resolution") + elif runner.get("requires_operator_resolution"): + blockers.append("external prediction command requires operator resolution") + else: + issues.append(f"{recipe_id}: unsupported runner.type {runner_type!r}") + if runner.get("training_summary"): + _check_path(issues, root, recipe_id, "runner.training_summary", runner.get("training_summary")) + if runner.get("selected_checkpoint_on_test"): + blockers.append("checkpoint/model selection on this test pack is declared") + for field in ("checkpoint", "config", "dictionary"): + blocker = _artifact_blocker(root, field, runner.get(field) or runner.get(f"{field}_path")) + if blocker: + blockers.append(blocker) + return issues, blockers + + +def _validate_page_output_audit(recipe_id: str, recipe: dict[str, Any]) -> tuple[list[str], list[str]]: + issues: list[str] = [] + blockers: list[str] = [] + if recipe.get("task") != PAGE_TASK: + return issues, blockers + eval_pack = recipe.get("eval_pack") + runner = recipe.get("runner") + if not isinstance(eval_pack, dict) or eval_pack.get("ocr_output_kind") != "live_detector": + return issues, blockers + if not isinstance(runner, dict): + return issues, blockers + output_audit = runner.get("output_audit") + if not isinstance(output_audit, dict): + blockers.append("live-detector page recipe missing runner.output_audit strict audit command") + return issues, blockers + template = output_audit.get("command_template") + if not isinstance(template, str) or not template: + blockers.append("live-detector page recipe missing runner.output_audit.command_template") + return issues, blockers + issues.extend(_output_audit_placeholder_issues(recipe_id, template)) + if _unresolved_external_command(template): + blockers.append("page output_audit command_template is unresolved") + if "{output_dir}" not in template: + blockers.append("page output_audit command_template must bind {output_dir}") + if str(recipe.get("language") or "") == "limbu": + if "audit-limbu-output" not in template: + blockers.append("Limbu page output_audit command_template must run audit-limbu-output") + required_flags = output_audit.get("required_flags") + if not isinstance(required_flags, list) or not required_flags or not all(isinstance(item, str) and item for item in required_flags): + blockers.append("Limbu page output_audit.required_flags must be a non-empty string list") + required_flags = [] + for flag in PAGE_LIVE_OUTPUT_AUDIT_REQUIRED_FLAGS: + if flag not in required_flags: + blockers.append(f"Limbu page output_audit.required_flags missing {flag}") + if flag not in template: + blockers.append(f"Limbu page output_audit command_template missing {flag}") + expected_script = LIMBU_SCRIPT_STRICT_AUDIT_NAMES.get(str(recipe.get("script") or "")) + required_scripts = output_audit.get("required_scripts") + if not isinstance(required_scripts, list) or not required_scripts or not all(isinstance(item, str) and item for item in required_scripts): + blockers.append("Limbu page output_audit.required_scripts must be a non-empty string list") + required_scripts = [] + if expected_script is not None: + if expected_script not in required_scripts: + blockers.append(f"Limbu page output_audit.required_scripts missing {expected_script}") + if f"--require-script {expected_script}" not in template: + blockers.append(f"page output_audit command_template missing --require-script {expected_script}") + return issues, blockers + + +def _validate_eval_pack(root: Path, recipe_id: str, recipe: dict[str, Any], task: Any, eval_pack: Any) -> tuple[list[str], list[str]]: + issues: list[str] = [] + blockers: list[str] = [] + if not isinstance(eval_pack, dict): + return [f"{recipe_id}: eval_pack must be an object"], blockers + required_eval_keys = PAGE_REQUIRED_EVAL_KEYS if task == PAGE_TASK else RECOGNIZER_REQUIRED_EVAL_KEYS + for key in required_eval_keys: + if key not in eval_pack: + issues.append(f"{recipe_id}: eval_pack missing required key {key}") + if task == PAGE_TASK: + _check_path(issues, root, recipe_id, "eval_pack.eval_manifest", eval_pack.get("eval_manifest")) + if eval_pack.get("ocr_output_kind") not in PAGE_OCR_OUTPUT_KINDS: + blockers.append( + f"page OCR output kind is not claim-safe: {eval_pack.get('ocr_output_kind')!r}; " + f"expected one of {sorted(PAGE_OCR_OUTPUT_KINDS)}" + ) + else: + for field in ("label_file", "data_dir"): + _check_path(issues, root, recipe_id, f"eval_pack.{field}", eval_pack.get(field)) + optional_artifacts = ("summary_file", "script_inventory_file") if task == PAGE_TASK else ("manifest_file", "summary_file", "script_inventory_file") + for optional in optional_artifacts: + if eval_pack.get(optional): + _check_path(issues, root, recipe_id, f"eval_pack.{optional}", eval_pack.get(optional)) + else: + blockers.append(f"missing eval_pack.{optional}") + summary = _read_summary(issues, root, recipe_id, eval_pack.get("summary_file")) + if eval_pack.get("summary_file") and _summary_lacks_metadata(summary): + blockers.append("eval pack summary lacks dataset/version/eval_pack metadata") + if summary is not None: + summary_digest = summary.get("pack_content_sha256") + nested_digest = summary.get("eval_pack", {}).get("pack_content_sha256") if isinstance(summary.get("eval_pack"), dict) else None + if not ((isinstance(summary_digest, str) and summary_digest) or (isinstance(nested_digest, str) and nested_digest)): + blockers.append("eval pack summary missing pack_content_sha256") + blockers.extend(_summary_consistency_blockers(summary, recipe, eval_pack, task)) + _check_script_inventory(issues, root, recipe_id, eval_pack.get("script_inventory_file")) + if eval_pack.get("spotcheck_calibration_file"): + _check_path(issues, root, recipe_id, "eval_pack.spotcheck_calibration_file", eval_pack.get("spotcheck_calibration_file")) + elif eval_pack.get("gt_status") == "machine_converted_spot_checked": + blockers.append("missing eval_pack.spotcheck_calibration_file for machine_converted_spot_checked GT") + if not eval_pack.get("frozen_eval_pack"): + blockers.append("eval pack is not frozen") + if not eval_pack.get("unseen_for_selection"): + blockers.append("eval pack is not unseen for selection") + if not eval_pack.get("claim_eligible"): + blockers.append("eval pack rows are not claim eligible by default") + if eval_pack.get("normalization_profile") != SUPPORTED_NORMALIZATION_PROFILE: + blockers.append( + "normalization profile is not scorer-supported: " + f"{eval_pack.get('normalization_profile')!r}; expected {SUPPORTED_NORMALIZATION_PROFILE!r}" + ) + if eval_pack.get("gt_status") not in {"human_verified", "machine_converted_spot_checked"}: + blockers.append(f"GT status is not claim-safe: {eval_pack.get('gt_status')}") + if eval_pack.get("domain") not in {"real_print", "real_handwritten"}: + blockers.append(f"domain is not claim-safe real material: {eval_pack.get('domain')}") + return issues, blockers + + +def _audit_eval_pack(root: Path, recipe: dict[str, Any], eval_pack: dict[str, Any]) -> dict[str, Any] | None: + required_paths = ("label_file", "data_dir", "manifest_file", "summary_file") + if any(not isinstance(eval_pack.get(field), str) or not eval_pack.get(field) for field in required_paths): + return None + resolved = {field: _resolve_path(root, str(eval_pack[field])) for field in required_paths} + if any(not path.exists() for path in resolved.values()): + return None + audit_tool = _load_tool("audit_recognizer_eval_pack") + return audit_tool.audit_pack( + Namespace( + label_file=resolved["label_file"], + data_dir=resolved["data_dir"], + manifest_file=resolved["manifest_file"], + summary_file=resolved["summary_file"], + language=str(recipe.get("language") or "unknown"), + script=str(recipe.get("script") or "unknown"), + domain=str(eval_pack.get("domain") or "unknown"), + gt_status=str(eval_pack.get("gt_status") or "unknown"), + split=str(eval_pack.get("split") or "eval"), + eval_pack_version=str(eval_pack.get("eval_pack_version") or ""), + frozen_eval_pack=bool(eval_pack.get("frozen_eval_pack")), + unseen_for_selection=bool(eval_pack.get("unseen_for_selection")), + claim_eligible=bool(eval_pack.get("claim_eligible")), + ) + ) + + +def _audit_page_eval_pack(root: Path, recipe: dict[str, Any], eval_pack: dict[str, Any]) -> dict[str, Any] | None: + manifest_value = eval_pack.get("eval_manifest") + if not isinstance(manifest_value, str) or not manifest_value: + return None + manifest_path = _resolve_path(root, manifest_value) + if not manifest_path.exists(): + return None + issues: list[str] = [] + warnings: list[str] = [] + try: + entries = load_manifest(manifest_path) + except Exception as exc: + return { + "passed": False, + "claim_ready": False, + "counts": {}, + "issues": [f"page eval manifest failed to load: {type(exc).__name__}: {exc}"], + "warnings": [], + } + counts = { + "rows": len(entries), + "references": 0, + "claim_ready_references": 0, + "missing_source_document": 0, + "missing_page": 0, + "missing_bbox": 0, + "missing_claim_eligibility": 0, + "missing_human_review_evidence": 0, + "missing_language": 0, + "missing_script": 0, + "missing_domain": 0, + "missing_gt_status": 0, + } + if not entries: + issues.append("page eval manifest has no rows") + image_paths: list[str] = [] + reference_slice_counts: dict[tuple[str, str, str, str, str], int] = {} + languages: dict[str, int] = {} + scripts: dict[str, int] = {} + domains: dict[str, int] = {} + gt_statuses: dict[str, int] = {} + manifest_dir = manifest_path.parent + for entry in entries: + metadata = entry.metadata or {} + input_path = _resolve_manifest_path(entry.image_path, manifest_dir) + image_paths.append(str(input_path)) + if not input_path.exists(): + issues.append(f"{entry.sample_id}: input image is missing: {input_path}") + elif entry.sha256: + actual_sha256 = sha256_file(input_path) + if actual_sha256 != entry.sha256: + issues.append(f"{entry.sample_id}: input image sha256 mismatch") + if not _metadata_has_any(metadata, SOURCE_DOCUMENT_KEYS): + counts["missing_source_document"] += 1 + if not _metadata_has_any(metadata, PAGE_KEYS): + counts["missing_page"] += 1 + if not _metadata_has_any(metadata, BBOX_KEYS): + counts["missing_bbox"] += 1 + if not _metadata_has_any(metadata, CLAIM_ELIGIBLE_KEYS): + counts["missing_claim_eligibility"] += 1 + if metadata.get("gt_status") == "human_verified" and not _metadata_has_any(metadata, HUMAN_REVIEW_EVIDENCE_KEYS): + counts["missing_human_review_evidence"] += 1 + for field in ("language", "script", "domain", "gt_status"): + if metadata.get(field) in (None, ""): + counts[f"missing_{field}"] += 1 + explicit = metadata.get("reference_path") + explicit_path = _resolve_manifest_path(explicit, manifest_dir) if isinstance(explicit, str) and explicit else None + if isinstance(explicit, str) and explicit and not explicit_path.exists(): + issues.append(f"{entry.sample_id}: reference_path does not exist: {explicit}") + continue + try: + reference = load_reference(input_path, explicit_path=explicit_path) + except Exception as exc: + issues.append(f"{entry.sample_id}: reference failed to parse: {type(exc).__name__}: {exc}") + continue + if reference is None: + issues.append(f"{entry.sample_id}: no reference found") + continue + counts["references"] += 1 + language = str(metadata.get("language") or recipe.get("language") or "unknown") + script = str(metadata.get("script") or recipe.get("script") or "unknown") + domain = str(metadata.get("domain") or eval_pack.get("domain") or "unknown") + gt_status = str(metadata.get("gt_status") or eval_pack.get("gt_status") or "unknown") + languages[language] = languages.get(language, 0) + 1 + scripts[script] = scripts.get(script, 0) + 1 + domains[domain] = domains.get(domain, 0) + 1 + gt_statuses[gt_status] = gt_statuses.get(gt_status, 0) + 1 + slice_key = ( + language, + script, + domain, + gt_status, + str(entry.split or eval_pack.get("split") or "eval"), + ) + reference_slice_counts[slice_key] = reference_slice_counts.get(slice_key, 0) + 1 + reference_metadata = reference.metadata or {} + if reference_metadata.get("reference_status") == "verified" and reference_metadata.get("claim_evidence_eligible") is True: + counts["claim_ready_references"] += 1 + else: + warnings.append(f"{entry.sample_id}: reference is not claim-ready") + duplicate_images = sorted({path for path in image_paths if image_paths.count(path) > 1}) + if duplicate_images: + issues.append(f"duplicate page eval image paths: {duplicate_images[:20]}") + for key in ( + "missing_source_document", + "missing_page", + "missing_bbox", + "missing_claim_eligibility", + "missing_human_review_evidence", + "missing_language", + "missing_script", + "missing_domain", + "missing_gt_status", + ): + count = counts[key] + if count: + warnings.append(f"{key}: {count}/{len(entries)}") + if counts["references"] != len(entries): + warnings.append(f"references: {counts['references']}/{len(entries)}") + if counts["claim_ready_references"] != len(entries): + warnings.append(f"claim_ready_references: {counts['claim_ready_references']}/{len(entries)}") + if counts["references"] < MIN_CLAIM_SCORING_UNITS: + warnings.append( + f"claim-facing sample size too small: {counts['references']} scoring units, minimum {MIN_CLAIM_SCORING_UNITS}" + ) + for (language, script, domain, gt_status, split), count in sorted(reference_slice_counts.items()): + if count < MIN_CLAIM_SCORING_UNITS: + warnings.append( + "slice sample size too small: " + f"{language}/{script}/{domain}/{gt_status}/{split} has {count} scoring units, minimum {MIN_CLAIM_SCORING_UNITS}" + ) + return { + "passed": not issues, + "claim_ready": not issues and not warnings, + "counts": counts, + "languages": dict(sorted(languages.items())), + "scripts": dict(sorted(scripts.items())), + "domains": dict(sorted(domains.items())), + "gt_statuses": dict(sorted(gt_statuses.items())), + "issues": issues, + "warnings": warnings, + } + + +def _validate_leakage_sources(root: Path, recipe_id: str, task: Any, sources: Any) -> tuple[list[str], list[str]]: + issues: list[str] = [] + blockers: list[str] = [] + if not isinstance(sources, list) or not sources: + return [f"{recipe_id}: leakage_sources must be a non-empty list"], ["no leakage sources declared"] + for idx, source in enumerate(sources): + if not isinstance(source, dict): + issues.append(f"{recipe_id}: leakage_sources[{idx}] must be an object") + continue + if source.get("manifest_file"): + _check_path(issues, root, recipe_id, f"leakage_sources[{idx}].manifest_file", source.get("manifest_file")) + _check_leakage_manifest( + issues, + blockers, + root, + recipe_id, + task, + f"leakage_sources[{idx}].manifest_file", + source.get("manifest_file"), + ) + else: + _check_path(issues, root, recipe_id, f"leakage_sources[{idx}].label_file", source.get("label_file")) + _check_path(issues, root, recipe_id, f"leakage_sources[{idx}].data_dir", source.get("data_dir")) + _check_leakage_label_source( + issues, + blockers, + root, + recipe_id, + f"leakage_sources[{idx}].label_file", + source.get("label_file"), + source.get("data_dir"), + ) + if not source.get("split"): + issues.append(f"{recipe_id}: leakage_sources[{idx}] missing split") + return issues, blockers + + +def validate_recipes(path: Path, root: Path) -> dict[str, Any]: + payload = _load_json(path) + recipes = payload.get("recipes") + if not isinstance(recipes, list) or not recipes: + raise ValueError("recipe file must contain a non-empty recipes list") + recipe_results: list[dict[str, Any]] = [] + ids: set[str] = set() + all_issues: list[str] = [] + for index, recipe in enumerate(recipes): + if not isinstance(recipe, dict): + issue = f"recipes[{index}] must be an object" + all_issues.append(issue) + recipe_results.append({"id": f"recipes[{index}]", "valid": False, "claim_ready": False, "issues": [issue], "claim_blockers": []}) + continue + recipe_id = str(recipe.get("id") or f"recipes[{index}]") + issues: list[str] = [] + blockers: list[str] = [] + if recipe_id in ids: + issues.append(f"{recipe_id}: duplicate recipe id") + ids.add(recipe_id) + for key in REQUIRED_RECIPE_KEYS: + if key not in recipe: + issues.append(f"{recipe_id}: missing required key {key}") + runner_issues, runner_blockers = _validate_runner(root, recipe_id, recipe.get("task"), recipe.get("runner")) + eval_issues, eval_blockers = _validate_eval_pack(root, recipe_id, recipe, recipe.get("task"), recipe.get("eval_pack")) + leakage_issues, leakage_blockers = _validate_leakage_sources(root, recipe_id, recipe.get("task"), recipe.get("leakage_sources")) + output_audit_issues, output_audit_blockers = _validate_page_output_audit(recipe_id, recipe) + dictionary_issues, dictionary_blockers = _dictionary_coverage_blockers(root, recipe) + candidate_evidence_issues, candidate_evidence_blockers, candidate_evidence_audit = _validate_page_candidate_evidence(root, recipe_id, recipe) + issues.extend(runner_issues) + issues.extend(eval_issues) + issues.extend(leakage_issues) + issues.extend(output_audit_issues) + issues.extend(candidate_evidence_issues) + issues.extend(f"{recipe_id}: {issue}" for issue in dictionary_issues) + blockers.extend(runner_blockers) + blockers.extend(eval_blockers) + blockers.extend(leakage_blockers) + blockers.extend(output_audit_blockers) + blockers.extend(candidate_evidence_blockers) + blockers.extend(dictionary_blockers) + eval_pack_audit: dict[str, Any] | None = None + spotcheck_calibration: dict[str, Any] | None = None + if isinstance(recipe.get("eval_pack"), dict): + spotcheck_calibration = _read_spotcheck_calibration( + issues, + root, + recipe_id, + recipe["eval_pack"].get("spotcheck_calibration_file"), + ) + if recipe.get("task") == RECOGNIZER_TASK and isinstance(recipe.get("eval_pack"), dict): + try: + eval_pack_audit = _audit_eval_pack(root, recipe, recipe["eval_pack"]) + except Exception as exc: + issues.append(f"{recipe_id}: eval pack audit failed: {type(exc).__name__}: {exc}") + elif recipe.get("task") == PAGE_TASK and isinstance(recipe.get("eval_pack"), dict): + try: + eval_pack_audit = _audit_page_eval_pack(root, recipe, recipe["eval_pack"]) + except Exception as exc: + issues.append(f"{recipe_id}: page eval pack audit failed: {type(exc).__name__}: {exc}") + if eval_pack_audit: + blockers.extend(f"eval pack audit issue: {issue}" for issue in eval_pack_audit.get("issues", [])) + blockers.extend(f"eval pack audit warning: {warning}" for warning in eval_pack_audit.get("warnings", [])) + if _audit_declares_spotchecked_gt(eval_pack_audit) and not recipe["eval_pack"].get("spotcheck_calibration_file"): + blockers.append("missing eval_pack.spotcheck_calibration_file for machine_converted_spot_checked GT rows") + if isinstance(recipe.get("eval_pack"), dict): + blockers.extend(_spotcheck_calibration_blockers(spotcheck_calibration, recipe, recipe["eval_pack"], eval_pack_audit)) + blockers.extend(f"known leakage acknowledged: {item}" for item in recipe.get("known_leakage", []) if item) + blockers.extend(str(item) for item in recipe.get("claim_blockers", []) if item) + all_issues.extend(issues) + recipe_results.append( + { + "id": recipe_id, + "task": recipe.get("task"), + "language": recipe.get("language"), + "script": recipe.get("script"), + "normalization_profile": recipe.get("eval_pack", {}).get("normalization_profile") + if isinstance(recipe.get("eval_pack"), dict) + else None, + "valid": not issues, + "claim_ready": not issues and not blockers, + "issues": issues, + "claim_blockers": sorted(set(blockers)), + "eval_pack_audit": { + "passed": eval_pack_audit.get("passed"), + "claim_ready": eval_pack_audit.get("claim_ready"), + "counts": eval_pack_audit.get("counts"), + "languages": eval_pack_audit.get("languages"), + "scripts": eval_pack_audit.get("scripts"), + "domains": eval_pack_audit.get("domains"), + "gt_statuses": eval_pack_audit.get("gt_statuses"), + "issues": eval_pack_audit.get("issues"), + "warnings": eval_pack_audit.get("warnings"), + } + if eval_pack_audit + else None, + "page_candidate_evidence": candidate_evidence_audit, + } + ) + return { + "recipe_file": str(path), + "root": str(root), + "recipe_count": len(recipes), + "valid": not all_issues, + "claim_ready_count": sum(1 for result in recipe_results if result["claim_ready"]), + "issues": all_issues, + "recipes": recipe_results, + } + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--recipes", type=Path, default=Path("configs/eval-harness-recipes-v1.json")) + parser.add_argument("--root", type=Path, default=Path(".")) + parser.add_argument("--out", type=Path) + parser.add_argument("--require-valid", action="store_true") + parser.add_argument("--require-claim-ready", action="store_true") + args = parser.parse_args(argv) + result = validate_recipes(args.recipes, args.root) + if args.out: + args.out.parent.mkdir(parents=True, exist_ok=True) + args.out.write_text(json.dumps(result, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + print( + f"recipes={result['recipe_count']} valid={result['valid']} " + f"claim_ready={result['claim_ready_count']}" + ) + if args.require_valid and not result["valid"]: + raise SystemExit(1) + if args.require_claim_ready and result["claim_ready_count"] != result["recipe_count"]: + raise SystemExit(1) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ocr-tech-mps-integration/tools/validate_eval_target_coverage.py b/ocr-tech-mps-integration/tools/validate_eval_target_coverage.py new file mode 100644 index 0000000000000000000000000000000000000000..70f53f475086167aa77d8de41ef5539e2a20bbee --- /dev/null +++ b/ocr-tech-mps-integration/tools/validate_eval_target_coverage.py @@ -0,0 +1,299 @@ +#!/usr/bin/env python3 +"""Validate target-language coverage against eval harness registries.""" + +from __future__ import annotations + +import argparse +import importlib.util +import json +from pathlib import Path +from types import ModuleType +from typing import Any + + +TOOLS_DIR = Path(__file__).resolve().parent +REQUIRED_TARGET_KEYS = ("language", "display_name", "script", "first_script_target", "eval_status") +KNOWN_EVAL_STATUSES = { + "missing_real_eval_pack", + "partial_real_recognizer_pack", + "shared_devanagari_pack", + "registered_real_pack", +} +CLAIM_READY_EVAL_STATUS = "registered_real_pack" + + +def _load_tool(name: str) -> ModuleType: + path = TOOLS_DIR / f"{name}.py" + spec = importlib.util.spec_from_file_location(name, path) + if spec is None or spec.loader is None: + raise RuntimeError(f"could not load tool module: {path}") + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def _read_json(path: Path) -> dict[str, Any]: + if not path.exists(): + raise FileNotFoundError(f"coverage config does not exist: {path}") + try: + payload = json.loads(path.read_text(encoding="utf-8")) + except json.JSONDecodeError as exc: + raise ValueError(f"coverage config is invalid JSON: {path}: {exc}") from exc + if not isinstance(payload, dict): + raise ValueError(f"coverage config must contain a JSON object: {path}") + return payload + + +def _target_sets(payload: dict[str, Any]) -> list[dict[str, Any]]: + sets = payload.get("target_sets") + if not isinstance(sets, list) or not sets: + raise ValueError("coverage config must contain a non-empty target_sets list") + return sets + + +def _by_id(rows: list[dict[str, Any]]) -> dict[str, dict[str, Any]]: + result: dict[str, dict[str, Any]] = {} + for row in rows: + row_id = str(row.get("id") or "") + if row_id: + result[row_id] = row + return result + + +def _validate_target_shape(target_set: dict[str, Any], target: Any, index: int) -> list[str]: + issues: list[str] = [] + set_id = str(target_set.get("id") or "target_set") + if not isinstance(target, dict): + return [f"{set_id}: targets[{index}] must be an object"] + for key in REQUIRED_TARGET_KEYS: + if key not in target or target[key] in (None, ""): + issues.append(f"{set_id}:{target.get('language', index)} missing required key {key}") + eval_status = target.get("eval_status") + if eval_status not in (None, "") and eval_status not in KNOWN_EVAL_STATUSES: + issues.append(f"{set_id}:{target.get('language', index)} unknown eval_status: {eval_status}") + return issues + + +def validate_coverage( + coverage_config: Path, + normalization_config: Path, + eval_recipes: Path, + root: Path, +) -> dict[str, Any]: + coverage_payload = _read_json(coverage_config) + normalization_tool = _load_tool("run_recognizer_pack_normalization") + recipe_tool = _load_tool("validate_eval_harness_recipes") + normalization = normalization_tool.validate_config(normalization_config, root) + recipes = recipe_tool.validate_recipes(eval_recipes, root) + normalization_by_id = _by_id(normalization["packs"]) + recipe_by_id = _by_id(recipes["recipes"]) + + set_results: list[dict[str, Any]] = [] + all_issues: list[str] = [] + all_gaps: list[str] = [] + for target_set in _target_sets(coverage_payload): + if not isinstance(target_set, dict): + issue = "target_sets entry must be an object" + all_issues.append(issue) + set_results.append({"id": "target_set", "valid": False, "targets": [], "issues": [issue], "gaps": []}) + continue + set_id = str(target_set.get("id") or "target_set") + targets = target_set.get("targets") + issues: list[str] = [] + gaps: list[str] = [] + target_results: list[dict[str, Any]] = [] + if not isinstance(targets, list) or not targets: + issues.append(f"{set_id}: targets must be a non-empty list") + targets = [] + seen_keys: set[tuple[str, str]] = set() + for index, target in enumerate(targets): + issues.extend(_validate_target_shape(target_set, target, index)) + if not isinstance(target, dict): + continue + language = str(target.get("language") or "") + script = str(target.get("script") or "") + key = (language, script) + if key in seen_keys: + issues.append(f"{set_id}:{language}/{script} duplicate target") + seen_keys.add(key) + normalization_pack_id = target.get("normalization_pack_id") + eval_recipe_id = target.get("eval_recipe_id") + page_eval_recipe_id = target.get("page_eval_recipe_id") + requires_page_eval_recipe = bool(target.get("requires_page_eval_recipe", target_set.get("requires_page_eval_recipe", False))) + requires_book_candidate_evidence = bool( + target.get("requires_book_candidate_evidence", target_set.get("requires_book_candidate_evidence", False)) + ) + eval_status = str(target.get("eval_status") or "") + normalization_result = normalization_by_id.get(str(normalization_pack_id)) if normalization_pack_id else None + recipe_result = recipe_by_id.get(str(eval_recipe_id)) if eval_recipe_id else None + page_recipe_result = recipe_by_id.get(str(page_eval_recipe_id)) if page_eval_recipe_id else None + page_candidate_evidence = page_recipe_result.get("page_candidate_evidence") if page_recipe_result else None + target_gaps: list[str] = [] + if eval_status == "missing_real_eval_pack" and (normalization_pack_id or eval_recipe_id): + target_gaps.append("missing_real_eval_pack target must not point at registered pack or recipe ids") + if not normalization_pack_id: + target_gaps.append("missing normalization_pack_id") + elif normalization_result is None: + target_gaps.append(f"normalization pack not found: {normalization_pack_id}") + elif not normalization_result.get("valid"): + target_gaps.append(f"normalization pack invalid: {normalization_pack_id}") + if not eval_recipe_id: + target_gaps.append("missing eval_recipe_id") + elif recipe_result is None: + target_gaps.append(f"eval recipe not found: {eval_recipe_id}") + elif not recipe_result.get("valid"): + target_gaps.append(f"eval recipe invalid: {eval_recipe_id}") + if requires_page_eval_recipe: + if not page_eval_recipe_id: + target_gaps.append("missing page_eval_recipe_id") + elif page_recipe_result is None: + target_gaps.append(f"page eval recipe not found: {page_eval_recipe_id}") + elif not page_recipe_result.get("valid"): + target_gaps.append(f"page eval recipe invalid: {page_eval_recipe_id}") + elif page_recipe_result.get("task") != "page_level_ocr": + target_gaps.append( + f"page eval recipe has wrong task: expected page_level_ocr, got {page_recipe_result.get('task')}" + ) + if requires_book_candidate_evidence: + if not requires_page_eval_recipe: + target_gaps.append("book candidate evidence requires page eval recipe requirement") + elif not page_recipe_result: + target_gaps.append("missing page eval recipe for book candidate evidence") + elif not isinstance(page_candidate_evidence, dict): + target_gaps.append("page eval recipe missing book candidate evidence") + else: + if page_candidate_evidence.get("admitted_operational") is not True: + target_gaps.append("book candidate evidence is not operationally admitted") + if page_candidate_evidence.get("claim_safe") is not True: + target_gaps.append("book candidate evidence is not claim-safe") + if normalization_result and not normalization_result.get("claim_ready"): + target_gaps.append("normalization pack is not claim-ready") + if recipe_result and not recipe_result.get("claim_ready"): + target_gaps.append("eval recipe is not claim-ready") + if page_recipe_result and not page_recipe_result.get("claim_ready"): + target_gaps.append("page eval recipe is not claim-ready") + if normalization_result and normalization_result.get("language") not in (None, language): + target_gaps.append( + f"normalization pack language mismatch: expected {language}, got {normalization_result.get('language')}" + ) + if normalization_result and normalization_result.get("script") not in (None, script): + target_gaps.append(f"normalization pack script mismatch: expected {script}, got {normalization_result.get('script')}") + if recipe_result and recipe_result.get("language") not in (None, language): + target_gaps.append(f"eval recipe language mismatch: expected {language}, got {recipe_result.get('language')}") + if recipe_result and recipe_result.get("script") not in (None, script): + target_gaps.append(f"eval recipe script mismatch: expected {script}, got {recipe_result.get('script')}") + if page_recipe_result and page_recipe_result.get("language") not in (None, language): + target_gaps.append(f"page eval recipe language mismatch: expected {language}, got {page_recipe_result.get('language')}") + if page_recipe_result and page_recipe_result.get("script") not in (None, script): + target_gaps.append(f"page eval recipe script mismatch: expected {script}, got {page_recipe_result.get('script')}") + if eval_status and eval_status != CLAIM_READY_EVAL_STATUS: + target_gaps.append(f"eval_status is not claim-ready: {eval_status}") + gaps.extend(f"{set_id}:{language}/{script}: {gap}" for gap in target_gaps) + target_results.append( + { + "language": language, + "script": script, + "display_name": target.get("display_name"), + "eval_status": target.get("eval_status"), + "normalization_pack_id": normalization_pack_id, + "normalization_language": normalization_result.get("language") if normalization_result else None, + "normalization_script": normalization_result.get("script") if normalization_result else None, + "normalization_valid": bool(normalization_result and normalization_result.get("valid")), + "normalization_claim_ready": bool(normalization_result and normalization_result.get("claim_ready")), + "eval_recipe_id": eval_recipe_id, + "eval_recipe_language": recipe_result.get("language") if recipe_result else None, + "eval_recipe_script": recipe_result.get("script") if recipe_result else None, + "eval_recipe_valid": bool(recipe_result and recipe_result.get("valid")), + "eval_recipe_claim_ready": bool(recipe_result and recipe_result.get("claim_ready")), + "requires_page_eval_recipe": requires_page_eval_recipe, + "requires_book_candidate_evidence": requires_book_candidate_evidence, + "page_eval_recipe_id": page_eval_recipe_id, + "page_eval_recipe_task": page_recipe_result.get("task") if page_recipe_result else None, + "page_eval_recipe_language": page_recipe_result.get("language") if page_recipe_result else None, + "page_eval_recipe_script": page_recipe_result.get("script") if page_recipe_result else None, + "page_eval_recipe_valid": bool(page_recipe_result and page_recipe_result.get("valid")), + "page_eval_recipe_claim_ready": bool(page_recipe_result and page_recipe_result.get("claim_ready")), + "book_candidate_evidence_present": isinstance(page_candidate_evidence, dict), + "book_candidate_admitted_operational": page_candidate_evidence.get("admitted_operational") + if isinstance(page_candidate_evidence, dict) + else None, + "book_candidate_claim_safe": page_candidate_evidence.get("claim_safe") + if isinstance(page_candidate_evidence, dict) + else None, + "coverage_ready": not target_gaps, + "gaps": target_gaps, + } + ) + all_issues.extend(issues) + all_gaps.extend(gaps) + set_results.append( + { + "id": set_id, + "description": target_set.get("description"), + "required_for_claim": bool(target_set.get("required_for_claim")), + "valid": not issues, + "target_count": len(target_results), + "coverage_ready_count": sum(1 for target in target_results if target["coverage_ready"]), + "gap_count": len(gaps), + "coverage_ready": not issues and not gaps, + "issues": issues, + "gaps": gaps, + "targets": target_results, + } + ) + return { + "coverage_config": str(coverage_config), + "normalization_config": str(normalization_config), + "eval_recipes": str(eval_recipes), + "root": str(root), + "valid": not all_issues, + "coverage_ready": not all_issues and not all_gaps, + "issue_count": len(all_issues), + "gap_count": len(all_gaps), + "issues": all_issues, + "gaps": all_gaps, + "target_sets": set_results, + "normalization": { + "pack_count": normalization["pack_count"], + "valid": normalization["valid"], + "claim_ready_count": normalization["claim_ready_count"], + }, + "eval_recipe_registry": { + "recipe_count": recipes["recipe_count"], + "valid": recipes["valid"], + "claim_ready_count": recipes["claim_ready_count"], + }, + } + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--coverage-config", type=Path, default=Path("configs/eval-target-coverage-v1.json")) + parser.add_argument("--normalization-config", type=Path, default=Path("configs/recognizer-eval-pack-normalization-v1.json")) + parser.add_argument("--eval-recipes", type=Path, default=Path("configs/eval-harness-recipes-v1.json")) + parser.add_argument("--root", type=Path, default=Path(".")) + parser.add_argument("--out", type=Path) + parser.add_argument("--require-valid", action="store_true") + parser.add_argument("--require-coverage-ready", action="store_true") + args = parser.parse_args(argv) + root = args.root.resolve() + coverage_config = args.coverage_config if args.coverage_config.is_absolute() else root / args.coverage_config + normalization_config = args.normalization_config if args.normalization_config.is_absolute() else root / args.normalization_config + eval_recipes = args.eval_recipes if args.eval_recipes.is_absolute() else root / args.eval_recipes + result = validate_coverage(coverage_config, normalization_config, eval_recipes, root) + if args.out: + args.out.parent.mkdir(parents=True, exist_ok=True) + args.out.write_text(json.dumps(result, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + print( + f"valid={result['valid']} coverage_ready={result['coverage_ready']} " + f"target_sets={len(result['target_sets'])} gaps={len(result['gaps'])}" + ) + if args.require_valid and not result["valid"]: + raise SystemExit(1) + if args.require_coverage_ready and not result["coverage_ready"]: + raise SystemExit(1) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ocr-tech-mps-integration/tools/validate_recognizer_training_admission_plan.py b/ocr-tech-mps-integration/tools/validate_recognizer_training_admission_plan.py new file mode 100644 index 0000000000000000000000000000000000000000..450220a639fdff5ed978bebe1b11f131be4ae3f2 --- /dev/null +++ b/ocr-tech-mps-integration/tools/validate_recognizer_training_admission_plan.py @@ -0,0 +1,566 @@ +#!/usr/bin/env python3 +"""Validate recognizer training/admission plans before held-out scoring.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +from pathlib import Path +from typing import Any + + +REQUIRED_PLAN_KEYS = ( + "id", + "language", + "script", + "model_family", + "training_bundle", + "selection_policy", + "admission_recipe", +) +REQUIRED_BUNDLE_KEYS = ( + "archive", + "archive_sha256", + "manifest", + "manifest_sha256", + "recipe_backend", + "run_command_after_extract", + "bundle_train_manifest", + "bundle_dev_manifest", +) +REQUIRED_SELECTION_KEYS = ( + "train_manifest", + "dev_manifest", + "train_plus_dev_manifest", + "sealed_eval_manifest", + "sealed_eval_label_file", + "allowed_checkpoint_selection_splits", + "forbidden_checkpoint_selection_splits", + "expected_split_counts", + "required_no_overlap_fields", +) +REQUIRED_RECIPE_KEYS = ( + "registry", + "recipe_id", + "requires_unseen_for_selection", + "requires_selected_checkpoint_on_test", + "requires_eval_split", + "requires_leakage_source_manifest", +) +OVERLAP_FIELD_ALIASES = { + "image_sha256": ("image_sha256", "sha256"), +} + + +def _read_json(path: Path) -> dict[str, Any]: + if not path.exists(): + raise FileNotFoundError(f"plan file does not exist: {path}") + try: + payload = json.loads(path.read_text(encoding="utf-8")) + except json.JSONDecodeError as exc: + raise ValueError(f"plan file is invalid JSON: {path}: {exc}") from exc + if not isinstance(payload, dict): + raise ValueError(f"plan file must contain a JSON object: {path}") + return payload + + +def _resolve(root: Path, value: str) -> Path: + path = Path(value) + if path.is_absolute(): + return path + return root / path + + +def _sha256_file(path: Path) -> str: + digest = hashlib.sha256() + with path.open("rb") as handle: + for chunk in iter(lambda: handle.read(1024 * 1024), b""): + digest.update(chunk) + return digest.hexdigest() + + +def _check_required(issues: list[str], owner: str, payload: Any, keys: tuple[str, ...]) -> bool: + if not isinstance(payload, dict): + issues.append(f"{owner} must be an object") + return False + ok = True + for key in keys: + if key not in payload or payload.get(key) in (None, ""): + issues.append(f"{owner} missing required key {key}") + ok = False + return ok + + +def _load_jsonl_manifest(issues: list[str], path: Path, label: str) -> list[dict[str, Any]]: + rows: list[dict[str, Any]] = [] + if not path.exists(): + issues.append(f"{label} does not exist: {path}") + return rows + try: + with path.open("r", encoding="utf-8") as handle: + for line_no, line in enumerate(handle, 1): + if not line.strip(): + continue + try: + payload = json.loads(line) + except json.JSONDecodeError as exc: + issues.append(f"{label}:{line_no}: invalid JSON: {exc}") + return rows + if not isinstance(payload, dict): + issues.append(f"{label}:{line_no}: row must be an object") + return rows + rows.append(payload) + except OSError as exc: + issues.append(f"{label} could not be read: {path}: {exc}") + return rows + if not rows: + issues.append(f"{label} has no rows: {path}") + return rows + + +def _row_value(row: dict[str, Any], field: str) -> str: + keys = OVERLAP_FIELD_ALIASES.get(field, (field,)) + for key in keys: + value = row.get(key) + if value not in (None, ""): + return str(value) + metadata = row.get("metadata") + if isinstance(metadata, dict): + for key in keys: + value = metadata.get(key) + if value not in (None, ""): + return str(value) + return "" + + +def _field_set(rows: list[dict[str, Any]], field: str) -> set[str]: + return {value for row in rows if (value := _row_value(row, field))} + + +def _check_overlap( + blockers: list[str], + left_name: str, + left_rows: list[dict[str, Any]], + right_name: str, + right_rows: list[dict[str, Any]], + fields: list[str], +) -> dict[str, int]: + counts: dict[str, int] = {} + for field in fields: + overlap = _field_set(left_rows, field) & _field_set(right_rows, field) + counts[field] = len(overlap) + if overlap: + examples = sorted(overlap)[:5] + blockers.append( + f"{left_name} overlaps {right_name} by {field}: {len(overlap)} examples={examples}" + ) + return counts + + +def _read_bundle_manifest(issues: list[str], path: Path) -> dict[str, Any] | None: + if not path.exists(): + issues.append(f"training bundle manifest does not exist: {path}") + return None + try: + payload = json.loads(path.read_text(encoding="utf-8")) + except json.JSONDecodeError as exc: + issues.append(f"training bundle manifest is invalid JSON: {path}: {exc}") + return None + if not isinstance(payload, dict): + issues.append(f"training bundle manifest must contain a JSON object: {path}") + return None + return payload + + +def _select_recipe(issues: list[str], registry_path: Path, recipe_id: str) -> dict[str, Any] | None: + if not registry_path.exists(): + issues.append(f"admission recipe registry does not exist: {registry_path}") + return None + try: + payload = json.loads(registry_path.read_text(encoding="utf-8")) + except json.JSONDecodeError as exc: + issues.append(f"admission recipe registry is invalid JSON: {registry_path}: {exc}") + return None + recipes = payload.get("recipes") + if not isinstance(recipes, list): + issues.append(f"admission recipe registry has no recipes list: {registry_path}") + return None + matches = [recipe for recipe in recipes if isinstance(recipe, dict) and recipe.get("id") == recipe_id] + if len(matches) != 1: + issues.append(f"admission recipe id must resolve exactly once: {recipe_id} matches={len(matches)}") + return None + return matches[0] + + +def _check_path_sha( + issues: list[str], + root: Path, + path_value: str, + expected_sha: str, + label: str, +) -> Path | None: + path = _resolve(root, path_value) + if not path.exists(): + issues.append(f"{label} does not exist: {path_value}") + return None + actual_sha = _sha256_file(path) + if actual_sha != expected_sha: + issues.append(f"{label} sha256 mismatch: expected {expected_sha}, got {actual_sha}") + return path + + +def _split_counts(rows_by_split: dict[str, list[dict[str, Any]]]) -> dict[str, int]: + return {split: len(rows) for split, rows in rows_by_split.items()} + + +def _manifest_splits(rows: list[dict[str, Any]]) -> set[str]: + splits: set[str] = set() + for row in rows: + split = row.get("split") + metadata = row.get("metadata") + if split in (None, "") and isinstance(metadata, dict): + split = metadata.get("split") + if split not in (None, ""): + splits.add(str(split)) + return splits + + +def _check_expected_counts( + blockers: list[str], + expected_counts: dict[str, Any], + actual_counts: dict[str, int], +) -> None: + for split, expected in expected_counts.items(): + if not isinstance(expected, int): + blockers.append(f"expected count for {split} must be an integer") + continue + actual = actual_counts.get(split) + if actual != expected: + blockers.append(f"{split} row count mismatch: expected {expected}, got {actual}") + + +def _check_min_counts( + blockers: list[str], + selection: dict[str, Any], + actual_counts: dict[str, int], +) -> None: + minimums = { + "train": selection.get("min_train_samples"), + "dev": selection.get("min_dev_samples"), + "eval": selection.get("min_sealed_eval_samples"), + } + for split, minimum in minimums.items(): + if minimum in (None, ""): + continue + if not isinstance(minimum, int): + blockers.append(f"minimum sample count for {split} must be an integer") + continue + if actual_counts.get(split, 0) < minimum: + blockers.append(f"{split} has fewer than {minimum} samples: {actual_counts.get(split, 0)}") + + +def _check_selection_policy( + blockers: list[str], + selection: dict[str, Any], + rows_by_split: dict[str, list[dict[str, Any]]], +) -> dict[str, Any]: + allowed = selection.get("allowed_checkpoint_selection_splits") + forbidden = selection.get("forbidden_checkpoint_selection_splits") + if not isinstance(allowed, list) or not all(isinstance(item, str) for item in allowed): + blockers.append("allowed_checkpoint_selection_splits must be a list of strings") + allowed = [] + if not isinstance(forbidden, list) or not all(isinstance(item, str) for item in forbidden): + blockers.append("forbidden_checkpoint_selection_splits must be a list of strings") + forbidden = [] + if "eval" in allowed: + blockers.append("sealed eval split must not be allowed for checkpoint selection") + if "eval" not in forbidden: + blockers.append("sealed eval split must be explicitly forbidden for checkpoint selection") + fields = selection.get("required_no_overlap_fields") + if not isinstance(fields, list) or not all(isinstance(item, str) for item in fields): + blockers.append("required_no_overlap_fields must be a list of strings") + fields = [] + overlap_counts: dict[str, dict[str, int]] = {} + overlap_counts["train_vs_dev"] = _check_overlap( + blockers, + "train", + rows_by_split["train"], + "dev", + rows_by_split["dev"], + fields, + ) + overlap_counts["train_vs_eval"] = _check_overlap( + blockers, + "train", + rows_by_split["train"], + "eval", + rows_by_split["eval"], + fields, + ) + overlap_counts["dev_vs_eval"] = _check_overlap( + blockers, + "dev", + rows_by_split["dev"], + "eval", + rows_by_split["eval"], + fields, + ) + return { + "allowed_checkpoint_selection_splits": allowed, + "forbidden_checkpoint_selection_splits": forbidden, + "overlap_counts": overlap_counts, + } + + +def _check_bundle( + issues: list[str], + blockers: list[str], + root: Path, + bundle: dict[str, Any], +) -> dict[str, Any]: + archive_path = _check_path_sha( + issues, + root, + str(bundle.get("archive") or ""), + str(bundle.get("archive_sha256") or ""), + "training bundle archive", + ) + manifest_path = _check_path_sha( + issues, + root, + str(bundle.get("manifest") or ""), + str(bundle.get("manifest_sha256") or ""), + "training bundle manifest", + ) + bundle_payload = _read_bundle_manifest(issues, manifest_path) if manifest_path else None + if bundle_payload: + if bundle_payload.get("recipe_backend") != bundle.get("recipe_backend"): + blockers.append( + "training bundle recipe_backend mismatch: " + f"bundle={bundle_payload.get('recipe_backend')!r} plan={bundle.get('recipe_backend')!r}" + ) + if bundle_payload.get("run_command") != bundle.get("run_command_after_extract"): + blockers.append("training bundle run command does not match the plan") + if bundle_payload.get("train_manifest") != bundle.get("bundle_train_manifest"): + blockers.append("training bundle train manifest path does not match the plan") + if bundle_payload.get("eval_manifest") != bundle.get("bundle_dev_manifest"): + blockers.append("training bundle dev/eval manifest path does not match the plan") + corpus_audit = bundle_payload.get("recognizer_corpus_audit") + if not isinstance(corpus_audit, dict) or corpus_audit.get("passed") is not True: + blockers.append("training bundle does not record a passing recognizer corpus audit") + return { + "archive": str(archive_path) if archive_path else None, + "manifest": str(manifest_path) if manifest_path else None, + "bundle_manifest_read": bundle_payload is not None, + } + + +def _check_recipe( + issues: list[str], + blockers: list[str], + root: Path, + recipe_plan: dict[str, Any], + selection: dict[str, Any], +) -> dict[str, Any]: + registry_path = _resolve(root, str(recipe_plan.get("registry") or "")) + recipe = _select_recipe(issues, registry_path, str(recipe_plan.get("recipe_id") or "")) + if not recipe: + return {"resolved": False} + runner = recipe.get("runner") if isinstance(recipe.get("runner"), dict) else {} + eval_pack = recipe.get("eval_pack") if isinstance(recipe.get("eval_pack"), dict) else {} + leakage_sources = recipe.get("leakage_sources") + if not isinstance(leakage_sources, list): + blockers.append("admission recipe leakage_sources must be a list") + leakage_sources = [] + + if eval_pack.get("manifest_file") != selection.get("sealed_eval_manifest"): + blockers.append("admission recipe eval manifest does not point at sealed_eval_manifest") + if eval_pack.get("label_file") != selection.get("sealed_eval_label_file"): + blockers.append("admission recipe eval label file does not point at sealed_eval_label_file") + if eval_pack.get("split") != recipe_plan.get("requires_eval_split"): + blockers.append("admission recipe split does not match the required eval split") + if eval_pack.get("unseen_for_selection") is not recipe_plan.get("requires_unseen_for_selection"): + blockers.append("admission recipe unseen_for_selection does not match the plan") + if runner.get("selected_checkpoint_on_test") is not recipe_plan.get("requires_selected_checkpoint_on_test"): + blockers.append("admission recipe selected_checkpoint_on_test does not match the plan") + required_leakage = recipe_plan.get("requires_leakage_source_manifest") + expected_leakage = [{"manifest_file": required_leakage, "split": "train_dev"}] + if leakage_sources != expected_leakage: + blockers.append(f"admission recipe leakage_sources mismatch: expected {expected_leakage!r}") + + command_template = str(runner.get("command_template") or "") + unresolved = "REPLACE_WITH" in command_template or runner.get("requires_operator_resolution") is True + checkpoint = runner.get("checkpoint") or runner.get("model_card") + claim_blockers = recipe.get("claim_blockers") if isinstance(recipe.get("claim_blockers"), list) else [] + heldout_admission_ready = not unresolved and bool(checkpoint) and not claim_blockers + return { + "resolved": True, + "recipe_id": recipe.get("id"), + "runner_type": runner.get("type"), + "external_command_unresolved": unresolved, + "checkpoint_or_model_card_present": bool(checkpoint), + "claim_blocker_count": len(claim_blockers), + "heldout_admission_ready": heldout_admission_ready, + } + + +def _validate_plan(plan: dict[str, Any], root: Path) -> dict[str, Any]: + issues: list[str] = [] + blockers: list[str] = [] + _check_required(issues, "plan", plan, REQUIRED_PLAN_KEYS) + bundle = plan.get("training_bundle") + selection = plan.get("selection_policy") + recipe_plan = plan.get("admission_recipe") + if isinstance(bundle, dict): + _check_required(issues, "training_bundle", bundle, REQUIRED_BUNDLE_KEYS) + else: + _check_required(issues, "training_bundle", bundle, REQUIRED_BUNDLE_KEYS) + bundle = {} + if isinstance(selection, dict): + _check_required(issues, "selection_policy", selection, REQUIRED_SELECTION_KEYS) + else: + _check_required(issues, "selection_policy", selection, REQUIRED_SELECTION_KEYS) + selection = {} + if isinstance(recipe_plan, dict): + _check_required(issues, "admission_recipe", recipe_plan, REQUIRED_RECIPE_KEYS) + else: + _check_required(issues, "admission_recipe", recipe_plan, REQUIRED_RECIPE_KEYS) + recipe_plan = {} + + bundle_result = _check_bundle(issues, blockers, root, bundle) if isinstance(bundle, dict) else {} + + rows_by_split = { + "train": _load_jsonl_manifest(issues, _resolve(root, str(selection.get("train_manifest") or "")), "train_manifest"), + "dev": _load_jsonl_manifest(issues, _resolve(root, str(selection.get("dev_manifest") or "")), "dev_manifest"), + "eval": _load_jsonl_manifest( + issues, + _resolve(root, str(selection.get("sealed_eval_manifest") or "")), + "sealed_eval_manifest", + ), + "train_plus_dev": _load_jsonl_manifest( + issues, + _resolve(root, str(selection.get("train_plus_dev_manifest") or "")), + "train_plus_dev_manifest", + ), + } + actual_counts = _split_counts(rows_by_split) + if rows_by_split["train_plus_dev"]: + train_dev_ids = _field_set(rows_by_split["train"], "sample_id") | _field_set(rows_by_split["dev"], "sample_id") + combined_ids = _field_set(rows_by_split["train_plus_dev"], "sample_id") + if train_dev_ids != combined_ids: + blockers.append("train_plus_dev_manifest does not exactly match train+dev sample ids") + for split in ("train", "dev", "eval"): + observed_splits = _manifest_splits(rows_by_split[split]) + if observed_splits and observed_splits != {split}: + blockers.append(f"{split}_manifest contains unexpected split values: {sorted(observed_splits)}") + if isinstance(selection.get("expected_split_counts"), dict): + _check_expected_counts(blockers, selection["expected_split_counts"], actual_counts) + _check_min_counts(blockers, selection, actual_counts) + selection_result = _check_selection_policy(blockers, selection, rows_by_split) if isinstance(selection, dict) else {} + recipe_result = _check_recipe(issues, blockers, root, recipe_plan, selection) if isinstance(recipe_plan, dict) else {} + + training_ready = not issues and not blockers + return { + "id": plan.get("id"), + "language": plan.get("language"), + "script": plan.get("script"), + "model_family": plan.get("model_family"), + "valid": not issues, + "training_ready": training_ready, + "heldout_admission_ready": bool(recipe_result.get("heldout_admission_ready")) and training_ready, + "issues": issues, + "blockers": blockers, + "counts": actual_counts, + "bundle": bundle_result, + "selection": selection_result, + "admission_recipe": recipe_result, + } + + +def validate_plans(plan_file: Path, root: Path) -> dict[str, Any]: + payload = _read_json(plan_file) + plans = payload.get("plans") + if not isinstance(plans, list) or not plans: + raise ValueError("plan file must contain a non-empty plans list") + results: list[dict[str, Any]] = [] + for index, plan in enumerate(plans): + if not isinstance(plan, dict): + results.append( + { + "id": f"plans[{index}]", + "valid": False, + "training_ready": False, + "heldout_admission_ready": False, + "issues": [f"plans[{index}] must be an object"], + "blockers": [], + } + ) + continue + results.append(_validate_plan(plan, root)) + issues = [issue for result in results for issue in result.get("issues", [])] + blockers = [blocker for result in results for blocker in result.get("blockers", [])] + return { + "plan_file": str(plan_file), + "root": str(root), + "version": payload.get("version"), + "valid": not issues, + "training_ready": not issues and not blockers, + "heldout_admission_ready_count": sum(1 for result in results if result["heldout_admission_ready"]), + "plan_count": len(results), + "issue_count": len(issues), + "blocker_count": len(blockers), + "issues": issues, + "blockers": blockers, + "plans": results, + } + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument( + "--plan", + type=Path, + default=Path("configs/limbu-devanagari-ppocrv5-admission-plan-v1.json"), + ) + parser.add_argument("--root", type=Path, default=Path(".")) + parser.add_argument("--out", type=Path, default=Path("outputs/recognizer-training-admission-plan-validation")) + args = parser.parse_args(argv) + + result = validate_plans(args.plan, args.root) + args.out.mkdir(parents=True, exist_ok=True) + (args.out / "recognizer-training-admission-plan-validation.json").write_text( + json.dumps(result, ensure_ascii=False, indent=2) + "\n", + encoding="utf-8", + ) + lines = [ + "# Recognizer Training Admission Plan Validation", + "", + f"- plan file: {result['plan_file']}", + f"- valid: {result['valid']}", + f"- training ready: {result['training_ready']}", + f"- held-out admission ready count: {result['heldout_admission_ready_count']}", + f"- issues: {result['issue_count']}", + f"- blockers: {result['blocker_count']}", + ] + if result["issues"]: + lines.extend(["", "## Issues", ""]) + lines.extend(f"- {issue}" for issue in result["issues"]) + if result["blockers"]: + lines.extend(["", "## Blockers", ""]) + lines.extend(f"- {blocker}" for blocker in result["blockers"]) + (args.out / "recognizer-training-admission-plan-validation.md").write_text( + "\n".join(lines) + "\n", + encoding="utf-8", + ) + print(args.out / "recognizer-training-admission-plan-validation.json") + print( + f"plans={result['plan_count']} valid={result['valid']} " + f"training_ready={result['training_ready']} " + f"heldout_admission_ready={result['heldout_admission_ready_count']}" + ) + return 0 if result["valid"] else 1 + + +if __name__ == "__main__": + raise SystemExit(main())