Building AI Systems with Python Practical Machine Learning and Agentic Workflows with Python and PyTorch (Martin Hander) (z-library.sk, 1lib.sk, z-lib.sk)

【One-Line Pitch】 A practical field manual for engineers who can already train a model but need to run one: it walks the full lifecycle from data pipelines and baselines through LLMs, RAG, agents, and production serving, with repeatable workflows and operational checklists at every step. Read it if you want to move from "I can build it" to "I can operate it." 【Book Arc】 - **Opening (~0%–10%)**: Frames the book's thesis — AI is infrastructure you operate, not a demo you show — and defines what makes a "system": contract, training story, evaluation story, operational story, and safety story. Sets expectations for Python/PyTorch as the backbone and for readers who already write Python and have trained at least one model. - **Early (~10%–35%)**: Builds the foundations that ship: NumPy/Pandas/PyArrow data handling, scikit-learn baselines, bias/variance without folklore, data engineering (Dataset/DataLoader contracts, streaming, weak supervision, synthetic data), evaluation and testing (Torchmetrics, Pytest, Hypothesis, golden sets, A/B design), ML software engineering (project structure, pyproject.toml, ruff/mypy, lockfiles), and PyTorch optimization basics (autograd, schedulers, mixed precision, early stopping). - **Early–Middle (~35%–50%)**: Moves into modern architectures — transformers by hand and via Hugging Face, KV cache and long context, diffusion and generative media, multimodal (CLIP-style alignment, audio/ASR/TTS), classical models that still deliver (recommenders, time series, tabular, anomaly detection), and RL in practice (RLHF/RLAIF, offline RL). - **Middle (~50%–60%)**: Centers on LLM systems: prompting, retrieval and reranking, RAG with citations and freshness, tool-using LLMs with typed schemas and sandboxed execution, LLM evaluation and observability (rubric evals, pairwise evals, traces, guardrail tests, dashboards), and responsible AI foundations (threat modeling, prompt-injection defenses, PII redaction, GDPR, differential privacy, model specs). - **Late (~60%–75%)**: Agentic systems in depth — controllers, memory, budgets, cancellations, multi-agent patterns (debate, auctions, blackboard), reliability and determinism (idempotence, retries, constrained decoding, transactional tool use), and agent evals/benchmarks with autonomy levels and incident post-mortems. - **Ending (~75%–100%)**: Production reality — experiment tracking and model registries, serving (FastAPI streaming, vLLM/TGI back ends, batching vs. first-token time), performance engineering (torch.compile, AMP, CUDA Graphs), cost control (distillation, spot fleets, cost telemetry), compliance and auditability (retention, audit trails, model cards), and edge/on-device deployment (TorchScript, torch.export, ExecuTorch, ONNX, TensorRT, WebGPU/WASM). 【Key Takeaways】 - **The book's unit of work is the system, not the model** (Opening): a shippable AI system has a contract, a reproducible training story, an evaluation story, an operational story, and a safety story — the framing that organizes every later chapter. - **Data-centric work is where most wins live** (Early): schema-first pipelines, Arrow → Dataset → Loader contracts, and hygiene practices matter more than model cleverness; weak supervision and synthetic data are treated as tools with failure modes, not magic. - **Evaluation must be designed to not fool you** (Early): golden sets, property-based tests, offline vs. online A/B design, and regression tests are presented as engineering discipline rather than afterthoughts. - **LLM systems are retrieval and tooling problems as much as modeling problems** (Middle): RAG with citations, reranking, freshness filters, typed function schemas, plan → validate → execute → synthesize routing, and sandboxed code execution are the recurring patterns. - **Agents need budgets, traces, and guardrails to be trustworthy** (Late): controller hooks for budgets/cancellations, idempotent tool calls, retries with jitter, constrained decoding tiers, and transactional patterns (unit-of-work, saga, outbox) turn agent loops into operable systems. - **Safety and governance are core engineering, not a skippable chapter** (Middle): prompt-injection defenses, PII detection/redaction, DP-SGD, model specs, and red-teaming in CI are framed as things that "actually run." - **Serving economics are a first-class concern** (Ending): batching trades against first-token latency, distillation and spot fleets cut cost, and cost telemetry is treated like latency telemetry. - **Auditability is a design goal** (Ending): replayable spans, evidence-pack exporters, retention sweepers, DSR checklists, and truthful model cards make systems defensible in audits. 【Reading Tips】 - Treat it as a field manual: the introduction explicitly invites jumping to the chapter matching what you're building, so skim Parts I–II if you're already strong on fundamentals and deep-read Parts III–V where the operational patterns live. - Deep-read the "What to Ship" sections at the end of each chapter — they are the author's compression of each topic into shippable checklists. - The hardest stretches are likely the reliability/determinism chapter (idempotence, sagas, constrained decoding) and the performance/cost chapters; budget extra time there and pair them with the code examples. - Keep the book's GitHub code alongside; the text repeatedly pairs concepts with runnable examples, tests, and checklists that are easier to absorb by running them. - Take away the repeatable workflows — schema-first tooling, reproducible training, golden-dataset evaluation, monitored rollouts — rather than individual tricks. 【Coverage Limits】 This guide is based on the blurb, introduction, and table-of-contents-level excerpts; chapter internals, code details, and the end-to-end playbooks (Part VII) are only partially covered, so specific implementation claims should be verified against the book itself.