# Funciones para la integración de PEFT

Una colección de funciones que podrían ser útiles para modelos que no son PeftModel, por ejemplo, para la integración con transformers o diffusers

Las funciones proporcionadas aquí pueden considerarse la "API pública" de PEFT y, por lo tanto, es seguro que los paquetes que ofrecen integraciones de PEFT las utilicen.

## Castea los dtypes de los pesos del adaptador[[peft.tuners.tuners_utils.cast_adapter_dtype]]

#### peft.tuners.tuners_utils.cast_adapter_dtype[[peft.tuners.tuners_utils.cast_adapter_dtype]]

```python
peft.tuners.tuners_utils.cast_adapter_dtype(model: nn.Module, adapter_name: str, autocast_adapter_dtype: bool = True)
```

[Fuente](https://github.com/huggingface/peft/blob/main/src/peft/tuners/tuners_utils.py#L2811)

**Parámetros:**

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

Un método auxiliar para convertir los pesos del adaptador al dtype correcto. Reasigna nuevos parámetros a las capas del adaptador; si algún objeto hace referencia a los parámetros antiguos, estos no se actualizarán.

Actualmente, esto solo convierte los tipos de datos flotantes a float32.

## Eliminar el adaptador PEFT del modelo[[peft.tuners.tuners_utils.delete_adapter]]

#### peft.tuners.tuners_utils.delete_adapter[[peft.tuners.tuners_utils.delete_adapter]]

```python
peft.tuners.tuners_utils.delete_adapter(model: nn.Module, adapter_name: str, prefix: str, layer_cls: type[BaseTunerLayer] = <class 'peft.tuners.tuners_utils.BaseTunerLayer'>)
```

[Fuente](https://github.com/huggingface/peft/blob/main/src/peft/tuners/tuners_utils.py#L2772)

**Parámetros:**

model (`nn.Module`) : El modelo del que se debe eliminar el adaptador.

adapter_name (str) : El nombre del adaptador que se eliminará.

prefix (str) : El prefijo del método PEFT, por ejemplo, "lora_" para LoRA.

layer_cls (type, opcional) : La clase de la capa del adaptador. El valor predeterminado es `BaseTunerLayer`.

**Devuelve:** new_adapter (list[str] | None)

El nombre del o los adaptadores restantes tras la eliminación, o `None` si no quedan adaptadores activos. Utilice esto para establecer el nuevo adaptador activo del modelo si es necesario.

Eliminar un adaptador PEFT existente.

Nota: Esta función no elimina la configuración de PEFT del modelo, si la hay. Tampoco purgará por completo las capas de PEFT si se elimina el último adaptador de PEFT. Para ello, considere usar `model.unload()` si está utilizando una instancia de modelo PEFT, o simplemente recargue el modelo base.

## Obtener el state dict del adaptador PEFT[[peft.get_peft_model_state_dict]]

#### peft.get_peft_model_state_dict[[peft.get_peft_model_state_dict]]

```python
peft.get_peft_model_state_dict(model, state_dict = None, adapter_name: str = 'default', unwrap_compiled: bool = False, save_embedding_layers: bool | Literal['auto'] = 'auto')
```

[Fuente](https://github.com/huggingface/peft/blob/main/src/peft/utils/save_and_load.py#L198)

**Parámetros:**

model ([PeftModel](/docs/peft/main/es/package_reference/peft_model#peft.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*, por defecto `False`) : Si se debe desenrollar el modelo si se usó torch.compile.

save_embedding_layers (`Union[bool, str]`, , *opcional*, por defecto `auto`) : Si `True`, guarda las capas de embedding además de los pesos del adaptador. Si `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 del modelo completo. Para obtener el `state_dict` completo, simplemente llama a `model.state_dict()`.

Si las entradas seleccionadas contienen tensores distribuidos (p. ej., FSDP2 o DTensor TP), todos los rangos participantes deben llamar a esta función: reunir esas entradas en tensores completos es una operación colectiva. Los pesos del modelo base no seleccionados permanecen fragmentados.

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()](/docs/peft/main/es/package_reference/functional#peft.set_peft_model_state_dict) para gestionar el nombre del adaptador al cargar los pesos.

## Inyecta un adaptador PEFT en el modelo en función de una configuración PEFT[[peft.inject_adapter_in_model]]

#### peft.inject_adapter_in_model[[peft.inject_adapter_in_model]]

```python
peft.inject_adapter_in_model(peft_config: PeftConfig, model: torch.nn.Module, adapter_name: str = 'default', low_cpu_mem_usage: bool = False, state_dict: Optional[dict[str, torch.Tensor]] = None)
```

[Fuente](https://github.com/huggingface/peft/blob/main/src/peft/mapping.py#L47)

**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`, por defecto `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 los valores del `state_dict` no se utilizan; solo se usan 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()](/docs/peft/main/es/package_reference/peft_model#peft.get_peft_model) para estos últimos.

Esta función es similar a [get_peft_model()](/docs/peft/main/es/package_reference/peft_model#peft.get_peft_model) pero no devuelve una instancia de [PeftModel](/docs/peft/main/es/package_reference/peft_model#peft.PeftModel). En su lugar, devuelve la instancia original, modificada, del modelo pasado.

## Establecer el o los adaptadores PEFT activos del modelo[[peft.tuners.tuners_utils.set_adapter]]

#### peft.tuners.tuners_utils.set_adapter[[peft.tuners.tuners_utils.set_adapter]]

```python
peft.tuners.tuners_utils.set_adapter(model, adapter_name: str | list[str], inference_mode: bool = False, layer_cls: type[BaseTunerLayer] = <class 'peft.tuners.tuners_utils.BaseTunerLayer'>)
```

[Fuente](https://github.com/huggingface/peft/blob/main/src/peft/tuners/tuners_utils.py#L2721)

**Parámetros:**

model (`nn.Module`) : El modelo en el que se deben establecer el o los adaptadores.

adapter_name (str, list[str]) : El nombre o los nombres del adaptador o 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.

layer_cls (type, opcional) : La clase de la capa del adaptador. El valor predeterminado es `BaseTunerLayer`.

Establece el o los adaptadores PEFT activos del modelo.

Los adaptadores activos son aquellos que participan en la pasada hacia adelante. Utilice esta función si desea alternar entre varios adaptadores PEFT.

## Establece el modo de entrenamiento de los adaptadores especificados[[peft.tuners.tuners_utils.set_training]]

#### peft.tuners.tuners_utils.set_training[[peft.tuners.tuners_utils.set_training]]

```python
peft.tuners.tuners_utils.set_training(model, adapter_names: str | Sequence[str], training: bool = True)
```

[Fuente](https://github.com/huggingface/peft/blob/main/src/peft/tuners/tuners_utils.py#L2896)

**Parámetros:**

model (`nn.Module`) : El modelo cuyos modos de entrenamiento de los módulos de adaptador deben actualizarse.

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.

## Establece el atributo `requires_grad` de los adaptadores especificados[[peft.tuners.tuners_utils.set_requires_grad]]

#### peft.tuners.tuners_utils.set_requires_grad[[peft.tuners.tuners_utils.set_requires_grad]]

```python
peft.tuners.tuners_utils.set_requires_grad(model, adapter_names: str | Sequence[str], requires_grad: bool = True)
```

[Fuente](https://github.com/huggingface/peft/blob/main/src/peft/tuners/tuners_utils.py#L2879)

**Parámetros:**

model (`nn.Module`) : El modelo cuyos requisitos de gradiente del adaptador deben actualizarse.

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 se deshabilita (`False`).

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

## Cargue los pesos del diccionario de estado de PEFT en el modelo[[peft.set_peft_model_state_dict]]

#### peft.set_peft_model_state_dict[[peft.set_peft_model_state_dict]]

```python
peft.set_peft_model_state_dict(model, peft_model_state_dict, adapter_name = 'default', ignore_mismatched_sizes: bool = False, low_cpu_mem_usage: bool = False)
```

[Fuente](https://github.com/huggingface/peft/blob/main/src/peft/utils/save_and_load.py#L601)

**Parámetros:**

model ([PeftModel](/docs/peft/main/es/package_reference/peft_model#peft.PeftModel)) : El modelo Peft.

peft_model_state_dict (`dict`) : El state dict del modelo Peft.

adapter_name (`str`, *opcional*, valor predeterminado `"default"`) : El nombre del adaptador cuyo state dict debe establecerse.

ignore_mismatched_sizes (`bool`, *opcional*, valor predeterminado `False`) : Si se deben ignorar los tamaños no coincidentes en el state dict.

low_cpu_mem_usage (`bool`, `optional`, por defecto `False`) : Este argumento debe ser `True` si el `model` se cargó con pesos de adaptador en el dispositivo meta, por ejemplo, después de llamar a `inject_adapter_in_model` con `low_cpu_mem_usage=True`. En caso contrario, déjalo como `False`.

**Devuelve:**

load_result (`_IncompatibleKeys`) Una tupla nombrada con los campos `missing_keys` y `unexpected_keys`.

Establece el state dict del modelo PEFT.

Dado un `state_dict` de PEFT (tal como lo devuelve [get_peft_model_state_dict()](/docs/peft/main/es/package_reference/peft_model#peft.get_peft_model_state_dict)), inserta los pesos en el modelo. El modelo debe tener ya en su lugar los adaptadores de PEFT (por ejemplo, mediante [inject_adapter_in_model()](/docs/peft/main/es/package_reference/peft_model#peft.inject_adapter_in_model)).

Establecer los pesos del adaptador también se encarga de reinsertar el nombre del adaptador. Este nombre puede ser diferente al que se usó originalmente para entrenar el adaptador.