Что такое learning rate scheduler?

Что такое learning rate scheduler?

Learning rate scheduler - это техника для динамического изменения скорости обучения (learning rate) во время тренировки модели. Вместо использования фиксированного learning rate на протяжении всей тренировки, scheduler автоматически понижает или иным образом модифицирует learning rate согласно заранее определенному расписанию. Это может значительно улучшить качество модели и скорость сходимости.

Зачем нужен learning rate scheduler?

Проблемы с фиксированным learning rate:

1. Слишком высокий - модель может прыгать через оптимумы и не сходиться
2. Слишком низкий - тренировка очень медленная
3. Компромисс - высокий на ранних этапах (быстрое продвижение), низкий на поздних (точное приближение к минимуму)

Learning rate scheduler решает эту проблему автоматически.

Основные виды schedulers

1. Step Decay (Пошаговое снижение)

Уменьшает learning rate на фиксированный множитель через определенное число epochs.

import numpy as np
import matplotlib.pyplot as plt

def step_decay(epoch, initial_lr=0.1, drop_rate=0.5, epochs_drop=10):
    """Формула: lr = initial_lr * (drop_rate ^ floor(epoch / epochs_drop))"""
    lr = initial_lr * (drop_rate ** (epoch // epochs_drop))
    return lr

epochs = np.arange(0, 100)
lr_values = [step_decay(e) for e in epochs]

plt.figure(figsize=(10, 6))
plt.plot(epochs, lr_values, marker='o', markersize=3)
plt.xlabel('Epoch')
plt.ylabel('Learning Rate')
plt.title('Step Decay Schedule')
plt.grid(True, alpha=0.3)
plt.show()

# В TensorFlow/Keras
import tensorflow as tf

def scheduler(epoch, lr):
    if epoch < 10:
        return lr
    else:
        return lr * 0.5

callback = tf.keras.callbacks.LearningRateScheduler(scheduler)
model.fit(X_train, y_train, epochs=100, callbacks=[callback])

2. Exponential Decay (Экспоненциальное снижение)

Линейно уменьшает learning rate согласно экспоненциальной функции.

def exponential_decay(epoch, initial_lr=0.1, decay_rate=0.95):
    """Формула: lr = initial_lr * (decay_rate ^ epoch)"""
    lr = initial_lr * (decay_rate ** epoch)
    return lr

epochs = np.arange(0, 100)
lr_values = [exponential_decay(e) for e in epochs]

plt.figure(figsize=(10, 6))
plt.plot(epochs, lr_values, 'b-', label='Exponential Decay')
plt.xlabel('Epoch')
plt.ylabel('Learning Rate')
plt.title('Exponential Decay Schedule')
plt.grid(True, alpha=0.3)
plt.legend()
plt.show()

# В TensorFlow
schedule = tf.keras.optimizers.schedules.ExponentialDecay(
    initial_learning_rate=0.1,
    decay_steps=1000,
    decay_rate=0.96
)
optimizer = tf.keras.optimizers.Adam(learning_rate=schedule)

3. Linear Decay (Линейное снижение)

Линейно уменьшает learning rate от начального значения к нулю.

def linear_decay(epoch, initial_lr=0.1, total_epochs=100):
    """Формула: lr = initial_lr * (1 - epoch / total_epochs)"""
    lr = initial_lr * (1 - epoch / total_epochs)
    return lr

epochs = np.arange(0, 100)
lr_values = [linear_decay(e) for e in epochs]

plt.plot(epochs, lr_values, 'g-', label='Linear Decay')
plt.show()

4. Cosine Annealing (Косинусное отжиг)

Использует косинусную функцию для плавного снижения learning rate. Популярна в современных моделях.

def cosine_annealing(epoch, initial_lr=0.1, total_epochs=100):
    """Формула: lr = initial_lr * (1 + cos(pi * epoch / total_epochs)) / 2"""
    lr = initial_lr * (1 + np.cos(np.pi * epoch / total_epochs)) / 2
    return lr

epochs = np.arange(0, 100)
lr_values = [cosine_annealing(e) for e in epochs]

plt.figure(figsize=(10, 6))
plt.plot(epochs, lr_values, 'r-', linewidth=2)
plt.xlabel('Epoch')
plt.ylabel('Learning Rate')
plt.title('Cosine Annealing Schedule')
plt.grid(True, alpha=0.3)
plt.show()

# В TensorFlow
schedule = tf.keras.optimizers.schedules.CosineDecay(
    initial_learning_rate=0.1,
    decay_steps=1000,
    alpha=0.0  # Минимальный learning rate
)
optimizer = tf.keras.optimizers.Adam(learning_rate=schedule)

5. Warm-up Scheduler

Начинается с низкого learning rate и постепенно увеличивается, затем снижается. Часто используется в Трансформерах.

def warmup_schedule(step, initial_lr=0.0, peak_lr=0.1, warmup_steps=1000, total_steps=10000):
    """Теплый старт + линейное снижение"""
    if step < warmup_steps:
        # Линейный рост
        return initial_lr + (peak_lr - initial_lr) * (step / warmup_steps)
    else:
        # Линейное снижение
        remaining_steps = total_steps - warmup_steps
        return peak_lr * (1 - (step - warmup_steps) / remaining_steps)

steps = np.arange(0, 10000)
lr_values = [warmup_schedule(s) for s in steps]

plt.figure(figsize=(12, 6))
plt.plot(steps, lr_values, 'purple', linewidth=2)
plt.xlabel('Training Step')
plt.ylabel('Learning Rate')
plt.title('Warmup Scheduler (трансформеры)')
plt.axvline(x=1000, color='r', linestyle='--', label='End of warmup')
plt.grid(True, alpha=0.3)
plt.legend()
plt.show()

6. Cyclical Learning Rate

Периодически увеличивает и уменьшает learning rate. Может помочь избежать локальных минимумов.

def cyclical_learning_rate(epoch, min_lr=0.001, max_lr=0.1, cycle_length=20):
    """Циклическое изменение learning rate"""
    position_in_cycle = epoch % cycle_length
    if position_in_cycle < cycle_length // 2:
        # Первая половина - увеличение
        return min_lr + (max_lr - min_lr) * (position_in_cycle / (cycle_length // 2))
    else:
        # Вторая половина - уменьшение
        remaining = position_in_cycle - cycle_length // 2
        return max_lr - (max_lr - min_lr) * (remaining / (cycle_length // 2))

epochs = np.arange(0, 200)
lr_values = [cyclical_learning_rate(e) for e in epochs]

plt.plot(epochs, lr_values, 'orange', linewidth=2)
plt.xlabel('Epoch')
plt.ylabel('Learning Rate')
plt.title('Cyclical Learning Rate')
plt.grid(True, alpha=0.3)
plt.show()

ReduceLROnPlateau (Адаптивный scheduler)

Автоматически снижает learning rate, если метрика качества перестает улучшаться.

from tensorflow.keras.callbacks import ReduceLROnPlateau

# Снижает LR в 10 раз, если validation loss не улучшается 5 epochs
reduce_lr = ReduceLROnPlateau(
    monitor='val_loss',
    factor=0.1,
    patience=5,
    min_lr=1e-6,
    verbose=1
)

model.fit(
    X_train, y_train,
    validation_data=(X_val, y_val),
    epochs=100,
    callbacks=[reduce_lr]
)

Практический пример: полный pipeline

import tensorflow as tf
from tensorflow.keras import layers

# Создание модели
model = tf.keras.Sequential([
    layers.Dense(256, activation='relu', input_shape=(784,)),
    layers.Dropout(0.2),
    layers.Dense(128, activation='relu'),
    layers.Dropout(0.2),
    layers.Dense(10, activation='softmax')
])

# Косинусное отжигание с теплым стартом
lr_schedule = tf.keras.optimizers.schedules.PolynomialDecay(
    initial_learning_rate=0.1,
    decay_steps=10000,
    end_learning_rate=0.0001,
    power=1.0
)

optimizer = tf.keras.optimizers.Adam(learning_rate=lr_schedule)
model.compile(optimizer=optimizer, loss='sparse_categorical_crossentropy', metrics=['accuracy'])

# Тренировка
history = model.fit(
    X_train, y_train,
    epochs=100,
    batch_size=128,
    validation_split=0.2,
    verbose=1
)

# Визуализация learning rate
plt.figure(figsize=(10, 6))
lr_history = [lr_schedule(step).numpy() for step in range(10000)]
plt.plot(range(10000), lr_history, linewidth=2)
plt.xlabel('Step')
plt.ylabel('Learning Rate')
plt.title('Learning Rate Schedule (Polynomial Decay)')
plt.grid(True, alpha=0.3)
plt.show()

Выбор scheduler в зависимости от задачи

Ключевые выводы

• Learning rate scheduler улучшает сходимость и качество модели
• Cosine Annealing - хороший выбор для большинства задач
• Warmup важен для Трансформеров и некоторых архитектур
• ReduceLROnPlateau полезна для адаптивного обучения
• Экспериментируйте и выбирайте scheduler в зависимости от вашей задачи

Праильный выбор scheduler может повысить точность на 1-2%, что может быть критично в соревнованиях и production системах.