# FP8

Berikut adalah fungsi dan kelas yang berkaitan dengan implementasi FP8 yang mendasarinya

## TERecipeKwargs[[accelerate.utils.TERecipeKwargs]]

#### accelerate.utils.TERecipeKwargs[[accelerate.utils.TERecipeKwargs]]

```python
accelerate.utils.TERecipeKwargs(use_autocast_during_eval: bool | None = None, margin: int | None = None, interval: int | None = None, fp8_format: typing.Literal['HYBRID', 'E4M3', 'E5M2'] = None, amax_history_len: int | None = None, amax_compute_algo: typing.Literal['max', 'most_recent'] = None, override_linear_precision: tuple = None, use_mxfp8_block_scaling: bool | None = None)
```

[Sumber](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L338)

**Parameter:**

use_autocast_during_eval (`bool`, *opsional*, default `False`) : Apakah akan menggunakan FP8 autocast selama mode eval. Umumnya metrik yang lebih baik ditemukan ketika ini `False`.

margin (`int`, *opsional*, default 0) : Margin yang digunakan untuk penskalaan gradien.

interval (`int`, *opsional*, default 1) : Interval yang digunakan untuk seberapa sering faktor penskalaan dihitung ulang.

fp8_format (`str`, *opsional*, default "HYBRID") : Format yang digunakan untuk resep FP8. Harus salah satu dari `HYBRID`, `E4M3` atau `E5M2`. (Umumnya `HYBRID` untuk pelatihan, `E4M3` atau `E5M2` untuk evaluasi)

amax_history_len (`int`, *opsional*, default 1024) : Panjang riwayat yang digunakan untuk komputasi faktor penskalaan

amax_compute_algo (`str`, *opsional*, default "most_recent") : Algoritma yang digunakan untuk perhitungan faktor penskalaan. Harus berupa `max` atau `most_recent`.

override_linear_precision (`tuple` dari tiga `bool`, *opsional*, default ke `(False, False, False)`) : Apakah akan mengeksekusi GEMM `fprop`, `dgrad`, dan `wgrad` dalam presisi yang lebih tinggi.

Gunakan objek ini di [Accelerator](/docs/accelerate/main/id/package_reference/accelerator#accelerate.Accelerator) Anda untuk menyesuaikan inisialisasi resep untuk pelatihan presisi campuran FP8 dengan `transformer-engine`.

Untuk informasi lebih lanjut tentang args, silakan merujuk ke [dokumentasi](https://docs.nvidia.com/deeplearning/transformer-engine/user-guide/api/common.html) API.

```python
from accelerate import Accelerator
from accelerate.utils import TERecipeKwargs

kwargs = TERecipeKwargs(fp8_format="HYBRID")
accelerator = Accelerator(mixed_precision="fp8", kwargs_handlers=[kwargs])
```

## AORecipeKwargs[[accelerate.utils.AORecipeKwargs]]

#### accelerate.utils.AORecipeKwargs[[accelerate.utils.AORecipeKwargs]]

```python
accelerate.utils.AORecipeKwargs(config: ForwardRef('Float8LinearConfig') | None = None, module_filter_func: typing.Callable | None = None, pad_inner_dim: bool | None = None, enable_fsdp_float8_all_gather: bool | None = None)
```

[Sumber](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L290)

**Parameter:**

config (`torchao.float8.Float8LinearConfig`, *opsional*, default ke `None`) : Konfigurasi untuk pelatihan FP8. Jika `None`, konfigurasi default akan dibuat dengan nilai default yang masuk akal untuk sebagian besar kasus penggunaan: - `pad_inner_dim=True`: Menambahkan padding pada dimensi matriks agar dapat dibagi habis oleh 16, yang diperlukan untuk operasi `torch._scaled_mm` untuk mencegah error saat runtime. - `enable_fsdp_float8_all_gather=True`: Mengaktifkan FP8 all-gather untuk FSDP2. Ini memberikan penghematan bandwidth memori dengan meng-cast parameter sebelum operasi all-gather, menghemat 50% bandwidth dibandingkan dengan BF16. Anda dapat menimpa nilai default ini dengan menyediakan instance `Float8LinearConfig` Anda sendiri.

module_filter_func (`Callable`, *opsional*, default ke `None`) : Fungsi opsional yang harus menerima modul dan nama layer, serta mengembalikan boolean yang menunjukkan apakah modul tersebut harus dikonversi ke FP8. Defaultnya adalah `accelerate.utils.ao.filter_linear_layers`. Lihat di sana untuk contoh.

Gunakan objek ini di [Accelerator](/docs/accelerate/main/id/package_reference/accelerator#accelerate.Accelerator) Anda untuk menyesuaikan inisialisasi resep untuk pelatihan presisi campuran FP8 dengan FP8 `torchao`.

## convert_model[[accelerate.utils.convert_model]]

#### accelerate.utils.convert_model[[accelerate.utils.convert_model]]

```python
accelerate.utils.convert_model(model, to_transformer_engine = True, _convert_linear = True, _convert_ln = True)
```

[Sumber](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/transformer_engine.py#L26)

Mengonversi secara rekursif lapisan linear dan layernorm dari sebuah model ke padanannya di `transformers_engine`.

## has_transformer_engine_layers[[accelerate.utils.has_transformer_engine_layers]]

#### accelerate.utils.has_transformer_engine_layers[[accelerate.utils.has_transformer_engine_layers]]

```python
accelerate.utils.has_transformer_engine_layers(model)
```

[Sumber](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/transformer_engine.py#L95)

Mengembalikan apakah model tertentu memiliki lapisan `transformer_engine` atau tidak.

## contextual_fp8_autocast[[accelerate.utils.contextual_fp8_autocast]]

#### accelerate.utils.contextual_fp8_autocast[[accelerate.utils.contextual_fp8_autocast]]

```python
accelerate.utils.contextual_fp8_autocast(model_forward, fp8_recipe, use_during_eval = False)
```

[Sumber](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/transformer_engine.py#L118)

Wrapper untuk metode forward sebuah model untuk menerapkan FP8 autocast. Konteks sadar, artinya secara default akan menonaktifkan FP8 autocast selama mode eval, yang umumnya lebih baik untuk metrik yang lebih akurat.

## apply_fp8_autowrap[[accelerate.utils.apply_fp8_autowrap]]

#### accelerate.utils.apply_fp8_autowrap[[accelerate.utils.apply_fp8_autowrap]]

```python
accelerate.utils.apply_fp8_autowrap(model, fp8_recipe_handler)
```

[Sumber](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/transformer_engine.py#L142)

Menerapkan context manager FP8 ke metode forward model