Разбор Weight Decay: Как регуляризация не стирает, а фиксирует старые знания

Две задачи с разной топологией:

1. Конфликт Топологий

Две задачи, требующие принципиально разной организации весов:

Задача A: «Шахматная доска» (Parity)

• Label = (floor(x) + floor(y)) % 2

• Высокочастотная, разрывная функция. Требует от нейросети построения множества четких границ («стен») между классами 0 и 1. Точка (0.7, 1.3) → ⌊0⌋ + ⌊1⌋ = 1 → класс 1

• Это воспоминание, которое пытаемся стереть.

Задача B: «Седло» (Saddle)

• z = (x^2 - y^2) / 5

• Низкочастотная, гладкая функция. Это классическая регрессия, требующая непрерывного преобразования координат.

• Это новая задача, которую навязываем модели.

Задачи геометрически ортогональны. Для решения Parity нужно квантовать пространство, а для Saddle нужно его интерполировать.

2. Протокол Эксперимента (Timeline)

Пространство x, y разделено на две зоны:

• Пончик (Donut, R > 1.5): Здесь модель получает градиенты во время переобучения.

• Слепое пятно (Blind Spot, R < 1.5): Здесь задача B не учится, только проверяется, что осталось в голове у модели.

Эксперимент проходит в три этапа для двух групп моделей:

Группа 1: CONTROL (Tabula Rasa)

Чистый эксперимент, имитирующий обучение с нуля.

1. Imprinting: Пропуск. Веса инициализируются случайно (Kaiming init).

2. Adaptation (Обучение): Учим задачу Saddle только на «Пончике».

   • Ожидание: Модель выучит форму седла по краям и интерполирует её в центр (так как функция гладкая).

3. Test: Замораживаем модель. Запускаем «Зонд» в центр.

Группа 2: IMPRINTING (Память)

Эксперимент на выживание структуры.

1. Imprinting (Запечатление): Учим задачу Parity на всём пространстве (включая центр).

   • Веса модели формируют сложную «решетку» для разделения классов. Точность ~99%.

2. Adaptation (Переобучение): Меняем задачу на Saddle. Учим только на «Пончике». Включаем Weight Decay.

   • Оптимизатор должен снизить Loss по седлу на периферии, не имея данных о центре.

3. Test: Замораживаем модель, зондируем центр.

3. Механизм работы зонда (The Probe)

Что измеряется

Ученик (зонд) — это отдельная, маленькая нейросеть (обычно линейный классификатор или 2-слойный MLP), которая ставится поверх замороженного учителя (основной модели).

Алгоритм проверки:

1. Берем тестовые данные X_center из слепого пятна.

2. Прогоняем их через учителя: V = Teacher(X_center).

   • Учитель в этот момент не учится (weights frozen). Мы просто снимаем его внутреннее представление (эмбеддинги) или выходной вектор.

3. Подаем вектора на вход ученику.

4. Ученик пытается предсказать Задача А (Parity).

Логика: Ученик никогда не видит координат x, y. Он видит только то, как учитель обработал эти координаты.

Интерпретация точности Ученика:

• Если Accuracy ~50-60%: Учитель выдал хаос. Вектора V не содержат информации о шахматном порядке. Структура разрушена.

• Если Accuracy ~90-95% (при WD=0): Учитель идеально закодировал координаты (Generalization). Ученик использовал это, чтобы выучить Parity заново.

• Если Accuracy ~80-85% (при WD=1e-3, где Control упал): Это структурная память. Учитель выдал вектора, которые уже сгруппированы в кластеры по старой памяти.

import torch import torch.nn as nn import torch.optim as optim import numpy as np # ========================================== # 1. КОНФИГУРАЦИЯ # ========================================== N_RUNS_PER_WD = 20 # Увеличили для надежности (займет время!) N_SAMPLES = 5000 BLIND_RADIUS = 1.5 OUTPUT_B_DIM = 20 # Детальная сетка Weight Decay (логарифмическая шкала + точки интереса) WD_VALUES = [ 0.0, 1e-5, 5e-5, 1e-4, 3e-4, 6e-4, 1e-3, # Ожидаемый "Sweet Spot" 2e-3, 4e-3, 7e-3, 1e-2, 2e-2 # Зона полной смерти ] # ========================================== # 2. ФУНКЦИИ (Генерация данных) # ========================================== def task_A_Parity(x): grid_x = torch.floor(x[:, 0]); grid_y = torch.floor(x[:, 1]) return ((grid_x + grid_y) % 2 == 0).float().unsqueeze(1) def task_B_Saddle(x): return ((x[:, 0]**2 - x[:, 1]**2) / 5.0).unsqueeze(1) def get_full_data(n): X = (torch.rand(n, 2) * 6 - 3); return X, task_A_Parity(X) def get_donut_data(n): X_list = [] while len(X_list) < n: batch = (torch.rand(n, 2) * 6 - 3) R = torch.norm(batch, dim=1) mask = (R > BLIND_RADIUS) & (R < 3.5) X_list.append(batch[mask]) X = torch.cat(X_list)[:n]; return X, task_B_Saddle(X) def get_center_data(n): X_list = [] while len(X_list) < n: batch = (torch.rand(n, 2) * 6 - 3) R = torch.norm(batch, dim=1) mask = R < BLIND_RADIUS X_list.append(batch[mask]) X = torch.cat(X_list)[:n]; return X, task_A_Parity(X) # ========================================== # 3. МОДЕЛЬ # ========================================== class Teacher(nn.Module): def __init__(self): super().__init__() self.core = nn.Sequential( nn.Linear(2, 128), nn.ReLU(), nn.Linear(128, 128), nn.ReLU(), nn.Linear(128, 32) ) self.head_a = nn.Linear(32, 1); self.head_b = nn.Linear(32, OUTPUT_B_DIM) def forward_A(self, x): return torch.sigmoid(self.head_a(self.core(x))) def forward_B(self, x): return self.head_b(self.core(x)) # ========================================== # 4. ЛОГИКА ОБУЧЕНИЯ И ТЕСТА # ========================================== def run_comparison(wd_value): def train_and_probe(scenario): teacher = Teacher() # 1. IMPRINTING if scenario == 'IMPRINTING': X_full, Y_par = get_full_data(N_SAMPLES) opt = optim.Adam(teacher.parameters(), lr=0.01) crit = nn.BCELoss() for _ in range(300): loss = crit(teacher.forward_A(X_full), Y_par) opt.zero_grad(); loss.backward(); opt.step() # 2. ADAPTATION (Weight Decay применяется здесь) X_donut, Y_sad = get_donut_data(N_SAMPLES) opt = optim.Adam(teacher.parameters(), lr=0.001, weight_decay=wd_value) crit = nn.MSELoss() for _ in range(800): # Важно: ограничиваем среднее, чтобы дать свободу скрытым измерениям loss = crit(teacher.forward_B(X_donut).mean(dim=1, keepdim=True), Y_sad) opt.zero_grad(); loss.backward(); opt.step() # 3. PROBE (Test в центре) X_cen, Y_par_cen = get_center_data(1000) teacher.eval() with torch.no_grad(): V = teacher.forward_B(X_cen) # Проверка на "смерть" нейронов if V.std().item() < 0.001: return 0.5 student = nn.Sequential(nn.Linear(OUTPUT_B_DIM, 64), nn.ReLU(), nn.Linear(64, 1), nn.Sigmoid()) opt_s = optim.Adam(student.parameters(), lr=0.01) crit_s = nn.BCELoss() for _ in range(300): loss = crit_s(student(V.detach()), Y_par_cen) opt_s.zero_grad(); loss.backward(); opt_s.step() with torch.no_grad(): return ((student(V) > 0.5) == Y_par_cen).float().mean().item() return train_and_probe('CONTROL'), train_and_probe('IMPRINTING') # ========================================== # 5. ЗАПУСК И СБОР СТАТИСТИКИ # ========================================== print(f"ЗАПУСК ДЕТАЛЬНОГО СКАНИРОВАНИЯ: {len(WD_VALUES)} точек, по {N_RUNS_PER_WD} прогонов.") print("="*105) print(f"{'Weight Decay':<12} | {'Control':<10} | {'Imprint':<10} | {'LEAKAGE':<10} | {'Std Dev':<10} | {'Status':<25}") print("-" * 105) stats = [] for wd in WD_VALUES: c_list, i_list = [], [] for i in range(N_RUNS_PER_WD): c, m = run_comparison(wd) c_list.append(c); i_list.append(m) # Небольшой индикатор прогресса внутри точки if i % 5 == 0: print(".", end="", flush=True) print("", end="\r") # Очистка строки точек mc, mi = np.mean(c_list), np.mean(i_list) std_i = np.std(i_list) # Разброс Imprinting важнее всего leak = mi - mc stats.append((wd, leak)) # Автоматическая классификация режима if mc > 0.85 and mi > 0.85: status = "Overfitting (Both High)" elif mc < 0.60 and mi > 0.75: status = ">>> MEMORY ZONE <<<" elif mc < 0.60 and mi < 0.60: status = "Erasure (Both Low)" else: status = "Transition" # Рисуем "звездочки" утечки bar = "*" * int(leak * 100 / 2.5) # 1 звезда на 2.5% print(f"{wd:<12.1e} | {mc:.1%} | {mi:.1%} | +{leak:.1%} {bar:<10} | +/-{std_i:.1%} | {status}") print("="*105) best = max(stats, key=lambda x: x[1]) print(f"ПИКОВАЯ УТЕЧКА: +{best[1]:.2%} при WD={best[0]}")