# Llama-Adapter

    

LLaMA-Adapter: Ajuste fino eficiente de modelos de lenguaje con atención de inicialización cero

[Llama-Adapter](https://hf.co/papers/2303.16199) es un método de PEFT diseñado específicamente para convertir Llama en un modelo que sigue instrucciones. El modelo Llama se congela y solo se aprende un conjunto de prompts de adaptación que se prefijan a los tokens de la instrucción de entrada. Dado que los módulos inicializados aleatoriamente e insertados en el modelo pueden hacer que este pierda parte de su conocimiento existente, Llama-Adapter utiliza atención inicializada en cero con compuerta en cero para añadir progresivamente los prompts de instrucción al modelo.

El resumen del artículo es:

*Presentamos LLaMA-Adapter, un método ligero de adaptación para afinar eficientemente LLaMA en un modelo que sigue instrucciones. Utilizando 52K demostraciones de auto-instruct, LLaMA-Adapter introduce solo 1,2M de parámetros aprendibles sobre el modelo LLaMA 7B congelado, y el costo de la afinación es inferior a una hora en 8 GPUs A100. Específicamente, adoptamos un conjunto de prompts de adaptación aprendibles y los antepone a los tokens de texto de entrada en las capas superiores del transformer. A continuación, se propone un mecanismo de atención con inicialización cero y compuerta cero, que inyecta de forma adaptativa las nuevas pistas instruccionales en LLaMA, mientras que preserva eficazmente su conocimiento preentrenado. Con un entrenamiento eficiente, LLaMA-Adapter genera respuestas de alta calidad, comparables a las de Alpaca con 7B parámetros totalmente afinados. Además, nuestro enfoque puede extenderse fácilmente a entradas multimodales, p. ej., imágenes, para un LLaMA condicionado por imágenes, que logra una capacidad de razonamiento superior en ScienceQA. Publicamos nuestro código en https://github.com/ZrrSkywalker/LLaMA-Adapter*.

## Cuándo usar Llama-Adapter

Llama-Adapter es una buena opción cuando:

- Desea un checkpoint muy pequeño. Solo se entrenan y guardan los prompts de adaptación y sus puertas, lo que equivale a `adapter_layers * (adapter_len * hidden_size + 1)` parámetros.
- Estás realizando instruction-tuning en un modelo compatible (Llama, Mistral o GPT-2), el caso de uso en el que se centra el artículo.
- Deseas mantener varios adaptadores específicos para tareas para el mismo modelo base y alternar entre ellos con `set_adapter`.

## Cuándo no usar Llama-Adapter

Llama-Adapter puede no ser la mejor opción cuando:

- Tu modelo no es un modelo Llama, Mistral o GPT-2. Otras arquitecturas generan un `ValueError`. Considera usar [LoRA](./lora) en su lugar.
- Se necesita una sobrecarga de inferencia nula. El adaptador no puede fusionarse en los pesos base (`merge_and_unload()` no está soportado), por lo que cada capa adaptada atiende a `adapter_len` tokens adicionales durante la inferencia.
- Desea que varios adaptadores estén activos al mismo tiempo. Solo puede haber un adaptador activo, y los prompts de adaptación no se pueden apilar en el mismo módulo de atención.

## Resumen de las pruebas de rendimiento

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

# API

## AdaptionPromptConfig[[peft.AdaptionPromptConfig]]

#### peft.AdaptionPromptConfig[[peft.AdaptionPromptConfig]]

```python
peft.AdaptionPromptConfig(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, target_modules: str = None, adapter_len: int = None, adapter_layers: int = None)
```

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

Almacena la configuración de un [AdaptionPromptModel](/docs/peft/v0.22.0/es/package_reference/llama_adapter#peft.AdaptionPromptModel).

## AdaptionPromptModel[[peft.AdaptionPromptModel]]

#### peft.AdaptionPromptModel[[peft.AdaptionPromptModel]]

```python
peft.AdaptionPromptModel(model, configs: dict, adapter_name: str)
```

[Fuente](https://github.com/huggingface/peft/blob/v0.22.0/src/peft/tuners/adaption_prompt/model.py#L27)

Implementa prompts de adaptación tal como se describe en https://huggingface.co/papers/2303.16199.

Los módulos de atención L superiores se reemplazan con módulos AdaptedAttention que envuelven a los originales, pero insertan prompts entrenables con puertas (para inicialización en cero).

Notas sobre el patrón multi-adapter:
- Guardamos los estados de diferentes adaptadores manteniendo un diccionario de módulos AdaptedAttention indexado por el nombre del adaptador.
- Cada vez que cambiamos de adaptador, eliminamos los módulos del adaptador actualmente activo del modelo, los almacenamos en el diccionario y los reemplazamos con los módulos del nuevo adaptador.
- Para evitar un estado duplicado y potencialmente inconsistente, el adaptador activo actual siempre se elimina del diccionario.
- Desactivar el adaptador también provocaría que los módulos se eliminaran del modelo.

#### add_adapter[[peft.AdaptionPromptModel.add_adapter]]

```python
add_adapter(adapter_name: str, config: AdaptionPromptConfig)
```

[Fuente](https://github.com/huggingface/peft/blob/v0.22.0/src/peft/tuners/adaption_prompt/model.py#L62)

Añade un adaptador con el nombre y la configuración dados.

#### delete_adapter[[peft.AdaptionPromptModel.delete_adapter]]

```python
delete_adapter(adapter_name: str)
```

[Fuente](https://github.com/huggingface/peft/blob/v0.22.0/src/peft/tuners/adaption_prompt/model.py#L104)

Eliminar un adaptador con el nombre indicado.

#### disable_adapter_layers[[peft.AdaptionPromptModel.disable_adapter_layers]]

```python
disable_adapter_layers()
```

[Fuente](https://github.com/huggingface/peft/blob/v0.22.0/src/peft/tuners/adaption_prompt/model.py#L168)

Desactiva las capas de adaptador reemplazando los módulos AdaptedAttention.

#### enable_adapter_layers[[peft.AdaptionPromptModel.enable_adapter_layers]]

```python
enable_adapter_layers()
```

[Fuente](https://github.com/huggingface/peft/blob/v0.22.0/src/peft/tuners/adaption_prompt/model.py#L163)

Habilite las capas de adaptador mediante el intercambio de los módulos AdaptedAttention en caché.

#### set_adapter[[peft.AdaptionPromptModel.set_adapter]]

```python
set_adapter(adapter_name: str, inference_mode: bool = False)
```

[Fuente](https://github.com/huggingface/peft/blob/v0.22.0/src/peft/tuners/adaption_prompt/model.py#L148)

Establezca el modelo para que use el adaptador con el nombre indicado.

