Spaces:
Paused
Paused
Download scripts/layout_service.py from CedM/vLLM_VLM_OCR_Nginx: direct link, hf CLI and curl.
- Browser
- Download file 10.3 kB
-
https://huggingface.co/spaces/CedM/vLLM_VLM_OCR_Nginx/resolve/main/scripts/layout_service.py
- Command line
-
hf download hf://spaces/CedM/vLLM_VLM_OCR_Nginx/scripts/layout_service.py
-
curl -L -o layout_service.py https://huggingface.co/spaces/CedM/vLLM_VLM_OCR_Nginx/resolve/main/scripts/layout_service.py
10.3 kB
| #!/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:<mime>;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_<id> | |
| 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 <table>), 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'])})") | |
| 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 | |
| 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"] | |
| 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") | |