PEFT documentation
IA3
IA3
IA3 es una excelente opción cuando necesitas el tamaño de adaptador más pequeño posible: utiliza vectores aprendidos en lugar de matrices de bajo rango, lo que lo convierte en uno de los métodos más eficientes en parámetros disponibles. Si tu prioridad es una huella mínima en disco/memoria y un entrenamiento rápido, IA3 es un candidato sólido.

Infused Adapter mediante la inhibición y amplificación de las activaciones internas, o IA3, es un método que añade tres vectores aprendidos para reescalar las claves y los valores de las capas de autoatención y de atención codificador-decodificador, así como la activación intermedia de la red feed-forward por posición.
El resumen del artículo es:
El aprendizaje en contexto de pocos ejemplos (ICL) permite que los modelos de lenguaje preentrenados realicen una tarea previamente no vista sin ningún entrenamiento basado en gradientes, proporcionando un pequeño número de ejemplos de entrenamiento como parte de la entrada. El ICL incurre en costos computacionales, de memoria y de almacenamiento sustanciales, ya que implica procesar todos los ejemplos de entrenamiento cada vez que se realiza una predicción. El ajuste fino eficiente en parámetros (PEFT) (p. ej., módulos de adaptador, ajuste de prompts, métodos de actualización dispersa, etc.) ofrece un paradigma alternativo donde se entrena un pequeño conjunto de parámetros para habilitar al modelo a realizar la nueva tarea. En este artículo, comparamos rigurosamente el ICL de pocos ejemplos y el PEFT, y demostramos que este último ofrece una mejor precisión, así como costos computacionales drásticamente menores. En el proceso, introducimos un nuevo método de PEFT llamado (IA)^3 que escala las activaciones mediante vectores aprendidos, logrando un rendimiento más fuerte mientras solo introduce una cantidad relativamente pequeña de nuevos parámetros. También proponemos una receta simple basada en el modelo T0 llamada T-Few, que puede aplicarse a nuevas tareas sin ajustes o modificaciones específicos de la tarea. Validamos la efectividad de T-Few en tareas completamente no vistas aplicándolo al benchmark RAFT, logrando por primera vez un rendimiento superior al humano y superando al estado del arte en un 6% absoluto. Todo el código utilizado en nuestros experimentos está disponible públicamente.
Para hacer el ajuste fino más eficiente, IA3 (Infused Adapter by Inhibiting and Amplifying Inner Activations) reescala las activaciones internas con vectores aprendidos. Estos vectores aprendidos se inyectan en los módulos de atención y de red feedforward en una arquitectura basada en transformers típica. Estos vectores aprendidos son los únicos parámetros entrenables durante el ajuste fino, por lo que los pesos originales permanecen congelados. Trabajar con vectores aprendidos (en contraposición a actualizaciones de bajo rango aprendidas de una matriz de pesos, como en LoRA) mantiene el número de parámetros entrenables mucho menor.
Al ser similar a LoRA, IA3 presenta muchas de las mismas ventajas:
- IA3 hace que el ajuste fino sea más eficiente al reducir drásticamente el número de parámetros entrenables. (Para T0, un modelo IA3 solo tiene aproximadamente el 0,01 % de parámetros entrenables, mientras que incluso LoRA tiene > 0,1 %)
- Los pesos preentrenados originales se mantienen congelados, lo que significa que puedes tener múltiples modelos IA3 ligeros y portátiles para diversas tareas de nivel inferior construidos sobre ellos.
- El rendimiento de los modelos ajustados con IA3 es comparable al de los modelos completamente ajustados.
- IA3 no añade ninguna latencia de inferencia porque los pesos del adaptador pueden fusionarse con el modelo base.
En principio, IA3 se puede aplicar a cualquier subconjunto de matrices de pesos en una red neuronal para reducir el número de parámetros entrenables. Siguiendo la implementación de los autores, los pesos de IA3 se añaden a las capas de clave, valor y feedforward de un modelo Transformer. Para ser más específicos, en los modelos transformer, los pesos de IA3 se añaden a las salidas de las capas de clave y valor, y a la entrada de la segunda capa feedforward en cada bloque transformer.
Dadas las capas objetivo para la inyección de parámetros IA3, el número de parámetros entrenables se puede determinar en función del tamaño de las matrices de pesos.
Uso
Para los modelos autoregresivos, dirígete a
k_proj,v_projydown_proj; estos son las capas que los autores encontraron más efectivas. Establecefeedforward_modules=["down_proj"]para que IA3 sepa qué módulos son capas de feedforward y pueda aplicar la escalada correcta.
Para la tarea de clasificación de secuencias, se puede inicializar la configuración de IA3 para un modelo Llama de la siguiente manera:
from peft import IA3Config, TaskType, get_peft_model
from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained("HuggingFaceTB/SmolLM-135M")
peft_config = IA3Config(
task_type=TaskType.CAUSAL_LM,
target_modules=["k_proj", "v_proj", "down_proj"],
feedforward_modules=["down_proj"],
)
model = get_peft_model(model, peft_config)
model.print_healthcheck()Cuándo usar IA3 frente a LoRA
IA3 es particularmente eficaz cuando necesitas los adaptadores más pequeños posibles para implementaciones con restricciones de almacenamiento, o cuando buscas una convergencia rápida con menos parámetros entrenables. LoRA puede ser preferible cuando necesitas el ecosistema más amplio de variantes de LoRA (DoRA, QLoRA, etc.) o deseas el enfoque más ampliamente probado, con un amplio soporte de la comunidad.
Resumen de las pruebas de rendimiento
API
IA3Config
clase peft.IA3Config
< source >( task_type: Optional[Union[str, TaskType]] = Nonepeft_type: Optional[Union[str, PeftType]] = Noneauto_mapping: Optional[dict] = Nonepeft_version: Optional[str] = Nonebase_model_name_or_path: Optional[str] = Nonerevision: Optional[str] = Noneinference_mode: bool = Falsetarget_modules: Optional[Union[list[str], str]] = Noneexclude_modules: Optional[Union[list[str], str]] = Nonefeedforward_modules: Optional[Union[list[str], str]] = Nonefan_in_fan_out: bool = Falsemodules_to_save: Optional[list[str]] = Noneinit_ia3_weights: bool = True )
Parámetros
- target_modules (
Optional[Union[List[str], str]]) — Los nombres de los módulos a los que se aplicará el adaptador. Si se especifica, solo se reemplazarán los módulos con los nombres indicados. Al pasar una cadena de caracteres, se realizará una coincidencia mediante expresión regular. Al pasar una lista de cadenas de caracteres, se realizará una coincidencia exacta o se verificará si el nombre del módulo termina con alguna de las cadenas pasadas. Si se especifica como ‘all-linear’, se seleccionarán todos los módulos lineales/Conv1D, excluyendo la capa de salida. Si no se especifica, los módulos se elegirán según la arquitectura del modelo. Si la arquitectura no es conocida, se generará un error; en este caso, debe especificar los módulos objetivo manualmente. - exclude_modules (
Optional[Union[List[str], str]]) — Los nombres de los módulos a los que no se aplicará el adaptador. Al pasar una cadena de caracteres, se realizará una coincidencia mediante expresión regular. Al pasar una lista de cadenas de caracteres, se realizará una coincidencia exacta o se comprobará si el nombre del módulo termina con alguna de las cadenas de caracteres pasadas. - feedforward_modules (
Optional[Union[List[str], str]]) — Los nombres de los módulos que se tratarán como módulos feedforward, tal como en el artículo original. A estos módulos se les multiplicarán vectores (IA)³ a la entrada, en lugar de a la salida.feedforward_modulesdebe ser un nombre o un subconjunto de nombres presentes entarget_modules. - fan_in_fan_out (
bool) — Establezca este valor en True si la capa que se va a reemplazar almacena los pesos como (fan_in, fan_out). Por ejemplo, gpt-2 utilizaConv1D, que almacena los pesos como (fan_in, fan_out), por lo que este valor debe establecerse enTrue. - modules_to_save (
Optional[List[str]]) — Lista de módulos, aparte de las capas (IA)³, que se configurarán como entrenables y se guardarán en el punto de control final. - init_ia3_weights (
bool) — Si se inicializan los vectores en las capas (IA)³, por defecto esTrue. Se desaconseja establecerlo enFalse.
Esta es la clase de configuración para almacenar la configuración de un IA3Model.
IA3Model
clase peft.IA3Model
< source >( modelpeft_config: Union[PeftConfig, dict[str, PeftConfig]]adapter_name: strlow_cpu_mem_usage: bool = Falsestate_dict: Optional[dict[str, torch.Tensor]] = None ) → torch.nn.Module
Parámetros
- model (PreTrainedModel) — El modelo que se va a adaptar.
- config (IA3Config) — La configuración del modelo (IA)^3.
- adapter_name (
str) — El nombre del adaptador, por defecto es"default". - low_cpu_mem_usage (
bool,optional, defaults toFalse) — Crea pesos de adaptador vacíos en el dispositivo meta. Útil para acelerar el proceso de carga.
Devuelve
torch.nn.Module
El modelo (IA)^3.
Crea un modelo Infused Adapter by Inhibiting and Amplifying Inner Activations ((IA)^3) a partir de un modelo de transformers preentrenado. El método se describe en detalle en https://huggingface.co/papers/2205.05638
Ejemplo:
>>> from transformers import AutoModelForSeq2SeqLM
>>> from peft import IA3Config, get_peft_model
>>> config = IA3Config(
... peft_type="IA3",
... task_type="SEQ_2_SEQ_LM",
... target_modules=["k", "v", "w0"],
... feedforward_modules=["w0"],
... )
>>> model = AutoModelForSeq2SeqLM.from_pretrained("t5-base")
>>> ia3_model = get_peft_model(model, config)Atributos:
- model (PreTrainedModel) — El modelo que se va a adaptar.
- peft_config (IA3Config): La configuración del modelo (IA)^3.
add_weighted_adapter
< source >( adapters: list[str]weights: list[float]adapter_name: str )
Este método añade un nuevo adaptador fusionando los adaptadores dados con los pesos dados.