# PEFT[[transformers.integrations.PeftAdapterMixin]] El [PeftAdapterMixin](/docs/transformers/v5.23.0/es/main_classes/peft#transformers.integrations.PeftAdapterMixin) proporciona funciones de la biblioteca [PEFT](https://huggingface.co/docs/peft/index) para gestionar adaptadores con Transformers. Este mixin admite todos los métodos de PEFT que no son de aprendizaje de prompts (LoRA, IA3, AdaLoRA y otros). Los métodos de prefix tuning (prompt tuning, prompt learning) no están admitidos porque no se pueden inyectar en un módulo de torch. #### transformers.integrations.PeftAdapterMixin[[transformers.integrations.PeftAdapterMixin]] ```python transformers.integrations.PeftAdapterMixin() ``` [Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/integrations/peft.py#L57) Una clase que contiene todas las funciones para cargar y usar pesos de adaptadores compatibles con la biblioteca PEFT. Para más detalles sobre los adaptadores y su inyección en un modelo basado en transformers, consulte la documentación de la biblioteca PEFT: https://huggingface.co/docs/peft/index Los métodos PEFT actualmente soportados son todos métodos de aprendizaje no basados en prompts (LoRA, IA³, etc.). Otros modelos PEFT, como prompt tuning o prompt learning, están fuera de alcance, ya que estos adaptadores no son "inyectables" en un módulo de torch. Para utilizar estos métodos, consulte la guía de uso de la biblioteca PEFT. Con este mixin, si se instala la versión correcta de PEFT (>= 0.20.0), es posible: - Cargue un adaptador almacenado en una ruta local o en un repositorio remoto de Hub e inyéctelo en el modelo - Adjunta nuevos adaptadores al modelo y entrénalos con Trainer o por tu cuenta. - Adjuntar varios adaptadores y activarlos / desactivarlos de forma iterativa - Activar / desactivar todos los adaptadores del modelo. - Obtenga el `state_dict` del adaptador activo. #### load_adapter[[transformers.integrations.PeftAdapterMixin.load_adapter]] ```python load_adapter(peft_model_id: str | None = None, adapter_name: str | None = None, peft_config: dict[str, typing.Any] | None = None, adapter_state_dict: dict[str, 'torch.Tensor'] | None = None, low_cpu_mem_usage: bool = False, is_trainable: bool = False, hotswap: typing.Union[bool, typing.Literal['auto']] = 'auto', local_files_only: bool = False, adapter_kwargs: dict[str, typing.Any] | None = None, load_config: typing.Optional[ForwardRef('LoadStateDictConfig')] = None, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/integrations/peft.py#L80) **Parámetros:** peft_model_id (`str`, *opcional*) : El identificador del modelo que se busca en el Hub, o una ruta local al archivo de configuración del adaptador guardado y a los pesos del adaptador. adapter_name (`str`, *opcional*) : El nombre del adaptador que se va a usar. Si no se establece, se usará el nombre "default". load_config (`LoadStateDictConfig`, *opcional*) : Una configuración de carga para reutilizar al obtener los pesos del adaptador, normalmente desde `from_pretrained`. kwargs (`dict[str, Any]`, *opcional*) : Campos adicionales de `LoadStateDictConfig` pasados como argumentos de palabra clave. peft_config (`dict[str, Any]`, *opcional*) : La configuración del adaptador que se va a añadir; los adaptadores admitidos son todas las configuraciones de aprendizaje no basadas en prompts (LoRA, IA³, etc.). Este argumento se utiliza en caso de que los usuarios pasen directamente diccionarios de estado de PEFT. adapter_state_dict (`dict[str, torch.Tensor]`, *opcional*) : El state dict del adaptador que se va a cargar. Este argumento se utiliza en caso de que los usuarios pasen directamente state dicts de PEFT. low_cpu_mem_usage (`bool`, *opcional*, valor predeterminado `False`) : Reduce el uso de memoria al cargar el adaptador PEFT. Esto también debería acelerar el proceso de carga. 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. hotswap : (`"auto"` o `bool`, *opcional*, valor predeterminado `"auto"`) Si se debe sustituir un adaptador (LoRA) existente por el adaptador recién cargado in situ. Esto significa que, en lugar de cargar un adaptador adicional, se tomarán los pesos del adaptador existente y se reemplazarán con los pesos del nuevo adaptador. Esto puede ser más rápido y eficiente en memoria. Sin embargo, la principal ventaja del hotswap es que, cuando el modelo se compila con torch.compile, la carga del nuevo adaptador no requiere recompilar el modelo. Al usar hotswap, el `adapter_name` pasado debe ser el nombre de un adaptador ya cargado. Si el nuevo adaptador y el antiguo tienen rangos y/o alfas LoRA (es decir, escalado) diferentes, es necesario llamar a un método adicional antes de cargar el adaptador: ```py model = AutoModel.from_pretrained(...) max_rank = ... # the highest rank among all LoRAs that you want to load # call *before* compiling and loading the LoRA adapter model.enable_peft_hotswap(target_rank=max_rank) model.load_adapter(file_name_1, adapter_name="default") # optionally compile the model now model = torch.compile(model, ...) output_1 = model(...) # now you can hotswap the 2nd adapter, use the same name as for the 1st # hotswap is activated by default since enable_peft_hotswap was called model.load_adapter(file_name_2, adapter_name="default") output_2 = model(...) ``` Por defecto, el hotswap está desactivado y requiere pasar `hotswap=True`. Si primero se llamó a `enable_peft_hotswap`, está activado. En ese caso, aún se puede desactivar manualmente pasando `hotswap=False`. Tenga en cuenta que el hotswap conlleva algunas limitaciones documentadas aquí: https://huggingface.co/docs/peft/main/en/package_reference/hotswap adapter_kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palabra clave adicionales que se pasan al método `from_pretrained` de la configuración del adaptador y al método `find_adapter_config_file`. Carga los pesos del adaptador desde un archivo o una carpeta remota del Hub. Si no estás familiarizado con los adaptadores y los métodos PEFT, te invitamos a leer más sobre ellos en la documentación oficial de PEFT: https://huggingface.co/docs/peft Requiere que PEFT esté instalado como backend para cargar los pesos del adaptador. #### add_adapter[[transformers.integrations.PeftAdapterMixin.add_adapter]] ```python add_adapter(adapter_config, adapter_name: str | None = None) ``` [Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/integrations/peft.py#L390) **Parámetros:** adapter_config (`~peft.PeftConfig`) : La configuración del adaptador a añadir; los adaptadores admitidos son métodos de aprendizaje no basados en prompts (LoRA, IA³, etc.). adapter_name (`str`, *opcional*, valor predeterminado `"default"`) : El nombre del adaptador que se va a añadir. Si no se pasa ningún nombre, se asigna un nombre predeterminado al adaptador. Si no está familiarizado con los adaptadores y los métodos PEFT, le invitamos a leer más sobre ellos en la documentación oficial de PEFT: https://huggingface.co/docs/peft Añade un adaptador nuevo al modelo actual con fines de entrenamiento. Si no se pasa un nombre de adaptador, se asigna un nombre predeterminado al adaptador para seguir la convención de la biblioteca PEFT (en PEFT usamos "default" como nombre de adaptador predeterminado). Tenga en cuenta que el adaptador recién añadido no se activa automáticamente. Para activarlo, use `model.set_adapter`. #### set_adapter[[transformers.integrations.PeftAdapterMixin.set_adapter]] ```python set_adapter(adapter_name: list[str] | str) ``` [Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/integrations/peft.py#L430) **Parámetros:** adapter_name (`Union[list[str], str]`) : El nombre del adaptador que se va a establecer. También puede ser una lista de cadenas de texto para establecer varios adaptadores. Si no está familiarizado con los adaptadores y los métodos PEFT, le invitamos a leer más sobre ellos en la documentación oficial de PEFT: https://huggingface.co/docs/peft Establece un adaptador específico forzando al modelo a usar ese adaptador y desactivando los demás. #### disable_adapters[[transformers.integrations.PeftAdapterMixin.disable_adapters]] ```python disable_adapters() ``` [Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/integrations/peft.py#L471) Si no está familiarizado con los adaptadores y los métodos PEFT, le invitamos a leer más sobre ellos en la documentación oficial de PEFT: https://huggingface.co/docs/peft Desactive todos los adaptadores que estén conectados al modelo. Esto provoca que la inferencia se realice únicamente con el modelo base. #### enable_adapters[[transformers.integrations.PeftAdapterMixin.enable_adapters]] ```python enable_adapters() ``` [Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/integrations/peft.py#L490) Si no está familiarizado con los adaptadores y los métodos PEFT, le invitamos a leer más sobre ellos en la documentación oficial de PEFT: https://huggingface.co/docs/peft Habilita los adaptadores que están unidos al modelo. #### enable_peft_hotswap[[transformers.integrations.PeftAdapterMixin.enable_peft_hotswap]] ```python enable_peft_hotswap(target_rank: int = 128, check_compiled: typing.Literal['error', 'warn', 'ignore'] = 'error') ``` [Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/integrations/peft.py#L353) **Parámetros:** target_rank (`int`, *opcional*, valor predeterminado `128`) : El rango más alto entre todos los adaptadores que se cargarán. check_compiled (`str`, *opcional*, valor predeterminado `"error"`) : Cómo manejar el caso en que el modelo ya está compilado, algo que generalmente debe evitarse. Las opciones son: - "error" (predeterminado): lanzar un error - "warn": emitir una advertencia - "ignore": no hacer nada Permite intercambiar en caliente adaptadores PEFT con rangos diferentes o, si el modelo está compilado, sin provocar una recompilación. Por ahora, el hotswapping solo se admite para LoRA. La llamada a este método solo es necesaria al cambiar de adaptador en caliente y si el modelo está compilado o si los rangos de los adaptadores cargados difieren. Si todos los rangos son idénticos y el modelo no está compilado, el cambio en caliente funciona sin necesidad de llamar a este método primero. #### active_adapters[[transformers.integrations.PeftAdapterMixin.active_adapters]] ```python active_adapters() ``` [Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/integrations/peft.py#L508) Si no está familiarizado con los adaptadores y los métodos PEFT, le invitamos a leer más sobre ellos en la documentación oficial de PEFT: https://huggingface.co/docs/peft Obtiene los adaptadores activos actuales del modelo. En el caso de inferencia con múltiples adaptadores (combinación de varios adaptadores para la inferencia), devuelve la lista de todos los adaptadores activos para que los usuarios puedan tratarlos en consecuencia. En versiones anteriores de PEFT (que no admiten inferencia multiadaptador), `module.active_adapter` devuelve una sola cadena. #### get_adapter_state_dict[[transformers.integrations.PeftAdapterMixin.get_adapter_state_dict]] ```python get_adapter_state_dict(adapter_name: str | None = None, state_dict: dict | None = None) ``` [Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/integrations/peft.py#L537) **Parámetros:** adapter_name (`str`, *opcional*) : El nombre del adaptador del que se obtiene el state dict. Si no se pasa ningún nombre, se utiliza el adaptador activo. state_dict (dict anidado de `torch.Tensor`, *opcional*) : El diccionario de estado del modelo. Por defecto será `self.state_dict()`, pero se puede utilizar si se necesitan precauciones especiales al recuperar el diccionario de estado de un modelo (como cuando se usa paralelismo de modelos). Si no está familiarizado con los adaptadores y los métodos PEFT, le invitamos a leer más sobre ellos en la documentación oficial de PEFT: https://huggingface.co/docs/peft Obtiene el diccionario de estado del adaptador, que debe contener únicamente los tensores de pesos del adaptador especificado por adapter_name. Si no se pasa adapter_name, se utiliza el adaptador activo. #### delete_adapter[[transformers.integrations.PeftAdapterMixin.delete_adapter]] ```python delete_adapter(adapter_names: list[str] | str) ``` [Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/integrations/peft.py#L622) **Parámetros:** adapter_names (`Union[list[str], str]`) : El nombre de los adaptadores a eliminar. Eliminar un adaptador PEFT del modelo subyacente.