Bài 12: PyTorch vs TensorFlow — chọn cái nào và vì sao

Sau bài học, bạn sẽ:

• Hiểu vì sao implement Deep Learning từ con số 0 không thực tế — và framework giải quyết những vấn đề gì.
• Phân biệt PyTorch, TensorFlow, JAX về cú pháp, debug, mức độ phổ biến trong research và industry.
• Biết lý do series này dùng PyTorch 2.x và khi nào nên cân nhắc TensorFlow/Keras.
• Cài được PyTorch trên máy local (CPU hoặc GPU) hoặc dùng trên Colab.
• Nắm bố cục các submodule chính: torch, torch.nn, torch.optim, torch.utils.data, torchvision.
• Chạy được snippet "Hello PyTorch" — định nghĩa model 2 layer và forward một batch tensor.

Module 1 (Bài 1–11) đã làm xong nền tảng ANN: perceptron, MLP, các activation, forward/backpropagation, loss cho regression và classification. Từ Module 2 trở đi, mọi thứ chuyển sang PyTorch để bạn có thể implement và train model thật.

Module 1 đã chứng minh: viết tay forward và backward cho MLP 2 layer trên NumPy là làm được, nhưng chậm và dễ sai. Mở rộng cho CNN (Bài 11) hay Transformer (Series 4) — quy mô weight, branching, và chain rule tăng phi tuyến — viết tay không còn khả thi.

Framework Deep Learning đứng giữa "code Python thuần" và "GPU low-level". Những thứ chúng cung cấp:

• Autodiff: tự động tính gradient cho mọi composition các phép toán đã định nghĩa. Người viết chỉ cần viết forward, backward được sinh tự động bằng reverse-mode automatic differentiation.
• GPU/TPU backend: cùng một đoạn code Python chạy được trên CPU, NVIDIA GPU (CUDA), Apple Silicon (MPS), Google TPU (qua JAX/TF). Không phải viết CUDA kernel thủ công.
• Layer và optimizer built-in: Linear, Conv, LSTM, Attention, BatchNorm, Dropout, SGD, Adam, AdamW, scheduler. Implement chuẩn, kiểm thử kỹ.
• Data loading: Dataset, DataLoader, batching, shuffling, multi-worker prefetch, augmentation.
• Serialization: lưu/load checkpoint (state_dict), export sang ONNX hoặc format mobile.
• Distributed training: data parallel, model parallel, FSDP — train model lớn trên nhiều GPU/node.

Chuẩn ngành hiện nay (2024–2026) gồm 3 framework lớn: PyTorch, TensorFlow, JAX. Cả 3 đều open-source, free, miễn license. Khác nhau ở triết lý thiết kế và hệ sinh thái — phần dưới so sánh.

• Nhà phát triển: Meta (Facebook AI Research), release 2016. Từ 2022 chuyển sang PyTorch Foundation (Linux Foundation) — quản trị mở.
• License: BSD 3-Clause, dùng được trong sản phẩm thương mại.
• Triết lý: define-by-run (dynamic computation graph) — graph được dựng khi code chạy, từng phép toán Python tương ứng node. Hệ quả: viết model như viết Python thường, debug bằng print hay pdb.
• Research adoption: chiếm đa số paper Deep Learning trên các venue lớn (NeurIPS, ICML, ICLR, CVPR, ACL). Theo thống kê Papers With Code giai đoạn 2022–2024, tỷ lệ paper có code công bố dùng PyTorch dao động khoảng 75–85%; con số chính xác thay đổi theo lĩnh vực và năm.
• Phiên bản hiện tại: 2.x (PyTorch 2.0 release tháng 3/2023). Series dùng PyTorch ≥ 2.0.

• Nhà phát triển: Google, release 2015 (TensorFlow 1.0 chính thức 2017).
• License: Apache 2.0.
• Triết lý: TensorFlow 1.x là define-and-run (static graph) — phải dựng graph trước, chạy session sau, debug khó. TensorFlow 2.0 (2019) chuyển sang eager execution mặc định, gần với PyTorch hơn; vẫn giữ tf.function để compile lại sang graph khi cần production.
• Keras: high-level API, ban đầu là wrapper trên nhiều backend (Theano, TensorFlow, CNTK), từ TF 2.0 thành API chính thức của TensorFlow. Keras 3.x (2023+) lại tách ra hỗ trợ đa backend TF/JAX/PyTorch — phù hợp người muốn cú pháp gọn.
• Mạnh ở production: TensorFlow Serving (gRPC), TensorFlow Lite (mobile/edge), TensorFlow.js (browser), TFX (pipeline ML). Hệ thống Google Search, Translate, YouTube dùng TF/JAX nội bộ.

• Nhà phát triển: Google Research, release 2018 (phổ biến hơn từ 2020).
• License: Apache 2.0.
• Triết lý: functional programming. Mọi phép toán là pure function trên array. Composability: grad (autodiff), jit (compile XLA), vmap (vectorize batch), pmap (parallel multi-device). Người dùng tự ráp các transformation.
• Phổ biến trong research: DeepMind (AlphaFold 2, AlphaGo gốc đã chuyển sang JAX), Google Brain, Anthropic. Hợp với TPU và large-scale training.
• Khó cho beginner: cú pháp functional, immutable array, state phải truyền tay (không có nn.Module built-in — phải dùng Flax hoặc Equinox). Curve học dốc hơn PyTorch.

Series này không dùng JAX. Sau khi vững PyTorch, học JAX nhanh hơn vì nắm rồi khái niệm autograd, JIT, batch.

Khoảng cách feature giữa 2 framework hiện đã rất hẹp. Quyết định chọn cái nào phụ thuộc vào use case (research vs production), ecosystem mình đang dùng (HuggingFace vs Google Cloud), và code base có sẵn.

• Pythonic, dễ học: cú pháp gần với NumPy. Người đã quen Python lên model PyTorch nhanh.
• Debug bằng công cụ Python thông thường: print, pdb, IDE breakpoint. Không phải học hệ symbolic riêng.
• Đa số code research là PyTorch: đọc paper, reproduce repo trên GitHub thuận tiện hơn.
• HuggingFace Transformers: Series 4 sẽ làm việc nhiều với pre-trained LLM. HuggingFace nguyên thuỷ build trên PyTorch (vẫn hỗ trợ TF/JAX nhưng PyTorch là first-class).
• PyTorch 2.x đã có torch.compile() để bù lại phần performance gap với graph-mode TF — viết Python thường, compile khi cần production.

TensorFlow không tệ. Đó là một framework production-ready với hệ sinh thái deploy hoàn chỉnh nhất hiện nay. Chọn PyTorch ở đây là chọn 1 trong 2 — không phải đánh giá cái còn lại kém.

• Legacy code TF: dự án đang chạy đã có pipeline TF — chi phí port sang PyTorch không bù được lợi ích.
• Production pipeline TF Serving / TFX: nếu hệ thống deploy đã build quanh TF Serving (gRPC, version control, A/B), giữ nguyên hợp lý.
• Mobile / edge nặng: TFLite hỗ trợ rộng Android/iOS/microcontroller, đã có nhiều năm tối ưu. ExecuTorch của PyTorch còn mới.
• Google Cloud TPU: TPU tích hợp tốt nhất với TensorFlow và JAX. PyTorch trên TPU qua torch_xla chạy được nhưng ít tối ưu hơn.
• Bắt đầu với Keras cho khoá học: Keras Sequential gọn, phù hợp cho người chỉ cần train model nhanh mà không quan tâm chi tiết training loop. Một số khoá online dùng Keras cho mục đích này.

Cách an toàn nhất là vào pytorch.org/get-started/locally chọn OS, package manager (pip/conda), compute platform (CPU / CUDA 11.8 / CUDA 12.1 / ROCm / MPS), trang sẽ sinh command chính xác.

CPU-only (chạy được, training chậm — dùng để học và debug):

pip install torch torchvision torchaudio

GPU NVIDIA — cần driver CUDA tương thích. Ví dụ CUDA 12.1 (PyTorch 2.x):

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

Apple Silicon (M1/M2/M3) — backend MPS tự kích hoạt, cài như CPU:

pip install torch torchvision torchaudio

Verify nhanh:

import torch
print(torch.__version__)
print("CUDA available:", torch.cuda.is_available())
print("MPS available:", torch.backends.mps.is_available())

Google Colab: PyTorch đã cài sẵn, đổi runtime sang GPU (T4 miễn phí) hoặc TPU. Phù hợp cho người chưa có máy GPU.

PyTorch chính thức được chia thành nhiều submodule và package phụ trợ:

• torch: core. Tensor (Bài 13), GPU/CUDA (Bài 14), autograd (Bài 15), random, linear algebra.
• torch.nn: layer (Linear, Conv2d, LSTM...), activation, loss function, nn.Module base class (Bài 16).
• torch.optim: optimizer (SGD, Adam, AdamW, RMSprop) và learning rate scheduler (Bài 17).
• torch.utils.data: Dataset, DataLoader, sampler, collate function (Bài 19).
• torchvision: dataset vision (CIFAR, ImageNet, COCO), transform (resize, crop, normalize), pre-trained model (ResNet, ViT). Package cài riêng nhưng đi cùng PyTorch.
• torchaudio: dataset audio (LibriSpeech, VoxCeleb), I/O wav/mp3, transform (MFCC, spectrogram), pre-trained model.
• torchtext: package NLP cũ — hiện không còn được khuyến nghị cho dự án mới. Ecosystem NLP đã chuyển sang HuggingFace Transformers + Datasets + Tokenizers.

Module 2 (Bài 12–20) tập trung vào torch, torch.nn, torch.optim, torch.utils.data. torchvision xuất hiện ở Module CNN. torchaudio ít dùng — chỉ giới thiệu khi cần.

Hệ sinh thái bên thứ ba xây trên PyTorch — sau khi vững core, các library này tăng năng suất rõ rệt:

• PyTorch Lightning: wrapper chuẩn hoá training loop, callback, checkpoint, distributed training. Bạn viết LightningModule, Lightning chạy giúp phần boilerplate.
• HuggingFace Transformers: pre-trained LLM (BERT, GPT-2, Llama, Mistral), model hub, pipeline cao cấp. First-class trên PyTorch; Series 4 dùng nhiều.
• HuggingFace Datasets: load và xử lý dataset NLP/vision/audio chuẩn hoá, hỗ trợ streaming dataset lớn không vừa RAM.
• HuggingFace Accelerate: chạy code PyTorch trên CPU/GPU/multi-GPU/TPU bằng cùng một script — wrap mỏng quanh PyTorch.
• timm (PyTorch Image Models): bộ sưu tập 700+ pre-trained vision model (ResNet, EfficientNet, ConvNeXt, ViT, Swin...). Maintainer: Ross Wightman, nay thuộc HuggingFace.
• skorch: wrapper cho PyTorch theo API scikit-learn (fit, predict, score) — hữu ích khi muốn dùng grid search hay pipeline sklearn.
• PyTorch Geometric và DGL: graph neural network.
• fastai: framework giáo dục của Jeremy Howard, viết trên PyTorch — có khoá học "Practical Deep Learning" miễn phí, được nhiều người khen.

Module 2 chỉ dùng PyTorch core để bạn hiểu mọi thứ chạy thế nào. Các library trên xuất hiện dần ở các Module sau.

• Series này dùng PyTorch ≥ 2.0. Code minh hoạ chạy được trên 2.0 đến 2.x mới nhất (kiểm thử trên 2.3 và 2.4).
• PyTorch 2.0 (3/2023) thêm torch.compile() — backend Inductor compile model thành kernel hợp nhất, tăng tốc rõ trên GPU mà không phải đổi code. Module 2 chưa đi sâu, đề cập lại khi cần optimize.
• Backward compatibility: code PyTorch 1.x (≥ 1.9) phần lớn chạy được trên 2.x. Một số deprecation nhỏ — kiểm tra release notes nếu nâng version.
• Python ≥ 3.9 (khuyến nghị 3.10 hoặc 3.11). PyTorch 2.x bỏ hỗ trợ Python 3.7.

Một MLP 2 layer cho ảnh MNIST flatten (784 chiều) phân loại 10 class. Chưa train, chỉ forward một batch ngẫu nhiên để kiểm tra shape:

import torch
import torch.nn as nn

# Định nghĩa model bằng Sequential — gọn cho kiến trúc tuyến tính
model = nn.Sequential(
    nn.Linear(784, 128),     # ảnh flatten 28x28 -> 128 hidden unit
    nn.ReLU(),
    nn.Linear(128, 10),      # 10 class logit
)

# Batch giả: 32 sample, mỗi sample 784 chiều
x = torch.randn(32, 784)

# Forward
y_pred = model(x)
print(y_pred.shape)          # torch.Size([32, 10])
print(y_pred[0])             # logit của sample đầu tiên — 10 số thực

Quan sát:

• nn.Sequential là cách viết model gọn nhất khi các layer xếp nối tiếp. Phức tạp hơn dùng class Model(nn.Module) với forward tự viết — gặp ở Bài 16.
• model(x) chính là gọi model.forward(x). PyTorch khuyến nghị gọi qua __call__ (tức model(x)) để hook và pre/post-processing chạy đúng.
• Output là logit — chưa softmax, theo quy ước Bài 10 (Loss cho classification): truyền logit thẳng cho CrossEntropyLoss.
• Tensor torch.randn(32, 784) tự sống trên CPU. Bài 14 sẽ chuyển sang GPU bằng .to("cuda").

Đây là cấu trúc tối thiểu của mọi network PyTorch. Phần còn lại của Module 2 mở rộng từng mảnh: tensor (B13), GPU (B14), gradient (B15), Module class (B16), optimizer và training loop (B17–18), data pipeline (B19), khởi tạo weight (B20).

1. Bài 13 — Tensor: cấu trúc dữ liệu cốt lõi. Shape, dtype, indexing, broadcasting, in-place op, conversion với NumPy.
2. Bài 14 — GPU / CUDA: device, .to(), cuda vs mps, kiểm tra memory, pin memory.
3. Bài 15 — Autograd: requires_grad, backward(), computation graph, .detach(), torch.no_grad().
4. Bài 16 — nn.Module: viết model bằng class, parameter, buffer, custom forward, state_dict.
5. Bài 17 — Optimizer: SGD, Momentum, Adam, AdamW. Cập nhật weight, zero_grad, weight decay.
6. Bài 18 — Training Loop: cấu trúc chuẩn forward → loss → backward → step. Train vs eval mode.
7. Bài 19 — Dataset / DataLoader: định nghĩa Dataset, batching, shuffle, multi-worker, collate.
8. Bài 20 — Weight Initialization: Xavier, He, vì sao init đúng quan trọng cho deep network.

Tổng 9 bài (B12–B20). Sau Module 2, bạn có đủ công cụ để implement bất kỳ model nào ở các Module sau (CNN, RNN, Transformer).

• PyTorch official tutorials (pytorch.org/tutorials): bộ tutorial chính thức, từ "60-min blitz" cho người mới đến phần distributed training.
• PyTorch documentation (docs.pytorch.org): API reference đầy đủ. Tra trước khi đoán.
• Deep Learning with PyTorch (Stevens, Antiga, Viehmann, 2020 — Manning): sách chính thống về PyTorch, miễn phí phiên bản đầu trên trang Manning.
• Practical Deep Learning for Coders (fast.ai): khoá học miễn phí của Jeremy Howard, dùng fastai (wrap PyTorch). Cách tiếp cận top-down — train model trước, hiểu chi tiết sau.
• CS231n (Stanford): note và assignment dùng PyTorch (từ 2017 trở đi). Tham khảo phần Conv và RNN.

1. Cài PyTorch trên máy bạn (hoặc mở Colab). Verify version bằng torch.__version__ — yêu cầu ≥ 2.0. Kiểm tra torch.cuda.is_available() hoặc torch.backends.mps.is_available() tuỳ thiết bị.
2. Tạo tensor đầu tiên: x = torch.tensor([[1.0, 2.0], [3.0, 4.0]]). In x.shape, x.dtype, x.device. Thử x.T, x.sum(), x @ x.
3. Chạy lại đoạn "Hello PyTorch" ở mục 13. Đổi batch size từ 32 sang 1, sang 100 — xem shape của y_pred thay đổi thế nào.
4. Đổi nn.ReLU() thành nn.Tanh() trong model, chạy lại. Quan sát phân phối giá trị y_pred trước và sau — có khác biệt gì rõ ràng không?
5. Liệt kê 3 tiêu chí so sánh PyTorch và TensorFlow (mục 6) mà bạn cho là quan trọng nhất với dự án/công việc của bạn. Giải thích ngắn vì sao.
6. Đọc lướt trang pytorch.org/get-started/locally — chọn đúng cấu hình của máy bạn, copy command được gợi ý ra giấy/note để dùng lại khi cài máy khác.
7. Tra docs torch.nn.Linear — viết ra 3 attribute của một Linear(784, 128): in_features, out_features, weight.shape, bias.shape.

• Framework Deep Learning cung cấp autodiff, GPU/TPU backend, layer/optimizer/loader built-in, serialization, distributed training — viết tay không thực tế cho model vừa và lớn.
• Ba framework lớn: PyTorch (Meta, 2016, BSD), TensorFlow (Google, 2015, Apache 2.0), JAX (Google, 2018, functional).
• PyTorch dynamic graph (define-by-run), Pythonic, dễ debug, đa số paper research dùng.
• TensorFlow 2.x eager mặc định + tf.function; mạnh ở production (TF Serving, TFLite, TFX) và TPU.
• JAX functional, composable, fast — phổ biến ở DeepMind, Anthropic; khó cho beginner.
• Series này dùng PyTorch ≥ 2.0 vì Pythonic, dominant trong research, first-class với HuggingFace.
• TensorFlow/Keras phù hợp khi có legacy TF, deploy TFLite mobile heavy, hoặc dùng Google Cloud TPU.
• Cài bằng pip install torch torchvision torchaudio; GPU cần URL index riêng theo CUDA version.
• Ecosystem core: torch, torch.nn, torch.optim, torch.utils.data, torchvision, torchaudio. NLP đã chuyển sang HuggingFace.
• Library bên thứ ba phổ biến: PyTorch Lightning, HuggingFace Transformers/Datasets/Accelerate, timm, skorch, PyTorch Geometric, fastai.
• Model 2 layer trong PyTorch chỉ cần nn.Sequential + nn.Linear + nn.ReLU; output là logit, truyền thẳng cho CrossEntropyLoss.
• Module 2 (Bài 12–20) sẽ đi qua tensor, GPU, autograd, nn.Module, optimizer, training loop, dataset, weight init.