Transformers documentation

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

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.23.0).
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