CS231n: Deep Learning for Computer Vision
by Stanford University
Implement deep learning from kNN to diffusion models in NumPy before you are allowed to call a library.
Overview
CS231n is Stanford's flagship deep-learning-for-vision course and, in its Spring 2026 offering, one of the few university courses that carries a competent programmer from k-nearest-neighbour classification to diffusion models inside a single quarter. The published schedule runs eighteen 80-minute lectures from 31 March to 2 June 2026: image classification with linear classifiers, regularization and optimization (SGD, momentum, Adam, learning-rate schedules), neural networks and backpropagation, CNNs, CNN architectures (batch normalization, transfer learning, AlexNet, VGG, ResNet), recurrent networks and LSTMs, attention and transformers, object detection and segmentation, video understanding, large-scale distributed training with parallelism and activation checkpointing, self-supervised and contrastive learning, VAEs, GANs and autoregressive models, diffusion models, 3D vision, vision and language, a guest lecture on world modelling, and human-centred AI. Three graded assignments, released 2 April, 23 April and 14 May, make you implement the mathematics rather than call a library: kNN, softmax and fully-connected nets first, then batch normalization, dropout, convolutional nets, network visualization and RNN image captioning, and finally transformers, self-supervised learning and diffusion. Grading is 45% assignments, 20% midterm and 35% final project, which is why the public material is a genuine curriculum rather than a lecture dump. The lecture notes at cs231n.github.io, the slides and the assignment starter code are free and public; current-year video sits behind Stanford Canvas while prior-year recordings are on YouTube.
At a Glance
- Topic
- ML
- Level
- Intermediate
- Format
- Course
- Cost
- Free
- Duration
- ~10 weeks (18 x 80-min lectures) plus 3 assignments; ~10-15 h/week, or self-paced from the free notes
- Provider
- Stanford University
- Hands-on
- Yes — code/exercises
- Certificate
- None
What You’ll Learn
- ✓Implement backpropagation by hand in NumPy for fully-connected and convolutional layers
- ✓Compare SGD with momentum, Adam and learning-rate schedules, and know when each actually helps
- ✓Build and train CNN architectures using batch normalization, dropout and transfer learning from ResNet
- ✓Derive self-attention and assemble a transformer block for vision and image-captioning tasks
- ✓Train models with self-supervised contrastive objectives instead of relying on labelled data
- ✓Explain and implement generative models: VAEs, GANs, autoregressive models and diffusion
- ✓Scale a training run across devices using parallelism and activation checkpointing
- ✓Debug training by visualizing learned features, gradients and adversarial failure cases
Highlights
- •Notes, slides and assignment starter code are free and public; only current-year lecture video is behind Canvas
- •The 2026 syllabus is genuinely current — transformers, self-supervised learning, diffusion and a world-modelling guest lecture
- •Assignments demand NumPy implementations before PyTorch, so you cannot autograd your way past the mathematics
- •Taught by Fei-Fei Li and Justin Johnson, the lineage that produced ImageNet and much of modern vision
- •A perennial Hacker News reference; cs231n.github.io has been the default backpropagation explainer for a decade
Who It’s For
Best For
- ✓ML engineers who can call PyTorch but have never implemented backpropagation themselves
- ✓LLM and agent engineers who want real grounding in the architectures underneath multimodal models
- ✓Students or researchers preparing a vision or multimodal final project
- ✓Anyone using CLIP, DINO or diffusion models as a black box who wants to stop
Prerequisites
- •Proficiency in Python with NumPy — the assignments are unforgiving without it
- •College-level calculus and linear algebra (Stanford MATH 19 / MATH 51 equivalent)
- •Basic probability and statistics
- •Roughly 10-15 hours per week if you actually complete the three assignments and a project
FAQ
What is CS231n: Deep Learning for Computer Vision?
Stanford's graduate course on deep learning for computer vision, taught in Spring 2026 by Fei-Fei Li, Justin Johnson, Ehsan Adeli, Zane Durante and Tiange Xiang. It walks from linear classifiers and backpropagation through CNN architectures, attention and transformers, self-supervised learning, diffusion models and 3D vision, with three from-scratch NumPy and PyTorch assignments. Finish it and you can implement, train and debug a modern vision model yourself.
Is CS231n: Deep Learning for Computer Vision free?
CS231n: Deep Learning for Computer Vision is free to access.
What level is CS231n: Deep Learning for Computer Vision for?
CS231n: Deep Learning for Computer Vision is aimed at a intermediate audience. Recommended background: Proficiency in Python with NumPy — the assignments are unforgiving without it, College-level calculus and linear algebra (Stanford MATH 19 / MATH 51 equivalent), Basic probability and statistics, Roughly 10-15 hours per week if you actually complete the three assignments and a project.
How long does CS231n: Deep Learning for Computer Vision take?
Expect roughly ~10 weeks (18 x 80-min lectures) plus 3 assignments; ~10-15 h/week, or self-paced from the free notes. Most learners work through it at their own pace.
What will I learn from CS231n: Deep Learning for Computer Vision?
You'll learn: Implement backpropagation by hand in NumPy for fully-connected and convolutional layers; Compare SGD with momentum, Adam and learning-rate schedules, and know when each actually helps; Build and train CNN architectures using batch normalization, dropout and transfer learning from ResNet; Derive self-attention and assemble a transformer block for vision and image-captioning tasks; Train models with self-supervised contrastive objectives instead of relying on labelled data; Explain and implement generative models: VAEs, GANs, autoregressive models and diffusion; Scale a training run across devices using parallelism and activation checkpointing; Debug training by visualizing learned features, gradients and adversarial failure cases.
Topics
Sources
This page was written from 4 sources, 2 on domains other than cs231n.stanford.edu.