Deep Learning and the Game of Go (Max Pumperla, Kevin Ferguson)（Z-Library）

【One-Line Pitch】 A hands-on guide that teaches deep learning by having you build a Go-playing bot from scratch, progressing from board representation to AlphaGo-style reinforcement learning. Best for Python programmers with basic math who want a concrete, motivating project to learn neural networks, search, and reinforcement learning. 【Book Arc】 - **Opening (~0%–10%)**: Frames the project and the field—why Go resisted classical AI, what machine learning is (and isn't), and how supervised, unsupervised, and reinforcement learning differ. Sets up the Python/NumPy/Keras/TensorFlow toolchain you'll use throughout. - **Early (~10%–32%)**: Builds the foundation in two tracks: the rules and mechanics of Go (captures, ko, komi, handicaps) and a working Python board implementation with legal-move logic, plus your first self-playing bot. - **Middle (~32%–48%)**: Introduces classical game AI—minimax search, game trees, depth pruning, and Monte Carlo Tree Search—including the exploitation-exploration trade-off that later powers the deep-learning bots. - **Late (~48%–70%)**: Turns to deep learning proper: a first neural network on MNIST, then move-probability prediction with softmax and cross-entropy, deeper networks with dropout and ReLU, and training on real human game records (SGF/KGS) with adaptive gradient methods. - **Ending (~70%–100%)**: Assembles the pieces into a deployable bot (web frontend, agents), then scales up to AlphaGo and AlphaGo Zero—combining neural networks with MCTS and self-play reinforcement learning—plus appendices on math, backpropagation, and deploying/submitting bots. 【Key Takeaways】 - **Go is the motivating case study, not the whole point** (Opening): the techniques—search, neural networks, reinforcement learning—transfer to other domains, and the book repeatedly flags this. - **A clean board abstraction comes first** (Early): representing points, strings, liberties, and legal moves is the unglamorous but essential substrate every later bot depends on. - **Classical search is the bridge to modern AI** (Middle): minimax and MCTS teach you to reason about game trees and the exploration-exploitation trade-off before neural networks enter. - **Move prediction is a classification problem** (Late): softmax outputs and cross-entropy loss turn "which move?" into something a network can learn from human records. - **Deeper isn't automatically better** (Late): dropout and ReLU are presented as practical tools for regularizing and training deeper networks effectively. - **Data engineering matters as much as modeling** (Late): importing SGF records, replaying games, and building efficient data generators are treated as first-class skills. - **Adaptive optimizers reduce tuning pain** (Late): momentum, Adagrad, and Adadelta are introduced as ways to train efficiently without hand-tuning learning rates. - **Self-play closes the loop** (Ending): AlphaGo Zero's reinforcement-learning approach removes the need for human data, connecting everything you built into a self-improving system. 【Reading Tips】 - **Deep-read the Early board implementation** even if you find Go rules tedious—later chapters assume you understand strings, liberties, and legal-move encoding. - **Skim the Go-rules chapter if you already play**; return to the ko and handicap discussions only when a bot behaves oddly. - **Treat the Middle search chapters as conceptual anchors**: the exploitation-exploration idea recurs in the AlphaGo chapters, so don't rush past it. - **Run the code as you go**, especially the data-processing and training chapters—the book is project-driven, and reading passively loses most of the value. - **Use the appendices as reference**, not front-to-back reading; dip into the math and backpropagation material when a chapter's notation gets dense. 【Coverage Limits】 These excerpts cover the book's structure, opening framing, early Go implementation, mid-book search, and late deep-learning chapters, but do not include the full text of the AlphaGo/AlphaGo Zero chapters or the appendices. Specific code details, figures, and later-chapter arguments are summarized from partial material.