diffusers/main/es/api/loaders/peft.md

PEFT

Diffusers admite la carga de adaptadores como LoRA con la biblioteca PEFT mediante la clase PeftAdapterMixin. Esto permite que las clases de modelado de Diffusers, como UNet2DConditionModel y SD3Transformer2DModel, funcionen con un adaptador.

Consulte el tutorial Inference with PEFT para obtener una visión general de cómo usar PEFT en Diffusers para inferencia.

PeftAdapterMixin[[diffusers.loaders.PeftAdapterMixin]]

diffusers.loaders.PeftAdapterMixin[[diffusers.loaders.PeftAdapterMixin]]

diffusers.loaders.PeftAdapterMixin()

Fuente

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 base, consulte la documentación de PEFT.

Instale la última versión de PEFT y use este mixin para:

• Adjuntar nuevos adaptadores en el modelo.
• Adjunte varios adaptadores y actívelos/desactívelos de forma iterativa.
• Activar/desactivar todos los adaptadores del modelo.
• Obtén una lista de los adaptadores activos.

active_adapters[[diffusers.loaders.PeftAdapterMixin.active_adapters]]

active_adapters()

Fuente

Obtiene la lista actual de adaptadores activos del modelo.

Si no está familiarizado con los adaptadores y los métodos PEFT, le invitamos a leer más sobre ellos en la documentación de PEFT.

add_adapter[[diffusers.loaders.PeftAdapterMixin.add_adapter]]

add_adapter(adapter_config, adapter_name: str = 'default')

Fuente

Parámetros:

adapter_config ([~peft.PeftConfig]) : La configuración del adaptador a añadir; los adaptadores admitidos son los métodos de non-prefix tuning y adaption prompt.

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.

Añade un nuevo adaptador al modelo actual para el 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.

Si no está familiarizado con los adaptadores y los métodos PEFT, le invitamos a leer más sobre ellos en la documentación de PEFT.

delete_adapters[[diffusers.loaders.PeftAdapterMixin.delete_adapters]]

delete_adapters(adapter_names: list[str] | str)

Fuente

Parámetros:

adapter_names (list[str, str]) : Los nombres (cadena única o lista de cadenas) del adaptador que se va a eliminar.

Eliminar las capas LoRA de un adaptador del modelo subyacente.

Ejemplo:

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
).to("cuda")
pipeline.load_lora_weights(
    "jbilcke-hf/sdxl-cinematic-1", weight_name="pytorch_lora_weights.safetensors", adapter_names="cinematic"
)
pipeline.unet.delete_adapters("cinematic")

disable_adapters[[diffusers.loaders.PeftAdapterMixin.disable_adapters]]

disable_adapters()

Fuente

Desactive todos los adaptadores adjuntos al modelo y vuelva a la inferencia con solo el modelo base.

Si no está familiarizado con los adaptadores y los métodos PEFT, le invitamos a leer más sobre ellos en la documentación de PEFT.

disable_lora[[diffusers.loaders.PeftAdapterMixin.disable_lora]]

disable_lora()

Fuente

Desactiva las capas LoRA activas del modelo subyacente.

Ejemplo:

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
).to("cuda")
pipeline.load_lora_weights(
    "jbilcke-hf/sdxl-cinematic-1", weight_name="pytorch_lora_weights.safetensors", adapter_name="cinematic"
)
pipeline.unet.disable_lora()

enable_adapters[[diffusers.loaders.PeftAdapterMixin.enable_adapters]]

enable_adapters()

Fuente

Habilita los adaptadores que están unidos al modelo. El modelo utiliza self.active_adapters() para obtener la lista de adaptadores que se habilitarán.

Si no está familiarizado con los adaptadores y los métodos PEFT, le invitamos a leer más sobre ellos en la documentación de PEFT.

enable_lora[[diffusers.loaders.PeftAdapterMixin.enable_lora]]

enable_lora()

Fuente

Habilita las capas LoRA activas del modelo subyacente.

Ejemplo:

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
).to("cuda")
pipeline.load_lora_weights(
    "jbilcke-hf/sdxl-cinematic-1", weight_name="pytorch_lora_weights.safetensors", adapter_name="cinematic"
)
pipeline.unet.enable_lora()

enable_lora_hotswap[[diffusers.loaders.PeftAdapterMixin.enable_lora_hotswap]]

enable_lora_hotswap(target_rank: int = 128, check_compiled: typing.Literal['error', 'warn', 'ignore'] = 'error')

Fuente

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, por defecto "error") : Cómo manejar el caso en que el modelo ya está compilado, lo cual generalmente debe evitarse. Las opciones son: - "error" (por defecto): lanzar un error - "warn": emitir una advertencia - "ignore": no hacer nada

Permite la posibilidad de intercambiar adaptadores LoRA en caliente.

La llamada a este método solo es necesaria al intercambiar adaptadores en caliente y si el modelo está compilado o si los rangos de los adaptadores cargados difieren.

load_lora_adapter[[diffusers.loaders.PeftAdapterMixin.load_lora_adapter]]

load_lora_adapter(pretrained_model_name_or_path_or_dict, prefix = 'transformer', hotswap: bool = False, **kwargs)

Fuente

Parámetros:

pretrained_model_name_or_path_or_dict (str o os.PathLike o dict) : Puede ser: - Una cadena, el model id (por ejemplo google/ddpm-celebahq-256) de un modelo preentrenado alojado en el Hub. - Una ruta a un directorio (por ejemplo ./my_model_directory) que contiene los pesos del modelo guardados con ModelMixin.save_pretrained(). - Un torch state dict.

prefix (str, opcional) : Prefijo para filtrar el state dict.

cache_dir (str | os.PathLike, opcional) : Ruta a un directorio donde se almacena en caché la configuración de un modelo preentrenado descargado si no se utiliza la caché estándar.

force_download (bool, opcional, valor predeterminado False) : Indica si se debe forzar la (re)descarga de los pesos del modelo y los archivos de configuración, reemplazando las versiones en caché si existen.

proxies (dict[str, str], opcional) : Un diccionario de servidores proxy a utilizar por protocolo o punto de acceso, por ejemplo, {'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}. Los proxies se utilizan en cada solicitud.

local_files_only (bool, opcional, valor predeterminado False) : Indica si se deben cargar únicamente los pesos y archivos de configuración del modelo localmente. Si se establece en True, el modelo no se descargará desde el Hub.

token (str o bool, opcional) : El token que se usará como autorización HTTP bearer para archivos remotos. Si es True, se utiliza el token generado por diffusers-cli login (almacenado en ~/.huggingface).

revision (str, opcional, valor predeterminado "main") : La versión específica del modelo que se va a utilizar. Puede ser el nombre de una rama, el nombre de una etiqueta, un id de commit o cualquier identificador permitido por Git.

subfolder (str, opcional, valor predeterminado "") : La ubicación de la subcarpeta de un archivo de modelo dentro de un repositorio de modelos más grande en el Hub o localmente.

network_alphas (dict[str, float]) : El valor de la alfa de la red utilizado para un aprendizaje estable y para evitar el subdesbordamiento. Este valor tiene el mismo significado que la opción --network_alpha en el script de entrenamiento de kohya-ss. Consulte este enlace.

low_cpu_mem_usage (bool, opcional) : Acelera la carga del modelo cargando solo los pesos LoRA preentrenados y no inicializando los pesos aleatorios.

hotswap : (bool, opcional) El valor predeterminado es False. Indica 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 hotswapping es que, cuando el modelo se compila con torch.compile, la carga del nuevo adaptador no requiere la recompilación del modelo. Al usar hotswapping, 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 de LoRA (es decir, escalado) diferentes, es necesario llamar a un método adicional antes de cargar el adaptador: py pipeline = ... # load diffusers pipeline max_rank = ... # the highest rank among all LoRAs that you want to load # call *before* compiling and loading the LoRA adapter pipeline.enable_lora_hotswap(target_rank=max_rank) pipeline.load_lora_weights(file_name) # optionally compile the model now Tenga en cuenta que el hotswapping de adaptadores del codificador de texto aún no está soportado. Existen algunas limitaciones adicionales a esta técnica, que están documentadas aquí: https://huggingface.co/docs/peft/main/en/package_reference/hotswap

metadata : Metadatos del adaptador LoRA. Cuando se proporcionan, los metadatos inferidos a través del state dict no se utilizan para inicializar LoraConfig.

Carga un adaptador LoRA en el modelo subyacente.

save_lora_adapter[[diffusers.loaders.PeftAdapterMixin.save_lora_adapter]]

save_lora_adapter(save_directory, adapter_name: str = 'default', upcast_before_saving: bool = False, safe_serialization: bool = True, weight_name: str | None = None)

Fuente

Parámetros:

save_directory (str o os.PathLike) : Directorio para guardar los parámetros de LoRA. Se creará si no existe.

adapter_name : (str, por defecto "default"): El nombre del adaptador que se va a serializar. Útil cuando el modelo subyacente tiene varios adaptadores cargados.

upcast_before_saving (bool, por defecto False) : Si se debe convertir el modelo subyacente a torch.float32 antes de la serialización.

safe_serialization (bool, opcional, por defecto True) : Si se guarda el modelo usando safetensors o de la forma tradicional de PyTorch con pickle.

weight_name : (str, opcional, valor predeterminado None): Nombre del archivo con el que serializar el state dict.

Guarde los parámetros de LoRA correspondientes al modelo subyacente.

set_adapter[[diffusers.loaders.PeftAdapterMixin.set_adapter]]

set_adapter(adapter_name: str | list[str])

Fuente

Parámetros:

adapter_name (str | list[str])) : La lista de adaptadores a establecer o el nombre del adaptador en el caso de un solo adaptador.

Establece un adaptador específico forzando al modelo a usar solo ese adaptador y desactivando los demás.

Si no está familiarizado con los adaptadores y los métodos PEFT, le invitamos a leer más sobre ellos en la documentación de PEFT.

set_adapters[[diffusers.loaders.PeftAdapterMixin.set_adapters]]

set_adapters(adapter_names: list[str] | str, weights: float | dict | list[float] | list[dict] | list[None] | None = None)

Fuente

Parámetros:

adapter_names (list[str] o str) : Los nombres de los adaptadores a utilizar.

weights (Union[List[float], float], opcional) : Los pesos del adaptador o adaptadores a utilizar con el UNet. Si es None, los pesos se establecen en 1.0 para todos los adaptadores.

Establece los adaptadores actualmente activos para su uso en la red de difusión (p. ej., unet, transformer, etc.).

Ejemplo:

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
).to("cuda")
pipeline.load_lora_weights(
    "jbilcke-hf/sdxl-cinematic-1", weight_name="pytorch_lora_weights.safetensors", adapter_name="cinematic"
)
pipeline.load_lora_weights("nerijs/pixel-art-xl", weight_name="pixel-art-xl.safetensors", adapter_name="pixel")
pipeline.unet.set_adapters(["cinematic", "pixel"], weights=[0.5, 0.5])