Portable Colab/Kaggle diffusion lm-eval with SliceGPT and task workers

README.md

@@ -14,7 +14,7 @@ The shared configuration is bundled unchanged from Pruning-LLMs/diffusion_eval_a
 
 All three pruning methods are supported. SparseGPT/sink-aware load via AutoModel and trusted model code; SliceGPT reconstructs the saved sliced architecture from its bundled adapters on the meta device, then mmap-loads its own weights. Diffusion log-likelihood uses the LLaDA/Dream adapters rather than autoregressive scoring. GSM8K uses built-in five-shot settings; other tasks use zero shots.
 
-A dense-shape 8B checkpoint still occupies roughly 16 GB despite its zero weights. A 16 GB GPU needs CPU offload and activation headroom, so automatic device mapping reserves GPU space by default. CPU RAM and disk are also needed; use a larger RAM session if loading runs out of host memory. Offload is slower than keeping the model on a GPU. dtype=auto uses bf16 on supporting GPUs and float16 otherwise, recorded in metadata.
+A dense-shape 8B checkpoint still occupies roughly 16 GB despite its zero weights. A 16 GB GPU needs CPU offload and activation headroom, so automatic device mapping reserves GPU space by default. CPU RAM and disk are also needed; use a larger RAM session if loading runs out of host memory. SliceGPT precision conversion streams temporary weight shards instead of allocating the entire converted model in RAM. Runtime offload weights and temporary shards live in .eval_offload, outside results; --offload-dir changes that location. Offload is slower than keeping the model on a GPU. dtype=auto uses bf16 on supporting GPUs and float16 otherwise, recorded in metadata.
 
 Evaluate a different model in each session, or partition tasks across sessions:
 
@@ -30,3 +30,12 @@ Merging groups different settings/revisions separately and rejects conflicting d
 Discovery lists completed checkpoints for run-9fc515e82f313fab, including new Dream uploads as they appear. No Modal account or repository checkout is needed to evaluate. Evaluation is not launched on Modal.
 
 Source references: the project’s shared diffusion adapters and settings; [lm-evaluation-harness](https://github.com/EleutherAI/lm-evaluation-harness); [Accelerate inference/offload](https://huggingface.co/docs/accelerate/concept_guides/big_model_inference).
+
+
+Verification covers all 27 public checkpoint repositories and the shared configuration
+against the completed pruning manifest. The reproducible workspace checker
+modal_pruning/verify_portable_eval.py uses tiny real models for all three methods
+and both families, including Dream's pinned HF generation code. It checks reload
+logits, actual harness likelihood/generation, CPU/disk dispatch, and CUDA FP16
+with CPU offload when a local GPU is available. These checks do not replace a
+full 7B/8B benchmark run on the target platform.

bundle_manifest.json

@@ -1,7 +1,7 @@
 {
   "run_id": "run-9fc515e82f313fab",
-  "zip_sha256": "a8c72c00bd69f7893cd08cce771214896c21357f71e90ad12b9d1ab6b13b54c7",
-  "available_checkpoints": 20,
+  "zip_sha256": "b411146207493dffc19ab59daf94dc7738d349a1d88bb7e0c4c4b6f546c9e6ec",
+  "available_checkpoints": 27,
   "shared_config": "Pruning-LLMs/diffusion_eval_and_vis/config.py",
-  "smoke_tests": "Real tiny LLaDA/Dream + SliceGPT reload and lm-eval scoring; task sharding and merging"
+  "smoke_tests": "All three methods on tiny LLaDA/Dream: likelihood, generation, CPU/disk and CUDA fp16 offload, reload agreement; task sharding and merging"
 }

models.json

@@ -164,55 +164,55 @@
     "method": "sparsegpt",
     "sparsity": 0.4,
     "repo_id": "vanshnawander/structured-dream-v0-base-7b-sparsegpt-40-9fc515e82f313fab",
-    "ready": false,
-    "revision": null
+    "ready": true,
+    "revision": "aaf9800ddad970ac06f61ba15f5ed7be46e92b09"
   },
   {
     "model": "Dream-org/Dream-v0-Base-7B",
     "method": "sink_aware",
     "sparsity": 0.2,
     "repo_id": "vanshnawander/structured-dream-v0-base-7b-sink_aware-20-9fc515e82f313fab",
-    "ready": false,
-    "revision": null
+    "ready": true,
+    "revision": "eac827cc208d1e3672e3b40118d37577a81f336a"
   },
   {
     "model": "Dream-org/Dream-v0-Base-7B",
     "method": "sink_aware",
     "sparsity": 0.3,
     "repo_id": "vanshnawander/structured-dream-v0-base-7b-sink_aware-30-9fc515e82f313fab",
-    "ready": false,
-    "revision": null
+    "ready": true,
+    "revision": "9d1f90cf393b34fc40280a47a3ea056cf9bc69ce"
   },
   {
     "model": "Dream-org/Dream-v0-Base-7B",
     "method": "sink_aware",
     "sparsity": 0.4,
     "repo_id": "vanshnawander/structured-dream-v0-base-7b-sink_aware-40-9fc515e82f313fab",
-    "ready": false,
-    "revision": null
+    "ready": true,
+    "revision": "d4fa71d6574ad2f336e2071a3001e3191551479d"
   },
   {
     "model": "Dream-org/Dream-v0-Base-7B",
     "method": "slicegpt",
     "sparsity": 0.2,
     "repo_id": "vanshnawander/structured-dream-v0-base-7b-slicegpt-20-9fc515e82f313fab",
-    "ready": false,
-    "revision": null
+    "ready": true,
+    "revision": "6910b571baa7f865ac3647e5edf4864a3a71cb0f"
   },
   {
     "model": "Dream-org/Dream-v0-Base-7B",
     "method": "slicegpt",
     "sparsity": 0.3,
     "repo_id": "vanshnawander/structured-dream-v0-base-7b-slicegpt-30-9fc515e82f313fab",
-    "ready": false,
-    "revision": null
+    "ready": true,
+    "revision": "e91b8a5338c979eebbb436f7004ce09c58d252f6"
   },
   {
     "model": "Dream-org/Dream-v0-Base-7B",
     "method": "slicegpt",
     "sparsity": 0.4,
     "repo_id": "vanshnawander/structured-dream-v0-base-7b-slicegpt-40-9fc515e82f313fab",
-    "ready": false,
-    "revision": null
+    "ready": true,
+    "revision": "8fec00f2b8a76cba6aaa35dff1063302210fe930"
   }
 ]

portable_eval.zip

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a8c72c00bd69f7893cd08cce771214896c21357f71e90ad12b9d1ab6b13b54c7
-size 36274
+oid sha256:b411146207493dffc19ab59daf94dc7738d349a1d88bb7e0c4c4b6f546c9e6ec
+size 37700

runner.py

@@ -92,6 +92,62 @@ def load_sliced_cpu(path, 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
@@ -107,6 +163,8 @@ def load_checkpoint(path, cfg, device_map="auto", gpu_memory_ratio=0.65, cpu_gib
     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:
@@ -115,12 +173,17 @@ def load_checkpoint(path, cfg, device_map="auto", gpu_memory_ratio=0.65, cpu_gib
     automatic = device_map == "auto" and cfg.device.startswith("cuda")
     limits = memory_limits(gpu_memory_ratio, cpu_gib) if automatic else None
     if sliced:
-        model = load_sliced_cpu(root, dtype)
+        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)
-            model = dispatch_model(model, device_map=mapping, offload_dir=offload_folder)
+            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:
@@ -191,6 +254,7 @@ def main():
     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")
@@ -236,7 +300,7 @@ def main():
         family = json.loads((root / "slicegpt_metadata.json").read_text())["family"]
     seed_all(cfg.seed)
     model, tokenizer = load_checkpoint(checkpoint, cfg, args.device_map, args.gpu_memory_ratio,
-                                        args.cpu_memory_gib, str(Path(args.output) / "offload"))
+                                        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})}

verification.json

@@ -0,0 +1,495 @@
+{
+  "public_checkpoints": {
+    "checkpoints": [
+      {
+        "job": "llada-8b-instruct-sparsegpt-20",
+        "public": true,
+        "repo_id": "vanshnawander/structured-llada-8b-instruct-sparsegpt-20-9fc515e82f313fab",
+        "revision": "f56c3dc9ba0eac6bbbb91fdcbaa9f491b38fee3c"
+      },
+      {
+        "job": "llada-8b-instruct-sparsegpt-30",
+        "public": true,
+        "repo_id": "vanshnawander/structured-llada-8b-instruct-sparsegpt-30-9fc515e82f313fab",
+        "revision": "c75776ff0a1e149587307873f5fbdbfe390f7ef6"
+      },
+      {
+        "job": "llada-8b-instruct-sparsegpt-40",
+        "public": true,
+        "repo_id": "vanshnawander/structured-llada-8b-instruct-sparsegpt-40-9fc515e82f313fab",
+        "revision": "b35bc34c9140e54c426bd1dfadd6373a52208be1"
+      },
+      {
+        "job": "llada-8b-instruct-sink_aware-20",
+        "public": true,
+        "repo_id": "vanshnawander/structured-llada-8b-instruct-sink_aware-20-9fc515e82f313fab",
+        "revision": "d69a5fed4519009626459d98ba1f35f7a90aa768"
+      },
+      {
+        "job": "llada-8b-instruct-sink_aware-30",
+        "public": true,
+        "repo_id": "vanshnawander/structured-llada-8b-instruct-sink_aware-30-9fc515e82f313fab",
+        "revision": "354ef39bb56f01f8489252f6d9c048de3b7281e2"
+      },
+      {
+        "job": "llada-8b-instruct-sink_aware-40",
+        "public": true,
+        "repo_id": "vanshnawander/structured-llada-8b-instruct-sink_aware-40-9fc515e82f313fab",
+        "revision": "eb015d58762dfd00839592f6c742124aee2cf4a1"
+      },
+      {
+        "job": "llada-8b-instruct-slicegpt-20",
+        "public": true,
+        "repo_id": "vanshnawander/structured-llada-8b-instruct-slicegpt-20-9fc515e82f313fab",
+        "revision": "63b9d0aa610eb91b70ff0cf4554e0c91df63e0c6"
+      },
+      {
+        "job": "llada-8b-instruct-slicegpt-30",
+        "public": true,
+        "repo_id": "vanshnawander/structured-llada-8b-instruct-slicegpt-30-9fc515e82f313fab",
+        "revision": "bc356927822d6fb348bf1e8d9660e24b5a611f13"
+      },
+      {
+        "job": "llada-8b-instruct-slicegpt-40",
+        "public": true,
+        "repo_id": "vanshnawander/structured-llada-8b-instruct-slicegpt-40-9fc515e82f313fab",
+        "revision": "f764f12c668d4a86c27bcbeb7a86e155ff21d950"
+      },
+      {
+        "job": "llada-8b-base-sparsegpt-20",
+        "public": true,
+        "repo_id": "vanshnawander/structured-llada-8b-base-sparsegpt-20-9fc515e82f313fab",
+        "revision": "859332c99f41154227543c065422248a7241135b"
+      },
+      {
+        "job": "llada-8b-base-sparsegpt-30",
+        "public": true,
+        "repo_id": "vanshnawander/structured-llada-8b-base-sparsegpt-30-9fc515e82f313fab",
+        "revision": "d4eb47ef5bb69c64b0384035887fb699d62d6b29"
+      },
+      {
+        "job": "llada-8b-base-sparsegpt-40",
+        "public": true,
+        "repo_id": "vanshnawander/structured-llada-8b-base-sparsegpt-40-9fc515e82f313fab",
+        "revision": "4f63215a6558d9ec3da32ce3d7552cc37e545d67"
+      },
+      {
+        "job": "llada-8b-base-sink_aware-20",
+        "public": true,
+        "repo_id": "vanshnawander/structured-llada-8b-base-sink_aware-20-9fc515e82f313fab",
+        "revision": "147ea0349de86619588d31404ca2ec4fc90a88c3"
+      },
+      {
+        "job": "llada-8b-base-sink_aware-30",
+        "public": true,
+        "repo_id": "vanshnawander/structured-llada-8b-base-sink_aware-30-9fc515e82f313fab",
+        "revision": "504029e464125f1aefb5d5ea528fec080d33a936"
+      },
+      {
+        "job": "llada-8b-base-sink_aware-40",
+        "public": true,
+        "repo_id": "vanshnawander/structured-llada-8b-base-sink_aware-40-9fc515e82f313fab",
+        "revision": "1732e7faf3bb942dff4d158c8688ef0f8ad3af19"
+      },
+      {
+        "job": "llada-8b-base-slicegpt-20",
+        "public": true,
+        "repo_id": "vanshnawander/structured-llada-8b-base-slicegpt-20-9fc515e82f313fab",
+        "revision": "88e504f8cbf5f42247fff76b59e165c7387b7109"
+      },
+      {
+        "job": "llada-8b-base-slicegpt-30",
+        "public": true,
+        "repo_id": "vanshnawander/structured-llada-8b-base-slicegpt-30-9fc515e82f313fab",
+        "revision": "209c312df7a7340353c60e29f7979b3593dcab86"
+      },
+      {
+        "job": "llada-8b-base-slicegpt-40",
+        "public": true,
+        "repo_id": "vanshnawander/structured-llada-8b-base-slicegpt-40-9fc515e82f313fab",
+        "revision": "ff324612ab470949f4183b560dbe188488b00205"
+      },
+      {
+        "job": "dream-v0-base-7b-sparsegpt-20",
+        "public": true,
+        "repo_id": "vanshnawander/structured-dream-v0-base-7b-sparsegpt-20-9fc515e82f313fab",
+        "revision": "f3aa7c71b0edbf9412bd7e569068e8b79f32e6b4"
+      },
+      {
+        "job": "dream-v0-base-7b-sparsegpt-30",
+        "public": true,
+        "repo_id": "vanshnawander/structured-dream-v0-base-7b-sparsegpt-30-9fc515e82f313fab",
+        "revision": "37b5b1d8e5a9f4070e6fe22268b0ef4a988a0a9f"
+      },
+      {
+        "job": "dream-v0-base-7b-sparsegpt-40",
+        "public": true,
+        "repo_id": "vanshnawander/structured-dream-v0-base-7b-sparsegpt-40-9fc515e82f313fab",
+        "revision": "aaf9800ddad970ac06f61ba15f5ed7be46e92b09"
+      },
+      {
+        "job": "dream-v0-base-7b-sink_aware-20",
+        "public": true,
+        "repo_id": "vanshnawander/structured-dream-v0-base-7b-sink_aware-20-9fc515e82f313fab",
+        "revision": "eac827cc208d1e3672e3b40118d37577a81f336a"
+      },
+      {
+        "job": "dream-v0-base-7b-sink_aware-30",
+        "public": true,
+        "repo_id": "vanshnawander/structured-dream-v0-base-7b-sink_aware-30-9fc515e82f313fab",
+        "revision": "9d1f90cf393b34fc40280a47a3ea056cf9bc69ce"
+      },
+      {
+        "job": "dream-v0-base-7b-sink_aware-40",
+        "public": true,
+        "repo_id": "vanshnawander/structured-dream-v0-base-7b-sink_aware-40-9fc515e82f313fab",
+        "revision": "d4fa71d6574ad2f336e2071a3001e3191551479d"
+      },
+      {
+        "job": "dream-v0-base-7b-slicegpt-20",
+        "public": true,
+        "repo_id": "vanshnawander/structured-dream-v0-base-7b-slicegpt-20-9fc515e82f313fab",
+        "revision": "6910b571baa7f865ac3647e5edf4864a3a71cb0f"
+      },
+      {
+        "job": "dream-v0-base-7b-slicegpt-30",
+        "public": true,
+        "repo_id": "vanshnawander/structured-dream-v0-base-7b-slicegpt-30-9fc515e82f313fab",
+        "revision": "e91b8a5338c979eebbb436f7004ce09c58d252f6"
+      },
+      {
+        "job": "dream-v0-base-7b-slicegpt-40",
+        "public": true,
+        "repo_id": "vanshnawander/structured-dream-v0-base-7b-slicegpt-40-9fc515e82f313fab",
+        "revision": "8fec00f2b8a76cba6aaa35dff1063302210fe930"
+      }
+    ],
+    "complete": true,
+    "file_sizes_and_lfs_hashes_verified": 27,
+    "phase": "pruning_and_uploads_complete",
+    "verified_public": 27
+  },
+  "config": {
+    "checkpoint_count": 27,
+    "gsm8k_fewshot": 5,
+    "notebook_cells_valid": true,
+    "portable_config_sha256": "a8f056bb8e7d35b588fbf17d03a9f3394364b92a336b92c2d7c7254f01ed76e3",
+    "shared_config_matches_pruning_manifest": true,
+    "tasks": [
+      "arc_easy",
+      "winogrande",
+      "piqa",
+      "arc_challenge",
+      "hellaswag",
+      "boolq",
+      "gsm8k"
+    ]
+  },
+  "integration": {
+    "checks": [
+      {
+        "checks": [
+          {
+            "device_map": {
+              "": "cpu"
+            },
+            "mode": "single_cpu",
+            "offload": false,
+            "reload_logits_match": true,
+            "tasks": [
+              "eval_choice",
+              "eval_generate"
+            ]
+          },
+          {
+            "device_map": {
+              "model.transformer.blocks": "disk",
+              "model.transformer.emb_drop": "cpu",
+              "model.transformer.ff_out": "disk",
+              "model.transformer.ln_f": "cpu",
+              "model.transformer.wte": "cpu"
+            },
+            "mode": "cpu_disk",
+            "offload": true,
+            "reload_logits_match": true,
+            "tasks": [
+              "eval_choice",
+              "eval_generate"
+            ]
+          },
+          {
+            "device_map": {
+              "model.transformer.blocks": "cpu",
+              "model.transformer.emb_drop": 0,
+              "model.transformer.ff_out": "cpu",
+              "model.transformer.ln_f": 0,
+              "model.transformer.wte": 0
+            },
+            "mode": "cuda_cpu_fp16",
+            "offload": true,
+            "reload_logits_match": true,
+            "tasks": [
+              "eval_choice",
+              "eval_generate"
+            ]
+          }
+        ],
+        "family": "llada",
+        "method": "sparsegpt"
+      },
+      {
+        "checks": [
+          {
+            "device_map": {
+              "": "cpu"
+            },
+            "mode": "single_cpu",
+            "offload": false,
+            "reload_logits_match": true,
+            "tasks": [
+              "eval_choice",
+              "eval_generate"
+            ]
+          },
+          {
+            "device_map": {
+              "model.transformer.blocks": "disk",
+              "model.transformer.emb_drop": "cpu",
+              "model.transformer.ff_out": "disk",
+              "model.transformer.ln_f": "cpu",
+              "model.transformer.wte": "cpu"
+            },
+            "mode": "cpu_disk",
+            "offload": true,
+            "reload_logits_match": true,
+            "tasks": [
+              "eval_choice",
+              "eval_generate"
+            ]
+          },
+          {
+            "device_map": {
+              "model.transformer.blocks": "cpu",
+              "model.transformer.emb_drop": 0,
+              "model.transformer.ff_out": "cpu",
+              "model.transformer.ln_f": 0,
+              "model.transformer.wte": 0
+            },
+            "mode": "cuda_cpu_fp16",
+            "offload": true,
+            "reload_logits_match": true,
+            "tasks": [
+              "eval_choice",
+              "eval_generate"
+            ]
+          }
+        ],
+        "family": "llada",
+        "method": "sink_aware"
+      },
+      {
+        "checks": [
+          {
+            "device_map": {},
+            "mode": "single_cpu",
+            "offload": false,
+            "reload_logits_match": true,
+            "tasks": [
+              "eval_choice",
+              "eval_generate"
+            ]
+          },
+          {
+            "device_map": {
+              "model.transformer.blocks": "disk",
+              "model.transformer.emb_drop": "cpu",
+              "model.transformer.ff_out": "disk",
+              "model.transformer.ln_f": "cpu",
+              "model.transformer.wte": "cpu"
+            },
+            "mode": "cpu_disk",
+            "offload": true,
+            "reload_logits_match": true,
+            "tasks": [
+              "eval_choice",
+              "eval_generate"
+            ]
+          },
+          {
+            "device_map": {
+              "model.transformer.blocks": "cpu",
+              "model.transformer.emb_drop": 0,
+              "model.transformer.ff_out": "cpu",
+              "model.transformer.ln_f": 0,
+              "model.transformer.wte": 0
+            },
+            "mode": "cuda_cpu_fp16",
+            "offload": true,
+            "reload_logits_match": true,
+            "tasks": [
+              "eval_choice",
+              "eval_generate"
+            ]
+          }
+        ],
+        "family": "llada",
+        "method": "slicegpt"
+      },
+      {
+        "checks": [
+          {
+            "device_map": {
+              "": "cpu"
+            },
+            "mode": "single_cpu",
+            "offload": false,
+            "reload_logits_match": true,
+            "tasks": [
+              "eval_choice",
+              "eval_generate"
+            ]
+          },
+          {
+            "device_map": {
+              "lm_head": "disk",
+              "model.embed_tokens": "cpu",
+              "model.layers": "disk",
+              "model.norm": "disk",
+              "model.rotary_emb": "disk"
+            },
+            "mode": "cpu_disk",
+            "offload": true,
+            "reload_logits_match": true,
+            "tasks": [
+              "eval_choice",
+              "eval_generate"
+            ]
+          },
+          {
+            "device_map": {
+              "lm_head": "cpu",
+              "model.embed_tokens": 0,
+              "model.layers": "cpu",
+              "model.norm": "cpu",
+              "model.rotary_emb": "cpu"
+            },
+            "mode": "cuda_cpu_fp16",
+            "offload": true,
+            "reload_logits_match": true,
+            "tasks": [
+              "eval_choice",
+              "eval_generate"
+            ]
+          }
+        ],
+        "family": "dream",
+        "method": "sparsegpt"
+      },
+      {
+        "checks": [
+          {
+            "device_map": {
+              "": "cpu"
+            },
+            "mode": "single_cpu",
+            "offload": false,
+            "reload_logits_match": true,
+            "tasks": [
+              "eval_choice",
+              "eval_generate"
+            ]
+          },
+          {
+            "device_map": {
+              "lm_head": "disk",
+              "model.embed_tokens": "cpu",
+              "model.layers": "disk",
+              "model.norm": "disk",
+              "model.rotary_emb": "disk"
+            },
+            "mode": "cpu_disk",
+            "offload": true,
+            "reload_logits_match": true,
+            "tasks": [
+              "eval_choice",
+              "eval_generate"
+            ]
+          },
+          {
+            "device_map": {
+              "lm_head": "cpu",
+              "model.embed_tokens": 0,
+              "model.layers": "cpu",
+              "model.norm": "cpu",
+              "model.rotary_emb": "cpu"
+            },
+            "mode": "cuda_cpu_fp16",
+            "offload": true,
+            "reload_logits_match": true,
+            "tasks": [
+              "eval_choice",
+              "eval_generate"
+            ]
+          }
+        ],
+        "family": "dream",
+        "method": "sink_aware"
+      },
+      {
+        "checks": [
+          {
+            "device_map": {},
+            "mode": "single_cpu",
+            "offload": false,
+            "reload_logits_match": true,
+            "tasks": [
+              "eval_choice",
+              "eval_generate"
+            ]
+          },
+          {
+            "device_map": {
+              "lm_head": "disk",
+              "model.embed_tokens": "cpu",
+              "model.layers": "disk",
+              "model.norm": "disk",
+              "model.rotary_emb": "disk"
+            },
+            "mode": "cpu_disk",
+            "offload": true,
+            "reload_logits_match": true,
+            "tasks": [
+              "eval_choice",
+              "eval_generate"
+            ]
+          },
+          {
+            "device_map": {
+              "lm_head": "cpu",
+              "model.embed_tokens": 0,
+              "model.layers": "cpu",
+              "model.norm": "cpu",
+              "model.rotary_emb": "cpu"
+            },
+            "mode": "cuda_cpu_fp16",
+            "offload": true,
+            "reload_logits_match": true,
+            "tasks": [
+              "eval_choice",
+              "eval_generate"
+            ]
+          }
+        ],
+        "family": "dream",
+        "method": "slicegpt"
+      }
+    ],
+    "complete": true,
+    "dream_code_repo": "vanshnawander/structured-dream-v0-base-7b-sparsegpt-20-9fc515e82f313fab",
+    "dream_code_revision": "f3aa7c71b0edbf9412bd7e569068e8b79f32e6b4",
+    "evaluation_paths": 18,
+    "tiny_models": 6
+  },
+  "smoke_tests_passed": 70,
+  "full_7b_8b_benchmarks_run": false
+}