Hugging Face's logo

PEFT documentation

Modelos

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v0.21.0).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Modelos

PeftModel es la clase de modelo base para especificar el modelo Transformer base y la configuración a la que se aplicará un método PEFT. La clase base PeftModel contiene métodos para cargar y guardar modelos desde el Hub.

PeftModel

clase peft.PeftModel

< >

( model: torch.nn.Modulepeft_config: PeftConfigadapter_name: str = 'default'autocast_adapter_dtype: bool = Truelow_cpu_mem_usage: bool = False )

Parámetros

  • model (torch.nn.Module) — El modelo base que se va a adaptar, normalmente un modelo de Transformers.
  • peft_config (PeftConfig) — La configuración del modelo Peft.
  • adapter_name (str, opcional) — El nombre del adaptador, por defecto es "default".
  • autocast_adapter_dtype (bool, opcional, valor predeterminado True) — Indica si se debe aplicar autocast al dtype del adaptador. El valor predeterminado es True. Actualmente, esto solo convierte los pesos del adaptador usando float16 y bfloat16 a float32, ya que esto suele ser necesario para un entrenamiento estable, y solo afecta a selectos sintonizadores PEFT. Si se establece en False, los dtypes permanecerán iguales que los de la capa correspondiente.
  • low_cpu_mem_usage (bool, optional, el valor predeterminado es False) — Crea pesos de adaptador vacíos en el dispositivo meta. Útil para acelerar el proceso de carga.

    > No uses low_cpu_mem_usage=True al crear un nuevo adaptador PEFT para el entrenamiento.

Modelo base que abarca varios métodos de Peft.

Atributos:

  • base_model (torch.nn.Module) — El modelo transformer base utilizado para Peft.
  • peft_config (PeftConfig) — La configuración del modelo Peft.
  • modules_to_save (list de str) — La lista de nombres de submódulos que se deben guardar al guardar el modelo.
  • prompt_encoder (PromptEncoder) — El codificador de prompts utilizado para Peft si se usa PromptLearningConfig.
  • prompt_tokens (torch.Tensor) — Los tokens de prompt virtuales utilizados para Peft si se usa PromptLearningConfig.
  • transformer_backbone_name (str) — El nombre del backbone de transformer en el modelo base si se utiliza PromptLearningConfig.
  • word_embeddings (torch.nn.Embedding) — Las incrustaciones de palabras del esqueleto del transformador en el modelo base si se utiliza PromptLearningConfig.

add_adapter

< >

( adapter_name: strpeft_config: PeftConfiglow_cpu_mem_usage: bool = Falseautocast_adapter_dtype: bool = True )

Parámetros

  • adapter_name (str) — El nombre del adaptador que se va a añadir.
  • peft_config (PeftConfig) — La configuración del adaptador que se va a añadir.
  • low_cpu_mem_usage (bool, optional, por defecto False) — Crea pesos de adaptador vacíos en el dispositivo meta. Útil para acelerar el proceso al cargar adaptadores guardados. No uses esta opción al crear un nuevo adaptador PEFT para entrenamiento.
  • autocast_adapter_dtype (bool, opcional, valor predeterminado True) — Indica si se debe aplicar autocast al dtype del adaptador. El valor predeterminado es True. Actualmente, esto solo convierte los pesos del adaptador de float16 y bfloat16 a float32, ya que generalmente se requiere para un entrenamiento estable, y solo afecta a ciertos sintonizadores de PEFT. Si se establece en False, los dtypes permanecerán iguales que los de la capa correspondiente.

Añade un adaptador al modelo en función de la configuración pasada.

Este adaptador no está entrenado. Para cargar un adaptador entrenado, consulta PeftModel.load_adapter().

El nombre del nuevo adaptador debe ser único.

El nuevo adaptador no se establece automáticamente como el adaptador activo. Use PeftModel.set_adapter() para establecer el adaptador activo.

create_or_update_model_card

< >

( output_dir: str )

Actualice o cree la tarjeta del modelo para incluir información sobre peft:

  1. Añade la etiqueta de la biblioteca peft
  2. Añade la versión de peft
  3. Añade información del modelo base
  4. Añade información de cuantización si se utilizó

delete_adapter

< >

( adapter_name: str )

Parámetros

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

Elimina un adaptador existente.

disable_adapter

< >

( )

Gestor de contexto que deshabilita el módulo de adaptador. Úsalo para ejecutar la inferencia en el modelo base.

Ejemplo:

>>> with model.disable_adapter():
...     model(inputs)

forward

< >

( *args: Any**kwargs: Any )

Paso hacia adelante del modelo.

from_pretrained

< >

( model: torch.nn.Modulemodel_id: Union[str, os.PathLike]adapter_name: str = 'default'is_trainable: bool = Falseconfig: Optional[PeftConfig] = Noneautocast_adapter_dtype: bool = Trueephemeral_gpu_offload: bool = Falselow_cpu_mem_usage: bool = Falsekey_mapping: Optional[dict[str, str]] = None**kwargs: Any )

Parámetros

  • model (torch.nn.Module) — El modelo que se va a adaptar. Para los modelos de 🤗 Transformers, el modelo debe inicializarse con from_pretrained.
  • model_id (str o os.PathLike) — El nombre de la configuración de PEFT que se va a usar. Puede ser:
    • Una cadena de texto, el model id de una configuración PEFT alojada en un repositorio de modelos en el Hugging Face Hub.
    • Una ruta a un directorio que contiene un archivo de configuración de PEFT guardado mediante el método save_pretrained (./my_peft_config_directory/).
  • adapter_name (str, opcional, valor predeterminado "default") — El nombre del adaptador que se va a cargar. Esto es útil para cargar varios adaptadores.
  • is_trainable (bool, opcional, valor predeterminado False) — Indica si el adaptador debe ser entrenable o no. Si es False, el adaptador se congelará y solo podrá usarse para inferencia.
  • config (PeftConfig, opcional) — El objeto de configuración que se usará en lugar de una configuración cargada automáticamente. Este objeto de configuración es mutuamente excluyente con model_id y kwargs. Esto es útil cuando la configuración ya está cargada antes de llamar a from_pretrained.
  • autocast_adapter_dtype (bool, opcional, valor predeterminado True) — Indica si se debe aplicar autocast al dtype del adaptador. El valor predeterminado es True. Actualmente, esto solo convierte los pesos del adaptador de float16 y bfloat16 a float32, ya que generalmente se requiere para un entrenamiento estable, y solo afecta a ciertos sintonizadores de PEFT. Si se establece en False, los dtypes permanecerán iguales que los de la capa correspondiente.
  • ephemeral_gpu_offload (bool, opcional) — Si se debe usar el descarte temporal en GPU para módulos cargados parcialmente. El valor predeterminado es False. Esto es útil cuando partes del modelo y/o componentes (como adaptadores) se mantienen en la memoria de CPU hasta que se necesitan. En lugar de realizar operaciones costosas con datos pequeños, los datos se transfieren a la GPU bajo demanda, se realizan las operaciones y los resultados se devuelven a la memoria de CPU. Esto introduce un ligero sobrecarga momentánea de VRAM, pero proporciona una aceleración de varios órdenes de magnitud en ciertos casos.
  • low_cpu_mem_usage (bool, optional, defaults to False) — Crea pesos de adaptador vacíos en el dispositivo meta antes de cargar los pesos guardados. Útil para acelerar el proceso.
  • key_mapping (dict, opcional, valor predeterminado None) — Mapeo adicional de las claves de state_dict de PEFT que se aplica antes de cargar el state_dict. Cuando se aplica este mapeo, el prefijo específico de PEFT "base_model.model" se elimina previamente y el nombre del adaptador (p. ej. "default") aún no se inserta. Solo pase este argumento si sabe lo que está haciendo.
  • kwargs — (optional): Argumentos de palabra clave adicionales que se pasan a la clase de configuración de PEFT específica. Esto incluye torch_device (str, optional): el dispositivo en el que se cargará el adaptador (se reenvía a load_adapter[PeftModel.load_adapter]); si es None, el dispositivo se inferirá.

Instanciar un modelo PEFT a partir de un modelo preentrenado y pesos PEFT cargados.

Tenga en cuenta que el model pasado puede ser modificado in situ.

get_base_model

< >

( )

Devuelve el modelo base.

get_layer_status

< >

( ) → listpeft.peft_model.TunerLayerStatus

Devuelve

listpeft.peft_model.TunerLayerStatus

Una lista de dataclasses, cada una contiene el estado de la capa de adaptador correspondiente.

Obtén el estado de cada capa de adaptador en el modelo.

Este método devuelve una lista de instancias de la dataclass TunerLayerStatus, cada una de las cuales contiene los siguientes atributos:

  • name (str): El nombre de la capa del adaptador, p. ej. model.encoder.block.0.layer.0.SelfAttention.q.
  • module_type (str): El tipo de la capa de adaptador, p. ej. lora.Linear.
  • enabled (bool): Indica si la capa de adaptador está habilitada.
  • active_adapters (list[str]): Los nombres de los adaptadores activos, si los hay, p. ej. ["default"].
  • merged_adapters (list[str]): Los nombres de los adaptadores fusionados, si los hay, p. ej. ["default"].
  • available_adapters (list[str]): Los nombres de los adaptadores disponibles, p. ej. ["default"].
  • quantization_backend (str o None): El nombre del backend de cuantización, por ejemplo "bnb 4bit", o None si no está cuantizado.

get_model_status

< >

( ) → peft.peft_model.TunerModelStatus

Devuelve

peft.peft_model.TunerModelStatus

Un dataclass que contiene el estado del modelo.

Obtén el estado de los ajustadores del modelo.

Este método devuelve una instancia de la dataclass TunerModelStatus, que contiene los siguientes atributos:

  • base_model_type (str): El tipo del modelo base, p. ej. T5Model.
  • adapter_model_type (str): El tipo del modelo de adaptador, p. ej. LoraModel.
  • peft_types (dict[str, str]): El mapeo de nombre de adaptador a tipo de adaptador, p. ej. {"default": "LORA"}.
  • trainable_params (int): El número de parámetros entrenables en el modelo.
  • total_params (int): El número total de parámetros en el modelo.
  • num_adapter_layers (int): El número de capas de adaptador en el modelo.
  • enabled (bool, Literal["irregular"]): Indica si todas las capas de adaptador están habilitadas. Si algunas están habilitadas y otras no, este valor será "irregular". Esto significa que tu modelo se encuentra en un estado inconsistente y es posible que no funcione como se espera.
  • active_adapters (list[str], Literal["irregular"]): Los nombres de los adaptadores activos. Si los adaptadores activos no son consistentes en todas las capas, este valor será "irregular", lo que significa que tu modelo está en un estado inconsistente y podría no funcionar como se espera.
  • merged_adapters (list[str], Literal["irregular"]): Los nombres de los adaptadores fusionados. Si los adaptadores fusionados no son consistentes en todas las capas, este valor será "irregular", lo que significa que tu modelo se encuentra en un estado inconsistente y es posible que no funcione como se espera.
  • available_adapters (list[str]): Los nombres de los adaptadores disponibles, p. ej. ["default"].
  • quantization_backend (str, None, Literal["irregular"]): El nombre del backend de cuantización, p. ej. "bnb 4bit", o None si no está cuantizado. Si el backend no es consistente en todas las capas, será "irregular".

get_nb_trainable_parameters

< >

( )

Devuelve el número de parámetros entrenables y el número total de parámetros en el modelo.

get_prompt

< >

( batch_size: inttask_ids: Optional[torch.Tensor] = Nonemax_cache_len: Optional[int] = None )

Devuelve los prompts virtuales a utilizar para Peft. Solo es aplicable cuando se utiliza un método de aprendizaje de prompts.

get_prompt_embedding_to_save

< >

( adapter_name: str )

Devuelve el embedding del prompt para guardar al guardar el modelo. Solo es aplicable cuando se utiliza un método de aprendizaje de prompts.

healthcheck

< >

( min_trainable_params: int = 1max_trainable_params_percent = 50 )

Parámetros

  • min_trainable_params (int, opcional, default=1) — Número mínimo esperado de parámetros. Si se encuentran menos, se informa como un error.
  • max_trainable_params_percent (int, opcional, default=50) — El porcentaje máximo de parámetros que deben ser entrenables. Si se encuentran más de esos, se informa como una advertencia.

Comprueba este modelo en busca de estados de adaptador sospechosos antes de entrenar.

Esta función resume las APIs de estado del modelo y de las capas, e incluye hallazgos sobre el estado inconsistente de los adaptadores, adaptadores fusionados y números improbables de parámetros entrenables. No valida el bucle de entrenamiento, el optimizador ni el conjunto de datos. Se reportará un estado como "irregular" si se encuentran inconsistencias en el modelo, por ejemplo, cuando para el mismo adaptador, algunas capas están habilitadas y otras deshabilitadas. Esto casi siempre significa que algo salió mal y que debes comprobar que no modificaste accidentalmente algunos atributos del modelo de forma incorrecta.

Si la comprobación detecta algo sospechoso, se informará en el campo "findings". Una lista "findings"" vacía significa que no se detectó ningún estado de adaptador sospechoso, no que se garantice que una ejecución de entrenamiento tenga éxito.

load_adapter

< >

( model_id: Union[str, os.PathLike]adapter_name: stris_trainable: bool = Falsetorch_device: Optional[str] = Noneautocast_adapter_dtype: bool = Trueephemeral_gpu_offload: bool = Falselow_cpu_mem_usage: bool = Falsekey_mapping: Optional[dict[str, str]] = None**kwargs: Any )

Parámetros

  • model_id (str o os.PathLike) — El nombre de la configuración de PEFT que se va a usar. Puede ser:
    • Una cadena de texto, el model id de una configuración PEFT alojada en un repositorio de modelos en el Hugging Face Hub.
    • Una ruta a un directorio que contiene un archivo de configuración de PEFT guardado mediante el método save_pretrained (./my_peft_config_directory/).
  • adapter_name (str) — El nombre del adaptador que se va a añadir.
  • is_trainable (bool, opcional, valor predeterminado False) — Indica si el adaptador debe ser entrenable o no. Si es False, el adaptador se congelará y solo podrá usarse para inferencia.
  • torch_device (str, opcional, valor predeterminado None) — El dispositivo en el que se cargará el adaptador. Si es None, el dispositivo se inferirá automáticamente.
  • autocast_adapter_dtype (bool, opcional, valor predeterminado True) — Indica si se debe aplicar autocast al dtype del adaptador. El valor predeterminado es True. Actualmente, esto solo convierte los pesos del adaptador de float16 y bfloat16 a float32, ya que generalmente se requiere para un entrenamiento estable, y solo afecta a ciertos sintonizadores de PEFT. Si se establece en False, los dtypes permanecerán iguales que los de la capa correspondiente.
  • ephemeral_gpu_offload (bool, opcional, valor predeterminado False) — Si se usa el descargado temporal en GPU para módulos cargados parcialmente. El valor predeterminado es False.
  • low_cpu_mem_usage (bool, optional, defaults to False) — Crea pesos de adaptador vacíos en el dispositivo meta antes de cargar los pesos guardados. Útil para acelerar el proceso.
  • key_mapping (dict, opcional, valor predeterminado None) — Mapeo adicional de las claves de state_dict de PEFT que se aplica antes de cargar el state_dict. Cuando se aplica este mapeo, el prefijo específico de PEFT "base_model.model" se elimina previamente y el nombre del adaptador (p. ej. "default") aún no se inserta. Solo pase este argumento si sabe lo que está haciendo.
  • kwargs — (optional): Argumentos adicionales para modificar la forma en que se carga el adaptador, por ejemplo, el token para Hugging Face Hub.

Cargue un adaptador entrenado en el modelo.

El nombre del nuevo adaptador debe ser único.

El nuevo adaptador no se establece automáticamente como el adaptador activo. Use PeftModel.set_adapter() para establecer el adaptador activo.

prepare_model_for_gradient_checkpointing

< >

( model: PreTrainedModel )

Prepara el modelo para el control de puntos de control de gradiente si es necesario

Nota: En las versiones más recientes de Transformers, esto se denomina ‘activation checkpointing’.

print_healthcheck

< >

( sink = <built-in function print>min_trainable_params: int = 1max_trainable_params_percent = 50**kwargs )

Parámetros

  • sink (callable, opcional, default=print) — Función que se llama para imprimir la salida. Por defecto, es la función integrada print, pero también puede ser otra cosa, como logger.info.
  • min_trainable_params (int, opcional, default=1) — Número mínimo esperado de parámetros. Si se encuentran menos, se informa como un error.
  • max_trainable_params_percent (int, opcional, default=50) — El porcentaje máximo de parámetros que deben ser entrenables. Si se encuentran más de esos, se informa como una advertencia.
  • kwargs — Los argumentos de palabra clave adicionales se pasan a format_healthcheck.

Imprime un informe de verificación de estado compacto y legible para humanos.

La salida resume el estado de tu modelo PEFT e incluye hallazgos sobre el estado inconsistente de los adaptadores, adaptadores fusionados y números improbables de parámetros entrenables. No valida el bucle de entrenamiento, el optimizador o el conjunto de datos. Se reportará un estado como "irregular" si se encuentran inconsistencias en el modelo, por ejemplo, cuando para el mismo adaptador, algunas capas están habilitadas y otras deshabilitadas. Esto casi siempre significa que algo salió mal y que debes comprobar que no hayas cambiado accidentalmente algunos atributos del modelo de forma incorrecta.

Si se detectaron problemas, se mostrarán en la última sección bajo “findings”. Si no se detectaron problemas, no significa que se garantice que una ejecución de entrenamiento tenga éxito.

print_trainable_parameters

< >

( )

Imprime el número de parámetros entrenables en el modelo.

Nota: print_trainable_parameters() utiliza get_nb_trainable_parameters(), que es diferente de num_parameters(only_trainable=True) de huggingface/transformers. get_nb_trainable_parameters() devuelve (parámetros entrenables, todos los parámetros) del modelo Peft, que incluye el modelo transformer de base modificado. Para técnicas como LoRA, el modelo transformer de base se modifica in situ con módulos de LoRA. Sin embargo, para prompt tuning, el modelo transformer de base no se modifica. num_parameters(only_trainable=True) devuelve el número de parámetros entrenables del modelo transformer de base, lo cual puede ser diferente.

save_pretrained

< >

( save_directory: strsafe_serialization: bool = Trueselected_adapters: Optional[list[str]] = Nonesave_embedding_layers: Union[str, bool] = 'auto'is_main_process: bool = Truepath_initial_model_for_weight_conversion: Optional[str] = None**kwargs: Any )

Parámetros

  • save_directory (str) — Directorio donde se guardarán el modelo de adaptador y los archivos de configuración (se creará si no existe).
  • safe_serialization (bool, opcional) — Si se guardan los archivos de adaptador en formato safetensors, por defecto es True.
  • selected_adapters (List[str], opcional) — Una lista de adaptadores que se guardarán. Si es None, se utilizarán todos los adaptadores por defecto.
  • save_embedding_layers (Union[bool, str], opcional, valor predeterminado "auto") — Si es True, guarda las capas de embedding además de los pesos del adaptador. Si es auto, comprueba las capas de embedding comunes peft.utils.other.EMBEDDING_LAYER_NAMES en target_modules de la configuración cuando está disponible, y establece automáticamente la bandera booleana. Esto solo funciona con modelos de 🤗 transformers.
  • is_main_process (bool, opcional) — Indica si el proceso que realiza esta llamada es el proceso principal o no. El valor predeterminado es True. No se guardará el punto de control si no se está en el proceso principal, lo cual es importante en configuraciones de múltiples dispositivos (p. ej., DDP).
  • path_initial_model_for_weight_conversion (str, opcional) — La ruta al adaptador inicializado, que se obtiene después de inicializar el modelo con PiSSA/CorDA/OLoRA y antes de realizar cualquier entrenamiento. Cuando path_initial_model_for_weight_conversion no es None, se calcula la diferencia del adaptador antes y después del fine-tuning. Esta diferencia puede representarse como los parámetros de un adaptador LoRA estándar. A diferencia de PiSSA y similares, el uso de este adaptador convertido no requiere cambios en el modelo base, lo que permite de forma conveniente el uso de múltiples adaptadores PiSSA/CorDA/OLoRA junto con adaptadores LoRA, y la activación o desactivación de cualquier adaptador. Tenga en cuenta que esta conversión no se admite si se usa rslora en combinación con rank_pattern o alpha_pattern. Consulte peft.tuners.lora.LoraModel.subtract_mutated_init() para obtener más información.
  • kwargs (argumentos de palabra clave adicionales, opcional) — Argumentos de palabra clave adicionales que se pasan al método push_to_hub.

Esta función guarda el modelo de adaptador y los archivos de configuración del adaptador en un directorio, de modo que pueda recargarse mediante el método de clase PeftModel.from_pretrained() y también utilizarse por el método PeftModel.push_to_hub().

set_adapter

< >

( adapter_name: strinference_mode: bool = False )

Parámetros

  • adapter_name (str) — El nombre del adaptador que se establecerá como activo. El adaptador debe cargarse primero.
  • inference_mode (bool, opcional) — Si el adaptador activado debe congelarse (es decir, requires_grad=False). El valor predeterminado es False.

Establece el adaptador activo.

Solo puede estar activo un adaptador a la vez, ya que no todos los métodos de PEFT admiten múltiples adaptadores activos. Para activar varios adaptadores en los métodos compatibles, use model.base_model.set_adapter(adapter_names).

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

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).

Nota: No se admite para métodos de aprendizaje de prompts como prompt tuning.

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.

PeftModelForSequenceClassification

Un PeftModel para tareas de clasificación de secuencias.

clase peft.PeftModelForSequenceClassification

< >

( model: torch.nn.Modulepeft_config: PeftConfigadapter_name: str = 'default'**kwargs )

Parámetros

  • model (PreTrainedModel) — Modelo transformer base.
  • peft_config (PeftConfig) — Configuración de Peft.
  • adapter_name (str, opcional) — El nombre del adaptador, por defecto es "default".
  • autocast_adapter_dtype (bool, opcional, valor predeterminado True) — Indica si se debe aplicar autocast al dtype del adaptador. El valor predeterminado es True. Actualmente, esto solo convierte los pesos del adaptador usando float16 y bfloat16 a float32, ya que esto suele ser necesario para un entrenamiento estable, y solo afecta a selectos sintonizadores PEFT. Si se establece en False, los dtypes permanecerán iguales que los de la capa correspondiente.

Modelo Peft para tareas de clasificación de secuencias.

Atributos:

  • config (PretrainedConfig) — El objeto de configuración del modelo base.
  • cls_layer_name (str) — El nombre de la capa de clasificación.

Ejemplo:

>>> from transformers import AutoModelForSequenceClassification
>>> from peft import PeftModelForSequenceClassification, get_peft_config

>>> config = {
...     "peft_type": "PREFIX_TUNING",
...     "task_type": "SEQ_CLS",
...     "inference_mode": False,
...     "num_virtual_tokens": 20,
...     "token_dim": 768,
...     "num_transformer_submodules": 1,
...     "num_attention_heads": 12,
...     "num_layers": 12,
...     "encoder_hidden_size": 768,
...     "prefix_projection": False,
... }

>>> peft_config = get_peft_config(config)
>>> model = AutoModelForSequenceClassification.from_pretrained("bert-base-cased")
>>> peft_model = PeftModelForSequenceClassification(model, peft_config)
>>> peft_model.print_trainable_parameters()
trainable params: 370178 || all params: 108680450 || trainable%: 0.3406113979101117

PeftModelForTokenClassification

Un PeftModel para tareas de clasificación de tokens.

clase peft.PeftModelForTokenClassification

< >

( model: torch.nn.Modulepeft_config: PeftConfig = Noneadapter_name: str = 'default'**kwargs )

Parámetros

  • model (PreTrainedModel) — Modelo transformer base.
  • peft_config (PeftConfig) — Configuración de Peft.
  • adapter_name (str, opcional) — El nombre del adaptador, por defecto es "default".
  • autocast_adapter_dtype (bool, opcional, valor predeterminado True) — Indica si se debe aplicar autocast al dtype del adaptador. El valor predeterminado es True. Actualmente, esto solo convierte los pesos del adaptador usando float16 y bfloat16 a float32, ya que esto suele ser necesario para un entrenamiento estable, y solo afecta a selectos sintonizadores PEFT. Si se establece en False, los dtypes permanecerán iguales que los de la capa correspondiente.

Modelo Peft para tareas de clasificación de tokens.

Atributos:

  • config (PretrainedConfig) — El objeto de configuración del modelo base.
  • cls_layer_name (str) — El nombre de la capa de clasificación.

Ejemplo:

>>> from transformers import AutoModelForTokenClassification
>>> from peft import PeftModelForTokenClassification, get_peft_config

>>> config = {
...     "peft_type": "PREFIX_TUNING",
...     "task_type": "TOKEN_CLS",
...     "inference_mode": False,
...     "num_virtual_tokens": 20,
...     "token_dim": 768,
...     "num_transformer_submodules": 1,
...     "num_attention_heads": 12,
...     "num_layers": 12,
...     "encoder_hidden_size": 768,
...     "prefix_projection": False,
... }

>>> peft_config = get_peft_config(config)
>>> model = AutoModelForTokenClassification.from_pretrained("bert-base-cased")
>>> peft_model = PeftModelForTokenClassification(model, peft_config)
>>> peft_model.print_trainable_parameters()
trainable params: 370178 || all params: 108680450 || trainable%: 0.3406113979101117

add_adapter

< >

( adapter_name: strpeft_config: PeftConfiglow_cpu_mem_usage: bool = Falseautocast_adapter_dtype: bool = True )

Parámetros

  • adapter_name (str) — El nombre del adaptador que se va a añadir.
  • peft_config (PeftConfig) — La configuración del adaptador que se va a añadir.
  • low_cpu_mem_usage (bool, optional, por defecto False) — Crea pesos de adaptador vacíos en el dispositivo meta. Útil para acelerar el proceso al cargar adaptadores guardados. No uses esta opción al crear un nuevo adaptador PEFT para entrenamiento.
  • autocast_adapter_dtype (bool, opcional, valor predeterminado True) — Indica si se debe aplicar autocast al dtype del adaptador. El valor predeterminado es True. Actualmente, esto solo convierte los pesos del adaptador de float16 y bfloat16 a float32, ya que generalmente se requiere para un entrenamiento estable, y solo afecta a ciertos sintonizadores de PEFT. Si se establece en False, los dtypes permanecerán iguales que los de la capa correspondiente.

Añade un adaptador al modelo en función de la configuración pasada.

Este adaptador no está entrenado. Para cargar un adaptador entrenado, consulta PeftModel.load_adapter().

El nombre del nuevo adaptador debe ser único.

El nuevo adaptador no se establece automáticamente como el adaptador activo. Use PeftModel.set_adapter() para establecer el adaptador activo.

PeftModelForCausalLM

Un PeftModel para el modelado de lenguaje causal.

clase peft.PeftModelForCausalLM

< >

( model: torch.nn.Modulepeft_config: PeftConfigadapter_name: str = 'default'**kwargs )

Parámetros

  • model (PreTrainedModel) — Modelo transformer base.
  • peft_config (PeftConfig) — Configuración de Peft.
  • adapter_name (str, opcional) — El nombre del adaptador, por defecto es "default".
  • autocast_adapter_dtype (bool, opcional, valor predeterminado True) — Indica si se debe aplicar autocast al dtype del adaptador. El valor predeterminado es True. Actualmente, esto solo convierte los pesos del adaptador usando float16 y bfloat16 a float32, ya que esto suele ser necesario para un entrenamiento estable, y solo afecta a selectos sintonizadores PEFT. Si se establece en False, los dtypes permanecerán iguales que los de la capa correspondiente.

Modelo Peft para modelado de lenguaje causal.

Ejemplo:

>>> from transformers import AutoModelForCausalLM
>>> from peft import PeftModelForCausalLM, get_peft_config

>>> config = {
...     "peft_type": "PREFIX_TUNING",
...     "task_type": "CAUSAL_LM",
...     "inference_mode": False,
...     "num_virtual_tokens": 20,
...     "token_dim": 1280,
...     "num_transformer_submodules": 1,
...     "num_attention_heads": 20,
...     "num_layers": 36,
...     "encoder_hidden_size": 1280,
...     "prefix_projection": False,
... }

>>> peft_config = get_peft_config(config)
>>> model = AutoModelForCausalLM.from_pretrained("gpt2-large")
>>> peft_model = PeftModelForCausalLM(model, peft_config)
>>> peft_model.print_trainable_parameters()
trainable params: 1843200 || all params: 775873280 || trainable%: 0.23756456724479544

PeftModelForSeq2SeqLM

Un PeftModel para el modelado de lenguaje de secuencia a secuencia.

Nota: esto generará automáticamente los tokens de entrada del decodificador desplazando los tokens de entrada un paso a la derecha con shift_tokens_right() si proporciona tokens de entrada pero no proporciona tokens de entrada del decodificador explícitamente.

clase peft.PeftModelForSeq2SeqLM

< >

( model: torch.nn.Modulepeft_config: PeftConfigadapter_name: str = 'default'**kwargs )

Parámetros

  • model (PreTrainedModel) — Modelo transformer base.
  • peft_config (PeftConfig) — Configuración de Peft.
  • adapter_name (str, opcional) — El nombre del adaptador, por defecto es "default".
  • autocast_adapter_dtype (bool, opcional, valor predeterminado True) — Indica si se debe aplicar autocast al dtype del adaptador. El valor predeterminado es True. Actualmente, esto solo convierte los pesos del adaptador usando float16 y bfloat16 a float32, ya que esto suele ser necesario para un entrenamiento estable, y solo afecta a selectos sintonizadores PEFT. Si se establece en False, los dtypes permanecerán iguales que los de la capa correspondiente.

Modelo Peft para modelado de lenguaje de secuencia a secuencia.

Ejemplo:

>>> from transformers import AutoModelForSeq2SeqLM
>>> from peft import PeftModelForSeq2SeqLM, get_peft_config

>>> config = {
...     "peft_type": "LORA",
...     "task_type": "SEQ_2_SEQ_LM",
...     "inference_mode": False,
...     "r": 8,
...     "target_modules": ["q", "v"],
...     "lora_alpha": 32,
...     "lora_dropout": 0.1,
...     "fan_in_fan_out": False,
...     "bias": "none",
... }

>>> peft_config = get_peft_config(config)
>>> model = AutoModelForSeq2SeqLM.from_pretrained("t5-base")
>>> peft_model = PeftModelForSeq2SeqLM(model, peft_config)
>>> peft_model.print_trainable_parameters()
trainable params: 884736 || all params: 223843584 || trainable%: 0.3952474242013566

PeftModelForQuestionAnswering

Un PeftModel para la respuesta a preguntas.

clase peft.PeftModelForQuestionAnswering

< >

( model: torch.nn.Modulepeft_config: PeftConfigadapter_name: str = 'default'**kwargs )

Parámetros

  • model (PreTrainedModel) — Modelo transformer base.
  • peft_config (PeftConfig) — Configuración de Peft.
  • adapter_name (str, opcional) — El nombre del adaptador, por defecto es "default".
  • autocast_adapter_dtype (bool, opcional, valor predeterminado True) — Indica si se debe aplicar autocast al dtype del adaptador. El valor predeterminado es True. Actualmente, esto solo convierte los pesos del adaptador usando float16 y bfloat16 a float32, ya que esto suele ser necesario para un entrenamiento estable, y solo afecta a selectos sintonizadores PEFT. Si se establece en False, los dtypes permanecerán iguales que los de la capa correspondiente.

Modelo Peft para respuesta a preguntas extractiva.

Atributos:

  • config (PretrainedConfig) — El objeto de configuración del modelo base.
  • cls_layer_name (str) — El nombre de la capa de clasificación.

Ejemplo:

>>> from transformers import AutoModelForQuestionAnswering
>>> from peft import PeftModelForQuestionAnswering, get_peft_config

>>> config = {
...     "peft_type": "LORA",
...     "task_type": "QUESTION_ANS",
...     "inference_mode": False,
...     "r": 16,
...     "target_modules": ["query", "value"],
...     "lora_alpha": 32,
...     "lora_dropout": 0.05,
...     "fan_in_fan_out": False,
...     "bias": "none",
... }

>>> peft_config = get_peft_config(config)
>>> model = AutoModelForQuestionAnswering.from_pretrained("bert-base-cased")
>>> peft_model = PeftModelForQuestionAnswering(model, peft_config)
>>> peft_model.print_trainable_parameters()
trainable params: 592900 || all params: 108312580 || trainable%: 0.5473971721475013

add_adapter

< >

( adapter_name: strpeft_config: PeftConfiglow_cpu_mem_usage: bool = Falseautocast_adapter_dtype: bool = True )

Parámetros

  • adapter_name (str) — El nombre del adaptador que se va a añadir.
  • peft_config (PeftConfig) — La configuración del adaptador que se va a añadir.
  • low_cpu_mem_usage (bool, optional, por defecto False) — Crea pesos de adaptador vacíos en el dispositivo meta. Útil para acelerar el proceso al cargar adaptadores guardados. No uses esta opción al crear un nuevo adaptador PEFT para entrenamiento.
  • autocast_adapter_dtype (bool, opcional, valor predeterminado True) — Indica si se debe aplicar autocast al dtype del adaptador. El valor predeterminado es True. Actualmente, esto solo convierte los pesos del adaptador de float16 y bfloat16 a float32, ya que generalmente se requiere para un entrenamiento estable, y solo afecta a ciertos sintonizadores de PEFT. Si se establece en False, los dtypes permanecerán iguales que los de la capa correspondiente.

Añade un adaptador al modelo en función de la configuración pasada.

Este adaptador no está entrenado. Para cargar un adaptador entrenado, consulta PeftModel.load_adapter().

El nombre del nuevo adaptador debe ser único.

El nuevo adaptador no se establece automáticamente como el adaptador activo. Use PeftModel.set_adapter() para establecer el adaptador activo.

PeftModelForFeatureExtraction

Un PeftModel para extraer características/embeddings de modelos transformer.

clase peft.PeftModelForFeatureExtraction

< >

( model: torch.nn.Modulepeft_config: PeftConfigadapter_name: str = 'default'**kwargs )

Parámetros

  • model (PreTrainedModel) — Modelo transformer base.
  • peft_config (PeftConfig) — Configuración de Peft.
  • adapter_name (str, opcional) — El nombre del adaptador, por defecto es "default".
  • autocast_adapter_dtype (bool, opcional, valor predeterminado True) — Indica si se debe aplicar autocast al dtype del adaptador. El valor predeterminado es True. Actualmente, esto solo convierte los pesos del adaptador usando float16 y bfloat16 a float32, ya que esto suele ser necesario para un entrenamiento estable, y solo afecta a selectos sintonizadores PEFT. Si se establece en False, los dtypes permanecerán iguales que los de la capa correspondiente.

Modelo Peft para extraer características/embeddings de modelos transformer

Atributos:

  • config (PretrainedConfig) — El objeto de configuración del modelo base.

Ejemplo:

>>> from transformers import AutoModel
>>> from peft import PeftModelForFeatureExtraction, get_peft_config

>>> config = {
...     "peft_type": "LORA",
...     "task_type": "FEATURE_EXTRACTION",
...     "inference_mode": False,
...     "r": 16,
...     "target_modules": ["query", "value"],
...     "lora_alpha": 32,
...     "lora_dropout": 0.05,
...     "fan_in_fan_out": False,
...     "bias": "none",
... }
>>> peft_config = get_peft_config(config)
>>> model = AutoModel.from_pretrained("bert-base-cased")
>>> peft_model = PeftModelForFeatureExtraction(model, peft_config)
>>> peft_model.print_trainable_parameters()

PeftMixedModel

Un PeftModel para mezclar diferentes tipos de adaptadores (p. ej., LoRA y LoHa).

clase peft.PeftMixedModel

< >

( model: nn.Modulepeft_config: PeftConfigadapter_name: str = 'default' )

Parámetros

  • model (torch.nn.Module) — El modelo que se va a ajustar.
  • config (PeftConfig) — La configuración del modelo que se va a ajustar. El tipo de adaptador debe ser compatible.
  • adapter_name (str, optional, por defecto "default") — El nombre del primer adaptador.
  • 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.

PeftMixedModel para cargar y mezclar diferentes tipos de adaptadores para inferencia.

Esta clase no admite la carga ni el guardado, y normalmente no debería inicializarse directamente. En su lugar, use get_peft_model con el argumento mixed=True.

> Lea la guía Tipos de adaptadores mixtos para obtener > más información sobre el uso de diferentes tipos de adaptadores.

Ejemplo:

>>> base_model = ...  # load the base model, e.g. from transformers
>>> peft_model = PeftMixedModel.from_pretrained(base_model, path_to_adapter1, "adapter1").eval()
>>> peft_model.load_adapter(path_to_adapter2, "adapter2")
>>> peft_model.set_adapter(["adapter1", "adapter2"])  # activate both adapters
>>> peft_model(data)  # forward pass using both adapters

add_adapter

< >

( adapter_name: strpeft_config: PeftConfiglow_cpu_mem_usage: bool = Falseautocast_adapter_dtype: bool = True )

Parámetros

  • adapter_name (str) — El nombre del adaptador que se va a añadir.
  • peft_config (PeftConfig) — La configuración del adaptador que se va a añadir.
  • low_cpu_mem_usage (bool, optional, por defecto es False) — Crea pesos de adaptador vacíos en el dispositivo meta. Útil para acelerar el proceso al cargar adaptadores guardados.

    > No utilice low_cpu_mem_usage=True al crear un nuevo adaptador PEFT para el entrenamiento (el entrenamiento no está probado > y se desaconseja en general para PeftMixedModel).

  • autocast_adapter_dtype (bool, opcional, valor predeterminado True) — Indica si se debe aplicar autocast al dtype del adaptador. El valor predeterminado es True. Actualmente, esto solo convierte los pesos del adaptador de float16 y bfloat16 a float32, ya que generalmente se requiere para un entrenamiento estable, y solo afecta a ciertos sintonizadores de PEFT. Si se establece en False, los dtypes permanecerán iguales que los de la capa correspondiente.

Añade un adaptador al modelo en función de la configuración pasada.

Este adaptador no está entrenado. Para cargar un adaptador entrenado, consulta PeftModel.load_adapter().

El nombre del nuevo adaptador debe ser único.

El nuevo adaptador no se establece automáticamente como el adaptador activo. Use PeftModel.set_adapter() para establecer el adaptador activo.

disable_adapter

< >

( )

Desactiva el módulo de adaptador.

forward

< >

( *args: Any**kwargs: Any )

Paso hacia adelante del modelo.

from_pretrained

< >

( model: nn.Modulemodel_id: str | os.PathLikeadapter_name: str = 'default'is_trainable: bool = Falseconfig: Optional[PeftConfig] = None**kwargs: Any )

Parámetros

  • model (nn.Module) — El modelo que se va a adaptar.
  • model_id (str o os.PathLike) — El nombre de la configuración de PEFT que se va a usar. Puede ser:
    • Una cadena de texto, el model id de una configuración PEFT alojada en un repositorio de modelos en el Hugging Face Hub.
    • Una ruta a un directorio que contiene un archivo de configuración de PEFT guardado mediante el método save_pretrained (./my_peft_config_directory/).
  • adapter_name (str, opcional, valor predeterminado "default") — El nombre del adaptador que se va a cargar. Esto es útil para cargar varios adaptadores.
  • is_trainable (bool, opcional, valor predeterminado False) — Indica si el adaptador debe ser entrenable o no. Si es False, el adaptador se congelará y se usará para la inferencia
  • config (PeftConfig, opcional) — El objeto de configuración que se usará en lugar de una configuración cargada automáticamente. Este objeto de configuración es mutuamente excluyente con model_id y kwargs. Esto es útil cuando la configuración ya está cargada antes de llamar a from_pretrained.
  • low_cpu_mem_usage (bool, optional, defaults to False) — Crea pesos de adaptador vacíos en el dispositivo meta antes de cargar los pesos guardados. Útil para acelerar el proceso.
  • kwargs — (optional): Additional keyword arguments passed along to the specific PEFT configuration class.

Instanciar un modelo PEFT mixto a partir de un modelo preentrenado y pesos PEFT cargados.

Tenga en cuenta que el model pasado puede ser modificado in situ.

generate

< >

( *args: Any**kwargs: Any )

Generar la salida.

get_nb_trainable_parameters

< >

( )

Devuelve el número de parámetros entrenables y el número total de parámetros en el modelo.

load_adapter

< >

( model_id: stradapter_name: str*args: Any**kwargs: Any )

Parámetros

  • adapter_name (str) — El nombre del adaptador que se va a añadir.
  • peft_config (PeftConfig) — La configuración del adaptador que se va a añadir.
  • is_trainable (bool, opcional, valor predeterminado False) — Indica si el adaptador debe ser entrenable o no. Si es False, el adaptador se congelará y solo podrá usarse para inferencia.
  • torch_device (str, opcional, valor predeterminado None) — El dispositivo en el que se cargará el adaptador. Si es None, el dispositivo se inferirá automáticamente.
  • autocast_adapter_dtype (bool, opcional, valor predeterminado True) — Indica si se debe aplicar autocast al tipo de datos del adaptador. El valor predeterminado es True. Actualmente, esto solo convierte los pesos del adaptador de float16 y bfloat16 a float32, ya que generalmente se requiere para un entrenamiento estable, y solo afecta a ciertos sintonizadores de PEFT.
  • ephemeral_gpu_offload (bool, opcional, valor predeterminado False) — Si se usa el descargado temporal en GPU para módulos cargados parcialmente. El valor predeterminado es False.
  • low_cpu_mem_usage (bool, optional, defaults to False) — Crea pesos de adaptador vacíos en el dispositivo meta antes de cargar los pesos guardados. Útil para acelerar el proceso.
  • kwargs — (optional): Argumentos adicionales para modificar la forma en que se carga el adaptador, por ejemplo, el token para Hugging Face Hub.

Cargue un adaptador entrenado en el modelo.

El nombre del nuevo adaptador debe ser único.

El nuevo adaptador no se establece automáticamente como el adaptador activo. Use PeftModel.set_adapter() para establecer el adaptador activo.

merge_and_unload

< >

( *args: Any**kwargs: Any )

Parámetros

  • progressbar (bool) — si se muestra una barra de progreso que indica el proceso de descarga y fusión
  • 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.

print_trainable_parameters

< >

( )

Imprime el número de parámetros entrenables en el modelo.

Nota: print_trainable_parameters() utiliza get_nb_trainable_parameters(), que es diferente de num_parameters(only_trainable=True) de huggingface/transformers. get_nb_trainable_parameters() devuelve (parámetros entrenables, todos los parámetros) del modelo Peft, que incluye el modelo transformer de base modificado. Para técnicas como LoRA, el modelo transformer de base se modifica in situ con módulos de LoRA. Sin embargo, para prompt tuning, el modelo transformer de base no se modifica. num_parameters(only_trainable=True) devuelve el número de parámetros entrenables del modelo transformer de base, lo cual puede ser diferente.

set_adapter

< >

( adapter_name: Union[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 para el modelo.

Tenga en cuenta que el orden en que se aplican los adaptadores durante la pasada hacia adelante puede no ser el mismo que el orden en que se pasan a esta función. En su lugar, el orden durante la pasada hacia adelante lo determina el orden en que los adaptadores se cargaron en el modelo. Los adaptadores activos solo determinan qué adaptadores están activos durante la pasada hacia adelante, pero no el orden en que se aplican.

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

descargar

< >

( *args: Any**kwargs: Any )

Recupera el modelo base eliminando todos los módulos de adaptador sin fusionarlos. Esto devuelve el modelo base original.

Utilidades

peft.cast_mixed_precision_params

< >

( model: torch.nn.Moduledtype: torch.dtype )

Parámetros

  • model (torch.nn.Module) — El modelo del que se deben convertir los parámetros no entrenables.
  • dtype (torch.dtype) — El dtype al que se deben convertir los parámetros no entrenables. El dtype puede ser torch.float16 o

Convierte todos los parámetros no entrenables del modelo al dtype indicado. El dtype puede ser torch.float16 o torch.bfloat16, según el entrenamiento de precisión mixta que estés realizando. Los parámetros entrenables se convierten a precisión completa. Esto está diseñado para reducir el uso de memoria de GPU al usar métodos PEFT, empleando un dtype de media precisión para los parámetros no entrenables. Mantener los parámetros entrenables en precisión completa preserva la estabilidad del entrenamiento al usar entrenamiento de precisión mixta automática.

torch.bfloat16 según el entrenamiento de precisión mixta que estás realizando.

peft.get_peft_model

< >

( model: nn.Modulepeft_config: PeftConfigadapter_name: str = 'default'mixed: bool = Falseautocast_adapter_dtype: bool = Truerevision: Optional[str] = Nonelow_cpu_mem_usage: bool = False )

Parámetros

  • model (torch.nn.Module) — Modelo que se va a envolver. Por lo general, se trata de un modelo de Transformers, pero cualquier nn.Module puede funcionar, con la salvedad de que las funciones específicas de la tarea (peft_config.task_type) requieren que el modelo siga las convenciones de Transformers.
  • peft_config (PeftConfig) — Objeto de configuración que contiene los parámetros del modelo Peft.
  • adapter_name (str, optional, por defecto "default") — El nombre del adaptador que se va a inyectar; si no se proporciona, se utiliza el nombre de adaptador predeterminado (“default”).
  • mixed (bool, optional, por defecto False) — Si se permite mezclar diferentes tipos de adaptadores (compatibles).
  • autocast_adapter_dtype (bool, opcional) — Si se debe aplicar autocast al dtype del adaptador. El valor predeterminado es True. Por ahora, esto solo convertirá los pesos del adaptador usando float16 o bfloat16 a float32, ya que esto suele ser necesario para un entrenamiento estable, y solo afectará a selectos sintonizadores PEFT.
  • revision (str, optional, por defecto main) — La revisión del modelo base. Si no se establece, el modelo peft guardado cargará la revisión main del modelo base
  • 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. Deja esta configuración en False si tienes la intención de entrenar el modelo, a menos que los pesos del adaptador se reemplacen por pesos diferentes antes de que comience el entrenamiento.

Devuelve un objeto de modelo Peft a partir de un modelo y una configuración, donde el modelo se modificará in situ.

peft.inject_adapter_in_model

< >

( peft_config: PeftConfigmodel: torch.nn.Moduleadapter_name: str = 'default'low_cpu_mem_usage: bool = Falsestate_dict: Optional[dict[str, torch.Tensor]] = None )

Parámetros

  • peft_config (PeftConfig) — Objeto de configuración que contiene los parámetros del modelo PEFT.
  • model (torch.nn.Module) — El modelo de entrada donde se inyectará el adaptador.
  • adapter_name (str, optional, por defecto "default") — El nombre del adaptador que se va a inyectar; si no se proporciona, se utiliza el nombre de adaptador predeterminado (“default”).
  • 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 utilizan las claves para determinar las capas correctas que deben adaptarse.

Crea capas PEFT e inyéctalas en el modelo in-place.

Actualmente, la API no admite métodos de aprendizaje de prompts, adaption prompt ni tuners que mantengan el estado del adaptador compartido entre múltiples capas objetivo. Utilice get_peft_model() para estos últimos.

Esta función es similar a get_peft_model() pero no devuelve una instancia de PeftModel. En su lugar, devuelve la instancia original, modificada, del modelo pasado.

peft.get_peft_model_state_dict

< >

( modelstate_dict = Noneadapter_name: str = 'default'unwrap_compiled: bool = Falsesave_embedding_layers: bool | Literal['auto'] = 'auto' )

Parámetros

  • model (PeftModel) — El modelo Peft. Al usar torch.nn.DistributedDataParallel, DeepSpeed o FSDP, el modelo debe ser el modelo subyacente/modelo sin envolver (es decir, model.module).
  • state_dict (dict, opcional, valor predeterminado None) — El state dict del modelo. Si no se proporciona, se utilizará el state dict del modelo pasado.
  • adapter_name (str, opcional, valor predeterminado "default") — El nombre del adaptador cuyo state dict debe devolverse.
  • unwrap_compiled (bool, opcional, valor predeterminado False) — Si se usó torch.compile, si se debe quitar el envoltorio del modelo.
  • save_embedding_layers (Union[bool, str], , opcional, valor predeterminado auto) — Si es True, guarda las capas de embedding además de los pesos del adaptador. Si es auto, comprueba las capas de embedding comunes peft.utils.other.EMBEDDING_LAYER_NAMES en target_modules de la configuración cuando está disponible. En base a ello, establece la bandera booleana. Esto solo funciona con modelos de 🤗 transformers.

Obtenga el state dict del adaptador dado del modelo PEFT.

Esto solo incluye los parámetros de PEFT, no los parámetros del modelo base. Por lo tanto, el state_dict devuelto es generalmente pequeño en comparación con el tamaño total del modelo. Para obtener el state_dict completo, simplemente llama a model.state_dict().

Tenga en cuenta que el nombre del adaptador se elimina de state_dict, ya que es solo un nombre arbitrario que puede cambiarse al cargar el adaptador. Por lo tanto, por ejemplo, si el nombre del adaptador es 'default' y la clave original es 'model.q_proj.lora_A.default.weight', la clave devuelta será 'model.q_proj.lora_A.weight'. Use esta función junto con set_peft_model_state_dict() para gestionar el nombre del adaptador al cargar los pesos.

peft.prepare_model_for_kbit_training

< >

( modeluse_gradient_checkpointing = Trueactivation_checkpointing_kwargs = Noneauto_clear_cache = Truegradient_checkpointing_kwargs = None )

Parámetros

  • model (transformers.PreTrainedModel) — El modelo cargado desde transformers
  • use_gradient_checkpointing (bool, opcional, valor predeterminado True) — Si es True, usa gradient checkpointing para ahorrar memoria a costa de una pasada inversa más lenta.
  • activation_checkpointing_kwargs (dict, opcional, valor predeterminado None) — Argumentos de palabra clave para pasar a la función de checkpointing de activaciones. Consulte la documentación de torch.utils.checkpoint.checkpoint para obtener más detalles sobre los argumentos que puede pasar a ese método. Tenga en cuenta que esto solo está disponible en las versiones de transformers (> 4.34.1).
  • auto_clear_cache (bool, opcional, valor predeterminado True) — Si se debe vaciar la caché del acelerador después de convertir los parámetros a fp32. Esto libera la memoria retenida por el asignador de caché, lo cual es especialmente útil en dispositivos que comparten memoria de host y acelerador. Establezca False para omitir este paso.
  • gradient_checkpointing_kwargs (dict, opcional, valor predeterminado None) — Argumentos de palabra clave para pasar a la función de checkpointing de activaciones. Este argumento existe solo por compatibilidad con versiones anteriores y está en desuso, utilice activation_checkpointing_kwargs en su lugar. Se eliminará en PEFT v1.2.

Tenga en cuenta que este método solo funciona para modelos de transformers.

Este método encapsula todo el protocolo para preparar un modelo antes de ejecutar un entrenamiento. Esto incluye: 1- Convertir el layernorm a fp32 2- Hacer que la capa de output embedding requiera grads 3- Agregar el upcasting de la lm head a fp32 4- Congelar las capas del modelo base para asegurar que no se actualicen durante el entrenamiento

peft.get_layer_status

< >

( model: torch.nn.Module ) → listpeft.peft_model.TunerLayerStatus

Parámetros

  • model ([Union[~PeftModel, ~transformers.PreTrainedModel, nn.Module]]) — El modelo del que se obtiene el estado de la capa de adaptador.

Devuelve

listpeft.peft_model.TunerLayerStatus

Una lista de dataclasses, cada una contiene el estado de la capa de adaptador correspondiente.

Obtén el estado de cada capa de adaptador en el modelo.

Esta función devuelve una lista de instancias de la dataclass TunerLayerStatus, cada una de las cuales contiene los siguientes atributos:

  • name (str): El nombre de la capa del adaptador, p. ej. model.encoder.block.0.layer.0.SelfAttention.q.
  • module_type (str): El tipo de la capa de adaptador, p. ej. lora.Linear.
  • enabled (bool): Indica si la capa de adaptador está habilitada.
  • active_adapters (list[str]): Los nombres de los adaptadores activos, si los hay, p. ej. ["default"].
  • merged_adapters (list[str]): Los nombres de los adaptadores fusionados, si los hay, p. ej. ["default"].
  • requires_grad : dict[str, bool | Literal[“irregular”]] El estado de requires_grad de los parámetros de cada módulo de adaptador. Idealmente, debería ser True o False. Si el estado de requires_grad no es coherente entre todos los parámetros, el valor se establecerá en "irregular".
  • available_adapters (list[str]): Los nombres de los adaptadores disponibles, p. ej. ["default"].
  • devices (dict[str, list[str]]): Los dispositivos donde se almacenan los parámetros del adaptador dado, p. ej. ["cuda","xpu"].
  • quantization_backend (str o None): El nombre del backend de cuantización, por ejemplo "bnb 4bit", o None si no está cuantizado.

peft.get_model_status

< >

( model: torch.nn.Module ) → peft.peft_model.TunerModelStatus

Parámetros

  • model ([Union[~PeftModel, ~transformers.PreTrainedModel, nn.Module]]) — El modelo del que se obtiene el estado de la capa de adaptador.

Devuelve

peft.peft_model.TunerModelStatus

Un dataclass que contiene el estado del modelo.

Obtén el estado de los ajustadores del modelo.

Esta función devuelve una instancia de la dataclass TunerModelStatus, que contiene los siguientes atributos:

  • base_model_type (str): El tipo del modelo base, p. ej. T5Model.
  • adapter_model_type (str): El tipo del modelo de adaptador, p. ej. LoraModel.
  • peft_types (dict[str, str]): El mapeo de nombre de adaptador a tipo de adaptador, p. ej. {"default": "LORA"}.
  • trainable_params (int): El número de parámetros entrenables en el modelo.
  • total_params (int): El número total de parámetros en el modelo.
  • num_adapter_layers (int): El número de capas de adaptador en el modelo.
  • enabled (bool, Literal["irregular"]): Indica si todas las capas de adaptador están habilitadas. Si algunas están habilitadas y otras no, este valor será "irregular". Esto significa que tu modelo se encuentra en un estado inconsistente y es posible que no funcione como se espera.
  • active_adapters (list[str], Literal["irregular"]): Los nombres de los adaptadores activos. Si los adaptadores activos no son consistentes en todas las capas, este valor será "irregular", lo que significa que tu modelo está en un estado inconsistente y podría no funcionar como se espera.
  • merged_adapters (list[str], Literal["irregular"]): Los nombres de los adaptadores fusionados. Si los adaptadores fusionados no son consistentes en todas las capas, este valor será "irregular", lo que significa que tu modelo se encuentra en un estado inconsistente y es posible que no funcione como se espera.
  • requires_grad (dict[str, bool | Literal["irregular"]]): Indica si, para el adaptador dado, todas las capas del adaptador tienen requires_grad establecido en True o False. Si hay una mezcla, se establecerá en "irregular", lo que significa que su modelo está en un estado inconsistente y es posible que no funcione como se espera.
  • available_adapters (list[str]): Los nombres de los adaptadores disponibles, p. ej. ["default"].
  • devices (dict[str, list[str]]): Los dispositivos donde se almacenan los parámetros del adaptador dado, p. ej. ["cuda","xpu"].
  • quantization_backend (str, None, Literal["irregular"]): El nombre del backend de cuantización, p. ej. "bnb 4bit", o None si no está cuantizado. Si el backend no es consistente en todas las capas, será "irregular".
Update on GitHub

←AutoPeftModel Tipos de PEFT→