| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| """ |
| Convert document images to markdown with OpenBMB's MiniCPM-OCR 1.0 pipeline. |
| |
| MiniCPM-OCR 1.0 (1.3B, Apache-2.0) is a region reader: the official SDK finds layout regions |
| with PP-DocLayoutV3, crops them, sends each crop to the model with the prompt for its type |
| (`Text Recognition:`, `Table Recognition:`, `Formula Recognition:`, ...) and assembles the page |
| as Markdown (tables as HTML, formulas as LaTeX). This script runs that pipeline unchanged. |
| |
| Two ways in and out: |
| |
| # Hub dataset -> Hub dataset (adds `markdown` and `markdown_status` columns) |
| hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/minicpm-ocr.py \\ |
| input-dataset output-dataset --max-samples 20 |
| |
| # Bucket (or folder) of page images -> one .md per image in a Bucket (or folder) |
| hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/minicpm-ocr.py \\ |
| hf://buckets/<ns>/<bucket>/pages hf://buckets/<ns>/<bucket>/minicpm-ocr |
| |
| Bucket input is listed and downloaded in batches with bucketbag (no mount); `x/y.jp2` becomes |
| `x/y.md` under the output prefix. A page whose regions all read cleanly is written; a page with |
| failed regions is not, and is listed at the end, so re-running the same command retries it (pages |
| with a `.md` already are skipped). In dataset mode every row gets a `markdown_status`: `ok`, |
| `partial_failed` (some regions failed; the text is kept), `failed` or `error: ...` (no text). |
| |
| Runtime image (from the [tool.hf-jobs] header): cr.hf.co/davanstrien/minicpm-ocr, built from |
| images/minicpm-ocr/Dockerfile. It holds: |
| - vLLM nightly 5d35ce3. MiniCPMOcrForConditionalGeneration landed in vLLM main on 23 Oct 2026 |
| and is not in a release yet. Drop the custom image for a stock vllm/vllm-openai tag once a |
| release has the architecture. |
| - transformers at OpenBMB's pin (549e5b4). |
| - The minicpm-ocr SDK 1.0.1 in its own venv (/opt/sdk) with PaddlePaddle GPU, as OpenBMB's docs |
| require (SDK and inference service in separate environments), and the PP-DocLayoutV3 layout |
| model baked in at /opt/minicpm-ocr-assets. |
| |
| Server settings follow OpenBMB's SDK tutorial (docs/minicpmvocr_tutorial_en.md): max-model-len |
| 40960, 32 sequences, image limit 36, `downsample_mode` 4x, thinking off, DSpark speculative |
| decoding with the matching draft model (`--no-dspark` for plain decoding). The SDK's bundled |
| config sets sampling and per-region prompts; nothing here overrides them. The SDK reads page |
| numbers, headers, footers, footnotes and side notes but leaves them out of the Markdown; |
| `--keep-labels footnote aside_text` puts those region types back. |
| |
| Model: https://huggingface.co/openbmb/MiniCPM-OCR-1.0 |
| SDK: https://github.com/OpenBMB/MiniCPM-OCR |
| Image: https://huggingface.co/containers/davanstrien/minicpm-ocr |
| """ |
|
|
| import argparse |
| import contextlib |
| import json |
| import logging |
| import os |
| import shlex |
| import shutil |
| import signal |
| import subprocess |
| import sys |
| import tempfile |
| import time |
| import urllib.request |
| from datetime import datetime |
| from pathlib import Path |
|
|
| logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s") |
| logger = logging.getLogger(__name__) |
|
|
| SCRIPT_URL = "https://huggingface.co/datasets/uv-scripts/ocr/raw/main/minicpm-ocr.py" |
| MODEL = "openbmb/MiniCPM-OCR-1.0" |
| MODEL_REVISION = "a59a4acf215e34c6d73149e9eafdb88ed2086e39" |
| DRAFT_MODEL = "openbmb/MiniCPM-OCR-1.0-DSpark" |
| DRAFT_REVISION = "31e3feaf80e0061cd6aa73db23480d2d691d6452" |
| SERVED_NAME = "minicpm-ocr" |
| PORT = 18499 |
| SDK_PYTHON = "/opt/sdk/bin/python" |
| LAYOUT_MODEL_DIR = "/opt/minicpm-ocr-assets/models/PP-DocLayoutV3_infer" |
| |
| SDK_IGNORED_LABELS = ["number", "footnote", "header", "footer", "aside_text"] |
| IMAGE_TAG = "cr.hf.co/davanstrien/minicpm-ocr:1.0-vllm-5d35ce3" |
| BUCKET_SCHEME = "hf://buckets/" |
| IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".tif", ".tiff", ".bmp", ".webp", ".jp2"} |
|
|
| |
| |
| SDK_RUNNER = """ |
| import json, sys |
| from importlib.resources import files |
| from pathlib import Path |
| from minicpmvocr import load_config, pipelined_run |
| from minicpmvocr.prompts import DEFAULT_PROMPT_MAP |
| args = json.loads(sys.argv[1]) |
| prompt = {} |
| if args["keep_labels"]: |
| # A prompt-map file replaces whole top-level sections, so write the full assembly section. |
| assembly = dict(DEFAULT_PROMPT_MAP["markdown_assembly"]) |
| assembly["ignore_labels"] = [l for l in assembly["ignore_labels"] if l not in args["keep_labels"]] |
| prompt_map = Path(args["run_root"]) / "prompt_map.json" |
| prompt_map.parent.mkdir(parents=True, exist_ok=True) |
| prompt_map.write_text(json.dumps({"markdown_assembly": assembly})) |
| prompt = {"prompt_map": str(prompt_map)} |
| cfg = load_config(str(files("minicpmvocr").joinpath("configs/minicpmvocr.yaml")), overrides={ |
| "input": {"image_dir": args["image_dir"]}, |
| "run": {"run_root": args["run_root"], "run_tag": args["run_tag"]}, |
| "engine": {"server_url": args["server_url"], "model_name": args["model_name"], "max_model_len": 40960}, |
| "layout": {"model_dir": args["layout_dir"], "device": "cuda:0"}, |
| "pipeline": {"overlap_layout": True}, |
| "prompt": prompt, |
| }) |
| pipelined_run(cfg) |
| print(json.dumps({"run_dir": cfg["_meta"]["run_dir"]})) |
| """ |
|
|
|
|
| def image_python() -> str | None: |
| """The image's own python3 (the one with vLLM and torch), looking past this script's venv.""" |
| own_bin = os.path.realpath(os.path.join(sys.prefix, "bin")) |
| path = os.pathsep.join(p for p in os.environ.get("PATH", "").split(os.pathsep) |
| if os.path.realpath(p) != own_bin) |
| return shutil.which("python3", path=path) |
|
|
|
|
| def check_runtime(): |
| """Fail fast, naming the fix, when not on the MiniCPM-OCR image or without a CUDA GPU.""" |
| py = image_python() |
| if not (py and shutil.which("vllm") and Path(SDK_PYTHON).exists() and Path(LAYOUT_MODEL_DIR).exists()): |
| logger.error("This script needs the %s image (vLLM with MiniCPM-OCR support, the " |
| "minicpm-ocr SDK and the layout model).", IMAGE_TAG) |
| logger.error("Run it with `hf jobs uv run`, which reads the image from the script header, " |
| "or pass --image %s.", IMAGE_TAG) |
| sys.exit(1) |
| probe = subprocess.run([py, "-c", "import torch; print(torch.cuda.is_available())"], |
| capture_output=True, text=True) |
| if probe.stdout.strip() != "True": |
| logger.error("CUDA is not available to the image's torch. This script needs a GPU " |
| "(e.g. --flavor a10g-large). %s", probe.stderr.strip()[-300:]) |
| sys.exit(1) |
|
|
|
|
| @contextlib.contextmanager |
| def vllm_server(dspark: bool): |
| """Run vLLM with OpenBMB's tutorial settings for the duration of the block. |
| |
| The server gets its own process group, and is terminated, then killed, then reaped, on every |
| exit path, including a failed or interrupted startup. |
| """ |
| from huggingface_hub import snapshot_download |
|
|
| model_dir = snapshot_download(MODEL, revision=MODEL_REVISION) |
| cmd = [ |
| "vllm", "serve", model_dir, "--served-model-name", SERVED_NAME, |
| "--host", "127.0.0.1", "--port", str(PORT), |
| "--max-model-len", "40960", "--max-num-batched-tokens", "40960", "--max-num-seqs", "32", |
| "--limit-mm-per-prompt", '{"image":36,"video":0}', |
| "--mm-processor-kwargs", '{"downsample_mode":"4x"}', |
| "--gpu-memory-utilization", "0.85", "--trust-request-mm-kwargs", |
| "--default-chat-template-kwargs", '{"enable_thinking":false}', |
| ] |
| if dspark: |
| draft_dir = snapshot_download(DRAFT_MODEL, revision=DRAFT_REVISION) |
| cmd += ["--speculative-config", json.dumps({ |
| "method": "dspark", "model": draft_dir, "num_speculative_tokens": 15, |
| "enable_adaptive_verification": False})] |
| |
| env = {k: v for k, v in os.environ.items() if k != "VIRTUAL_ENV"} |
| logger.info("Starting vLLM: %s", shlex.join(cmd)) |
| proc = subprocess.Popen(cmd, env=env, start_new_session=True) |
| try: |
| deadline = time.time() + 1800 |
| while True: |
| if proc.poll() is not None: |
| sys.exit(f"vLLM exited during startup (code {proc.returncode})") |
| try: |
| with urllib.request.urlopen(f"http://127.0.0.1:{PORT}/v1/models", timeout=5) as r: |
| if SERVED_NAME in r.read().decode(): |
| break |
| except OSError: |
| pass |
| if time.time() > deadline: |
| sys.exit("vLLM did not become ready within 30 minutes") |
| time.sleep(5) |
| logger.info("vLLM ready") |
| yield |
| finally: |
| stop_process_group(proc) |
|
|
|
|
| def group_alive(pgid: int) -> bool: |
| try: |
| os.killpg(pgid, 0) |
| return True |
| except (ProcessLookupError, PermissionError): |
| return False |
|
|
|
|
| def stop_process_group(proc: subprocess.Popen): |
| """SIGTERM the whole group, wait up to 60 s for it to empty, then SIGKILL; always reap the |
| parent. Checks the group, not just the parent, since vLLM's workers can outlive it.""" |
| pgid = proc.pid |
| for sig, wait in ((signal.SIGTERM, 60), (signal.SIGKILL, 30)): |
| if not group_alive(pgid): |
| break |
| with contextlib.suppress(ProcessLookupError): |
| os.killpg(pgid, sig) |
| deadline = time.time() + wait |
| while group_alive(pgid) and time.time() < deadline: |
| with contextlib.suppress(subprocess.TimeoutExpired): |
| proc.wait(timeout=1) |
| with contextlib.suppress(subprocess.TimeoutExpired): |
| proc.wait(timeout=5) |
|
|
|
|
| def parse_batch(images: dict, work: Path, tag: str, keep_labels: list[str]) -> dict: |
| """OCR one batch of pages with the SDK. |
| |
| `images` maps a key to a PIL image, a path, or an undecoded datasets image dict. Returns |
| key -> (status, markdown or None). A page that cannot be read gets an `error: ...` status and |
| does not stop the batch; if the SDK run itself fails, every page in the batch gets one. |
| """ |
| from datasets import Image as ImageFeature |
| from PIL import Image, ImageOps |
|
|
| decoder = ImageFeature() |
| image_dir = work / tag / "images" |
| image_dir.mkdir(parents=True) |
| results, ids = {}, {} |
| for i, (key, source) in enumerate(images.items()): |
| try: |
| if isinstance(source, dict): |
| |
| |
| img = decoder.decode_example(source) |
| else: |
| img = source if isinstance(source, Image.Image) else Image.open(source) |
| img = ImageOps.exif_transpose(img) |
| img.convert("RGB").save(image_dir / f"{i:06d}.png") |
| ids[f"{i:06d}"] = key |
| except Exception as e: |
| logger.warning("Cannot read %s: %s", key, e) |
| results[key] = (f"error: unreadable image ({type(e).__name__})", None) |
| if ids: |
| args = {"image_dir": str(image_dir), "run_root": str(work / tag / "runs"), "run_tag": tag, |
| "server_url": f"http://127.0.0.1:{PORT}", "model_name": SERVED_NAME, |
| "layout_dir": LAYOUT_MODEL_DIR, "keep_labels": keep_labels} |
| run = subprocess.run([SDK_PYTHON, "-c", SDK_RUNNER, json.dumps(args)], |
| capture_output=True, text=True) |
| if run.returncode != 0: |
| logger.error("SDK run failed for %s (exit %d):\n%s", tag, run.returncode, run.stderr[-3000:]) |
| results.update({key: (f"error: SDK exit {run.returncode}", None) for key in ids.values()}) |
| else: |
| run_dir = Path(json.loads(run.stdout.strip().splitlines()[-1])["run_dir"]) |
| status = {} |
| metrics = run_dir / "per_page_metrics.jsonl" |
| if metrics.exists(): |
| for line in metrics.read_text(encoding="utf-8").splitlines(): |
| row = json.loads(line) |
| status[row["image_id"]] = row.get("status") or "unknown" |
| for image_id, key in ids.items(): |
| md = run_dir / "output" / f"{image_id}.md" |
| page_status = status.get(image_id, "failed" if not md.exists() else "unknown") |
| text = md.read_text(encoding="utf-8").strip() if md.exists() else None |
| results[key] = (page_status, text if page_status in ("ok", "partial_failed") else None) |
| shutil.rmtree(work / tag, ignore_errors=True) |
| return results |
|
|
|
|
| |
|
|
|
|
| def is_bucket(location: str) -> bool: |
| return location.startswith(BUCKET_SCHEME) |
|
|
|
|
| def as_bucket_dir(url: str) -> tuple[str, str]: |
| """Split a bucket URL into (bucket root URL, directory key prefix ending in "/"). |
| |
| The prefix goes to bucketbag explicitly: it matches prefixes as strings, so `.../vol` |
| would also list `.../vol2/...`. |
| """ |
| parts = url[len(BUCKET_SCHEME):].strip("/").split("/", 2) |
| if len(parts) < 2: |
| raise ValueError(f"Not a bucket URL: {url} (expected hf://buckets/<ns>/<bucket>[/<prefix>])") |
| prefix = parts[2] + "/" if len(parts) == 3 else "" |
| return BUCKET_SCHEME + "/".join(parts[:2]), prefix |
|
|
|
|
| def md_rel(rel: str) -> str: |
| return str(Path(rel).with_suffix(".md")) |
|
|
|
|
| def list_rels(location: str) -> list[str]: |
| """Relative paths of every file under a bucket prefix or folder, sorted.""" |
| if is_bucket(location): |
| from bucketbag import iter_keys |
|
|
| url, prefix = as_bucket_dir(location) |
| return sorted(k[len(prefix):] for k in iter_keys(url, prefix=prefix)) |
| root = Path(location) |
| return sorted(str(p.relative_to(root)) for p in root.rglob("*") if p.is_file()) if root.is_dir() else [] |
|
|
|
|
| def iter_local_batches(source: str, rels: list[str], n: int): |
| """Yield batches of (rel, local path): from disk, or downloaded by bucketbag to scratch.""" |
| if not is_bucket(source): |
| for i in range(0, len(rels), n): |
| yield [(rel, Path(source) / rel) for rel in rels[i: i + n]] |
| return |
| from bucketbag import batched_files |
|
|
| url, prefix = as_bucket_dir(source) |
| for batch in batched_files(url, keys=[prefix + rel for rel in rels], n=n, prefetch=2): |
| yield [(item.key[len(prefix):], item.path) for item in batch] |
|
|
|
|
| def write_outputs(dest: str, pairs: list[tuple[str, str]]): |
| if not pairs: |
| return |
| if is_bucket(dest): |
| from bucketbag import put_files |
|
|
| url, prefix = as_bucket_dir(dest) |
| put_files([(prefix + rel, content) for rel, content in pairs], url) |
| return |
| for rel, content in pairs: |
| |
| path = Path(dest) / rel |
| path.parent.mkdir(parents=True, exist_ok=True) |
| tmp = path.with_name(f".{path.name}.tmp") |
| tmp.write_text(content, encoding="utf-8") |
| os.replace(tmp, path) |
|
|
|
|
| def run_files(args): |
| inputs = [r for r in list_rels(args.input) if Path(r).suffix.lower() in IMAGE_EXTENSIONS] |
| owners: dict[str, list[str]] = {} |
| for rel in inputs: |
| owners.setdefault(md_rel(rel), []).append(rel) |
| clashes = [" + ".join(group) for group in owners.values() if len(group) > 1] |
| if clashes: |
| sys.exit("These inputs would write the same .md file; rename or move them first:\n " |
| + "\n ".join(clashes)) |
| if args.max_samples: |
| inputs = inputs[: args.max_samples] |
| done = {r for r in list_rels(args.output) if r.endswith(".md")} |
| todo = [r for r in inputs if args.overwrite or md_rel(r) not in done] |
| already = sum(md_rel(r) in done for r in inputs) |
| logger.info("%d images under %s, %d already have a .md, %d to OCR", len(inputs), args.input, |
| already, len(todo)) |
| if not todo: |
| return |
| failed = [] |
| with vllm_server(dspark=not args.no_dspark), tempfile.TemporaryDirectory() as work: |
| for b, batch in enumerate(iter_local_batches(args.input, todo, args.batch_size)): |
| results = parse_batch(dict(batch), Path(work), f"batch{b:06d}", args.keep_labels) |
| write_outputs(args.output, [(md_rel(rel), text) for rel, (status, text) in results.items() |
| if status == "ok"]) |
| failed += [f"{rel} ({status})" for rel, (status, _) in results.items() if status != "ok"] |
| logger.info("%d/%d images", min((b + 1) * args.batch_size, len(todo)), len(todo)) |
| if failed: |
| logger.warning("%d pages not written (re-run the same command to retry them):\n %s", |
| len(failed), "\n ".join(failed)) |
| stale = [f for f in failed if md_rel(f.rsplit(" (", 1)[0]) in done] |
| if args.overwrite and stale: |
| logger.warning("%d of them still have a .md from an earlier run, which a re-run without " |
| "--overwrite will skip; delete those files to retry them:\n %s", |
| len(stale), "\n ".join(stale)) |
|
|
|
|
| |
|
|
|
|
| def jobs_flavor() -> str: |
| """Return the HF Jobs hardware flavor this run is on, or "" when it cannot be told. |
| |
| HF Jobs sets ACCELERATOR to "cpu" or "gpu", not the flavor name, so the flavor is looked up |
| in the public Jobs hardware list: first by GPU model and count, then by the CPU_CORES and |
| MEMORY values that Jobs sets in the container (to tell a10g-small from a10g-large, or |
| cpu-basic from cpu-upgrade). Any failure (no network, older huggingface_hub) returns "". |
| """ |
| hardware = os.environ.get("ACCELERATOR") or "" |
| if "-" in hardware or any(character.isdigit() for character in hardware): |
| return hardware |
| try: |
| from huggingface_hub import HfApi |
|
|
| gpu_name, gpu_count = "", 0 |
| try: |
| import torch |
|
|
| if torch.cuda.is_available(): |
| gpu_name = torch.cuda.get_device_name(0) |
| gpu_count = torch.cuda.device_count() |
| except ImportError: |
| |
| import subprocess |
|
|
| try: |
| listed = subprocess.run( |
| ["nvidia-smi", "--query-gpu=name", "--format=csv,noheader"], |
| capture_output=True, text=True, timeout=10, check=True, |
| ).stdout |
| names = [line.strip() for line in listed.splitlines() if line.strip()] |
| if names: |
| gpu_name, gpu_count = names[0], len(names) |
| except (OSError, subprocess.SubprocessError): |
| pass |
| if gpu_count == 0 and hardware == "gpu": |
| return "" |
|
|
| |
| gpu_words = gpu_name.upper().replace("-", " ").split() |
| candidates = [] |
| for flavor in HfApi(token=False).list_jobs_hardware(): |
| accelerator = flavor.accelerator |
| if gpu_count == 0 and accelerator is None: |
| candidates.append(flavor) |
| elif ( |
| gpu_count > 0 |
| and accelerator is not None |
| and accelerator.model.upper() in gpu_words |
| and int(accelerator.quantity) == gpu_count |
| ): |
| candidates.append(flavor) |
| if not candidates: |
| return "" |
|
|
| cores = float(os.environ.get("CPU_CORES") or 0) |
| memory_gb = float((os.environ.get("MEMORY") or "0").upper().rstrip("GIB ") or 0) |
|
|
| def distance(flavor) -> float: |
| |
| listed_cores = float(flavor.cpu.split()[0]) |
| listed_memory = float(flavor.ram.split()[0]) |
| return abs(listed_cores - cores) / listed_cores + abs(listed_memory - memory_gb) / listed_memory |
|
|
| return min(candidates, key=distance).name |
| except Exception: |
| return "" |
|
|
|
|
| def create_dataset_card(args, num_samples: int, counts: dict, processing_time: str) -> str: |
| |
| on_jobs = os.environ.get("JOB_ID") is not None |
| hw = jobs_flavor() |
| origin = ( |
| "Produced on [Hugging Face Jobs](https://huggingface.co/docs/huggingface_hub/guides/jobs)" |
| + (f" (`{hw}`)" if hw else "") |
| ) if on_jobs else "Generated" |
| jobs_tag = "\n- hf-jobs" if on_jobs else "" |
| status_col = f"{args.output_column}_status" |
| flags = [f"--flavor {hw or 'a10g-large'}"] |
| for flag, value, default in (("--split", args.split, "train"), ("--image-column", args.image_column, "image"), |
| ("--output-column", args.output_column, "markdown"), |
| ("--batch-size", args.batch_size, 64)): |
| if value != default: |
| flags.append(f"{flag} {shlex.quote(str(value))}") |
| if args.max_samples: |
| flags.append(f"--max-samples {args.max_samples}") |
| if args.shuffle: |
| flags.append(f"--shuffle --seed {args.seed}") |
| if args.no_dspark: |
| flags.append("--no-dspark") |
| if args.keep_labels: |
| flags.append("--keep-labels " + " ".join(args.keep_labels)) |
| if args.overwrite: |
| flags.append("--overwrite") |
| command = f"hf jobs uv run {' '.join(flags[:1])} \\\n {SCRIPT_URL} \\\n {args.input} <output-dataset>" |
| if flags[1:]: |
| command += " \\\n " + " ".join(flags[1:]) |
| counts_line = ", ".join(f"`{k}` {v:,}" for k, v in sorted(counts.items())) |
| return f"""--- |
| tags: |
| - ocr |
| - document-processing |
| - minicpm-ocr |
| - markdown |
| - uv-script |
| - generated{jobs_tag} |
| --- |
| |
| # Document OCR using MiniCPM-OCR 1.0 |
| |
| OCR of [{args.input}](https://huggingface.co/datasets/{args.input}) with OpenBMB's |
| [MiniCPM-OCR 1.0](https://huggingface.co/{MODEL}) pipeline: PP-DocLayoutV3 layout regions, each |
| region read by the model, assembled into Markdown by the official SDK. |
| |
| ## Processing Details |
| |
| - **Source Dataset**: [{args.input}](https://huggingface.co/datasets/{args.input}) (split `{args.split}`, column `{args.image_column}`) |
| - **Model**: [{MODEL}](https://huggingface.co/{MODEL}) @ `{MODEL_REVISION[:7]}` |
| - **Decoding**: {"standard" if args.no_dspark else "DSpark speculative decoding"} |
| - **Region types left out of the Markdown**: {", ".join(f"`{l}`" for l in SDK_IGNORED_LABELS if l not in args.keep_labels) or "none"} |
| - **Number of Samples**: {num_samples:,} |
| - **Page status**: {counts_line} |
| - **Processing Time**: {processing_time} |
| - **Processing Date**: {datetime.now().strftime("%Y-%m-%d %H:%M UTC")} |
| |
| ## Columns |
| |
| - `{args.output_column}`: the SDK's Markdown for each page (tables as HTML, formulas as LaTeX); empty when |
| the page failed |
| - `{status_col}`: `ok`, `partial_failed` (some regions failed; text kept), `failed` or `error: ...` |
| - `inference_info`: JSON list tracking all OCR models applied to this dataset |
| |
| ## Reproduction |
| |
| {origin} with the [`minicpm-ocr.py`]({SCRIPT_URL}) recipe from [uv-scripts](https://huggingface.co/uv-scripts). Run it yourself: |
| |
| ```bash |
| {command} |
| ``` |
| """ |
|
|
|
|
| def run_dataset(args): |
| from datasets import load_dataset |
| from huggingface_hub import DatasetCard |
|
|
| status_col = f"{args.output_column}_status" |
| reserved = {"inference_info", args.image_column} |
| if args.output_column in reserved or status_col in reserved: |
| sys.exit(f"--output-column {args.output_column!r} clashes with {sorted(reserved)}; pick another name") |
|
|
| dataset = load_dataset(args.input, split=args.split) |
| if args.shuffle: |
| dataset = dataset.shuffle(seed=args.seed) |
| if args.max_samples: |
| dataset = dataset.select(range(min(args.max_samples, len(dataset)))) |
| |
| from datasets import Image as ImageFeature |
|
|
| dataset = dataset.cast_column(args.image_column, ImageFeature(decode=False)) |
| clash = [c for c in (args.output_column, status_col) if c in dataset.column_names] |
| if clash and not args.overwrite: |
| sys.exit(f"Output column(s) {clash} already exist; choose another --output-column or pass --overwrite") |
| if clash: |
| logger.warning("--overwrite: replacing existing column(s) %s", clash) |
| dataset = dataset.remove_columns(clash) |
| logger.info("%d pages from %s", len(dataset), args.input) |
|
|
| |
| |
| image_only = dataset.select_columns([args.image_column]) |
| start = datetime.now() |
| texts, statuses = [], [] |
| with vllm_server(dspark=not args.no_dspark), tempfile.TemporaryDirectory() as work: |
| for b in range(0, len(dataset), args.batch_size): |
| images = image_only[b: b + args.batch_size][args.image_column] |
| results = parse_batch(dict(enumerate(images)), Path(work), f"batch{b:08d}", args.keep_labels) |
| for i in range(len(images)): |
| status, text = results[i] |
| statuses.append(status) |
| texts.append(text or "") |
| logger.info("%d/%d pages", len(texts), len(dataset)) |
| elapsed = datetime.now() - start |
|
|
| counts = {} |
| for s in statuses: |
| key = "error" if s.startswith("error") else s |
| counts[key] = counts.get(key, 0) + 1 |
| logger.info("Page status: %s", counts) |
|
|
| dataset = dataset.cast_column(args.image_column, ImageFeature()) |
| dataset = dataset.add_column(args.output_column, texts).add_column(status_col, statuses) |
| entry = {"model_id": MODEL, "model_name": "MiniCPM-OCR-1.0", "column_name": args.output_column, |
| "timestamp": datetime.now().isoformat(), "model_revision": MODEL_REVISION, |
| "pipeline": "minicpm-ocr SDK 1.0.1 (PP-DocLayoutV3)", "dspark": not args.no_dspark, |
| "keep_labels": args.keep_labels} |
| if "inference_info" in dataset.column_names: |
| def update(example): |
| try: |
| info = json.loads(example["inference_info"]) if example["inference_info"] else [] |
| except (json.JSONDecodeError, TypeError): |
| info = [] |
| return {"inference_info": json.dumps(info + [entry])} |
| dataset = dataset.map(update) |
| else: |
| dataset = dataset.add_column("inference_info", [json.dumps([entry])] * len(dataset)) |
|
|
| dataset.push_to_hub(args.output, private=args.private) |
| card = create_dataset_card(args, len(dataset), counts, f"{elapsed.total_seconds() / 60:.1f} min") |
| DatasetCard(card).push_to_hub(args.output) |
| logger.info("Done: https://huggingface.co/datasets/%s (%.2f pages/s including startup)", |
| args.output, len(dataset) / elapsed.total_seconds()) |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser( |
| description="Document OCR with the MiniCPM-OCR 1.0 pipeline", |
| formatter_class=argparse.RawDescriptionHelpFormatter, |
| epilog="Input/output: Hub dataset IDs (dataset mode), or hf://buckets/<ns>/<bucket>[/<prefix>] " |
| "URLs / folders (one .md per image).") |
| parser.add_argument("input", help="Hub dataset ID, or hf://buckets/... URL or folder of page images") |
| parser.add_argument("output", help="Hub dataset ID (dataset input), or hf://buckets/... URL or folder") |
| parser.add_argument("--image-column", default="image", help="Dataset mode: image column") |
| parser.add_argument("--output-column", default="markdown", help="Dataset mode: output column") |
| parser.add_argument("--split", default="train", help="Dataset mode: split") |
| parser.add_argument("--max-samples", type=int, help="Process only the first N pages (for testing)") |
| parser.add_argument("--shuffle", action="store_true", help="Dataset mode: shuffle before --max-samples") |
| parser.add_argument("--seed", type=int, default=42) |
| parser.add_argument("--batch-size", type=int, default=64, |
| help="Pages handed to the SDK per run (it parallelises regions inside a run)") |
| parser.add_argument("--no-dspark", action="store_true", help="Standard decoding, no draft model") |
| parser.add_argument("--keep-labels", nargs="+", default=[], choices=SDK_IGNORED_LABELS, |
| help="Region types to keep in the Markdown that the SDK leaves out by default") |
| parser.add_argument("--private", action="store_true", help="Dataset mode: private output dataset") |
| parser.add_argument("--overwrite", action="store_true", |
| help="Replace an existing output column / re-OCR images that already have a .md") |
| parser.add_argument("--hf-token", help="Hugging Face token (default: HF_TOKEN env var)") |
| args = parser.parse_args() |
|
|
| if args.hf_token: |
| os.environ["HF_TOKEN"] = args.hf_token |
| if args.max_samples is not None and args.max_samples < 1: |
| sys.exit("--max-samples must be at least 1") |
| if args.batch_size < 1: |
| sys.exit("--batch-size must be at least 1") |
| |
| |
| file_in = is_bucket(args.input) or Path(args.input).is_dir() |
| if not file_in and (is_bucket(args.output) or Path(args.output).is_dir()): |
| sys.exit("Dataset input writes a Hub dataset; for Bucket output, give a Bucket or folder as input.") |
| check_runtime() |
| if file_in: |
| run_files(args) |
| else: |
| run_dataset(args) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
