# ExecuTorch

[`ExecuTorch`](https://github.com/pytorch/executorch) es una solución integral para habilitar la inferencia en el dispositivo en dispositivos móviles y de borde, incluidos los dispositivos portátiles, los dispositivos embebidos y los microcontroladores. Forma parte del ecosistema de PyTorch y admite el despliegue de modelos de PyTorch con un enfoque en la portabilidad, la productividad y el rendimiento.

ExecuTorch introduce puntos de entrada bien definidos para realizar optimizaciones específicas de modelo, dispositivo y/o caso de uso, como la delegación de backends, transformaciones de compilador definidas por el usuario, planificación de memoria y más. El primer paso para preparar un modelo de PyTorch para su ejecución en un dispositivo de borde con ExecuTorch es exportar el modelo. Esto se logra mediante el uso de una API de PyTorch llamada [`torch.export`](https://pytorch.org/docs/stable/export.html).

## Integración de ExecuTorch[[transformers.TorchExportableModuleWithStaticCache]]

Se está desarrollando un punto de integración para garantizar que 🤗 Transformers pueda exportarse mediante `torch.export`. El objetivo de esta integración no solo es habilitar la exportación, sino también asegurar que el artefacto exportado pueda reducirse y optimizarse ulteriormente para ejecutarse de manera eficiente en `ExecuTorch`, especialmente en casos de uso para móviles y 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)
```

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

Un módulo de receta diseñado para hacer que un `PreTrainedModel` sea exportable con `torch.export`, específicamente para LM solo decodificador a `StaticCache`. Este módulo garantiza que el modelo exportado sea compatible con una reducción y ejecución posteriores en `ExecuTorch`.

Nota: Esta clase está diseñada específicamente para apoyar el proceso de exportación mediante `torch.export` de manera que se garantice que el modelo pueda reducirse y ejecutarse de forma eficiente en `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)
```

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

**Parámetros:**

input_ids (`torch.Tensor`) : Tensor que representa el id del token de entrada actual al módulo.

inputs_embeds (`torch.Tensor`) : Tensor que representa los embeddings de entrada actuales del módulo.

cache_position (`torch.Tensor`) : Tensor que representa la posición de entrada actual en la caché.

**Devuelve:** `torch.Tensor`

Salida de logits del modelo.

Paso hacia adelante del módulo, que es compatible con el tiempo de ejecución ExecuTorch.

Este adaptador de propagación hacia adelante cumple dos propósitos principales:

1. **Hacer que el modelo sea compatible con `torch.export`**: el adaptador oculta los objetos no compatibles, como `Cache`, de las entradas y salidas del grafo, lo que permite exportar el modelo con `torch.export` sin encontrar problemas.

2. **Garantizar la compatibilidad con el runtime de `ExecuTorch`**: el adaptador coincide con la firma de forward del modelo y la de `executorch/extension/llm/runner`, lo que garantiza que el modelo exportado pueda ejecutarse en `ExecuTorch` sin configuración adicional.

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

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

**Parámetros:**

model (`PreTrainedModel`): El modelo preentrenado que se va a exportar.

example_input_ids (`Optional[torch.Tensor]`) : ID de token de entrada de ejemplo utilizado por `torch.export`.

example_cache_position (`Optional[torch.Tensor]`) : Posición de caché actual de ejemplo utilizada por `torch.export`.

dynamic_shapes(`Optional[dict]`) : Formas dinámicas utilizadas por `torch.export`.

strict(`Optional[bool]`) : Bandera para indicar a `torch.export` que use `dynamo`.

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

El programa exportado generado mediante `torch.export`.

Convierta un `PreTrainedModel` en un módulo exportable y expórtelo con `torch.export`, asegurándose de que el modelo exportado sea compatible con `ExecuTorch`.