# FP8

Abaixo estão as funções e classes relativas à implementação subjacente 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)
```

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

**Parâmetros:**

use_autocast_during_eval (`bool`, *opcional*, padrão `False`) : Se deve usar FP8 autocast durante o modo de avaliação. Geralmente, métricas melhores são obtidas quando este valor é `False`.

margin (`int`, *opcional*, padrão 0) : A margem a ser usada para o escalonamento do gradiente.

interval (`int`, *opcional*, padrão 1) : O intervalo a ser usado para a frequência de recálculo do fator de escala.

fp8_format (`str`, *opcional*, padrão "HYBRID") : O formato a ser usado para a receita FP8. Deve ser um dos `HYBRID`, `E4M3` ou `E5M2`. (Geralmente `HYBRID` para treinamento, `E4M3` ou `E5M2` para avaliação)

amax_history_len (`int`, *opcional*, padrão 1024) : O comprimento do histórico a ser usado para o cálculo do fator de escala

amax_compute_algo (`str`, *opcional*, padrão "most_recent") : O algoritmo a ser usado para o cálculo do fator de escala. Deve ser um dos valores `max` ou `most_recent`.

override_linear_precision (`tuple` de três `bool`, *opcional*, padrão `(False, False, False)`) : Se deve ou não executar os GEMMs de `fprop`, `dgrad` e `wgrad` em precisão mais alta.

Use este objeto em seu [Accelerator](/docs/accelerate/main/pt/package_reference/accelerator#accelerate.Accelerator) para personalizar a inicialização da receita para treinamento de precisão mista FP8 com `transformer-engine`.

Para mais informações sobre os args, consulte a [documentação](https://docs.nvidia.com/deeplearning/transformer-engine/user-guide/api/common.html) da 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)
```

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

**Parâmetros:**

config (`torchao.float8.Float8LinearConfig`, *opcional*, padrão `None`) : A configuração para o treinamento em FP8. Se `None`, uma configuração padrão será criada com valores sensatos para a maioria dos casos de uso: - `pad_inner_dim=True`: Preenche as dimensões da matriz para que sejam divisíveis por 16, necessário para operações de `torch._scaled_mm` a fim de evitar erros em tempo de execução. - `enable_fsdp_float8_all_gather=True`: Habilita o all-gather em FP8 para o FSDP2. Isso proporciona economia de largura de banda de memória ao converter os parâmetros antes da operação de all-gather, economizando 50% da largura de banda em comparação com BF16. Você pode sobrescrever esses padrões fornecendo sua própria instância de `Float8LinearConfig`.

module_filter_func (`Callable`, *opcional*, padrão `None`) : Função opcional que deve receber um módulo e um nome de camada e retorna um booleano indicando se o módulo deve ser convertido para FP8. O padrão é `accelerate.utils.ao.filter_linear_layers`. Consulte-o para ver um exemplo.

Use este objeto em seu [Accelerator](/docs/accelerate/main/pt/package_reference/accelerator#accelerate.Accelerator) para personalizar a inicialização da receita para treinamento com precisão mista FP8 usando FP8 do `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)
```

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

Converte recursivamente as camadas lineares e de layernorm de um modelo para o equivalente em `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)
```

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

Indica se um determinado modelo possui alguma camada `transformer_engine` ou não.

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

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

Wrapper para o método forward de um modelo para aplicar FP8 autocast. É consciente do contexto, o que significa que, por padrão, desativará o FP8 autocast durante o modo de avaliação, o que geralmente é melhor para métricas mais 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)
```

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

Aplica o gerenciador de contexto FP8 ao método forward do modelo