Use repository-native Unlimited OCR Nano training backend

generic_train_job.py

@@ -10,6 +10,8 @@
 #   "pillow>=11",
 #   "huggingface-hub>=1.0",
 #   "safetensors>=0.5",
+#   "pyyaml>=6",
+#   "timm>=1.0",
 # ]
 # ///
 from __future__ import annotations
@@ -19,6 +21,7 @@ import inspect
 import json
 import os
 import re
+import subprocess
 import tempfile
 from abc import ABC, abstractmethod
 from dataclasses import asdict, dataclass
@@ -27,7 +30,7 @@ from typing import Any
 
 import torch
 from datasets import Dataset, load_dataset
-from huggingface_hub import HfApi
+from huggingface_hub import HfApi, snapshot_download
 from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
 from transformers import (
     AutoConfig,
@@ -387,12 +390,162 @@ def apply_peft(model: Any, args: argparse.Namespace) -> Any:
     return get_peft_model(model, config)
 
 
+def _pick_ocr_file(files: list[str], explicit: str, candidates: list[str]) -> str:
+    if explicit:
+        if explicit not in files:
+            raise FileNotFoundError(f"Dataset file not found: {explicit}")
+        return explicit
+    for candidate in candidates:
+        if candidate in files:
+            return candidate
+    raise FileNotFoundError(f"No compatible OCR JSONL found. Tried: {candidates}")
+
+
+def _subset_jsonl(source: Path, limit: int) -> Path:
+    if limit <= 0:
+        return source
+    destination = source.with_name(f"{source.stem}.subset-{limit}{source.suffix}")
+    lines = []
+    with source.open("r", encoding="utf-8", errors="replace") as handle:
+        for index, line in enumerate(handle):
+            if index >= limit:
+                break
+            lines.append(line)
+    destination.write_text("".join(lines), encoding="utf-8")
+    return destination
+
+
+def run_unlimited_ocr_nano(args: argparse.Namespace, token: str, plan: AdapterPlan) -> None:
+    import yaml
+
+    api = HfApi(token=token)
+    files = api.list_repo_files(args.dataset_id, repo_type="dataset", token=token)
+    train_file = _pick_ocr_file(
+        files,
+        args.train_file,
+        ["teacher/train.jsonl", f"{args.train_split}.jsonl", "train.jsonl"],
+    )
+    validation_file = ""
+    if args.validation_file:
+        validation_file = _pick_ocr_file(files, args.validation_file, [])
+    else:
+        for candidate in ["teacher/validation.jsonl", "validation.jsonl"]:
+            if candidate in files:
+                validation_file = candidate
+                break
+
+    print(json.dumps({
+        "event": "adapter",
+        **asdict(plan),
+        "train_file": train_file,
+        "validation_file": validation_file or None,
+    }, ensure_ascii=False), flush=True)
+    if args.dry_run:
+        print("100% · Unlimited OCR Nano dry-run validation completed", flush=True)
+        return
+
+    with tempfile.TemporaryDirectory() as tmp:
+        root = Path(tmp)
+        project = Path(snapshot_download(
+            args.model_id,
+            repo_type="model",
+            token=token,
+            local_dir=root / "project",
+            allow_patterns=["src/**", "scripts/train.py", "configs/**", "pyproject.toml", "README.md"],
+        ))
+        patterns = [train_file, "pages/**"]
+        if validation_file:
+            patterns.append(validation_file)
+        dataset = Path(snapshot_download(
+            args.dataset_id,
+            repo_type="dataset",
+            token=token,
+            local_dir=root / "dataset",
+            allow_patterns=patterns,
+            max_workers=64,
+        ))
+        train_path = _subset_jsonl(dataset / train_file, args.max_samples)
+        validation_path = dataset / validation_file if validation_file else None
+
+        base_name = "nano-600m-alignment.yaml" if args.method == "projector" else "nano-600m-distill.yaml"
+        base_path = project / "configs" / base_name
+        if not base_path.exists():
+            available = sorted(path.name for path in (project / "configs").glob("*.yaml"))
+            raise FileNotFoundError(f"Missing {base_name}; available configs: {available}")
+        config = yaml.safe_load(base_path.read_text(encoding="utf-8"))
+        training = config.setdefault("training", {})
+        training.update({
+            "max_length": int(args.max_length),
+            "batch_size": int(args.batch_size),
+            "gradient_accumulation_steps": int(args.gradient_accumulation),
+            "learning_rate": float(args.learning_rate),
+            "epochs": float(args.epochs),
+            "max_steps": int(args.max_steps),
+            "warmup_ratio": float(args.warmup_ratio),
+            "weight_decay": float(args.weight_decay),
+            "logging_steps": int(args.logging_steps),
+            "save_steps": int(args.save_steps),
+            "eval_steps": int(args.eval_steps),
+            "fp16": args.precision == "fp16",
+            "bf16": args.precision == "bf16",
+            "gradient_checkpointing": bool(args.gradient_checkpointing),
+            "seed": int(args.seed),
+        })
+        if args.method == "projector":
+            training.update({"stage": "alignment", "freeze_language_model": True, "freeze_vision_encoder": True, "use_lora": False})
+        elif args.method == "lora":
+            training.update({"stage": "distill", "freeze_language_model": False, "use_lora": True})
+            lora = training.setdefault("lora", {})
+            lora.update({"rank": int(args.lora_rank), "alpha": int(args.lora_alpha), "dropout": float(args.lora_dropout)})
+        elif args.method == "full":
+            training.update({"stage": "full", "freeze_language_model": False, "freeze_vision_encoder": False, "use_lora": False})
+        else:
+            raise ValueError("Unlimited OCR Nano supports projector, lora or full methods.")
+
+        generated_config = root / "ocr-nano-generated.yaml"
+        generated_config.write_text(yaml.safe_dump(config, sort_keys=False), encoding="utf-8")
+        output_dir = root / "output"
+        command = [
+            os.environ.get("PYTHON", "python"),
+            str(project / "scripts" / "train.py"),
+            "--config", str(generated_config),
+            "--train-file", str(train_path),
+            "--output-dir", str(output_dir),
+        ]
+        if validation_path and validation_path.exists():
+            command += ["--validation-file", str(validation_path)]
+        environment = dict(os.environ)
+        environment["PYTHONPATH"] = str(project / "src")
+        subprocess.run(command, check=True, env=environment)
+        manifest = {
+            "model_id": args.model_id,
+            "dataset_id": args.dataset_id,
+            "adapter": plan.adapter_id,
+            "method": args.method,
+            "train_file": train_file,
+            "validation_file": validation_file or None,
+            "arguments": vars(args),
+        }
+        (output_dir / "generic_trainer_manifest.json").write_text(json.dumps(manifest, indent=2), encoding="utf-8")
+        api.create_repo(args.output_repo, repo_type="model", private=True, exist_ok=True, token=token)
+        api.upload_folder(
+            folder_path=output_dir,
+            repo_id=args.output_repo,
+            repo_type="model",
+            token=token,
+            commit_message=f"Generic Trainer OCR Nano: {args.method}",
+        )
+        print(f"100% · uploaded OCR Nano checkpoint to {args.output_repo}", flush=True)
+
+
 def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser(description="Generic Transformers training job")
     parser.add_argument("--model-id", required=True)
     parser.add_argument("--dataset-id", required=True)
     parser.add_argument("--dataset-config", default="")
     parser.add_argument("--train-split", default="train")
+    parser.add_argument("--train-file", default="")
+    parser.add_argument("--validation-file", default="")
     parser.add_argument("--validation-split", default="")
     parser.add_argument("--output-repo", required=True)
     parser.add_argument("--adapter", default="auto", choices=["auto", "gemma4", "unlimited-ocr-nano", "vision-language", "seq2seq", "causal-lm"])
@@ -430,10 +583,21 @@ def main() -> None:
     token = os.environ["HF_TOKEN"]
     api = HfApi(token=token)
     info = api.model_info(args.model_id, token=token)
-    config = AutoConfig.from_pretrained(args.model_id, token=token, trust_remote_code=args.trust_remote_code)
+    is_ocr_nano = args.adapter == "unlimited-ocr-nano" or "unlimited-ocr-nano" in args.model_id.lower()
+    if is_ocr_nano:
+        class OCRConfig:
+            model_type = "unlimited_ocr_nano"
+            architectures = ["UnlimitedOCRNanoForConditionalGeneration"]
+            is_encoder_decoder = False
+        config = OCRConfig()
+    else:
+        config = AutoConfig.from_pretrained(args.model_id, token=token, trust_remote_code=args.trust_remote_code)
     adapter = choose_adapter(args.adapter, args.model_id, config, list(info.tags or []))
     plan = adapter.plan(args.model_id, config)
     args.adapter = plan.adapter_id
+    if plan.adapter_id == "unlimited-ocr-nano":
+        run_unlimited_ocr_nano(args, token, plan)
+        return
     print(json.dumps({"event": "adapter", **asdict(plan)}, ensure_ascii=False), flush=True)
 
     dataset_kwargs: dict[str, Any] = {"path": args.dataset_id, "split": args.train_split, "token": token}