See us on the Leaderboard ⇗

Blog post read it here ⇗

PixelModel v1 🖼️

A neural network where the weights are the image. Now the model is a thumbnail.

📌 What is this?

model.png is not a picture — it is the model.

Every pixel encodes neural network weights. At inference, the PNG is decoded into weight matrices, the prompt is hashed into an embedding, and a coordinate-conditioned decoder paints an image — at any resolution.

v0 was a 202,752-parameter MLP welded to 32×32 output, trained on 6 color swatches. v1 is 8.5× smaller (23,747 parameters), renders at any resolution (native 64×64), and is trained on ~20K real MS-COCO caption/image pairs.

cherry on top 🍒

The model generates 600 images (cpu) in 5 (five) seconds. Thats 5000 images in 24 seconds on cpu. The model trained on cpu for just 30 minutes.

🆕 v0 → v1

	v0	v1
Parameters	202,752	23,747
`model.png`	64×3200 px	160×149 px (a thumbnail)
Output head	1 weight row per pixel (196K params, 97% of model)	CPPN decoder on (x, y) — resolution-free
Resolution	fixed 32×32	any; native 64×64
Prompt embedding	char-sum (order-blind, collision-heavy)	hashed trigrams + words (FNV-1a), still 0 params
Biases	none	yes
Weight precision	8-bit (G channel wasted)	16-bit (R=high byte, G=low byte)
Training data	6 solid-color swatches	~20K MS-COCO caption/image pairs

Training loss curve crossing below both naive-predictor baselines

🎨 Weight Encoding

Each pixel stores one weight at 16-bit precision, mapped from [-2, 2]:

R channel → high byte
G channel → low byte
B channel → reserved

Round-trip quantization error ≈ 3×10⁻⁵ per weight.

🧠 Architecture

prompt string
  → hashed char-trigram + word embedding (64-dim, deterministic, 0 params)
  → T1 (80×64)+b → tanh
  → T2 (64×80)+b → tanh          = latent z (64)

for every pixel (x, y):
  concat(z, fourier features of (x, y))   ← 18 coord dims, freqs 1/2/4/8
  → D1 (80×82)+b → tanh
  → D2 (80×80)+b → tanh
  → D3 (3×80)+b  → sigmoid  = RGB

Because pixels are decoded from coordinates, parameter count is independent of resolution — --res 256 works with the same 23,747 weights.

All weights live inside model.png (160×149 px).

📦 Standard weights (safetensors)

model.png is the canonical model — training writes to it directly. For tooling that expects standard weight files, the same 10 tensors are exported as model.safetensors (23,747 parameters total):

python convert_to_safetensors.py            # model.png -> model.safetensors

Parameter count is verifiable without running code: config.json (total_parameters: 23747, full per-layer breakdown) and the safetensors header metadata (total_parameters, param_breakdown, has_bias, text_encoder_parameters: 0, vae_parameters: 0).

📊 Benchmark results

Measured per the Tiny-T2I-Leaderboard protocol — see eval.md for full method and EVAL_REPRODUCTION.md to re-run:

Metric	v0	v1	Tooling
FID ↓	566.84 (n=40)	439.46 (n=5000)	`torchmetrics.image.fid.FrechetInceptionDistance`
CLIP Score ↑	18.60 (n=40)	20.02 (n=5000)	`torchmetrics.multimodal.CLIPScore`, `openai/clip-vit-base-patch32`
Native resolution	32×32	64×64

Real set: MS-COCO val2014 pairs from sayakpaul/coco-30-val-2014 (256×256 center-crop). Training images are hash-checked to be disjoint from the eval images.

Expectation management: a 23K-parameter model does not draw recognizable objects. It learns caption-conditioned color, layout, and texture statistics of COCO photos — the outputs are blurry impressions, not pictures. The point is the size:quality ratio and the PNG-as-model gimmick, executed honestly.

Target photos vs model outputs: the model produces caption-conditioned color washes

⚙️ Usage

# training data (COCO subset)
python fetch_coco_subset.py --out ../pm-work

# train (writes model.png every epoch)
python train.py --data ../pm-work/coco_train.npz --epochs 50

# inference from model.png (canonical)
python main.py "a red double decker bus" --out bus.png

# inference from model.safetensors (standalone, needs only this one file + torch)
python convert_to_safetensors.py
python INFERENCE.py "a red double decker bus" --out bus.png

# any resolution from the same 23,747 weights
python main.py "a beach with palm trees" --res 256 --scale 1

# benchmark eval
python eval/run_eval.py --work ../pm-work --model model.png --n 5000

main.py and INFERENCE.py produce identical output for the same prompt and resolution.

📁 Files

model.png                   ← THE MODEL (160×149 px)
model.safetensors           ← same weights, standard format + param metadata
config.json                 ← architecture + parameter-count metadata
main.py                     ← inference, loads model.png
INFERENCE.py                ← inference, loads model.safetensors (standalone)
convert_to_safetensors.py   ← model.png -> model.safetensors
train.py                    ← training
model.py                    ← architecture + PNG weight codec
fetch_coco_subset.py        ← builds train/eval data from COCO
eval/run_eval.py            ← FID + CLIP Score via torchmetrics
eval.md                     ← benchmark results + method
EVAL_REPRODUCTION.md        ← step-by-step reproduction guide

Still a toy. Slightly less useless. The model is literally a thumbnail.

Bench Labs · Simple, Reliable, Open sourced