# Tokens entrenables

El método Trainable Tokens ofrece una forma de dirigir el ajuste fino hacia embeddings de tokens específicos, sin recurrir a entrenar la matriz de embeddings completa ni a utilizar un adaptador sobre la matriz de embeddings. Se basa en la implementación inicial de [aquí](https://github.com/huggingface/peft/pull/1541).

El método solo apunta a tokens específicos y entrena de forma selectiva los índices de tokens que especifiques. En consecuencia, la RAM requerida será menor y la memoria en disco también será significativamente menor que la necesaria para almacenar la matriz de embeddings completa ajustada.

Algunos benchmarks preliminares obtenidos con [este script](https://github.com/huggingface/peft/blob/main/scripts/train_memory.py) sugieren que para `gemma-2-2b` (que tiene una matriz de embedding bastante grande) se puede ahorrar ~4 GiB de VRAM con Trainable Tokens en comparación con el fine-tuning completo de la matriz de embedding. Si bien LoRA utilizará cantidades de VRAM comparables, también podría apuntar a tokens que no se desea modificar. Tenga en cuenta que estas son solo indicaciones y que los diferentes tamaños de la matriz de embedding podrían alterar ligeramente estas cifras.

Tenga en cuenta que este método no añade tokens por usted; debe añadir los tokens al tokenizer usted mismo y redimensionar la matriz de embeddings del modelo en consecuencia. Este método solo volverá a entrenar los embeddings para los tokens que especifique. ¡Este método también se puede usar en conjunto con capas de LoRA! Consulte [la documentación de LoRA](lora#efficiently-train-tokens-alongside-lora).

> [!TIP]
> Guardar el modelo con [save_pretrained()](/docs/peft/main/es/package_reference/peft_model#peft.PeftModel.save_pretrained) o recuperar el state dict usando [get_peft_model_state_dict()](/docs/peft/main/es/package_reference/peft_model#peft.get_peft_model_state_dict) al añadir nuevos tokens puede guardar la matriz de embeddings completa en lugar de solo la diferencia, como medida de precaución, porque la matriz de embeddings se redimensionó. Para ahorrar espacio, puedes deshabilitar este comportamiento estableciendo `save_embedding_layers=False` al llamar a `save_pretrained`. Esto es seguro siempre que no modifiques la matriz de embeddings por otros medios, ya que dichos cambios no serán rastreados por los tokens entrenables.

## Resumen de las pruebas de rendimiento

<iframe src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=TRAINABLE_TOKENS" frameborder="0" width="850" height="1000"
>

# API

## TrainableTokensConfig[[peft.TrainableTokensConfig]]

#### peft.TrainableTokensConfig[[peft.TrainableTokensConfig]]

```python
peft.TrainableTokensConfig(task_type: Optional[Union[str, TaskType]] = None, peft_type: Optional[Union[str, PeftType]] = None, auto_mapping: Optional[dict] = None, peft_version: Optional[str] = None, base_model_name_or_path: Optional[str] = None, revision: Optional[str] = None, inference_mode: bool = False, token_indices: list[int] = <factory>, target_modules: Optional[Union[list[str], str]] = None, init_weights: bool = True)
```

[Fuente](https://github.com/huggingface/peft/blob/main/src/peft/tuners/trainable_tokens/config.py#L25)

**Parámetros:**

token_indices (`list[int]`) : Lista de enteros que indican los índices de los tokens que deseas que sean entrenables. Para encontrar el índice de un token con un tokenizer, puedes tokenizar la cadena y revisar los `input_ids` devueltos. Cuanto más se acerque la cantidad de índices al número total de tokens, menos eficiente se vuelve este método.

target_modules (`Optional[Union[list[str], str]]`) : Lista de nombres de módulos o expresión regular de los nombres de módulos que se reemplazarán con nuestro `TrainableTokensLayer`. Si no se define, intentará obtener la capa de incrustación de entrada del modelo si el modelo tiene un método `get_input_embeddings` (los modelos transformer suelen tenerlo); si eso falla, el valor predeterminado es 'embed_tokens'. Otros ejemplos de objetivos son `embedding`, `encoder.embeddings` o `decoder.embeddings`.

init_weights (`bool`) : Por defecto, los pesos de los nuevos tokens se inicializan para que sean iguales a los embeddings de los tokens respectivos. Esto hace que TrainableTokens sea una operación sin efecto (no-op) cuando no se entrena. Si se establece en `False`, los pesos serán valores aleatorios. No cambies esta configuración a menos que sepas exactamente lo que estás haciendo.

Configuración para el método `TrainableTokens`.

Permite entrenar nuevos tokens (y reentrenar los existentes) sin entrenar la matriz de embeddings completa. Al marcar como entrenables unos pocos tokens seleccionados (identificados por sus índices) y dejar el resto intacto, este método se puede utilizar para agregar nuevos tokens o cambiar el embedding de tokens existentes, ahorrando memoria. Tanto el almacenamiento como el uso de memoria de trabajo se reducen en comparación con el entrenamiento completo de la matriz de embeddings.

Tenga en cuenta que el entrenamiento con FSDP/DeepSpeed podría no estar aún totalmente soportado.

## TrainableTokensModel[[peft.TrainableTokensModel]]

#### peft.TrainableTokensModel[[peft.TrainableTokensModel]]

```python
peft.TrainableTokensModel(model, peft_config: Union[PeftConfig, dict[str, PeftConfig]], adapter_name: str, low_cpu_mem_usage: bool = False, state_dict: Optional[dict[str, torch.Tensor]] = None)
```

[Fuente](https://github.com/huggingface/peft/blob/main/src/peft/tuners/trainable_tokens/model.py#L26)

