Machine Learning in Action (Peter Harrington)（Z-Library） (1)

【One-Line Pitch】 A hands-on tutorial that teaches classic machine learning algorithms by having you build them from scratch in Python, rather than calling a library. Best for developers and self-taught programmers who know a little Python and want to understand how classification, regression, and clustering actually work under the hood. 【Book Arc】 - **Opening (~0%–15%)**: Frames what machine learning is, why deterministic modeling fails for messy human problems, and walks the standard workflow from data collection through training, testing, and deployment. Establishes Python (with NumPy and Matplotlib) as the implementation language and explains why. - **Early (~15%–35%)**: Begins Part 1 (Classification) with the k-Nearest Neighbors algorithm, using a movie "kicks vs. kisses" toy example and a dating-profile dataset to show data parsing, normalization, and a working classifier. - **Middle (~35%–55%)**: Continues classification with decision trees — information theory, Shannon entropy, recursive tree construction, and Matplotlib-based tree plotting — then applies it to predicting contact lens prescriptions. - **Late (~55%–80%)**: Covers the remaining classifiers (naïve Bayes, logistic regression, support vector machines) and the AdaBoost meta-algorithm, then moves into Part 2 on regression for predicting numeric values, including tree-based regression. - **Ending (~80%–100%)**: Part 3 turns to unsupervised learning, starting with grouping unlabeled data (clustering); the excerpts do not cover the closing chapters in detail. 【Key Takeaways】 - **Machine learning is defined by improvement through experience** (Opening): the book opens by grounding the field in the idea that a program learns when its performance improves with data, and that many real problems resist deterministic modeling. This framing matters because it justifies why statistical tools are needed at all. - **Python is chosen for readability, not performance** (Early): clear syntax, built-in high-level data types, and NumPy/SciPy (compiled in C and Fortran) let you write code that reads like linear algebra while still running fast. Matplotlib handles visualization. - **kNN is the gentlest entry point to classification** (Early): the movie and dating examples show that a usable classifier needs only distance computation, a k value, and normalized features — normalization is emphasized because raw feature scales distort distance. - **Decision trees trade interpretability for overfitting risk** (Middle): the book explicitly lists pros (cheap, human-readable, tolerant of missing/irrelevant features) and cons (prone to overfitting), then builds the tree recursively using Shannon entropy to pick the best split. - **Entropy drives the split decision** (Middle): rather than guessing which feature to branch on, the algorithm tries each feature and measures which split best organizes the data — a concrete, testable criterion you can verify with the book's own entropy function. - **The workflow is iterative, not linear** (Early): the book stresses that data collection or preparation problems often send you back to step 1, and new data can force revisiting earlier steps — a realistic counterweight to textbook pipelines. - **Algorithms are taught as reusable code, not theory** (Throughout): each chapter pairs a classic algorithm (kNN, decision trees, naïve Bayes, logistic regression, SVM, AdaBoost, regression, Apriori) with runnable Python, so the takeaway is working implementations you can adapt. - **Unsupervised learning closes the arc** (Ending): Part 3 shifts from labeled classification and numeric forecasting to grouping unlabeled data, completing the progression from supervised to unsupervised techniques. 【Reading Tips】 - **Deep-read Part 1's first two chapters** (kNN and decision trees): they establish the data-parsing, normalization, and evaluation habits reused throughout the book; skimming them will make later chapters harder than they need to be. - **Type the code rather than reading it**: the book is explicitly a tutorial, and the value comes from running the examples, reloading modules, and inspecting arrays in the Python shell as the excerpts demonstrate. - **Treat the pros/cons boxes as your map**: each algorithm chapter states when it works and its weaknesses; use these to decide which technique fits a problem before diving into implementation. - **Skim the Matplotlib plotting sections if visualization isn't your goal**: tree plotting and annotation code is useful but can be treated as a utility you return to later. - **Don't skip the workflow chapter**: the iterative collect→prepare→analyze→train→test→use loop is the most transferable idea in the book, more than any single algorithm. 【Coverage Limits】 This guide is based on stratified excerpts covering roughly the first half of the book (through decision trees and into later classification/regression material); the excerpts do not cover the full details of naïve Bayes, SVM, AdaBoost, regression, or the unsupervised chapters, so those sections are described only at the level of the table of contents.