# FP8

A continuación se muestran las funciones y clases relativas a la implementación subyacente de FP8

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

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

**Parámetros:**

use_autocast_during_eval (`bool`, *opcional*, por defecto `False`) : Si se debe usar FP8 autocast durante el modo de evaluación. Generalmente se obtienen mejores métricas cuando esto es `False`.

margin (`int`, *opcional*, valor predeterminado 0) : El margen a utilizar para la escalado del gradiente.

interval (`int`, *opcional*, valor predeterminado 1) : El intervalo a utilizar para la frecuencia con la que se recalcula el factor de escalado.

fp8_format (`str`, *opcional*, valor predeterminado "HYBRID") : El formato a utilizar para la receta FP8. Debe ser uno de `HYBRID`, `E4M3` o `E5M2`. (Generalmente `HYBRID` para entrenamiento, `E4M3` o `E5M2` para evaluación)

amax_history_len (`int`, *opcional*, valor predeterminado 1024) : La longitud del historial que se utilizará para el cálculo del factor de escalado

amax_compute_algo (`str`, *opcional*, por defecto "most_recent") : El algoritmo a utilizar para el cálculo del factor de escalado. Debe ser uno de `max` o `most_recent`.

override_linear_precision (`tuple` de tres `bool`, *opcional*, valor predeterminado `(False, False, False)`) : Si se deben ejecutar o no los GEMM de `fprop`, `dgrad` y `wgrad` en mayor precisión.

Use este objeto en su [Accelerator](/docs/accelerate/main/es/package_reference/accelerator#accelerate.Accelerator) para personalizar la inicialización de la receta para el entrenamiento con precisión mixta FP8 con `transformer-engine`.

Para obtener más información sobre los args, consulte la [documentación](https://docs.nvidia.com/deeplearning/transformer-engine/user-guide/api/common.html) de la 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)
```

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

**Parámetros:**

config (`torchao.float8.Float8LinearConfig`, *opcional*, valor predeterminado `None`) : La configuración para el entrenamiento en FP8. Si es `None`, se creará una configuración predeterminada con valores razonables para la mayoría de los casos de uso: - `pad_inner_dim=True`: Rellena las dimensiones de la matriz para que sean divisibles entre 16, requisito para las operaciones de `torch._scaled_mm` para evitar errores en tiempo de ejecución. - `enable_fsdp_float8_all_gather=True`: Habilita el all-gather en FP8 para FSDP2. Esto proporciona ahorros en el ancho de banda de memoria al convertir los parámetros antes de la operación all-gather, ahorrando un 50% de ancho de banda en comparación con BF16. Puede sobrescribir estos valores predeterminados proporcionando su propia instancia de `Float8LinearConfig`.

module_filter_func (`Callable`, *opcional*, valor predeterminado `None`) : Función opcional que debe recibir un módulo y el nombre de una capa, y devuelve un valor booleano que indica si el módulo debe convertirse a FP8. El valor predeterminado es `accelerate.utils.ao.filter_linear_layers`. Consulte esta función para ver un ejemplo.

Use este objeto en su [Accelerator](/docs/accelerate/main/es/package_reference/accelerator#accelerate.Accelerator) para personalizar la inicialización de la receta para el entrenamiento con precisión mixta FP8 mediante FP8 de `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)
```

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

Convierte recursivamente las capas lineales y de normalización de capas de un modelo a su equivalente de `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)
```

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

Indica si un modelo dado tiene alguna capa de `transformer_engine` o no.

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

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

Envoltorio para el método forward de un modelo para aplicar FP8 autocast. Es consciente del contexto, lo que significa que, de forma predeterminada, desactivará el FP8 autocast durante el modo de evaluación, lo cual suele ser mejor para obtener métricas más precisas.

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

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

Aplica el gestor de contexto FP8 al método forward del modelo