Khi tích lũy gradient qua các microbatch có kích thước khác nhau, chia mỗi loss trung bình cho cùng một số lượt có thể làm sai trọng số của từng mẫu. Với 23 mẫu được chia thành 8 + 8 + 7, loss của ba microbatch cần nhân lần lượt với 8/23, 8/23 và 7/23. Nếu dùng gradient clipping để mô phỏng một batch 23 mẫu, hãy clip một lần sau khi đã cộng đủ gradient.
Thí nghiệm CPU dưới đây so trực tiếp gradient và tham số sau một bước SGD. Cách cân theo số mẫu khớp batch đầy đủ trong sai số làm tròn; chia đều cho ba microbatch tạo sai lệch gradient lớn nhất khoảng 0,140258. Không cần huấn luyện nhiều epoch hay nhìn đường loss để phát hiện lỗi này.
Đang lấy trung bình trên mẫu hay trên microbatch?
Một microbatch ở đây là phần dữ liệu đi qua một lượt forward/backward. Một cửa sổ tích lũy gồm các microbatch góp vào cùng một lần optimizer.step(). Nếu cần ôn cách đếm các lượt này, xem epoch, batch size, iteration và số lần cập nhật trọng số.
Giả sử cửa sổ có $K$ microbatch, microbatch thứ $i$ có $n_i$ mẫu và loss trung bình $L_i$. Tổng số mẫu là $N=\sum_i n_i$. Với loss độc lập theo mẫu và cùng số phần tử loss trên mỗi mẫu, loss trung bình của cả cửa sổ là:
$$ L = \sum_{i=1}^{K} \frac{n_i}{N} L_i $$Do tính tuyến tính của đạo hàm, giữ nguyên tham số trong cả cửa sổ rồi cộng gradient của từng $L_i n_i/N$ cho kết quả tương ứng với $\nabla L$. PyTorch cộng gradient vào .grad qua các lần backward(), nên chỉ xóa gradient ở ranh giới cửa sổ. Mỗi forward ở đây tạo đồ thị mới; không cần retain_graph=True. Tài liệu Tensor.backward
Nếu thay $n_i/N$ bằng $1/K$, ta đang tối ưu trung bình của các trung bình microbatch. Hai biểu thức trùng nhau khi mọi microbatch có cùng kích thước. Với 8 + 8 + 7 và $K=3$:
| Microbatch | Trọng số của mỗi mẫu khi chia loss cho 3 | Trọng số mục tiêu |
|---|---|---|
| 8 mẫu đầu | 1/24 | 1/23 |
| 8 mẫu kế | 1/24 | 1/23 |
| 7 mẫu cuối | 1/21 | 1/23 |
Các mẫu trong microbatch cuối được nhấn mạnh hơn. Đây là thay đổi hàm mục tiêu, không chỉ là nhiễu do cộng số thực theo thứ tự khác.
Trong ví dụ, MSELoss(reduction="mean") chia tổng bình phương sai số cho số phần tử đầu ra. Vì mỗi mẫu chỉ có một giá trị dự đoán, số phần tử bằng số mẫu. Nếu mỗi mẫu có cùng nhiều đầu ra, tỷ lệ $n_i/N$ vẫn đúng. Với token bị mask, độ dài chuỗi khác nhau hoặc loss có trọng số, phải xác định mẫu số thực của phép reduction trước khi áp dụng công thức. Tài liệu MSELoss
Đo sai lệch gradient trước khi đo chất lượng mô hình
Mã dùng Python 3.10.11, PyTorch 2.8.0, CPU, float64, một luồng và seed 20261118. Dữ liệu tổng hợp có ba đặc trưng, một đầu ra; mô hình Linear(3, 1); SGD có learning rate 0,1 và không dùng momentum. Mỗi phương án bắt đầu từ cùng một bản sao trọng số, chỉ cập nhật một lần. Không có BatchNorm, Dropout, mixed precision hay huấn luyện phân tán.
Hai đại lượng được đo là sai lệch tuyệt đối lớn nhất giữa các phần tử gradient và giữa các phần tử tham số sau bước cập nhật. Phần không clipping dùng batch đầy đủ 23 mẫu làm chuẩn; phần clipping dùng batch đầy đủ đã clip ở ngưỡng norm 0,5 làm chuẩn riêng.
| Phương án | Sai lệch gradient lớn nhất | Sai lệch tham số lớn nhất |
|---|---|---|
| Cân loss theo 8/23, 8/23, 7/23; không clip | 4,440892e-16 | 4,163336e-17 |
| Chia mỗi loss cho 3; không clip | 1,402579e-1 | 1,402579e-2 |
| Cân đúng; clip một lần cuối cửa sổ | 2,775558e-17 | 0 |
Cân đúng; clip .grad sau từng backward |
1,482930e-1 | 1,482930e-2 |
Các số trên được lấy từ lần chạy thực tế, không phải giới hạn bảo đảm trên mọi máy. Các phép so đúng có assert_close với sai số tuyệt đối $10^{-12}$ và sai số tương đối bằng 0. float64 giúp quan sát lỗi logic tách khỏi sai số làm tròn thông thường; đây không phải benchmark tốc độ hay khuyến nghị dùng float64 cho mọi bài huấn luyện.
Lưu đoạn sau thành accumulation_check.py, chạy bằng python3 accumulation_check.py trong môi trường có PyTorch 2.8.0:
1from copy import deepcopy
2import json
3import platform
4
5import torch
6from torch import nn
7from torch.nn import functional as F
8from torch.utils.data import DataLoader, TensorDataset
9
10SEED = 20261118
11LR = 0.1
12MAX_NORM = 0.5
13DTYPE = torch.float64
14
15
16def parameter_vector(model, gradients=False):
17 values = [parameter.grad if gradients else parameter for parameter in model.parameters()]
18 return torch.cat([value.detach().flatten() for value in values]).clone()
19
20
21def make_data(size):
22 generator = torch.Generator().manual_seed(SEED)
23 x = torch.randn((size, 3), generator=generator, dtype=DTYPE)
24 y = x @ torch.tensor([[2.0], [-3.0], [0.5]], dtype=DTYPE)
25 y += 0.1 * torch.randn((size, 1), generator=generator, dtype=DTYPE)
26 return x, y
27
28
29def one_step(initial, x, y, sizes, weights, clip_each=False, clip_end=False):
30 model = deepcopy(initial)
31 optimizer = torch.optim.SGD(model.parameters(), lr=LR)
32 optimizer.zero_grad(set_to_none=True)
33 for xb, yb, weight in zip(x.split(sizes), y.split(sizes), weights):
34 (F.mse_loss(model(xb), yb, reduction="mean") * weight).backward()
35 if clip_each:
36 nn.utils.clip_grad_norm_(model.parameters(), MAX_NORM)
37 if clip_end:
38 nn.utils.clip_grad_norm_(model.parameters(), MAX_NORM)
39 gradients = parameter_vector(model, gradients=True)
40 optimizer.step()
41 return gradients, parameter_vector(model)
42
43
44def comparison(scenario, method, result, reference, should_match):
45 gradients, parameters = result
46 ref_gradients, ref_parameters = reference
47 grad_error = (gradients - ref_gradients).abs().max().item()
48 param_error = (parameters - ref_parameters).abs().max().item()
49 if should_match:
50 torch.testing.assert_close(gradients, ref_gradients, rtol=0, atol=1e-12)
51 torch.testing.assert_close(parameters, ref_parameters, rtol=0, atol=1e-12)
52 else:
53 assert grad_error > 1e-6 and param_error > 1e-6
54 return {
55 "scenario": scenario,
56 "method": method,
57 "max_abs_gradient_error": grad_error,
58 "max_abs_parameter_error": param_error,
59 "gradient_norm": gradients.norm().item(),
60 }
61
62
63def train_epoch(model, optimizer, loader, accumulation_steps=3, max_norm=MAX_NORM):
64 """Mean MSE over all loss elements in each accumulation window of a sized loader."""
65 if accumulation_steps < 1:
66 raise ValueError("accumulation_steps must be positive")
67 model.train()
68 optimizer.zero_grad(set_to_none=True)
69 elements = 0
70 steps = 0
71 for micro_step, (xb, yb) in enumerate(loader, start=1):
72 prediction = model(xb)
73 if prediction.shape != yb.shape:
74 raise ValueError("prediction and target shapes must match")
75 squared_errors = F.mse_loss(prediction, yb, reduction="none")
76 squared_errors.sum().backward()
77 elements += squared_errors.numel()
78 if micro_step % accumulation_steps == 0 or micro_step == len(loader):
79 for parameter in model.parameters():
80 if parameter.grad is not None:
81 parameter.grad.div_(elements)
82 nn.utils.clip_grad_norm_(model.parameters(), max_norm)
83 optimizer.step()
84 optimizer.zero_grad(set_to_none=True)
85 elements = 0
86 steps += 1
87 return steps
88
89
90def check_epoch(initial):
91 x, y = make_data(47)
92 accumulated = deepcopy(initial)
93 optimizer = torch.optim.SGD(accumulated.parameters(), lr=LR)
94 loader = DataLoader(TensorDataset(x, y), batch_size=8, shuffle=False)
95 steps = train_epoch(accumulated, optimizer, loader)
96
97 reference = deepcopy(initial)
98 ref_optimizer = torch.optim.SGD(reference.parameters(), lr=LR)
99 for xb, yb in zip(x.split((24, 23)), y.split((24, 23))):
100 ref_optimizer.zero_grad(set_to_none=True)
101 F.mse_loss(reference(xb), yb, reduction="mean").backward()
102 nn.utils.clip_grad_norm_(reference.parameters(), MAX_NORM)
103 ref_optimizer.step()
104 actual, expected = parameter_vector(accumulated), parameter_vector(reference)
105 torch.testing.assert_close(actual, expected, rtol=0, atol=1e-12)
106 assert steps == 2
107 return {
108 "samples": 47,
109 "microbatch_sizes": [8, 8, 8, 8, 8, 7],
110 "full_batch_window_sizes": [24, 23],
111 "optimizer_steps": steps,
112 "max_abs_parameter_error": (actual - expected).abs().max().item(),
113 }
114
115
116def main():
117 torch.set_num_threads(1)
118 torch.manual_seed(SEED)
119 initial = nn.Linear(3, 1, dtype=DTYPE)
120 rows = []
121 for size, sizes in ((23, (8, 8, 7)), (24, (8, 8, 8)), (16, (8, 8))):
122 x, y = make_data(size)
123 reference = one_step(initial, x, y, (size,), (1.0,))
124 weighted = one_step(initial, x, y, sizes, [n / size for n in sizes])
125 naive = one_step(initial, x, y, sizes, [1 / 3] * len(sizes))
126 scenario = f"N={size}, microbatches={list(sizes)}, K=3"
127 rows.append(comparison(scenario, "sample_weighted", weighted, reference, True))
128 rows.append(comparison(scenario, "divide_by_fixed_K", naive, reference, size == 24))
129 if size == 16:
130 torch.testing.assert_close(naive[0], reference[0] * (2 / 3), rtol=0, atol=1e-12)
131 if size == 23:
132 clipped_reference = one_step(initial, x, y, (size,), (1.0,), clip_end=True)
133 correct = one_step(initial, x, y, sizes, [n / size for n in sizes], clip_end=True)
134 early = one_step(initial, x, y, sizes, [n / size for n in sizes], clip_each=True)
135 rows.append(comparison("N=23, clipping max_norm=0.5", "clip_after_window", correct, clipped_reference, True))
136 rows.append(comparison("N=23, clipping max_norm=0.5", "clip_after_each_backward", early, clipped_reference, False))
137 print(json.dumps({
138 "python": platform.python_version(),
139 "torch": torch.__version__,
140 "device": "cpu",
141 "dtype": str(DTYPE),
142 "seed": SEED,
143 "threads": 1,
144 "learning_rate": LR,
145 "optimizer": "SGD, one step per window",
146 "loss": "MSE mean, one output per sample",
147 "rows": rows,
148 "epoch_loop_check": check_epoch(initial),
149 }, indent=2))
150
151
152if __name__ == "__main__":
153 main()
Vì sao clip sau từng backward cho kết quả khác?
clip_grad_norm_ lấy norm trên gradient của các tham số như một vector ghép lại và sửa gradient tại chỗ. Nó không phải phép biến đổi tuyến tính: clip một tổng không tương đương clip một phần tổng rồi cộng tiếp và clip lại. Tài liệu clip_grad_norm_
Trong mã, clip_each=True cắt gradient đang tích lũy sau mỗi backward. Phần đóng góp đến sớm có thể bị thu nhỏ nhiều lần, trong khi phần đóng góp đến sau chưa bị tác động bởi những lần cắt trước. Đây là một thuật toán cập nhật khác với clip gradient của toàn batch một lần.
Norm gradient trước clipping của batch đầy đủ đo được là 7.514010800767387. Sau clipping cuối cửa sổ, norm là khoảng 0.4999999335; khi clip sau từng backward, norm cuối là khoảng 0.4999998286. Cả hai đều gần 0,5, nhưng hướng gradient khác nhau như hàng cuối bảng. Vì thế kiểm tra “norm đã dưới ngưỡng” chưa đủ để xác nhận tích lũy đúng.
Xử lý cửa sổ cuối mà không cần biết trước kích thước
Có hai chuyện riêng cần kiểm tra: microbatch cuối ít mẫu hơn và cửa sổ cuối có ít lượt hơn cấu hình. Nếu đặt accum_steps=3 nhưng cuối epoch chỉ còn hai microbatch bằng nhau, chia mỗi loss cho 3 rồi vẫn gọi step() sẽ thu gradient xuống còn 2/3 so với trung bình của cửa sổ thực tế. Gọi thêm một bước cuối chỉ xử lý phần gradient bị bỏ sót; mẫu số vẫn cần đúng.
Mã cũng chạy hai đối chứng không clipping: với 24 mẫu chia 8 + 8 + 8, cách chia loss cho 3 khớp gradient chuẩn trong sai số 8.881784e-16. Với 16 mẫu chia 8 + 8 nhưng vẫn chia loss cho 3, kiểm tra xác nhận gradient bằng 2/3 gradient chuẩn trong dung sai đã nêu; sai lệch gradient lớn nhất là 1.903300e0.
Hàm train_epoch trong mã dùng MSE với reduction="none", cộng các phần tử loss khi backward, đếm tổng số phần tử rồi chia .grad cho tổng đó trước clipping và cập nhật. Cách này không cần giữ các đồ thị tính toán hoặc toàn bộ dữ liệu của cửa sổ trong bộ nhớ.
Hàm yêu cầu loader có len(), các tensor đầu vào/đích đã đặt trên thiết bị phù hợp, MSE không mask, không thêm hạng regularization vào loss và không AMP. Hàm kiểm tra shape dự đoán bằng shape đích để tránh broadcast ngoài ý muốn. Chạy kiểm tra với 47 mẫu, DataLoader(batch_size=8, shuffle=False), accum_steps=3 tạo hai cửa sổ 24 và 23 mẫu. Hàm check_epoch chạy phép so với hai bước trên batch đầy đủ tương ứng. Kết quả thực tế có hai lần cập nhật và sai lệch tham số lớn nhất bằng 0 trên môi trường này.
Nếu loss có hạng regularization, cần xác định riêng hệ số của hạng đó: cộng nó vào mỗi microbatch rồi chia toàn bộ gradient theo số phần tử có thể làm hệ số phụ thuộc cách chia batch. Với AMP, gradient cần được unscale sau khi tích lũy hoàn tất và trước clipping; scale phải giữ nguyên trong cửa sổ. Đó là hướng dẫn của PyTorch, chưa phải nhánh đã đo trong thí nghiệm CPU này. Ví dụ chính thức về AMP và gradient accumulation
Khi nào tích lũy vẫn không giống một batch lớn?
So sánh trên chỉ kiểm chứng mô hình có phép tính độc lập theo mẫu, cùng hàm mục tiêu và cùng một lần optimizer cập nhật. Với BatchNorm ở train, mỗi forward vẫn dùng thống kê của microbatch hiện tại; cân loss đúng không biến các thống kê đó thành thống kê batch lớn. Xem thí nghiệm BatchNorm và LayerNorm khi batch nhỏ.
Dropout và các phép ngẫu nhiên có thể tạo khác biệt giữa hai cách chia forward nếu không kiểm soát được các lần lấy mẫu. Phép cộng số thực khác thứ tự cũng không bảo đảm khớp từng bit. Với loss đối chiếu phụ thuộc các mẫu khác trong batch, huấn luyện phân tán hoặc loss theo token có mask, cần xây dựng phép đối chiếu riêng theo chính hàm mục tiêu đang dùng.
Khi chuyển một vòng lặp sang gradient accumulation, phép kiểm tra hữu ích đầu tiên là giữ cùng dữ liệu và trọng số ban đầu, so gradient trước step(), rồi so tham số sau step(). Nếu hai kết quả lệch đáng kể, kiểm tra mẫu số loss, ranh giới zero_grad()/step() và thời điểm clipping trước khi điều chỉnh learning rate.
Bình luận