# ExecuTorch

[`ExecuTorch`](https://github.com/pytorch/executorch) é uma solução de ponta a ponta para habilitar a capacidade de inferência em dispositivos móveis e de borda, incluindo wearables, dispositivos embarcados e microcontroladores. Faz parte do ecossistema do PyTorch e suporta o deploy de modelos do PyTorch, com foco em portabilidade, produtividade e desempenho.

O ExecuTorch introduz pontos de entrada bem definidos para realizar otimizações específicas de modelo, dispositivo e/ou caso de uso, como delegação de backend, transformações de compilador definidas pelo usuário, planejamento de memória e muito mais. O primeiro passo para preparar um modelo do PyTorch para execução em um dispositivo de borda usando o ExecuTorch é exportar o modelo. Isso é feito por meio do uso de uma API do PyTorch chamada [`torch.export`](https://pytorch.org/docs/stable/export.html).

## Integração com o ExecuTorch[[transformers.TorchExportableModuleWithStaticCache]]

Um ponto de integração está sendo desenvolvido para garantir que o 🤗 Transformers possa ser exportado usando `torch.export`. O objetivo dessa integração não é apenas habilitar a exportação, mas também garantir que o artefato exportado possa ser posteriormente reduzido e otimizado para executar de forma eficiente no `ExecuTorch`, especialmente para casos de uso em dispositivos móveis e na borda.

#### transformers.TorchExportableModuleWithStaticCache[[transformers.TorchExportableModuleWithStaticCache]]

```python
transformers.TorchExportableModuleWithStaticCache(model: PreTrainedModel, batch_size: int | None = None, max_cache_len: int | None = None, device: typing.Optional[torch.device] = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/executorch.py#L445)

Um módulo de receita projetado para tornar um `PreTrainedModel` exportável com `torch.export`, especificamente para LM apenas de decodificador para `StaticCache`. Este módulo garante que o modelo exportado seja compatível com o rebaixamento e a execução adicionais no `ExecuTorch`.

Nota: Esta classe foi projetada especificamente para suportar o processo de exportação usando `torch.export` de forma a garantir que o modelo possa ser reduzido e executado de maneira eficiente no `ExecuTorch`.

#### forward[[transformers.TorchExportableModuleWithStaticCache.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, cache_position: typing.Optional[torch.Tensor] = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/executorch.py#L540)

**Parâmetros:**

input_ids (`torch.Tensor`) : Tensor que representa o id do token de entrada atual para o módulo.

inputs_embeds (`torch.Tensor`) : Tensor que representa os embeddings de entrada atuais para o módulo.

cache_position (`torch.Tensor`) : Tensor que representa a posição atual da entrada no cache.

**Retorna:** `torch.Tensor`

Saída de logits do modelo.

Passada adiante do módulo, compatível com o runtime ExecuTorch.

Este adaptador de encaminhamento tem dois propósitos principais:

1. **Tornar o modelo compatível com `torch.export`**: o adaptador oculta objetos não suportados, como o `Cache`, das entradas e saídas do grafo, permitindo que o modelo seja exportado usando `torch.export` sem encontrar problemas.

2. **Garantindo compatibilidade com o runtime `ExecuTorch`**: o adaptador corresponde à assinatura do forward do modelo àquela em `executorch/extension/llm/runner`, garantindo que o modelo exportado possa ser executado no `ExecuTorch` sem necessidade de ajustes adicionais.

#### transformers.convert_and_export_with_cache[[transformers.convert_and_export_with_cache]]

```python
transformers.convert_and_export_with_cache(model: PreTrainedModel, example_input_ids: typing.Optional[torch.Tensor] = None, example_cache_position: typing.Optional[torch.Tensor] = None, dynamic_shapes: dict | None = None, strict: bool | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/executorch.py#L757)

**Parâmetros:**

model (`PreTrainedModel`): O modelo pré-treinado a ser exportado.

example_input_ids (`Optional[torch.Tensor]`) : ID de token de entrada de exemplo usado pelo `torch.export`.

example_cache_position (`Optional[torch.Tensor]`) : Posição atual do cache de exemplo usada por `torch.export`.

dynamic_shapes(`Optional[dict]`) : Formas dinâmicas usadas pelo `torch.export`.

strict(`Optional[bool]`) : Sinalizador para instruir o `torch.export` a usar o `dynamo`.

**Retorna:** Programa exportado (`torch.export.ExportedProgram`)

O programa exportado gerado via `torch.export`.

Converta um `PreTrainedModel` em um módulo exportável e exporte-o usando `torch.export`, garantindo que o modelo exportado seja compatível com `ExecuTorch`.