深入浅出PyTorch：从模型到源码 (张效捷 著) (Z-Library)

【One-Line Pitch】 A hands-on guide to PyTorch that walks you from the mathematical foundations of deep learning all the way to reading the framework's own source code, using real computer-vision models as the vehicle. Best for readers who already know some Python and basic ML and want to understand *why* PyTorch works the way it does, not just how to call its APIs. 【Book Arc】 - **Opening (~0%–10%)**: Builds the conceptual floor — deep learning's role in NLP and machine translation, discriminative vs. generative models, maximum likelihood, loss functions (MSE/L1), tensors and their NCHW/NHWC layouts, and how images, text, and audio become model inputs. Solves the "what is actually happening under the math" problem. - **Early (~10%–35%)**: Moves into PyTorch mechanics — activation functions and the vanishing/exploding gradient problem, optimizers (Adam, momentum), learning-rate and weight decay, then tensor creation, autograd and computation graphs, `nn.Module`, loss functions, `DataLoader`/`Dataset`, model saving via state dicts, TensorBoard, and distributed data-parallel training. Solves the "how do I actually drive the framework" problem. - **Middle (~35%–60%)**: Covers the building blocks of vision models — linear and convolution layers, transposed convolution, pooling, `Sequential`/`ModuleList`/`ModuleDict`, weight initialization (He/Kaiming), and canonical architectures like InceptionNet. Then applies them in full case studies: LeNet on MNIST, ResNet bottlenecks, InceptionNet v3, SSD object detection, and FCN segmentation. Solves the "how do these pieces compose into real models" problem. - **Late (beyond ~60%)**: Excerpts do not cover this range in detail; the book's title promises a move "from model to source code," so later material presumably dives into PyTorch internals, but the provided excerpts stop around the computer-vision case studies. 【Key Takeaways】 - **Deep learning theory is framed through probability, not just calculus** (Opening): loss functions like MSE and L1 are derived from maximum likelihood under Gaussian or Laplacian noise assumptions, which makes the choice of loss feel principled rather than arbitrary. - **Tensors are the universal data container, and layout matters** (Opening): vectors, matrices, and higher-dimensional tensors are built by adding dimensions, and the NCHW vs. NHWC distinction directly affects cross-framework model portability. - **Activation choice is a gradient-stability decision** (Opening): Sigmoid/Tanh cause vanishing gradients in deep stacks, while ReLU's simple gradient is why deep networks became trainable; weight initialization and gradient clipping are the companion fixes for exploding gradients. - **Autograd is a computation-graph story** (Early): static graphs build the backward graph alongside the forward one, while dynamic graphs bind a backward function to each output tensor — understanding this explains `torch.no_grad` and `detach`. - **`nn.Module` is the organizing abstraction** (Early/Middle): parameters must be wrapped with `nn.Parameter`, and module containers like `ModuleList`/`ModuleDict` are required (instead of plain Python lists/dicts) so that `parameters()` recursion doesn't break. - **Data loading is a first-class engineering concern** (Early): `DataLoader`'s many knobs — `batch_size`, `shuffle`, `sampler`, `num_workers`, `pin_memory`, `collate_fn` — are where training throughput and correctness are won or lost. - **Real models are compositions of a few recurring motifs** (Middle): bottleneck residual blocks, Inception's multi-scale parallel convolutions, and SSD's anchor-box prediction heads all reuse the same primitives (conv, BN, ReLU, pooling) in different arrangements. - **Style and segmentation show the flexibility of convolutional features** (Middle): Gram matrices capture channel-similarity as "style," and FCN reuses ResNet layers with upsampling and auxiliary heads for dense prediction. 【Reading Tips】 - **Deep-read the Opening math if you're shaky on fundamentals**, but skim it if you already know maximum likelihood and backprop — the payoff is in how it motivates later API choices. - **Treat the Early PyTorch chapters as a reference desk**: the `DataLoader` signature and state-dict saving details are worth bookmarking rather than memorizing in one pass. - **Work through the Middle case studies (LeNet → ResNet → Inception → SSD → FCN) in order** — each one introduces one new idea (engineering structure, bottlenecks, multi-scale, detection heads, segmentation) that builds on the last. - **Watch the cross-framework notes** (NCHW/NHWC, rounding in pooling) if you plan to port models between PyTorch and other frameworks. - **Keep the source-code angle in mind**: the book repeatedly points at files like `torch/nn/modules/conv.py`, so read with the PyTorch source open beside you. 【Coverage Limits】 This guide is based on stratified excerpts covering roughly the first half of the book (fundamentals through computer-vision case studies); the later "model to source code" material promised by the title is not represented in the excerpts, so claims about the book's internals coverage are inferred from the title and early signposting rather than verified.