ElemedexA pocket encyclopedia of AI architectures
No. 018

AlexNet

SuperVision (its ILSVRC 2012 entry)

Deep Vision

It was born in a Toronto student's bedroom, on two graphics cards built for gaming. It learned to see from a million photos that thousands of invisible people had labeled for pennies. When it appeared in 2012, computer vision changed species almost overnight.

Height
8 (5 conv + 3 dense)
Weight
≈ 240 MB (fp32)
Parameters
≈ 60 M
Context
1 image 224 × 224 × 3
Training data
ImageNet ILSVRC-2012: ≈ 1.2 M images · 1000 classes
Year
2012
Generation
3 · Deep learning
Creators
Krizhevsky, Sutskever & Hinton (University of Toronto)
Kind
Model

Base stats

Total
168

Approximate, ordinal scales meant for comparing species with each other; the hard numbers are in the data sheet.

Weaknesses

  • Adversarial examples: invisible pixel changes make it see an ostrich in a school bus.
  • It needs more than a million hand-labeled images.
  • It assigns a single label per photo: it describes neither scenes nor relations between objects.
  • As a model of human vision it covers, at best, the first hundred milliseconds.

Habitat

It grew up on the ImageNet subset used in the ILSVRC challenge: 1.2 million photos from Flickr and search engines, filtered by Mechanical Turk workers. Today it lives in introductory courses, in the museum (its original code was released in 2025), and in the genes of nearly every vision network that followed.

Moves

Abilities

Rectification (ReLU)
The max(0, x) activation does not saturate: with it the network trained several times faster than with tanh.
Dropout
In the first two dense layers, each neuron is switched off at random with probability 0.5 during training, which curbs overfitting.
Split brain
The network did not fit on a single 3 GB GPU, so it was split across two cards that communicate only at certain layers.

Anatomy

AlexNet: five convolutional and three dense layers. Every convolution and every dense layer is followed by a ReLU. In the original, nearly every layer is split into two halves, one per GPU, which exchange information only at the third convolutional layer and in the dense layers.

Evolution chain

018 AlexNet
  • convolutional policy and value networks, tree search and self-play024 AlphaGo

AlexNet is an eight-layer convolutional network that sorts photographs into a thousand categories. Its victory in the 2012 ImageNet challenge is usually taken as the start of the deep learning boom (Buckner, 2024, p. 55; Chollet, 2021, sec. 1.2.5). It invented almost nothing: it brought together, for the first time and at the right scale, ideas that had been waiting for two decades.

How it works

The network takes a 224 × 224 image with three color channels and processes it through five convolutional and three dense layers: about 60 million parameters and 650,000 neurons (Krizhevsky et al., 2012). Each convolutional layer slides a bank of small filters across the image (96 filters of 11 × 11 pixels in the first one) that respond to edges, orientations or blobs of color; a rectification lets through only what was detected, and pooling summarizes each neighborhood by its maximum value. Buckner (2024) calls this sequence an "abstraction sandwich," stacked again and again (2024, p. 127). Two dense layers of 4,096 units combine the features, and a softmax spreads the probability over the thousand classes.

The authors single out several ingredients (Krizhevsky et al., 2012, secs. 3–4):

  • ReLU: the activation function max(0, x), with which the network trained several times faster than with tanh.
  • Two GPUs: the network did not fit in the 3 GB of a GTX 580, so it was split across two cards that communicate only at certain layers.
  • Data augmentation: random crops and reflections multiply the training images.
  • Dropout: in the first two dense layers each neuron is switched off with probability 0.5 at every step; without it, the network overfit substantially. It amounts to training, all at once, an exponential ensemble of subnetworks that share weights (Witten et al., 2017, p. 436).

Training took five to six days (Krizhevsky et al., 2012, sec. 5).

What changed

The pieces were old: convolution and backpropagation were well understood by 1990 (Chollet, 2021, sec. 1.3), and Convolutional network (LeNet) was already reading handwritten digits. What was new was scale. In 2010 and 2011, the ImageNet winners, built on support vector machines and hand-designed features, got 72% and 74% right with five guesses (M. Mitchell, 2019, ch. 5). AlexNet brought the top-5 error down to 15.3%, against 26.2% for the runner-up (Krizhevsky et al., 2012); non-convolutional methods seemed stuck at around 25% (Witten et al., 2017, p. 439). It was not the first GPU-trained network to win competitions (Dan Cireşan had been doing so since 2011), but it was the one that won the field over (Chollet, 2021, sec. 1.2.5).

The deeper change is that features were no longer designed by hand: the network learns them together with the classifier (Chollet, 2021, sec. 1.2.6). Its first-layer filters turned out to be selective for orientation and frequency (Krizhevsky et al., 2012, sec. 6.1), like the "simple" cells of cat visual cortex described by Hubel & Wiesel (1962), whose discovery inspired the whole convolutional lineage (Buckner, 2024, pp. 122–124).

Everything was built for something else

GPUs were designed for video games: the gaming market, as Chollet puts it, subsidized supercomputing for AI (2021, sec. 1.3.1). ImageNet's labels were obtained through Amazon Mechanical Turk, a system built to weed out duplicate product pages; some 49,000 people in 167 countries worked on them between 2007 and 2010 (Mollick, 2026). The name alludes to a chess automaton with a human hidden inside. Soon afterwards, Google bought Hinton, Krizhevsky and Sutskever's tiny company in an auction that stopped at 44 million dollars (Mollick, 2026).

Limits

A year later, Szegedy and colleagues showed that imperceptible pixel changes made AlexNet see an ostrich where there was a school bus, and that the fragility affected other networks too (M. Mitchell, 2019, ch. 6). As a model of vision, such a network covers at most the first hundred milliseconds of perception, with no recurrence or top-down control (Buckner, 2024, p. 124). And its design aged quickly: local normalization was dropped, and its successors won with more depth, from VGG (19 layers, 7.3%) to ResNet (152 layers, 3.6%) (Witten et al., 2017, p. 439; He et al., 2016). Even the "5% human error" figure these networks were compared with comes from a single person, Andrej Karpathy, who trained himself on 500 images (M. Mitchell, 2019, ch. 5).

Sources

  • Buckner, C. J. (2024). From deep learning to rational machines: What the history of philosophy can teach us about the future of artificial intelligence. Oxford University Press. https://doi.org/10.1093/oso/9780197653302.001.0001 §
  • Chollet, F. (2021). Deep learning with Python (2nd ed.). Manning Publications. §
  • Deng, J., Dong, W., Socher, R., Li, L.-J., Li, K., & Fei-Fei, L. (2009). ImageNet: A large-scale hierarchical image database. In 2009 IEEE Conference on Computer Vision and Pattern Recognition (pp. 248–255). IEEE. https://doi.org/10.1109/CVPR.2009.5206848 §
  • Gray, M. L., & Suri, S. (2019). Ghost work: How to stop Silicon Valley from building a new global underclass. Houghton Mifflin Harcourt. §
  • He, K., Zhang, X., Ren, S., & Sun, J. (2016). Deep residual learning for image recognition. In Proceedings of the 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR) (pp. 770–778). IEEE. https://doi.org/10.1109/CVPR.2016.90 §
  • Hubel, D. H., & Wiesel, T. N. (1962). Receptive fields, binocular interaction and functional architecture in the cat’s visual cortex. The Journal of Physiology, 160(1), 106–154. https://doi.org/10.1113/jphysiol.1962.sp006837 §
  • Krizhevsky, A., Sutskever, I., & Hinton, G. E. (2012). ImageNet classification with deep convolutional neural networks. In Advances in Neural Information Processing Systems (Vol. 25). Curran Associates. https://proceedings.neurips.cc/paper_files/paper/2012/hash/c399862d3b9d6b76c8436e924a68c45b-Abstract.html §
  • Mitchell, M. (2019). Artificial intelligence: A guide for thinking humans. Pelican Books. §
  • Mollick, E. (2026). Built for something else: Sources and notes [Sources companion to the video "Built for something else: How a chain of accidents built ChatGPT"; written by Claude Opus 5.5, supervised by E. Mollick]. Retrieved September 30, 2026, from https://built-for-something-else.netlify.app/ §
  • Srivastava, N., Hinton, G., Krizhevsky, A., Sutskever, I., & Salakhutdinov, R. (2014). Dropout: A simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(56), 1929–1958. https://jmlr.org/papers/v15/srivastava14a.html §
  • Witten, I. H., Frank, E., Hall, M. A., & Pal, C. J. (2017). Data mining: Practical machine learning tools and techniques (4th ed.). Morgan Kaufmann. https://doi.org/10.1016/C2015-0-02071-8 §