MNIST at 99% accuracy in a 256 KB model

Download the submitted JSON model and check its byte size is at most 262144. Reimplement (or reuse a reference implementation of) the five fixed layer types exactly as specified (conv, maxpool, avgpool, flatten, dense, with the stated padding and int8/scale dequantization rules), and total the MACs layer by layer to confirm the running sum never exceeds 3,000,000. Then run the model over the platform's own held-out t10k images and labels at /data/mnist-t10k-images-idx3-ubyte and /data/mnist-t10k-labels-idx1-ubyte, not any training or validation split the submitter may have used, and compute accuracy = correct predictions / 10000 independently:
      model = load_and_validate_shapes(json_path)
      correct = 0
      for img, label in zip(load_idx_images(...), load_idx_labels(...)):
        pred = argmax(run_layers(model, img))
        correct += (pred == label)
      accuracy = 100 * correct / 10000
    Compare this independently computed accuracy to the submitted score; they should match to the stated rounding. A dishonest or broken submission typically reports an accuracy number measured on its own training-time validation split instead of the platform's t10k set, or ships weight/scale/bias arrays whose lengths do not actually match the declared layer shapes, silently truncated or padded by a lenient loader.

Background. MNIST is the classic 28x28 grayscale handwritten-digit dataset (10 classes, digits 0-9). It has been solved to well above 99% accuracy for decades (LeCun's original LeNet-5 in 1998 got ~99.2% with about 60,000 parameters), but that is with unrestricted model size and unrestricted compute. This mission adds two hard limits: the entire model must serialize to 262,144 bytes (256 KiB) or fewer, and inference must use at most 3,000,000 multiply-accumulate operations (MACs) per image. The verifier does not execute your code; it interprets a fixed, sequential JSON layer format directly. Getting the layout exactly right matters more than being clever.

Artifact format. Submit a single JSON file (<= 262144 bytes total). Top level:
{"layers": [ ... ]}
Layers are applied in array order. The input to the first layer is always a 28x28x1 float32 tensor (image, layout [H=28][W=28][C=1]), with each pixel equal to raw_pixel_value / 255, i.e. in [0,1]. Five layer types exist:

- conv: {"type":"conv","k":3|5,"stride":1|2,"pad":"same"|"valid","in":Cin,"out":Cout,"w":"<base64 int8, layout [Cout][k][k][Cin]>","scale":<float, or an array of Cout floats>,"b":[Cout floats],"act":"relu"|"none"}
  Real weight value = int8_value * scale (scale is either one number applied to the whole tensor, or one number per output channel for finer per-channel quantization). "pad":"same" follows the usual convention: output size = ceil(input/stride), with zero padding split as evenly as possible (extra padding on the bottom/right when odd). "pad":"valid" uses no padding: output size = floor((input-k)/stride)+1, and input must be at least k on each side.
- maxpool: {"type":"maxpool","k":<int>}  (non-overlapping, stride = k, output size = floor(input/k) on each axis)
- avgpool: {"type":"avgpool","k":<int>}  (same windowing as maxpool, but averages)
- flatten: {"type":"flatten"}  (reshapes the current H x W x C tensor into a length H*W*C vector, iterating H outer, W middle, C inner -- i.e. index = (h*W + w)*C + c. Required before any dense layer.)
- dense: {"type":"dense","in":N,"out":M,"w":"<base64 int8, layout [M][N]>","scale":<float, or an array of M floats>,"b":[M floats],"act":"relu"|"none"}

"w" may also be a plain JSON array of numbers instead of a base64 string, in which case those values are used directly (still multiplied by "scale", which defaults to 1 if omitted). This is sometimes convenient for debugging but usually wastes your byte budget compared to base64-encoded int8. "act" defaults to "none" if omitted. The very last layer in the pipeline must produce exactly 10 output values; the predicted digit is argmax over those 10 values.

Tiny example (a bare linear classifier, for format illustration only, expect roughly 85-92% accuracy from this alone):
{
  "layers": [
    {"type": "flatten"},
    {"type": "dense", "in": 784, "out": 10, "w": "<base64 of 7840 int8 values>", "scale": 0.05, "b": [0,0,0,0,0,0,0,0,0,0], "act": "none"}
  ]
}

Validity and scoring. A submission is valid iff: the JSON parses; every layer's shape matches the tensor coming out of the previous layer (first layer sees 28x28x1); every "w"/"scale"/"b" array has exactly the length its layer's shape implies; the running total of MACs across all layers (conv MACs = outH*outW*Cout*k*k*Cin per layer, dense MACs = in*out per layer, pooling and flatten cost nothing) never exceeds 3,000,000; the final layer produces exactly 10 values; and inference completes for all 10,000 test images. Score = accuracy in percent on the canonical MNIST t10k test set, rounded to 2 decimal places. Direction is max. Target (mission "solved"): 99.00%. Record: 99.50%. Reaching the record tier inside a 3,000,000 MAC budget is genuinely hard: it usually needs either a carefully tuned small CNN, aggressive but accuracy-preserving int8 quantization (per-channel scales help a lot versus a single global scale), or techniques like knowledge distillation from a bigger teacher model.

Data. The canonical MNIST test set is served pre-processed as raw IDX files at /data/mnist-t10k-images-idx3-ubyte and /data/mnist-t10k-labels-idx1-ubyte (10,000 images, 28x28, standard IDX format, already gunzipped -- this is exactly Yann LeCun's t10k split). The platform does NOT provide the 60,000-image training set. Download it yourself from a standard mirror, e.g. https://storage.googleapis.com/cvdf-datasets/mnist/ or https://ossci-datasets.s3.amazonaws.com/mnist/ (same filenames as the original: train-images-idx3-ubyte.gz, train-labels-idx1-ubyte.gz), or simply use torchvision.datasets.MNIST(download=True) / keras.datasets.mnist.load_data(), which fetch it automatically. Whatever you train on, you are scored only on the held-out t10k set described above, so do not train on it.

Export recipe. Train with any framework (PyTorch, TensorFlow, NumPy, JAX...) using a small CNN: a couple of 3x3 or 5x5 conv layers with modest channel counts, a pool or stride-2 downsample, then a small dense head to 10 classes works well and comfortably fits both budgets (a LeNet-5-shaped network is around 60k parameters, and 256 KB of int8 weights gives you room for roughly 250,000 int8 values, i.e. plenty of headroom if you quantize instead of shipping float32). After training: (1) quantize each weight tensor to int8, typically per-output-channel symmetric quantization (scale_c = max(abs(weights_in_channel_c)) / 127, int8 = round(weight / scale_c)); (2) pack each tensor into the [Cout][k][k][Cin] or [M][N] byte layout described above; (3) base64-encode the bytes; (4) write the JSON, keeping biases as plain float arrays; (5) locally re-run your own reference implementation of the exact same layer semantics against a few images to sanity-check before submitting, and check your file's byte size against 262144 and your MAC total against 3,000,000 by hand.

Common pitfalls: forgetting that "same" padding must match the verifier's convention (ceil-size output, padding split with any odd remainder going after, not before); mixing up the weight layout order (it is [Cout][k][k][Cin] / [M][N], not transposed); shipping float32 weights inside a base64 blob meant for int8 (byte length will not match, causing an immediate parse-time rejection); forgetting a "flatten" layer between spatial and dense layers; and quietly exceeding the MAC budget by stacking too many wide conv layers before your first downsample (pooling and stride-2 convs are your friends for staying inside budget while covering more channels near the end of the network).