B
Recommended Reading
A question-led map from this introduction into primary papers, tools, systems, and evaluations.
6 min read
Printed pages: 231–256
Categorized reading map
Read to answer the next engineering question
Inference engineering is too broad and changes too quickly for one book to be the endpoint. Use this appendix as a routing layer: choose the category that matches the uncertainty blocking your current decision, read one primary source, reproduce one small result, and record what changed in your model of the system.
AI Engineering by Chip Huyen
Choose this broad survey when the next gap spans the full practice of building applications with foundation models.
Build a Large Language Model (From Scratch)
Sebastian Raschka offers a hands-on route to a detailed understanding of large language model architecture.
AI Systems Performance Engineering by Chris Fregly
Choose this performance-focused text to go deeper on model workloads, GPUs, CUDA, and PyTorch.
Use the book's linked blog as one route to newer implementation notes, while checking dates and applicability to your stack.
Architecture · What computation does the model require?
Start here when a serving symptom is difficult to explain from the outside. Architecture papers reveal sequence dependencies, intermediate state, sparsity, attention traffic, and iterative pipelines that later become hardware and scheduling constraints.
Read the original attention architecture to connect token interactions, parallel training structure, and the autoregressive serving path.
Use the first FlashAttention paper to understand why reducing memory traffic can matter more than reducing the arithmetic count.
Study denoising diffusion to see why image and video generation repeat a model over a schedule instead of emitting one token at a time.
BLIP-2 is a useful bridge for understanding how visual encoders and language models exchange representations without retraining every component together.
Mamba offers a contrasting sequence model for asking which transformer costs are architectural necessities and which are design choices.
Developer tools · Where should I measure or intervene?
Use tool documentation after the model, workload, and target metric are explicit. Compare supported architectures and optimization features, but make the final choice from a reproducible benchmark and profile on the hardware you will operate.
A broad serving baseline for learning continuous batching, paged attention state, and common application programming interfaces.
A serving project worth comparing for model support, structured generation, caching, and mixture-of-experts execution.
NVIDIA's engine documentation exposes architecture-tuned kernels, low precision, and build-versus-runtime trade-offs.
Use the profiler recipe to attribute host and accelerator time only after a stable workload reproduces the target regression.
Explore kernel building blocks when framework-level evidence shows that matrix operation shape, tiling, or precision is the remaining constraint.
Frontier open models · Which capability frontier can I control?
Model publisher collections help scan the available frontier across text, reasoning, vision, audio, image, and video. They are discovery indexes, not deployment approval: verify the exact checkpoint, license, tokenizer, chat template, evaluation record, and engine compatibility.
A model family for studying dense and sparse language-model serving choices across reasoning and general workloads.
A broad family spanning language and multimodal checkpoints, useful for comparing sizes and task-specific variants.
A source of open language and sparse expert models for evaluating capability, size, and serving topology together.
An image-generation family for examining pipeline components, model variants, memory demand, and license constraints.
Includes Whisper checkpoints that ground automatic speech recognition experiments in a widely implemented reference family.
GPU infrastructure · What does the service depend on?
Infrastructure reading connects accelerator limits to scheduling, networking, storage, rollout, and failure recovery. It becomes essential when one benchmark looks good but the fleet cannot deliver the same latency or availability under real traffic.
Use the interconnect overview to understand the topology assumptions behind tensor and expert parallel deployments.
Study the orchestration primitives that place, restart, expose, and roll out stateful GPU-serving workloads.
Designing Data-Intensive Applications
Use the systems text to strengthen reasoning about replication, partitioning, consistency, streams, and failure beyond model execution.
Apply service objectives, error budgets, monitoring, and incident response to inference as a user-facing production dependency.
Optimization research · Which mechanism attacks my bottleneck?
Read optimization research with a baseline and a falsifiable hypothesis. A paper's speedup is conditional on model, request shape, hardware, batch policy, quality tolerance, and implementation maturity; reproduce those conditions before transferring the result.
Paged attention memory management
Read the vLLM systems paper when attention-cache fragmentation or scheduler utilization is the suspected constraint.
Study draft-and-verify generation when decode is serial and extra parallel compute may buy lower per-user token latency.
Activation-aware weight quantization
Use AWQ to examine how calibration and sensitive channels affect the quality-performance trade-off of low-bit weights.
Explore a customizable attention-kernel library when profiles point to serving attention rather than general framework overhead.
A pragmatic disaggregation study
Use the systems analysis to challenge whether separating prefill and decode improves the actual workload after state-transfer costs.
Intelligence evaluation · Did the optimization preserve usefulness?
Quality is a deployment constraint, not a postscript. Public evaluations help expose capability dimensions, but production approval should combine them with task-specific examples, adversarial cases, and human review that mirror the product's real cost of failure.
Massive multitask language understanding
A broad knowledge benchmark useful for learning the strengths and limitations of aggregate academic-task scores.
A compact code-generation reference for studying functional correctness, sampling, and benchmark contamination concerns.
Massive text embedding benchmark
Use MTEB to compare representation models across retrieval, similarity, classification, clustering, and other embedding tasks.
A repository-level software task benchmark that illustrates the gap between isolated code snippets and tool-using workflows.
A route into evaluations of abstraction and generalization that do not reduce capability to familiar language tasks.
Turn reading into evidence
- Write the decision and the uncertainty blocking it in one sentence.
- Read the primary paper or official documentation before relying on benchmark summaries or vendor comparisons.
- Reproduce the smallest relevant claim with your model, request distribution, hardware, and quality checks.
- Record assumptions, versions, workload shape, result, and rollback criteria so the evidence survives the next tool release.
Source map
Orientation
Printed page 233 explains why continued learning must follow a fast-changing field.
Architecture
Printed pages 234 to 238 collect foundations for language, vision, audio, attention, diffusion, and sequence models.
Developer tools
Printed pages 239 to 242 collect runtimes, GPU libraries, profilers, and model tooling.
Frontier open models
Printed pages 243 to 245 index open model publishers across several modalities.
GPU infrastructure
Printed pages 246 to 248 link accelerator systems with orchestration and reliability resources.
Inference optimization
Printed pages 249 to 253 survey research on quantization, caching, attention, speculation, parallelism, and disaggregation.
Intelligence evaluation
Printed pages 254 to 255 collect evaluations for general reasoning, code, mathematics, embeddings, and applied tasks.
- How the appendix frames continued learning and changing technical material
- Printed pages: 233–233; PDF pages: 235–235
- Model architecture, attention, diffusion, multimodality, and representation learning resources
- Printed pages: 234–238; PDF pages: 236–240
- CUDA, inference runtimes, model libraries, profiling, and developer tools
- Printed pages: 239–242; PDF pages: 241–244
- Frontier open-model publishers and modality-spanning model collections
- Printed pages: 243–245; PDF pages: 245–247
- GPU architecture, interconnects, orchestration, data systems, and reliability
- Printed pages: 246–248; PDF pages: 248–250
- Quantization, caching, attention, speculation, parallelism, and disaggregation research
- Printed pages: 249–253; PDF pages: 251–255
- General, code, mathematics, embedding, and real-world model evaluations
- Printed pages: 254–255; PDF pages: 256–257