Full search page →

Start Here · Learning Paths and Recommended Textbooks

FoundationsBeginner17 minUpdated Nov 5, 2026

Navigate: this page and this track: Navigate: this page and this track

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.

Eight-track learning map in four layers: Foundations at the top; then the three entry tracks Image Processing, Natural Language Processing and Pattern Recognition; then Machine Learning feeding Deep Learning for Computer Vision (DLCV); and at the bottom a dashed band of advanced theory, Optimization and Information Theory, with dashed arrows up to DLCV, Machine Learning and Pattern Recognition.
Figure 1 — How the eight tracks fit together. Start with Foundations, then pick an entry track (IP, NLP or PR); Machine Learning and Deep Learning for Computer Vision (DLCV) build on them; Optimization and Information Theory are the advanced theory behind those large topics. Arrows are suggestions, not locks: each tutorial lists its own prerequisites.
TrackCentral questionContentsA useful first outcome
Foundations · startWhat are the data?this page and Images as Arraysinspect an image’s shape, dtype and coordinate convention
Image Processing (IP) · entryHow can we transform or measure an image?IP 01–13, from fundamentals to pattern classificationexplain a filter and its boundary behavior
NLP · entryHow are text and language modeled?NLP 01–12, from the introduction and linguistic essentials through embeddings, RNNs, Transformers and BERT to syntactic and semantic tasksbuild and evaluate a small language application
Pattern Recognition (PR) · entryHow can features support decisions under uncertainty?PR 01–10, from Bayes decisions to a recognition capstonecompare classifiers with a valid train/test split
Machine Learning (ML) · coreHow are representations, predictors and generators learned?ML 01–11, the math chapters ML 01A–01C, and ML 06A on factor models and autoencoderstrain and evaluate a small model
Deep Learning for Computer Vision (DLCV) · coreHow do learned models solve visual tasks?DLCV 01–14: recognition, geometry, restoration, generation, world models and robustnessunderstand a classification or detection pipeline end to end
Optimization (OPT) · theoryHow can we model and solve constrained decisions?OPT 01–08, from convex sets to solvers and applicationsformulate a convex problem and check its optimality conditions
Information Theory (IT) · theoryWhat are the limits of representing and communicating uncertainty?IT 01–08, from entropy to coding, channels, rate distortion and networkscalculate 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.

GoalSuggested order
Classical image processingImages 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 recognitionML 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 visionML 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 modelsML 01B → ML 02 → ML 06 → ML 06A → ML 07 → ML 08 → ML 09 → ML 10
LanguageNLP 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 solversML 01A, ML 01C → OPT 01 → OPT 02–04 (functions, programs, duality) → OPT 05–07 (estimation, numerical methods, constrained solvers) → OPT 08
Information, compression and communicationML 01B → IT 01 → IT 02–03 (typicality, source coding) → IT 04–06 (capacity, Gaussian channels, rate distortion) → IT 07–08 (statistical decisions, networks)
World modelsML 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 jupyterlab

On 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 dev

The 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.

NeedRecommended bookHow to use it
Mathematical preparationDeisenroth, 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 operationsGonzalez 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 textTheodoridis and Koutroumbas, Pattern Recognition, 4th ed. [3]follow classifier design, features and clustering; work the problems rather than only reading summaries
Pattern Recognition, companionBishop, Pattern Recognition and Machine Learning [4]revisit the same topics through probability, latent variables and graphical models
A first modern DL textPrince, Understanding Deep Learning [5]connect diagrams, mathematics and the accompanying notebooks for networks and generative modeling
Another modern DL explanationC. 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 referenceGoodfellow, 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 classificationSzeliski, Computer Vision: Algorithms and Applications, 2nd ed. [8]connect image formation, motion, geometry, recognition and reconstruction
Probabilistic machine learningMurphy, Probabilistic Machine Learning: An Introduction [9]a modern, probability-first reference for the ML and PR tracks
NLP applications, main textHagiwara, Real-World Natural Language Processing [13]follow the application workflow, text classification, sequence models, attention, pretrained models, training practices and deployment
NLP linguistic foundations, companionMcRoy, Principles of Natural Language Processing [14]study syntax, grammars, semantics, discourse, retrieval, generation and translation alongside the corresponding NLP chapters
Language and text, supplementaryJurafsky and Martin, Speech and Language Processing, 3rd-edition draft [10]deepen selected topics in tokens, n-grams, classification, embeddings, Transformers and evaluation
Convex optimizationBoyd 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 theoryCover 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

  1. Represent data: inspect an image and explain its axes, range and dtype.
  2. Transform data: implement one filter, compare it with a library function and account for the boundaries.
  3. Make a decision: fit a simple classifier with preprocessing learned only from the training data.
  4. Learn features: train a small neural network and justify its loss and validation choice.
  5. Study a modern method: reproduce a mechanism such as attention, masking or noising on synthetic data.
  6. 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

  1. 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.

  1. Kernel sweep. Change the smoothing example to kernel sizes 3, 5 and 9 (raise σ\sigma 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.

  1. 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.

  1. 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?”

  1. 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

  1. M. P. Deisenroth, A. A. Faisal and C. S. Ong, Mathematics for Machine Learning, Cambridge University Press, 2020. Book site
  2. R. C. Gonzalez and R. E. Woods, Digital Image Processing, 4th ed., Pearson, 2018. Book site
  3. S. Theodoridis and K. Koutroumbas, Pattern Recognition, 4th ed., Academic Press, 2009. Companion site
  4. C. M. Bishop, Pattern Recognition and Machine Learning, Springer, 2006 (official PDF available). Book page
  5. S. J. D. Prince, Understanding Deep Learning, MIT Press, 2023. Book and notebooks
  6. C. M. Bishop and H. Bishop, Deep Learning: Foundations and Concepts, Springer, 2024 (free online version). Book site
  7. I. Goodfellow, Y. Bengio and A. Courville, Deep Learning, MIT Press, 2016. Book site
  8. R. Szeliski, Computer Vision: Algorithms and Applications, 2nd ed., Springer, 2022 (PDF for personal use). Book site
  9. K. P. Murphy, Probabilistic Machine Learning: An Introduction, MIT Press, 2022. Book site
  10. D. Jurafsky and J. H. Martin, Speech and Language Processing, 3rd ed. draft, release of August 19, 2026. Draft site
  11. PyTorch, “Get Started Locally,” installation documentation. Documentation
  12. Node.js, “Download Node.js.” Download page
  13. M. Hagiwara, Real-World Natural Language Processing, Manning, 2021. Publisher
  14. S. McRoy, Principles of Natural Language Processing, open textbook, 2021. Open textbook
  15. S. Boyd and L. Vandenberghe, Convex Optimization, Cambridge University Press, 2004. Author site and book
  16. 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