Practical Full Stack Machine Learning (Alok Kumar)（Z-Library）

【One-Line Pitch】 A hands-on guide to the unglamorous middle of machine learning work: turning notebooks into reproducible pipelines, versioned data, and scalable APIs. Best for data scientists and ML engineers who already know Python and scikit-learn but have never shipped a model to production. 【Book Arc】 - **Opening (~0%–10%)**: Sets up the project before any modeling — choosing infrastructure (on-premises vs cloud, CPU vs GPU), picking libraries, defining project structure, and establishing baseline metrics so you can tell whether a model is actually good. - **Early (~10%–33%)**: The data layer. Preprocessing and imputation, feature distribution and outlier handling, numerical transformations like binarization, deep feature synthesis with featuretools, weak supervision with Snorkel, image augmentation, scaling with Dask, and data versioning with DVC. - **Middle (~33%–57%)**: Model exploration and optimization — grid vs random search, Keras Tuner for neural architecture, transfer learning, embeddings (word2vec through BERT), ensemble/stacking with ml-ens, then orchestration with Airflow (DAGs, operators, sensors, Celery executors). - **Late (~57%–80%)**: Operationalizing the model — MLflow for reproducible training and packaging, feature stores as a central vault for documented, access-controlled features, and serving models as APIs. - **Ending (~80%–100%)**: Deployment and scale — FastAPI for RESTful endpoints, Ray Serve for scaling ML serving, plus chapter summaries and review questions. (Excerpts thin out here; exact closing content is not fully covered.) 【Key Takeaways】 - **Full-stack means owning the pipeline, not just the model** (Opening): the book's spine is the sequence from project setup through data, training, orchestration, and serving — each stage treated as a first-class engineering task. - **Baselines make model quality legible** (Opening): without a baseline, an error-vs-iteration curve tells you nothing about whether to continue; the book stresses defining targets and metrics before training. - **Feature engineering is where most practical gains live** (Early): distribution analysis, imputation, binarization, and deep feature synthesis across multiple tables are covered in depth, including the caveat that raw counts (e.g., listen counts) are often poor proxies for the underlying behavior. - **Weak supervision and augmentation stretch small labeled datasets** (Early): Snorkel's labeling functions and Augmentor pipelines show how to manufacture training data when manual labeling doesn't scale. - **Data and experiments need version control too** (Early–Middle): DVC handles versioned datasets via `.dvc` files and fetch/commit cycles, while MLflow packages models so others can treat them as a reproducible black box. - **Hyperparameter search is a strategy choice, not a button** (Middle): grid search, random search (Bergstra & Bengio), and Keras Tuner each fit different budgets and search spaces; transfer learning lets you decide how many layers to freeze or how to control weight change rates. - **Orchestration turns scripts into scheduled, observable workflows** (Middle): Airflow DAGs, cron syntax, PythonOperator/PythonSensor, backfilling, and Celery/PostgreSQL/Redis configuration are the production backbone. - **Serving is a scaling problem, not just an endpoint** (Late): FastAPI handles sync and async requests, and Ray Serve addresses scaling — the final mile from model artifact to live API. 【Reading Tips】 - **Skim Chapter 1 if you already have infrastructure opinions**; deep-read the baseline/metrics discussion, since it frames every later evaluation decision. - **Treat the Early chapters as a toolbox, not a linear read**: featuretools, Snorkel, Augmentor, and Dask solve different problems — jump to whichever matches your current bottleneck. - **Run the Airflow and MLflow setups yourself.** These are configuration-heavy and the excerpts show real friction (DB connection strings, result backends, executor choices); reading alone won't stick. - **Watch for version drift.** The book references Airflow 1.10 and older tooling; expect to consult current docs when reproducing setups. - **Use the end-of-chapter "Points to remember" and questions as a self-check** before moving to the next stage. 【Coverage Limits】 These excerpts cover the book's structure and early-to-middle chapters in reasonable detail, but the late deployment chapters (MLflow, feature stores, FastAPI/Ray Serve) are represented mostly by chapter introductions and outlines rather than full content. Specific code, benchmarks, and closing material are not fully covered here.