PEFT documentation
Tuners
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
< source >( 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 destra objetosPeftConfig. También se puede pasar un objeto PeftConfig y se creará un nuevo adaptador con el nombre predeterminadoadaptero se puede crear un nuevo diccionario con una claveadapter_namey un valor de esa configuración peft. - config (
dict[str, Any]) — El objeto de configuración del modelo, debe ser un diccionario de objetosstraAny. - 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 losconfig.target_modulesse 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 queconfig.target_parametersse 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
< source >( adapter_name: str )
Elimina un adaptador existente.
Desactiva todos los adaptadores in situ.
Al deshabilitar todos los adaptadores, la salida del modelo corresponde a la salida del modelo base.
Habilitar todos los adaptadores in situ
get_model_config
< source >( model: nn.Module )
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
< source >( 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 esTrue. - 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. - state_dict (
dict, opcional, valor predeterminadoNone) — 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 lostarget_modulesexactos 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
< source >( 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 esNone, se fusionarán todos los adaptadores activos. El valor predeterminado esNone. - safe_merge (
bool, opcional) — Si esTrue, 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 esFalse.
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
< source >( 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 esNone.
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
< source >( adapter_name: str | list[str]inference_mode: bool = False )
Establece el o los adaptadores activos.
set_requires_grad
< source >( adapter_names: str | Sequence[str]requires_grad: bool = True )
Activar o desactivar los gradientes en el o los adaptador(es) indicado(s).
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.
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!
Este método desune todas las capas de adaptador fusionadas del modelo base.
BaseTunerLayer
clase peft.tuners.tuners_utils.BaseTunerLayer
< source >( )
Un mixin de capa de tuner que proporciona los métodos y atributos comunes para todos los tuners.
delete_adapter
< source >( adapter_name: str )
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
< source >( enabled: bool )
Activar y desactivar adaptadores
Se encarga de establecer la bandera requires_grad para los pesos del adaptador.
get_additive_delta
< source >( adapter_name: str = '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.
Obtener (recursivamente) la base_layer.
Esto es necesario para el caso en que la capa de afinador envuelva a otra capa de afinador.
Devuelve el peso de la capa base.
Esto se encarga de descuantizar el peso, si está cuantizado.
set_adapter
< source >( adapter_names: str | list[str]inference_mode: bool = 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.
Establece el peso base de la capa base en el nuevo tensor
Esto también funciona con pesos cuantizados.
set_requires_grad
< source >( adapter_names: str | Sequence[str]requires_grad: bool = True )
Activar o desactivar los gradientes en el o los adaptador(es) indicado(s).
set_training
< source >( adapter_names: str | Sequence[str]training: bool = True )
Activar o desactivar el modo de entrenamiento en los módulos de adaptador dados.
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.