Start Here · Learning Paths and Recommended Textbooks
Navigate: this page and this track: Navigate: this page and this track
On this page
- What you’ll learn1 min
- The big picture3 min
- How a tutorial page works1 min
- Choose your entry route1 min
- Suggested learning paths by goal2 min
- Run the code2 min
- Your first CPU experiment1 min
- Choose one main textbook3 min
- Read textbooks, surveys and papers differently1 min
- A sequence of small milestones1 min
- Key takeaways1 min
- Exercises2 min
- References
Foundations
What you’ll learn
- How the site’s eight tracks relate to each other and what each one is for.
- How to read a tutorial page: level, prerequisites, the track rail, notebooks and the playground.
- Which learning path fits your background (new to programming, rusty mathematics, already training networks) and your goal (vision, theory, generative models, language, world models).
- How to set up a small Python environment and run the code blocks and notebooks on a CPU.
- Which main textbook to pair with each track, and how to read textbooks, surveys and papers differently.
- How to turn reading into small, checkable milestones.
The big picture
You do not need to finish every mathematical topic before touching an image. You do need to know what each operation assumes. The fastest way to learn is to start from a question you can test: “Why does blur remove an edge?”, “Does a classifier still work on images from a new camera?”, or “What changes when a model predicts the next token instead of a class?”
The site is organized into eight tracks. A track is an ordered sequence of tutorials on one theme. The numbering describes the role of each track, not a rule that you must complete one before entering another.

| Track | Central question | Contents | A useful first outcome |
|---|---|---|---|
| Foundations · start | What are the data? | this page and Images as Arrays | inspect an image’s shape, dtype and coordinate convention |
| Image Processing (IP) · entry | How can we transform or measure an image? | IP 01–13, from fundamentals to pattern classification | explain a filter and its boundary behavior |
| NLP · entry | How are text and language modeled? | NLP 01–12, from the introduction and linguistic essentials through embeddings, RNNs, Transformers and BERT to syntactic and semantic tasks | build and evaluate a small language application |
| Pattern Recognition (PR) · entry | How can features support decisions under uncertainty? | PR 01–10, from Bayes decisions to a recognition capstone | compare classifiers with a valid train/test split |
| Machine Learning (ML) · core | How are representations, predictors and generators learned? | ML 01–11, the math chapters ML 01A–01C, and ML 06A on factor models and autoencoders | train and evaluate a small model |
| Deep Learning for Computer Vision (DLCV) · core | How do learned models solve visual tasks? | DLCV 01–14: recognition, geometry, restoration, generation, world models and robustness | understand a classification or detection pipeline end to end |
| Optimization (OPT) · theory | How can we model and solve constrained decisions? | OPT 01–08, from convex sets to solvers and applications | formulate a convex problem and check its optimality conditions |
| Information Theory (IT) · theory | What are the limits of representing and communicating uncertainty? | IT 01–08, from entropy to coding, channels, rate distortion and networks | calculate entropy and explain a compression or communication limit |
How they connect, in one paragraph: Image Processing treats an image as a signal and designs operations by hand. Pattern Recognition adds statistics and decision theory: given features, how should we decide, and how sure can we be? ML/DL replaces hand-designed features with learned ones and supplies the shared machinery (losses, optimization, architectures, generative models) used everywhere else. DL for Vision applies that machinery to concrete visual tasks, and its restoration and enhancement chapters lean on the image-formation ideas from Image Processing. NLP reuses the same probability, optimization and Transformer ideas with text as input. Optimization develops the modeling rules, constraints, duality and numerical methods behind estimation and training. Information Theory explains uncertainty, coding and communication limits; its entropy and divergence concepts connect classification, language modeling and compression.
How a tutorial page works
Every tutorial follows the same layout, so once you know one page you know them all.
- Level pill. Beginner, intermediate or advanced. The ML math chapters and the first IP tutorials are beginner; the DLCV tutorials assume you already know CNNs and backpropagation.
- Needs. Under the title, a Needs line links the tutorials that the page assumes. Prerequisites are language independent, so the Chinese and English pages share them. If a Needs link is unfamiliar, read that page first, or at least its Key takeaways.
- Track rail. The left column lists every tutorial in the current track in order; Previous and Next links at the bottom follow the same order.
- Sections. Each tutorial opens with What you’ll learn and an Explain like I’m five box, then develops each topic in two passes: a plain-language statement first, then the precise version with equations and code. It ends with Key takeaways, Exercises (hints are folded; try before you open them) and numbered References, cited in the text as [1], [2] and so on.
- Notebook buttons. A tutorial that has a companion notebook shows an Open in Colab pill next to its title and a View notebook link at the end. Currently ML 03 has one (convolution and image filtering).
- Interactive labs. Many pages embed a live experiment that runs a real algorithm on a real image or dataset in your browser: filters, Fourier transforms, thresholds, nearest neighbors and more. Each lab asks you to predict the outcome first, then lets you check it. All of them also live on the Playground page.
- Search and language. The search page finds tutorials and blog posts in the language you are reading; the language switch in the header jumps to the same page in the other language. If a page has not been translated, the Chinese site shows the English version with a notice.
Choose your entry route
Pick the description that fits you best. The routes overlap on purpose.
If programming is new. Learn Python functions, loops, list and array indexing, and basic plotting first. Then read Images as Arrays and IP 01. Make a synthetic image, inspect its rows and columns, and explain why adding two uint8 images can overflow. Continue with IP 02 and IP 03, which are written so that every equation has a matching NumPy line.
If you can code but mathematics feels rusty. Read ML 01 for the vocabulary of learning, then the three math chapters: linear algebra, probability and information theory and numerical computation. They follow the “applied math” part of Goodfellow, Bengio and Courville [7] and pair each idea with a short NumPy check. Aim to be able to check matrix shapes, interpret a conditional probability and spot a numerically unstable calculation.
If you know introductory probability and linear algebra. Start PR 01 for statistical decisions and classical methods, or ML 02 for learned representations. Return to the math chapters only when a derivation reveals a specific gap.
If you already train neural networks. Skim ML 03 and ML 05, then pick an application chapter in DL for Vision, and pair it with ML 11 on evaluation and deployment.
Suggested learning paths by goal
Once you have an entry point, choose a goal. Each path is a reading order, typically eight to twelve tutorials. Read each page’s Needs line to fill gaps as they appear.
| Goal | Suggested order |
|---|---|
| Classical image processing | Images as Arrays → IP 01–05 (fundamentals, filtering, frequency domain, restoration) → IP 06–09 (color, wavelets, compression, morphology) → IP 10–13 (segmentation, active contours, features, classification) |
| Statistical pattern recognition | ML 01A, ML 01B → PR 01 → PR 02 (density estimation) → PR 03 (linear models) → PR 04 (kernels) → PR 05 (features) → PR 07 (clustering, EM) → PR 08 (approximate inference) → PR 09 (ensembles, validation) → PR 10 |
| Deep learning for vision | ML 01 → ML 01A–01C → ML 02 → ML 03 → ML 05 → DLCV 01 → DLCV 02 → DLCV 03 → choose DLCV 09 restoration or DLCV 07 tracking → ML 11 |
| Generative models | ML 01B → ML 02 → ML 06 → ML 06A → ML 07 → ML 08 → ML 09 → ML 10 |
| Language | NLP 01 → NLP 02 → NLP 03–04 (neural networks, word embeddings) → NLP 05–06 (RNNs, sequence labeling) → NLP 07–09 (attention and Transformers, seq2seq, language modeling) → NLP 10–11 (BERT, classification) → NLP 12; add ML 02 and ML 04 for network and sequence-model foundations |
| Convex modeling and solvers | ML 01A, ML 01C → OPT 01 → OPT 02–04 (functions, programs, duality) → OPT 05–07 (estimation, numerical methods, constrained solvers) → OPT 08 |
| Information, compression and communication | ML 01B → IT 01 → IT 02–03 (typicality, source coding) → IT 04–06 (capacity, Gaussian channels, rate distortion) → IT 07–08 (statistical decisions, networks) |
| World models | ML 04 → ML 05 → ML 07 → ML 08 → DLCV 13 |
A realistic pace is one tutorial per week if you run the code and do two exercises; a long tutorial can take two weeks. Speed matters less than being able to explain each page’s key takeaways in your own words.
Run the code
The website and the Python examples use separate environments. You can read the site without installing anything. To run the code you need Python; to preview the website itself you need Node.
A Python environment for the tutorials
Create one dedicated virtual environment for all tutorials. Python 3.11 or newer is a practical starting point; check each package’s requirements if you use a different version.
Code · Bash · 4 lines
python3 -m venv .venv-study
source .venv-study/bin/activate
python -m pip install --upgrade pip
python -m pip install numpy scipy matplotlib scikit-learn scikit-image opencv-python PyWavelets jupyterlabOn Windows, activate with .venv-study\Scripts\Activate.ps1 in PowerShell. These packages cover the introductory array and classical-learning examples. Neural-network chapters also use PyTorch, and specialized examples may name additional dependencies. Install PyTorch with the command produced by its official installation selector [11]; choose the CPU build if you have no GPU. Every example on the site is sized to run on a laptop CPU in seconds to about a minute.
Running a code block
Some examples are self-contained; others deliberately build on earlier blocks in the same chapter. In Images as Arrays, for example, load gray and rgb in the first block before running the slicing examples. In the PR 10 capstone, run the main workflow in order so later blocks use the original development/test split. Use a fresh notebook kernel for a new chapter, and restart and run all cells before trusting a saved result. An undefined name usually means an earlier setup block has not run; it is not a reason to replace the variable with unrelated data. assert statements, where provided, check specific claims; they are not a guarantee that every possible input is supported.
A good habit is to change one thing and re-run: a kernel size, a learning rate, a random seed. The exercises suggest which knob to turn.
Notebooks and Colab
A tutorial with a companion notebook has an Open in Colab button. Colab runs the notebook in your browser on a hosted machine, with NumPy, OpenCV, scikit-image and Matplotlib already installed, so nothing needs to be set up locally. To run the same notebook locally, download it from the View notebook link, then start jupyter lab inside the activated environment and open the file. The notebooks live in the repository’s notebooks/ folder.
Previewing the website (optional)
Only needed if you want to change the site. The repository requires Node 22.12 or newer [12]:
Code · Bash · 2 lines
npm install
npm run devThe development server prints a local address. Tutorials are MDX files under src/content/tutorials/<lang>/<track>/.
Your first CPU experiment
This complete example creates its own image, adds noise and smooths it. No download is needed.
Code · Python · 15 lines
import numpy as np
import cv2
rng = np.random.default_rng(0)
clean = np.zeros((32, 32), dtype=np.float32)
clean[8:24, 8:24] = 1.0
noisy = clean + rng.normal(0, 0.1, clean.shape).astype(np.float32)
smooth = cv2.GaussianBlur(noisy, (5, 5), 1.0,
borderType=cv2.BORDER_REFLECT_101)
print("Shape and type:", smooth.shape, smooth.dtype)
print("Noise-region standard deviation:",
noisy[:5, :5].std(), smooth[:5, :5].std())
print("Across the edge:", np.round(smooth[16, 5:12], 3))
assert smooth.shape == clean.shape
assert np.isfinite(smooth).all()The output shows two effects. The standard deviation in the flat, all-background corner drops from about 0.074 to about 0.026: smoothing averages away noise. Across the edge at column 8, the values now ramp from about 0.04 to 0.93 over three or four pixels instead of jumping from 0 to 1: smoothing also spreads a sharp transition. A lower noise estimate therefore does not mean every important detail improved. IP 03 explains why, and Exercise 2 asks you to measure the trade-off.
Choose one main textbook
Use one main book for continuity and a second one for a different explanation of the same idea. The links point to author or publisher pages, with access conditions as described there. This is a curated starting set, not a ranking.
| Need | Recommended book | How to use it |
|---|---|---|
| Mathematical preparation | Deisenroth, Faisal and Ong, Mathematics for Machine Learning [1] | start with linear algebra, matrix decompositions, vector calculus and probability; apply them through regression and PCA |
| Image operations | Gonzalez and Woods, Digital Image Processing, 4th ed. [2] | pair image fundamentals, spatial and frequency filtering, restoration and segmentation with the DIP track |
| Pattern Recognition, main text | Theodoridis and Koutroumbas, Pattern Recognition, 4th ed. [3] | follow classifier design, features and clustering; work the problems rather than only reading summaries |
| Pattern Recognition, companion | Bishop, Pattern Recognition and Machine Learning [4] | revisit the same topics through probability, latent variables and graphical models |
| A first modern DL text | Prince, Understanding Deep Learning [5] | connect diagrams, mathematics and the accompanying notebooks for networks and generative modeling |
| Another modern DL explanation | C. M. Bishop and H. Bishop, Deep Learning: Foundations and Concepts [6] | use its probabilistic presentation to strengthen the concepts behind architectures and training |
| DL foundations and reference | Goodfellow, Bengio and Courville, Deep Learning [7] | Part I (applied math) matches ML 01A–01C; later chapters cover optimization, CNNs, sequence models and representation learning |
| Computer vision beyond classification | Szeliski, Computer Vision: Algorithms and Applications, 2nd ed. [8] | connect image formation, motion, geometry, recognition and reconstruction |
| Probabilistic machine learning | Murphy, Probabilistic Machine Learning: An Introduction [9] | a modern, probability-first reference for the ML and PR tracks |
| NLP applications, main text | Hagiwara, Real-World Natural Language Processing [13] | follow the application workflow, text classification, sequence models, attention, pretrained models, training practices and deployment |
| NLP linguistic foundations, companion | McRoy, Principles of Natural Language Processing [14] | study syntax, grammars, semantics, discourse, retrieval, generation and translation alongside the corresponding NLP chapters |
| Language and text, supplementary | Jurafsky and Martin, Speech and Language Processing, 3rd-edition draft [10] | deepen selected topics in tokens, n-grams, classification, embeddings, Transformers and evaluation |
| Convex optimization | Boyd and Vandenberghe, Convex Optimization [15] | OPT 01–05 follow modeling and applications in Chapters 1–8; OPT 06–08 develop numerical methods in Chapters 9–11 and modern extensions |
| Information theory | Cover and Thomas, Elements of Information Theory, 2nd ed. [16] | follow entropy and typicality through source/channel coding, continuous variables, rate distortion, statistical decisions, universal coding and networks |
For the Pattern Recognition track, Theodoridis and Koutroumbas [3] and Bishop’s PRML [4] are the two core references. Read Theodoridis for a systematic recognition pipeline, then compare Bishop’s probabilistic treatment of the same problem. Their publication dates do not weaken Bayes decision theory or Gaussian models; turn to newer papers when the architecture, data scale or application has changed.
If you choose just one deep learning introduction, start with Prince [5] and use this site’s math chapters as needed. Choose Bishop and Bishop [6] if you prefer a sustained probabilistic viewpoint. Goodfellow et al. [7] remains a valuable foundation, but its 2016 edition predates Transformers in vision, diffusion models and foundation models; the ML track covers those.
The NLP track uses Hagiwara [13] and McRoy [14] as its two core books. Hagiwara connects models to applications; McRoy supplies the linguistic and symbolic concepts needed to understand what a language system is trying to represent. Read both around the same problem: a classifier needs a data workflow, but a parser or dialogue system also needs an explicit account of linguistic structure. Newer papers supplement their 2021 editions.
For Optimization, use Boyd and Vandenberghe [15] to learn which problem transformations preserve convexity and what an optimality certificate means. For Information Theory, use Cover and Thomas [16] to distinguish an achievable construction from a bound that no construction can beat. These tracks extend the introductory mathematics in ML 01B–01C; their book chapter maps appear within each tutorial.
The Jurafsky and Martin draft changes over time; its current release is dated August 19, 2026 [10]. Record the release date when you make chapter notes, because chapter numbering can move between versions. Likewise, record textbook edition numbers so that exercise references stay reproducible.
Read textbooks, surveys and papers differently
A textbook gives definitions and a coherent sequence. Re-derive one equation, run a tiny example and solve one exercise before moving on.
A survey or review gives a map of alternatives, assumptions and open questions. Each tutorial’s Modern view section summarizes several. When you read one, make a table with the prediction target, learning objective, required data, compute and evaluation of each method it covers. Check its coverage date: “recent” means recent to its authors.
An original paper supplies one method and its evidence. Read the problem, the method, the experimental protocol and the limitations. Trace an important claim to the actual table or ablation that supports it. Knowing what changed relative to a fair baseline is more useful than knowing the method’s name.
Keep a reading note with five entries: the question, the mathematical objects, the main assumption, the experiment that tests it, and one remaining doubt. The reference lists in each tutorial suggest focused next readings; you do not need to read every cited paper before running the code.
A sequence of small milestones
- Represent data: inspect an image and explain its axes, range and dtype.
- Transform data: implement one filter, compare it with a library function and account for the boundaries.
- Make a decision: fit a simple classifier with preprocessing learned only from the training data.
- Learn features: train a small neural network and justify its loss and validation choice.
- Study a modern method: reproduce a mechanism such as attention, masking or noising on synthetic data.
- Finish a small project: report a baseline, independent test results, failure cases and limitations.
Move on when you can explain the previous milestone without copying its wording. A modest experiment with a clean comparison teaches more than a large model whose data and evaluation you cannot inspect.
Key takeaways
- Eight tracks: Foundations, Image Processing, NLP, Pattern Recognition, ML/DL, DL for Vision, Optimization and Information Theory. They feed each other; none has to be finished before another is started.
- Each page’s Needs line, level pill and track rail tell you where it sits; use them instead of reading everything in order.
- Choose an entry route by background and a learning path by goal; one tutorial per week with code and exercises is a sustainable pace.
- Examples are designed for CPU study. Run dependent blocks in chapter order, keep each chapter in its own notebook, and install additional packages when a specific example requires them.
- Pair each track with one main textbook and one companion, and read textbooks, surveys and papers for different purposes.
Exercises
- Plan. Pick an entry route, a learning path and a main textbook. Write the question your first experiment will answer and a concrete result that would count as progress.
Hint
Keep the question small enough to test on a CPU in one sitting, for example “How much does a 5×5 Gaussian blur reduce noise in flat regions, and how much does it widen an edge?” Progress is a number you can measure, not a feeling.
- Kernel sweep. Change the smoothing example to kernel sizes 3, 5 and 9 (raise with the kernel, for example 0.8, 1.0 and 2.0). Report the flat-region standard deviation and the number of pixels the edge takes to rise from 0.1 to 0.9.
Hint
Keep the random seed and the noisy image fixed so only the filter changes. Noise should fall and the edge width should grow together: that is the bias–variance trade-off of linear smoothing.
- Read a page’s metadata. Open ML 02. What is its level, what does its Needs line point to, and which tutorial comes next in the track rail?
Hint
The Needs line is right under the title. Follow it back until you reach a page whose prerequisites you already know; that chain is your personal reading order.
- Classify a source. Select one reference from any tutorial and classify it as textbook, survey, original paper or software documentation. What question is that source best suited to answer?
Hint
A survey answers “what are the options and how do they compare?”; an original paper answers “does this specific change help, and under what protocol?”; documentation answers “what does this function actually compute?”
- Split by the right unit. Sketch a training/validation/test split for a dataset containing many frames from each of 50 videos. Explain why splitting individual frames at random can be misleading.
Hint
Neighboring frames are nearly identical, so a random frame split puts near-duplicates in both training and test sets and inflates the test score. Split by video (or by recording session) instead.
References
- M. P. Deisenroth, A. A. Faisal and C. S. Ong, Mathematics for Machine Learning, Cambridge University Press, 2020. Book site
- R. C. Gonzalez and R. E. Woods, Digital Image Processing, 4th ed., Pearson, 2018. Book site
- S. Theodoridis and K. Koutroumbas, Pattern Recognition, 4th ed., Academic Press, 2009. Companion site
- C. M. Bishop, Pattern Recognition and Machine Learning, Springer, 2006 (official PDF available). Book page
- S. J. D. Prince, Understanding Deep Learning, MIT Press, 2023. Book and notebooks
- C. M. Bishop and H. Bishop, Deep Learning: Foundations and Concepts, Springer, 2024 (free online version). Book site
- I. Goodfellow, Y. Bengio and A. Courville, Deep Learning, MIT Press, 2016. Book site
- R. Szeliski, Computer Vision: Algorithms and Applications, 2nd ed., Springer, 2022 (PDF for personal use). Book site
- K. P. Murphy, Probabilistic Machine Learning: An Introduction, MIT Press, 2022. Book site
- D. Jurafsky and J. H. Martin, Speech and Language Processing, 3rd ed. draft, release of August 19, 2026. Draft site
- PyTorch, “Get Started Locally,” installation documentation. Documentation
- Node.js, “Download Node.js.” Download page
- M. Hagiwara, Real-World Natural Language Processing, Manning, 2021. Publisher
- S. McRoy, Principles of Natural Language Processing, open textbook, 2021. Open textbook
- S. Boyd and L. Vandenberghe, Convex Optimization, Cambridge University Press, 2004. Author site and book
- T. M. Cover and J. A. Thomas, Elements of Information Theory, 2nd ed., Wiley, 2006. Publisher
Links and draft dates were checked on October 4, 2026. A companion website does not imply that the complete textbook is free; access conditions are those stated on each site.
Check your understanding
This tutorial has 5 exercises. Can you solve them without opening the hints?
Go to the exercises ↑Next Images as Arrays · 17 min