#!/usr/bin/env python3 """ Layout service (CPU only, 0 GB VRAM). Pipeline for /OCR_parse: 1. PP-DocLayoutV3 (ONNX Runtime, CPU) detects layout regions (polygons, classes, scores) and reading order on the input image / PDF page. 2. Each region is cropped and sent to the local GLM-OCR vLLM instance (127.0.0.1:8001, served model name from SERVED_OCR) with a prompt adapted to the region class (text / table / formula / figure ...). 3. Results are aggregated in reading order into a single Markdown document. Endpoints (internal, behind Nginx at /OCR_parse/*): GET /health -> 200 once the ONNX model is loaded, 503 otherwise POST /parse -> {"image": "data:;base64,...", "max_tokens": 4096, "score_threshold": 0.5} -> {"pages": n, "regions": [...], "markdown": "..."} PaddlePaddle is intentionally NOT used: the official ONNX export of PaddlePaddle/PP-DocLayoutV3 runs on CPU via onnxruntime (no conflict with torch/vLLM). """ import base64 import glob import io import os import time from contextlib import asynccontextmanager import numpy as np import httpx import onnxruntime as ort from fastapi import FastAPI, HTTPException from PIL import Image from pydantic import BaseModel from huggingface_hub import snapshot_download LAYOUT_MODEL = os.getenv("LAYOUT_MODEL", "PaddlePaddle/PP-DocLayoutV3_onnx") LAYOUT_PORT = int(os.getenv("LAYOUT_PORT", "8003")) PORT_OCR = int(os.getenv("PORT_OCR", "8001")) SERVED_OCR = os.getenv("SERVED_OCR", "glm-ocr") # Partial label map for PP-DocLayout (25 classes); unknown ids fall back to class_ LABELS = { 0: "text", 1: "title", 2: "figure", 3: "table", 4: "formula", 5: "header", 6: "footer", 7: "page_number", 8: "caption", 9: "reference", 10: "list", 11: "code", 12: "abstract", 13: "author", 14: "keywords", 15: "seal", 16: "image", 17: "paragraph", } PROMPTS = { "table": "Convertis le tableau de cette image en HTML fidele (balises ), sans aucun commentaire.", "formula": "Transcris la ou les formules mathematiques de cette image en LaTeX pur, sans explication.", "figure": "Decris brievement cette figure en une phrase.", "image": "Decris brievement cette image en une phrase.", "seal": "Decris ce sceau/tampon : texte lisible et forme.", "title": "Extrais le titre de cette image, tel quel, sans commentaire.", "code": "Extrais le code de cette image tel quel, dans un bloc de code, sans commentaire.", } DEFAULT_PROMPT = "Extrais tout le texte de cette image tel quel, sans commentaire." state = {"ready": False, "session": None, "input_name": None, "in_w": 640, "in_h": 640, "error": None} HTTPX = httpx.Client(timeout=900.0) def load_model(): """Download (cached in HF_HOME) and load the PP-DocLayoutV3 ONNX model on CPU.""" print(f"[layout] Downloading {LAYOUT_MODEL} (cached in {os.getenv('HF_HOME', '/data/hf')})...") t0 = time.time() snapshot_dir = snapshot_download( repo_id=LAYOUT_MODEL, allow_patterns=["*.onnx", "*.json", "*.txt", "*.yml", "*.yaml"], ) onnx_files = glob.glob(os.path.join(snapshot_dir, "**", "*.onnx"), recursive=True) if not onnx_files: raise RuntimeError(f"No .onnx file found in {snapshot_dir}") # prefer model.onnx, else the largest (fp32) one onnx_files.sort(key=lambda p: (os.path.basename(p) != "model.onnx", -os.path.getsize(p))) model_path = onnx_files[0] print(f"[layout] Loading ONNX model: {model_path} ({os.path.getsize(model_path)/1e6:.1f} MB)") sess = ort.InferenceSession(model_path, providers=["CPUExecutionProvider"]) inputs = sess.get_inputs() # Paddle-style export: 3 inputs -> image (NCHW), im_shape (N,2), scale_factor (N,2) image_input = next(i for i in inputs if len(i.shape) == 4) h = image_input.shape[2] if isinstance(image_input.shape[2], int) else 800 w = image_input.shape[3] if isinstance(image_input.shape[3], int) else 800 state["in_h"], state["in_w"] = int(h), int(w) state["input_names"] = {i.name: len(i.shape) for i in inputs} state["session"] = sess state["ready"] = True print(f"[layout] Model ready in {time.time()-t0:.1f}s (input {state['in_w']}x{state['in_h']}, CPU, inputs={list(state['input_names'])})") @asynccontextmanager async def lifespan(app: FastAPI): try: load_model() except Exception as e: state["error"] = str(e) print(f"[layout] FATAL: {e}") yield app = FastAPI(title="PP-DocLayoutV3 layout service (CPU)", lifespan=lifespan) class ParseRequest(BaseModel): image: str # data URL (image/* or application/pdf) or raw base64 max_tokens: int = 4096 score_threshold: float = 0.5 @app.get("/health") def health(): if state["ready"]: return {"status": "ok", "model": LAYOUT_MODEL, "device": "cpu"} raise HTTPException(status_code=503, detail=f"layout model not ready: {state['error']}") def split_data_url(s: str): if s.startswith("data:"): head, _, b64 = s.partition(",") mime = head[5:].split(";")[0] or "application/octet-stream" return mime, b64 return "application/octet-stream", s def pdf_pages_to_images(raw: bytes): import pymupdf # pymupdf (fitz) doc = pymupdf.open(stream=raw, filetype="pdf") pages = [] for page in doc: pix = page.get_pixmap(dpi=200) pages.append(Image.frombytes("RGB", (pix.width, pix.height), pix.samples)) doc.close() return pages def detect_regions(img: Image.Image, score_threshold: float): """Run PP-DocLayoutV3 ONNX on one page image, return regions in reading order. Official PaddlePaddle/PP-DocLayoutV3_onnx export: inputs : image (N,3,H,W) float32 rescaled 1/255 (mean 0, std 1), im_shape (N,2) = [orig_h, orig_w], scale_factor (N,2) = [orig_h/H, orig_w/W] outputs: fetch_name_0 (N,7) rows = [class_id, score, x1, y1, x2, y2, order] (boxes in original image coordinates), plus a label count and a mask (ignored) """ sess = state["session"] orig_w, orig_h = img.size in_w, in_h = state["in_w"], state["in_h"] resized = img.resize((in_w, in_h)) arr = np.asarray(resized, dtype=np.float32) / 255.0 image_tensor = arr.transpose(2, 0, 1)[None, ...] # NCHW im_shape = np.array([[orig_h, orig_w]], dtype=np.float32) scale_factor = np.array([[orig_h / in_h, orig_w / in_w]], dtype=np.float32) feed = {} for name, ndim in state["input_names"].items(): lname = name.lower() if ndim == 4 or lname == "image": feed[name] = image_tensor elif "im_shape" in lname or ndim == 2 and "scale" not in lname and "shape" in lname: feed[name] = im_shape elif "scale" in lname or ndim == 2: feed[name] = scale_factor outputs = sess.run(None, feed) rows = None for out in outputs: a = np.asarray(out) if a.ndim == 2 and a.shape[-1] == 7: rows = a break if rows is None: raise RuntimeError(f"Unexpected ONNX outputs: {[np.asarray(o).shape for o in outputs]}") regions = [] for row in rows: cls_id, score = int(row[0]), float(row[1]) x1, y1, x2, y2 = [float(v) for v in row[2:6]] order = int(row[6]) if score < score_threshold: continue x1, y1 = max(0.0, x1), max(0.0, y1) x2, y2 = min(orig_w, x2), min(orig_h, y2) if x2 - x1 < 8 or y2 - y1 < 8: continue regions.append({ "label": LABELS.get(cls_id, f"class_{cls_id}"), "score": round(score, 4), "bbox": [round(x1, 1), round(y1, 1), round(x2, 1), round(y2, 1)], "polygon": None, "order": order, }) regions.sort(key=lambda r: r["order"]) for idx, r in enumerate(regions): r["order"] = idx return regions def ocr_region(crop: Image.Image, label: str, max_tokens: int) -> str: buf = io.BytesIO() crop.save(buf, format="JPEG", quality=90) b64 = base64.b64encode(buf.getvalue()).decode() payload = { "model": SERVED_OCR, "messages": [{ "role": "user", "content": [ {"type": "text", "text": PROMPTS.get(label, DEFAULT_PROMPT)}, {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{b64}"}}, ], }], "max_tokens": max_tokens, "temperature": 0.0, } r = HTTPX.post(f"http://127.0.0.1:{PORT_OCR}/v1/chat/completions", json=payload) r.raise_for_status() return r.json()["choices"][0]["message"]["content"] @app.post("/parse") def parse(req: ParseRequest): if not state["ready"]: raise HTTPException(status_code=503, detail=f"layout model not ready: {state['error']}") mime, b64 = split_data_url(req.image) try: raw = base64.b64decode(b64, validate=True) except Exception: raise HTTPException(status_code=400, detail="Invalid base64 image data") if mime == "application/pdf" or raw[:5] == b"%PDF-": pages = pdf_pages_to_images(raw) else: try: pages = [Image.open(io.BytesIO(raw)).convert("RGB")] except Exception: raise HTTPException(status_code=400, detail=f"Unsupported or unreadable image (mime={mime})") all_regions = [] md_parts = [] for pidx, page in enumerate(pages): regions = detect_regions(page, req.score_threshold) for r in regions: x1, y1, x2, y2 = [int(round(v)) for v in r["bbox"]] crop = page.crop((x1, y1, x2, y2)) try: r["ocr"] = ocr_region(crop, r["label"], req.max_tokens) except Exception as e: r["ocr"] = f"[OCR error: {e}]" r["page"] = pidx + 1 all_regions.append(r) md_parts.append(r["ocr"]) print(f"[layout] page {pidx+1}/{len(pages)}: {len(regions)} regions") return {"pages": len(pages), "regions": all_regions, "markdown": "\n\n".join(md_parts)} if __name__ == "__main__": import uvicorn uvicorn.run(app, host="127.0.0.1", port=LAYOUT_PORT, log_level="info")