Start with motion, shape, and analogy.
Each concept opens with a mental model you can carry before the notation starts.
Geometry, routing, density, and flow before formalism.
Study Dot ProductContinuous Function
Start with Attention To Serving
Learn one frontier-AI route first: how attention math becomes KV-cache memory, long-context pressure, and serving tradeoffs through concepts, code witnesses, and a prediction-first lab.
Start Here
How does attention become a serving bottleneck?
Follow one source-scoped path from attention math to KV-cache pressure, then repair the next concept before browsing the full atlas.
01Attention02Efficient Attention03RoPE04FlashAttention05Long Context06LLM Serving
Prediction firstWhich memory symbol should move first?
Open the route labMem_KV = B * N_layers * T * H_kv * d_head * 2 * bytesDomain Atlas
Navigate by mathematical territory
linear-algebra
Linear Algebra
Vectors, matrices, and linear maps: the language of representations, optimization, and modern deep learning.
9 concepts6 demos
Dot ProductMatrix Decompositions: Eigendecomposition, SVD, and Spectral StructureOrthogonality, Projections, and Least-Squares Geometry
calculus
Calculus
Rates of change and accumulation. Calculus is the language behind gradients, optimization, continuous-time dynamics, and why backprop works as efficiently as it does.
6 concepts6 demos
BackpropagationComputation GraphsDerivatives
optimization
Optimization
How we train models: gradients, learning rates, curvature, and the practical tricks that make deep nets converge.
10 concepts5 demos
Adam OptimizerGradient DescentLearning Rate Schedules: Warmup, Decay & Cycling
machine-learning
Machine Learning
The classical supervised-learning spine: models, losses, generalization, evaluation, and the experiment habits that make modern AI results trustworthy.
10 concepts10 demos
Bias-Variance DecompositionClassification Metrics, Thresholds, and CalibrationLinear Regression & Least Squares
probability
Probability
Uncertainty made precise: events, random variables, expectations, and the distributions that models learn.
6 concepts6 demos
Cross-EntropyDistributionsMaximum Likelihood
information-theory
Information Theory
How we measure information and mismatch between distributions: entropy, cross-entropy, KL divergence, mutual information, and why they appear everywhere in ML.
1 concepts1 demos
KL Divergence (Relative Entropy)
attention-transformers
Attention & Transformers
The sequence model backbone: tokenization, self-attention, positional encodings, and the transformer block that powers modern LLMs.
12 concepts12 demos
Scaled Dot-Product Attention & Transformer LayersEfficient Attention at Scale: KV Cache, GQA & FlashAttentionFlashAttention: IO-Aware Attention
representation-learning
Representation Learning
Embeddings and the geometry of meaning: similarity, normalization, contrastive objectives, and why vector spaces become usable interfaces for models.
3 concepts3 demos
Autoencoders and Denoising AutoencodersRepresentation Learning & Embedding GeometrySparse Autoencoders: Feature Dictionaries for Mechanistic Interpretability
generative-models
Generative Models
How models generate: likelihood, latent variables, diffusion/score models, flows, and the training tricks that make sampling work.
5 concepts5 demos
Diffusion, Score-Based Models & Flow MatchingFlow Matching & Rectified FlowsNormalizing Flows: Tractable Density via Invertible Transforms
scaling
Scaling
How loss and capability change with parameters, data, and compute; how to allocate a training budget; and why some abilities appear suddenly at scale.
6 concepts6 demos
Overparameterization & Generalization (Double Descent)Scaling Laws & Emergent Abilities
alignment
Alignment
How we shape model behavior: preference learning, reward modeling, KL-regularized fine-tuning, and the failure modes that appear when you optimize the wrong thing.
5 concepts5 demos
Direct Preference OptimizationKahneman-Tversky OptimizationProcess Reward Models: Step-Level Verifiers for Reasoning
efficiency
Efficiency
How we make models cheaper to train and serve: quantization, distillation, low-rank adapters, sparsity, and the memory/latency tradeoffs that dominate real deployments.
5 concepts5 demos
Efficiency: Quantization, Distillation, LoRA & Sparse MoEKnowledge Distillation: Learning from TeachersPruning: Removing Unnecessary Weights
llm-systems
LLM Systems
How models run in production: prefill vs decode, KV cache memory, batching and scheduling, and the techniques that make latency and throughput practical.
6 concepts6 demos
Decoding & Sampling: Temperature, Top-p & Inference-Time ControlLLM Serving at Scale: Prefill, Decode & Continuous BatchingMoE Serving & Scheduling: Token Dispatch, All-to-All, Disaggregated Parallelism
production-ml
Production ML
The engineering discipline around trustworthy model use: evaluation pipelines, dataset and model versioning, monitoring, drift, reproducibility, and operational tradeoffs.
5 concepts4 demos
Cost and Latency ObservabilityEvaluation Harnesses and Benchmark ContaminationEvaluation Pipelines
Editorial Method
Every page follows the same teaching contract
The site is not an archive of notes. It is a repeatable notebook format for turning abstract ML ideas into something you can reason through from first contact to implementation.
Write the objects down precisely.
Definitions, symbols, and derivations stay close to the intuition instead of replacing it.
Derivatives, KL, vector spaces, and chain rule done step by step.
Study Chain RuleMatch notation to runnable Python.
The symbols on the page become short NumPy or PyTorch fragments you can actually run.
Code mirrors the math instead of hiding it behind frameworks.
Study Adam OptimizerManipulate the system and watch it respond.
Interactive diagrams turn abstract machinery into something you can stress-test, poke, and break.
Attention, diffusion, routing, and serving concepts become explorable.
Study Scaled Dot-Product Attention & Transformer LayersCurated Entries
Start with a thread, not a random page
You can browse the full atlas, but the fastest way in is to follow one editorial thread from prerequisites to modern applications.
track
Foundations First
Build the minimum mathematical language needed to understand optimization and modern model training.
Open track domaintrack
Transformer Systems
Move from attention mechanics to the engineering decisions that make long-context inference work.
Dot ProductScaled Dot-Product Attention & Transformer LayersEfficient Attention at Scale: KV Cache, GQA & FlashAttentionLong Context Engineering: RoPE Scaling, KV Compression & Memory Optimization
Open track domaintrack
Frontier Notebooks
Use the foundations to step into generation, alignment, and inspectable model representations.
Scaled Dot-Product Attention & Transformer LayersSparse Autoencoders: Feature Dictionaries for Mechanistic InterpretabilityDirect Preference OptimizationDiffusion, Score-Based Models & Flow Matching
Open track domainFirst Route Readiness
First route: attention to serving
A new learner should see one concrete path: map or search a claim, inspect the route graph, open Efficient Attention, predict the KV-cache lever, review the claim boundary, and leave a reproduction or repair note attached to the exact object.
HomeStart with a path this browser can remember.
Start the local trail or open the route graph.
01Homenow02Paper Mappernext action03Knowledge Graphnext action04Searchnext action05Attention To Servingnext action+1 more
Scope labels requiredPreview/local where applicable; claim review before comparison; reproduction notes stay object-attached.
No benchmark result, hosted compute, automatic expert review, or live runtime-performance claim is made by this v0.
Paper Mapper
Turn a paper clue into a route, one equation, and one experiment.
Clickable equation
Mem_KV = B * N_layers * T * H_kv * d_head * 2 * bytesThe mapper turns the bottleneck into a calculator, then links the symbols back to attention and serving.
Example route note
What changed from old work?
The paper trades exact key-value retention for a bounded decode-time memory budget. Learn attention first, test the memory curve, then inspect where retrieval quality can break.
Extract equationsFind prerequisitesOpen a labAsk one question
Reader Lenses
One atlas, different depths of use.
A guided route through prerequisites, notation, code, and demos.
Start from a path, predict the demo, then ask the companion to repair the exact gap.
Start foundationsA quick way to inspect the mechanism, assumptions, and executable witness.
Use concept pages as small, testable models before jumping back to papers or experiments.
Inspect a bridgeA teachable sequence with visual hooks, derivation checkpoints, and failure regimes.
Use the same page as a lecture spine: intuition first, then math, code, and manipulation.
Open a lessonLive Proof Loop
Map AI research to a route you can test.
Continuous Function helps a serious learner move from a claim or equation to prerequisite repair, a runnable toy witness, a scoped caveat, and one next question without losing the thread.
01Claim
Map the claim
Paste a specific equation, architecture name, arXiv ID, or short excerpt to find the prerequisite path in the atlas.
02Map
Reveal prerequisites
The graph places the paper inside concepts, equations, prior work, and the ideas the reader should repair first.
03Lab
Run toy witnesses
Small authored examples turn the central mechanism into sliders, curves, tensors, and scoped failure cases.
04Discuss
Ask one sharper question
Discussion prompts attach to the exact concept, equation, lab, or paper claim so the next conversation has a clear anchor.
First Launch Route
Attention To Serving launch route.
The first complete module should help students, engineers, and researchers understand transformer inference from the attention equation to serving tradeoffs.
Open Attention To ServingAsk Beside The Notebook
Specific help attached to the route.
Concept Coach
Breaks down notation, prerequisites, equations, demos, and the current learner question.
Paper Mapper
Maps a pasted claim, equation, arXiv ID, or model-report excerpt to concepts, sources, and caveats.
Toy Witness Guide
Points to authored browser demos and small local examples that test one mechanism at a time.
Claim Scope Review
Separates what the toy witness shows from what depends on sources, scale, or expert review.
Ask About This Object
Guided lessons, rigorous notes, coding practice, and a companion attached to the object you are studying.
Continuous Function should feel like a mathematical playground, a serious course, a code lab, and a patient tutor in the same place. The companion helps learners ask sharper questions, recover missing prerequisites, turn notation into code, and test understanding against the exact equation or live demo in view.
Object Companion
Plan beside the atlas
Choose a path, study a notebook, manipulate the demo, then use the selected object to explain, quiz, connect, or debug the idea.
Context prompt
You are my AI learning companion for Continuous Function. Current context: homepage learning atlas. Learning surface: Continuous Function atlas. What this page says: Choose a path, study a notebook, manipulate the demo, then use the selected object to explain, quiz, connect, or debug the idea. Suggested next step: Pick a track and ask the companion to turn it into a short plan.. Learner goal: Understand the idea. Learner comfort level: New to this. Preferred explanation style: Visual first. Task: Ask me 5 quick questions, then recommend the best Continuous Function learning path for my current level. Answer in a way that helps me learn: ask one clarifying question only if needed, use intuition before notation, and end with one thing I should try on the page.