This deep learning roadmap shows how to progress from tensors and gradient descent to neural networks, CNNs, sequence models, attention, and transformers. Use it as a learning tracker: complete each stage, build a small exercise, record what still feels unclear, and revisit the checkpoints as tools and model terminology change.
Overview
Deep learning is easier to learn when its concepts are studied in sequence rather than as a collection of disconnected tutorials. The central path is simple: understand how data is represented, learn how a model adjusts its parameters, build basic neural networks, then specialize in architectures designed for images, sequences, and language.
You do not need to master every mathematical proof before writing your first model. However, you should be comfortable with the ideas behind vectors, matrices, functions, derivatives, probability, and optimization. Python, NumPy, and basic data handling are also useful prerequisites. If Python, supervised learning, or evaluation metrics are still unfamiliar, begin with a broader machine learning roadmap for beginners before starting this sequence.
The roadmap below is framework-aware without depending on one specific library. In practice, learners commonly use a notebook environment, Python, NumPy, a deep learning framework such as PyTorch or TensorFlow, and a dataset library. Interfaces change, but the underlying learning questions remain stable: What is the input? What does the model predict? How is error measured? Which parameters are updated? How do you know the model generalizes?
What to track
Use the following table as a checklist. Do not mark a topic complete merely because you watched a lesson. A stage is more useful when you can explain it in plain language, implement a small example, and identify one way the result could be misleading.
| Stage | Core ideas | Small practice exercise | Ready-to-move-on check |
|---|---|---|---|
| 1. Tensors and data | Scalars, vectors, matrices, tensors, shapes, dimensions, batches, normalization, and train-validation-test splits. | Create tensors with different shapes, perform basic operations, and inspect how a batch moves through a model. | You can explain the shape of every input and output and identify a likely shape mismatch. |
| 2. Gradient descent | Parameters, loss functions, gradients, learning rate, optimization, and the difference between training and inference. | Fit a line to a small dataset using a manual update loop, then compare it with an optimizer provided by a framework. | You can explain why a model needs a loss function and what a gradient update changes. |
| 3. Neural networks | Layers, weights, biases, activations, forward passes, backpropagation, epochs, batches, and overfitting. | Train a small multilayer perceptron on a simple classification dataset and plot training and validation loss. | You can diagnose whether poor results suggest underfitting, overfitting, weak data preparation, or an unsuitable metric. |
| 4. Convolutional neural networks | Convolution, kernels, channels, feature maps, pooling, padding, stride, and image classification. | Build a CNN for a small image dataset. Inspect a few filters or intermediate feature maps rather than viewing accuracy alone. | You can describe why convolution is useful for local visual patterns and how input dimensions change across layers. |
| 5. Sequence models | Ordered data, token or feature sequences, recurrent networks, hidden states, and long-range dependencies. | Train a basic sequence model for next-step prediction or text classification, then compare results with a non-sequential baseline. | You can explain why sequence order matters and why a simple baseline is useful for comparison. |
| 6. Attention | Queries, keys, values, attention weights, context, masking, and the value of relating one position to another. | Calculate attention over a short sequence with small, interpretable vectors. Trace which positions receive the most weight. | You can explain attention without treating it as a synonym for intelligence or as an automatic explanation of a prediction. |
| 7. Transformers | Self-attention, positional information, encoder and decoder roles, tokenization, embeddings, and pretraining or fine-tuning. | Use a small pretrained model for classification or text generation, document the inputs and outputs, and test several edge cases. | You can distinguish a model architecture from a task, a pretrained checkpoint from training from scratch, and a demonstration from a reliable evaluation. |
Keep a short learning log for each stage. Record the dataset, model configuration, metric, result, error pattern, and next experiment. This turns isolated exercises into evidence of progress and can later support AI portfolio projects or a technical portfolio.
Cadence and checkpoints
A practical pace is more valuable than an ambitious schedule that leaves gaps. For a first pass, give yourself enough time at each stage to alternate between explanation, implementation, and review. A useful weekly pattern is:
- Learn: read or watch one focused lesson and write a five-sentence explanation without copying its wording.
- Implement: reproduce a small example, preferably with a deliberately simple dataset.
- Inspect: check tensor shapes, loss curves, predictions, errors, and a baseline result.
- Reflect: write down what changed, what failed, and what experiment would test your current assumption.
At the end of every two or three stages, pause for a checkpoint rather than immediately adding a harder architecture. Rebuild one earlier exercise from a blank notebook, change one variable, and explain the result. If you cannot identify the input shape, target, loss, evaluation method, and main failure mode, spend more time on the current stage.
Framework examples should be reviewed periodically because APIs, recommended workflows, and model-loading methods can change. Keep your notes focused on durable concepts, then add a separate section for library-specific commands. This makes an older course or tutorial easier to adapt instead of treating every changed function name as a new subject.
How to interpret changes
Improvement is not the same as a higher training score. Track at least one training measure, one validation measure, the chosen task metric, runtime or resource constraints, and representative errors. A model that performs well on familiar examples but fails on slightly different inputs may have memorized the training data rather than learned a useful pattern.
When results change, alter one meaningful factor at a time where possible. Check the data split before changing the architecture. Check labels and preprocessing before increasing model size. Compare against a simple baseline before concluding that a new model is better. For classification, inspect confusion patterns instead of relying only on a single aggregate score. For generation, examine factuality, repetition, relevance, and consistency with the task.
Pay attention to reproducibility. Save the data version or source, preprocessing steps, hyperparameters, random seed when relevant, framework version, and evaluation code. These details make it possible to tell whether a change came from a real improvement, a different sample, or a changed environment. For a broader view of how experiments become dependable systems, use the production machine learning workflow checklist.
Do not skip the conceptual bridges. CNNs are not simply “neural networks for images,” and transformers are not simply “large language models.” They are architectural ideas that can support different tasks. Learn what problem each design addresses, what assumptions it makes, and what trade-offs it introduces.
When to revisit
Return to this roadmap monthly while you are actively learning and quarterly once the sequence becomes part of your reference library. Revisit sooner when you begin a new project, change frameworks, adopt a pretrained model, or encounter a result you cannot explain. The most useful update is usually not a longer list of models; it is a clearer exercise, a corrected code example, or a better checkpoint question.
Use this final action plan:
- Choose the first incomplete stage, not the most fashionable topic.
- Set up a small, reproducible notebook with a baseline and a clear evaluation metric.
- Complete the practice exercise and save the result in your learning log.
- Explain the concept without notes, then identify one limitation of your experiment.
- Move forward only when you can connect the stage to the next one.
- Review your notes each month and update framework-specific instructions when they no longer match your environment.
If mathematics is slowing your progress, study only the concepts needed for the current experiment and return to formal detail later. The companion guide on learning deep learning without getting lost in the math can help you maintain that balance. The goal is not to finish a list once; it is to build enough understanding to choose, test, and explain deep learning methods responsibly.
