generic_train_job.py

# /// script
# requires-python = ">=3.11"
# dependencies = [
#   "torch>=2.6",
#   "transformers>=5.0.0",
#   "datasets>=4.0",
#   "accelerate>=1.10",
#   "peft>=0.17",
#   "bitsandbytes>=0.46; platform_system == 'Linux'",
#   "pillow>=11",
#   "huggingface-hub>=1.0",
#   "psutil>=6.0",
#   "nvidia-ml-py>=12.560",
#   "safetensors>=0.5",
#   "pyyaml>=6",
#   "timm>=1.0",
# ]
# ///
from __future__ import annotations

import argparse
import atexit
import threading
import time

import psutil
import inspect
import json
import os
import re
import subprocess
import tempfile
from abc import ABC, abstractmethod
from dataclasses import asdict, dataclass
from pathlib import Path
from typing import Any

import torch
from datasets import Dataset, load_dataset
from huggingface_hub import HfApi, snapshot_download
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from transformers import (
    AutoConfig,
    AutoModelForCausalLM,
    AutoModelForSeq2SeqLM,
    AutoProcessor,
    AutoTokenizer,
    BitsAndBytesConfig,
    DataCollatorForLanguageModeling,
    DataCollatorForSeq2Seq,
    Trainer,
    TrainingArguments,
)


class TelemetryReporter:
    """Emit machine-readable host and accelerator utilization for the Gradio monitor."""

    def __init__(self, interval: float = 2.0):
        self.interval = interval
        self.stop_event = threading.Event()
        self.thread = threading.Thread(target=self._run, name="generic-trainer-telemetry", daemon=True)
        self.nvml = None
        try:
            import pynvml
            pynvml.nvmlInit()
            self.nvml = pynvml
        except Exception:
            self.nvml = None

    def start(self) -> None:
        psutil.cpu_percent(interval=None)
        self.thread.start()
        atexit.register(self.stop)

    def stop(self) -> None:
        self.stop_event.set()
        if self.thread.is_alive() and threading.current_thread() is not self.thread:
            self.thread.join(timeout=1.0)
        if self.nvml is not None:
            try:
                self.nvml.nvmlShutdown()
            except Exception:
                pass

    def _gpu_sample(self) -> dict[str, object]:
        if self.nvml is not None:
            count = self.nvml.nvmlDeviceGetCount()
            names, utils, used, total, temperatures = [], [], 0, 0, []
            for index in range(count):
                handle = self.nvml.nvmlDeviceGetHandleByIndex(index)
                name = self.nvml.nvmlDeviceGetName(handle)
                names.append(name.decode() if isinstance(name, bytes) else str(name))
                memory = self.nvml.nvmlDeviceGetMemoryInfo(handle)
                used += int(memory.used); total += int(memory.total)
                try:
                    utils.append(float(self.nvml.nvmlDeviceGetUtilizationRates(handle).gpu))
                except Exception:
                    pass
                try:
                    temperatures.append(float(self.nvml.nvmlDeviceGetTemperature(handle, self.nvml.NVML_TEMPERATURE_GPU)))
                except Exception:
                    pass
            return {
                "gpu_count": count,
                "gpu_name": " · ".join(names) if names else None,
                "gpu_util_percent": round(sum(utils) / len(utils), 1) if utils else None,
                "vram_used_gb": round(used / 1024**3, 3) if total else None,
                "vram_total_gb": round(total / 1024**3, 3) if total else None,
                "vram_percent": round(used * 100 / total, 1) if total else None,
                "gpu_temperature_c": round(max(temperatures), 1) if temperatures else None,
            }
        if torch.cuda.is_available():
            free, total = torch.cuda.mem_get_info()
            used = total - free
            return {
                "gpu_count": torch.cuda.device_count(),
                "gpu_name": " · ".join(torch.cuda.get_device_name(i) for i in range(torch.cuda.device_count())),
                "gpu_util_percent": None,
                "vram_used_gb": round(used / 1024**3, 3),
                "vram_total_gb": round(total / 1024**3, 3),
                "vram_percent": round(used * 100 / total, 1) if total else None,
                "gpu_temperature_c": None,
            }
        return {"gpu_count": 0, "gpu_name": None, "gpu_util_percent": None, "vram_used_gb": None, "vram_total_gb": None, "vram_percent": None, "gpu_temperature_c": None}

    def sample(self) -> dict[str, object]:
        memory = psutil.virtual_memory()
        payload: dict[str, object] = {
            "event": "telemetry",
            "timestamp": time.time(),
            "cpu_percent": round(psutil.cpu_percent(interval=None), 1),
            "ram_used_gb": round((memory.total - memory.available) / 1024**3, 3),
            "ram_total_gb": round(memory.total / 1024**3, 3),
            "ram_percent": round(float(memory.percent), 1),
        }
        payload.update(self._gpu_sample())
        return payload

    def _run(self) -> None:
        while not self.stop_event.is_set():
            try:
                print(json.dumps(self.sample(), ensure_ascii=False), flush=True)
            except Exception as exc:
                print(json.dumps({"event": "telemetry_error", "message": str(exc)}), flush=True)
            self.stop_event.wait(self.interval)


def start_telemetry() -> TelemetryReporter:
    reporter = TelemetryReporter()
    reporter.start()
    return reporter


@dataclass(slots=True)
class RuntimePlan:
    runtime_id: str
    modality: str
    model_loader: str
    processor_loader: str
    default_method: str
    notes: list[str]


class ModelRuntime(ABC):
    """Runtime adapter contract used by every training family."""

    runtime_id: str

    @classmethod
    @abstractmethod
    def score(cls, model_id: str, config: Any, tags: list[str]) -> int: ...

    @classmethod
    @abstractmethod
    def plan(cls, model_id: str, config: Any) -> RuntimePlan: ...

    @abstractmethod
    def load(self, args: argparse.Namespace, quantization_config: BitsAndBytesConfig | None): ...

    @abstractmethod
    def build_trainer(self, args: argparse.Namespace, model: Any, processor: Any, train: Dataset, validation: Dataset | None, output_dir: Path) -> Trainer: ...


class TextRuntimeBase(ModelRuntime):
    seq2seq = False

    def _render(self, row: dict[str, Any], tokenizer: Any, args: argparse.Namespace) -> str:
        messages = row.get(args.messages_column) if args.messages_column else None
        if isinstance(messages, list) and hasattr(tokenizer, "apply_chat_template"):
            return tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=False)
        text = row.get(args.text_column) if args.text_column else None
        if text not in (None, ""):
            return str(text)
        prompt = str(row.get(args.prompt_column, "")) if args.prompt_column else ""
        response = str(row.get(args.response_column, "")) if args.response_column else ""
        if response:
            return f"{prompt}\n{response}".strip()
        return prompt

    def build_trainer(self, args, model, tokenizer, train, validation, output_dir):
        max_length = int(args.max_length)
        if self.seq2seq:
            def tokenize_batch(batch):
                prompts = [str(value or "") for value in batch[args.prompt_column]]
                targets = [str(value or "") for value in batch[args.response_column]]
                encoded = tokenizer(prompts, max_length=max_length, truncation=True)
                encoded["labels"] = tokenizer(text_target=targets, max_length=max_length, truncation=True)["input_ids"]
                return encoded
        else:
            def tokenize_batch(batch):
                rows = [{key: batch[key][i] for key in batch} for i in range(len(next(iter(batch.values()))))]
                texts = [self._render(row, tokenizer, args) for row in rows]
                encoded = tokenizer(texts, max_length=max_length, truncation=True, padding=False)
                encoded["labels"] = [list(ids) for ids in encoded["input_ids"]]
                return encoded

        remove_columns = train.column_names
        tokenized_train = train.map(tokenize_batch, batched=True, remove_columns=remove_columns, desc="Tokenizing train split")
        tokenized_validation = None
        if validation is not None:
            tokenized_validation = validation.map(tokenize_batch, batched=True, remove_columns=validation.column_names, desc="Tokenizing validation split")
        collator = DataCollatorForSeq2Seq(tokenizer, model=model) if self.seq2seq else DataCollatorForLanguageModeling(tokenizer, mlm=False)
        return Trainer(
            model=model,
            args=training_arguments(args, output_dir, tokenized_validation is not None),
            train_dataset=tokenized_train,
            eval_dataset=tokenized_validation,
            data_collator=collator,
        )


class CausalLMRuntime(TextRuntimeBase):
    runtime_id = "causal-lm"

    @classmethod
    def score(cls, model_id, config, tags):
        architectures = " ".join(getattr(config, "architectures", []) or []).lower()
        return 35 if "causallm" in architectures or "text-generation" in " ".join(tags).lower() else 10

    @classmethod
    def plan(cls, model_id, config):
        return RuntimePlan(cls.runtime_id, "text/chat", "AutoModelForCausalLM", "AutoTokenizer", "lora", [])

    def load(self, args, quantization_config):
        tokenizer = AutoTokenizer.from_pretrained(args.model_id, token=os.environ["HF_TOKEN"], trust_remote_code=args.trust_remote_code)
        if tokenizer.pad_token_id is None:
            tokenizer.pad_token = tokenizer.eos_token
        model = AutoModelForCausalLM.from_pretrained(
            args.model_id,
            token=os.environ["HF_TOKEN"],
            trust_remote_code=args.trust_remote_code,
            torch_dtype="auto",
            device_map="auto" if torch.cuda.is_available() else None,
            quantization_config=quantization_config,
        )
        return model, tokenizer


class Seq2SeqRuntime(TextRuntimeBase):
    runtime_id = "seq2seq"
    seq2seq = True

    @classmethod
    def score(cls, model_id, config, tags):
        return 50 if bool(getattr(config, "is_encoder_decoder", False)) else 0

    @classmethod
    def plan(cls, model_id, config):
        return RuntimePlan(cls.runtime_id, "text-to-text", "AutoModelForSeq2SeqLM", "AutoTokenizer", "lora", [])

    def load(self, args, quantization_config):
        tokenizer = AutoTokenizer.from_pretrained(args.model_id, token=os.environ["HF_TOKEN"], trust_remote_code=args.trust_remote_code)
        model = AutoModelForSeq2SeqLM.from_pretrained(
            args.model_id,
            token=os.environ["HF_TOKEN"],
            trust_remote_code=args.trust_remote_code,
            torch_dtype="auto",
            device_map="auto" if torch.cuda.is_available() else None,
            quantization_config=quantization_config,
        )
        return model, tokenizer


class MultimodalCollator:
    def __init__(self, processor: Any, args: argparse.Namespace):
        self.processor = processor
        self.args = args

    def _text(self, row: dict[str, Any]) -> str:
        messages = row.get(self.args.messages_column) if self.args.messages_column else None
        if isinstance(messages, list) and hasattr(self.processor, "apply_chat_template"):
            return self.processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=False)
        prompt = str(row.get(self.args.prompt_column, "")) if self.args.prompt_column else ""
        response = str(row.get(self.args.response_column, "")) if self.args.response_column else ""
        text = str(row.get(self.args.text_column, "")) if self.args.text_column else ""
        return text or (f"{prompt}\n{response}".strip())

    def __call__(self, rows: list[dict[str, Any]]) -> dict[str, torch.Tensor]:
        texts = [self._text(row) for row in rows]
        images = None
        if self.args.image_column and self.args.image_column in rows[0]:
            images = [row.get(self.args.image_column) for row in rows]
        kwargs: dict[str, Any] = {"text": texts, "padding": True, "truncation": True, "max_length": self.args.max_length, "return_tensors": "pt"}
        if images is not None and any(image is not None for image in images):
            kwargs["images"] = images
        batch = self.processor(**kwargs)
        if "input_ids" in batch:
            labels = batch["input_ids"].clone()
            pad_id = getattr(getattr(self.processor, "tokenizer", None), "pad_token_id", None)
            if pad_id is not None:
                labels[labels == pad_id] = -100
            batch["labels"] = labels
        return batch


class VisionLanguageRuntime(ModelRuntime):
    runtime_id = "vision-language"

    @classmethod
    def score(cls, model_id, config, tags):
        haystack = " ".join([model_id, getattr(config, "model_type", ""), *(getattr(config, "architectures", []) or []), *tags]).lower()
        return 70 if any(term in haystack for term in ("image-text-to-text", "vision", "multimodal", "any-to-any")) else 0

    @classmethod
    def plan(cls, model_id, config):
        return RuntimePlan(cls.runtime_id, "text+image", "Auto multimodal model", "AutoProcessor", "lora", [])

    def _model_class(self):
        import transformers
        for name in ("AutoModelForMultimodalLM", "AutoModelForImageTextToText", "AutoModelForVision2Seq"):
            candidate = getattr(transformers, name, None)
            if candidate is not None:
                return candidate
        raise RuntimeError("This Transformers version has no multimodal auto-model class.")

    def load(self, args, quantization_config):
        processor = AutoProcessor.from_pretrained(args.model_id, token=os.environ["HF_TOKEN"], trust_remote_code=args.trust_remote_code)
        model = self._model_class().from_pretrained(
            args.model_id,
            token=os.environ["HF_TOKEN"],
            trust_remote_code=args.trust_remote_code,
            torch_dtype="auto",
            device_map="auto" if torch.cuda.is_available() else None,
            quantization_config=quantization_config,
        )
        return model, processor

    def build_trainer(self, args, model, processor, train, validation, output_dir):
        return Trainer(
            model=model,
            args=training_arguments(args, output_dir, validation is not None),
            train_dataset=train,
            eval_dataset=validation,
            data_collator=MultimodalCollator(processor, args),
        )


class UnlimitedOCRNanoRuntime(VisionLanguageRuntime):
    runtime_id = "unlimited-ocr-nano"

    @classmethod
    def score(cls, model_id, config, tags):
        haystack = " ".join([model_id, getattr(config, "model_type", ""), *(getattr(config, "architectures", []) or []), *tags]).lower()
        return 95 if "unlimited-ocr-nano" in haystack else 0

    @classmethod
    def plan(cls, model_id, config):
        return RuntimePlan(
            cls.runtime_id,
            "document image → structured text",
            "AutoModel / custom trust_remote_code architecture",
            "AutoProcessor",
            "projector",
            [
                "Uses the model repository's custom processor and model code.",
                "Projector mode trains the multimodal projector while keeping backbone weights frozen when supported.",
                "Expected dataset columns are image plus text/target or prompt/response.",
            ],
        )

    def _model_class(self):
        from transformers import AutoModel
        return AutoModel

    def load(self, args, quantization_config):
        processor = AutoProcessor.from_pretrained(args.model_id, token=os.environ["HF_TOKEN"], trust_remote_code=True)
        model = self._model_class().from_pretrained(
            args.model_id,
            token=os.environ["HF_TOKEN"],
            trust_remote_code=True,
            torch_dtype="auto",
            device_map="auto" if torch.cuda.is_available() else None,
            quantization_config=quantization_config,
        )
        if args.method == "projector":
            if hasattr(model, "freeze_language_model"):
                model.freeze_language_model()
            if hasattr(model, "freeze_vision_encoder"):
                model.freeze_vision_encoder()
            if hasattr(model, "unfreeze_projector"):
                model.unfreeze_projector()
            else:
                for name, parameter in model.named_parameters():
                    parameter.requires_grad = any(key in name.lower() for key in ("projector", "multimodal_projector", "vision_projector"))
        return model, processor


class Gemma4Runtime(VisionLanguageRuntime):
    runtime_id = "gemma4"

    @classmethod
    def score(cls, model_id, config, tags):
        haystack = " ".join([model_id, getattr(config, "model_type", ""), *(getattr(config, "architectures", []) or []), *tags]).lower()
        return 100 if "gemma4" in haystack or "gemma-4" in haystack else 0

    @classmethod
    def plan(cls, model_id, config):
        return RuntimePlan(
            cls.runtime_id,
            "Gemma 4 any-to-any / image-text",
            "AutoModelForMultimodalLM",
            "AutoProcessor",
            "qlora",
            ["Text and image-conditioned SFT are enabled.", "Accept Gemma model terms before launching."],
        )


RUNTIMES: list[type[ModelRuntime]] = [Gemma4Runtime, UnlimitedOCRNanoRuntime, Seq2SeqRuntime, VisionLanguageRuntime, CausalLMRuntime]


def choose_runtime(runtime_id: str, model_id: str, config: Any, tags: list[str]) -> ModelRuntime:
    if runtime_id != "auto":
        for adapter in RUNTIMES:
            if adapter.runtime_id == runtime_id:
                return adapter()
        raise ValueError(f"Unknown adapter {runtime_id}")
    selected = max(RUNTIMES, key=lambda adapter: adapter.score(model_id, config, tags))
    return selected()


def training_arguments(args: argparse.Namespace, output_dir: Path, has_eval: bool) -> TrainingArguments:
    kwargs = dict(
        output_dir=str(output_dir),
        per_device_train_batch_size=args.batch_size,
        per_device_eval_batch_size=max(1, args.batch_size),
        gradient_accumulation_steps=args.gradient_accumulation,
        learning_rate=args.learning_rate,
        num_train_epochs=args.epochs,
        max_steps=args.max_steps,
        warmup_ratio=args.warmup_ratio,
        weight_decay=args.weight_decay,
        logging_steps=args.logging_steps,
        save_steps=args.save_steps,
        save_total_limit=2,
        fp16=args.precision == "fp16",
        bf16=args.precision == "bf16",
        gradient_checkpointing=args.gradient_checkpointing,
        remove_unused_columns=False,
        report_to=[],
        prediction_loss_only=True,
        seed=args.seed,
    )
    signature = inspect.signature(TrainingArguments)
    if "eval_strategy" in signature.parameters:
        kwargs["eval_strategy"] = "steps" if has_eval else "no"
    elif "evaluation_strategy" in signature.parameters:
        kwargs["evaluation_strategy"] = "steps" if has_eval else "no"
    if has_eval:
        kwargs["eval_steps"] = args.eval_steps
    return TrainingArguments(**kwargs)


def quantization(method: str) -> BitsAndBytesConfig | None:
    if method != "qlora":
        return None
    if not torch.cuda.is_available():
        raise RuntimeError("QLoRA requires a CUDA GPU.")
    compute_dtype = torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float16
    return BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type="nf4", bnb_4bit_use_double_quant=True, bnb_4bit_compute_dtype=compute_dtype)


def apply_peft(model: Any, args: argparse.Namespace) -> Any:
    if args.method not in {"lora", "qlora"}:
        return model
    if args.method == "qlora":
        model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=args.gradient_checkpointing)
    config = LoraConfig(
        r=args.lora_rank,
        lora_alpha=args.lora_alpha,
        lora_dropout=args.lora_dropout,
        bias="none",
        target_modules="all-linear",
        task_type="SEQ_2_SEQ_LM" if args.runtime_family == "seq2seq" else "CAUSAL_LM",
    )
    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: RuntimePlan) -> 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": "runtime",
        **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)]
        if args.resume_checkpoint:
            resume_root = Path(args.resume_checkpoint)
            trainer_states = sorted(resume_root.rglob("trainer_state.json"), key=lambda item: item.stat().st_mtime if item.exists() else 0) if resume_root.exists() else []
            if trainer_states:
                command += ["--resume-training-from", str(trainer_states[-1].parent)]
            else:
                model_roots = [resume_root] + [item.parent for item in resume_root.rglob("config.json")] if resume_root.exists() else []
                model_root = next((item for item in model_roots if (item / "config.json").exists() and (list(item.glob("*.safetensors")) or list(item.glob("*.bin")))), None)
                if model_root is not None:
                    command += ["--resume-from", str(model_root)]
                else:
                    print(json.dumps({"event":"warning","message":f"No resumable OCR checkpoint found below {resume_root}"}), flush=True)
        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,
            "runtime_family": plan.runtime_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("--runtime-family", default="auto", choices=["auto", "gemma4", "unlimited-ocr-nano", "vision-language", "seq2seq", "causal-lm"])
    parser.add_argument("--method", default="lora", choices=["projector", "lora", "qlora", "full"])
    parser.add_argument("--text-column", default="text")
    parser.add_argument("--prompt-column", default="prompt")
    parser.add_argument("--response-column", default="response")
    parser.add_argument("--messages-column", default="messages")
    parser.add_argument("--image-column", default="image")
    parser.add_argument("--max-samples", type=int, default=0)
    parser.add_argument("--max-length", type=int, default=2048)
    parser.add_argument("--batch-size", type=int, default=1)
    parser.add_argument("--gradient-accumulation", type=int, default=8)
    parser.add_argument("--learning-rate", type=float, default=2e-4)
    parser.add_argument("--epochs", type=float, default=1.0)
    parser.add_argument("--max-steps", type=int, default=-1)
    parser.add_argument("--warmup-ratio", type=float, default=0.03)
    parser.add_argument("--weight-decay", type=float, default=0.0)
    parser.add_argument("--logging-steps", type=int, default=1)
    parser.add_argument("--save-steps", type=int, default=50)
    parser.add_argument("--eval-steps", type=int, default=50)
    parser.add_argument("--precision", choices=["fp32", "fp16", "bf16"], default="bf16")
    parser.add_argument("--gradient-checkpointing", action="store_true")
    parser.add_argument("--lora-rank", type=int, default=16)
    parser.add_argument("--lora-alpha", type=int, default=32)
    parser.add_argument("--lora-dropout", type=float, default=0.05)
    parser.add_argument("--trust-remote-code", action="store_true")
    parser.add_argument("--resume-checkpoint", default="")
    parser.add_argument("--seed", type=int, default=42)
    parser.add_argument("--dry-run", action="store_true")
    return parser.parse_args()


def main() -> None:
    telemetry = start_telemetry()
    args = parse_args()
    token = os.environ["HF_TOKEN"]
    api = HfApi(token=token)
    info = api.model_info(args.model_id, token=token)
    is_ocr_nano = args.runtime_family == "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_runtime(args.runtime_family, args.model_id, config, list(info.tags or []))
    plan = adapter.plan(args.model_id, config)
    args.runtime_family = plan.runtime_id
    if plan.runtime_id == "unlimited-ocr-nano":
        run_unlimited_ocr_nano(args, token, plan)
        return
    print(json.dumps({"event": "runtime", **asdict(plan)}, ensure_ascii=False), flush=True)

    dataset_kwargs: dict[str, Any] = {"path": args.dataset_id, "split": args.train_split, "token": token}
    if args.dataset_config:
        dataset_kwargs["name"] = args.dataset_config
    train = load_dataset(**dataset_kwargs)
    if args.max_samples > 0:
        train = train.select(range(min(args.max_samples, len(train))))
    validation = None
    if args.validation_split:
        validation_kwargs = dict(dataset_kwargs)
        validation_kwargs["split"] = args.validation_split
        validation = load_dataset(**validation_kwargs)
        if args.max_samples > 0:
            validation = validation.select(range(min(max(1, args.max_samples // 10), len(validation))))

    print(json.dumps({"event": "dataset", "train_rows": len(train), "validation_rows": len(validation) if validation is not None else 0, "columns": train.column_names}), flush=True)
    if args.dry_run:
        print("100% · dry-run validation completed", flush=True)
        return

    with tempfile.TemporaryDirectory() as tmp:
        output_dir = Path(tmp) / "output"
        output_dir.mkdir(parents=True)
        model, processor = adapter.load(args, quantization(args.method))
        model = apply_peft(model, args)
        if hasattr(model, "config") and args.gradient_checkpointing:
            model.config.use_cache = False
        if hasattr(model, "print_trainable_parameters"):
            model.print_trainable_parameters()
        trainer = adapter.build_trainer(args, model, processor, train, validation, output_dir)
        trainer.train(resume_from_checkpoint=(args.resume_checkpoint or None))
        trainer.save_model(output_dir)
        if hasattr(processor, "save_pretrained"):
            processor.save_pretrained(output_dir)
        manifest = {"model_id": args.model_id, "dataset_id": args.dataset_id, "runtime_family": plan.runtime_id, "method": args.method, "arguments": vars(args)}
        (output_dir / "training_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: {args.method} on {args.dataset_id}")
        print(f"100% · uploaded model to {args.output_repo}", flush=True)


if __name__ == "__main__":
    main()