Tensors, Training Loops, CNNs, Sequence and Transformer Models, and Deploying Models

Read before you buy: the PDF here is a free sample — the first 20 pages of the 476-page book (payments, sales and reviews on this demo site are sample data). Get the full e-book at thenexbooks on Gumroad.

Understand deep learning from the inside — and build models that train, generalize, and ship.

Deep learning often feels like two separate worlds: impressive demos on one side, and on the other, code that refuses to train — shapes that don't match, a loss that won't move, an accuracy that looks too good to be true. This book connects the two. You start with a single tensor and build upward one idea at a time, until you can design, train, debug, evaluate, export, and serve your own models with PyTorch.

Every concept appears at the moment it solves a real problem, every script is short enough to read in one sitting, and every example runs on an ordinary CPU in seconds to about a minute. No GPU, cloud account, or large download is required — and when you do have a GPU, the same device-independent code simply runs faster.

What's inside

• What deep learning is, when it beats simpler methods and when it doesn't, and how to set up PyTorch on Windows, macOS, or Linux
• Tensors in depth: shapes, indexing, broadcasting, memory, devices, and the shape errors everyone hits
• Autograd and gradient descent written by hand, so the training loop is never a black box again
• nn.Module, Dataset and DataLoader, loss functions, optimizers, and a complete, reusable training loop
• Making training work: initialization, normalization, dropout, weight decay, early stopping, learning-rate schedules, and a debugging checklist
• Computer vision: convolutions from first principles, a CNN for product images, data augmentation with torchvision transforms, batch normalization, residual networks, and transfer learning when the data changes
• Sequences and text: tokenization, vocabularies, embeddings, RNNs, LSTMs and GRUs, packed sequences, and multi-day demand forecasting against honest baselines
• Attention and transformers built from scratch, then with PyTorch's modules: multi-head attention, positional encodings, encoder blocks, a transformer classifier, and a tiny language model that generates text
• Pretraining, fine-tuning, and parameter-efficient methods explained with runnable miniature examples
• Production skills: seeds and reproducibility, checkpoints, experiment logs, profiling, mixed precision, torch.compile, torch.export, ONNX, quantization, batch scoring, and a small prediction API

One running example, start to finish. You join the data team at Larkspur Goods, a fictional home-and-lifestyle retailer, and build three systems: a classifier that tags product thumbnails, a sentiment model that flags unhappy customer reviews, and a forecaster that predicts a week of sales for each store — plus a warm-up network that reads handwritten digits from stock-count sheets. A short script in the appendix generates all the data, so your results can be compared directly with the book's.

Current and honest. Examples were tested with Python 3.12, PyTorch 2.14, and torchvision 0.29, and every output shown was produced by running the code. Deprecated APIs are labeled as such, code that needs a GPU, a download, or an extra library is clearly marked as not run, and the book contains no invented benchmarks or statistics. Every chapter includes Tips, Notes, Warnings, exercises, and Key Takeaways, and the appendices give you a PyTorch cheat sheet, the complete reference code, a production checklist, and a glossary.

Format: PDF, 476 pages (A4), linked table of contents and bookmarks. English. First Edition, 2026. Published by thenexbooks. This book is independent and is not affiliated with, sponsored by, or endorsed by the PyTorch Foundation or The Linux Foundation.

Table of Contents

Part I — Foundations

• Ch 1 · What Deep Learning Is and Where PyTorch Fits
• Ch 2 · Setting Up PyTorch: Installation, Devices, and Your First Tensors
• Ch 3 · Tensors in Depth: Shapes, Indexing, Broadcasting, and Memory
• Ch 4 · Autograd: How PyTorch Computes Gradients
• Ch 5 · Gradient Descent by Hand: Fitting Larkspur's Demand Trend

Part II — Training Neural Networks

• Ch 6 · Building Models with nn.Module
• Ch 7 · Datasets and DataLoaders: Feeding Data to Models
• Ch 8 · The Training Loop: Loss Functions, Optimizers, and Evaluation
• Ch 9 · Your First Neural Network: Reading Count-Sheet Digits
• Ch 10 · Making Training Work: Initialization, Normalization, Regularization, and Schedules

Part III — Computer Vision with CNNs

• Ch 11 · Convolutions from First Principles
• Ch 12 · Building a CNN: Classifying Product Thumbnails
• Ch 13 · Data Augmentation with torchvision Transforms
• Ch 14 · Modern CNN Architectures: Batch Norm, Residual Connections, and torchvision Models
• Ch 15 · Transfer Learning and Fine-Tuning

Part IV — Sequences and Text

• Ch 16 · Text as Tensors: Tokenization, Vocabularies, and Embeddings
• Ch 17 · Recurrent Networks: RNN, LSTM, and GRU for Review Sentiment
• Ch 18 · Forecasting Store Demand with Sequence Models
• Ch 19 · Attention from Scratch

Part V — Transformer Models

• Ch 20 · Inside the Transformer: Multi-Head Attention, Positions, and Encoder Blocks
• Ch 21 · Building a Transformer Classifier for Reviews
• Ch 22 · Generating Text: A Tiny Decoder-Only Language Model
• Ch 23 · Pretraining, Fine-Tuning, and the Pretrained-Model Ecosystem

Part VI — Deploying Models

• Ch 24 · Reproducibility, Checkpoints, and Experiment Tracking
• Ch 25 · Performance: GPUs, Mixed Precision, torch.compile, and Profiling
• Ch 26 · Exporting and Optimizing Models: torch.export, ONNX, and Quantization
• Ch 27 · Serving Predictions: Batch Scoring and a Prediction API
• Ch 28 · Capstone: Larkspur's Deep Learning System End to End — and What to Learn Next

Appendices
A · PyTorch Cheat Sheet
B · Templates and Reference
C · Production Checklist
D · Glossary

Book details