No pretrained weights. No parameter to spare. Almost everything else is allowed.
The challenge
Score the highest top-1 accuracy on the ImageNet-1k (ILSVRC-2012) validation set using a model whose learned state fits in 40,000 bytes — 10,000 fp32 parameters, which is where the name comes from. Top-5 accuracy is reported alongside it; both are defined exactly under Scoring.
The motivation
Modern vision models solve ImageNet with millions to billions of weights trained on millions to billions of images. Humans get there on far less. A child has been awake for only about 3,100 hours by 11 months of age (Jayaraman, Fausey and Smith, PLoS ONE, 2015), and none of what they see arrives with a label. Yet children of four to six already recognize distorted objects more accurately than ImageNet-trained networks do, relying on shape where the networks rely on texture (Huber, Geirhos and Wichmann, Journal of Vision, 2023). Models trained on 200 hours of head-camera video from a single child reach roughly 70% of the performance of a model trained on all of ImageNet (Orhan and Lake, Nature Machine Intelligence, 2024). Whatever is going on there, it is not brute scale.
This contest asks how far we can get on this task when free parameters are strictly limited but computation and algorithmic structure are not. The goal is to push research on inductive bias, computation, and domain knowledge expressed as algorithms, instead of scale.
To help calibrate how tight the budget is: a plain linear classifier over just 10 features already costs \(1{,}000 \text{ classes} \times 10 = 10{,}000\) parameters, the entire budget. Fitting 1,000 classes at all forces compact class representations. That squeeze is part of the challenge.
The one rule
You get 40,000 bytes of learned state, total. Everything you fit to data lives in that budget, at every stage of your pipeline, inference included.
That is 10,000 fp32 parameters, which is where the name comes from, but the budget is space, not count. Use fp32, int8, a packed bitfield, or a representation nobody has named yet; what matters is that the serialized state your inference code reads back is at most 40,000 bytes. If you can compress it to fit, it fits: 40,000 bytes of information is 40,000 bytes of information however you encode it.
The contest takes no position on what to call the things in that budget. Weights, biases, running statistics, thresholds, codebooks, class prototypes, selected structure: if it was chosen by fitting rather than derived by your code, it occupies bytes. Stating the rule as space rather than as a count of parameters means it still applies to methods nobody has invented yet.
Legal
Any fitting method, applied directly to your 40,000 bytes, on the official ImageNet-1k training split. Gradient descent, evolutionary search, closed-form solutions, random search, something nobody has named yet: the contest takes no position on how you get there
Analytic or closed-form weights: if you can derive it, you can use it
Procedurally generated structure: Gabor banks, scattering transforms, wavelets, any fixed feature computed by your code
Priors expressed as programs: the WordNet hierarchy, image-formation physics, hand-designed architectures, formula-driven supervised learning, and so on
Compact class codes: error-correcting output codes, hierarchical classifiers, shared prototypes
Heavy computation at training time, and source code of any length
Computation of any kind at test time, including optimization over activations or latents, so long as anything you fit there fits inside the budget and your submitted state is left untouched. Inference is per-image, so it sees only the image being scored
LLMs helping you write and search for code (this is encouraged)
Banned
Fitting more than 40,000 bytes of state, at any stage, even on the official data
Distilling, pruning, or fine-tuning a larger trained network down into the budget
Weights from an existing network, yours or anyone else's, pretrained or otherwise
Learned embeddings, statistics, or lookup tables derived from other data
Training on any data other than the official ImageNet-1k training split or data your own code generates procedurally
Fitting anything at test time that does not fit in the 40,000 bytes, or changing your submitted state while the model runs
Transductive inference: carrying state from one validation image to the next, or exploiting the fact that the validation set holds exactly 50 images per class
Network or training-set access at inference time
The distinction is how a number came to exist. Derive it with a program, or fit it directly, and it is legal. Route it through a larger model first and it is not. Compressing a big trained network into a small one is a solved genre and it is not what this contest is asking. Synthetic images your own code generates are fair game to train on, formula-driven supervised learning included, because your program derives them; the 40,000-byte ceiling still applies to whatever you train on them.
An LLM may hand you ideas and code. It may not hand you weights from existing trained models.
Submissions
Format. Self-contained source code of any length, with no network access and no external files. Write as much code as the idea needs. Numbers hardcoded into your source count against your 40,000 bytes unless your code derives them (that is, weights generated algorithmically, without training on images). Code length is unlimited, so this boundary is what verification actually checks: anything fit to data lives in the budget, and your source holds only what you derived or wrote by hand.
We run it. Your code trains from scratch on the official training split, then evaluates. The finished model’s learned state must be at most 40,000 bytes, and it runs inference with no access to the training data.
Verification. We run your pipeline end to end and check that no more than 40,000 bytes of state is ever fit along the way, measuring the serialized state your inference code reads back. Nobody audits how you searched for the idea. Winning entries receive human code review; an opaque numeric table is presumed to be imported weights unless you can show the code that derives it.
Compute. No cap on training compute, but winners must make their result reproducible by the organizers, with entrant-sponsored compute if the run is very large. Inference compute is reported on the leaderboard, not capped.
Scoring
Entries are ranked by top-1 accuracy on the ImageNet-1k validation set. Top-5 accuracy is reported alongside it and is the tie-breaker.
For each validation image your model must emit a ranked list of five distinct class labels, best guess first. Write the set of validation images as \((x_1, y_1), \ldots, (x_N, y_N)\) with \(N = 50{,}000\) and each true label \(y_i \in \{1, \ldots, 1000\}\). Let \(\hat{Y}_i^{(k)}\) be the first \(k\) labels of your ranked list for image \(i\). Then:
\(N = 50{,}000\) validation images\(y_i\) = ground-truth label of image \(i\)\(\hat{Y}_i^{(k)}\) = your top \(k\) labels for image \(i\)\(\mathbf{1}[\cdot]\) = 1 if the condition holds, else 0
Top-1 accuracy is \(\mathrm{acc@}1\), which counts an image correct only when your first guess is the true label. Top-5 accuracy is \(\mathrm{acc@}5\), which counts it correct when the true label appears anywhere in your five. Both are reported as percentages to two decimals. If you prefer the ILSVRC convention, the error rate is \(100\% - \mathrm{acc@}k\). By construction \(\mathrm{acc@}1 \le \mathrm{acc@}5\).
Every image counts. There is no abstain option and no partial credit. Emit fewer than five labels and the missing slots simply cannot match; emit a duplicate and it wastes a slot.
Ties in your own scores are broken by ascending class index, applied by the scoring harness, so the ranking is always well defined and never depends on floating-point luck.
Macro equals micro. The validation set holds exactly 50 images per class, so per-image accuracy and per-class mean accuracy are the same number. No reweighting is applied.
Preprocessing and test-time augmentation are yours. Your code receives the original image file and may resize, crop, or average over many views as it likes; inference compute is reported, not capped. Predictions must be deterministic given the submitted code, so seed anything stochastic.
Inference is per-image. Each validation image is scored on its own, with no state carried from one image to the next, and your ranked list for an image must be identical whether it is scored alone or alongside the other 49,999. The many views in the bullet above are views of that one image. Transductive entries are therefore out of reach: you may not cluster the validation set, and the exactly-50-per-class balance is a property of the scoring metric, not a constraint you are allowed to solve against.
Leaderboard
TBD No results yet. Entries and baseline numbers will be posted here.
For reference, random guessing scores 0.1% top-1 and 0.5% top-5. Expect absolute scores to be low; the point is the headroom.
The ImageNet Dataset
The contest uses ImageNet-1k (ILSVRC-2012), the same 1,000-class dataset the field has benchmarked against since 2012. It is free for non-commercial research but gated; obtain it yourself by agreeing to the terms at image-net.org or through the gated Hugging Face repository. This site does not redistribute the data.
Splits
Split
Images
Per class
Size
Role in this contest
Train
1,281,167
732–1,300
~138 GB
the only data you may fit on
Validation
50,000
50 exactly
~6 GB
the score on the leaderboard
Test
100,000
100
~13 GB
unused; labels were never released
The held-out test labels stayed with the ILSVRC servers and are not public, which is why the validation split has served as the de facto test set for the last decade and serves as one here. Treat it as held out: fit on train only, and resist tuning against the validation number more than you would in any honest experiment.
Class balance
The validation set used for scoring is exactly balanced at 50 images per class, so top-1 and top-5 need no reweighting. The training split is close to balanced but not exactly: most classes sit at the 1,300-image cap and the smallest has 732, a max-to-min ratio of about 1.8. That is mild next to a genuinely long-tailed dataset, and how you handle it is up to you. There is no balanced variant of ImageNet-1k worth switching to; subsampling every class to 732 would cost you 40% of the data to fix a problem the scoring metric already sidesteps.
What is actually in it
The classes are WordNet nouns, mostly concrete leaf-level concepts, and they are not a uniform sample of the visual world. Roughly 400 of the 1,000 are animals, and about 120 of those are breeds of dog. The remainder is dominated by man-made objects, with smaller groups of food, plants, instruments, vehicles, and a few materials and scenes.
Much of the difficulty is fine-grained. Separating Siberian husky from Eskimo dog, or one similar snake or mushroom from another, accounts for a large share of the residual error even for very large models. This is the main reason top-5 is reported next to top-1: it separates "the model has no idea" from "the model is choosing among the right handful."
One label per image, but scenes are cluttered. Each image carries a single ground-truth class. The labeled object is usually prominent, though it is not always centered, largest, or unambiguous, and other labelable objects frequently appear alongside it. Some label noise exists and is simply part of the benchmark.
Images are ordinary web photographs. Color JPEGs of varying size and aspect ratio, averaging roughly 470 × 390 pixels, most a few hundred pixels on a side. A small number are grayscale or CMYK, so decode defensively rather than assuming three channels.
Train and validation were collected the same way and are disjoint. The validation images were relabeled with extra annotator care, so they are somewhat cleaner than training images.
Explore the ImageNet Dataset
NAVIGU: the full 1.28M-image training set as a zoomable map, laid out so that visually similar images land near each other. Drag to wander, search by text, double-click an image to recenter on it. The fastest way to feel how much of this dataset is dogs.
Karpathy's ILSVRC labeling interface: real validation images alongside the full 1,000-class list, browsable through the WordNet hierarchy with sample images for every class. Try to label an image yourself, then reveal the true answer and the ConvNet's guess. This is the interface behind the well-known 5.1% human top-5 error figure, and a few rounds of it make the fine-grained problem visceral.
imagenet-sample-images: one representative JPEG per class, 1,000 files in a repository, for a quick scroll through the entire label space.
How to enter
Email a link to your code repository to isaac.gerg@gergltd.com with the subject line 10k entry. The organizers run submissions manually and update the leaderboard on this page. Evaluation cadence: TBD. There is no prize money; the leaderboard is the prize.