Transformers documentation

Оптимизаторы и планировщики

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Оптимизаторы и планировщики

Оптимизатор обновляет веса модели в процессе обучения. Планировщик оборачивает оптимизатор и корректирует скорость обучения на каждом шаге обучения. Trainer создаёт оба объекта, когда вызывает create_optimizer_and_scheduler().

                                    ┌────────────┐         ┌──────────────┐
                                    │ Optimizer  │         │  Scheduler   │
                                    │ (adamw_torch_fused)◄─│  (linear)    │
                                    │            │         │              │
                                    │ param_groups         |              |
                                    │  └ lr       ◄────────┤              |
                                    │  └ weight_decay      │              │
                                    └──────┬─────┘         └──────────────┘
                                           │                      
  ┌──── EACH TRAINING STEP ───────────────────────────────────────────┐
  │                                        │                          │
  │   model(batch)                         │                          │
  │       │                                │                          │
  │       ▼                                │                          │
  │     loss ──► loss.backward() ──► param.grad                       │
  │                                        │                          │
  │                          ┌─────────────┘                          │
  │                          ▼                                        │
  │              optimizer.step()                                     │
  │                          │                                        │
  │                          ▼                                        │
  │                   param.data updated                              │
  │                          │                                        │
  │                          ▼                                        │
  │              lr_scheduler.step()  ──► recalculates lr             │
  │                          │            writes to optimizer         │
  │                          ▼            .param_groups['lr']         │
  │              model.zero_grad()                                    │
  │                                                                   │
  └───────────────────────────────────────────────────────────────────┘

Настройте поведение оптимизатора и планировщика, например lr_scheduler_type() и optim(), в TrainingArguments. Значения по умолчанию (оптимизатор adamw_torch и планировщик разгона linear) являются хорошей отправной точкой для большинства задач дообучения.

from transformers import TrainingArguments

args = TrainingArguments(
    ...,
    # Optimizer
    optim="adamw_torch",          # or "adamw_torch_fused", "adafactor", "sgd", etc.
    learning_rate=2e-5,
    weight_decay=0.01,
    adam_beta1=0.9,
    adam_beta2=0.999,
    adam_epsilon=1e-8,
    # Scheduler
    lr_scheduler_type="cosine",   # "linear", "cosine", "constant_with_warmup", etc.
    warmup_steps=500,
    lr_scheduler_kwargs={"num_cycles": 3},  # scheduler-specific extras
)

Планировщики на основе метрик

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

GreedyLR обновляет скорость обучения на основе результатов оценки. Если метрика продолжает улучшаться, скорость обучения увеличивается путём деления на factor; если метрика не улучшается, скорость обучения уменьшается путём умножения на factor. Когда скорость обучения достигает min_lr и не улучшается в течение reset_start шагов, GreedyLR сбрасывается в исходное состояние и начинает новый цикл.

Для GreedyLR требуется оценка в процессе обучения. Установите eval_strategy в значение "steps" или "epoch".

args = TrainingArguments(
+   lr_scheduler_type="greedy",
+   lr_scheduler_kwargs={"patience": 10, "factor": 0.95, "min_lr": 1e-5},
+   eval_strategy="steps",
+   eval_steps=200,
    ...  # remaining args from the TrainingArguments intro config
)

По умолчанию mode="min" подходит для функции потерь. Если вы отслеживаете метрику, где большее значение лучше, например точность, передайте "mode": "max" в lr_scheduler_kwargs.

См. класс GreedyLR для полного списка настраиваемых параметров.

Интеграции с оптимизаторами

Transformers интегрирует сторонние оптимизаторы для специализированных сценариев обучения.

ОптимизаторУстановкаoptim="value"Описание
APOLLOapollo-torchapollo_adamwЭффективная по памяти полная параметризация с помощью случайных проекций; достаточно ранга 1
GrokAdamWgrokadamwgrokadamwЦеленаправленно откладывает обобщение (grokking)
LOMO / AdaLomolomo-optimlomo / adalomoОбъединяет шаги градиента и обновления для дообучения всех параметров с низким потреблением памяти
Без расписанияschedulefreeschedule_free_adamw, schedule_free_radam, schedule_free_sgdУбирает аннелинг LR; используйте в паре с lr_scheduler_type="constant"
GaLoregalore-torchgalore_adamw, galore_adafactor, galore_adamw_8bitПолнопараметрическое обучение с помощью градиентной проекции на низкоранговое подпространство
StableAdamWtorch-optimistable_adamwОбрезка обновлений AdamW + AdaFactor; обрезка градиентов не требуется
APOLLO
GrokAdamW
LOMO
Без расписания
StableAdamW
GaLore
pip install apollo-torch

Approximated Gradient Scaling for Memory Efficient LLM Optimization (APOLLO) — это оптимизатор с низким потреблением памяти для обучения всех параметров на этапах предобучения и дообучения. Он обеспечивает производительность, сопоставимую с AdamW, при затратах на память, близких к SGD, за счёт использования дешёвых случайных проекций вместо SVD. Для максимального сокращения потребления памяти используйте APOLLO-Mini — вариант с рангом 1.

Используйте параметр optim_target_modules, чтобы указать, какие слои нужно обучать.

args = TrainingArguments(
+   optim="apollo_adamw",
+   optim_target_modules=[r".*.attn.*", r".*.mlp.*"],
    ...  # remaining args from the TrainingArguments intro config
)

Передавайте дополнительные гиперпараметры через optim_args.

Установите scale в значение n/r, где n — размерность исходного пространства, а r — размерность пространства с низким рангом. Аналогичный эффект достигается за счёт подбора скорости обучения при сохранении значения scale по умолчанию.

параметрОписаниеAPOLLOAPOLLO-Mini
rankранг вспомогательного подпространства для масштабирования градиентов2561
scale_typeкак применяются коэффициенты масштабированияchannel (масштабирование по каналам)tensor (масштабирование на уровне тензора)
scaleкорректирует обновления градиентов для стабилизации обучения1.0128
update_proj_gapшагов до обновления матриц проекций200200
projтип проекцииrandomrandom

Включите APOLLO-Mini с конфигурацией rank-1.

args = TrainingArguments(
    optim="apollo_adamw",
    optim_target_modules=[r".*.attn.*", r".*.mlp.*"],
    optim_args="proj=random,rank=1,scale=128.0,scale_type=tensor,update_proj_gap=200",
    ...  # remaining args from the TrainingArguments intro config
)

Настройка оптимизатора и планировщика

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

Передайте класс и kwargs

~Trainer.optimizer_cls_and_kwargs принимает пользовательский класс оптимизатора, передавая группировку параметров и размещение на устройствах в Trainer.

Trainer откладывает создание оптимизатора до выполнения create_optimizer(), поэтому модель уже находится на правильном устройстве.

import torch

trainer = Trainer(
    ...
    optimizer_cls_and_kwargs=(
        torch.optim.SGD,
        {"momentum": 0.9, "nesterov": True}
    ),
)

Передача предварительно созданных экземпляров

Передайте заранее созданные оптимизатор и планировщик в ~Trainer.optimizers. Trainer пропускает вызовы create_optimizer() и create_scheduler(), если переданы готовые экземпляры. Если планировщик не передан, Trainer автоматически создаст его.

Создавайте оптимизатор после размещения модели на нужном устройстве. Параметры разрешаются в момент конструирования, до того как Trainer переместит модель. При распределённом обучении несоответствие устройств может незаметно привести к некорректному поведению.

import torch
from transformers import Trainer, get_cosine_schedule_with_warmup

optimizer = torch.optim.AdamW(model.parameters(), lr=2e-5)
scheduler = get_cosine_schedule_with_warmup(
    optimizer, num_warmup_steps=500, num_training_steps=10_000
)

trainer = Trainer(
    ...
    optimizers=(optimizer, scheduler),
)

Предварительно собранные инстансы обходят create_optimizer() и create_scheduler(), поэтому вам необходимо самостоятельно указать группы параметров.

Переопределение методов оптимизатора и планировщика

Создайте подклассы create_optimizer() и create_scheduler() для полного контроля. Оба метода выполняются в процессе train().

Переопределите create_scheduler(), чтобы использовать планировщик, например OneCycleLR, который не входит в SchedulerType.

Для каждого метода убедитесь, что вы присваиваете значение self и возвращаете его.

import torch
from transformers import Trainer

class MyTrainer(Trainer):

    def create_scheduler(self, num_training_steps, optimizer=None):
        optimizer = optimizer or self.optimizer
        self.lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(
            optimizer,
            max_lr=0.1,
            total_steps=num_training_steps,
        )
        return self.lr_scheduler

Нет необходимости переопределять create_optimizer(), если стандартный оптимизатор подходит. Расширение метода с помощью super() проще, чем его полная замена. Например, можно добавить дополнительную группу параметров, сохранив всё остальное без изменений.

class MyTrainer(Trainer):
    def create_optimizer(self, model=None):
        super().create_optimizer(model)  # builds the default two param groups
        # add extra param group
        self.optimizer.add_param_group({
            "params": self.model.classifier.parameters(),
            "lr": self.args.learning_rate * 10,
        })
        return self.optimizer
Update on GitHub