Building Machine Learning Systems with a Feature Store (Jim Dowling)（Z-Library）

【One-Line Pitch】 A practical field guide to building ML systems around a shared feature store, showing how to decompose any AI application into feature, training, and inference pipelines. Best for data scientists, data engineers, and ML engineers who can train models but struggle to ship and operate them on dynamic data. 【Book Arc】 - **Opening (~0%–15%)**: Frames the core problem — models trained on static datasets don't create recurring value. Introduces the book's central thesis: any AI system decomposes into independent feature, training, and inference pipelines joined by a shared data layer, and defines the three system classes (batch, real-time, agentic). - **Early (~15%–30%)**: Lays out the roadmap and a first hands-on build (an air-quality forecasting system with a dashboard and LLM querying), then introduces feature stores conceptually — feature groups, feature views, offline/online skew, and data modeling — before moving into Hopsworks APIs and project security. - **Middle (~30%–55%)**: The data-heavy core. Covers transformations for feature pipelines (Pandas, Polars, Spark, Flink, Feldera) with validation via Great Expectations, training/inference transformations including real-time ones, and batch vs. streaming feature pipeline design with windowed and rolling aggregations. Also contrasts batch systems (e.g., Spotify-style weekly recommendations) with request-driven real-time systems. - **Late (~55%–80%)**: Training and prediction at scale — building training datasets from the store, decision trees on time-series data, fine-tuning LLMs with LoRA, PyTorch training with Ray, and distributed-training challenges. Then batch inference with PySpark, model serving via KServe (with and without GPUs, including vLLM), and an introduction to agents, RAG, LlamaIndex, and tool/agent protocols like MCP and A2A. - **Ending (~80%–100%)**: MLOps in depth — offline testing from feature-contract unit tests through pipeline integration and blue/green deployment to agent evals, plus governance and automatic containerization. Observability via logs, traces, and metrics feeding feature/model monitoring and autoscaling, closing with a personalized video recommender case study and the "dirty dozen fallacies of MLOps." 【Key Takeaways】 - **The feature store is the architectural spine** (Early): storing training and inference feature data in one place with feature groups and feature views is what prevents offline/online skew — the book's central design decision. - **Pipelines, not notebooks, deliver value** (Middle): a model earns its keep only when feature, training, and inference pipelines run repeatedly on fresh data; the running example contrasts a one-off static-dataset model with an automated batch system feeding a dashboard. - **Know which transformation belongs where** (Middle): the book offers a taxonomy for deciding whether a data transformation runs in the feature pipeline, training pipeline, or inference pipeline — the key lever for real-time systems via "shift left" or "shift right" feature computation. - **Three system classes need different designs** (Early): batch (scheduled predictions), real-time (24/7 request-driven, personalized), and agentic (LLM + tools + RAG) systems share the FTI decomposition but differ in latency, freshness, and testing needs. - **Data engineering is the hard part** (Middle): transformation frameworks (Pandas, Polars, Spark, Flink, Feldera), validation with Great Expectations, and streaming windowed aggregations get substantial treatment because that's where most ML system effort goes. - **Training scales beyond tabular models** (Late): training datasets from the store, time-series decision trees, LoRA fine-tuning, and Ray-based PyTorch training — with distributed-training scalability flagged as a distinct challenge. - **Serving spans batch to LLM** (Late): PySpark batch inference, KServe deployment with and without GPUs, and vLLM for LLMs; agents add RAG, LlamaIndex, and MCP/A2A protocols with their own development process. - **Testing and observability are first-class** (Ending): feature-contract unit tests, pipeline integration tests, blue/green deploys, agent evals, and trace/metric-based monitoring with autoscaling — plus a catalog of common MLOps fallacies to avoid. 【Reading Tips】 - If you already train models comfortably, skim the ML-type refreshers and deep-read Parts II–III (feature store concepts and transformations) — that's where the book's distinctive value sits. - Follow the recurring credit-card fraud example and the air-quality build; they anchor abstract pipeline concepts in concrete code. - Treat the taxonomy of transformations as the takeaway to internalize: before writing any pipeline, decide where each transformation runs and why. - The MLOps chapters (testing, observability, fallacies) are worth reading even if you skip implementation details — they're the checklist for production readiness. - Have Python and SQL fluency ready; the exercises assume it, and the Hopsworks-specific APIs are best learned by doing. 【Coverage Limits】 These excerpts are dominated by front matter, preface, and chapter roadmap, so detailed technical content from the middle and later chapters is only summarized at the table-of-contents level; specific code, benchmarks, and case-study details are not covered here.