B

Recommended Reading

A question-led map from this introduction into primary papers, tools, systems, and evaluations.

6 min read

Printed pages: 231–256

Star on GitHub

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.

  • Baseten blog

    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.

  • Transformer foundations

    Read the original attention architecture to connect token interactions, parallel training structure, and the autoregressive serving path.

  • Input-output-aware attention

    Use the first FlashAttention paper to understand why reducing memory traffic can matter more than reducing the arithmetic count.

  • Diffusion foundations

    Study denoising diffusion to see why image and video generation repeat a model over a schedule instead of emitting one token at a time.

  • Frozen-encoder multimodality

    BLIP-2 is a useful bridge for understanding how visual encoders and language models exchange representations without retraining every component together.

  • Selective state spaces

    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.

  • vLLM

    A broad serving baseline for learning continuous batching, paged attention state, and common application programming interfaces.

  • SGLang

    A serving project worth comparing for model support, structured generation, caching, and mixture-of-experts execution.

  • TensorRT-LLM

    NVIDIA's engine documentation exposes architecture-tuned kernels, low precision, and build-versus-runtime trade-offs.

  • PyTorch Profiler

    Use the profiler recipe to attribute host and accelerator time only after a stable workload reproduces the target regression.

  • CUTLASS

    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.

  • DeepSeek AI collection

    A model family for studying dense and sparse language-model serving choices across reasoning and general workloads.

  • Alibaba Qwen collection

    A broad family spanning language and multimodal checkpoints, useful for comparing sizes and task-specific variants.

  • Mistral AI collection

    A source of open language and sparse expert models for evaluating capability, size, and serving topology together.

  • Black Forest Labs collection

    An image-generation family for examining pipeline components, model variants, memory demand, and license constraints.

  • OpenAI model collection

    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.

  • Kubernetes documentation

    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.

  • Site Reliability Engineering

    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.

  • Speculative decoding

    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.

  • FlashInfer

    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.

  • HumanEval

    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.

  • SWE-bench

    A repository-level software task benchmark that illustrates the gap between isolated code snippets and tool-using workflows.

  • ARC Prize

    A route into evaluations of abstraction and generalization that do not reduce capability to familiar language tasks.

Turn reading into evidence

  1. Write the decision and the uncertainty blocking it in one sentence.
  2. Read the primary paper or official documentation before relying on benchmark summaries or vendor comparisons.
  3. Reproduce the smallest relevant claim with your model, request distribution, hardware, and quality checks.
  4. 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