Hugging Face's logo

timm documentation

Optimasi

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Optimasi

Halaman ini berisi dokumentasi referensi API untuk optimizer yang disertakan dalam timm, serta gambaran umum tentang bagaimana optimizer tersebut dipilih dan dikonfigurasi melalui pabrik optimizer.

Penggunaan

Optimizer dibuat berdasarkan nama dengan create_optimizer_v2. Diberikan sebuah model, factory membangun parameter groups (pencarian weight decay, optional layer-wise learning rate decay) sebelum membangun optimizer. Argumen spesifik optimizer diteruskan sebagai keyword arguments.

import timm
from timm.optim import create_optimizer_v2, list_optimizers

model = timm.create_model('vit_base_patch16_224')

# AdamW. 1D params (biases, norm scales) and params in model.no_weight_decay() are excluded from weight decay.
optimizer = create_optimizer_v2(model, opt='adamw', lr=1e-3, weight_decay=0.05)

# Layer-wise learning rate decay (fine-tuning), per-layer lr scales from the model's group_matcher().
optimizer = create_optimizer_v2(model, opt='adamw', lr=1e-3, weight_decay=0.05, layer_decay=0.75)

# Optimizer specific arguments are passed through.
optimizer = create_optimizer_v2(model, opt='lamb', lr=5e-3, weight_decay=0.02, trust_clip=True)

# A list of params or param groups can be passed instead of a model, weight decay grouping is then up to the caller.
optimizer = create_optimizer_v2(model.parameters(), opt='sgd', lr=0.1, momentum=0.9)

# All registered names, optionally with a description.
print(list_optimizers(with_description=True))

Skrip pelatihan (train.py) membuka akses yang sama melalui flag berikut:

  • --opt memilih optimizer.
  • --lr mengatur learning rate.
  • --weight-decay mengatur weight decay.
  • --momentum mengatur momentum.
  • --opt-eps mengatur epsilon (eps).
  • --opt-betas mengatur koefisien beta (betas).
  • --layer-decay mengatur peluruhan laju pembelajaran per lapisan.
  • --opt-kwargs key=value ... meneruskan argumen optimizer lainnya.

Konvensi penamaan

Nama yang terdaftar menggunakan huruf kecil, yaitu nama optimizer dasar ditambah modifikator:

ModifikatorArtiContoh
prefiks cVarian yang lebih hati-hati, di mana pembaruan dimasker jika tandanya tidak sesuai dengan gradien (Cautious Optimizers)cadamw, clion, cmars, cadopt
sufiks wWeight decay yang terpisah (gaya AdamW), untuk optimizer yang secara default menggunakan L2 decay yang terkopelsgdw, lambw, adoptw, novogradw, rmsproptfw
sufiks cWeight decay yang dikoreksi, di mana decay diskalakan oleh lrΒ² / max_lr alih-alih lr (Mengapa Gradien Meningkat dengan Cepat di Akhir Pelatihan)adamc, nadamc, sgdc, lionc, adoptc, kronc
prefiks nMomentum Nesterov (keluarga SGD, LARS, dan Muon)nesterov, nlars, nmuon, nadamuon
prefiks lookahead_Bungkus optimizer dalam Lookaheadlookahead_adamw
prefiks fusedImplementasi fused NVIDIA Apex (memerlukan apex)fusedadamw, fusedlamb
prefiks bnbimplementasi bitsandbytes, 8bit akhiran untuk state 8-bit (memerlukan bitsandbytes)bnbadamw, bnbadamw8bit

Beberapa nama mendahului konvensi: lambc dan larc adalah LAMB / LARS dengan pemotongan rasio kepercayaan (varian LAMB dengan peluruhan yang dikoreksi adalah lambcd), momentum adalah SGD dengan momentum klasik, dan sgd adalah SGD dengan momentum Nesterov. Implementasi legacy dalam tabel di bawah ini mendahului penyertaannya di PyTorch.

Keluarga optimizer

NamaImplementasiCatatan
adamw, adam, nadam, radam, radamw, adamax, adadelta, adagrad, rmsprop, sgd, momentum, nesterovtorch.optim
adamwlegacy, adamc, cadamw, cadamcAdamWLegacyAdamW dengan kehati-hatian, peluruhan yang dikoreksi, pemotongan pembaruan, capturable
nadamw, nadamc, cnadamw, cnadamcNAdamWAdamW dengan momentum Nesterov (bentuk efisiensi algoritmik MLCommons)
adopt, adoptw, adoptc, cadopt, cadoptw, cadoptcAdoptVarian Adam yang konvergen untuk Ξ²2 apa pun
adan, adanw, cadan, cadanwAdanMomentum Nesterov adaptif
adabelief, radabeliefAdaBeliefradabelief menambahkan rektifikasi gaya RAdam
adafactor, cadafactorAdafactorfairseq Adafactor, ukuran langkah relatif saat lr=None
adafactorbv, adafactorbvc, cadafactorbv, cadafactorbvcAdafactorBigVisionBig Vision Adafactor, momen kedua terfaktor, momentum presisi rendah, pemotongan pembaruan
adamp, cadamp, sgdp, csgdpAdamP, SGDPProyeksi pembaruan untuk bobot yang invarian terhadap skala
adahessianAdahessianOrde kedua, memerlukan closure (is_second_order)
kron, kronw, kroncKronPSGD dengan preconditioner yang difaktorkan Kronecker
lamb, lambc, lambw, lambcw, lambcd, clamb, clambwLambMomen adaptif per lapisan, varian trust_clip (lambc, lambcw)
laprop, lapropc, clapropLaPropMomentum dan adaptivitas dipisahkan
lars, larc, nlars, nlarcLarsSkala laju adaptif per lapisan, varian trust_clip (larc, nlarc)
lion, lionc, clion, clioncLionMomentum tanda berevolusi
madgrad, madgradwMADGRADRata-rata ganda berbasis momentum
mars, cmarsMarsPengurangan varians, pembaruan gaya AdamW atau Lion
muon, nmuon, adamuon, nadamuonMuonMomentum terortogonalisasi Newton-Schulz untuk bobot 2D+, fallback AdamW / NAdamW untuk parameter 1D
novograd, novogradw, novogradcNvNovoGradMomen ternormalisasi per lapisan
rmsproptf, rmsproptfw, rmsproptfc, crmsproptfRMSpropTFUrutan ops dan penanganan eps dalam TensorFlow, lr yang digabungkan ke dalam buffer momentum
sgdw, nesterovw, sgdc, csgdw, csgdcSGDWSGD dengan peluruhan bobot yang terpisah
nadamlegacy, radamlegacyNAdamLegacy, RAdamLegacyImplementasi referensi, digantikan oleh torch.optim
fused*, bnb*NVIDIA Apex, bitsandbytesDidaftarkan saat paket diinstal

Opsi umum

Sebagian besar optimizer timm berbagi seperangkat opsi di luar lr, weight_decay, betas, dan eps yang umum. Optimizer mana saja yang menerima opsi mana dapat diperiksa pada tanda tangan kelas di bawah; factory akan melempar error untuk argumen yang tidak didukung.

  • caution menerapkan mask pembaruan hati-hati, yang setara dengan nama registry berawalan c.
  • corrected_weight_decay menskalakan decoupled weight decay dengan lrΒ² / max_lr alih-alih lr (nama-nama dengan akhiran c), sehingga peluruhan efektif mengikuti jadwal learning rate. max_lr adalah learning rate yang digunakan saat optimizer dibuat; buatlah optimizer dengan lr puncak dari jadwal (seperti yang dilakukan oleh train.py). Nilai ini disimpan di setiap param group (max_lr_snapshot) dan disimpan/dipulihkan bersama state optimizer.
  • decoupled_decay (atau decoupled) mengubah optimizer yang secara default menggunakan L2 decay yang coupled menjadi gaya decay AdamW (nama-nama dengan akhiran w).
  • foreach memilih implementasi multi-tensor. Secara default (None), ini digunakan pada CUDA dan perangkat lain dengan kernel foreach, sesuai dengan torch.optim, kecuali jika tidak didukung oleh konfigurasi (tensor lr tanpa capturable, atau caution pada versi PyTorch tanpa overload _foreach_maximum_ yang diperlukan). Langkah multi-tensor dijalankan dalam chunk parameter yang ukurannya disesuaikan agar working set setiap chunk tetap berada di cache L2 GPU, yang lebih cepat daripada streaming setiap parameter melalui memori sekali per op untuk model besar. Ukuran chunk diturunkan dari ukuran cache L2 perangkat (PyTorch >= 2.5) dan chunking dilewati pada perangkat di mana chunk yang dihasilkan berada di bawah 4M elemen. TIMM_FOREACH_CHUNK_SIZE=<elements> menimpa ukuran chunk, 0 menonaktifkan chunking.
  • capturable (AdamWLegacy, NAdamW, Adopt, Muon) menyimpan jumlah langkah di perangkat sehingga langkah dapat ditangkap dalam grafik CUDA. Semua optimizer menerima lr yang diberikan sebagai tensor 0-dim, diperbarui di tempat oleh jadwal, untuk digunakan dengan torch.compile dan grafik CUDA.
  • clipping_threshold (AdamWLegacy, NAdamW, AdafactorBigVision) memotong (clipping) pembaruan berdasarkan RMS-nya, update / max(1, rms / threshold) dengan rms sebagai RMS dari gradien yang dinormalisasi oleh momen kedua, per tensor (StableAdamW, Adafactor). 1.0 seperti dalam makalah-makalah tersebut. Seperti pada Adafactor, weight decay (terpisah) tidak dipotong, StableAdamW juga menskalakan decay dengan learning rate yang telah dipotong.
  • maximize memaksimalkan fungsi tujuan alih-alih meminimalkannya.

Parameter presisi rendah (bfloat16, float16) didukung di seluruh bagian:

  • AdaBelief, RAdamLegacy dan Adafactor menyimpan state mereka dalam float32 untuk parameter presisi rendah.
  • AdafactorBigVision mempertahankan momentumnya dalam presisi yang dikurangi (momentum_dtype).
  • Kron memiliki opsi mu_dtype / precond_dtype yang terpisah.

State dtype ini dipertahankan oleh load_state_dict (loader default PyTorch meng-cast state ke param dtype). Fungsi step menghindari host sync (cabang Python yang bergantung pada data pada tensor perangkat), kecuali pemeriksaan proyeksi AdamP / SGDP.

Grup parameter

Ketika diberikan sebuah model, create_optimizer_v2 mengelompokkan parameter dengan param_groups_weight_decay (tanpa decay untuk parameter 1D dan set no_weight_decay() dari model) atau, jika layer_decay diset, menggunakan param_groups_layer_decay, yang menetapkan skala learning rate sebesar layer_decay ** (num_layers - layer_id) per layer menggunakan group_matcher() dari model. Model tanpa group_matcher() akan kembali ke auto_group_layers, yang membutuhkan pretrained_cfg['classifier'] dari model untuk memisahkan head. Untuk optimizer hibrida (Muon), argumen fallback_list dan fallback_no_weight_decay mengarahkan parameter ke optimizer fallback (AdamW).

API

Fungsi pabrik

timm.optim.create_optimizer_v2

< >

( model_or_params: typing.Union[torch.nn.Module, torch.optim.optimizer.ParamsT]opt: str = 'sgd'lr: typing.Optional[float] = Noneweight_decay: float = 0.0momentum: float = 0.9foreach: typing.Optional[bool] = Nonefilter_bias_and_bn: bool = Truefallback_list: typing.Collection[str] = ()fallback_no_weight_decay: bool = Falselayer_decay: typing.Optional[float] = Nonelayer_decay_min_scale: float = 0.0layer_decay_no_opt_scale: typing.Optional[float] = Noneparam_group_fn: typing.Optional[typing.Callable[[torch.nn.Module], torch.optim.optimizer.ParamsT]] = None**kwargs: typing.Any )

Parameter

  • model_or_params β€” Model PyTorch atau iterable dari parameter/grup parameter. Jika model diberikan, parameter akan diekstrak dan dikelompokkan secara otomatis berdasarkan argumen lainnya.
  • opt β€” Nama optimizer yang akan dibuat (misalnya, β€˜adam’, β€˜adamw’, β€˜sgd’). Gunakan list_optimizers() untuk melihat opsi yang tersedia.
  • lr β€” Laju pembelajaran. Jika None, akan menggunakan nilai default dari optimizer.
  • weight_decay β€” Faktor weight decay. Akan digunakan untuk membuat param groups jika model_or_params adalah model.
  • momentum β€” Faktor momentum untuk optimizer yang mendukungnya. Hanya digunakan jika optimizer yang dipilih menerima parameter momentum.
  • foreach β€” Mengaktifkan/menonaktifkan implementasi foreach (multi-tensor) jika tersedia. Jika None, akan menggunakan nilai default yang spesifik untuk optimizer.
  • filter_bias_and_bn β€” Jika True, parameter bias dan lapisan norm (semua parameter 1d) tidak akan diberi weight decay. Hanya digunakan ketika model_or_params adalah model dan weight_decay > 0.
  • fallback_list β€” Kumpulan pola nama parameter untuk menggunakan optimizer fallback pada optimizer hybrid (misalnya, AdamW untuk Muon). Mendukung pencocokan wildcard.
  • fallback_no_weight_decay β€” Jika True, parameter dalam daftar no_weight_decay() model akan menggunakan optimizer fallback untuk optimizer hybrid (misalnya, AdamW untuk Muon).
  • layer_decay β€” Faktor peluruhan laju pembelajaran per lapisan yang opsional. Jika diberikan, laju pembelajaran akan diskalakan dengan layer_decay^(max_depth - layer_depth). Hanya digunakan ketika model_or_params adalah model.
  • param_group_fn β€” Fungsi opsional untuk membuat grup parameter kustom. Jika disediakan, opsi pengelompokan parameter lainnya akan diabaikan.
  • **kwargs β€” Argumen tambahan yang spesifik untuk optimizer (misalnya, betas untuk Adam).

Buat instance optimizer melalui registry timm.

Membuat dan mengonfigurasi optimizer dengan grup parameter dan pengaturan yang sesuai. Mendukung pembuatan grup parameter secara otomatis untuk weight decay dan laju pembelajaran per lapisan, serta pengelompokan parameter kustom.

Contoh:

AdamW dari sebuah model, grup parameter dibuat secara otomatis:

optimizer = create_optimizer_v2(model, 'adamw', lr=1e-3)

SGD dengan momentum dan peluruhan bobot:

optimizer = create_optimizer_v2(model, 'sgd', lr=0.1, momentum=0.9, weight_decay=1e-4)

Adam dengan peluruhan laju pembelajaran per lapisan:

optimizer = create_optimizer_v2(model, 'adam', lr=1e-3, layer_decay=0.7)

Grup parameter kustom:

def group_fn(model):
    return [
        {'params': model.backbone.parameters(), 'lr': 1e-4},
        {'params': model.head.parameters(), 'lr': 1e-3},
    ]

optimizer = create_optimizer_v2(model, 'sgd', param_group_fn=group_fn)

Catatan: Prioritas penanganan grup parameter:

  1. Jika param_group_fn disediakan, ia akan digunakan secara eksklusif
  2. Jika layer_decay disediakan, grup per lapisan akan dibuat
  3. Jika weight_decay > 0 dan filter_bias_and_bn adalah True, grup weight decay akan dibuat
  4. Jika tidak, semua parameter akan berada dalam satu grup

timm.optim.list_optimizers

< >

( filter: typing.Union[str, typing.List[str]] = ''exclude_filters: typing.Optional[typing.List[str]] = Nonewith_description: bool = False ) β†’ If with_description is False

Parameter

  • filter β€” String filter bergaya wildcard atau daftar string filter (contohnya, β€˜adam’ untuk semua varian Adam, atau [β€˜adam’, β€˜*8bit’] untuk varian Adam dan optimizer 8-bit). String kosong berarti tanpa filter.
  • exclude_filters β€” Daftar opsional pola wildcard untuk dikecualikan. Misalnya, [’8bit’, β€˜fused’] akan mengecualikan implementasi 8-bit dan fused.
  • with_description β€” Jika True, mengembalikan tuple (name, description) alih-alih hanya nama. Deskripsi menyediakan penjelasan singkat tentang karakteristik optimizer.

Mengembalikan

Jika with_description adalah False

Daftar nama optimizer sebagai string (misalnya, [β€˜adam’, β€˜adamw’, …]) Jika with_description adalah True: Daftar tuple dari (name, description) (misalnya, [(β€˜adam’, β€˜Adaptive Moment…’), …])

Daftarkan nama optimizer yang tersedia, opsional dengan filter.

Daftarkan semua optimizer yang terdaftar, dengan filter opsional menggunakan pola wildcard. Optimizer dapat difilter menggunakan pola include dan exclude, dan secara opsional mengembalikan deskripsi bersama setiap nama optimizer.

Contoh:

>>> list_optimizers()
['adam', 'adamw', 'sgd', ...]

>>> list_optimizers(['la*', 'nla*'])  # List lamb & lars
['lamb', 'lambc', 'larc', 'lars', 'nlarc', 'nlars']

>>> list_optimizers('*adam*', exclude_filters=['bnb*', 'fused*'])  # Exclude bnb & apex adam optimizers
['adam', 'adamax', 'adamp', 'adamw', 'nadam', 'nadamw', 'radam']

>>> list_optimizers(with_description=True)  # Get descriptions
[('adabelief', 'Adapts learning rate based on gradient prediction error'),
 ('adadelta', 'torch.optim Adadelta, Adapts learning rates based on running windows of gradients'),
 ('adafactor', 'Memory-efficient implementation of Adam with factored gradients'),
...]

timm.optim.get_optimizer_class

< >

( name: strbind_defaults: bool = True ) β†’ If bind_defaults is False

Parameter

  • name β€” Nama optimizer yang akan diambil (misalnya, β€˜adam’, β€˜sgd’)
  • bind_defaults β€” Jika True, mengembalikan fungsi parsial dengan argumen default dari OptimInfo yang terikat. Jika False, mengembalikan kelas optimizer mentah.

Mengembalikan

Jika bind_defaults adalah False

Kelas optimizer (misalnya, torch.optim.Adam) Jika bind_defaults adalah True: Fungsi parsial dengan argumen default yang terikat

Membuang

ValueError

  • ValueError β€” Jika nama optimizer tidak ditemukan di registry

Dapatkan kelas optimizer berdasarkan nama dengan opsi untuk mengikat argumen default.

Mengambil kelas optimizer atau fungsi parsial dengan argumen default yang terikat. Hal ini memungkinkan instansiasi langsung optimizer dengan konfigurasi defaultnya tanpa harus melalui pabrik lengkap.

Contoh:

Dengan default registry yang terikat, sgd memiliki momentum nesterov yang diaktifkan:

SGD = get_optimizer_class('sgd')
opt = SGD(model.parameters(), lr=0.1, momentum=0.9)

Kelas optimizer mentah:

SGD = get_optimizer_class('sgd', bind_defaults=False)
opt = SGD(model.parameters(), lr=1e-3, momentum=0.9, nesterov=True)

timm.optim.get_optimizer_info

< >

( name: str )

Parameter

  • name β€” Nama optimizer

Membuang

ValueError

  • ValueError β€” Jika optimizer tidak ditemukan

Dapatkan OptimInfo untuk optimizer.

Fungsi grup parameter

timm.optim.param_groups_weight_decay

< >

( model: Moduleweight_decay: typing.Optional[float] = 1e-05weight_decay_exclude_1d: bool = Trueno_weight_decay_list: typing.Collection[str] = ()fallback_list: typing.Collection[str] = ()fallback_no_weight_decay: bool = False )

timm.optim.param_groups_layer_decay

< >

( model: Moduleweight_decay: float = 0.05no_weight_decay_list: typing.Collection[str] = ()fallback_list: typing.Collection[str] = ()fallback_no_weight_decay: bool = Falseweight_decay_exclude_1d: bool = Truelayer_decay: float = 0.75min_scale: float = 0.0no_opt_scale: typing.Optional[float] = Noneverbose: bool = False )

Grup parameter untuk peluruhan lr per lapisan & peluruhan bobot Berdasarkan BEiT: https://github.com/microsoft/unilm/blob/master/beit/optim_factory.py#L58

timm.optim.auto_group_layers

< >

( modellayers_per_group = 12num_groups = None )

Kelas Optimizer

kelas timm.optim.AdaBelief

< >

( paramslr = 0.001betas = (0.9, 0.999)eps = 1e-16weight_decay = 0amsgrad = Falsedecoupled_decay = Truefixed_decay = Falserectify = Truedegenerated_to_sgd = Trueforeach: typing.Optional[bool] = None )

Parameter

  • params (iterable) β€” iterable dari parameter untuk dioptimalkan atau dicts yang mendefinisikan grup parameter
  • lr (float, opsional) β€” learning rate (default: 1e-3)
  • betas (Tuple[float, float], opsional) β€” koefisien yang digunakan untuk menghitung rata-rata berjalan dari gradien dan kuadratnya (default: (0.9, 0.999))
  • eps (float, opsional) β€” istilah yang ditambahkan ke penyebut untuk meningkatkan stabilitas numerik (default: 1e-16)
  • weight_decay (float, opsional) β€” weight decay (penalti L2) (default: 0)
  • amsgrad (boolean, opsional) β€” apakah akan menggunakan varian AMSGrad dari algoritma ini dari makalah On the Convergence of Adam and Beyond_ (default: False)
  • decoupled_decay (boolean, opsional) β€” (default: True) Jika diset sebagai True, maka optimizer menggunakan decoupled weight decay seperti pada AdamW
  • fixed_decay (boolean, opsional) β€” (default: False) Ini digunakan ketika weightdecouple diatur sebagai True. Ketika fixed_decay == True, weight decay dilakukan sebagai $W{new} = W{old} - W{old} \times decay$. Ketika fixeddecay == False, weight decay dilakukan sebagai $W{new} = W{old} - W{old} \times decay \times lr$. Perhatikan bahwa dalam kasus ini, rasio weight decay berkurang seiring dengan learning rate (lr).
  • rectify (boolean, opsional) β€” (default: True) Jika diset sebagai True, maka lakukan pembaruan yang direkifikasi serupa dengan RAdam
  • degenerated_to_sgd (boolean, opsional) (default β€”True) Jika diset sebagai True, maka lakukan pembaruan SGD ketika varians gradien tinggi
  • foreach (boolean, opsional) β€” gunakan implementasi foreach (multi-tensor), secara default (None) digunakan kecuali tidak didukung

Menerapkan algoritma AdaBelief. Dimodifikasi dari Adam di PyTorch

reference: Optimizer AdaBelief, menyesuaikan ukuran langkah berdasarkan keyakinan terhadap gradien yang diamati, NeurIPS 2020

Untuk tabel lengkap hiperparameter yang direkomendasikan, lihat https://github.com/juntang-zhuang/Adabelief-Optimizer’ Sebagai contoh, train/args untuk EfficientNet dapat dilihat pada gists berikut

langkah

< >

( closure = None )

Parameter

  • closure (callable, opsional) β€” Closure yang mengevaluasi ulang model dan mengembalikan loss.

Melakukan satu langkah optimasi.

kelas timm.optim.Adafactor

< >

( params: ParamsTlr: typing.Optional[float] = Noneeps: float = 1e-30eps_scale: float = 0.001clip_threshold: float = 1.0decay_rate: float = -0.8betas: typing.Optional[typing.Tuple[float, float]] = Noneweight_decay: float = 0.0scale_parameter: bool = Truewarmup_init: bool = Falsemin_dim_size_to_factor: int = 16caution: bool = False )

Menerapkan algoritma Adafactor.

Implementasi ini didasarkan pada: Adafactor: Adaptive Learning Rates with Sublinear Memory Cost (lihat https://arxiv.org/abs/1804.04235)

Perhatikan bahwa optimizer ini secara internal menyesuaikan learning rate berdasarkan opsi scale_parameter, relative_step, dan warmup_init.

Jadwal laju pembelajaran manual (eksternal) digunakan ketika lr diset (relative_step kemudian menjadi False). Perlu dicatat bahwa dalam implementasi ini, scale_parameter dan warmup_init hanya berlaku untuk laju pembelajaran langkah relatif (lr=None), berbeda dengan fairseq / HF Transformers, penskalaan RMS parameter tidak diterapkan pada laju pembelajaran eksternal.

Ags: params: iterable dari parameter untuk dioptimalkan atau dicts yang mendefinisikan grup parameter lr: learning rate eksternal eps: konstanta regularisasi untuk square gradient dan skala parameter, masing-masing eps_scale: konstanta regularisasi untuk skala parameter, masing-masing clip_threshold: ambang batas root-mean-square dari pembaruan gradient akhir decay_rate: koefisien yang digunakan untuk menghitung running averages dari square gradient beta1: koefisien yang digunakan untuk menghitung running averages dari gradient weight_decay: weight decay scale_parameter: jika True, relative step learning rate diskalakan oleh root-mean-square dari parameter warmup_init: perhitungan learning rate yang bergantung pada waktu bergantung pada apakah inisialisasi warm-up sedang digunakan

langkah

< >

( closure = None )

Parameter

  • closure (callable, opsional) β€” Closure yang mengevaluasi ulang model dan mengembalikan loss.

Melakukan satu langkah optimasi.

kelas timm.optim.AdafactorBigVision

< >

( params: ParamsTlr: float = 1.0min_dim_size_to_factor: int = 16decay_rate: float = 0.8decay_offset: int = 0beta2_cap: float = 0.999momentum: typing.Optional[float] = 0.9momentum_dtype: typing.Union[str, torch.dtype] = torch.bfloat16eps: typing.Optional[float] = Noneweight_decay: float = 0.0clipping_threshold: typing.Optional[float] = Noneunscaled_wd: bool = Falsecaution: bool = Falsecorrected_weight_decay: bool = False )

Implementasi PyTorch dari varian Adafactor BigVision dengan implementasi tensor tunggal dan multi tensor.

Diadaptasi dari https://github.com/google-research/big_vision oleh Ross Wightman

kelas timm.optim.Adahessian

< >

( paramslr = 0.1betas = (0.9, 0.999)eps = 1e-08weight_decay = 0.0hessian_power = 1.0update_each = 1n_samples = 1avg_conv_kernel = False )

Parameter

  • params (iterable) β€” iterable dari parameter untuk dioptimalkan atau dict yang mendefinisikan grup parameter
  • lr (float, opsional) β€” learning rate (default: 0.1)
  • betas ((float, float), optional) β€” koefisien yang digunakan untuk menghitung rata-rata berjalan gradien dan jejak hessian kuadrat (default: (0.9, 0.999))
  • eps (float, opsional) β€” istilah yang ditambahkan ke penyebut untuk meningkatkan stabilitas numerik (default: 1e-8)
  • weight_decay (float, opsional) β€” weight decay (penalti L2) (default: 0.0)
  • hessian_power (float, opsional) β€” eksponen dari jejak hessian (default: 1.0)
  • update_each (int, opsional) β€” hitung aproksimasi jejak hessian hanya setelah ini jumlah langkah (untuk menghemat waktu) (default: 1)
  • n_samples (int, opsional) β€” berapa kali z akan disampelkan untuk aproksimasi jejak hessian (default: 1)

Implements the AdaHessian algorithm from β€œADAHESSIAN: An Adaptive Second OrderOptimizer for Machine Learning”

get_params

< >

( )

Mendapatkan semua parameter di semua param_groups yang memiliki gradien

set_hessian

< >

( )

Menghitung aproksimasi Hutchinson dari jejak hessian dan mengakumulasikannya untuk setiap parameter yang dapat dilatih.

langkah

< >

( closure = None )

Parameter

  • closure (callable, opsional) β€” closure yang mengevaluasi ulang model dan mengembalikan loss (default β€” None)

Melakukan satu langkah optimasi.

zero_hessian

< >

( )

Menolakan jejak hessian yang terakumulasi.

kelas timm.optim.AdamP

< >

( paramslr = 0.001betas = (0.9, 0.999)eps = 1e-08weight_decay = 0delta = 0.1wd_ratio = 0.1nesterov = Falsecaution = False )

kelas timm.optim.AdamWLegacy

< >

( params: ParamsTlr: float = 0.001betas: typing.Tuple[float, float] = (0.9, 0.999)eps: float = 1e-08weight_decay: float = 0.01amsgrad: bool = Falsecaution: bool = Falsecorrected_weight_decay: bool = Falsemaximize: bool = Falseforeach: typing.Optional[bool] = Nonecapturable: bool = Falseclipping_threshold: typing.Optional[float] = None )

Parameter

  • params β€” iterable dari parameter untuk dioptimalkan atau dicts yang mendefinisikan grup parameter
  • lr β€” learning rate
  • betas β€” koefisien yang digunakan untuk menghitung rata-rata berjalan dari gradien dan kuadratnya
  • eps β€” istilah yang ditambahkan ke penyebut untuk meningkatkan stabilitas numerik
  • weight_decay β€” koefisien weight decay
  • amsgrad β€” apakah akan menggunakan varian AMSGrad dari algoritme ini dari makalah On the Convergence of Adam and Beyond
  • caution β€” berhati-hatilah saat menggunakan AdamW
  • corrected_weight_decay β€” terapkan koreksi weight decay (lr**2 / max_lr)
  • maximize β€” memaksimalkan parameter berdasarkan tujuan, alih-alih meminimalkannya
  • foreach β€” apakah implementasi foreach dari optimizer digunakan. Jika tidak ditentukan oleh pengguna (sehingga foreach adalah None), kami akan mencoba menggunakan foreach daripada implementasi for-loop pada CUDA, karena secara umum lebih cepat.
  • capturable β€” apakah instance ini aman untuk ditangkap dalam grafik CUDA. Menyampaikan True dapat menurunkan kinerja tanpa grafik, jadi jika Anda tidak bermaksud untuk menangkap grafik instance ini, biarkan False
  • clipping_threshold β€” ambang pemotongan pembaruan RMS (StableAdamW, https://arxiv.org/abs/2304.13013), pembaruannya diskalakan dengan 1 / max(1, rms / clipping_threshold) dengan rms sebagai RMS dari grad / (sqrt(v_hat) + eps). Meredam pembaruan parameter yang mengalami peningkatan gradien secara tiba-tiba relatif terhadap estimasi momen keduanya. 1.0 sesuai dengan makalah, None (default) menonaktifkan. Seperti pada Adafactor, peluruhan bobot yang terpisah tidak dipotong (StableAdamW juga menskalakan peluruhan dengan lr yang dipotong).

Menerapkan algoritma AdamW.

CATATAN: Implementasi ini telah ditinggalkan demi torch.optim.AdamW dan tetap ada sebagai referensi

Referensi:

langkah

< >

( closure = None )

Parameter

  • closure (callable, opsional) β€” Closure yang mengevaluasi ulang model dan mengembalikan loss.

Melakukan satu langkah optimasi.

kelas timm.optim.Adan

< >

( paramslr: float = 0.001betas: typing.Tuple[float, float, float] = (0.98, 0.92, 0.99)eps: float = 1e-08weight_decay: float = 0.0no_prox: bool = Falsecaution: bool = Falseforeach: typing.Optional[bool] = None )

Parameter

  • params β€” Iterable dari parameter untuk dioptimalkan atau dicts yang mendefinisikan grup parameter.
  • lr β€” Laju pembelajaran.
  • betas β€” Koefisien yang digunakan untuk momen orde pertama dan kedua.
  • eps β€” Istilah yang ditambahkan ke penyebut untuk meningkatkan stabilitas numerik.
  • weight_decay β€” Peluruhan bobot terurai (penalti L2)
  • no_prox β€” Cara melakukan weight decay
  • caution β€” Aktifkan caution dari β€˜Cautious Optimizers’
  • foreach β€” Jika True, akan menggunakan implementasi torch._foreach. Lebih cepat tetapi menggunakan sedikit lebih banyak memori.

Menerapkan varian pytorch dari Adan.

Adan diusulkan dalam Adan: Adaptive Nesterov Momentum Algorithm for Faster Optimizing Deep Models https://arxiv.org/abs/2208.06677

langkah

< >

( closure = None )

Melakukan satu langkah optimasi.

kelas timm.optim.Adopt

< >

( params: ParamsTlr: typing.Union[float, torch.Tensor] = 0.001betas: typing.Tuple[float, float] = (0.9, 0.9999)eps: float = 1e-06clip_exp: typing.Optional[float] = 0.333weight_decay: float = 0.0decoupled: bool = Falsecorrected_weight_decay: bool = Falsecaution: bool = Falseforeach: typing.Optional[bool] = Nonemaximize: bool = Falsecapturable: bool = Falsedifferentiable: bool = False )

ADOPT: Modifikasi Adam Dapat Konvergen dengan Ξ²2 Apa Pun pada Laju Optimal: https://arxiv.org/abs/2411.02853

langkah

< >

( closure = None )

Parameter

  • closure (Callable, opsional) β€” Closure yang mengevaluasi ulang model dan mengembalikan loss.

Lakukan satu langkah optimasi.

kelas timm.optim.kron.Kron

< >

( params: ParamsTlr: float = 0.001momentum: float = 0.9weight_decay: float = 0.0preconditioner_update_probability: typing.Union[typing.Callable, float, NoneType] = Nonemax_size_triangular: int = 2048min_ndim_triangular: int = 2memory_save_mode: typing.Optional[str] = Nonemomentum_into_precond_update: bool = Trueprecond_lr: float = 0.1precond_init_scale: float = 1.0mu_dtype: typing.Optional[torch.dtype] = Noneprecond_dtype: typing.Optional[torch.dtype] = Nonedecoupled_decay: bool = Falsecorrected_weight_decay: bool = Falseflatten: bool = Falseflatten_start_dim: int = 2flatten_end_dim: int = -1stochastic_weight_decay: bool = Falsedeterministic: bool = False )

Parameter

  • params β€” Iterable dari parameter untuk dioptimalkan atau dicts yang mendefinisikan grup parameter.
  • lr β€” Laju pembelajaran.
  • Parameter momentum.
  • weight_decay β€” Peluruhan bobot.
  • preconditioner_update_probability β€” Probabilitas pembaruan preconditioner. Jika None, defaultnya adalah jadwal yang melakukan annealing dari 1.0 menjadi 0.03 pada langkah 4000.
  • max_size_triangular β€” Ukuran maksimum untuk preconditioner dim agar berbentuk segitiga.
  • min_ndim_triangular β€” Jumlah dimensi minimum yang harus dimiliki sebuah layer untuk memiliki preconditioner segitiga.
  • memory_save_mode β€” β€˜one_diag’, β€˜smart_one_diag’, atau β€˜all_diag’, defaultnya None untuk mengatur semua preconditioner menjadi segitiga, β€˜one_diag’ mengatur dimensi terbesar atau terakhir menjadi diagonal per layer, dan β€˜all_diag’ mengatur semua preconditioner menjadi diagonal.
  • momentum_into_precond_update β€” apakah momentum dikirim ke pembaruan preconditioner alih-alih gradien mentah.
  • mu_dtype β€” Dtype dari akumulator momentum.
  • precond_dtype β€” Dtype dari preconditioner.
  • decoupled_decay β€” peluruhan bobot terpisahkan gaya AdamW
  • corrected_weight_decay β€” terapkan corrected weight decay saat menggunakan decoupled_decay (lr**2 / max_lr)
  • flatten β€” Ratakan dimensi alih-alih sepenuhnya mengandalkan ekspresi untuk parameter dengan rank lebih tinggi
  • flatten_start_dim β€” Awal dari rentang flatten, defaultnya 2. Tampaknya merupakan kompromi yang baik untuk ConvNets.
  • flatten_end_dim β€” Akhir dari rentang flatten, defaultnya -1.
  • stochastic_weight_decay β€” Aktifkan modulasi acak dari weight decay
  • deterministic β€” Perilaku deterministik di antara simpan / muat (lanjutkan). FIXME lambat, perlu perbaikan

Menerapkan PSGD Kron dari https://github.com/lixilinx/psgd_torch.

kelas timm.optim.Lamb

< >

( params: ParamsTlr: float = 0.001bias_correction: bool = Truebetas: typing.Tuple[float, float] = (0.9, 0.999)eps: float = 1e-06weight_decay: float = 0.01grad_averaging: bool = Truemax_grad_norm: typing.Optional[float] = 1.0trust_clip: bool = Falsealways_adapt: bool = Falsecaution: bool = Falsedecoupled_decay: bool = Falsecorrected_weight_decay: bool = Falseforeach: typing.Optional[bool] = None )

Parameter

  • params β€” Iterable dari parameter untuk dioptimalkan atau dicts yang mendefinisikan grup parameter.
  • lr β€” Laju pembelajaran
  • betas β€” Koefisien yang digunakan untuk menghitung rata-rata berjalan dari gradien dan normnya.
  • eps β€” Istilah yang ditambahkan ke penyebut untuk meningkatkan stabilitas numerik.
  • weight_decay β€” Peluruhan bobot
  • grad_averaging β€” Apakah menerapkan (1-beta2) ke grad saat menghitung rata-rata berjalan dari gradien.
  • max_grad_norm β€” Nilai yang digunakan untuk memotong (clip) norma grad global.
  • trust_clip β€” Aktifkan pemotongan rasio kepercayaan LAMBC.
  • always_adapt β€” Terapkan learning rate adaptif ke parameter weight decay 0.0.
  • caution β€” Bersikaplah hati-hati.
  • decoupled β€” terapkan peluruhan bobot yang terpisah
  • corrected_weight_decay β€” terapkan koreksi weight decay (lr**2 / max_lr) saat menggunakan decoupled_decay
  • foreach β€” gunakan implementasi foreach (multi-tensor), secara default (None) digunakan kecuali tidak didukung

Menerapkan varian pytorch murni dari optimizer FuseLAMB (varian NvLamb) dari apex.optimizers.FusedLAMB referensi: https://github.com/NVIDIA/DeepLearningExamples/blob/master/PyTorch/LanguageModeling/Transformer-XL/pytorch/lamb.py

LAMB diusulkan dalam:

langkah

< >

( closure = None )

Parameter

  • closure (callable, opsional) β€” Closure yang mengevaluasi ulang model dan mengembalikan loss.

Melakukan satu langkah optimasi.

kelas timm.optim.LaProp

< >

( params: ParamsTlr: float = 0.0004betas: typing.Tuple[float, float] = (0.9, 0.999)eps: float = 1e-15weight_decay: float = 0.0caution: bool = Falsecorrected_weight_decay: bool = Falseforeach: typing.Optional[bool] = None )

Parameter

  • foreach β€” gunakan implementasi foreach (multi-tensor), secara default (None) digunakan kecuali tidak didukung (lihat laprop())

LaProp Optimizer

Makalah: LaProp: Separating Momentum and Adaptivity in Adam, https://arxiv.org/abs/2002.04839

langkah

< >

( closure = None )

Parameter

  • closure (callable, opsional) β€” Closure yang mengevaluasi ulang model dan mengembalikan loss.

Melakukan satu langkah optimasi.

kelas timm.optim.Lars

< >

( paramslr = 1.0momentum = 0dampening = 0weight_decay = 0nesterov = Falsetrust_coeff = 0.001eps = 1e-08trust_clip = Falsealways_adapt = Falseforeach: typing.Optional[bool] = None )

Parameter

  • params (iterable) β€” iterable dari parameter yang akan dioptimalkan atau dict yang mendefinisikan grup parameter.
  • lr (float, opsional) β€” learning rate (default: 1.0).
  • momentum (float, opsional) β€” faktor momentum (default: 0)
  • weight_decay (float, opsional) β€” weight decay (penalti L2) (default: 0)
  • dampening (float, opsional) β€” peredaman untuk momentum (default: 0)
  • nesterov (bool, opsional) β€” mengaktifkan momentum Nesterov (default: False)
  • trust_coeff (float) β€” koefisien kepercayaan untuk menghitung lr adaptif / trust_ratio (default: 0.001)
  • eps (float) β€” eps untuk penyebut pembagian (default: 1e-8)
  • trust_clip (bool) β€” mengaktifkan pemotongan rasio kepercayaan LARC (default: False)
  • always_adapt (bool) β€” selalu terapkan adaptasi LARS LR, selain itu hanya ketika group weight_decay != 0 (default: False)
  • foreach (bool, opsional) β€” gunakan implementasi foreach (multi-tensor), secara default (None) digunakan kecuali tidak didukung

LARS untuk PyTorch

Makalah: Large batch training of Convolutional Networks - https://arxiv.org/pdf/1708.03888.pdf

langkah

< >

( closure = None )

Parameter

  • closure (callable, opsional) β€” Closure yang mengevaluasi ulang model dan mengembalikan loss.

Melakukan satu langkah optimasi.

kelas timm.optim.Lion

< >

( params: ParamsTlr: float = 0.0001betas: typing.Tuple[float, float] = (0.9, 0.99)weight_decay: float = 0.0caution: bool = Falsecorrected_weight_decay: bool = Falsemaximize: bool = Falseforeach: typing.Optional[bool] = None )

Menerapkan algoritma Lion.

langkah

< >

( closure = None )

Parameter

  • closure β€” Closure yang mengevaluasi ulang model dan mengembalikan loss.

Melakukan satu langkah optimasi.

kelas timm.optim.Lookahead

< >

( base_optimizeralpha = 0.5k = 6 )

kelas timm.optim.MADGRAD

< >

( params: typing.Anylr: float = 0.01momentum: float = 0.9weight_decay: float = 0eps: float = 1e-06decoupled_decay: bool = False )

Parameter

  • params (iterable) β€” Iterable dari parameter untuk dioptimalkan atau dict yang mendefinisikan grup parameter.
  • lr (float) β€” Learning rate (default: 1e-2).
  • momentum (float) — Momentum value in the range [0,1) (default: 0.9).
  • weight_decay (float) β€” Weight decay, yaitu penalti L2 (default: 0).
  • eps (float) β€” Istilah yang ditambahkan ke penyebut di luar operasi akar untuk meningkatkan stabilitas numerik. (default: 1e-6).

MADGRAD_: Metode Gradien Rata-rata Dual yang Diadaptasi dan Dimomentalisasi untuk Optimasi Stokastik.

.. _MADGRAD: https://arxiv.org/abs/2101.11075

MADGRAD adalah optimizer serbaguna yang dapat digunakan sebagai pengganti SGD atau Adam, dan mungkin dapat konvergen lebih cepat serta menghasilkan generalisasi yang lebih baik. Saat ini hanya mendukung GPU. Biasanya, jadwal learning rate yang sama yang digunakan untuk SGD atau Adam dapat digunakan. Nilai learning rate keseluruhan tidak dapat dibandingkan langsung dengan kedua metode tersebut dan harus ditentukan melalui hyper-parameter sweep.

MADGRAD membutuhkan weight decay yang lebih sedikit dibandingkan metode lain, sering kali bahkan nol. Nilai momentum yang digunakan untuk SGD atau beta1 Adam juga seharusnya berfungsi di sini.

Pada masalah sparse, weight_decay dan momentum harus diatur ke 0.

langkah

< >

( closure: typing.Optional[typing.Callable[[], float]] = None )

Parameter

  • closure (callable, opsional) β€” Closure yang mengevaluasi ulang model dan mengembalikan loss.

Melakukan satu langkah optimasi.

kelas timm.optim.Mars

< >

( params: ParamsTlr: float = 0.003betas: typing.Tuple[float, float] = (0.9, 0.99)eps: float = 1e-08weight_decay: float = 0.0gamma: float = 0.025mars_type: str = 'adamw'optimize_1d: bool = Falselr_1d_factor: float = 1.0betas_1d: typing.Optional[typing.Tuple[float, float]] = Nonecaution: bool = False )

MARS Optimizer

Makalah: MARS: Membangunkan Kekuatan Pengurangan Varians untuk Melatih Model Besar https://arxiv.org/abs/2411.10438

langkah

< >

( closure = None )

Parameter

  • closure (callable, opsional) β€” Closure yang mengevaluasi ulang model dan mengembalikan loss.

Melakukan satu langkah optimasi.

kelas timm.optim.Muon

< >

( params: ParamsTlr: float = 0.02weight_decay: float = 0momentum: float = 0.95nesterov: bool = Falsens_steps: int = 5ns_coefficients: typing.Union[str, typing.Tuple[float, float, float], typing.List[typing.Tuple[float, float, float]]] = 'quintic'eps: float = 1e-07safety_factor: float = 1.0adjust_lr_fn: typing.Optional[str] = 'match_rms_adamw'conv_mode: str = 'flatten'normalize_spatial: bool = Trueadamw_lr: typing.Optional[float] = Nonefallback_lr_scale: float = 1.0betas: typing.Tuple[float, float] = (0.9, 0.95)algo: str = 'muon'scale_eps: bool = Falsecapturable: bool = Falseverbose: bool = False )

Muon - MomentUm yang Diortogonalkan dengan Newton-schulz

Menggabungkan Muon untuk parameter 2D+ (matriks bobot) dengan AdamW untuk parameter 1D (bias, norm) dan grup parameter yang disetel dengan β€˜use_fallback=True’ (atau β€˜use_muon=False’ untuk kompatibilitas).

Mendukung dua algoritma:

  • β€œmuon”: Algoritma Muon standar dengan momentum + ortogonalisasi
  • β€œadamuon”: Algoritma AdaMuon yang menambahkan estimasi momen kedua per elemen ke arah yang diortogonalkan untuk penskalaan adaptif serupa Adam

langkah

< >

( closure = None )

Melakukan satu langkah optimasi.

kelas timm.optim.NAdamLegacy

< >

( paramslr = 0.002betas = (0.9, 0.999)eps = 1e-08weight_decay = 0schedule_decay = 0.004 )

Parameter

  • params (iterable) β€” iterable dari parameter untuk dioptimalkan atau dicts yang mendefinisikan grup parameter
  • lr (float, opsional) β€” learning rate (default: 2e-3)
  • betas (Tuple[float, float], optional) β€” koefisien yang digunakan untuk menghitung rata-rata berjalan dari gradien dan kuadratnya
  • eps (float, opsional) β€” istilah yang ditambahkan ke penyebut untuk meningkatkan stabilitas numerik (default: 1e-8)
  • weight_decay (float, opsional) β€” weight decay (penalti L2) (default: 0)
  • schedule_decay (float, opsional) β€” peluruhan jadwal momentum (default: 4e-3)

Menerapkan algoritma Nadam (varian Adam yang didasarkan pada momentum Nesterov).

CATATAN: Implementasi ini telah ditinggalkan demi torch.optim.NAdam dan tetap ada sebagai referensi

Hal ini telah diusulkan dalam Incorporating Nesterov Momentum into Adam__.

http://cs229.stanford.edu/proj2015/054_report.pdf http://www.cs.toronto.edu/~fritz/absps/momentum.pdf

Awalnya diambil dari: https://github.com/pytorch/pytorch/pull/1408 CATATAN: Memiliki potensi masalah tetapi berfungsi dengan baik pada beberapa masalah.

langkah

< >

( closure = None )

Parameter

  • closure (callable, opsional) β€” Closure yang mengevaluasi ulang model dan mengembalikan loss.

Melakukan satu langkah optimasi.

kelas timm.optim.NAdamW

< >

( params: ParamsTlr: float = 0.001betas: typing.Tuple[float, float] = (0.9, 0.999)eps: float = 1e-08weight_decay: float = 0.01caution: bool = Falsecorrected_weight_decay: bool = Falsemaximize: bool = Falseforeach: typing.Optional[bool] = Nonecapturable: bool = Falseclipping_threshold: typing.Optional[float] = None )

Parameter

  • params β€” iterable dari parameter untuk dioptimalkan atau dicts yang mendefinisikan grup parameter
  • lr β€” learning rate
  • betas β€” koefisien yang digunakan untuk menghitung rata-rata berjalan dari gradien dan kuadratnya
  • eps β€” istilah yang ditambahkan ke penyebut untuk meningkatkan stabilitas numerik
  • weight_decay β€” koefisien weight decay
  • caution β€” aktifkan caution
  • corrected_weight_decay β€” terapkan koreksi weight decay (lr**2 / max_lr)
  • maximize β€” memaksimalkan parameter berdasarkan tujuan, alih-alih meminimalkannya
  • foreach β€” apakah implementasi foreach dari optimizer digunakan. Jika tidak ditentukan (None), implementasi foreach digunakan pada CUDA (perangkat dengan kernel foreach) karena secara umum lebih cepat.
  • capturable β€” apakah instance ini aman untuk ditangkap dalam grafik CUDA
  • clipping_threshold β€” ambang pemotongan pembaruan RMS (StableAdamW, https://arxiv.org/abs/2304.13013), pembaruannya diskalakan dengan 1 / max(1, rms / clipping_threshold) dengan rms sebagai RMS dari grad / (sqrt(v_hat) + eps). Meredam pembaruan parameter yang mengalami peningkatan gradien secara tiba-tiba relatif terhadap estimasi momen keduanya. 1.0 sesuai dengan makalah, None (default) menonaktifkan. Seperti pada Adafactor, peluruhan bobot yang terpisah tidak dipotong (StableAdamW juga menskalakan peluruhan dengan lr yang dipotong).

Menerapkan algoritma NAdamW.

Lihat Tabel 1 di https://arxiv.org/abs/1910.05446 untuk implementasi algoritma NAdam (ada juga komentar dalam kode yang menyoroti satu-satunya perbedaan antara NAdamW dan AdamW).

Untuk detail lebih lanjut mengenai algoritma, kami merujuk ke

langkah

< >

( closure = None )

Parameter

  • closure (callable, opsional) β€” Closure yang mengevaluasi ulang model dan mengembalikan loss.

Melakukan satu langkah optimasi.

kelas timm.optim.NvNovoGrad

< >

( paramslr = 0.001betas = (0.95, 0.98)eps = 1e-08weight_decay = 0grad_averaging = Falseamsgrad = Falsedecoupled_decay = Falsecorrected_weight_decay = False )

Parameter

  • params (iterable) β€” iterable dari parameter untuk dioptimalkan atau dicts yang mendefinisikan grup parameter
  • lr (float, opsional) β€” learning rate (default: 1e-3)
  • betas (Tuple[float, float], optional) β€” koefisien yang digunakan untuk menghitung rata-rata berjalan dari gradien dan kuadratnya (default: (0.95, 0.98))
  • eps (float, opsional) β€” istilah yang ditambahkan ke penyebut untuk meningkatkan stabilitas numerik (default: 1e-8)
  • weight_decay (float, opsional) β€” weight decay (penalti L2) (default: 0)
  • grad_averaging β€” rata-rata gradien
  • amsgrad (boolean, opsional) β€” apakah akan menggunakan varian AMSGrad dari algoritma ini dari makalah On the Convergence of Adam and Beyond_ (default: False)
  • decoupled_decay β€” terapkan weight decay langsung pada bobot (lr * weight_decay per langkah) alih-alih menambahkannya ke gradien yang dinormalisasi sebelum pembaruan momentum (sesuai dengan makalah)
  • corrected_weight_decay β€” terapkan koreksi weight decay (lr**2 / max_lr) ketika decoupled_decay bernilai True

Menerapkan algoritma Novograd.

langkah

< >

( closure = None )

Parameter

  • closure (callable, opsional) β€” Closure yang mengevaluasi ulang model
  • and mengembalikan loss. β€”

Melakukan satu langkah optimasi.

kelas timm.optim.RAdamLegacy

< >

( paramslr = 0.001betas = (0.9, 0.999)eps = 1e-08weight_decay = 0 )

Optimizer RAdam PyTorch

CATATAN: Implementasi ini telah ditinggalkan demi torch.optim.AdamW dan tetap ada sebagai referensi

kelas timm.optim.RMSpropTF

< >

( params: ParamsTlr: float = 0.01alpha: float = 0.9eps: float = 1e-10weight_decay: float = 0momentum: float = 0.0centered: bool = Falsedecoupled_decay: bool = Falsecorrected_weight_decay: bool = Falselr_in_momentum: bool = Truecaution: bool = Falseforeach: typing.Optional[bool] = None )

Parameter

  • params β€” iterable dari parameter untuk dioptimalkan atau dicts yang mendefinisikan grup parameter
  • lr β€” learning rate
  • momentum β€” faktor momentum
  • alpha β€” konstanta penghalusan (peluruhan)
  • eps β€” istilah yang ditambahkan ke penyebut untuk meningkatkan stabilitas numerik
  • centered β€” jika True, hitung RMSProp yang terpusat, gradiennya dinormalisasi oleh estimasi variansnya
  • weight_decay β€” weight decay (penalti L2) (default: 0)
  • decoupled_decay β€” peluruhan bobot yang dipisahkan sesuai https://arxiv.org/abs/1711.05101
  • corrected_weight_decay β€” terapkan koreksi weight decay (lr**2 / max_lr) ketika decoupled_decay bernilai True
  • lr_in_momentum β€” penskalaan learning rate disertakan dalam pembaruan buffer momentum sesuai dengan nilai default di Tensorflow
  • caution β€” berhati-hatilah
  • foreach β€” gunakan implementasi foreach (multi-tensor), secara default (None) digunakan kecuali tidak didukung (lihat rmsprop_tf())

Menerapkan algoritma RMSprop (epsilon gaya TensorFlow)

NOTE: Ini adalah salin-tempel langsung dari PyTorch RMSprop dengan eps diterapkan sebelum sqrt dan beberapa modifikasi lain untuk lebih mendekati Tensorflow agar cocok dengan hyper-params.

Perubahan yang patut diperhatikan meliputi:

  1. Epsilon diterapkan di dalam akar kuadrat
  2. square_avg diinisialisasi ke ones
  3. Skala LR dari pembaruan yang terakumulasi dalam buffer momentum

Diajukan oleh G. Hinton dalam kursusnya.

Versi terpusat pertama kali muncul di Menghasilkan Urutan Dengan Jaringan Saraf Berulang.

langkah

< >

( closure = None )

Parameter

  • closure (callable, opsional) β€” Closure yang mengevaluasi ulang model dan mengembalikan loss.

Melakukan satu langkah optimasi.

kelas timm.optim.SGDP

< >

( paramslr = torch.optim.optimizer.requiredmomentum = 0dampening = 0weight_decay = 0nesterov = Falseeps = 1e-08delta = 0.1wd_ratio = 0.1caution = False )

kelas timm.optim.SGDW

< >

( params: ParamsTlr: float = 0.001momentum: float = 0.0dampening: float = 0.0weight_decay: float = 0.0nesterov: bool = Falsecaution: bool = Falsecorrected_weight_decay: bool = Falsemaximize: bool = Falseforeach: typing.Optional[bool] = Nonedifferentiable: bool = False )

langkah

< >

( closure = None )

Parameter

  • closure (Callable, opsional) β€” Closure yang mengevaluasi ulang model dan mengembalikan loss.

Melakukan satu langkah optimasi.

Update on GitHub

←Fungsi Kehilangan Penjadwal Laju Pembelajaranβ†’