The Complete Deep Learning Roadmap 2026-2027

Why This Roadmap?

Deep learning is the technology behind nearly every major AI breakthrough of the last decade - image recognition surpassing human accuracy, machine translation that reads naturally, large language models that write code and reason through problems, and diffusion models that generate photorealistic images from text. But the learning path is unusually fragmented: some resources jump straight to fine-tuning pretrained transformers without ever explaining what a gradient is, while others stay purely theoretical and never touch a training loop.

This roadmap closes that gap. It is architecturally complete, following the same progression that produced the field's landmark results - from a single neuron to the transformer to today's foundation models. It is implementation-first, with a from-scratch coding exercise at every major milestone, because understanding a diagram is not the same as understanding the mechanism. And it is honest about scope: deep learning is a large field, and this roadmap covers computer vision, NLP, generative models, graph learning, and deep reinforcement learning without pretending any of them can be mastered in a weekend course.

Phase 0: Prerequisites & Assessment (2–3 weeks)

Deep learning has a steeper mathematical and engineering on-ramp than classical ML. This phase confirms you have what you need before investing months into architectures that will not make sense without it.

What You Should Already Know

Comfortable Python (functions, classes, list/dict comprehensions, working with virtual environments) and the core classical ML vocabulary: train/validation/test splits, overfitting and underfitting, regularisation, cross-validation, and standard evaluation metrics. If any of this is unfamiliar, the Machine Learning Roadmap covers it in full before you arrive here.

Mathematics Refresher for Deep Learning

You will lean on linear algebra and calculus more heavily here than in classical ML. Before Phase 1, make sure you can comfortably:

• Multiply matrices and reason about tensor shapes (this is the single most common source of bugs in deep learning code)
• Compute partial derivatives and apply the chain rule to composite functions
• Explain what a gradient and a Jacobian represent geometrically
• Understand basic probability distributions and the intuition behind KL divergence

• 3Blue1Brown: Essence of Linear Algebra - Non-negotiable viewing if matrix operations feel unfamiliar
• 3Blue1Brown: Essence of Calculus - Builds the intuition backpropagation depends on
• Khan Academy: Statistics and Probability - Refresh distributions and expectation

Development Environment

Set up a Python environment with PyTorch, and get comfortable with a GPU-backed notebook environment. You do not need to own a GPU to start.

• Google Colab - Free GPU access, zero setup, the standard starting point
• Kaggle Notebooks - Free GPU/TPU quota, integrated with datasets and competitions
• PyTorch local installation guide - For when you want a persistent local setup

Phase 1: Neural Network Foundations (4–6 weeks)

This phase builds the conceptual and mathematical core that every subsequent architecture - CNNs, RNNs, transformers - is a variation on. Rush this phase and every later architecture will feel like memorised recipes instead of logical extensions.

The Artificial Neuron & the Perceptron

Start with the single artificial neuron: weighted sum of inputs, bias term, activation function. Understand the historical Perceptron, its linear-separability limitation, and why this motivated multi-layer architectures.

The Multilayer Perceptron (MLP)

What you need: Stacking layers of neurons, universal approximation intuition, forward propagation as repeated matrix multiplication plus non-linearity.

Activation functions: Sigmoid and Tanh (historical, understand their vanishing-gradient weakness), ReLU and its variants (Leaky ReLU, ELU, GELU, Swish/SiLU - the modern defaults), and Softmax for multi-class output layers. Understand why the choice of activation function materially affects trainability, not just output shape.

Backpropagation: The Core Mechanism

Backpropagation is simply the chain rule applied systematically backwards through a computational graph. Understand: the forward pass computes activations and caches intermediate values; the backward pass computes gradients of the loss with respect to every parameter using those cached values; and gradient descent then updates parameters in the direction that reduces loss.

Loss Functions

Mean Squared Error and Mean Absolute Error for regression; Cross-Entropy Loss (binary and categorical) for classification; understand the relationship between cross-entropy and maximum likelihood estimation, and why cross-entropy pairs naturally with softmax.

PyTorch Fundamentals

• PyTorch: Learn the Basics - Official tutorial series covering tensors, autograd, and nn.Module
• Deep Learning with PyTorch: A 60 Minute Blitz - Fast, hands-on introduction
• Andrej Karpathy: Neural Networks - Zero to Hero - The best free video series bridging from-scratch understanding to PyTorch fluency

Exercise: Re-implement the same MLP from your NumPy version using PyTorch's autograd and nn.Module. Compare outputs - they should match. This confirms you understand what the framework is automating for you.

Phase 2: Training Deep Networks in Practice (4–5 weeks)

Knowing the theory of a neural network is not the same as being able to make one train reliably. This phase covers the engineering craft of getting deep networks to converge, generalise, and train efficiently - skills that separate practitioners from people who can only run tutorial notebooks.

Optimisation Algorithms

Stochastic Gradient Descent (SGD) and mini-batch gradient descent; momentum and Nesterov momentum for accelerating convergence; adaptive methods - RMSprop, Adam, and AdamW (the modern default, which decouples weight decay from the adaptive learning rate). Understand learning rate schedules: step decay, cosine annealing, and warmup - the last of which is essential for training transformers stably.

Regularisation for Deep Networks

• Dropout - Randomly zeroing activations during training to prevent co-adaptation
• Weight decay (L2 regularisation) and its distinction from Adam's naive L2 implementation, which AdamW corrects
• Early stopping based on validation loss
• Data augmentation - task-specific but universally effective (covered per-domain in later phases)

Normalisation Techniques

Batch Normalization - normalising activations across the batch dimension to stabilise and accelerate training; Layer Normalization - normalising across the feature dimension, essential for RNNs and transformers where batch statistics are less meaningful; Group Normalization and Instance Normalization for vision tasks with small batch sizes.

Weight Initialisation

Why initialisation matters: poor initialisation causes vanishing or exploding activations before training even begins. Xavier/Glorot initialisation for sigmoid/tanh networks; He initialisation for ReLU-family networks. Understand the variance-preservation argument behind both.

Diagnosing Training Problems

This is the practical skill most tutorials skip. Learn to read a loss curve: a loss that plateaus immediately suggests a learning rate or initialisation problem; a loss that diverges to NaN suggests exploding gradients or too high a learning rate; a large train/validation gap suggests overfitting; a model that fails to beat a trivial baseline suggests a data or labelling bug before an architecture problem.

• A Recipe for Training Neural Networks - Andrej Karpathy - The single best practical guide to debugging training runs
• Weights & Biases - Experiment tracking; learn to log every run rather than relying on memory

Phase 3: Convolutional Neural Networks & Computer Vision (6–8 weeks)

CNNs remain the backbone of most production computer vision systems and are the clearest illustration of how architectural inductive bias (in this case, translation invariance) makes learning dramatically more sample-efficient.

Convolution Fundamentals

The convolution operation: filters/kernels sliding across an input, producing feature maps. Padding (valid vs. same), stride, and how they control output spatial dimensions. Pooling (max pooling, average pooling) for spatial downsampling and translation invariance. Understand why convolution's parameter sharing makes it vastly more sample-efficient than a fully-connected layer for image data.

Classic CNN Architectures - In Historical & Conceptual Order

Transfer Learning & Fine-Tuning

Using pretrained CNN backbones (via torchvision.models or Hugging Face Model Hub) and fine-tuning on a target task. Understand feature extraction (freezing the backbone) vs. full fine-tuning, and when each is appropriate given dataset size.

Beyond Classification: Core CV Tasks

• Object Detection: Two-stage (Faster R-CNN) vs. single-stage (YOLO, SSD) detectors; anchor boxes; non-maximum suppression
• Semantic & Instance Segmentation: Fully Convolutional Networks, U-Net (especially dominant in medical imaging), Mask R-CNN
• Vision Transformers (ViT): Treating image patches as sequence tokens - covered in depth in Phase 5

Best Courses for CNNs & Computer Vision

• Stanford CS231N: CNNs for Visual Recognition - The definitive course; lecture videos and assignments are freely available
• Fast.ai: Practical Deep Learning for Coders - Top-down, code-first approach with strong CV coverage
• torchvision documentation - Reference implementations and pretrained models

Recommended Datasets for Practice

MNIST and Fashion-MNIST for the first from-scratch CNN. CIFAR-10/100 for architecture comparison experiments. ImageNet (or a subset, Tiny-ImageNet) for understanding large-scale training. Domain-specific: Kaggle vision datasets for a portfolio-worthy applied project.

Phase 4: RNNs, LSTMs & GRUs - Sequential Data (4–6 weeks)

Before transformers, recurrent architectures were the standard approach to sequential data - text, time series, audio. Understanding them deeply is not merely historical: LSTMs and GRUs remain competitive for many time-series and low-resource sequence tasks, and understanding why they were superseded illuminates exactly what makes transformers powerful.

Recurrent Neural Networks (RNNs)

The core idea: a hidden state carried forward through time, updated at each step by combining the current input with the previous hidden state. Understand backpropagation through time (BPTT) - the chain rule unrolled across time steps - and why this unrolling causes the vanishing and exploding gradient problems that limit vanilla RNNs to short sequences.

Long Short-Term Memory (LSTM)

Hochreiter & Schmidhuber's LSTM (1997) solves vanishing gradients with a gating mechanism: the forget gate, input gate, and output gate control what information persists in the cell state across time steps, allowing gradients to flow largely unimpeded across long sequences. Understand each gate's role and why the additive cell-state update (rather than repeated multiplication) is the key structural fix.

Gated Recurrent Unit (GRU)

A simplified alternative to the LSTM, merging the forget and input gates into a single update gate and combining the cell and hidden states. Fewer parameters, often comparable performance, and a common default when compute or data is limited.

Sequence-to-Sequence (Seq2Seq) Models

Encoder-decoder architectures for tasks where input and output are both sequences of different lengths (translation, summarisation). Understand the original encoder-decoder bottleneck problem - compressing an entire input sequence into a single fixed-length vector - which directly motivated the invention of attention mechanisms, covered next.

Attention Mechanisms (Pre-Transformer)

Bahdanau and Luong attention: instead of relying solely on a fixed encoder output, the decoder learns to attend to different encoder hidden states at each decoding step. This was the conceptual bridge between RNNs and the fully attention-based Transformer architecture in Phase 5 - understanding it here makes the transformer's self-attention feel like a natural generalisation rather than an abrupt invention.

• Understanding LSTM Networks - Christopher Olah - The definitive visual explanation of LSTM gating
• The Unreasonable Effectiveness of Recurrent Neural Networks - Andrej Karpathy - Intuition-building with character-level RNN demos
• PyTorch Seq2Seq Translation Tutorial - Hands-on encoder-decoder-attention implementation

Phase 5: Transformers & Attention Mechanisms (5–7 weeks)

The Transformer is the single most important architecture in modern deep learning. It underlies every major LLM, most state-of-the-art vision models (ViT), speech models, and increasingly biology and multimodal systems. Mastering this phase is the highest-leverage investment in this entire roadmap.

Why Transformers Replaced Recurrence

RNNs process sequences step-by-step, which is inherently sequential and slow to parallelise, and still struggles with very long-range dependencies despite gating. Vaswani et al. (2017) showed that self-attention alone - with no recurrence at all - could model dependencies of any distance in a sequence while being fully parallelisable across the sequence dimension during training. This is the single insight the entire modern LLM era is built on.

Self-Attention Mechanics

Query, Key, and Value projections of the input; attention scores as scaled dot products between queries and keys; softmax normalisation; the weighted sum of values as output. Understand the scaling factor (dividing by √d_k) and why it prevents softmax saturation at higher dimensions.

Multi-Head Attention

Running several attention operations in parallel with different learned projections, allowing the model to jointly attend to information from different representation subspaces - some heads might track syntax, others long-range coreference, others local patterns.

Positional Encoding

Because self-attention has no inherent notion of order, position must be injected explicitly. Understand sinusoidal positional encodings (the original approach), learned positional embeddings, and modern alternatives like Rotary Position Embeddings (RoPE), now standard in most open-weight LLMs.

The Full Transformer Block

Residual connections around both the attention and feed-forward sublayers; Layer Normalization (pre-norm vs. post-norm placement, and why pre-norm is now preferred for training stability at scale); the position-wise feed-forward network; encoder-only (BERT-style), decoder-only (GPT-style), and encoder-decoder (T5-style, original transformer) variants and when each is used.

Vision Transformers (ViT)

Dosovitskiy et al. (2021) showed that splitting an image into fixed-size patches, linearly embedding them, and feeding the resulting sequence through a standard transformer encoder matches or exceeds CNN performance at sufficient data scale - unifying vision and language modelling under one architecture family.

Best Resources for Learning Transformers

• The Annotated Transformer - Harvard NLP - Line-by-line PyTorch implementation alongside the original paper's text
• The Illustrated Transformer - Jay Alammar - The most accessible visual explanation available anywhere
• Andrej Karpathy: Let's Build GPT From Scratch - Live-coded decoder-only transformer, exceptional for solidifying implementation
• Stanford CS25: Transformers United - Guest lectures from researchers on transformer applications across domains

Phase 6: Large Language Models & Foundation Models (6–8 weeks)

With the transformer architecture in hand, this phase covers how it is scaled, pretrained, adapted, and deployed to produce the large language models that define the current era of AI.

Pretraining Paradigms

Masked Language Modelling (BERT-style):Devlin et al.'s BERT masks random tokens and trains the model to predict them using bidirectional context - ideal for understanding-oriented tasks (classification, extraction, embeddings).

Autoregressive/Causal Language Modelling (GPT-style): Predicting the next token given all previous tokens, with a causal attention mask preventing the model from seeing the future. This is the paradigm underlying GPT, Llama, Mistral, and virtually every modern generative LLM. Brown et al.'s GPT-3 paper demonstrated that scale alone produces qualitatively new few-shot capabilities.

Scaling Laws

Empirical relationships between model size, dataset size, compute budget, and loss (Kaplan et al. and the later Chinchilla scaling laws) that guide how organisations allocate compute between larger models and more training tokens. Understanding scaling laws explains why the field's biggest gains over the past five years have come disproportionately from scale rather than architectural novelty.

Tokenisation

Byte-Pair Encoding (BPE), WordPiece, and SentencePiece - subword tokenisation schemes that balance vocabulary size against sequence length. Understand tokenisation quirks (numbers, whitespace, non-English languages) that cause surprising LLM failures in practice.

Prompting & In-Context Learning

• Zero-shot, few-shot, and chain-of-thought prompting - promptingguide.ai
• Why in-context learning works without weight updates - an active research question, but understanding the leading hypotheses (implicit gradient descent, task-vector induction) is expected at research-adjacent roles

Fine-Tuning & Parameter-Efficient Methods

• Full fine-tuning: Updating all model weights - expensive but sometimes necessary for large domain shifts
• LoRA (Low-Rank Adaptation):Hu et al. (2022) - freezing pretrained weights and injecting small trainable low-rank matrices, reducing trainable parameters by orders of magnitude
• QLoRA: Combining LoRA with 4-bit quantisation of the frozen base model, enabling fine-tuning of large models on consumer GPUs
• Hugging Face PEFT library documentation

Alignment: RLHF & Beyond

RLHF (Reinforcement Learning from Human Feedback):Ouyang et al.'s InstructGPT paper established the now-standard pipeline: supervised fine-tuning on demonstrations, training a reward model on human preference comparisons, then optimising the policy against that reward model with PPO. Understand DPO (Direct Preference Optimization) as a simpler alternative that skips the separate reward model, and RLAIF (using AI feedback instead of human feedback) as a scaling strategy.

Retrieval-Augmented Generation (RAG)

Grounding LLM outputs in external, retrievable knowledge rather than relying solely on parametric memory - reduces hallucination and enables up-to-date, source-attributable answers. Covers embedding models, vector databases, chunking strategies, and retrieval-generation pipelines.

• LangChain RAG tutorial
• LlamaIndex documentation - Purpose-built for RAG pipelines

Agents & Tool Use

LLMs augmented with the ability to call external tools, APIs, or functions, and to plan multi-step tasks. Understand the ReAct pattern (reasoning and acting interleaved) and the current limitations of agentic reliability at long horizons.

Evaluating LLMs

Perplexity for language modelling quality; BLEU, ROUGE, and METEOR for generation tasks (and their well-documented limitations); benchmark suites (MMLU, HellaSwag, GSM8K, HumanEval) and their saturation/contamination concerns; LLM-as-judge evaluation and its biases; human evaluation as the ultimate ground truth for open-ended generation.

• Hugging Face Evaluate library
• Hugging Face NLP Course - Comprehensive, free, hands-on transformer and LLM training

Phase 7: Generative Models - GANs & Diffusion (5–6 weeks)

Generative modelling - learning to produce new samples from a data distribution rather than just classifying or predicting - has its own architectural lineage, running from GANs through VAEs to the diffusion models that now dominate image, audio, and video generation.

Variational Autoencoders (VAEs)

Encoder-decoder architecture trained to reconstruct inputs through a compressed, probabilistic latent bottleneck. Understand the reparameterisation trick (enabling gradients to flow through a sampling operation) and the ELBO (Evidence Lower Bound) objective, which balances reconstruction quality against latent space regularity.

Generative Adversarial Networks (GANs)

Goodfellow et al.'s (2014) GAN framework: a generator network competes against a discriminator network in a minimax game, the generator trying to produce samples indistinguishable from real data, the discriminator trying to tell them apart. Understand training instability (mode collapse, non-convergence) as the framework's central practical challenge, and the architectural fixes developed over time: DCGAN (convolutional architectures), WGAN (Wasserstein distance for stabler gradients), StyleGAN (style-based generation with fine control over generated attributes).

Diffusion Models - The Current State of the Art

Ho et al.'s Denoising Diffusion Probabilistic Models (DDPM, 2020) reframed generation as learning to reverse a gradual noising process: the forward process incrementally adds Gaussian noise to data over many steps until it becomes pure noise; the model learns to reverse this, step by step, turning noise back into data. Understand why diffusion models produce more diverse, higher-fidelity samples with more stable training than GANs, at the cost of slower (multi-step) sampling.

• Latent Diffusion: Running the diffusion process in a compressed latent space rather than pixel space (the basis of Stable Diffusion) - dramatically reduces compute cost
• Classifier-free guidance: Steering generation toward a text prompt without a separate classifier
• Samplers: DDIM and other fast samplers that reduce the number of denoising steps needed at inference time

• Hugging Face Diffusion Models Course - Free, hands-on, code-first
• Diffusers library documentation - The standard tooling for working with diffusion models in practice
• CVPR proceedings - Primary venue for the latest generative vision research

Beyond Images: Generative Models in Other Modalities

Diffusion for audio synthesis and music generation; diffusion and autoregressive approaches for video generation; the emerging convergence between diffusion and transformer-based generation (Diffusion Transformers / DiT), which now underlies most state-of-the-art image and video generators.

Phase 8: Self-Supervised Learning & Multimodal AI (4–5 weeks)

Self-supervised learning - extracting supervisory signal from the structure of unlabelled data itself - is what makes training on internet-scale data possible, and multimodal AI is where the field's research frontier currently sits.

Self-Supervised Learning in Vision

Contrastive learning:SimCLR (Chen et al., 2020) trains representations by pulling augmented views of the same image together in embedding space while pushing different images apart, requiring no labels at all. Understand the role of strong data augmentation and large negative-sample batches in making contrastive objectives work.

Masked image modelling: MAE (Masked Autoencoders) applies the BERT-style masking idea to images - masking large patches and training a model to reconstruct them - producing strong representations with a simpler, non-contrastive objective.

Multimodal Architectures

CLIP (Contrastive Language-Image Pretraining) jointly embeds images and text into a shared space by contrasting matched vs. mismatched image-caption pairs at internet scale, enabling zero-shot image classification and forming the backbone of most modern text-to-image systems. Vision-language models (LLaVA, GPT-4V-style architectures, Gemini-style architectures) that combine a vision encoder with an LLM decoder to enable image-conditioned text generation and reasoning.

Speech & Audio Deep Learning

Automatic Speech Recognition (ASR) with encoder-decoder and CTC-based architectures; Whisper-style large-scale multilingual, multitask speech models; text-to-speech (TTS) with neural vocoders; speaker diarization and voice cloning, and the ethical considerations that come with them.

• Hugging Face Audio Course
• OpenAI Whisper research post

Medical Imaging with Deep Learning

A high-impact specialisation with distinctive challenges: small labelled datasets relative to natural images, class imbalance, the need for interpretability and uncertainty estimation, and strict regulatory requirements. U-Net remains the dominant architecture for segmentation tasks (tumour boundaries, organ delineation); transfer learning from natural-image pretraining is common but must be validated carefully given the domain gap.

Phase 9: Graph Neural Networks (3–4 weeks)

Not all data is grid-structured (like images) or sequential (like text) - social networks, molecules, knowledge graphs, and recommendation systems are naturally represented as graphs. GNNs extend the deep learning toolkit to this relational data structure.

Why Standard Architectures Fail on Graphs

Graphs have no fixed ordering of nodes and variable numbers of neighbours per node, so CNNs (fixed grid structure) and RNNs (fixed sequential structure) do not directly apply. GNNs need to be permutation-invariant or equivariant.

Message Passing & Core Architectures

The general message-passing framework: each node aggregates information from its neighbours, combines it with its own representation, and updates - repeated over several layers to let information propagate across the graph. Graph Convolutional Networks (Kipf & Welling, 2017) generalise convolution to graphs via spectral/neighbourhood aggregation; GraphSAGE enables inductive learning on graphs where new, unseen nodes appear at inference time; Graph Attention Networks (GAT) apply attention weighting to neighbour aggregation, analogous to transformer attention.

Applications

• Molecular property prediction and drug discovery (molecules as graphs of atoms and bonds)
• Recommendation systems (users and items as a bipartite graph)
• Fraud and anomaly detection (transaction networks)
• Knowledge graph completion and reasoning

• A Gentle Introduction to Graph Neural Networks - Distill.pub - Exceptional interactive visual explanation
• PyTorch Geometric documentation - The standard library for implementing GNNs
• Stanford CS224W: Machine Learning with Graphs

Phase 10: Deep Reinforcement Learning (4–6 weeks)

Deep RL combines neural function approximation with reinforcement learning's trial-and-error framework, and has recently become directly relevant to deep learning practitioners through its role in LLM alignment (RLHF), not just games and robotics.

RL Foundations

Markov Decision Processes (states, actions, rewards, transitions); the value function and Q-function; the exploration-exploitation tradeoff; the distinction between model-free and model-based RL.

Value-Based Deep RL

Deep Q-Networks (DQN) approximate the Q-function with a neural network, using experience replay (breaking correlation between consecutive samples) and a target network (stabilising the bootstrapped target) - the combination that first made deep RL work reliably on high-dimensional inputs like raw pixels (Atari).

Policy-Based & Actor-Critic Methods

Policy gradient methods directly optimise a parameterised policy rather than a value function. Actor-critic methods combine both, using a learned value function to reduce the variance of policy gradient estimates. PPO (Proximal Policy Optimization) constrains policy updates to prevent destructively large steps, making it stable enough to be the default choice in both robotics and - critically - RLHF pipelines for LLM alignment. SAC (Soft Actor-Critic) adds an entropy bonus encouraging exploration, popular in continuous-control robotics.

Multi-Agent RL

Extending RL to settings with multiple learning agents, cooperative or competitive - relevant to game AI, autonomous vehicle coordination, and emerging multi-agent LLM systems.

• OpenAI Spinning Up in Deep RL - The best-structured free introduction, with clean reference implementations
• Berkeley CS 285: Deep Reinforcement Learning
• Gymnasium - Standard RL environment suite for practice and benchmarking

Phase 11: Domain Specialisations (Ongoing, Choose 1–2)

With the core architectures covered, depth in a chosen domain is what makes a portfolio and interview performance genuinely competitive rather than generically broad.

Phase 12: Efficient Deep Learning, Deployment & MLOps (5–6 weeks)

A model that only runs in a notebook on a rented A100 is a research artefact, not a product. This phase covers making deep learning models fast, small, reliable, and observable in production.

Model Compression

Quantisation: Reducing numerical precision of weights and activations (FP32 → FP16/BF16 → INT8 → INT4) to shrink memory footprint and increase inference speed, with a tradeoff against accuracy. Post-training quantisation vs. quantisation-aware training (which simulates quantisation during training to recover more accuracy).

Pruning: Removing redundant weights or entire structural units (neurons, channels, attention heads) that contribute little to output - structured pruning (removing whole channels/heads, hardware-friendly) vs. unstructured pruning (removing individual weights, requires sparse-matrix support to realise speedups).

Knowledge Distillation:Hinton, Vinyals & Dean (2015) - training a smaller "student" model to match a larger "teacher" model's output distribution (soft labels), often recovering much of the teacher's performance at a fraction of the size and inference cost.

Distributed Training

Data parallelism (replicating the model across devices, splitting the batch); model parallelism (splitting the model itself across devices when it does not fit on one); pipeline parallelism (splitting layers across devices with staged execution); ZeRO / Fully Sharded Data Parallel (FSDP) - sharding optimizer states, gradients, and parameters across devices to train models far larger than any single device's memory would allow.

• PyTorch FSDP tutorial
• Microsoft DeepSpeed documentation - ZeRO optimizer and large-scale training infrastructure

Efficient Inference

KV-caching for autoregressive generation (avoiding recomputation of past-token representations); batching strategies for serving throughput; speculative decoding (using a small draft model to propose tokens a larger model verifies in parallel); dedicated inference runtimes - vLLM, ONNX Runtime, NVIDIA TensorRT.

Model Serving & Deployment

• FastAPI - Build inference APIs for model serving
• Docker - Containerisation for reproducible deployment
• Kubernetes - Orchestration and autoscaling for serving infrastructure
• TorchServe, TensorFlow Serving - Framework-native serving solutions
• Edge deployment: TensorFlow Lite, ExecuTorch - On-device inference for mobile and embedded systems

MLOps for Deep Learning

• Experiment tracking and model versioning: Weights & Biases, MLflow
• Data and training pipelines: Apache Airflow
• Monitoring for data drift, model drift, and performance degradation in production
• CI/CD for model releases: automated evaluation gates before deployment

Phase 13: Portfolio Projects & Career Positioning (Ongoing)

Deep learning portfolios need to demonstrate architectural understanding, not just the ability to call a pretrained model's API. This phase is about proving depth.

What Makes a Strong Deep Learning Project?

• Includes at least one from-scratch component - an architecture, training loop, or loss function you implemented yourself, not only library calls
• Addresses a real constraint - limited data, limited compute, latency requirements, or a genuine deployment target
• Rigorous evaluation - proper baselines, ablations showing what each architectural choice contributed, error analysis on failure cases
• Reproducible - clean code, pinned dependencies, a README that lets someone else run it
• Clearly communicated - a write-up explaining design decisions, not just a results table

Project Ideas by Domain

Publishing & Recognition

• Kaggle Competitions: Deep-learning-heavy competitions (vision, NLP) - kaggle.com/competitions
• Research Papers: Submit to arXiv, workshop tracks at ICLR, NeurIPS, ICML - workshop papers are a realistic first publication target
• Open-Weight Model Cards & Fine-Tunes: Publishing well-documented fine-tunes on Hugging Face Hub is a strong, visible portfolio signal
• Open Source: Contribute to PyTorch, Hugging Face Transformers, Diffusers

Career Pathways

Timeline & Realistic Pace

Total commitment: ~14–20 months at 20–30 hours/week for intensive learning, then ongoing for career growth and staying current. This assumes classical ML fundamentals are already in place (see the Machine Learning Roadmap if not). Software engineers and mathematics graduates may compress Phases 0–2; those pursuing only one specialisation (e.g. only NLP, skipping GNNs and deep RL) can reasonably shorten the total timeline by two to three months.

Common Mistakes When Learning Deep Learning

• Skipping the from-scratch implementations - Using nn.Linear, nn.LSTM, or a pretrained transformer without ever building the equivalent from raw tensor operations produces fragile, surface-level understanding that collapses under interview or debugging pressure.
• Chasing every new paper instead of mastering fundamentals - Attention, normalisation, and optimisation explain the overwhelming majority of what looks like a "new" architecture. Depth on fundamentals generalises further than breadth on recent releases.
• Training on tiny toy datasets and drawing large conclusions - Architectural comparisons on MNIST rarely predict behaviour at scale; treat toy datasets as mechanism-verification tools, not benchmarks for architectural decisions.
• Ignoring tensor shape bugs until they cause silent failures - Shape mismatches that silently broadcast incorrectly are the most common and hardest-to-diagnose deep learning bug. Get in the habit of asserting expected shapes throughout a forward pass.
• Not logging or tracking experiments - Re-running the "same" experiment from memory rather than from a logged configuration wastes enormous time; adopt experiment tracking (Weights & Biases or MLflow) from your very first project.
• Treating GPU/compute constraints as a blocker rather than a design constraint - Nearly every phase in this roadmap can be learned meaningfully on free-tier Colab/Kaggle GPUs by working at smaller scale; scale is rarely the limiting factor for understanding.
• Fine-tuning without a strong baseline - Skipping a zero-shot or prompted baseline before fine-tuning makes it impossible to know whether fine-tuning actually helped, or by how much.

Frequently Asked Questions

• Do I need to learn classical machine learning before deep learning?+
  Yes, at least the fundamentals. Deep learning is a subfield of machine learning, and concepts like train/test splits, overfitting, regularisation, cross-validation, bias-variance tradeoff, and evaluation metrics transfer directly. You do not need to master gradient boosting or SVMs before starting neural networks, but you should understand the general ML workflow first. If you have not covered this ground, our Machine Learning Roadmap is the natural starting point - Phases 0 through 3 there set up everything this roadmap builds on.
• How much mathematics do I actually need for deep learning?+
  More linear algebra and calculus than classical ML, but the level required is computational rather than theoretical. You need to be fluent with matrix multiplication, the chain rule, partial derivatives, Jacobians, and basic probability (distributions, expectation, KL divergence). Understanding why backpropagation is just repeated application of the chain rule makes debugging vanishing and exploding gradients intuitive. You do not need measure theory or functional analysis unless you are pursuing theoretical deep learning research. Four to six weeks of focused study before touching neural network code pays for itself many times over.
• Should I learn PyTorch or TensorFlow first?+
  Learn PyTorch first. As of 2026-2027, the overwhelming majority of research papers, open-source model releases, and Hugging Face ecosystem tools ship PyTorch implementations first or exclusively. PyTorch's eager execution model also makes debugging and learning far more intuitive than TensorFlow's historically graph-based approach. TensorFlow (via Keras 3) remains relevant for certain production and mobile deployment pipelines (TensorFlow Lite, TensorFlow.js), so it is worth a few weeks of exposure once you are comfortable in PyTorch, but it should not be your first framework in 2026.
• What is the difference between deep learning and machine learning as career paths?+
  Classical ML roles (data scientist, ML engineer at most non-frontier companies) lean on gradient boosting, regression, and statistical modelling for structured/tabular data, where deep learning often underperforms simpler methods. Deep learning roles concentrate in computer vision, NLP/LLMs, speech, generative AI, and research positions at AI labs, where unstructured data (images, text, audio, video) dominates. The skill sets overlap substantially - evaluation, experimentation discipline, and production engineering are shared - but deep learning roles demand comfort with GPU training, large model architectures, and often research paper literacy that classical ML roles do not require to the same degree.
• Is it worth learning to build a transformer from scratch if I can just use Hugging Face?+
  Yes, unambiguously. Being able to call model.from_pretrained() and being able to explain, debug, and modify what happens inside that call are different skill levels, and interviewers at every serious AI company test for the latter. Implementing multi-head attention, positional encodings, and a full transformer block from scratch in raw PyTorch - without looking at reference code - is the single most valuable exercise in this entire roadmap. It is also what separates candidates who can only fine-tune from candidates who can debug a broken training run, modify an architecture, or reason about why a model is failing.
• How do I keep up with how fast deep learning research moves?+
  Accept that you cannot read everything, and instead build a filtering system. Subscribe to arXiv cs.LG and cs.CL RSS feeds and skim titles and abstracts daily - this takes under ten minutes. Follow Papers With Code (paperswithcode.com) for benchmarked state-of-the-art results with linked implementations. Hugging Face's blog and model cards are usually the fastest accessible explanations of new open-weight releases. Following a curated set of researchers on X/Twitter or Bluesky remains one of the highest-signal ways to see what the field considers important in near real time, since papers are discussed within hours of release. Prioritise depth on foundational architectures over breadth on every new paper - the fundamentals (attention, normalisation, optimisation) explain 90% of what looks new.
• What GPU or compute setup do I need to learn deep learning?+
  For learning fundamentals - MLPs, small CNNs, small RNNs - a free-tier Google Colab or Kaggle Notebooks GPU (T4-class) is entirely sufficient. For fine-tuning small-to-mid transformers (under ~1B parameters) with parameter-efficient methods like LoRA, Colab Pro or a single consumer GPU (RTX 3090/4090, 24GB VRAM) will get you far. For pretraining from scratch, large-scale fine-tuning, or working with models above a few billion parameters, you will need cloud GPU rental (Lambda Labs, RunPod, Vast.ai, or major cloud providers) - budget matters more than owning hardware at this stage. Do not let compute access block you from starting: the fundamentals phase requires almost none.
• Should I specialise in NLP, computer vision, or another domain?+
  Choose based on genuine interest rather than perceived market size, because the field reshuffles quickly and today's hottest specialisation may look different in eighteen months. That said, as of 2026-2027: NLP and LLM-adjacent roles (fine-tuning, RAG, agents, evaluation) have the broadest job market. Computer vision retains strong demand in autonomous systems, robotics, medical imaging, and manufacturing quality control. Multimodal AI (models that jointly handle text, image, audio, video) is the fastest-growing frontier-lab research area. Speech and audio has resurged with real-time voice agents. If undecided, start with the transformer architecture regardless of domain - it now underlies state-of-the-art work in vision, language, speech, and even biology, so the investment transfers everywhere.
• How is deep learning used outside of NLP and computer vision?+
  Extensively, and this is where less-crowded, high-impact opportunities often exist. Graph neural networks power fraud detection, drug discovery, and recommendation systems built on relational data. Deep reinforcement learning drives robotics, game AI, and increasingly LLM alignment (RLHF, RLAIF). Deep learning models AlphaFold-style structure prediction in biology and materials science. Time-series transformers are used in forecasting and anomaly detection for finance and industrial systems. Diffusion models extend well beyond image generation into audio synthesis, video generation, and even molecule design. This roadmap's later phases cover each of these directions.
• What is the realistic timeline to become job-ready in deep learning?+
  For someone starting with solid classical ML and Python fundamentals already in place, 14–20 months of consistent, focused effort (20–30 hours/week) is realistic to reach a genuinely competitive level for deep learning engineer or applied scientist roles. This is longer than many "learn deep learning in 3 months" claims suggest, but it reflects the field's actual depth: neural network fundamentals, CNNs, RNNs, transformers, and a specialisation each require real mastery, not surface familiarity. Software engineers transitioning from adjacent fields can sometimes compress this; complete beginners to both programming and mathematics should expect it to take longer, and should start with our Machine Learning Roadmap first.
• How do I prepare for deep learning and LLM engineering interviews?+
  Deep learning interviews test differently from classical ML interviews: expect to derive backpropagation on a whiteboard, explain why LSTMs solve vanishing gradients, implement attention from memory, and reason about architecture choices under constraints (latency, memory, data). Practise implementing a transformer block from scratch repeatedly until it is automatic. Understand training dynamics deeply enough to diagnose a loss curve without running code. Read the model cards and technical reports for major open-weight releases (Llama, Mistral, Gemma) to understand real engineering tradeoffs. Our ML Interview Guide covers the broader interview process end-to-end, including system design and behavioural rounds, and pairs directly with the technical depth built in this roadmap.

Comprehensive Resource List

Free Courses & Learning Platforms

Recommended Books

Key Websites, Tools & Libraries

Conclusion: Your Deep Learning Journey Starts Now

Deep learning sits at the centre of the most important technology shift of this decade. This roadmap provides a structured, honest path from a single artificial neuron to the transformer, LLM, and diffusion architectures defining the current frontier. But no roadmap replaces action.

Start today. Pick Phase 0, confirm your fundamentals, then move into Phase 1 and implement backpropagation by hand. Write code before reading more theory. Build projects. Share your work. Engage with the research and open-source community. The best way to learn deep learning is to train models, break them, and figure out why.

The timeline is 14–20 months. This is longer than most "learn deep learning fast" claims, but it reflects the field's genuine depth - CNNs, RNNs, transformers, generative models, and a specialisation each demand real mastery. Skipping the from-scratch exercises to move faster is the single most common way learners end up with fragile, surface-level knowledge that fails under interview or production pressure.

Finally: this field rewards curiosity as much as discipline. The architectures are elegant, the open problems are genuinely unsolved, and the pace of progress means there has never been a better time to build deep technical depth. And when you are ready to turn this knowledge into a job offer, our ML Interview Guide is the natural next step.

Next Steps

• Confirm classical ML fundamentals are solid - Machine Learning Roadmap if not
• Pick a start date and commit to a schedule (20–30 hours/week)
• Set up a free-tier Colab or Kaggle GPU environment and run your first PyTorch tensor operation today
• Join a learning community (Discord servers, Hugging Face forums, local meetups)
• Build in public - share your from-scratch implementations and training runs openly
• Never stop reading - the architectures shift, but attention, gradients, and optimisation remain the throughline