A reference shelf with a reading plan

Start with the introduction and types of machine learning.

Follow regression and classification, then contrast their targets with next-token prediction.

Study overfitting and data preparation; look for how information can leak across a split.

Use classification metrics and fairness sections. Move a threshold and describe who benefits and who loses.

Read fairness and production ML systems; choose realistic evaluation slices.

Start with the moving grid and matrix columns. Follow the chapter links to vectors, multiplication, and dot products.

Follow how a tiny input change passes through two composed functions; this is the picture behind multiplying derivatives.

Watch the desired changes travel backward through the digit classifier.

Focus on the chain-rule section; you can skip the longer algebra on a first pass.

Connect that picture to products of local derivatives. Stop once the chain rule feels concrete.

Follow the query/key matching picture and how it changes a token’s embedding.

Start with micrograd. Draw a small computation graph before following the Python implementation.

Compare linear models, nearest neighbors, SVMs, and ensembles using the examples and diagrams.

Use clustering, decomposition, and novelty detection. Compare their assumptions on the same small dataset.

Use the public previous-year videos and useful notes on convolution and vision transformers.

Find multimodal learning in the course schedule and inspect how modalities meet.

Start with audio data and the task overview, then compare ASR and text-to-speech pipelines.

Connect audio representation and chunking to streaming latency.

Start with graph representations and message-passing lectures.

Use embeddings and matrix factorization to see how an objective shapes the space.

Follow candidate generation → scoring → re-ranking.

Follow the noise-to-image notebook. Change the number of sampling steps and inspect the outputs.

Use the tokenizer chapter to compare text with its token IDs.

Find generation strategies and compare outputs using fixed prompts.

Use the architecture lecture for the full transformer block and positional encoding.

Use data, scaling laws, and supervised fine-tuning lectures. Identify the objective and dataset at each stage.

Use data processing and systems lectures to locate CPU/storage bottlenecks.

Use the reinforcement learning lectures to identify rollout and update work.

Watch the tokenization portion and follow one merge example.

Review policy and reward before connecting reinforcement learning to language generation.

Use Unit 1’s agent-environment loop and the first simple environment.

Read the problem setup and contrast its preference loss with the RLHF pipeline.

Look at the low-rank update diagram and the rank experiments.

Read the architecture diagram and motivation for selective state updates before the equations.

Read the architecture and active-parameter explanation.

Use the MLA diagram to contrast latent cache storage with ordinary per-head KV.

Use the introduction and confounding lectures; draw the causal graph before reading the notation.

Use introductory lectures on behavior cloning, value functions, and policy gradients. Trace what data each method needs.

Read the retrieval-plus-generation diagram and identify where retrieved documents enter.

Separate retrieval quality from generation quality in the pipeline.

Compare the workflow patterns with the agent loop. Identify where deterministic code would suffice.

Map each workflow pattern to the number of model/tool calls and its failure path.

Identify tool permissions and human checkpoints in an agent workflow.

Relate peak arithmetic and memory bandwidth to actual work.

Work through the matrix multiplication example and locate the crossover.

Read the sampling loop and KV-cache introduction before the performance sections.

Compare the linear-operation and attention bottleneck sections. Notice how batch size changes the answer.

Use the memory section to separate fixed model cost from per-sequence cache cost.

Follow the cached sampling diagram and the attention bandwidth analysis.

Read continuous batching and compare it with a fixed request batch.

Compare attention costs as context grows; keep prefill arithmetic and decode cache reads separate.

Compare bulk, interactive, and edge objectives before choosing a serving configuration.

Use latency/throughput tradeoffs as the basis of a capacity model.

Revisit the inference-engine design section as a checklist of physical constraints.

Draw what each device holds and what it exchanges at every layer.

Read the forward/backward and memory accounting sections.

Use the virtual-memory analogy and block diagrams. Track two sequences sharing a prefix then diverging.

Follow the memory-hierarchy diagram and tiled algorithm. Focus on which arrays are never stored in HBM.

Read the motivation for mixing decode work with chunks of prefill.

Follow the mixed-batch diagrams and the role of chunk size.

Use its scheduling idea to form your hypothesis.

Read how the evaluation combines first-token and per-token latency constraints.

Read placement and bandwidth assumptions before the goodput plots.

Read the evaluation assumptions and design a counterexample workload.

Follow the draft/verify diagram and rejection correction before reading speedup results.

Find memory pressure, preemption, and concurrency controls.

Read the CUDA graph and compilation guidance for your engine version.

Study the sequence and token-budget controls rather than copying default values.

Read chunked prefill guidance and measure the current scheduler’s behavior.

Study preemption and memory-pressure guidance; identify when a request is recomputed.

Use the same workload to compare engine behavior, with supported settings and explicit versions.

Map that hypothesis to the current engine’s supported controls.

Read the examples and limitations. Distinguish skipped prefill from unchanged decode work.

Use the supported-hardware table and compare weight-only with activation-aware paths.

Read accuracy and scaling-factor guidance before enabling low-precision KV.

Follow context-parallel guidance and supported configurations; identify where communication replaces local work.

Use the deployment guidance to connect model size and topology to parallelism choices.

Read multi-node setup and troubleshooting guidance.

Study expert placement and load-balancing options for the deployed backend.

Read adapter limits, loading, and security considerations.

Find queue, prefill, decode, and end-to-end latency metrics. Map each to a request stage.

Compare engine latency with client-observed latency and end-to-end request timing.

Choose stage metrics and histogram buckets that support your SLOs.

Specify exactly how each service target will be observed.

Inspect supported latency metrics and goodput/SLO options for the installed version.

Read dataset, request-rate, and output-length options; save the exact command and configuration.

Inspect request-rate, burstiness, dataset, and latency options. Read the current version’s metric definitions.

Use the benchmark interface for reproducible traffic.

Read deployment boundaries and untrusted-input/model guidance. Turn each relevant boundary into an enforceable control.

Follow the quickstart request path and identify the engine versus HTTP-server responsibilities.

Find structured outputs and run a small schema example; inspect both validity and latency.

Check supported models and serving features before making a like-for-like comparison.

Follow its reinforcement-learning integrations and locate the inference engine’s role.

Find KV cache offloading and compare storage tiers with GPU residency.

Follow disaggregated serving and the KV-transfer path for your backend.

Find encode-prefill-decode disaggregation and trace its extra handoff.

Use a supported disaggregated deployment recipe after checking hardware and connector requirements.

Inspect how cache overlap competes with current worker load.

Follow the cache-overlap and active-load components of worker selection.

Relate repeated contexts and session traffic to cache reuse and load.

Trace what data moves in each collective and what topology-aware communication means.

Map each training communication step to a collective.

Find profiling metrics and health diagnostics; distinguish activity from useful throughput.

Find GPU health and diagnostic signals to connect application errors with hardware issues.

Add hardware counters only when they help distinguish a suspected bottleneck.

Use CUDA tracing and the timeline views; identify host launches and GPU work.

Capture a short trace at the configuration where your estimate and measurement disagree most.

Inspect the fused-attention tutorial after the paper’s dataflow is clear.

Compare vector addition, fused softmax, and matrix multiplication tutorials.

Start with the programming model and memory hierarchy. Draw where one matrix tile lives.

Connect GPU scheduling to available node resources and placement.

Review GPU requests and node selection before writing the deployment manifest.

Use scale-up/down delays and in-flight request guidance to design a stable control loop.

Study bounded queues and client throttling. Apply the same reasoning to variable-length generation.

Study retry amplification and cascading overload.

Apply bounded-resource reasoning to connections and output buffers.

Connect utilization targets to overload behavior and reserve capacity.

Use the overload chapter to predict retry amplification.

Use the analysis and rollback sections to define measurable release gates.

Adapt canary decision criteria to both model quality and service performance.

Define abort and rollback conditions before the drill.

Finish with release and rollback gates.

Use the index-selection guidance to connect search recall with latency and memory.

Use index selection and the comparison of index types. Track memory, recall, and query time.

Inspect task configuration and result output; identify the prompt and scoring assumptions.

Choose a small task-specific quality set and retain individual outputs.

Build task slices that reveal where the smaller model fails.

Read task configuration and reproducibility guidance; retain examples, not just totals.

Compare hardware partitioning with software sharing and its capacity tradeoffs.

Inspect supported backends and quantized local inference; measure on hardware you have.

Separate the three kinds of state ZeRO partitions.

Follow how optimizer, gradient, and parameter partitioning progressively reduce replicated state.

Read save/load semantics and distributed state handling.

Read the introductory path/velocity picture; leave the derivation for later.

Read the teacher/student setup. Ask which behavior the student learns and where task-specific evaluation is still required.

Use the search, constraint satisfaction, and games chapters. Trace a tiny search tree before comparing algorithms.

Use the Bayes nets and inference chapters. Follow one update of beliefs after an observation.

Use tensors, autograd, and save/load tutorials. Identify what inference can skip compared with training.

Follow the process-isolation explanation. List which dependencies live in the image and which remain on the host.

Inspect architecture and supported optimization features; note model and hardware requirements.