# التحسين

تحتوي هذه الصفحة على توثيق مرجع واجهة برمجة التطبيقات (API) للمحسّنات (optimizers) المضمنة في `timm`، بالإضافة إلى نظرة عامة على كيفية اختيارها وإعدادها من خلال مصنع المحسّنات (optimizer factory).

## الاستخدام

تُنشأ المُحسِّنات بالاسم باستخدام [`create_optimizer_v2`](#timm.optim.create_optimizer_v2). عند تقديم نموذج، يبني المصنع مجموعات المعاملات (استثناءات اضمحلال الوزن، والتخفيض الاختياري لمعدل التعلم على مستوى الطبقات) قبل إنشاء المُحسِّن. تمرّ الحجج الخاصة بكل مُحسِّن كحجج كلمات مفتاحية.

```python
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))
```

يُتيح سكربت التدريب (`train.py`) نفس الوظائف من خلال هذه الأعلام:

- يحدد **`--opt`** المُحسِّن.
- يحدد **`--lr`** معدل التعلم.
- يحدد **`--weight-decay`** قيمة تخفيف الوزن.
- **`--momentum`** يحدد الزخم.
- **`--opt-eps`** يحدد قيمة إبسيلون (`eps`).
- **`--opt-betas`** يحدد معاملات بيتا (`betas`).
- يحدد **`--layer-decay`** معدل التلاشي التدريجي لمعدل التعلم على مستوى الطبقات.
- **`--opt-kwargs key=value ...`** يمرر أي حُجج أخرى للمُحسِّن.

### اتفاقيات التسمية

تكون الأسماء المسجلة بحروف صغيرة، وهي اسم المُحسِّن الأساسي مع بعض التعديلات:

| تعديل | المعنى | أمثلة |
|---|---|---|
| بادئة `c` | النوع الحذر، حيث يتم إخفاء التحديث في المواضع التي يختلف فيها علامته عن علامة التدرج ([المحسّنات الحذرة](https://arxiv.org/abs/2411.16085)) | `cadamw`, `clion`, `cmars`, `cadopt` |
| لاحقة `w` | تخفيف الوزن المنفصل (بنمط AdamW)، للمحسّنات التي تعتمد افتراضيًا على تخفيف L2 المقترن | `sgdw`, `lambw`, `adoptw`, `novogradw`, `rmsproptfw` |
| لاحقة `c` | تصحيح للتلاشي الوزني، حيث يُقاس التلاشي بواسطة `lr² / max_lr` بدلاً من `lr` ([لماذا تتزايد التدرجات بسرعة قرب نهاية التدريب](https://arxiv.org/abs/2506.02285)) | `adamc`, `nadamc`, `sgdc`, `lionc`, `adoptc`, `kronc` |
| بادئة `n` | زخم نيستروف (عائلات SGD وLARS وMuon) | `nesterov`, `nlars`, `nmuon`, `nadamuon` |
| بادئة `lookahead_` | غلّف المُحسِّن في [`Lookahead`](#timm.optim.lookahead.Lookahead) | `lookahead_adamw` |
| بادئة `fused` | تنفيذ NVIDIA Apex المدمج (يتطلب `apex`) | `fusedadamw`, `fusedlamb` |
| بادئة `bnb` | تنفيذ bitsandbytes، لاحقة `8bit` لحالة 8-بت (يتطلب `bitsandbytes`) | `bnbadamw`, `bnbadamw8bit` |

تسبق بعض التسميات المعايير المتبعة: `lambc` و`larc` هما LAMB / LARS مع قص نسبة الثقة (النسخة المصححة من LAMB مع الاضمحلال هي `lambcd`)، و`momentum` هو SGD مع الزخم الكلاسيكي، و`sgd` هو SGD مع زخم Nesterov. تنتمي تطبيقات `legacy` الواردة في الجدول أدناه إلى ما سبق إدراجها في PyTorch.

### عائلات المُحسِّنات

| الأسماء | التنفيذ | ملاحظات |
|---|---|---|
| `adamw`, `adam`, `nadam`, `radam`, `radamw`, `adamax`, `adadelta`, `adagrad`, `rmsprop`, `sgd`, `momentum`, `nesterov` | `torch.optim` | |
| `adamwlegacy`, `adamc`, `cadamw`, `cadamc` | [`AdamWLegacy`](#timm.optim.adamw.AdamWLegacy) | AdamW مع الحذر، اضمحلال مُصحح، قصّ التحديث، `capturable` |
| `nadamw`, `nadamc`, `cnadamw`, `cnadamc` | [`NAdamW`](#timm.optim.nadamw.NAdamW) | AdamW مع زخم نيستروف (صيغة كفاءة الخوارزميات من MLCommons) |
| `adopt`, `adoptw`, `adoptc`, `cadopt`, `cadoptw`, `cadoptc` | [`Adopt`](#timm.optim.adopt.Adopt) | نموذج مشتق من Adam يتقارب لأي قيمة لـ β2 |
| `adan`, `adanw`, `cadan`, `cadanw` | [`Adan`](#timm.optim.adan.Adan) | زخم نيستروف التكيفي |
| `adabelief`, `radabelief` | [`AdaBelief`](#timm.optim.adabelief.AdaBelief) | `radabelief` يضيف تصحيحًا بنمط RAdam |
| `adafactor`, `cadafactor` | [`Adafactor`](#timm.optim.adafactor.Adafactor) | fairseq Adafactor، حجم الخطوة النسبي عندما يكون `lr=None` |
| `adafactorbv`, `adafactorbvc`, `cadafactorbv`, `cadafactorbvc` | [`AdafactorBigVision`](#timm.optim.adafactor_bv.AdafactorBigVision) | Big Vision Adafactor، زخم الدقائق الثانية المُجزّأة، زخم بدقة منخفضة، قصّ التحديث |
| `adamp`, `cadamp`, `sgdp`, `csgdp` | [`AdamP`](#timm.optim.adamp.AdamP), [`SGDP`](#timm.optim.sgdp.SGDP) | إسقاط التحديث للأوزان غير الحساسة للمقياس |
| `adahessian` | [`Adahessian`](#timm.optim.adahessian.Adahessian) | من الرتبة الثانية، ويتطلب دالة مغلقة (`is_second_order`) |
| `kron`, `kronw`, `kronc` | [`Kron`](#timm.optim.kron.Kron) | PSGD مع مُسبِّق مُعامَل مُقسَّم على شكل كرونكر |
| `lamb`, `lambc`, `lambw`, `lambcw`, `lambcd`, `clamb`, `clambw` | [`Lamb`](#timm.optim.lamb.Lamb) | زخم التكيف على مستوى الطبقات، متغيرات `trust_clip` (`lambc`، `lambcw`) |
| `laprop`, `lapropc`, `claprop` | [`LaProp`](#timm.optim.laprop.LaProp) | فصل الزخم والتكيف |
| `lars`, `larc`, `nlars`, `nlarc` | [`Lars`](#timm.optim.lars.Lars) | مقياس المعدل التكيفي على مستوى الطبقات، متغيرات `trust_clip` (`larc`، `nlarc`) |
| `lion`, `lionc`, `clion`, `clionc` | [`Lion`](#timm.optim.lion.Lion) | زخم الإشارة المتطور |
| `madgrad`, `madgradw` | [`MADGRAD`](#timm.optim.madgrad.MADGRAD) | المُتَوَسِّط المزدوج القائم على الزخم |
| `mars`, `cmars` | [`Mars`](#timm.optim.mars.Mars) | تقليل التباين، تحديث بأسلوب AdamW أو Lion |
| `muon`, `nmuon`, `adamuon`, `nadamuon` | [`Muon`](#timm.optim.muon.Muon) | زخم مُعامَد بطريقة نيوتن-شولتز للأوزان ذات البُعد 2+، مع اللجوء إلى AdamW / NAdamW للمعاملات ذات البُعد 1 |
| `novograd`, `novogradw`, `novogradc` | [`NvNovoGrad`](#timm.optim.nvnovograd.NvNovoGrad) | الزخمات المعيارية على مستوى الطبقات |
| `rmsproptf`, `rmsproptfw`, `rmsproptfc`, `crmsproptf` | [`RMSpropTF`](#timm.optim.rmsprop_tf.RMSpropTF) | ترتيب العمليات في TensorFlow ومعالجة eps، مع دمج lr في مخزن الزخم |
| `sgdw`, `nesterovw`, `sgdc`, `csgdw`, `csgdc` | [`SGDW`](#timm.optim.sgdw.SGDW) | SGD مع انحلال الوزن المنفصل |
| `nadamlegacy`, `radamlegacy` | [`NAdamLegacy`](#timm.optim.nadam.NAdamLegacy), [`RAdamLegacy`](#timm.optim.radam.RAdamLegacy) | تنفيذات مرجعية، تم استبدالها بواسطة `torch.optim` |
| `fused*`, `bnb*` | NVIDIA Apex، bitsandbytes | يُسجَّل عند تثبيت الحزمة |

### خيارات شائعة

تشارك معظم محسّنات `timm` مجموعة من الخيارات إلى جانب الخيارات المعتادة `lr` و`weight_decay` و`betas` و`eps`. يمكن التحقق من المحسّنات التي تقبل أيًا من هذه الخيارات من خلال التواقيع (signatures) الخاصة بالفئات أدناه، حيث يثير المصنع (factory) خطأً عند تمرير حِجج غير مدعومة.

- **`caution`** يطبّق قناع التحديث الحذر، وهو ما يعادل أسماء السجلّات التي تبدأ بالبادئة `c`.
- يُقيّم **`corrected_weight_decay`** التخميد المنفصل للوزن بمعامل `lr² / max_lr` بدلاً من `lr` (الأسماء التي تنتهي بلاحقة `c`)، بحيث يتبع التخميد الفعلي جدول معدل التعلم. يمثل `max_lr` معدل التعلم الذي بُني به المُحسِّن، لذا يجب بناؤه بمعدل التعلم الذروي للجدول (كما تفعل `train.py`). يُحفظ هذا القيمة في كل مجموعة من مجموعات المعلمات (`max_lr_snapshot`) ويُحفظ ويُستعاد مع حالة المُحسِّن.
- **`decoupled_decay`** (أو `decoupled`) يبدّل المُحسِّنات التي تعتمد افتراضيًا على توهين L2 مقترن إلى توهين بنمط AdamW (الأسماء المنتهية بـ `w`).
- يختار **`foreach`** التنفيذ متعدد الموترات. افتراضيًا (`None`)، يُستخدم على CUDA والأجهزة الأخرى التي تدعم نواة foreach، بما يتوافق مع `torch.optim`، ما لم يكن غير مدعوم من قبل الإعدادات (موتر `lr` بدون `capturable`، أو `caution` على إصدار PyTorch لا يحتوي على الحمولة الزائدة `_foreach_maximum_` المطلوبة). يُنفَّذ الخطوة متعددة الموترات في مجموعات من المعاملات بحجم يُبقي مجموعة العمل لكل مجموعة داخل ذاكرة L2 في وحدة المعالجة الرسومية، وهو أسرع من تمرير كل معامل عبر الذاكرة مرة واحدة لكل عملية في النماذج الكبيرة. يُشتق حجم المجموعة من حجم ذاكرة L2 في الجهاز (PyTorch >= 2.5) ويُتخطى التقسيم إلى مجموعات على الأجهزة التي يكون فيها حجم المجموعة الناتج أقل من 4 ملايين عنصر. يعيد `TIMM_FOREACH_CHUNK_SIZE=<elements>` تعيين حجم المجموعة، بينما يعطّل `0` التقسيم إلى مجموعات.
- يحافظ **`capturable`** (AdamWLegacy، NAdamW، Adopt، Muon) على عدد الخطوات على الجهاز حتى يمكن التقاط الخطوة في رسم CUDA. تقبل جميع المُحسِّنات `lr` المُعطاة كمُتجه بعدد أبعاد صفر، ويتم تحديثه في مكانه بواسطة جدول، للاستخدام مع `torch.compile` ورسميات CUDA.
- يقوم **`clipping_threshold`** (في AdamWLegacy وNAdamW وAdafactorBigVision) بقص التحديث بناءً على جذر متوسط مربعه (RMS)، وذلك عبر `update / max(1, rms / threshold)` حيث يمثل `rms` جذر متوسط مربع التدرج المُطبَّع بلحظة ثانية، لكل متجه ([StableAdamW](https://arxiv.org/abs/2304.13013)، Adafactor). القيمة الافتراضية هي `1.0` كما في الأوراق البحثية. وكما في Adafactor، لا يتم قص تضاؤل الوزن (المفصول)، لكن StableAdamW يقوم أيضاً بمقياس تضاؤل الوزن بمعدل التعلم المُقصّ.
- **`maximize`** تعظّم الدالة الهدف بدلاً من تقليلها.

تُدعم معاملات الدقة المنخفضة (`bfloat16`، `float16`) على نطاق واسع:

- **AdaBelief وRAdamLegacy وAdafactor** تحتفظ بحالتها في `float32` للمعاملات منخفضة الدقة.
- يحافظ **AdafactorBigVision** على زخمه بدقة مخفّضة (`momentum_dtype`).
- يتميز **Kron** بخيارات منفصلة هي `mu_dtype` / `precond_dtype`.

تُحافظ أنواع الحالة هذه على قيمها عند استخدام `load_state_dict` (فالمحمّل الافتراضي في PyTorch يُحوّل الحالة إلى نوع المعامل). وتتجنّب دوال الخطوة مزامنة المضيف (فروع بايثون المعتمدة على البيانات على متجهات الجهاز)، باستثناء فحص الإسقاط في AdamP / SGDP.

### مجموعات المعلمات

عند تقديم نموذج، تُجمّع `create_optimizer_v2` المعاملات باستخدام [`param_groups_weight_decay`](#timm.optim.param_groups_weight_decay) (بدون اضمحلال للمعاملات أحادية البعد ومجموعة `no_weight_decay()` الخاصة بالنموذج) أو، عند تعيين `layer_decay`، باستخدام [`param_groups_layer_decay`](#timm.optim.param_groups_layer_decay)، والذي يعيّن مقياس معدل تعلّم قدره `layer_decay ** (num_layers - layer_id)` لكل طبقة باستخدام `group_matcher()` الخاص بالنموذج. أما النماذج التي لا تحتوي على `group_matcher()` فتعود إلى [`auto_group_layers`](#timm.optim.auto_group_layers)، والذي يحتاج إلى `pretrained_cfg['classifier']` الخاص بالنموذج لفصل الرأس. بالنسبة لمُحسِّنات الهجين (Muon)، تُوجّه الحجة `fallback_list` و `fallback_no_weight_decay` المعاملات إلى مُحسِّن الاحتياط (AdamW).

## واجهة برمجة التطبيقات

### دوال المصنع[[timm.optim.create_optimizer_v2]]

#### timm.optim.create_optimizer_v2[[timm.optim.create_optimizer_v2]]

```python
timm.optim.create_optimizer_v2(model_or_params: typing.Union[torch.nn.Module, torch.optim.optimizer.ParamsT], opt: str = 'sgd', lr: typing.Optional[float] = None, weight_decay: float = 0.0, momentum: float = 0.9, foreach: typing.Optional[bool] = None, filter_bias_and_bn: bool = True, fallback_list: typing.Collection[str] = (), fallback_no_weight_decay: bool = False, layer_decay: typing.Optional[float] = None, layer_decay_min_scale: float = 0.0, layer_decay_no_opt_scale: typing.Optional[float] = None, param_group_fn: typing.Optional[typing.Callable[[torch.nn.Module], torch.optim.optimizer.ParamsT]] = None, **kwargs: typing.Any)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/_optim_factory.py#L1242)

**المعاملات:**

model_or_params : نموذج PyTorch أو قابل للتكرار من المعاملات/مجموعات المعاملات. إذا تم تقديم نموذج، فسيتم استخراج المعاملات وتجميعها تلقائيًا بناءً على الحُجج الأخرى.

opt : اسم المُحسِّن الذي سيتم إنشاؤه (مثلًا: 'adam', 'adamw', 'sgd'). استخدم list_optimizers() لعرض الخيارات المتاحة.

lr : معدل التعلم. إذا كان None، فسيتم استخدام القيمة الافتراضية للمُحسِّن.

weight_decay : معامل تخفيف الوزن. سيُستخدم لإنشاء مجموعات المعلمات إذا كان model_or_params نموذجًا.

momentum : معامل الزخم للمحسّنات التي تدعمه. يُستخدم فقط إذا كان المحسّن المختار يقبل معامل الزخم.

foreach : تفعيل/تعطيل تنفيذ foreach (متعدد المتجهات) إذا كان متاحًا. إذا كانت القيمة None، فسيتم استخدام الإعدادات الافتراضية الخاصة بالمحسّن.

filter_bias_and_bn : إذا كانت القيمة True، فلن يُطبَّق تخفيف الوزن على معاملات طبقات الانحياز والتطبيع (جميع المعاملات أحادية البعد). يُستخدم هذا الخيار فقط عندما يكون model_or_params نموذجًا وكانت قيمة weight_decay > 0.

fallback_list : مجموعة من أنماط أسماء المعلمات لاستخدام مُحسِّن احتياطي للمُحسِّنات الهجينة (مثل AdamW لـ Muon). يدعم المطابقة باستخدام الرموز البرجية.

fallback_no_weight_decay : إذا كانت القيمة True، فستستخدم المعاملات الموجودة في قائمة no_weight_decay() الخاصة بالنموذج مُحسِّن الاحتياط للمُحسِّنات الهجينة (مثل AdamW لـ Muon).

layer_decay : معامل اختفاء معدل التعلم على مستوى الطبقات (اختياري). إذا تم تقديمه، سيتم قياس معدلات التعلم بواسطة layer_decay^(max_depth - layer_depth). يُستخدم فقط عندما يكون model_or_params نموذجًا.

param_group_fn : دالة اختيارية لإنشاء مجموعات معلمات مخصصة. إذا تم توفيرها، سيتم تجاهل خيارات تجميع المعلمات الأخرى.

- ****kwargs**** : حُجج إضافية خاصة بالمُحسِّن (مثل betas في Adam).

**يعيد:**

مثال المُحسِّن المُهيّأ.

أنشئ مثبّتًا (optimizer) عبر سجل timm.

ينشئ مُحسِّناً (optimizer) ويضبطه مع مجموعات معاملات وإعدادات مناسبة. يدعم إنشاء مجموعات معاملات تلقائياً لتلاشي الأوزان ومعدلات التعلم على مستوى الطبقات، بالإضافة إلى تجميع مخصص للمعاملات.

أمثلة:

عند استخدام AdamW من نموذج، تُنشأ مجموعات المعاملات تلقائيًا:

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

SGD مع الزخم وتلاشي الأوزان:

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

أدام مع انخفاض معدل التعلم على مستوى الطبقات:

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

مجموعات المعلمات المخصصة:

```python
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)
```

ملاحظة: أولوية معالجة مجموعات المعلمات:
1. إذا تم توفير param_group_fn، فسيتم استخدامه حصريًا
2. إذا تم توفير layer_decay، فسيتم إنشاء مجموعات على مستوى الطبقات
3. إذا كان weight_decay > 0 وكان filter_bias_and_bn True، فسيتم إنشاء مجموعات تخفيف الوزن
4. وإلا، فستكون جميع المعاملات في مجموعة واحدة

#### timm.optim.list_optimizers[[timm.optim.list_optimizers]]

```python
timm.optim.list_optimizers(filter: typing.Union[str, typing.List[str]] = '', exclude_filters: typing.Optional[typing.List[str]] = None, with_description: bool = False)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/_optim_factory.py#L1137)

**المعاملات:**

filter : سلسلة نصية أو قائمة بسلاسل نصية بنمط النجمة (e.g., 'adam*' for all Adam variants, or ['adam*', '*8bit'] for Adam variants and 8-bit optimizers). السلسلة الفارغة تعني عدم وجود تصفية.

exclude_filters : قائمة اختيارية لأنماط كروية (wildcard) للاستبعاد. على سبيل المثال، ['*8bit', 'fused*'] يستبعد التنفيذات الثمانية البتات (8-bit) والمدمجة (fused).

with_description : إذا كانت القيمة True، تُرجع tuples من (name, description) بدلاً من الأسماء فقط. توفر الأوصاف شرحًا موجزًا لخصائص المُحسِّن (optimizer).

**يعيد:** `If with_description is False`

قائمة بأسماء المُحسِّنات كنصوص (مثل ['adam', 'adamw', ...]) إذا كان with_description هو True: قائمة من السلاسل (توبلز) من (name, description) (مثل [('adam', 'Adaptive Moment...'), ...])

قائمة أسماء المُحسِّنات المتاحة، مع إمكانية التصفية اختيارياً.

اعرض جميع المُحسِّنات المسجَّلة، مع إمكانية التصفية الاختيارية باستخدام أنماط النجمة. يمكن تصفية المُحسِّنات باستخدام أنماط الإدراج والاستبعاد، ويمكن اختيارياً إرجاع الأوصاف مع اسم كل مُحسِّن.

أمثلة:

```python
>>> 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[[timm.optim.get_optimizer_class]]

```python
timm.optim.get_optimizer_class(name: str, bind_defaults: bool = True)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/_optim_factory.py#L1200)

**المعاملات:**

name : اسم المُحسِّن المطلوب استرجاعه (مثلًا، 'adam'، 'sgd')

bind_defaults : إذا كانت القيمة True، تُرجع دالة جزئية مع حُجج افتراضية مرتبطة من OptimInfo. إذا كانت False، تُرجع فئة المُحسِّن الخام.

**يعيد:** `If bind_defaults is False`

فئة المُحسِّن (مثل torch.optim.Adam) إذا كان bind_defaults هو True: دالة جزئية مع ربط الحُجج الافتراضية

**يرفع:** ``ValueError``

- ``ValueError`` -- إذا لم يتم العثور على اسم المُحسِّن في السجل

احصل على فئة المُحسِّن (optimizer) بالاسم مع خيار ربط الحُجج الافتراضية.

يسترجع فئة المُحسِّن أو دالة جزئية مع ربط الحُجج الافتراضية. وهذا يتيح إنشاء المُحسِّنات مباشرةً بإعداداتها الافتراضية دون المرور عبر المصنع الكامل.

أمثلة:

مع ربط الإعدادات الافتراضية للسجل، تم تفعيل زخم نيستروف في `sgd`:

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

فئة المُحسِّن الخام:

```python
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[[timm.optim.get_optimizer_info]]

```python
timm.optim.get_optimizer_info(name: str)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/_optim_factory.py#L1185)

**المعاملات:**

name : اسم المُحسِّن

**يعيد:**

إعدادات OptimInfo

**يرفع:** ``ValueError``

- ``ValueError`` -- إذا لم يتم العثور على المُحسِّن

احصل على OptimInfo لمُحسِّن (optimizer).

### دوال مجموعات المعلمات[[timm.optim.param_groups_weight_decay]]

#### timm.optim.param_groups_weight_decay[[timm.optim.param_groups_weight_decay]]

```python
timm.optim.param_groups_weight_decay(model: Module, weight_decay: typing.Optional[float] = 1e-05, weight_decay_exclude_1d: bool = True, no_weight_decay_list: typing.Collection[str] = (), fallback_list: typing.Collection[str] = (), fallback_no_weight_decay: bool = False)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/_param_groups.py#L19)

#### timm.optim.param_groups_layer_decay[[timm.optim.param_groups_layer_decay]]

```python
timm.optim.param_groups_layer_decay(model: Module, weight_decay: float = 0.05, no_weight_decay_list: typing.Collection[str] = (), fallback_list: typing.Collection[str] = (), fallback_no_weight_decay: bool = False, weight_decay_exclude_1d: bool = True, layer_decay: float = 0.75, min_scale: float = 0.0, no_opt_scale: typing.Optional[float] = None, verbose: bool = False)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/_param_groups.py#L113)

مجموعات المعاملات لتخفيف معدل التعلم على مستوى الطبقات & تخفيف الوزن استنادًا إلى BEiT: https://github.com/microsoft/unilm/blob/master/beit/optim_factory.py#L58

#### timm.optim.auto_group_layers[[timm.optim.auto_group_layers]]

```python
timm.optim.auto_group_layers(model, layers_per_group = 12, num_groups = None)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/_param_groups.py#L84)

### فئات المُحسِّن[[timm.optim.AdaBelief]]

#### timm.optim.AdaBelief[[timm.optim.AdaBelief]]

```python
timm.optim.AdaBelief(params, lr = 0.001, betas = (0.9, 0.999), eps = 1e-16, weight_decay = 0, amsgrad = False, decoupled_decay = True, fixed_decay = False, rectify = True, degenerated_to_sgd = True, foreach: typing.Optional[bool] = None)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adabelief.py#L13)

**المعاملات:**

params (iterable) : iterable من المعاملات المراد تحسينها أو قواميس تعرّف مجموعات المعاملات

lr (float, اختياري) : معدل التعلم (الافتراضي: 1e-3)

betas (Tuple[float, float]، اختياري) : المعاملات المستخدمة لحساب المتوسطات المتحركة للتدرج ومربعه (الافتراضي: (0.9, 0.999))

eps (float, اختياري) : حد يُضاف إلى المقام لتحسين الاستقرار العددي (الافتراضي: 1e-16)

weight_decay (float, اختياري) : تراجع الوزن (عقوبة L2) (الافتراضي: 0)

amsgrad (منطقية، اختيارية) : ما إذا كان سيتم استخدام متغير AMSGrad لهذا الخوارزمية من الورقة `On the Convergence of Adam and Beyond`_ (الافتراضي: False)

decoupled_decay (boolean, اختياري) : (الافتراضي: True) إذا تم ضبطه على True، فإن المُحسِّن يستخدم تخفيف الوزن المنفصل كما في AdamW

fixed_decay (boolean, optional) : (الافتراضي: False) يُستخدم هذا عندما يُضبط weight_decouple على True. عندما يكون fixed_decay == True، يتم تنفيذ تضاؤل الأوزان وفق المعادلة $W_{new} = W_{old} - W_{old} \times decay$. وعندما يكون fixed_decay == False، يتم تنفيذ تضاؤل الأوزان وفق المعادلة $W_{new} = W_{old} - W_{old} \times decay \times lr$. لاحظ أنه في هذه الحالة، ينخفض معدل تضاؤل الأوزان مع معدل التعلم (lr).

rectify (boolean, اختياري) : (الافتراضي: True) إذا تم ضبطه على True، يتم تنفيذ التحديث المُصحَّح المشابه لـ RAdam

degenerated_to_sgd (منطقي، اختياري) (الافتراضي --True) إذا تم ضبطه على True، يتم تنفيذ تحديث SGD عندما تكون تباين التدرج مرتفع

foreach (boolean, optional) : استخدام تنفيذ foreach (متعدد المتجهات)، يُستخدم افتراضيًا (None) ما لم يكن غير مدعوم

يُنفّذ خوارزمية AdaBelief. تم تعديله من Adam في PyTorch

مرجع: مُحسِّن AdaBelief، يُكيّف أحجام الخطوات بناءً على الثقة في التدرجات المرصودة، NeurIPS 2020

لجدول كامل بالمعاملات الفائقة الموصى بها، راجع https://github.com/juntang-zhuang/Adabelief-Optimizer. على سبيل المثال، لمعايير التدريب train/args الخاصة بـ EfficientNet، راجع هذه المقتطفات gists
- رابط إلى train_script: https://gist.github.com/juntang-zhuang/0a501dd51c02278d952cf159bc233037
- رابط إلى args.yaml: https://gist.github.com/juntang-zhuang/517ce3c27022b908bb93f78e4f786dc3

#### خطوة[[timm.optim.AdaBelief.step]]

```python
step(closure = None)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adabelief.py#L121)

**المعاملات:**

closure (callable, اختياري) : دالة مغلقة تعيد تقييم النموذج وتعيد الخسارة.

يُنفّذ خطوة تحسين واحدة.

#### timm.optim.Adafactor[[timm.optim.Adafactor]]

```python
timm.optim.Adafactor(params: ParamsT, lr: typing.Optional[float] = None, eps: float = 1e-30, eps_scale: float = 0.001, clip_threshold: float = 1.0, decay_rate: float = -0.8, betas: typing.Optional[typing.Tuple[float, float]] = None, weight_decay: float = 0.0, scale_parameter: bool = True, warmup_init: bool = False, min_dim_size_to_factor: int = 16, caution: bool = False)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adafactor.py#L22)

يُنفّذ خوارزمية Adafactor.

تستند هذه النسخة إلى: `Adafactor: Adaptive Learning Rates with Sublinear Memory Cost` (انظر https://arxiv.org/abs/1804.04235)

لاحظ أن هذا المُحسِّن يعدّل معدل التعلم داخلياً بناءً على خيارات *scale_parameter* و*relative_step* و*warmup_init*.

يُستخدم جدول معدل تعلّم يدوي (خارجي) عند ضبط `lr` (حيث يصبح `relative_step` كاذبًا في هذه الحالة). لاحظ أنه في هذا التنفيذ، لا تنطبق `scale_parameter` و`warmup_init` إلا على معدل تعلّم الخطوة النسبية (`lr=None`)، على عكس fairseq / HF Transformers، حيث لا يُطبَّق تحجيم RMS للمعامل على معدل التعلّم الخارجي.

Ags: params: iterable of parameters to optimize or dicts defining parameter groups lr: external learning rate eps: regularization constants for square gradient and parameter scale respectively eps_scale: regularization constants for parameter scale respectively clip_threshold: threshold of root-mean-square of final gradient update decay_rate: coefficient used to compute running averages of square gradient beta1: coefficient used for computing running averages of gradient weight_decay: weight decay scale_parameter: if True, relative step learning rate is scaled by root-mean-square of parameter warmup_init: time-dependent learning rate computation depends on whether warm-up initialization is being used

#### خطوة[[timm.optim.Adafactor.step]]

```python
step(closure = None)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adafactor.py#L140)

**المعاملات:**

closure (callable, اختياري) : دالة مغلقة تعيد تقييم النموذج وتعيد الخسارة.

يُنفّذ خطوة تحسين واحدة.

#### timm.optim.AdafactorBigVision[[timm.optim.AdafactorBigVision]]

```python
timm.optim.AdafactorBigVision(params: ParamsT, lr: float = 1.0, min_dim_size_to_factor: int = 16, decay_rate: float = 0.8, decay_offset: int = 0, beta2_cap: float = 0.999, momentum: typing.Optional[float] = 0.9, momentum_dtype: typing.Union[str, torch.dtype] = torch.bfloat16, eps: typing.Optional[float] = None, weight_decay: float = 0.0, clipping_threshold: typing.Optional[float] = None, unscaled_wd: bool = False, caution: bool = False, corrected_weight_decay: bool = False)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adafactor_bv.py#L49)

تنفيذ PyTorch لمتغير Adafactor الخاص بـ BigVision مع كلا التنفيذين أحادي المتجه ومتعدد المتجهات.

مُعدَّل من https://github.com/google-research/big_vision بواسطة Ross Wightman

#### timm.optim.Adahessian[[timm.optim.Adahessian]]

```python
timm.optim.Adahessian(params, lr = 0.1, betas = (0.9, 0.999), eps = 1e-08, weight_decay = 0.0, hessian_power = 1.0, update_each = 1, n_samples = 1, avg_conv_kernel = False)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adahessian.py#L9)

**المعاملات:**

params (iterable) : iterable من المعاملات المراد تحسينها أو قواميس تعرّف مجموعات المعاملات

lr (float، اختياري) : معدل التعلم (الافتراضي: 0.1)

betas ((float, float), اختياري) : المعاملات المستخدمة لحساب المتوسطات المتحركة للتدرج وأثر الهيسين المربع (الافتراضي: (0.9, 0.999))

eps (float, اختياري) : حد يُضاف إلى المقام لتحسين الاستقرار العددي (الافتراضي: 1e-8)

weight_decay (float, اختياري) : تراجع الوزن (عقوبة L2) (الافتراضي: 0.0)

hessian_power (float, اختياري) : أُسّ أثر الهيسيان (الافتراضي: 1.0)

update_each (int, اختياري) : حساب تقريب أثر الهيسيان فقط بعد *هذا* العدد من الخطوات (لتوفير الوقت) (الافتراضي: 1)

n_samples (int, اختياري) : عدد مرات أخذ عينات من `z` لتقريب أثر الهيسيان (الافتراضي: 1)

يُنفّذ خوارزمية AdaHessian من «ADAHESSIAN: محسّن من الدرجة الثانية متكيف لتعلم الآلة»

#### get_params[[timm.optim.Adahessian.get_params]]

```python
get_params()
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adahessian.py#L74)

يحصل على جميع المعاملات في جميع مجموعات المعاملات التي تحتوي على تدرجات

#### set_hessian[[timm.optim.Adahessian.set_hessian]]

```python
set_hessian()
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adahessian.py#L90)

يُحسب تقريب هاتشيسون لمتتبع الهيسين ويجمعه لكل معامل قابل للتدريب.

#### خطوة[[timm.optim.Adahessian.step]]

```python
step(closure = None)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adahessian.py#L119)

**المعاملات:**

closure (callable, اختياري) : دالة مغلقة تعيد تقييم النموذج وتعيد الخسارة (الافتراضي -- None)

يُنفّذ خطوة تحسين واحدة.

#### zero_hessian[[timm.optim.Adahessian.zero_hessian]]

```python
zero_hessian()
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adahessian.py#L81)

يصفّر آثار هيسيان المتراكمة.

#### timm.optim.AdamP[[timm.optim.AdamP]]

```python
timm.optim.AdamP(params, lr = 0.001, betas = (0.9, 0.999), eps = 1e-08, weight_decay = 0, delta = 0.1, wd_ratio = 0.1, nesterov = False, caution = False)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adamp.py#L64)

#### timm.optim.AdamWLegacy[[timm.optim.AdamWLegacy]]

```python
timm.optim.AdamWLegacy(params: ParamsT, lr: float = 0.001, betas: typing.Tuple[float, float] = (0.9, 0.999), eps: float = 1e-08, weight_decay: float = 0.01, amsgrad: bool = False, caution: bool = False, corrected_weight_decay: bool = False, maximize: bool = False, foreach: typing.Optional[bool] = None, capturable: bool = False, clipping_threshold: typing.Optional[float] = None)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adamw.py#L23)

**المعاملات:**

params : قابل للتكرار من المعلمات المراد تحسينها أو قواميس تعرّف مجموعات المعلمات

lr : معدل التعلم

betas : المعاملات المستخدمة لحساب المتوسطات المتحركة للتدرج ومربعه

eps : الحد المضاف إلى المقام لتحسين الاستقرار العددي

weight_decay : معامل تخفيف الوزن

amsgrad : ما إذا كان سيتم استخدام متغير AMSGrad لهذا الخوارزمية من الورقة `On the Convergence of Adam and Beyond`

caution : استخدم الحذر عند استخدام AdamW

corrected_weight_decay : تطبيق تضاؤل الوزن المُصحَّح (lr**2 / max_lr)

maximize : تعظيم المعلمات بناءً على الدالة الهدف، بدلاً من تقليلها

foreach : whether foreach implementation of optimizer is used. If unspecified by the user (so foreach is None), we will try to use foreach over for-loop implementation on CUDA, since it is faster in general.

capturable : ما إذا كان هذا المثال آمنًا للالتقاط في رسم CUDA. قد يؤدي تمرير True إلى تدهور الأداء غير المرتبط بالرسم، لذا إذا لم تكن تنوي التقاط هذا المثال في رسم، اتركه False

clipping_threshold : عتبة قصّ تحديث RMS (StableAdamW, https://arxiv.org/abs/2304.13013)، حيث يُقاس التحديث بمعامل 1 / max(1, rms / clipping_threshold) حيث rms هو RMS للتدرج / (sqrt(v_hat) + eps). يُخمد هذا التحديث المعاملات التي تشهد زيادة مفاجئة في التدرج مقارنةً بتقدير لحظتها الثانية. القيمة الافتراضية هي 1.0 وفقاً للورقة البحثية، بينما تعطيلها يتم بتعيين None (الافتراضي). كما في Adafactor، لا يُقصّ اضمحلال الوزن المنفصل (كما أن StableAdamW يقاس اضمحلال الوزن أيضاً بالتعلم المعدّل بعد القص).

يُنفّذ خوارزمية AdamW.

ملاحظة: تم إيقاف استخدام هذا التنفيذ لصالح torch.optim.AdamW ويبقى كمرجع

المراجع:
- Adam: A Method for Stochastic Optimization: https://arxiv.org/abs/1412.6980
- تنظيم تخفيف الوزن المنفصل: https://arxiv.org/abs/1711.05101
- حول تقارب آدم وما بعده: https://openreview.net/forum?id=ryQu7f-RZ

#### خطوة[[timm.optim.AdamWLegacy.step]]

```python
step(closure = None)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adamw.py#L116)

**المعاملات:**

closure (callable, اختياري) : دالة مغلقة تعيد تقييم النموذج وتعيد الخسارة.

يُنفّذ خطوة تحسين واحدة.

#### timm.optim.Adan[[timm.optim.Adan]]

```python
timm.optim.Adan(params, lr: float = 0.001, betas: typing.Tuple[float, float, float] = (0.98, 0.92, 0.99), eps: float = 1e-08, weight_decay: float = 0.0, no_prox: bool = False, caution: bool = False, foreach: typing.Optional[bool] = None)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adan.py#L48)

**المعاملات:**

params : قابل للتكرار من المعاملات المراد تحسينها أو قواميس تعرّف مجموعات المعاملات.

lr : معدل التعلم.

betas : المعاملات المستخدمة لحساب العزوم من الرتبة الأولى والثانية.

eps : مصطلح يُضاف إلى المقام لتحسين الاستقرار العددي.

weight_decay : فصل تخفيف الأوزان (عقوبة L2)

no_prox : كيفية تنفيذ تضاؤل الأوزان

caution : تفعيل الحذر من المحسّنات الحذرة

foreach : إذا كانت القيمة True، فسيتم استخدام تنفيذ torch._foreach. أسرع لكنه يستخدم ذاكرة أكثر قليلاً.

يُنفّذ نسخة من Adan مبنية على PyTorch.

قُدم خوارزمية Adan في ورقة Adan: Adaptive Nesterov Momentum Algorithm for Faster Optimizing Deep Models https://arxiv.org/abs/2208.06677

#### خطوة[[timm.optim.Adan.step]]

```python
step(closure = None)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adan.py#L119)

يُنفّذ خطوة تحسين واحدة.

#### timm.optim.Adopt[[timm.optim.Adopt]]

```python
timm.optim.Adopt(params: ParamsT, lr: typing.Union[float, torch.Tensor] = 0.001, betas: typing.Tuple[float, float] = (0.9, 0.9999), eps: float = 1e-06, clip_exp: typing.Optional[float] = 0.333, weight_decay: float = 0.0, decoupled: bool = False, corrected_weight_decay: bool = False, caution: bool = False, foreach: typing.Optional[bool] = None, maximize: bool = False, capturable: bool = False, differentiable: bool = False)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adopt.py#L60)

ADOPT: Adam المُعدَّل يمكن أن يتقارب مع أي β2 بمعدل مثالي: https://arxiv.org/abs/2411.02853

#### خطوة[[timm.optim.Adopt.step]]

```python
step(closure = None)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adopt.py#L197)

**المعاملات:**

closure (Callable, اختياري) : دالة مغلقة تعيد تقييم النموذج وتعيد الخسارة.

أداء خطوة تحسين واحدة.

#### timm.optim.kron.Kron[[timm.optim.kron.Kron]]

```python
timm.optim.kron.Kron(params: ParamsT, lr: float = 0.001, momentum: float = 0.9, weight_decay: float = 0.0, preconditioner_update_probability: typing.Union[typing.Callable, float, NoneType] = None, max_size_triangular: int = 2048, min_ndim_triangular: int = 2, memory_save_mode: typing.Optional[str] = None, momentum_into_precond_update: bool = True, precond_lr: float = 0.1, precond_init_scale: float = 1.0, mu_dtype: typing.Optional[torch.dtype] = None, precond_dtype: typing.Optional[torch.dtype] = None, decoupled_decay: bool = False, corrected_weight_decay: bool = False, flatten: bool = False, flatten_start_dim: int = 2, flatten_end_dim: int = -1, stochastic_weight_decay: bool = False, deterministic: bool = False)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/kron.py#L82)

**المعاملات:**

params : قابل للتكرار من المعاملات المراد تحسينها أو قواميس تعرّف مجموعات المعاملات.

lr : معدل التعلم.

momentum : معامل الزخم.

weight_decay : اضمحلال الأوزان.

preconditioner_update_probability : احتمال تحديث المُعدِّم المسبق. إذا كانت القيمة None، فإن القيمة الافتراضية هي جدول يُخفِّض الاحتمال تدريجياً من 1.0 إلى 0.03 خلال 4000 خطوة.

max_size_triangular : الحد الأقصى لحجم مُعدِّم الأبعاد ليكون مثلثيًا.

min_ndim_triangular : الحد الأدنى لعدد الأبعاد التي يجب أن تمتلكها طبقة ما حتى تستخدم المُسبِّقات (preconditioners) المثلثية.

memory_save_mode : 'one_diag' أو 'smart_one_diag' أو 'all_diag'، القيمة الافتراضية هي None لضبط جميع المُسَبِّقات (preconditioners) لتكون مثلثية، و'one_diag' يضبط أكبر بُعد أو البُعد الأخير ليكون قطريًا في كل طبقة، و'all_diag' يضبط جميع المُسَبِّقات لتكون قطرية.

momentum_into_precond_update : ما إذا كان يجب إرسال العزم إلى تحديث المُعدِّم المسبق بدلاً من التدرجات الخام.

mu_dtype : نوع البيانات لمجمّع الزخم.

precond_dtype : نوع البيانات (Dtype) للمُعدِّم المسبق (preconditioner).

decoupled_decay : انحطاط وزن منفصل بنمط AdamW

corrected_weight_decay : تطبيق تخفيف الوزن المُصحَّح عند استخدام decoupled_decay (lr**2 / max_lr)

flatten : تسطيح الأبعاد بدلاً من الاعتماد الكامل على التعبيرات للمعاملات ذات الرتبة الأعلى

flatten_start_dim : بداية نطاق التسطيح، القيمة الافتراضية هي 2. يبدو أنه توازن جيد لشبكات الالتفاف (ConvNets).

flatten_end_dim : نهاية نطاق التسطيح، القيمة الافتراضية هي -1.

stochastic_weight_decay : تفعيل تعديل عشوائي لتلاشي الأوزان

deterministic : سلوك حتمي عبر الحفظ / التحميل (الاستئناف). FIXME بطيء، يحتاج إلى عمل

يُنفّذ PSGD Kron من https://github.com/lixilinx/psgd_torch.

#### timm.optim.Lamb[[timm.optim.Lamb]]

```python
timm.optim.Lamb(params: ParamsT, lr: float = 0.001, bias_correction: bool = True, betas: typing.Tuple[float, float] = (0.9, 0.999), eps: float = 1e-06, weight_decay: float = 0.01, grad_averaging: bool = True, max_grad_norm: typing.Optional[float] = 1.0, trust_clip: bool = False, always_adapt: bool = False, caution: bool = False, decoupled_decay: bool = False, corrected_weight_decay: bool = False, foreach: typing.Optional[bool] = None)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/lamb.py#L71)

**المعاملات:**

params : قابل للتكرار من المعاملات المراد تحسينها أو قواميس تعرّف مجموعات المعاملات.

lr : معدل التعلم

betas : المعاملات المستخدمة لحساب المتوسطات المتحركة للتدرج ومعايره.

eps : مصطلح يُضاف إلى المقام لتحسين الاستقرار العددي.

weight_decay : اضمحلال الأوزان

grad_averaging : ما إذا كان سيتم تطبيق (1-beta2) على التدرّج عند حساب المتوسطات المتحركة للتدرّج.

max_grad_norm : القيمة المستخدمة لقص معيار التدرّج العالمي.

trust_clip : تفعيل قصّ نسبة الثقة في LAMBC.

always_adapt : تطبيق معدل تعلم تكيفي على معامل تخفيف الوزن 0.0.

caution : توخَّ الحذر.

decoupled : تطبيق تخفيف الوزن المنفصل

corrected_weight_decay : تطبيق تخفيف الوزن المُصحَّح (lr**2 / max_lr) عند استخدام decoupled_decay

foreach : استخدم تنفيذ foreach (متعدد المتجهات) افتراضيًا (None) ما لم يكن غير مدعوم

يُنفّذ نسخةً خالصةً من PyTorch لمُحسّن FuseLAMB (نسخة NvLamb) من apex.optimizers.FusedLAMB، المرجع: https://github.com/NVIDIA/DeepLearningExamples/blob/master/PyTorch/LanguageModeling/Transformer-XL/pytorch/lamb.py

قُدم خوارزمية LAMB في:
- التحسين بدفعات كبيرة للتعلم العميق - تدريب BERT في 76 دقيقة: https://arxiv.org/abs/1904.00962
- حول تقارب آدم وما بعده: https://openreview.net/forum?id=ryQu7f-RZ

#### خطوة[[timm.optim.Lamb.step]]

```python
step(closure = None)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/lamb.py#L169)

**المعاملات:**

closure (callable, اختياري) : دالة مغلقة تعيد تقييم النموذج وتعيد الخسارة.

يُنفّذ خطوة تحسين واحدة.

#### timm.optim.LaProp[[timm.optim.LaProp]]

```python
timm.optim.LaProp(params: ParamsT, lr: float = 0.0004, betas: typing.Tuple[float, float] = (0.9, 0.999), eps: float = 1e-15, weight_decay: float = 0.0, caution: bool = False, corrected_weight_decay: bool = False, foreach: typing.Optional[bool] = None)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/laprop.py#L32)

**المعاملات:**

foreach : استخدم تنفيذ foreach (متعدد المتجهات) افتراضيًا (None) ما لم يكون غير مدعوم (انظر laprop())

مُحسِّن LaProp

الورقة البحثية: LaProp: فصل الزخم عن الملاءمة في Adam، https://arxiv.org/abs/2002.04839

#### خطوة[[timm.optim.LaProp.step]]

```python
step(closure = None)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/laprop.py#L106)

**المعاملات:**

closure (callable, اختياري) : دالة مغلقة تعيد تقييم النموذج وتعيد الخسارة.

يُنفّذ خطوة تحسين واحدة.

#### timm.optim.Lars[[timm.optim.Lars]]

```python
timm.optim.Lars(params, lr = 1.0, momentum = 0, dampening = 0, weight_decay = 0, nesterov = False, trust_coeff = 0.001, eps = 1e-08, trust_clip = False, always_adapt = False, foreach: typing.Optional[bool] = None)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/lars.py#L22)

**المعاملات:**

params (iterable) : iterable من المعاملات المراد تحسينها أو قواميس تعرّف مجموعات المعاملات.

lr (float, اختياري) : معدل التعلم (الافتراضي: 1.0).

momentum (float, اختياري) : عامل الزخم (الافتراضي: 0)

weight_decay (float, اختياري) : تراجع الوزن (عقوبة L2) (الافتراضي: 0)

dampening (float, اختياري) : تخميد للعزم (الافتراضي: 0)

nesterov (bool, اختياري) : يُفعّل زخم نيستروف (الافتراضي: False)

trust_coeff (float) : معامل الثقة لحساب معدل التعلم التكيفي / trust_ratio (الافتراضي: 0.001)

eps (float) : eps لمقام القسمة (الافتراضي: 1e-8)

trust_clip (bool) : تفعيل قصّ نسبة الثقة في LARC (الافتراضي: False)

always_adapt (bool) : تطبيق تكيّف معدل التعلم LARS دائمًا، وإلا فقط عندما يكون group weight_decay != 0 (الافتراضي: False)

foreach (bool, optional) : استخدام تنفيذ foreach (متعدد المتجهات)، يُستخدم افتراضيًا (None) ما لم يكن غير مدعوم

LARS لـ PyTorch

الورقة: `Large batch training of Convolutional Networks` - https://arxiv.org/pdf/1708.03888.pdf

#### خطوة[[timm.optim.Lars.step]]

```python
step(closure = None)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/lars.py#L84)

**المعاملات:**

closure (callable, اختياري) : دالة مغلقة تعيد تقييم النموذج وتعيد الخسارة.

يُنفّذ خطوة تحسين واحدة.

#### timm.optim.Lion[[timm.optim.Lion]]

```python
timm.optim.Lion(params: ParamsT, lr: float = 0.0001, betas: typing.Tuple[float, float] = (0.9, 0.99), weight_decay: float = 0.0, caution: bool = False, corrected_weight_decay: bool = False, maximize: bool = False, foreach: typing.Optional[bool] = None)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/lion.py#L34)

يُنفّذ خوارزمية Lion.

#### خطوة[[timm.optim.Lion.step]]

```python
step(closure = None)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/lion.py#L86)

**المعاملات:**

closure : دالة إغلاق تعيد تقييم النموذج وتعيد الخسارة.

**يعيد:**

القيمة المفقودة.

يُنفّذ خطوة تحسين واحدة.

#### timm.optim.Lookahead[[timm.optim.Lookahead]]

```python
timm.optim.Lookahead(base_optimizer, alpha = 0.5, k = 6)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/lookahead.py#L15)

#### timm.optim.MADGRAD[[timm.optim.MADGRAD]]

```python
timm.optim.MADGRAD(params: typing.Any, lr: float = 0.01, momentum: float = 0.9, weight_decay: float = 0, eps: float = 1e-06, decoupled_decay: bool = False)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/madgrad.py#L24)

**المعاملات:**

params (iterable) : Iterable من المعاملات المراد تحسينها أو قواميس تعرّف مجموعات المعاملات.

lr (float) : معدل التعلم (الافتراضي: 1e-2).

momentum (float) : قيمة العزم في المدى [0,1) (الافتراضي: 0.9).

weight_decay (float) : اضمحلال الأوزان، أي عقوبة من الدرجة الثانية (الافتراضي: 0).

eps (float) : حد يُضاف إلى المقام خارج عملية الجذر لتحسين الاستقرار العددي. (الافتراضي: 1e-6).

MADGRAD_: طريقة تدرّج مُزَمنة ومُكيّفة ومتوسط ثنائي للتُحسين العشوائي.

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

MADGRAD هو مُحسِّن عام يمكن استخدامه بدلاً من SGD أو Adam، وقد يتقارب بشكل أسرع ويعمم بشكل أفضل. حاليًا، يعمل على وحدات معالجة الرسوميات (GPU) فقط. عادةً، يمكن استخدام جدول معدل التعلم نفسه المستخدم لـ SGD أو Adam. معدل التعلم الكلي غير قابل للمقارنة مع أيٍّ من الطريقتين، ويجب تحديده من خلال مسح المعلمات الفائقة (hyper-parameter sweep).

يتطلب MADGRAD مقداراً أقل من اضمحلال الوزن مقارنةً بالطرق الأخرى، وغالباً ما يكون صفر. كما أن قيم الزخم المستخدمة في SGD أو beta1 في Adam ينبغي أن تعمل هنا أيضاً.

في المسائل المتناثرة، يجب ضبط كل من weight_decay و momentum على القيمة 0.

#### خطوة[[timm.optim.MADGRAD.step]]

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

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/madgrad.py#L90)

**المعاملات:**

closure (callable, اختياري) : دالة مغلقة تعيد تقييم النموذج وتعيد الخسارة.

يُنفّذ خطوة تحسين واحدة.

#### timm.optim.Mars[[timm.optim.Mars]]

```python
timm.optim.Mars(params: ParamsT, lr: float = 0.003, betas: typing.Tuple[float, float] = (0.9, 0.99), eps: float = 1e-08, weight_decay: float = 0.0, gamma: float = 0.025, mars_type: str = 'adamw', optimize_1d: bool = False, lr_1d_factor: float = 1.0, betas_1d: typing.Optional[typing.Tuple[float, float]] = None, caution: bool = False)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/mars.py#L90)

مُحسِّن MARS

الورقة: MARS: إطلاق قوة تقليل التباين لتدريب النماذج الكبيرة

#### خطوة[[timm.optim.Mars.step]]

```python
step(closure = None)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/mars.py#L140)

**المعاملات:**

closure (callable, اختياري) : دالة مغلقة تعيد تقييم النموذج وتعيد الخسارة.

يُنفّذ خطوة تحسين واحدة.

#### timm.optim.Muon[[timm.optim.Muon]]

```python
timm.optim.Muon(params: ParamsT, lr: float = 0.02, weight_decay: float = 0, momentum: float = 0.95, nesterov: bool = False, ns_steps: int = 5, ns_coefficients: typing.Union[str, typing.Tuple[float, float, float], typing.List[typing.Tuple[float, float, float]]] = 'quintic', eps: float = 1e-07, safety_factor: float = 1.0, adjust_lr_fn: typing.Optional[str] = 'match_rms_adamw', conv_mode: str = 'flatten', normalize_spatial: bool = True, adamw_lr: typing.Optional[float] = None, fallback_lr_scale: float = 1.0, betas: typing.Tuple[float, float] = (0.9, 0.95), algo: str = 'muon', scale_eps: bool = False, capturable: bool = False, verbose: bool = False)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/muon.py#L654)

مايون - الزخم المُعامَل بطريقة نيوتن-شولتز

يجمع بين Muon للمعاملات ذات البُعد 2+ (مصفوفات الأوزان) وAdamW للمعاملات ذات البُعد 1 (الانحيازات، المعايير) ومجموعات المعاملات التي تم ضبط 'use_fallback=True' فيها (أو 'use_muon=False' من أجل التوافق).

يدعم خوارزميتين:
- "muon": خوارزمية Muon القياسية مع الزخم + التقويم
- "adamuon": خوارزمية AdaMuon التي تضيف تقديرًا للزخم الثاني لكل عنصر إلى الاتجاهات المتعامدة من أجل تحقيق تحجيم تكيفي مشابه لـ Adam

#### خطوة[[timm.optim.Muon.step]]

```python
step(closure = None)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/muon.py#L798)

يُنفّذ خطوة تحسين واحدة.

#### timm.optim.NAdamLegacy[[timm.optim.NAdamLegacy]]

```python
timm.optim.NAdamLegacy(params, lr = 0.002, betas = (0.9, 0.999), eps = 1e-08, weight_decay = 0, schedule_decay = 0.004)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/nadam.py#L7)

**المعاملات:**

params (iterable) : iterable من المعاملات المراد تحسينها أو قواميس تعرّف مجموعات المعاملات

lr (float, اختياري) : معدل التعلم (الافتراضي: 2e-3)

betas (Tuple[float, float], اختياري) : المعاملات المستخدمة لحساب المتوسطات المتحركة للتدرج ومربعه

eps (float, اختياري) : حد يُضاف إلى المقام لتحسين الاستقرار العددي (الافتراضي: 1e-8)

weight_decay (float, اختياري) : تراجع الوزن (عقوبة L2) (الافتراضي: 0)

schedule_decay (float, اختياري) : معدل اضمحلال جدول الزخم (الافتراضي: 4e-3)

يُنفّذ خوارزمية Nadam (نسخة من Adam مبنية على زخم Nesterov).

ملاحظة: تم إيقاف استخدام هذا التنفيذ لصالح torch.optim.NAdam ويبقى كمرجع

تم اقتراح ذلك في `Incorporating Nesterov Momentum into Adam`__.

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

أُخذت في الأصل من: https://github.com/pytorch/pytorch/pull/1408 ملاحظة: قد تحتوي على مشاكل محتملة لكنها تعمل بشكل جيد في بعض المشكلات.

#### خطوة[[timm.optim.NAdamLegacy.step]]

```python
step(closure = None)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/nadam.py#L52)

**المعاملات:**

closure (callable, اختياري) : دالة مغلقة تعيد تقييم النموذج وتعيد الخسارة.

يُنفّذ خطوة تحسين واحدة.

#### timm.optim.NAdamW[[timm.optim.NAdamW]]

```python
timm.optim.NAdamW(params: ParamsT, lr: float = 0.001, betas: typing.Tuple[float, float] = (0.9, 0.999), eps: float = 1e-08, weight_decay: float = 0.01, caution: bool = False, corrected_weight_decay: bool = False, maximize: bool = False, foreach: typing.Optional[bool] = None, capturable: bool = False, clipping_threshold: typing.Optional[float] = None)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/nadamw.py#L25)

**المعاملات:**

params : قابل للتكرار من المعلمات المراد تحسينها أو قواميس تعرّف مجموعات المعلمات

lr : معدل التعلم

betas : المعاملات المستخدمة لحساب المتوسطات المتحركة للتدرج ومربعه

eps : الحد المضاف إلى المقام لتحسين الاستقرار العددي

weight_decay : معامل تخفيف الوزن

caution : تفعيل الحذر

corrected_weight_decay : تطبيق تضاؤل الوزن المُصحَّح (lr**2 / max_lr)

maximize : تعظيم المعلمات بناءً على الدالة الهدف، بدلاً من تقليلها

foreach : ما إذا كان يُستخدم تنفيذ foreach الخاص بمحسّن الأداء. إذا لم يُحدد (None)، فسيُستخدم تنفيذ foreach على CUDA (الأجهزة التي تحتوي على نواة foreach) لأنه أسرع بشكل عام.

capturable : ما إذا كان هذا المثال آمناً للالتقاط في رسم CUDA

clipping_threshold : عتبة قصّ تحديث RMS (StableAdamW, https://arxiv.org/abs/2304.13013)، حيث يُقاس التحديث بمعامل 1 / max(1, rms / clipping_threshold) حيث rms هو RMS للتدرج / (sqrt(v_hat) + eps). يُخمد هذا التحديث المعاملات التي تشهد زيادة مفاجئة في التدرج مقارنةً بتقدير لحظتها الثانية. القيمة الافتراضية هي 1.0 وفقاً للورقة البحثية، بينما تعطيلها يتم بتعيين None (الافتراضي). كما في Adafactor، لا يُقصّ اضمحلال الوزن المنفصل (كما أن StableAdamW يقاس اضمحلال الوزن أيضاً بالتعلم المعدّل بعد القص).

يُنفّذ خوارزمية NAdamW.

انظر إلى الجدول 1 في https://arxiv.org/abs/1910.05446 لمعرفة تنفيذ خوارزمية NAdam (يوجد أيضًا تعليق في الكود يبرز الفرق الوحيد بين NAdamW و AdamW).

لمزيد من التفاصيل حول الخوارزمية، نحيلكم إلى
- تنظيم تخفيف الوزن المنفصل: https://arxiv.org/abs/1711.05101
- حول تقارب آدم وما بعده: https://openreview.net/forum?id=ryQu7f-RZ

#### خطوة[[timm.optim.NAdamW.step]]

```python
step(closure = None)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/nadamw.py#L113)

**المعاملات:**

closure (callable, اختياري) : دالة مغلقة تعيد تقييم النموذج وتعيد الخسارة.

يُنفّذ خطوة تحسين واحدة.

#### timm.optim.NvNovoGrad[[timm.optim.NvNovoGrad]]

```python
timm.optim.NvNovoGrad(params, lr = 0.001, betas = (0.95, 0.98), eps = 1e-08, weight_decay = 0, grad_averaging = False, amsgrad = False, decoupled_decay = False, corrected_weight_decay = False)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/nvnovograd.py#L17)

**المعاملات:**

params (iterable) : iterable من المعاملات المراد تحسينها أو قواميس تعرّف مجموعات المعاملات

lr (float, اختياري) : معدل التعلم (الافتراضي: 1e-3)

betas (Tuple[float, float]، اختياري) : المعاملات المستخدمة لحساب المتوسطات المتحركة للتدرج ومربعه (الافتراضي: (0.95, 0.98))

eps (float, اختياري) : حد يُضاف إلى المقام لتحسين الاستقرار العددي (الافتراضي: 1e-8)

weight_decay (float, اختياري) : تراجع الوزن (عقوبة L2) (الافتراضي: 0)

grad_averaging : متوسط التدرجات

amsgrad (منطقية، اختيارية) : ما إذا كان سيتم استخدام متغير AMSGrad لهذا الخوارزمية من الورقة `On the Convergence of Adam and Beyond`_ (الافتراضي: False)

decoupled_decay : تطبيق انحطاط الوزن مباشرة على الأوزان (lr * weight_decay في كل خطوة) بدلاً من إضافته إلى التدرج المُطَبَّع قبل تحديث الزخم (كما هو مذكور في الورقة البحثية)

corrected_weight_decay : تطبيق تخفيف الوزن المُصحَّح (lr**2 / max_lr) عندما يكون decoupled_decay بقيمة True

يُنفّذ خوارزمية Novograd.

#### خطوة[[timm.optim.NvNovoGrad.step]]

```python
step(closure = None)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/nvnovograd.py#L90)

**المعاملات:**

closure (callable, اختياري): دالة إغلاق تعيد تقييم النموذج

وتعيد الخسارة. --

يُنفّذ خطوة تحسين واحدة.

#### timm.optim.RAdamLegacy[[timm.optim.RAdamLegacy]]

```python
timm.optim.RAdamLegacy(params, lr = 0.001, betas = (0.9, 0.999), eps = 1e-08, weight_decay = 0)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/radam.py#L16)

مُحسِّن PyTorch RAdam

ملاحظة: تم إيقاف استخدام هذا التنفيذ لصالح torch.optim.AdamW ويبقى كمرجع

#### timm.optim.RMSpropTF[[timm.optim.RMSpropTF]]

```python
timm.optim.RMSpropTF(params: ParamsT, lr: float = 0.01, alpha: float = 0.9, eps: float = 1e-10, weight_decay: float = 0, momentum: float = 0.0, centered: bool = False, decoupled_decay: bool = False, corrected_weight_decay: bool = False, lr_in_momentum: bool = True, caution: bool = False, foreach: typing.Optional[bool] = None)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/rmsprop_tf.py#L27)

**المعاملات:**

params : قابل للتكرار من المعلمات المراد تحسينها أو قواميس تعرّف مجموعات المعلمات

lr : معدل التعلم

momentum : معامل الزخم

alpha : ثابت التنعيم (التلاشي)

eps : الحد المضاف إلى المقام لتحسين الاستقرار العددي

centered : إذا كان `True`، يتم حساب RMSProp المركزي، حيث يُطَبَّع التدرّج بواسطة تقدير لتباينه

weight_decay : اضمحلال الأوزان (عقوبة L2) (الافتراضي: 0)

decoupled_decay : فصل إضمحلال الوزن وفقاً لـ https://arxiv.org/abs/1711.05101

corrected_weight_decay : تطبيق تخفيف الوزن المُصحَّح (lr**2 / max_lr) عندما يكون decoupled_decay بقيمة True

lr_in_momentum : يتضمن توسيع معدل التعلم في تحديث مخزن الزخم وفقًا للإعدادات الافتراضية في Tensorflow

caution : يُنصح بالحذر

foreach : استخدم تنفيذ foreach (متعدد المتجهات) افتراضيًا (None) ما لم يكون غير مدعوم (انظر rmsprop_tf())

يُنفّذ خوارزمية RMSprop (مع قيمة epsilon بأسلوب TensorFlow)

NOTE: هذا نسخ ولصق مباشر لخوارزمية PyTorch RMSprop مع تطبيق eps قبل الجذر التربيعي، بالإضافة إلى بعض التعديلات الأخرى لمطابقة Tensorflow بشكل أقرب عند استخدام نفس المعلمات الفائقة.

تشمل التغييرات الجديرة بالذكر:
1. إبسيلون مطبقة داخل الجذر التربيعي
2. square_avg مُهيّأة إلى ones
3. مقياس معدل التعلم للتحديث المتراكم في مخزن الزخم

اقترحها جي. هنتون في [دوره](http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf).

تظهر النسخة المركزية أولاً في [توليد المتتابعات باستخدام الشبكات العصبية المتكررة](https://arxiv.org/pdf/1308.0850v5.pdf).

#### خطوة[[timm.optim.RMSpropTF.step]]

```python
step(closure = None)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/rmsprop_tf.py#L112)

**المعاملات:**

closure (callable, اختياري) : دالة مغلقة تعيد تقييم النموذج وتعيد الخسارة.

يُنفّذ خطوة تحسين واحدة.

#### timm.optim.SGDP[[timm.optim.SGDP]]

```python
timm.optim.SGDP(params, lr = torch.optim.optimizer.required, momentum = 0, dampening = 0, weight_decay = 0, nesterov = False, eps = 1e-08, delta = 0.1, wd_ratio = 0.1, caution = False)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/sgdp.py#L22)

#### timm.optim.SGDW[[timm.optim.SGDW]]

```python
timm.optim.SGDW(params: ParamsT, lr: float = 0.001, momentum: float = 0.0, dampening: float = 0.0, weight_decay: float = 0.0, nesterov: bool = False, caution: bool = False, corrected_weight_decay: bool = False, maximize: bool = False, foreach: typing.Optional[bool] = None, differentiable: bool = False)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/sgdw.py#L26)

#### خطوة[[timm.optim.SGDW.step]]

```python
step(closure = None)
```

[المصدر](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/sgdw.py#L98)

**المعاملات:**

closure (Callable, اختياري) : دالة مغلقة تعيد تقييم النموذج وتعيد الخسارة.

يُنفّذ خطوة تحسين واحدة.