بهینه‌سازها و برنامه‌های زمان‌بندی نرخ یادگیری

def lr(self, step: int) -> float:
    if step < 0:
        raise ValueError(f"step must be non-negative, got {step}")
    if self.warmup_steps > 0 and step <= self.warmup_steps:
        return self.lr_max * (step / self.warmup_steps)  # 0 در گام 0
    if step >= self.total_steps:
        return self.lr_min                               # کف، بدون برونیابی
    decay_span = max(1, self.total_steps - self.warmup_steps)
    progress = (step - self.warmup_steps) / decay_span
    cosine = 0.5 * (1.0 + math.cos(math.pi * progress))
    return self.lr_min + (self.lr_max - self.lr_min) * cosine

self.optimizer.zero_grad(set_to_none=True)
with torch.amp.autocast(device_type=self.device_type, dtype=self.amp_dtype):
    predictions = self.model(inputs)
    loss = self._loss_fn(predictions, targets)
if not torch.isfinite(loss).all().item():  # رد شدن، update() را فراخوانی نکنید
    return self._record_skip(...)
self.scaler.scale(loss).backward()
self.scaler.unscale_(self.optimizer)       # clip پس از unscale
if has_non_finite_grad(self.model.parameters()):
    self.scaler.update()                   # رد شدن، مقیاس‌بخش نصف می‌شود
pre_clip, post_clip = clip_global_l2_norm(list(self.model.parameters()), self.max_norm)
self.scaler.step(self.optimizer)
self.scaler.update()                       # فاکتور را دوبرابر یا نصف می‌کند

accumulation_steps = effective_batch // (micro_batch * world_size)
for x, y in chunks(x_full, y_full, n):   # n میکروبچ
    scaled = criterion(model(x), y) / n  # تقسیم قبل از backward
    scaled.backward()                    # گرادیان‌ها در param.grad جمع می‌شوند
opt.step()                               # یک‌بار به‌ازای هر دسته‌ی مؤثر
with no_sync_context(model):             # همه‌ی میکروبچ‌ها به‌جز آخری
    loss.backward()