Add safetensors weights and standalone INFERENCE.py

Exports the same 3 weight matrices already encoded in model.png to
model.safetensors via convert_to_safetensors.py, and adds INFERENCE.py
as a standalone entry point that loads from the safetensors file
instead of the PNG. Verified byte-identical output between main.py
and INFERENCE.py for the same prompt. README documents both paths.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

INFERENCE.py

@@ -0,0 +1,77 @@
+"""
+INFERENCE.py — run PixelModel from its model.safetensors weights.
+
+This is the standalone entry point for anyone who just wants to load the
+safetensors weights and generate an image, without needing model.png or
+the rest of this repo's training code.
+
+Usage:
+  python INFERENCE.py "a red circle"
+  python INFERENCE.py "a red circle" --model model.safetensors --out out.png --scale 8
+"""
+
+import argparse
+import os
+import sys
+
+import numpy as np
+import torch
+from PIL import Image
+from safetensors.torch import load_file
+
+PROMPT_DIM = 32
+OUT_SIZE = 32
+
+
+def prompt_to_embedding(prompt: str) -> torch.Tensor:
+    """Deterministic char-level embedding -> PROMPT_DIM vector."""
+    vec = torch.zeros(PROMPT_DIM)
+    for i, ch in enumerate(prompt.lower()):
+        idx = i % PROMPT_DIM
+        vec[idx] += ord(ch) / 127.0
+    norm = vec.norm()
+    if norm > 0:
+        vec = vec / norm
+    return vec
+
+
+def forward(weights: dict, prompt: str) -> torch.Tensor:
+    emb = prompt_to_embedding(prompt)
+    x = torch.tanh(weights["W1"] @ emb)
+    x = torch.tanh(weights["W2"] @ x)
+    x = torch.sigmoid(weights["W3"] @ x)
+    return x.reshape(OUT_SIZE, OUT_SIZE, 3)
+
+
+def generate(prompt: str, model_path: str, out_path: str, scale: int = 8):
+    if not os.path.exists(model_path):
+        sys.exit(
+            f"Model not found: {model_path}\n"
+            f"Run: python convert_to_safetensors.py   to create one from model.png first."
+        )
+
+    weights = load_file(model_path)
+
+    with torch.no_grad():
+        result = forward(weights, prompt)
+
+    arr = (result.numpy() * 255).clip(0, 255).astype(np.uint8)
+    img = Image.fromarray(arr, mode="RGB")
+
+    if scale > 1:
+        img = img.resize((OUT_SIZE * scale, OUT_SIZE * scale), Image.NEAREST)
+
+    img.save(out_path)
+    print(f"prompt : '{prompt}'")
+    print(f"model  : {model_path}  ({os.path.getsize(model_path)} bytes, safetensors)")
+    print(f"output : {out_path}  ({OUT_SIZE * scale}x{OUT_SIZE * scale} px)")
+
+
+if __name__ == "__main__":
+    p = argparse.ArgumentParser(description="PixelModel inference (safetensors)")
+    p.add_argument("prompt", help="Text prompt")
+    p.add_argument("--model", default="model.safetensors", help="Path to safetensors weights")
+    p.add_argument("--out", default="out.png", help="Output image path")
+    p.add_argument("--scale", type=int, default=8, help="Upscale factor for output (default 8 -> 256x256)")
+    args = p.parse_args()
+    generate(args.prompt, args.model, args.out, args.scale)

README.md

@@ -40,6 +40,19 @@ All weights live inside `model.png`.
 
 ---
 
+## 📦 Standard weights (safetensors)
+
+`model.png` is the canonical model — training writes to it directly, and it's what makes PixelModel PixelModel. For tooling that expects standard weight files, the same 3 matrices are also exported as `model.safetensors` (202,752 parameters total, no bias terms):
+
+```bash
+python convert_to_safetensors.py            # model.png -> model.safetensors
+python convert_to_safetensors.py --model model.png --out model.safetensors
+```
+
+Re-run this after training if you retrain into a new `model.png` — `model.safetensors` doesn't update itself.
+
+---
+
 ## 🧪 Dataset vs Outputs
 
 | Target                                     | Output                                 |
@@ -56,10 +69,13 @@ All weights live inside `model.png`.
 ## 📁 Files
 
 ```text
-model.png       ← THE MODEL (64×3200 px)
-main.py         ← inference
-train.py        ← training
-model.py        ← architecture
+model.png                   ← THE MODEL (64×3200 px)
+model.safetensors           ← same weights, standard format (generated, see below)
+main.py                     ← inference, loads model.png
+INFERENCE.py                ← inference, loads model.safetensors
+convert_to_safetensors.py   ← model.png -> model.safetensors
+train.py                    ← training
+model.py                    ← architecture
 dataset/
   red.png
   red.txt       ← prompt: "red"
@@ -76,8 +92,14 @@ python train.py --epochs 500 --lr 0.05
 
 python main.py "red"
 python main.py "a cat" --out cat.png --scale 8
+
+# equivalent, but loads model.safetensors instead of model.png
+python convert_to_safetensors.py
+python INFERENCE.py "a cat" --out cat.png --scale 8
 ```
 
+`main.py` and `INFERENCE.py` produce byte-identical output for the same prompt — they're the same architecture and weights, just loaded from different files.
+
 ---
 
 ## 📊 Tips

convert_to_safetensors.py

@@ -0,0 +1,47 @@
+"""
+convert_to_safetensors.py — extract PixelModel's weights from model.png
+and save them as model.safetensors.
+
+model.png remains the canonical "weights ARE the image" artifact (see
+README.md); this just re-exports its contents in a standard, directly
+loadable format for tooling that expects .safetensors weights.
+
+Usage:
+  python convert_to_safetensors.py
+  python convert_to_safetensors.py --model model.png --out model.safetensors
+"""
+
+import argparse
+from safetensors.torch import save_file
+
+from model import load_model, pixels_to_weights
+
+
+def convert(model_path: str, out_path: str):
+    pixels = load_model(model_path)
+    W1, W2, W3 = pixels_to_weights(pixels)
+
+    save_file(
+        {
+            "W1": W1.contiguous(),
+            "W2": W2.contiguous(),
+            "W3": W3.contiguous(),
+        },
+        out_path,
+        metadata={
+            "format": "pt",
+            "source": model_path,
+            "architecture": "PixelModel 3-layer MLP (char-embed -> tanh -> tanh -> sigmoid)",
+        },
+    )
+
+    total = W1.numel() + W2.numel() + W3.numel()
+    print(f"Wrote {out_path}  ({total:,} parameters: W1={tuple(W1.shape)}, W2={tuple(W2.shape)}, W3={tuple(W3.shape)})")
+
+
+if __name__ == "__main__":
+    p = argparse.ArgumentParser(description="Export PixelModel weights (from model.png) to safetensors")
+    p.add_argument("--model", default="model.png", help="Path to source model PNG")
+    p.add_argument("--out", default="model.safetensors", help="Output safetensors path")
+    args = p.parse_args()
+    convert(args.model, args.out)

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8c365a7f71955241d343da88796e7c221f88b040e93006e9f1a46ecf5b36f10a
+size 811344