Trình lập lịch tốc độ học

Trang này chứa tài liệu tham khảo API cho các trình lập lịch tốc độ học (learning rate schedulers) có trong timm, cùng với tổng quan về cách chúng được tạo và thực hiện bước (stepped).

Cách sử dụng

Schedulers được tạo theo tên bằng create_scheduler_v2, hàm này trả về scheduler và tổng số epochs cần huấn luyện (bao gồm cả phần warmup, các chu kỳ và cooldown, xem bên dưới). Khác với torch.optim.lr_scheduler, các scheduler của timm không tự đếm số bước. Chúng được thiết kế để không có trạng thái: lr là một hàm của cấu hình lịch và số epoch hoặc số lần cập nhật được chỉ định rõ ràng, do đó việc tiếp tục một lần chạy chỉ cần epoch, và không có trạng thái scheduler nào được lưu trong các checkpoint. Vòng lặp huấn luyện truyền vào epoch hoặc số lần cập nhật một cách rõ ràng:

scheduler.step(epoch) ở cuối mỗi epoch, với chỉ mục của epoch tiếp theo (epoch + 1)
scheduler.step_update(num_updates) sau mỗi lần cập nhật optimizer, với số lần cập nhật tính đến thời điểm đó

Một scheduler được bước (stepped) theo từng epoch hoặc theo từng lần cập nhật (step_on_epochs), lệnh gọi còn lại là no-op, do đó một vòng lặp huấn luyện có thể thực hiện cả hai lệnh gọi và hỗ trợ cả hai cách.

import timm
from timm.optim import create_optimizer_v2
from timm.scheduler import create_scheduler_v2

model = timm.create_model('resnet50')
optimizer = create_optimizer_v2(model, opt='adamw', lr=1e-3, weight_decay=0.05)
updates_per_epoch = len(loader)  # optimizer updates per epoch

# Cosine decay w/ 5 epochs of linear warmup, stepped per update for a smooth schedule.
scheduler, num_epochs = create_scheduler_v2(
    optimizer,
    sched='cosine',
    num_epochs=100,
    warmup_epochs=5,
    min_lr=1e-6,
    step_on_epochs=False,
    updates_per_epoch=updates_per_epoch,
)

num_updates = 0
for epoch in range(num_epochs):
    for batch in loader:
        ...  # forward, backward, optimizer.step()
        num_updates += 1
        scheduler.step_update(num_updates=num_updates)
    scheduler.step(epoch + 1)  # pass the eval metric too for 'plateau', scheduler.step(epoch + 1, metric)

Thời lượng (num_epochs, warmup_epochs, decay_epochs, …) luôn được cho theo epoch, nhà máy sẽ chuyển đổi chúng thành số lần cập nhật khi step_on_epochs=False. Các trình lập lịch cũng có thể được xây dựng trực tiếp từ lớp của chúng, khi đó thời lượng sẽ được tính theo đơn vị mà chúng được bước (t_in_epochs).

Script huấn luyện (train.py) phơi bày các đối số nhà máy thông qua các cờ sau:

--sched chọn lịch trình.
--epochs thiết lập độ dài lịch trình.
--sched-on-updates số bước mỗi lần cập nhật thay vì mỗi epoch.
--warmup-epochs thiết lập thời lượng warmup.
--warmup-lr đặt tốc độ học warmup ban đầu.
--warmup-prefix thêm bước khởi động trước lịch trình thay vì chồng lên phần đầu của nó.
--min-lr đặt tốc độ học tối thiểu.
--decay-epochs đặt khoảng cách bước suy giảm hoặc thời lượng suy giảm cuối cùng cho WSD / rsqrt.
--decay-milestones thiết lập các epoch suy giảm cho lịch multistep.
--decay-rate đặt hệ số suy giảm, hoặc số mũ cho lịch trình đa thức.
--cooldown-epochs thêm các epoch ở tốc độ học tối thiểu sau khi lịch trình kết thúc.
--patience-epochs thiết lập mức kiên nhẫn của bộ lập lịch plateau.
--lr-noise chọn phần của lịch trình có nhiễu tốc độ học.
--lr-noise-pct giới hạn độ lớn của nhiễu.
--lr-noise-std đặt độ lệch chuẩn của nhiễu.
--lr-cycle-mul đặt hệ số nhân độ dài chu kỳ.
--lr-cycle-decay đặt hệ số nhân tốc độ học đỉnh giữa các chu kỳ.
--lr-cycle-limit đặt số lượng chu kỳ.
--lr-k-decay thiết lập k-decay cho các lịch cosine / polynomial.
--lr-decay-fn chọn hàm suy giảm cuối cùng cho WSD / rsqrt.
--lr-stable-timescale thiết lập thang thời gian của pha ổn định rsqrt.

Lịch trình

`sched`	Lớp	Lịch trình
`cosine`	`CosineLRScheduler`	Giảm dần cosine từ lr cơ bản đến `min_lr` (SGDR), có tùy chọn khởi động lại (chu kỳ) và k-decay
`tanh`	`TanhLRScheduler`	Phân rã hyperbolic tangent (bài báo), khởi động lại tùy chọn
`poly`	`PolyLRScheduler`	Phân rã đa thức đến `min_lr`, số mũ được cho bởi `decay_rate`, có tùy chọn khởi động lại và k-phân rã
`step`	`StepLRScheduler`	lr được nhân với `decay_rate` mỗi `decay_epochs`
`multistep`	`MultiStepLRScheduler`	lr được nhân với `decay_rate` tại mỗi epoch trong `decay_milestones`
`plateau`	`PlateauLRScheduler`	Đã ngừng hỗ trợ. lr được nhân với `decay_rate` khi metric eval không cải thiện trong `patience_epochs`, chỉ stepping theo epoch
`wsd`	`WSDLRScheduler`	Warmup-stable-decay (MiniCPM), lr không đổi sau đó giảm xuống `min_lr` trong `decay_epochs` cuối, mặc định là giảm `1-sqrt` (bài báo)
`rsqrt`	`WSDLRScheduler`	Suy giảm căn bậc hai nghịch đảo với làm mát tuyến tính trong `decay_epochs` cuối cùng (Big Vision)

Các tùy chọn phổ biến

Warmup. warmup_epochs của quá trình warmup tuyến tính từ warmup_lr lên lr cơ bản, được hỗ trợ bởi tất cả các lịch trình.
- warmup_prefix: mặc định, warmup chồng lên phần đầu của lịch trình (lịch trình được tính từ epoch 0, warmup thay thế các epoch đầu tiên của nó), do đó num_epochs là tổng độ dài. Với warmup_prefix=True, lịch trình bắt đầu sau warmup và warmup được cộng thêm vào tổng độ dài.
- Đối với wsd và rsqrt, pha ổn định luôn bắt đầu sau warmup, nếu không có warmup_prefix thì pha ổn định và pha suy giảm được điều chỉnh để nằm trong num_epochs - warmup_epochs nên num_epochs vẫn là tổng số.
min_lr: tốc độ học mà các lịch trình suy giảm (cosine, tanh, poly, wsd, rsqrt) đạt được ở cuối, và là cận dưới cho plateau.

Lịch trình plateau đã bị ngừng hỗ trợ và sẽ được loại bỏ trong một bản phát hành tương lai. Lịch trình này không bao giờ phù hợp với thiết kế không trạng thái ở trên: lr của nó phụ thuộc vào lịch sử của chỉ số đánh giá (eval metric) chứ không phải vào epoch, và lịch sử đó (chỉ số tốt nhất, bộ đếm patience và cooldown) không được lưu trong checkpoint, do đó một lần chạy được khôi phục sẽ khởi động lại logic plateau. Hỗ trợ checkpoint sẽ không được thêm vào. Một plateau trong kiểm chứng cũng là một tín hiệu yếu để xác định thời điểm anneal; một lịch trình cố định như cosine hoặc wsd có thể tái lập và khôi phục chính xác, và một lượt quét WSD (xem Hyperparameter Sweeps) so sánh các cooldown ở nhiều ngân sách khác nhau từ một lần chạy ổn định duy nhất.

cooldown_epochs: số epoch được giữ ở mức min_lr sau khi lịch trình kết thúc (cosine, tanh, poly, wsd, rsqrt), được cộng thêm vào num_epochs được trả về. Vì lịch trình đạt đến min_lr một bước sau bước cuối cùng của nó, một epoch cooldown cũng là một cách để huấn luyện ở mức min_lr khi bước theo từng epoch.
Cycles (cosine, tanh, poly): cycle_limit > 1 khởi động lại lịch trình, mỗi chu kỳ dài hơn cycle_mul lần và lr đỉnh của nó được nhân với cycle_decay so với chu kỳ trước. num_epochs được trả về bao gồm tất cả các chu kỳ.
k_decay (cosine, poly): k-decay thay đổi hình dạng của sự suy giảm (t ** k), k > 1 giữ lr ở mức cao lâu hơn.
Nhiễu: noise thêm nhiễu lr nhân ngẫu nhiên trên một khoảng của lịch trình, được cho dưới dạng phân số của num_epochs (một điểm bắt đầu, hoặc một điểm bắt đầu và một điểm kết thúc), bị giới hạn bởi noise_pct.

WSD và rsqrt

WSDLRScheduler có ba giai đoạn: làm nóng tuyến tính, giai đoạn ổn định và giảm dần xuống min_lr.

decay_epochs thiết lập thời lượng suy giảm cuối cùng. Một giá trị trong khoảng (0, 1) là một phần của tổng độ dài ổn định + suy giảm, mặc định là 20%.
decay_fn (--lr-decay-fn) chọn 1-sqrt (mặc định cho wsd), linear (mặc định cho rsqrt), cosine, power hoặc exp.
stable_timescale (--lr-stable-timescale, tính theo epochs) kiểm soát pha ổn định rsqrt, pha này suy giảm theo công thức (1 + t / timescale) ** -0.5 kể từ khi kết thúc warmup. Giá trị mặc định của tham số này là độ dài warmup và bắt buộc phải được đặt khi không có warmup.

Lớp này cũng hỗ trợ pha ổn định power tổng quát và các hàm suy giảm tùy chỉnh.

Giai đoạn anneal cuối cùng là nơi lịch WSD phát huy phần lớn lợi ích, vì vậy hãy cập nhật theo từng bước (--sched-on-updates), hoặc thêm một epoch cooldown khi pha suy giảm chỉ kéo dài vài epoch. Nếu cập nhật theo từng epoch, epoch cuối cùng của một pha suy giảm ngắn sẽ cao hơn đáng kể so với min_lr (khoảng 10% của lr cơ bản cho epoch cuối cùng trong 5 epoch suy giảm với 1-sqrt).

# 300 epochs, 5 epoch warmup, constant lr, then a 1-sqrt decay over the final 20%
scheduler, num_epochs = create_scheduler_v2(
    optimizer, sched='wsd', num_epochs=300, warmup_epochs=5, decay_epochs=0.2,
    step_on_epochs=False, updates_per_epoch=updates_per_epoch,
)

Tỷ lệ scale của lr cho nhóm tham số

Các nhóm tham số có trường lr_scale (ví dụ: các nhóm suy giảm lr theo lớp từ param_groups_layer_decay) sẽ nhận lr được lên lịch nhân với hệ số của chúng. lr cơ bản của mỗi nhóm được ghi lại dưới dạng initial_lr trong nhóm khi trình lên lịch được tạo.

Tiếp tục

Khi số bước được truyền vào, trình lập lịch cho một lần chạy tiếp nối được thiết lập bằng cách tạo nó như với lần chạy ban đầu và thực hiện bước đến điểm tiếp nối, scheduler.step(start_epoch) hoặc scheduler.step_update(start_epoch * updates_per_epoch). state_dict() / load_state_dict() lưu và khôi phục các thuộc tính của trình lập lịch.

API

Hàm nhà máy

timm.scheduler.create_scheduler

< source >

( argsoptimizer: Optimizerupdates_per_epoch: int = 0 )

timm.scheduler.create_scheduler_v2

< source >

( optimizer: Optimizersched: str = 'cosine'num_epochs: int = 300decay_epochs: typing.Optional[float] = Nonedecay_milestones: typing.List[int] = (90, 180, 270)cooldown_epochs: int = 0patience_epochs: int = 10decay_rate: float = 0.1min_lr: float = 0.0warmup_lr: float = 1e-05warmup_epochs: int = 0warmup_prefix: bool = Falsenoise: typing.Union[float, typing.List[float]] = Nonenoise_pct: float = 0.67noise_std: float = 1.0noise_seed: int = 42cycle_mul: float = 1.0cycle_decay: float = 0.1cycle_limit: int = 1k_decay: float = 1.0decay_fn: typing.Optional[str] = Nonestable_timescale: typing.Optional[float] = Noneplateau_mode: str = 'max'step_on_epochs: bool = Trueupdates_per_epoch: int = 0 )

Tham số

optimizer — optimizer cần lên lịch
sched — tên scheduler, một trong ‘cosine’, ‘tanh’, ‘step’, ‘multistep’, ‘poly’, ‘wsd’, ‘rsqrt’, ‘constant’, ‘plateau’ (đã ngừng hỗ trợ), hoặc ‘none’ nếu không dùng scheduler (trả về None, lr của optimizer sẽ không bị thay đổi). ‘constant’ giữ nguyên lr sau warmup với param group lr_scale (giảm lr theo từng lớp) được áp dụng.
num_epochs — số epoch trong lịch (không bao gồm warmup nếu có warmup_prefix, không bao gồm cooldown)
decay_epochs — khoảng thời gian suy giảm lr (step), hoặc độ dài của pha suy giảm (wsd / rsqrt) tính bằng epochs, một giá trị trong (0, 1) là một phần của độ dài lịch trình. None = 90 (step), 0.2 (wsd / rsqrt)
decay_milestones — các epoch để giảm lr (multistep)
cooldown_epochs — số epoch để giữ lr ở min_lr sau khi lịch trình kết thúc
patience_epochs — số epochs không có cải thiện trước khi giảm lr (plateau, đã ngừng hỗ trợ)
decay_rate — tốc độ suy giảm lr (step, multistep, plateau), số mũ của đa thức (poly)
min_lr — giới hạn dưới của lr cho các trình lập lịch suy giảm về giá trị này
warmup_lr — lr tại thời điểm bắt đầu warmup
warmup_epochs — số epoch của quá trình làm nóng tuyến tính
warmup_prefix — loại bỏ giai đoạn warmup khỏi num_epochs (được cộng thêm vào tổng), wsd / rsqrt luôn có tiền tố warmup, với warmup_prefix=False các pha stable + decay nằm gọn trong num_epochs
noise — các điểm bật/tắt nhiễu lr dưới dạng phân số của độ dài lịch
noise_pct — phần trăm giới hạn nhiễu lr
noise_std — độ lệch chuẩn của nhiễu lr
noise_seed — hạt giống nhiễu cho lr
cycle_mul — hệ số nhân độ dài chu kỳ (cosine, tanh, poly)
cycle_decay — suy giảm lr theo chu kỳ (cosine, tanh, poly)
cycle_limit — số chu kỳ (cosine, tanh, poly)
k_decay — k-decay (cosine, poly)
decay_fn — hàm pha suy giảm (wsd / rsqrt), None = ‘1-sqrt’ cho wsd, ‘linear’ cho rsqrt
stable_timescale — thang thời gian rsqrt tính theo số epoch (rsqrt), None = warmup_epochs
plateau_mode — ‘max’ hoặc ‘min’, hướng của chỉ số (plateau)
step_on_epochs — cập nhật lịch theo từng epoch, nếu không thì theo từng lần cập nhật (yêu cầu updates_per_epoch)
updates_per_epoch — số lần cập nhật optimizer mỗi epoch (step_on_epochs=False)

Tạo trình lập lịch tốc độ học theo tên.

Các lớp Scheduler

lớp timm.scheduler.CosineLRScheduler

< source >

( optimizer: Optimizert_initial: intlr_min: float = 0.0cycle_mul: float = 1.0cycle_decay: float = 1.0cycle_limit: int = 1warmup_t: int = 0warmup_lr_init: float = 0.0warmup_prefix: bool = Falset_in_epochs: bool = Truenoise_range_t: typing.Union[typing.List[int], typing.Tuple[int, int], int, NoneType] = Nonenoise_pct: float = 0.67noise_std: float = 1.0noise_seed: int = 42k_decay: float = 1.0initialize: bool = True )

Phóng thích cosine có khởi động lại. Điều này được mô tả trong bài báo https://arxiv.org/abs/1608.03983.

Lấy cảm hứng từ https://github.com/allenai/allennlp/blob/master/allennlp/training/learning_rate_schedulers/cosine.py

tùy chọn k-decay dựa trên k-decay: A New Method For Learning Rate Schedule - https://arxiv.org/abs/2004.05909

lớp timm.scheduler.MultiStepLRScheduler

< source >

( optimizer: Optimizerdecay_t: typing.List[int]decay_rate: float = 1.0warmup_t: int = 0warmup_lr_init: float = 0.0warmup_prefix: bool = Truet_in_epochs: bool = Truenoise_range_t: typing.Union[typing.List[int], typing.Tuple[int, int], int, NoneType] = Nonenoise_pct: float = 0.67noise_std: float = 1.0noise_seed: int = 42initialize: bool = True )

Lịch trình tốc độ học đa bước với làm nóng và nhiễu.

Ngoài giai đoạn warmup, các mốc suy giảm được so sánh với t + 1, trong đó t loại trừ warmup khi warmup_prefix=True. Ví dụ, nếu không có warmup, mốc 10 sẽ được áp dụng tại chỉ số lịch trình 9.

Quy ước lâu đời này khác với MultiStepLR của PyTorch và được giữ lại để đảm bảo tương thích với các lịch trình huấn luyện hiện có.

lớp timm.scheduler.PlateauLRScheduler

< source >

( optimizer: Optimizerdecay_rate: float = 0.1patience_t: int = 10threshold: float = 0.0001cooldown_t: int = 0warmup_t: int = 0warmup_lr_init: float = 0.0lr_min: float = 0.0mode: str = 'max'noise_range_t: typing.Union[typing.List[int], typing.Tuple[int, int], int, NoneType] = Nonenoise_type: str = 'normal'noise_pct: float = 0.67noise_std: float = 1.0noise_seed: typing.Optional[int] = Noneinitialize: bool = True )

Giảm LR đi một hệ số mỗi khi loss kiểm định đạt trạng thái ổn định.

Đã ngừng hỗ trợ: trình lập lịch này sẽ bị loại bỏ trong một bản phát hành tương lai. Các trình lập lịch của timm được thiết kế để là các hàm không trạng thái của epoch hoặc số lần cập nhật, điều mà lịch trình dựa trên chỉ số này chưa bao giờ đáp ứng. Trạng thái của nó (chỉ số tốt nhất, bộ đếm patience và cooldown) không được lưu trong các checkpoint huấn luyện, do đó một lần chạy được khôi phục sẽ khởi động lại logic plateau, và hỗ trợ checkpoint sẽ không được thêm vào. Nên ưu tiên một lịch trình cố định như cosine hoặc wsd, nhánh cooldown WSD trong sweep.py so sánh quá trình annealing ở nhiều ngân sách khác nhau với các lịch trình có thể tái lập.

lớp timm.scheduler.PolyLRScheduler

< source >

( optimizer: Optimizert_initial: intpower: float = 0.5lr_min: float = 0.0cycle_mul: float = 1.0cycle_decay: float = 1.0cycle_limit: int = 1warmup_t: int = 0warmup_lr_init: float = 0.0warmup_prefix: bool = Falset_in_epochs: bool = Truenoise_range_t: typing.Union[typing.List[int], typing.Tuple[int, int], int, NoneType] = Nonenoise_pct: float = 0.67noise_std: float = 1.0noise_seed: int = 42k_decay: float = 1.0initialize: bool = True )

Trình lập lịch LR đa thức có làm nóng, nhiễu và suy giảm k

tùy chọn k-decay dựa trên k-decay: A New Method For Learning Rate Schedule - https://arxiv.org/abs/2004.05909

lớp timm.scheduler.StepLRScheduler

< source >

( optimizer: Optimizerdecay_t: floatdecay_rate: float = 1.0warmup_t: int = 0warmup_lr_init: float = 0.0warmup_prefix: bool = Truet_in_epochs: bool = Truenoise_range_t: typing.Union[typing.List[int], typing.Tuple[int, int], int, NoneType] = Nonenoise_pct: float = 0.67noise_std: float = 1.0noise_seed: int = 42initialize: bool = True )

lớp timm.scheduler.TanhLRScheduler

< source >

( optimizer: Optimizert_initial: intlb: float = -7.0ub: float = 3.0lr_min: float = 0.0cycle_mul: float = 1.0cycle_decay: float = 1.0cycle_limit: int = 1warmup_t: int = 0warmup_lr_init: float = 0.0warmup_prefix: bool = Falset_in_epochs: bool = Truenoise_range_t: typing.Union[typing.List[int], typing.Tuple[int, int], int, NoneType] = Nonenoise_pct: float = 0.67noise_std: float = 1.0noise_seed: int = 42initialize: bool = True )

Phóng thích Hyperbolic-Tangent có khởi động lại. Điều này được mô tả trong bài báo https://arxiv.org/abs/1806.01593

class timm.scheduler.WSDLRScheduler

< source >

( optimizer: Optimizert_initial: intdecay_t: intlr_min: float = 0.0stable_fn: str = 'constant'stable_timescale: typing.Optional[float] = Nonestable_power: float = 0.5decay_fn: typing.Union[str, typing.Callable[[float], float]] = '1-sqrt'decay_power: float = 0.5decay_ratio: float = 0.1warmup_t: int = 0warmup_lr_init: float = 0.0t_in_epochs: bool = Truenoise_range_t: typing.Union[typing.List[int], typing.Tuple[int, int], int, NoneType] = Nonenoise_pct: float = 0.67noise_std: float = 1.0noise_seed: int = 42initialize: bool = True )

Tham số

optimizer — optimizer cần lên lịch
t_initial — độ dài của các pha ổn định + suy giảm (epochs hoặc updates, xem t_in_epochs)
decay_t — độ dài của pha suy giảm, decay_t bước cuối cùng của t_initial
lr_min — lr ở cuối pha suy giảm
stable_fn — hàm pha ổn định, một trong ‘constant’, ‘rsqrt’, ‘power’
stable_timescale — thang thời gian của các hàm ổn định ‘rsqrt’ / ‘power’, mặc định là warmup_t
stable_power — số mũ của hàm ổn định ‘power’
decay_fn — hàm pha suy giảm, một trong các giá trị ‘linear’, ‘1-sqrt’, ‘cosine’, ‘power’, ‘exp’ hoặc một hàm callable
decay_power — số mũ của hàm suy giảm dạng ‘power’
decay_ratio — tỷ lệ cuối cùng (trước khi chuẩn hóa) của hàm suy giảm ‘exp’
warmup_t — độ dài warmup, một phần tiền tố của t_initial
warmup_lr_init — lr tại thời điểm bắt đầu warmup
t_in_epochs — t được tính theo số epoch (step()), nếu không thì theo số lần cập nhật (step_update())
noise_range_t — khoảng nhiễu lr, xem Scheduler
noise_pct — phần trăm giới hạn nhiễu lr
noise_std — độ lệch chuẩn của nhiễu lr
noise_seed — hạt giống nhiễu cho lr
initialize — khởi tạo trường nhóm tham số initial_lr từ lr hiện tại

Lịch trình LR Warmup-Stable-Decay (WSD) với các hàm stable và decay có thể chọn.

Ba giai đoạn: làm nóng tuyến tính trong warmup_t bước, giai đoạn ổn định, và suy giảm xuống lr_min trong decay_t bước cuối. t_initial là độ dài của các giai đoạn ổn định + suy giảm, phần làm nóng luôn là phần đầu nên lịch trình có tổng độ dài là warmup_t + t_initial (xem get_cycle_length()), sau đó lr_min được giữ nguyên.

NOTE: giống như các scheduler khác, lr_min được đạt tới tại t = warmup_t + t_initial, tức là một bước sau bước được lên lịch cuối cùng, do đó bước được lên lịch cuối cùng thiếu một bước suy giảm so với giá trị đó. Với một pha suy giảm ngắn được thực hiện theo từng epoch, điều này có ý nghĩa đáng kể (ví dụ: epoch suy giảm thứ 5 trong 5 epoch với ‘1-sqrt’ nằm ở khoảng 10% của lr ổn định). Việc anneal cuối cùng rất quan trọng đối với WSD, vì vậy hãy bước theo từng cập nhật (t_in_epochs=False, --sched-on-updates trong train.py) hoặc thêm một epoch cooldown (giữ ở lr_min, --cooldown-epochs).

Hàm ổn định được đánh giá dựa trên thời gian kể từ khi kết thúc warmup (t_s) và bằng 1 tại t_s = 0, do đó warmup luôn chuyển giao tại lr cơ sở. Hàm suy giảm ánh xạ tiến độ suy giảm frac trong [0, 1] thành một hệ số từ 1 đến 0 và nhân với giá trị ổn định, do đó một hàm ổn định suy giảm sẽ tiếp tục suy giảm xuyên suốt giai đoạn suy giảm (như trong lịch trình rsqrt + linear cooldown của Big Vision).

lr(t) = lr_min + (base_lr stable(t_s) - lr_min) decay(frac)

Các hàm ổn định:

constant: 1, lịch trình WSD
rsqrt: (1 + t_s / timescale) ** -0.5, lịch trình căn bậc hai nghịch đảo Big Vision khi stable_timescale == warmup_t (mặc định)
power: (1 + t_s / timescale) ** -stable_power, rsqrt tổng quát (Trình lập lịch Power)

Các hàm suy giảm:

1-sqrt: 1 - sqrt(frac), phương pháp làm nguội (cooldown) cho hiệu suất tốt nhất trong https://arxiv.org/abs/2405.18392 (mặc định)
linear: 1 - frac, lịch trình “hình thang” và quá trình làm nguội Big Vision
cosine: 0.5 (1 + cos(pi frac))
power: 1 - frac ** decay_power, 0.5 == ‘1-sqrt’, 1.0 == ‘linear’, 2.0 là suy giảm ‘square’
exp: suy giảm mũ xuống một phần decay_ratio của giá trị ổn định, được chuẩn hóa để đạt lr_min
một hàm có thể gọi fn(frac) -> factor cho mọi trường hợp khác

Update on GitHub