"""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()