Publish E1M1 38-layer seed-0 bundle

README.md

@@ -7,7 +7,8 @@ pipeline_tag: text-generation
 
 This is a stock Hugging Face `Phi3ForCausalLM` that renders DOOM through
 ordinary autoregressive inference. The model and the data-only fast tokenizer
-load through ordinary Transformers auto classes without remote code.
+load through the ordinary Transformers text-generation pipeline without
+remote code.
 
 The bundled `examples/e1m1_prompt.txt` is the executable prompt. Run
 `infer.py` (at the bundle root) to produce canonical emitted row ids and raw
@@ -18,15 +19,40 @@ The protocol is specified in `PROTOCOL.md` in the source repo. Neither
 post-processing tool participates in inference or performs geometry,
 visibility, lighting, texture selection, or sorting.
 
+Ordinary Transformers pipeline inference works directly, with no custom or
+remote model code:
+
+```python
+from pathlib import Path
+from huggingface_hub import hf_hub_download
+from transformers import pipeline
+
+repo = "physicsrob/torchwright-doom-e1m1"
+prompt = Path(hf_hub_download(repo, "examples/e1m1_prompt.txt")).read_text()
+generate = pipeline("text-generation", model=repo, device_map="auto")
+generated_text = generate(prompt, return_full_text=False)[0]["generated_text"]
+```
+
+The saved generation defaults are greedy and cover the complete frame. Use
+the shipped `infer.py` when canonical integer row IDs, progress reporting, and
+the exact terminal-token-preserving raw text are required.
+
+Published checkpoints: [320×200](https://huggingface.co/physicsrob/torchwright-doom-e1m1)
+and [80×50](https://huggingface.co/physicsrob/torchwright-doom-e1m1-80x50).
+The compiler-facing source is
+[torchwright_doom](https://github.com/physicsrob/torchwright_doom).
+
 **This bundle:** screen 320×200, map
 E1M1, dense fp32 sharded safetensors, eager attention (the validated
 implementation), greedy decode, generation bound
 61440 new tokens.
 
-**What running it takes:** the weights load in full fp32 (total size = the
-sum of the shards; the flagship 320×200 bundle is ~98 GB, needing an
-H200/B200-class GPU or multi-GPU `device_map`). The flagship render measured
-~42 minutes of greedy decode on one B200 for its 53,747-token rollout from a
-3,614-token prompt, scoring ~99.99% within-option color against the
-reference renderer. Canonical numbers and their provenance: `FACTS.md` in
-the source repo (github.com/physicsrob/torchwright_doom).
+**What running it takes:** the fp32 weight shards total
+79.97 GiB (85.87 GB), needing a B200-class GPU
+or multi-GPU `device_map`. The flagship pipeline render peaked at 151.00 GiB
+reserved; greedy decode took 39.7 minutes on one B200 for its 53,747-token rollout
+from a 3,614-token prompt, scoring 99.9% within-option color against the
+reference renderer.
+
+Canonical numbers and their provenance: `FACTS.md` in the source repo
+(github.com/physicsrob/torchwright_doom).

config.json

@@ -3,6 +3,7 @@
     "Phi3ForCausalLM"
   ],
   "attention_dropout": 0.0,
+  "attn_implementation": "eager",
   "bos_token_id": 133096,
   "doom_screen_config": {
     "detail": "low",
@@ -34,6 +35,12 @@
     "rope_type": "default"
   },
   "sliding_window": null,
+  "task_specific_params": {
+    "text-generation": {
+      "do_sample": false,
+      "max_new_tokens": 61440
+    }
+  },
   "tie_word_embeddings": true,
   "transformers_version": "5.13.1",
   "use_cache": true,

doom_bundle_manifest.json

@@ -2,22 +2,23 @@
   "architecture": "Phi3ForCausalLM",
   "artifact_kind": "hf_phi3_bundle",
   "bos_token_id": 133096,
-  "bundle_identity": "torchwright_doom.phi3.v1:bfd028379c63520b4e2aa3919fbdeb76c1b598580d425e65059f07dfcd4a33f7",
+  "bundle_identity": "torchwright_doom.phi3.v1:aee65882d6900d333fe2c91cc1790f861de4415a18b15a1438749b39a0a925f1",
   "compile": {
     "n_layers": 38,
-    "solver_seed": 0
+    "solver_seed": 0,
+    "solver_workers": 64
   },
-  "compile_payload_sha256": "bfd028379c63520b4e2aa3919fbdeb76c1b598580d425e65059f07dfcd4a33f7",
+  "compile_payload_sha256": "aee65882d6900d333fe2c91cc1790f861de4415a18b15a1438749b39a0a925f1",
   "dtype": "float32",
   "eos_token_id": 133029,
   "files": {
     "README.md": {
-      "sha256": "b96069316230d13ed86b2e5829a6d180b45ef331f98e3f0efc4a532bbfd23b5a",
-      "size": 1562
+      "sha256": "5ce39ee763e70552dfde8dff45ae5b332e0564490b5d5b9b476e1de3052e69e7",
+      "size": 2511
     },
     "config.json": {
-      "sha256": "12cc69eb384a668beb1b65a62a7d32d62f0ae939fae247b1a9ecf548d16b2308",
-      "size": 1012
+      "sha256": "ff7b2b5221b2da242ab5ac08efea64ad3d63f9e9c1ae933a5d6affae0938507a",
+      "size": 1166
     },
     "doom_palette.json": {
       "sha256": "e6a86012014e059fa3dcd22ee185a23d5eac6976fbc59debbdded09fd885f287",
@@ -36,12 +37,12 @@
       "size": 53014
     },
     "generation_config.json": {
-      "sha256": "4d66e6be7ef4f8ba1237fe25d3973066f9f44e400c1eae69cc8ba1e0a5714084",
-      "size": 117
+      "sha256": "1b438a69a303eb106671ecb93df9bf4007a5af7ff3115245f2aad2095cb61a2d",
+      "size": 166
     },
     "infer.py": {
-      "sha256": "1ddc270d57e9d4a66731c556b27d2de7260ee2cd9f300e4fb1299f0528a63a08",
-      "size": 10564
+      "sha256": "a99be58f8d1596e6e2584d926896ee5f0d42951e7d3705b6f7a6fa7788b9f145",
+      "size": 12361
     },
     "model-00001-of-00039.safetensors": {
       "size": 2144928208
@@ -256,7 +257,7 @@
   },
   "source_revisions": {
     "torchwright": "b431c4a5a2d39cab0b47033f1c0a89e3ee5cca31",
-    "torchwright_doom": "49feb52d455f1223d402fa585249ff24b6055c74"
+    "torchwright_doom": "6c18b01969ceb8e96d003663b63f37d5fe39573b"
   },
   "tokenizer_vocab_sha256": "c51d61c03f3496e793b52790e77b670b801255d59da80df5abb6ef7c3a1e212e",
   "validation": {

generation_config.json

@@ -1,6 +1,8 @@
 {
   "bos_token_id": 133096,
+  "do_sample": false,
   "eos_token_id": 133029,
+  "max_new_tokens": 61440,
   "pad_token_id": 133029,
   "transformers_version": "5.13.1"
 }

infer.py

@@ -31,7 +31,7 @@ os.environ.setdefault("HF_PARALLEL_LOADING_WORKERS", "8")
 
 import torch
 import transformers
-from transformers import AutoModelForCausalLM, AutoTokenizer
+from transformers import TextGenerationPipeline, pipeline
 
 _PROGRESS_INTERVAL_SECONDS = 15.0
 
@@ -44,6 +44,13 @@ def _sha(data: bytes) -> str:
     return hashlib.sha256(data).hexdigest()
 
 
+def _cuda_devices(model) -> list[torch.device]:
+    return sorted(
+        {parameter.device for parameter in model.parameters() if parameter.is_cuda},
+        key=str,
+    )
+
+
 class _ProgressStreamer:
     """Report generation throughput without changing or collecting tokens."""
 
@@ -118,23 +125,43 @@ def main(argv: list[str] | None = None) -> int:
     bundled_prompt = prompt_sha256 == manifest["prompt"]["sha256"]
 
     load_t0 = time.monotonic()
-    tokenizer = AutoTokenizer.from_pretrained(model_dir)
-    load_kwargs = {}
+    model_kwargs = {
+        "attn_implementation": "eager",
+        # Read each shard's bytes eagerly: deferring them to mmap page faults
+        # stalls badly on network filesystems, and eager reads are harmless on
+        # local disks.
+        "disable_mmap": True,
+    }
+    generate: TextGenerationPipeline
     if args.device != "cpu":
         # Accelerate builds the skeleton on meta and dispatches each shard
         # directly to the target device.  This avoids a second full-model
         # ``model.to(cuda)`` pass through CPU-backed mmap pages.
-        load_kwargs["device_map"] = args.device
-    model = AutoModelForCausalLM.from_pretrained(
-        model_dir,
-        attn_implementation="eager",
-        dtype=torch.float32,
-        # Read each shard's bytes eagerly: deferring them to mmap page
-        # faults stalls badly on network filesystems, and eager reads are
-        # harmless on local disks.
-        disable_mmap=True,
-        **load_kwargs,
-    ).eval()
+        generate = pipeline(
+            "text-generation",
+            model=str(model_dir),
+            dtype=torch.float32,
+            model_kwargs=model_kwargs,
+            device_map=args.device,
+        )
+    else:
+        generate = pipeline(
+            "text-generation",
+            model=str(model_dir),
+            dtype=torch.float32,
+            model_kwargs=model_kwargs,
+        )
+    tokenizer = generate.tokenizer
+    if tokenizer is None:
+        raise RuntimeError("text-generation pipeline loaded without a tokenizer")
+    model = generate.model
+    model.eval()
+    cuda_devices = _cuda_devices(model)
+    for cuda_device in cuda_devices:
+        # Reset after loading: the current allocation still includes all
+        # weights, while the peak will additionally capture generation cache
+        # and runtime workspace. This is the consumer-fit measurement.
+        torch.cuda.reset_peak_memory_stats(cuda_device)
     attention_implementation = getattr(model.config, "_attn_implementation", None)
     if attention_implementation != "eager":
         # Eager is the implementation the published render was validated
@@ -154,14 +181,14 @@ def main(argv: list[str] | None = None) -> int:
         )
     load_seconds = time.monotonic() - load_t0
 
-    inputs = tokenizer(
-        prompt_bytes.decode("utf-8"),
+    prompt_text = prompt_bytes.decode("utf-8")
+    encoded_prompt = tokenizer(
+        prompt_text,
         return_tensors="pt",
         add_special_tokens=False,
     )
     input_device = next(model.parameters()).device
-    inputs = inputs.to(input_device)
-    prompt_ids = [int(row) for row in inputs.input_ids[0].tolist()]
+    prompt_ids = [int(row) for row in encoded_prompt.input_ids[0].tolist()]
     prompt_ids_sha256 = _sha(_canonical_json(prompt_ids))
     # Only the bundled prompt has a manifest row-id expectation; a custom
     # prompt is permitted, never verified, and recorded in the payload as
@@ -185,8 +212,10 @@ def main(argv: list[str] | None = None) -> int:
     progress = _ProgressStreamer(len(prompt_ids), max_new)
     print(f"[infer] generation started; max_new_tokens={max_new}", flush=True)
     with torch.inference_mode():
-        sequences = model.generate(
-            **inputs,
+        records = generate(
+            prompt_text,
+            add_special_tokens=False,
+            return_tensors=True,
             do_sample=False,
             use_cache=True,
             max_new_tokens=max_new,
@@ -195,7 +224,18 @@ def main(argv: list[str] | None = None) -> int:
             streamer=progress,
         )
     generate_seconds = time.monotonic() - generate_t0
-    generated = [int(row) for row in sequences[0, inputs.input_ids.shape[1] :].tolist()]
+    sequence = records[0]["generated_token_ids"]
+    generated = [int(row) for row in sequence[len(prompt_ids) :]]
+    for cuda_device in cuda_devices:
+        torch.cuda.synchronize(cuda_device)
+    cuda_memory = [
+        {
+            "device": str(cuda_device),
+            "peak_allocated_bytes": torch.cuda.max_memory_allocated(cuda_device),
+            "peak_reserved_bytes": torch.cuda.max_memory_reserved(cuda_device),
+        }
+        for cuda_device in cuda_devices
+    ]
     prefill_seconds = progress.prefill_seconds or generate_seconds
     decode_seconds = progress.decode_seconds
     raw_text = tokenizer.decode(
@@ -223,7 +263,7 @@ def main(argv: list[str] | None = None) -> int:
         "emitted_row_ids": generated,
         "emitted_row_ids_sha256": emitted_ids_sha256,
         "generation": {
-            "mode": "transformers_generate",
+            "mode": "transformers_pipeline",
             "max_new_tokens": max_new,
             "termination_reason": "terminal" if stopped else "cap",
         },
@@ -234,6 +274,7 @@ def main(argv: list[str] | None = None) -> int:
             "generate": generate_seconds,
         },
         "attention_implementation": attention_implementation,
+        "cuda_memory": cuda_memory,
         "transformers_version": transformers.__version__,
     }
     (args.output / "output.ids.json").write_text(
@@ -245,6 +286,15 @@ def main(argv: list[str] | None = None) -> int:
         f"stopped={payload['generation']['termination_reason']}",
         flush=True,
     )
+    for memory in cuda_memory:
+        peak_allocated = int(memory["peak_allocated_bytes"])
+        peak_reserved = int(memory["peak_reserved_bytes"])
+        print(
+            f"[infer] {memory['device']} peak allocated="
+            f"{peak_allocated / 1024**3:.2f} GiB "
+            f"reserved={peak_reserved / 1024**3:.2f} GiB",
+            flush=True,
+        )
     return 0