runner.py

"""Portable lm-eval for public structured LLaDA/Dream checkpoints."""
import argparse
from dataclasses import asdict
import gc
import hashlib
import importlib.util
import json
import os
from pathlib import Path
import random
import sys
import time
sys.path.insert(0, str(Path(__file__).resolve().parent))
from diffusion_eval_and_vis.config import DiffusionEvalConfig

DEFAULT_RUN = "9fc515e82f313fab"
DEFAULT_OWNER = "vanshnawander"


def write_json(path, value):
    path = Path(path)
    path.parent.mkdir(parents=True, exist_ok=True)
    temporary = path.with_suffix(path.suffix + ".tmp")
    def clean(value):
        import math
        if isinstance(value, dict):
            return {str(k): clean(v) for k, v in value.items()}
        if isinstance(value, (list, tuple)):
            return [clean(v) for v in value]
        if hasattr(value, "tolist"):
            return clean(value.tolist())
        if isinstance(value, float) and not math.isfinite(value):
            return None
        if value is None or isinstance(value, (str, int, float, bool)):
            return value
        return str(value)
    temporary.write_text(json.dumps(clean(value), indent=2, allow_nan=False))
    temporary.replace(path)


def seed_all(seed):
    import numpy as np
    import torch
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)


def split_tasks(tasks, worker_index, num_workers):
    if num_workers < 1 or not 0 <= worker_index < num_workers:
        raise ValueError("Require 0 <= worker-index < num-workers")
    return list(tasks)[worker_index::num_workers]


def discover(owner=DEFAULT_OWNER, run=DEFAULT_RUN):
    from huggingface_hub import HfApi
    api = HfApi(token=os.environ.get("HF_TOKEN", False))
    ready = []
    for model in api.list_models(author=owner):
        if not model.id.startswith(owner + "/structured-") or not model.id.endswith("-" + run):
            continue
        info = api.model_info(model.id)
        names = {entry.rfilename for entry in info.siblings}
        if "checkpoint_manifest.json" in names and names & {"model.safetensors", "model.safetensors.index.json", "slicegpt_state.pt"}:
            ready.append({"repo_id": model.id, "revision": info.sha})
    return sorted(ready, key=lambda row: row["repo_id"])


def load_sliced_cpu(path, dtype):
    """Construct the saved architecture on meta, then mmap and assign its weights."""
    import torch
    from accelerate import init_empty_weights
    from transformers import AutoConfig, AutoModel
    from transformers.modeling_utils import no_init_weights
    root = Path(path)
    sys.path.insert(0, str(root / "loader_code"))
    from slicegpt.adapters.llada_adapter import LLaDAModelAdapter, replace_llada_rms
    from slicegpt.adapters.dream_adapter import DreamModelAdapter, replace_dream_rms
    from slicegpt.layernorm_fusion import replace_layers
    from slicegpt.model_adapter import SlicingConfig
    from slicegpt.rotate import slice_rotated_model
    meta = json.loads((root / "slicegpt_metadata.json").read_text())
    config = AutoConfig.from_pretrained(root, trust_remote_code=True)
    saved_dtype = getattr(torch, meta["dtype"].split(".")[-1])
    previous = torch.get_default_dtype()
    try:
        torch.set_default_dtype(saved_dtype)
        with init_empty_weights(), no_init_weights():
            model = AutoModel.from_config(config, trust_remote_code=True)
            adapter = DreamModelAdapter(model) if meta["family"] == "dream" else LLaDAModelAdapter(model)
            replace_layers(adapter, verbose=False)
            (replace_dream_rms if meta["family"] == "dream" else replace_llada_rms)(adapter)
            adapter.slicing_conf = SlicingConfig.from_json_string((root / "slicing_config.json").read_text())
            for layer in adapter.get_layers():
                layer.layer.attn_shortcut_Q = torch.nn.Parameter(torch.empty(adapter.hidden_size, adapter.hidden_size))
                layer.layer.mlp_shortcut_Q = torch.nn.Parameter(torch.empty(adapter.hidden_size, adapter.hidden_size))
            slice_rotated_model(adapter)
    finally:
        torch.set_default_dtype(previous)
    state = torch.load(root / "slicegpt_state.pt", map_location="cpu", mmap=True, weights_only=True)
    model.load_state_dict(state, strict=True, assign=True)
    if any(p.is_meta for p in model.parameters()):
        raise ValueError("SliceGPT loader left unmaterialized parameters")
    if dtype != saved_dtype:
        model.to(dtype=dtype)
    return model



def sliced_shard_index(root, model, folder, shard_bytes=128 * 1024**2):
    """Stream mmap-backed weights into shards without converting the whole model."""
    import torch
    original = root / "slicegpt_state.pt"
    stat = original.stat()
    identity = hashlib.sha256(f"{original.resolve()}:{stat.st_size}:{stat.st_mtime_ns}".encode()).hexdigest()[:16]
    target = Path(folder) / ("sliced-shards-" + identity)
    index = target / "pytorch_model.bin.index.json"
    if index.exists():
        data = json.loads(index.read_text())
        if all((target / name).is_file() for name in set(data["weight_map"].values())):
            return index
    target.mkdir(parents=True, exist_ok=True)
    state = model.state_dict()
    group, weight_map = {}, {}
    total, current, number = 0, 0, 0
    def save_group():
        nonlocal group, current, number
        number += 1
        name = f"pytorch_model-{number:05d}.bin"
        temporary = target / (name + ".tmp")
        torch.save(group, temporary)
        temporary.replace(target / name)
        weight_map.update({key: name for key in group})
        group, current = {}, 0
    for name, tensor in state.items():
        size = tensor.numel() * tensor.element_size()
        if group and current + size > shard_bytes:
            save_group()
        group[name] = tensor
        current += size
        total += size
    if group:
        save_group()
    write_json(index, {"metadata": {"total_size": total}, "weight_map": weight_map})
    return index


def dispatch_sliced_dtype(model, root, mapping, dtype, folder):
    """Convert only the shards being loaded, respecting CPU/GPU/disk placement."""
    import torch
    from accelerate import load_checkpoint_and_dispatch
    index = sliced_shard_index(root, model, folder)
    # Keep nonpersistent RoPE buffers materialized; only parameters become empty.
    for module in model.modules():
        for name, parameter in list(module._parameters.items()):
            if parameter is not None:
                module._parameters[name] = torch.nn.Parameter(
                    torch.empty_like(parameter, device="meta", dtype=dtype),
                    requires_grad=parameter.requires_grad)
    model.config.torch_dtype = dtype
    gc.collect()
    return load_checkpoint_and_dispatch(model, str(index), device_map=mapping,
        dtype=dtype, offload_folder=str(folder), offload_state_dict=True)

def memory_limits(ratio, cpu_gib=None):
    import psutil
    import torch
    if not 0 < ratio < 1:
        raise ValueError("GPU memory ratio must be between zero and one")
    limits = {i: int(torch.cuda.mem_get_info(i)[0] * ratio) for i in range(torch.cuda.device_count())}
    limits["cpu"] = int(cpu_gib * 1024**3) if cpu_gib else max(1024**3, int(psutil.virtual_memory().available * 0.7))
    return limits


def load_checkpoint(path, cfg, device_map="auto", gpu_memory_ratio=0.65, cpu_gib=None, offload_folder="offload"):
    import torch
    from accelerate import dispatch_model, infer_auto_device_map
    from transformers import AutoModel, AutoTokenizer
    root = Path(path)
    # Different models/revisions must never share disk offload weight filenames.
    offload_folder = str(Path(offload_folder) / hashlib.sha256(str(root.resolve()).encode()).hexdigest()[:16])
    sliced = (root / "slicegpt_metadata.json").exists()
    tokenizer = AutoTokenizer.from_pretrained(root, trust_remote_code=True)
    if tokenizer.pad_token_id is None:
        tokenizer.pad_token = tokenizer.eos_token
    dtype = getattr(torch, cfg.dtype)
    automatic = device_map == "auto" and cfg.device.startswith("cuda")
    limits = memory_limits(gpu_memory_ratio, cpu_gib) if automatic else None
    if sliced:
        saved_dtype = getattr(torch, json.loads((root / "slicegpt_metadata.json").read_text())["dtype"].split(".")[-1])
        # Mapping first keeps BF16 mmap-backed weights from becoming a full FP16 RAM copy.
        model = load_sliced_cpu(root, saved_dtype if automatic else dtype)
        if automatic:
            blocks = model.model.layers if hasattr(model.model, "layers") else model.model.transformer.blocks
            no_split = sorted({type(block).__name__ for block in blocks})
            mapping = infer_auto_device_map(model, max_memory=limits, no_split_module_classes=no_split, dtype=dtype)
            if dtype != saved_dtype:
                model = dispatch_sliced_dtype(model, root, mapping, dtype, offload_folder)
            else:
                model = dispatch_model(model, device_map=mapping, offload_dir=offload_folder)
        else:
            model.to(cfg.device)
    else:
        model = AutoModel.from_pretrained(root, trust_remote_code=True, torch_dtype=dtype,
                                         low_cpu_mem_usage=True, device_map="auto" if automatic else {"": cfg.device},
                                         max_memory=limits, offload_folder=offload_folder,
                                         offload_state_dict=True)
    model.config.use_cache = False
    model.eval()
    return model, tokenizer


def adapter_parameters(cfg, family):
    """The exact config values passed to the benchmark adapter."""
    common = {"batch_size": cfg.batch_size, "mc_num": cfg.mc_num, "device": cfg.device}
    if family == "dream":
        return {**common, "add_bos_token": cfg.add_bos_token and not cfg.no_add_bos_token,
                "max_length": cfg.max_length, "nll_type": cfg.nll_type, "log_type": cfg.log_type,
                "sampling_eps": cfg.sampling_eps, "classifier_free_guidance": cfg.dream_cfg,
                "diffusion_steps": cfg.dream_steps, "gen_length": cfg.dream_gen_length,
                "gen_alg": cfg.dream_gen_alg, "gen_temperature": cfg.dream_gen_temperature}
    return {**common, "mask_id": cfg.llada_mask_id, "dtype": cfg.dtype,
            "is_check_greedy": cfg.is_check_greedy, "cfg": cfg.llada_cfg,
            "steps": cfg.llada_steps, "gen_length": cfg.llada_gen_length,
            "block_length": cfg.llada_block_length, "remasking": cfg.llada_remasking}


def make_adapter(model, tokenizer, cfg, family, checkpoint=""):
    parameters = adapter_parameters(cfg, family)
    if family == "dream":
        from diffusion_eval_and_vis.eval_dream import DreamLM
        return DreamLM(model, tokenizer, **parameters)
    from diffusion_eval_and_vis.eval_diffusion import LLaDiffusionLM
    return LLaDiffusionLM(model_path=checkpoint, model_instance=model, tokenizer_instance=tokenizer,
                         **parameters)


def merge_results(root, destination):
    groups = {}
    for path in Path(root).rglob("*.json"):
        value = json.loads(path.read_text())
        if value.get("kind") not in {"lm_eval_task", "perplexity"} or not value.get("complete"):
            continue
        metadata = value["metadata"]
        key = (metadata["repo_id"], metadata["revision"],
               json.dumps(metadata["eval_config"], sort_keys=True))
        group = groups.setdefault(key, {"metadata": metadata, "results": {}, "tasks": [], "perplexities": {}})
        if value["kind"] == "perplexity":
            dataset = value.get("results", {}).get("dataset") or path.stem.removeprefix("perplexity_").removeprefix("ppl_")
            number = value.get("value", value.get("results", {}).get("perplexity"))
            if dataset in group["perplexities"] and group["perplexities"][dataset] != number:
                raise ValueError("Conflicting duplicate perplexity: " + dataset)
            group["perplexities"][dataset] = number
            continue
        for task, metrics in value["results"]["results"].items():
            if task in group["results"] and group["results"][task] != metrics:
                raise ValueError("Conflicting duplicate task results: " + task)
            group["results"][task] = metrics
            if task not in group["tasks"]:
                group["tasks"].append(task)
    write_json(destination, {"evaluations": list(groups.values())})
    return len(groups)



def evaluation_units(cfg, family, selected_tasks=None, selected_units=None, worker_index=0, num_workers=1):
    tasks = selected_tasks or ((cfg.dream_tasks or cfg.llada_tasks) if family == "dream" else cfg.llada_tasks)
    allowed = ["task:" + task for task in tasks] + ([] if cfg.skip_ppl else ["ppl:" + dataset for dataset in cfg.ppl_datasets])
    units = list(selected_units) if selected_units is not None else allowed
    if len(set(units)) != len(units) or not set(units) <= set(allowed):
        raise ValueError("Unknown or duplicate evaluation units")
    return split_tasks(units, worker_index, num_workers)


def matching_result(value, metadata):
    old = value.get("metadata", {})
    return bool(value.get("complete") and old.get("repo_id") == metadata["repo_id"]
                and old.get("revision") == metadata["revision"] and old.get("eval_config") == metadata["eval_config"])


def run_units(model, tokenizer, cfg, family, checkpoint, metadata, output, units, deadline=None, request_chunk_size=32):
    from diffusion_eval_and_vis.resume import attach_response_cache, EvaluationContinuation
    from diffusion_eval_and_vis.lm_eval_utils import evaluate_tasks
    import lm_eval
    output = Path(output)
    completed = []
    for unit in units:
        path = output / (unit.split(":", 1)[1] + ".json" if unit.startswith("task:") else
                         "perplexity_" + unit.split(":", 1)[1] + ".json")
        if path.exists() and matching_result(json.loads(path.read_text()), metadata):
            print("Already completed:", unit, flush=True)
            completed.append(unit)
            continue
        if deadline is not None and time.monotonic() >= deadline:
            return {"complete": False, "completed_units": completed, "pending_unit": unit}
        signature = {"repo_id": metadata["repo_id"], "revision": metadata["revision"],
                     "eval_config": metadata["eval_config"], "unit": unit, "smoke": False}
        seed_all(cfg.seed)
        try:
            if unit.startswith("task:"):
                task = unit.split(":", 1)[1]
                adapter = make_adapter(model, tokenizer, cfg, family, checkpoint)
                attach_response_cache(adapter, output / (task + "_responses"), signature, lambda: None,
                                      seconds=float("inf"), progress=output / (task + "_progress.json"),
                                      deadline=deadline, request_chunk_size=request_chunk_size)
                def seeded_evaluate(**kw):
                    return lm_eval.simple_evaluate(**kw, random_seed=cfg.seed, numpy_random_seed=cfg.seed,
                                                  torch_random_seed=cfg.seed, fewshot_random_seed=cfg.seed)
                result = evaluate_tasks(adapter, [task], limit=cfg.limit, simple_evaluate=seeded_evaluate)
                if task not in result.get("results", {}):
                    raise ValueError("lm-eval returned no result for " + task)
                record = {"kind": "lm_eval_task", "complete": True, "metadata": metadata, "results": result}
                del adapter
            else:
                dataset = unit.split(":", 1)[1]
                if family == "dream":
                    from diffusion_eval_and_vis.eval_dream import evaluate_perplexity_dream as ppl
                    length = cfg.dream_ppl_seq_len
                else:
                    from diffusion_eval_and_vis.eval_diffusion import evaluate_perplexity as ppl
                    length = cfg.llada_ppl_seq_len
                kw = dict(model=model, tokenizer=tokenizer, dataset=dataset, seq_len=length, device=cfg.device,
                          mc_num=cfg.mc_num, mc_batch_size=cfg.batch_size,
                          resume_path=output / ("perplexity_" + dataset + "_resume.pt"),
                          resume_signature=signature, deadline=deadline)
                if family == "dream":
                    kw["sampling_eps"] = cfg.sampling_eps
                value = float(ppl(**kw))
                import math
                if not math.isfinite(value):
                    raise ValueError("Non-finite perplexity")
                record = {"kind": "perplexity", "complete": True, "metadata": metadata, "value": value,
                          "results": {"dataset": dataset, "perplexity": value}}
        except EvaluationContinuation:
            print("Progress saved; resume this unit in the next session:", unit, flush=True)
            return {"complete": False, "completed_units": completed, "pending_unit": unit}
        write_json(path, record)
        completed.append(unit)
        print("Saved:", path, flush=True)
    return {"complete": True, "completed_units": completed, "pending_unit": None}


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--repo")
    parser.add_argument("--revision")
    parser.add_argument("--checkpoint", help="Already downloaded local checkpoint")
    parser.add_argument("--family", choices=["llada", "dream"])
    parser.add_argument("--list", action="store_true")
    parser.add_argument("--show-config", action="store_true", help="Print effective config and adapter parameters without loading weights")
    parser.add_argument("--owner", default=DEFAULT_OWNER)
    parser.add_argument("--run", default=DEFAULT_RUN)
    parser.add_argument("--tasks", nargs="+")
    parser.add_argument("--units", nargs="+", help="Specific task:name or ppl:dataset units; supports PPL-only sessions")
    parser.add_argument("--time-budget-seconds", type=float, default=0, help="Stop after committing a response/sequence; zero is unlimited")
    parser.add_argument("--request-chunk-size", type=int, default=32, help="Durable likelihood responses per chunk; use 1 on slow GPUs")
    parser.add_argument("--require-finetuned-slice", action="store_true", help="Reject SliceGPT baselines without a sequential LoRA manifest")
    parser.add_argument("--batch-size", type=int)
    parser.add_argument("--mc-num", type=int)
    parser.add_argument("--limit", type=int)
    parser.add_argument("--dtype", choices=["auto", "bfloat16", "float16", "float32"])
    parser.add_argument("--device", default="cuda")
    parser.add_argument("--device-map", choices=["auto", "single"], default="auto")
    parser.add_argument("--gpu-memory-ratio", type=float, default=0.65)
    parser.add_argument("--cpu-memory-gib", type=float)
    parser.add_argument("--output", default="results")
    parser.add_argument("--cache-dir")
    parser.add_argument("--offload-dir", default=".eval_offload", help="Runtime weights, kept outside downloadable results")
    parser.add_argument("--worker-index", type=int, default=0)
    parser.add_argument("--num-workers", type=int, default=1)
    parser.add_argument("--skip-ppl", action="store_true")
    parser.add_argument("--smoke", action="store_true", help="Only load and check finite forward logits")
    parser.add_argument("--merge", help="Directory containing downloaded per-task results from all workers")
    args = parser.parse_args()
    if args.list:
        print(json.dumps(discover(args.owner, args.run), indent=2))
        return
    if args.merge:
        print({"merged_evaluations": merge_results(args.merge, args.output)})
        return
    if not args.repo and not args.checkpoint and not args.show_config:
        parser.error("Supply --repo or --checkpoint")
    import torch
    from huggingface_hub import HfApi, snapshot_download
    if args.time_budget_seconds < 0 or args.request_chunk_size < 1:
        raise ValueError("Time budget must be nonnegative and chunk size positive")
    deadline = time.monotonic() + args.time_budget_seconds if args.time_budget_seconds else None
    cfg = DiffusionEvalConfig()
    cfg.device = args.device
    for key in ("batch_size", "mc_num", "limit"):
        if getattr(args, key) is not None:
            setattr(cfg, key, getattr(args, key))
    cfg.skip_ppl = cfg.skip_ppl or args.skip_ppl
    cfg.dtype = args.dtype or cfg.dtype
    if cfg.dtype == "auto":
        cfg.dtype = "bfloat16" if cfg.device.startswith("cuda") and torch.cuda.is_bf16_supported() else "float16" if cfg.device.startswith("cuda") else "float32"
    if cfg.batch_size <= 0 or cfg.mc_num <= 0 or cfg.mc_num % cfg.batch_size:
        raise ValueError("batch-size must be positive and divide mc-num")
    if not args.show_config and cfg.device.startswith("cuda") and not torch.cuda.is_available():
        raise RuntimeError("Enable a GPU runtime or pass --device cpu")
    if not args.show_config and cfg.dtype == "bfloat16" and cfg.device.startswith("cuda") and not torch.cuda.is_bf16_supported():
        raise RuntimeError("This GPU needs --dtype auto or --dtype float16; the override is recorded in results")
    if args.show_config:
        family = args.family or ("dream" if "structured-dream-" in (args.repo or "") else "llada")
        tasks = args.tasks or (cfg.dream_tasks or cfg.llada_tasks if family == "dream" else cfg.llada_tasks)
        print(json.dumps({"family": family, "eval_config": asdict(cfg),
                          "adapter_parameters": adapter_parameters(cfg, family),
                          "worker_tasks": [u.split(":", 1)[1] for u in evaluation_units(cfg, family, args.tasks, args.units,
                              args.worker_index, args.num_workers) if u.startswith("task:")],
                          "worker_units": evaluation_units(cfg, family, args.tasks, args.units, args.worker_index, args.num_workers),
                          "perplexity_enabled": not cfg.skip_ppl,
                          "note": "llada_generation_* are separate helper defaults; the benchmark uses llada_steps/llada_gen_length/llada_block_length."}, indent=2))
        return
    token = os.environ.get("HF_TOKEN", False)
    if args.checkpoint:
        checkpoint, revision = args.checkpoint, args.revision or "local"
    else:
        info = HfApi(token=token).model_info(args.repo, revision=args.revision or "main")
        revision = info.sha  # Pin the checkpoint for the entire evaluation.
        checkpoint = snapshot_download(args.repo, revision=revision, token=token, cache_dir=args.cache_dir)
    root = Path(checkpoint)
    saved = json.loads((root / "checkpoint_manifest.json").read_text()) if (root / "checkpoint_manifest.json").exists() else None
    manifest_job = (saved.get("job", saved.get("provenance", {}).get("job", {})) if saved else {})
    family = args.family or ("dream" if manifest_job.get("model", "").startswith("Dream-org/") else "llada")
    if (root / "slicegpt_metadata.json").exists():
        family = json.loads((root / "slicegpt_metadata.json").read_text())["family"]
    if args.require_finetuned_slice and (root / "slicegpt_metadata.json").exists() and not (root / "finetune_manifest.json").exists():
        raise ValueError("This SliceGPT checkpoint has not completed sequential LoRA; choose a fine-tuned repo or remove --require-finetuned-slice to explicitly evaluate the pruned baseline")
    seed_all(cfg.seed)
    model, tokenizer = load_checkpoint(checkpoint, cfg, args.device_map, args.gpu_memory_ratio,
                                        args.cpu_memory_gib, str(Path(args.offload_dir) / f"worker-{args.worker_index}"))
    metadata = {"repo_id": args.repo or str(root), "revision": revision, "eval_config": asdict(cfg),
                "family": family, "torch_version": torch.__version__,
                "device_map": getattr(model, "hf_device_map", {"": cfg.device})}
    label = (args.repo or root.name).split("/")[-1]
    profile = hashlib.sha256(json.dumps(asdict(cfg), sort_keys=True).encode()).hexdigest()[:12]
    output = Path(args.output) / label / revision[:12] / profile
    write_json(output / "effective_config.json", {"metadata": metadata, "shared_source": "Pruning-LLMs/diffusion_eval_and_vis/config.py"})
    if args.smoke:
        inputs = tokenizer("The quick brown fox.", return_tensors="pt").input_ids.to(cfg.device)
        with torch.no_grad():
            logits = model(inputs).logits
        if not torch.isfinite(logits).all():
            raise ValueError("Checkpoint produced non-finite logits")
        write_json(output / "smoke.json", {"complete": True, "metadata": metadata, "shape": list(logits.shape)})
        print(json.dumps({"smoke_passed": True, "output": str(output), "metadata": metadata}, default=str))
        return
    units = evaluation_units(cfg, family, args.tasks, args.units, args.worker_index, args.num_workers)
    status = run_units(model, tokenizer, cfg, family, checkpoint, metadata, output, units,
                       deadline=deadline, request_chunk_size=args.request_chunk_size)
    write_json(output / "session_status.json", status)
    print(json.dumps({"output": str(output), **status}), flush=True)
    del model, tokenizer
    gc.collect()
    if torch.cuda.is_available():
        torch.cuda.empty_cache()


if __name__ == "__main__":
    main()