PEFT documentation

Tuners

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Tuners

Un tuner (o adaptador) es un módulo que se puede conectar a un torch.nn.Module. La clase base BaseTuner para otros tuners y proporciona métodos y atributos compartidos para preparar una configuración de adaptador y reemplazar un módulo objetivo con el módulo de adaptador. BaseTunerLayer es una clase base para capas de adaptador. Ofrece métodos y atributos para gestionar adaptadores, como activar y desactivar adaptadores.

BaseTuner

clase peft.tuners.tuners_utils.BaseTuner

< >

( modelpeft_config: Union[PeftConfig, dict[str, PeftConfig]]adapter_name: strlow_cpu_mem_usage: bool = Falsestate_dict: Optional[dict[str, torch.Tensor]] = None )

Parámetros

  • model (torch.nn.Module) — El modelo al que se adjuntarán las capas del afinador de adaptadores.
  • forward (Callable) — El método forward del modelo.
  • peft_config (Union[PeftConfig, dict[str, PeftConfig]]) — El objeto de configuración del adaptador, debe ser un diccionario de str a objetos PeftConfig. También se puede pasar un objeto PeftConfig y se creará un nuevo adaptador con el nombre predeterminado adapter o se puede crear un nuevo diccionario con una clave adapter_name y un valor de esa configuración peft.
  • config (dict[str, Any]) — El objeto de configuración del modelo, debe ser un diccionario de objetos str a Any.
  • targeted_module_names (list[str]) — La lista de nombres de módulos que se adaptaron realmente. Puede ser útil para inspeccionar si deseas verificar rápidamente que los config.target_modules se especificaron correctamente.
  • targeted_parameter_names (list[str]) — La lista de nombres de parámetros que se adaptaron realmente. Puede ser útil para inspeccionar si deseas verificar rápidamente que config.target_parameters se especificaron correctamente.
  • prefix (str) — Prefijo único específico del método PEFT. Por ejemplo, "lora_" para LoRA.

Un modelo de afinador base que proporciona los métodos y atributos comunes para todos los afinadores que son inyectables en un torch.nn.Module

Para añadir una nueva clase Tuner, es necesario sobrescribir los siguientes métodos:

  • _prepare_adapter_config: Un método privado para preparar la configuración del adaptador, por ejemplo, en caso de que falte el campo target_modules.
  • _create_and_replace: Un método privado para crear y reemplazar el módulo objetivo con el módulo de adaptador.
  • _check_target_module_exists: Método auxiliar privado para comprobar si el nombre de clave del módulo pasado coincide con alguno de los módulos objetivo en adapter_config.

La forma más sencilla es revisar lo que se hace en la clase peft.tuners.lora.LoraModel.

delete_adapter

< >

( adapter_name: str )

Parámetros

  • adapter_name (str) — Nombre del adaptador que se eliminará.

Elimina un adaptador existente.

disable_adapter_layers

< >

( )

Desactiva todos los adaptadores in situ.

Al deshabilitar todos los adaptadores, la salida del modelo corresponde a la salida del modelo base.

enable_adapter_layers

< >

( )

Habilitar todos los adaptadores in situ

get_model_config

< >

( model: nn.Module )

Parámetros

  • model (nn.Module) — Modelo del que obtener la configuración.
  • default (dict|None, opcional) —: Qué devolver si el modelo no tiene un atributo config.

Este método obtiene la configuración de un modelo en forma de diccionario. Si el modelo no tiene el atributo config, este método devuelve una configuración predeterminada.

inject_adapter

< >

( model: nn.Moduleadapter_name: strautocast_adapter_dtype: bool = Truelow_cpu_mem_usage: bool = Falsestate_dict: Optional[dict[str, torch.Tensor]] = None )

Parámetros

  • model (nn.Module) — El modelo que se va a ajustar.
  • adapter_name (str) — El nombre del adaptador.
  • autocast_adapter_dtype (bool, opcional) — Si se debe aplicar autocast al dtype del adaptador. El valor predeterminado es True.
  • low_cpu_mem_usage (bool, optional, defaults to False) — Crea pesos de adaptador vacíos en el dispositivo meta. Útil para acelerar el proceso de carga.
  • state_dict (dict, opcional, valor predeterminado None) — Si se pasa un state_dict aquí, los adaptadores se inyectarán en función de las entradas del state_dict. Esto puede ser útil cuando no se conocen los target_modules exactos del método PEFT, por ejemplo, porque el punto de control se creó sin metadatos. Tenga en cuenta que no se utilizan los valores del state_dict, solo se usan las claves para determinar las capas correctas que deben adaptarse.

Crea capas de adaptador y reemplaza los módulos objetivo con las capas de adaptador. Este método se llama internamente por peft.mapping.get_peft_model si se pasa una clase de adaptador de ajuste no basado en prompts.

La configuración de PEFT correspondiente se recupera directamente del atributo peft_config de la clase BaseTuner.

merge_adapter

< >

( adapter_names: Optional[list[str]] = Nonesafe_merge: bool = False )

Parámetros

  • adapter_names (list[str], opcional) — La lista de nombres de adaptadores que deben fusionarse. Si es None, se fusionarán todos los adaptadores activos. El valor predeterminado es None.
  • safe_merge (bool, opcional) — Si es True, la operación de fusión se realizará en una copia de los pesos originales y se comprobarán los NaN antes de fusionar los pesos. Esto es útil si deseas comprobar si la operación de fusión producirá NaN. El valor predeterminado es False.

Este método fusiona las capas del adaptador en el modelo base.

La fusión de adaptadores puede acelerar la pasada hacia adelante. Se mantiene una copia de los pesos del adaptador en la memoria, lo cual es necesario para desfusionar los adaptadores. Para fusionar los pesos del adaptador sin mantenerlos en la memoria, llame a merge_and_unload.

Una vez que una capa ha fusionado los pesos del adaptador, su paso hacia adelante utiliza únicamente esos pesos. Por lo tanto, si adapter_names no cubre todos los adaptadores activos, los adaptadores activos restantes no se aplican de forma silenciosa, aunque siguen siendo reportados como activos. Fusiona todos los adaptadores activos o llama primero a unmerge_adapter. Ten en cuenta que se planea cambiar este comportamiento en la versión v1.0.

merge_and_unload

< >

( progressbar: bool = Falsesafe_merge: bool = Falseadapter_names: Optional[list[str]] = None )

Parámetros

  • progressbar (bool) — si se muestra una barra de progreso que indica el proceso de descarga y fusión (predeterminado: False).
  • safe_merge (bool) — si se debe activar la comprobación de fusión segura para verificar si hay algún Nan potencial en los pesos del adaptador.
  • adapter_names (List[str], opcional) — La lista de nombres de adaptadores que deben fusionarse. Si es None, se fusionarán todos los adaptadores activos. El valor predeterminado es None.

Este método fusiona las capas del adaptador en el modelo base.

Esto es necesario si alguien quiere usar el modelo base como un modelo independiente. El modelo devuelto tiene la misma arquitectura que el modelo base original.

Es importante asignar el modelo devuelto a una variable y usarlo, ¡esta no es una operación in situ!

Ejemplo:

>>> from transformers import AutoModelForCausalLM
>>> from peft import PeftModel

>>> model_id = ...
>>> base_model = AutoModelForCausalLM.from_pretrained(model_id)
>>> peft_model_id = ...
>>> model = PeftModel.from_pretrained(base_model, peft_model_id)
>>> merged_model = model.merge_and_unload()

set_adapter

< >

( adapter_name: str | list[str]inference_mode: bool = False )

Parámetros

  • adapter_name (str, list[str]) — El nombre de los adaptadores que se establecerán como activos
  • inference_mode (bool, opcional) — Si el adaptador activado debe congelarse (es decir, requires_grad=False). El valor predeterminado es False.

Establece el o los adaptadores activos.

set_requires_grad

< >

( adapter_names: str | Sequence[str]requires_grad: bool = True )

Parámetros

  • adapter_names (str o Sequence[str]) — El nombre del adaptador o adaptadores cuyos gradientes deben habilitarse/deshabilitarse.
  • requires_grad (bool, opcional) — Si se habilita (True, predeterminado) o deshabilita (False).

Activar o desactivar los gradientes en el o los adaptador(es) indicado(s).

supports_lora_conversion

< >

( adapter_name: str = 'default' )

Si es posible convertir el adaptador de este modelo a LoRA.

Normalmente, esto funciona si el método PEFT es aditivo, es decir, W’ = W_base + delta_weight.

descargar

< >

( )

Devuelve el modelo base eliminando todos los módulos de PEFT.

Es importante asignar el modelo devuelto a una variable y usarlo, ¡esta no es una operación in situ!

unmerge_adapter

< >

( )

Este método desune todas las capas de adaptador fusionadas del modelo base.

BaseTunerLayer

clase peft.tuners.tuners_utils.BaseTunerLayer

< >

( )

Parámetros

  • is_pluggable (bool, opcional) — Si la capa de adaptador se puede conectar a cualquier módulo de PyTorch
  • active_adapters (Union[Liststr, str], opcional) — El nombre del adaptador activo.

Un mixin de capa de tuner que proporciona los métodos y atributos comunes para todos los tuners.

delete_adapter

< >

( adapter_name: str )

Parámetros

  • adapter_name (str) — El nombre del adaptador a eliminar

Eliminar un adaptador de la capa

Esto debe llamarse en todas las capas de adaptador, de lo contrario obtendremos un estado inconsistente.

Este método también establecerá un nuevo adaptador activo si el adaptador eliminado era un adaptador activo. Es importante que el nuevo adaptador se elija de manera determinista, para que se seleccione el mismo adaptador en todas las capas.

enable_adapters

< >

( enabled: bool )

Parámetros

  • enabled (bool) — True para habilitar los adaptadores, False para deshabilitar los adaptadores

Activar y desactivar adaptadores

Se encarga de establecer la bandera requires_grad para los pesos del adaptador.

get_additive_delta

< >

( adapter_name: str = 'default' )

Parámetros

  • adapter_name (str) — El nombre del adaptador. El valor predeterminado es "default".

Devuelve el delta aditivo de peso W’ - W para el adaptador dado, donde W es el peso base y W’ es el peso después de fusionar el adaptador en el peso base. Esto significa que el peso fusionado se puede reconstruir mediante base_weight + module.get_additive_delta(adapter_name).

Para los métodos PEFT aditivos (p. ej., LoRA, LoKr, LoHa), esto es equivalente a get_delta_weight. Para los métodos multiplicativos (p. ej., OFT, BOFT), este método construye el peso efectivo W’ y resta el peso base W.

Llamar a este método mientras algún adaptador está fusionado genera un ValueError, ya que la fusión modifica el peso base, lo que haría que el valor de retorno dependa de los adaptadores fusionados actualmente. Desfusionar los adaptadores primero.

El tensor devuelto tiene el dtype de los pesos de la capa del adaptador (p. ej. lora_A para LoRA), no el dtype del peso de la capa base. Este es el dtype que utilizará el adaptador LoRA convertido.

El resultado se utiliza en convert_to_lora para realizar una aproximación basada en SVD del adaptador como un adaptador LoRA.

Por defecto, esto lanza un NotImplementedError. Los métodos de PEFT que admiten esto deben sobrescribir el método _get_additive_delta para devolver la delta aditiva.

get_base_layer

< >

( )

Obtener (recursivamente) la base_layer.

Esto es necesario para el caso en que la capa de afinador envuelva a otra capa de afinador.

get_base_weight

< >

( )

Devuelve el peso de la capa base.

Esto se encarga de descuantizar el peso, si está cuantizado.

set_adapter

< >

( adapter_names: str | list[str]inference_mode: bool = False )

Parámetros

  • adapter_names (str o list[str]) — El nombre o los nombres de los adaptadores que se establecerán como activos.
  • inference_mode (bool, opcional) — Si el adaptador activado debe congelarse (es decir, requires_grad=False). El valor predeterminado es False.

Establece el o los adaptadores activos.

Además, esta función establecerá el adaptador especificado como entrenable (es decir, requires_grad=True) a menos que inference_mode sea True.

set_base_weight

< >

( weight_data: torch.Tensor )

Establece el peso base de la capa base en el nuevo tensor

Esto también funciona con pesos cuantizados.

set_requires_grad

< >

( adapter_names: str | Sequence[str]requires_grad: bool = True )

Parámetros

  • adapter_names (str o Sequence[str]) — El nombre del adaptador o adaptadores cuyos gradientes deben habilitarse/deshabilitarse.
  • requires_grad (bool, opcional) — Si se habilita (True, predeterminado) o deshabilita (False).

Activar o desactivar los gradientes en el o los adaptador(es) indicado(s).

set_training

< >

( adapter_names: str | Sequence[str]training: bool = True )

Parámetros

  • adapter_names (str o Sequence[str]) — El nombre del adaptador o adaptadores cuyo modo de entrenamiento debe actualizarse.
  • training (bool, opcional) — Si se habilita (True, predeterminado) o deshabilita (False) el modo de entrenamiento.

Activar o desactivar el modo de entrenamiento en los módulos de adaptador dados.

supports_lora_conversion

< >

( adapter_name: str = 'default' )

Si es posible convertir este tipo de capa a LoRA.

Normalmente, esto funciona si el método PEFT es aditivo, es decir, W’ = W_base + delta_weight.

Update on GitHub