Learning Rate

Скорость обучения — это гиперпараметр, который определяет, насколько далеко перемещаются веса модели на каждом шаге обучения. Градиентный спуск вычисляет градиент функции потерь, указывающий направление её наиболее быстрого роста, и обновляет каждый вес по формуле w ← w − η × градиент, где η (эта) — скорость обучения. Её также называют размером шага, а в коде обычно используют имя lr. Правильно выбранная скорость позволяет нейронной сети быстро сходиться к хорошему решению, а неудачно выбранная заставляет обучение расходиться или идти медленно. Поэтому в статье Лесли Смита о циклических скоростях обучения она названа важнейшим гиперпараметром для настройки глубоких сетей.

Слишком высокая, слишком низкая и оптимальная скорость#

Скорость обучения — это компромисс между быстродействием и стабильностью:

• Слишком высокая: каждый шаг перескакивает через минимум. Функция потерь колеблется, резко меняется или растёт, пока не становится NaN, и обучение расходится.
• Слишком низкая: каждый шаг лишь немного сдвигает веса. Функция потерь убывает медленно, для сходимости требуется гораздо больше эпох, а обучение с фиксированным бюджетом заканчивается недообучением.
• Оптимальная: функция потерь стабильно убывает и приближается к минимуму.

Приведённый ниже скрипт на PyTorch минимизирует функцию потерь w², начиная с одной и той же точки, при четырёх скоростях обучения:

import torch

# Minimize loss = w**2 (lowest at w = 0) from the same start with four learning rates
for lr in (0.01, 0.1, 0.9, 1.1):
    w = torch.tensor(5.0, requires_grad=True)
    optimizer = torch.optim.SGD([w], lr=lr)
    path = []
    for step in range(20):
        optimizer.zero_grad()
        loss = w**2
        loss.backward()
        optimizer.step()  # w = w - lr * gradient
        path.append(w.item())
    print(f"lr={lr}: first steps {[round(v, 2) for v in path[:3]]}, after 20 steps w={path[-1]:.3f}")

При скорости 0.01 вес за 20 шагов лишь медленно уменьшается с 5 до 3.338, а при 0.1 достигает 0.058. При 0.9 знак веса меняется на каждом шаге (−4.0, 3.2, −2.56), но он всё же сходится к 0.058. При 1.1 каждый шаг всё дальше перескакивает через минимум, и вес увеличивается до 191.688. Градиентный спуск для квадратичной функции остаётся устойчивым, только если скорость обучения меньше 2, делённых на кривизну функции потерь, то есть на её вторую производную. Кривизна w² равна 2, поэтому здесь предел составляет ровно 1.0, а скорость 0.5 позволяет за один шаг достичь минимума. В реальной сети предел того же типа задаётся наиболее крутым направлением функции потерь, поэтому скорость, подходящая одной модели или размеру пакета, может привести к расходимости при других условиях.

Расписания скорости обучения#

При обучении скорость редко остаётся неизменной от начала до конца. Расписание меняет её со временем:

• Разогрев: скорость начинается с малого значения и постепенно увеличивается в течение первых эпох или итераций, что не даёт большим и нестабильным градиентам в начале обучения нарушить его устойчивость.
• Пошаговое уменьшение: скорость делится на фиксированный коэффициент, часто на 10, в заданные эпохи или когда функция потерь на валидационной выборке перестаёт снижаться.
• Линейное и косинусное уменьшение: скорость плавно снижается до небольшого конечного значения. Косинусное затухание следует половине косинусоиды, а его вариант с тёплыми перезапусками возвращает скорость к высокому значению в начале каждого нового цикла.
• Циклические политики и политика одного цикла: во время обучения изменяй скорость обучения в диапазоне от нижней до верхней границы.

Большие шаги в начале быстро перемещают веса в подходящую область, а маленькие шаги в конце позволяют им сойтись к минимуму, а не колебаться вокруг него. Обучение YOLO26 в Ultralytics начинается с lr0, проходит разогрев за warmup_epochs (по умолчанию 3) и линейно снижается до lr0 * lrf либо следует косинусному графику с cos_lr=True. При значении optimizer="auto" по умолчанию тренер сам выбирает и оптимизатор, и начальную скорость обучения: MuSGD со скоростью 0.01 для запусков дольше 10 000 итераций, а в остальных случаях AdamW со скоростью, подобранной с учётом числа классов, поэтому lr0 применяется только при явном указании оптимизатора:

from ultralytics import YOLO

# Загрузи предварительно обученную nano-модель YOLO26
model = YOLO("yolo26n.pt")

# При явном указании оптимизатора применяется lr0; скорость снижается до lr0 * lrf по косинусному графику
results = model.train(data="coco8.yaml", epochs=10, optimizer="SGD", lr0=0.01, lrf=0.01, cos_lr=True)

Выбор начального значения#

Типичные начальные значения — от 0.01 до 0.1 для стохастического градиентного спуска (SGD) с моментумом и 0.001 для оптимизатора Adam — значение по умолчанию, предложенное в статье об Adam. При дообучении предобученной модели используют меньшую скорость обучения, чем при обучении с нуля: большие шаги могут перезаписать признаки, благодаря которым работает перенос обучения.

Тест диапазона скорости обучения из той же статьи о циклической скорости обучения, реализованный в fastai как поиск скорости обучения, позволяет найти подходящее значение за один короткий запуск. После каждого мини-пакета скорость повышается, а функция потерь записывается; полезный диапазон находится там, где функция потерь снижается быстрее всего, пока она не начинает резко расти.

Скорость обучения и связанные понятия#

• Алгоритм оптимизации: правило обновления, использующее скорость обучения. Адаптивные оптимизаторы, например Adam, масштабируют шаг для каждого веса на основе истории его градиентов, но всё равно умножают каждый шаг на одну глобальную скорость обучения.
• Моментум: отдельный гиперпараметр, который добавляет к текущему обновлению долю предыдущего, сглаживая траекторию и увеличивая эффективный размер шага в устойчивых направлениях.
• Затухание весов: член регуляризации, который на каждом шаге сдвигает сами веса к нулю; затухание скорости обучения со временем уменьшает размер шага.
• Размер пакета: число примеров, по которым усредняется каждый градиент. Большие пакеты дают менее зашумлённые градиенты и позволяют использовать более высокую скорость обучения, а правило линейного масштабирования увеличивает скорость обучения в k раз, если размер пакета вырос в k раз.