# ExecuTorch

[`ExecuTorch`](https://github.com/pytorch/executorch) est une solution de bout en bout permettant d’activer les capacités d’inférence sur appareil sur les dispositifs mobiles et de bord, y compris les objets connectés, les dispositifs embarqués et les microcontrôleurs. Il fait partie de l’écosystème PyTorch et prend en charge le déploiement de modèles PyTorch, avec un accent mis sur la portabilité, la productivité et les performances.

ExecuTorch introduit des points d’entrée bien définis pour effectuer des optimisations spécifiques au modèle, à l’appareil et/ou au cas d’usage, telles que la délégation au backend, les transformations de compilateur définies par l’utilisateur, la planification de la mémoire, et bien d’autres. La première étape pour préparer un modèle PyTorch à l’exécution sur un appareil edge à l’aide d’ExecuTorch consiste à exporter le modèle. Cela se fait à l’aide d’une API PyTorch nommée [`torch.export`](https://pytorch.org/docs/stable/export.html).

## Intégration d'ExecuTorch[[transformers.TorchExportableModuleWithStaticCache]]

Un point d’intégration est en cours de développement afin de garantir que 🤗 Transformers peut être exporté à l’aide de `torch.export`. L’objectif de cette intégration est non seulement de permettre l’export, mais aussi de s’assurer que l’artefact exporté peut être ultérieurement abaissé et optimisé pour s’exécuter efficacement dans `ExecuTorch`, en particulier pour les cas d’usage mobiles et sur le bord (edge).

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/integrations/executorch.py#L445)

Un module de recette conçu pour rendre un `PreTrainedModel` exportable avec `torch.export`, spécifiquement pour un LM uniquement décodeur vers `StaticCache`. Ce module garantit que le modèle exporté est compatible avec une réduction et une exécution ultérieures dans `ExecuTorch`.

Remarque : Cette classe est spécifiquement conçue pour prendre en charge le processus d’exportation à l’aide de `torch.export` de manière à garantir que le modèle peut être ultérieurement abaissé et exécuté efficacement dans `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)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/integrations/executorch.py#L540)

**Paramètres :**

input_ids (`torch.Tensor`) : Tenseur représentant l'identifiant du jeton d'entrée actuel pour le module.

inputs_embeds (`torch.Tensor`) : Tenseur représentant les embeddings d'entrée actuels du module.

cache_position (`torch.Tensor`) : Tenseur représentant la position d'entrée actuelle dans le cache.

**Retourne :** `torch.Tensor`

Sortie des logits du modèle.

Passage avant du module, compatible avec le runtime ExecuTorch.

Cet adaptateur avant remplit deux fonctions principales :

1. **Rendre le modèle compatible avec `torch.export`** : l'adaptateur masque les objets non pris en charge, tels que `Cache`, des entrées et des sorties du graphe, permettant ainsi d'exporter le modèle à l'aide de `torch.export` sans rencontrer de problème.

2. **Garantir la compatibilité avec le runtime `ExecuTorch`** : l'adaptateur aligne la signature de la méthode forward du modèle sur celle présente dans `executorch/extension/llm/runner`, afin de s'assurer que le modèle exporté peut être exécuté dans `ExecuTorch` sans configuration supplémentaire.

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/integrations/executorch.py#L757)

**Paramètres :**

model (`PreTrainedModel`) : Le modèle pré-entraîné à exporter.

example_input_ids (`Optional[torch.Tensor]`) : Exemple d'identifiant de jeton d'entrée utilisé par `torch.export`.

example_cache_position (`Optional[torch.Tensor]`) : Position actuelle du cache utilisée par `torch.export`.

dynamic_shapes(`Optional[dict]`) : Formes dynamiques utilisées par `torch.export`.

strict(`Optional[bool]`) : Indicateur pour demander à `torch.export` d'utiliser `dynamo`.

**Retourne :** Programme exporté (`torch.export.ExportedProgram`)

Le programme exporté généré via `torch.export`.

Convertir un `PreTrainedModel` en module exportable et l’exporter à l’aide de `torch.export`, en veillant à ce que le modèle exporté soit compatible avec `ExecuTorch`.

