وقتی هوش مصنوعی در صحرای مسطح گم می‌شود: معمای Plateau و راه‌های نجات

مقدمه

Plateau چیست و چرا با Local Optima و Saddle Point فرق دارد؟

تعریف دقیق Plateau

• Gradient بسیار کوچک است (نزدیک به صفر اما نه دقیقاً صفر)
• Loss برای تعداد زیادی iteration تقریباً ثابت می‌ماند
• مدل در حال حرکت است اما پیشرفت قابل توجهی ندارد
• شبیه راه رفتن در یک صحرای مسطح که هرچه می‌روید، منظره تغییر نمی‌کند

چرا Plateau‌ها وجود دارند؟

1. معماری شبکه: برخی معماری‌ها مثل شبکه‌های بسیار عمیق بدون residual connections، سطح loss بسیار مسطحی ایجاد می‌کنند
2. مقیاس‌بندی داده‌ها: اگر ورودی‌ها normalize نشده باشند، می‌توانند plateau‌های گسترده ایجاد کنند
3. تابع فعال‌سازی: توابعی مثل Sigmoid که در نواحی اشباع شده (saturation) دارند، باعث plateau می‌شوند
4. Learning rate نامناسب: اگر LR خیلی کوچک باشد، حتی در gradient‌های معقول هم پیشرفت بسیار کند است
5. Batch size: batch size‌های بزرگ می‌توانند noise را کاهش دهند و مدل را در plateau‌ها گیر کنند

انواع مختلف Plateau

1. Early Training Plateau (Plateau اولیه)

• وزن‌های اولیه نامناسب
• Learning rate خیلی کوچک
• مشکل در معماری شبکه

# مثال Warmup در PyTorch
def warmup_lr(step, warmup_steps=4000, d_model=512):
    return (d_model ** -0.5) * min(step ** -0.5, step * warmup_steps ** -1.5)

scheduler = LambdaLR(optimizer, lr_lambda=lambda step: warmup_lr(step))

2. Mid-Training Plateau (Plateau میانی)

• مدل به یک ناحیه مسطح رسیده که نیاز به exploration بیشتر دارد
• Learning rate برای پیشرفت در این مرحله خیلی کوچک شده
• Batch normalization statistics ثابت شده‌اند

• کاهش learning rate (Decay)
• افزایش موقت learning rate (Cyclic LR)
• تغییر batch size

3. Near-Convergence Plateau (Plateau نزدیک به همگرایی)

• مدل واقعاً در حال نزدیک شدن به minimum است
• Loss landscape خیلی مسطح شده
• Gradients طبیعتاً کوچک شده‌اند

چرا Plateau‌ها مشکل بزرگی هستند؟

1. هدر رفت منابع محاسباتی

• یک مدل GPT-style با 1 میلیارد پارامتر
• آموزش روی 8 GPU A100 (هر کدام حدود $3/ساعت)
• اگر در plateau بماند: $24/ساعت × 48 ساعت = $1,152 هدر رفت!
• در حالی که با LR scheduling مناسب، می‌توانست در 12 ساعت به همان نتیجه برسد

2. تاخیر در تحویل پروژه

• مشتری منتظر می‌ماند
• رقبا جلوتر می‌افتند
• فرصت‌های بازار از دست می‌روند

3. خطای تشخیص Early Stopping

• سیستم فکر می‌کند مدل همگرا شده
• آموزش زودتر از موعد متوقف می‌شود
• پتانسیل واقعی مدل هرگز محقق نمی‌شود

scheduler = ReduceLROnPlateau(
    optimizer, 
    mode='min',
    factor=0.5,      # LR را نصف کن
    patience=10,     # 10 epoch صبر کن
    verbose=True,
    min_lr=1e-7     # حداقل LR
)

علل علمی Plateau: چرا مدل‌ها در صحرا گم می‌شوند؟

1. Activation Function Saturation

sigmoid(x) = 1 / (1 + e^(-x))
gradient = sigmoid(x) * (1 - sigmoid(x))

برای x = 10:  gradient ≈ 0.00005
برای x = -10: gradient ≈ 0.00005

• ReLU: f(x) = max(0, x) - بدون saturation در سمت مثبت
• Leaky ReLU: gradient غیرصفر برای مقادیر منفی
• GELU: استاندارد در Transformers
• Swish/SiLU: استفاده در مدل‌های مدرن

2. Poor Initialization

# برای ReLU
weight = np.random.randn(n_in, n_out) * np.sqrt(2.0 / n_in)

3. Batch Normalization Issues

• استفاده از Layer Normalization در Transformers
• Group Normalization در Computer Vision
• تنظیم دقیق momentum در BatchNorm

4. Loss Landscape Geometry

استراتژی‌های حرفه‌ای برای عبور از Plateau

1. Learning Rate Scheduling: علم تنظیم سرعت یادگیری

الف) Step Decay (کاهش پله‌ای)

scheduler = StepLR(optimizer, step_size=30, gamma=0.1)
# هر 30 epoch، LR = LR × 0.1

ب) Cosine Annealing (کاهش کسینوسی)

scheduler = CosineAnnealingLR(optimizer, T_max=100, eta_min=1e-6)

• کاهش نرم‌تر از Step Decay
• مدل زمان بیشتری برای explore کردن دارد
• در plateau‌های میانی بهتر عمل می‌کند

ج) Warm Restarts (راه‌اندازی‌های گرم)

scheduler = CosineAnnealingWarmRestarts(
    optimizer, 
    T_0=10,     # اولین restart بعد از 10 epoch
    T_mult=2,   # هر دفعه دوره دو برابر می‌شود
    eta_min=1e-6
)

• اجازه می‌دهد مدل از plateau‌ها "بپرد"
• هر restart شبیه یک جستجوی جدید است
• می‌تواند چندین local/saddle را explore کند

د) ReduceLROnPlateau (کاهش هوشمند)

scheduler = ReduceLROnPlateau(
    optimizer,
    mode='min',
    factor=0.5,
    patience=10,
    verbose=True,
    threshold=0.0001,
    min_lr=1e-7
)

• Adaptive - خودش تشخیص می‌دهد plateau هست یا نه
• نیاز به تنظیم دستی کمتر
• برای هر نوع مدلی کار می‌کند

• ممکن است خیلی زود یا خیلی دیر react کند
• نیاز به تنظیم دقیق patience

ه) Cyclical Learning Rate (نرخ یادگیری چرخه‌ای)

from torch.optim.lr_scheduler import CyclicLR

scheduler = CyclicLR(
    optimizer,
    base_lr=1e-5,
    max_lr=1e-3,
    step_size_up=2000,
    mode='triangular2'
)

• LR بالا: اجازه escape از plateau
• LR پایین: refinement دقیق
• نوسان مداوم: مانع از گیر کردن

2. Warmup Strategy: شروع آرام، پایان قدرتمند

def get_lr(step, d_model=512, warmup_steps=4000):
    """
    فرمول استاندارد "Attention is All You Need"
    """
    arg1 = step ** (-0.5)
    arg2 = step * (warmup_steps ** (-1.5))
    return (d_model ** (-0.5)) * min(arg1, arg2)

1. Attention weights در ابتدا بسیار بی‌نظم هستند
2. Layer Normalization نیاز به چند iteration دارد تا stabilize شود
3. بدون warmup، مدل در plateau اولیه گیر می‌کند

• BERT-Base: 10,000 steps warmup
• GPT-3: تقریباً 375M tokens warmup
• T5: 10,000 steps warmup

• Vision Transformers (ViT): warmup ضروری است
• Transfer Learning: fine-tuning با warmup بهتر عمل می‌کند
• Reinforcement Learning: در بعضی الگوریتم‌ها

3. Gradient Clipping: جلوگیری از انفجار و کنترل جریان

# روش 1: Clip by norm (توصیه می‌شود)
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

# روش 2: Clip by value
torch.nn.utils.clip_grad_value_(model.parameters(), clip_value=0.5)

• RNNs و LSTMs: بدون clipping تقریباً غیرممکن است
• Transformers: معمولاً max_norm=1.0
• Reinforcement Learning: gradient variance بالا دارد

4. Batch Size Scheduling: بازی با نویز

• Batch size کوچک ← Gradient نویزی ← کمک به فرار از plateau
• Batch size بزرگ ← Gradient دقیق ← همگرایی سریع‌تر نزدیک بهینه

# شروع با BS=32، هر 10 epoch دو برابر کن تا 512
initial_bs = 32
for epoch in range(num_epochs):
    current_bs = min(initial_bs * (2 ** (epoch // 10)), 512)
    train_with_batch_size(current_bs)

• در ابتدا: exploration بیشتر، کمتر در plateau گیر می‌کند
• در انتها: همگرایی سریع‌تر و دقیق‌تر

LR_new = LR_base * sqrt(BS_new / BS_base)

5. Optimizer Switching: تغییر اسب در وسط راه

1. ابتدا: SGD با Momentum برای exploration خوب
2. بعد از Plateau: switch به Adam برای همگرایی سریع

# Phase 1: SGD
optimizer1 = SGD(model.parameters(), lr=0.1, momentum=0.9)
train_for_n_epochs(optimizer1, n=50)

# Phase 2: Adam
optimizer2 = Adam(model.parameters(), lr=0.001)
train_for_n_epochs(optimizer2, n=50)

Plateau در معماری‌های مختلف: چالش‌های خاص

1. Transformers: پادشاه Plateau‌ها

• Self-Attention Initialization: در ابتدا، attention weights تصادفی هستند
• Layer Normalization: نیاز به چند iteration برای stabilize شدن
• Position Encoding: می‌تواند gradient flow را مختل کند

# 1. Warmup
scheduler = get_linear_schedule_with_warmup(
    optimizer,
    num_warmup_steps=10000,
    num_training_steps=100000
)

# 2. Pre-LN (Layer Norm قبل از attention)
class TransformerBlock(nn.Module):
    def forward(self, x):
        # Pre-LN بهتر از Post-LN
        x = x + self.attention(self.ln1(x))
        x = x + self.ffn(self.ln2(x))
        return x
# 3. Gradient Clipping
clip_grad_norm_(model.parameters(), max_norm=1.0)

2. CNNs: Plateau در لایه‌های عمیق

• Vanishing Gradients: در لایه‌های اولیه
• Dead ReLUs: نورون‌هایی که هرگز activate نمی‌شوند

1. Residual Connections (ResNet):

class ResidualBlock(nn.Module):
    def forward(self, x):
        residual = x
        out = self.conv1(x)
        out = self.conv2(out)
        return out + residual  # Skip connection

2. Batch Normalization:

self.bn = nn.BatchNorm2d(num_features)

3. Leaky ReLU به جای ReLU:

nn.LeakyReLU(negative_slope=0.01)

3. GANs: تعادل نازک

1. Discriminator Too Strong: Generator در plateau می‌افتد چون نمی‌تواند Discriminator را فریب دهد
2. Generator Too Strong: Discriminator در plateau می‌افتد و فایده‌ای ندارد

# 1. نرخ یادگیری متفاوت
opt_G = Adam(generator.parameters(), lr=0.0001)
opt_D = Adam(discriminator.parameters(), lr=0.0004)  # D سریع‌تر

# 2. Alternate training
for epoch in range(num_epochs):
    # Train D بیشتر
    for _ in range(5):
        train_discriminator()
    # Train G یکبار
    train_generator()
# 3. Spectral Normalization
from torch.nn.utils import spectral_norm
self.conv = spectral_norm(nn.Conv2d(...))

4. RNNs و LSTMs: Plateau زمانی

1. LSTM/GRU به جای RNN ساده:

# LSTM با gate mechanism
self.lstm = nn.LSTM(input_size, hidden_size, num_layers=2)

2. Gradient Clipping (ضروری!):

clip_grad_norm_(model.parameters(), max_norm=5.0)

3. Truncated BPTT:

# به جای backprop در کل توالی، فقط 50 step
sequence_length = 50

4. یا بهتر: استفاده از Transformer! 🚀

ابزارها و تکنیک‌های مانیتورینگ Plateau

1. TensorBoard: چشم‌های شما

from torch.utils.tensorboard import SummaryWriter

writer = SummaryWriter()
# در هر iteration:
writer.add_scalar('Loss/train', loss, iteration)
writer.add_scalar('Loss/validation', val_loss, iteration)
# مهم: Gradient نرم
total_norm = 0
for p in model.parameters():
    param_norm = p.grad.data.norm(2)
    total_norm += param_norm.item() ** 2
total_norm = total_norm ** 0.5
writer.add_scalar('Gradient/norm', total_norm, iteration)
# Learning rate فعلی
writer.add_scalar('LR', scheduler.get_last_lr()[0], iteration)

• Loss مسطح برای 100+ iterations
• Gradient norm < 0.001
• Validation loss ثابت اما training loss همچنان کم می‌شود (overfitting)

2. Weights & Biases: Platform حرفه‌ای

import wandb

wandb.init(project="my-project")
# لاگ خودکار
wandb.watch(model, log='all', log_freq=100)
# Detect plateau خودکار
if wandb.run.summary.get('plateau_detected'):
    print("⚠️ Plateau detected! Consider reducing LR")

3. Custom Plateau Detector

class PlateauDetector:
    def __init__(self, patience=50, threshold=1e-4):
        self.patience = patience
        self.threshold = threshold
        self.losses = []
        
    def check(self, loss):
        self.losses.append(loss)
        if len(self.losses) < self.patience:
            return False
            
        recent = self.losses[-self.patience:]
        improvement = max(recent) - min(recent)
        
        if improvement < self.threshold:
            print(f"🚨 PLATEAU DETECTED! Improvement: {improvement:.6f}")
            return True
        return False

# استفاده:
detector = PlateauDetector(patience=100)
if detector.check(current_loss):
    # کاهش LR یا سایر اقدامات
    for param_group in optimizer.param_groups:
        param_group['lr'] *= 0.5

Case Studies: داستان‌های موفقیت و شکست

موفقیت 1: BERT و Warmup Magic

• 10,000 steps linear warmup
• بعد از warmup: linear decay
• Adam با β1=0.9, β2=0.999

• پیشرفت فوری بعد از warmup
• همگرایی در 40 epoch به جای 100+ epoch
• تفاوت دقت: 2-3٪ بهتر

موفقیت 2: ResNet و Skip Connections

• Gradient می‌تواند مستقیماً به لایه‌های اولیه برگردد
• هر لایه فقط یک residual کوچک یاد می‌گیرد
• Loss landscape صاف‌تر می‌شود

شکست: Early GANs و Plateau جهنمی

• Generator در plateau می‌افتاد ← تصاویر blurry
• Discriminator خیلی قوی می‌شد ← Mode Collapse
• ساعت‌ها tuning دستی!

• Spectral Normalization
• Self-Attention
• Progressive Growing

چک‌لیست عملی: چطور از Plateau جلوگیری کنیم؟

قبل از شروع آموزش 

• Initialization درست: He برای ReLU، Xavier برای Tanh
• معماری مناسب: استفاده از Residual connections در شبکه‌های عمیق
• Normalization: BatchNorm یا LayerNorm اضافه کنید
• Learning Rate اولیه: شروع با LR متوسط (1e-3 برای Adam)
• Warmup برنامه‌ریزی: اگر Transformer ← حتماً warmup
• Gradient Clipping: در RNN/LSTM حتماً فعال کنید

در حین آموزش 

• مانیتور Loss و Gradient Norm: هر 10-50 iteration
• TensorBoard یا wandb: برای visualization
• Validation metric: چک کنید overfitting نداشته باشید
• Learning Rate tracking: ببینید LR چقدر است

وقتی Plateau تشخیص دادید 

1. اول: صبر کنید (شاید plateau موقتی است)
   • 100-200 iteration صبر کنید
   • اگر هنوز plateau است ← گام بعدی
2. دوم: LR را کاهش دهید

   for param_group in optimizer.param_groups:
       param_group['lr'] *= 0.5
   print(f"New LR: {param_group['lr']}")

3. سوم: اگر کمک نکرد، LR را موقتاً افزایش دهید

   for param_group in optimizer.param_groups:
       param_group['lr'] *= 2.0

• این ممکن است به مدل کمک کند از plateau "بپرد"

4. چهارم: Batch size را تغییر دهید
   • کوچک‌تر کنید ← نویز بیشتر ← فرار از plateau
   • یا بزرگتر کنید ← gradient دقیق‌تر
5. پنجم: Warmup restart
   • اگر از CosineAnnealingWarmRestarts استفاده می‌کنید، منتظر restart بمانید

اقدامات طولانی‌مدت 🔧

• معماری را بازنگری کنید: شاید Skip connections نیاز دارید
• Activation function: از ReLU به GELU یا Swish تغییر دهید
• Optimizer را عوض کنید: از Adam به AdamW یا SGD
• Data Augmentation بیشتر: شاید overfitting دارید
• Regularization اضافه کنید: Dropout، Weight Decay

آینده: AI هایی که خودشان Plateau را حل می‌کنند

Auto-LR: یادگیری خودکار Learning Rate

# هر لایه LR خودش را دارد
for layer in model.layers:
    layer_lr = base_lr * layer_trust_coefficient(layer)

Meta-Learning برای Optimization

class LearnedOptimizer(nn.Module):
    def __init__(self):
        self.lstm = nn.LSTM(...)
        
    def forward(self, gradients, loss_history):
        # به جای gradient descent ساده
        # از LSTM برای تصمیم‌گیری استفاده کن
        update = self.lstm(gradients, loss_history)
        return update

Automated Architecture Search

نتیجه‌گیری: هنر مدیریت Plateau

• زمان آموزش را 30-50٪ کاهش دهید
• هزینه‌های GPU را به طرز چشمگیری کم کنید
• به نتایج بهتری برسید
• استرس کمتری در طول آموزش داشته باشید!