diffusers/main/es/api/modular_diffusers/pipeline_components.md

Componentes y configuraciones

ComponentSpec[[diffusers.ComponentSpec]]

diffusers.ComponentSpec[[diffusers.ComponentSpec]]

diffusers.ComponentSpec(name: str | None = None, type_hint: typing.Optional[typing.Type] = None, description: str | None = None, config: diffusers.configuration_utils.FrozenDict | None = None, pretrained_model_name_or_path: str | list[str] | None = None, subfolder: str | None = '', variant: str | None = None, revision: str | None = None, default_creation_method: typing.Literal['from_config', 'from_pretrained'] = 'from_pretrained', repo: str | list[str] | None = None)

Fuente

Parámetros:

name : Nombre del componente

type_hint : Tipo del componente (p. ej., UNet2DConditionModel)

description : Descripción opcional del componente

config : Diccionario de configuración opcional para la creación de init

pretrained_model_name_or_path : Ruta opcional pretrained_model_name_or_path para la creación con from_pretrained

subfolder : Subcarpeta opcional en pretrained_model_name_or_path

variant : Variante opcional en pretrained_model_name_or_path

revision : Revisión opcional en pretrained_model_name_or_path

default_creation_method : Preferred creation method - "from_config" or "from_pretrained"

Especificación de un componente de pipeline.

Un componente puede crearse de dos formas:

1. Desde cero usando init con un diccionario de configuración
2. usando from_pretrained

create[[diffusers.ComponentSpec.create]]

create(config: diffusers.configuration_utils.FrozenDict | dict[str, typing.Any] | None = None, **kwargs)

Fuente

Crea el componente usando from_config con config.

decode_load_id[[diffusers.ComponentSpec.decode_load_id]]

decode_load_id(load_id: str)

Fuente

Parámetros:

load_id : La cadena load_id a decodificar, formato: "pretrained_model_name_or_path|subfolder|variant|revision" donde los valores None se representan como "null"

Devuelve:

Diccionario que mapea los nombres de los campos de carga a sus valores. p. ej. { "pretrained_model_name_or_path": "path/to/repo", "subfolder": "subfolder", "variant": "variant", "revision": "revision" } Si el valor de un segmento es "null", se reemplaza por None. Devuelve None si load_id es "null" (lo que indica que el componente no se creó con el método load).

Decodifica una cadena load_id de vuelta en un diccionario de campos y valores de carga.

from_component[[diffusers.ComponentSpec.from_component]]

from_component(name: str, component: Any)

Fuente

Parámetros:

name : Nombre del componente

component : Objeto de componente desde el cual crear la especificación

Devuelve:

Objeto ComponentSpec

Excepciones: ValueError

• ValueError -- Si el componente no es compatible (p. ej., nn.Module sin load_id, no-ConfigMixin)

Crea un ComponentSpec a partir de un Component.

Actualmente soporta:

• Componentes creados con el método ComponentSpec.load()
• Componentes que son subclases de ConfigMixin pero no de nn.Modules (p. ej., schedulers, guiders)

load[[diffusers.ComponentSpec.load]]

load(**kwargs)

Fuente

Cargue el componente usando from_pretrained.

loading_fields[[diffusers.ComponentSpec.loading_fields]]

loading_fields()

Fuente

Devuelve los nombres de todos los campos relacionados con la carga (es decir, aquellos cuyo field.metadata["loading"] es True).

ConfigSpec[[diffusers.ConfigSpec]]

diffusers.ConfigSpec[[diffusers.ConfigSpec]]

diffusers.ConfigSpec(name: str, default: Any, description: str | None = None)

Fuente

Especificación de un parámetro de configuración de pipeline.

ComponentsManager[[diffusers.ComponentsManager]]

diffusers.ComponentsManager[[diffusers.ComponentsManager]]

diffusers.ComponentsManager()

Fuente

Un registro central y un sistema de gestión para los componentes de modelos en varias tuberías.

ComponentsManager ofrece una forma unificada de registrar, hacer seguimiento y reutilizar componentes de modelos (como UNet, VAE, codificadores de texto, etc.) entre diferentes pipelines modulares. Incluye funciones para la detección de duplicados, la gestión de memoria y la organización de componentes.

> Esta es una función experimental y es probable que cambie en el futuro.

Ejemplo:

from diffusers import ComponentsManager

# Create a components manager
cm = ComponentsManager()

# Add components
cm.add("unet", unet_model, collection="sdxl")
cm.add("vae", vae_model, collection="sdxl")

# Enable auto offloading
cm.enable_auto_cpu_offload()

# Retrieve components
unet = cm.get_one(name="unet", collection="sdxl")

add[[diffusers.ComponentsManager.add]]

add(name: str, component: Any, collection: str | None = None)

Fuente

Parámetros:

name (str) : El nombre del componente

component (Cualquiera) : El componente a agregar

collection (str | None) : La colección a la que se debe agregar el componente

Devuelve: str

El ID de componente único, que se genera como "{name}_{id(component)}", donde id(component) es el identificador único integrado de Python para el objeto

Agregue un componente al ComponentsManager.

disable_auto_cpu_offload[[diffusers.ComponentsManager.disable_auto_cpu_offload]]

disable_auto_cpu_offload()

Fuente

Desactivar el descargado automático de CPU para todos los componentes.

enable_auto_cpu_offload[[diffusers.ComponentsManager.enable_auto_cpu_offload]]

enable_auto_cpu_offload(device: str | int | torch.device = None, memory_reserve_margin = '3GB', offload_strategy = None)

Fuente

Parámetros:

device (str | int | torch.device) : El dispositivo de ejecución al que se trasladan los modelos para las pasadas hacia adelante

memory_reserve_margin (str) : El margen de reserva de memoria a utilizar, el valor predeterminado es 3GB. Esta es la cantidad de memoria que se mantiene libre en el dispositivo para evitar quedarse sin memoria durante la ejecución del modelo (p. ej., para activaciones intermedias, gradientes, etc.)

offload_strategy : Cualquier función invocable con la firma (hooks, model_id, model, execution_device) -> hooks, que devuelve qué modelos residentes deben descargarse antes de que se cargue el entrante. El valor predeterminado es AutoOffloadStrategy, que libera la combinación mínima suficiente.

Habilita el descargado automático de CPU para todos los componentes.

El algoritmo funciona de la siguiente manera:

1. Todos los modelos se inician en la CPU de forma predeterminada
2. Cuando se llama al paso hacia adelante de un modelo, este se mueve al dispositivo de ejecución
3. Si la memoria es insuficiente, otros modelos en el dispositivo se devuelven a la CPU
4. El sistema intenta descargar la combinación más pequeña de modelos que libere suficiente memoria
5. Los modelos permanecen en el dispositivo de ejecución hasta que otro modelo necesita memoria y los fuerza a salir

Un modelo con descarga por grupo participa en esto pero se coloca a sí mismo: aún puede hacer espacio moviendo otros modelos a un lado, y nunca se mueve para hacerles espacio a ellos. Cualquiera de los dos órdenes funciona: la descarga por grupo antes o después de habilitar esto. AutoOffloadStrategy dimensiona sus decisiones a partir de la huella de memoria de los modelos, lo cual no describe un modelo que mantiene un grupo a la vez, por lo que pase una offload_strategy que decida a partir del flujo de trabajo.

get_components_by_ids[[diffusers.ComponentsManager.get_components_by_ids]]

get_components_by_ids(ids: list[str], return_dict_with_names: bool | None = True)

Fuente

Parámetros:

ids (list[str]) : lista de IDs de componentes

return_dict_with_names (bool | None) : Si se debe devolver un diccionario con los nombres de los componentes como claves:

Devuelve: dict[str, Any]

Diccionario de componentes.

• Si return_dict_with_names=True, las claves son los nombres de los componentes.
• Si return_dict_with_names=False, las claves son los ID de los componentes.

Excepciones: ValueError

• ValueError -- Si se encuentran nombres de componentes duplicados en los resultados de búsqueda cuando return_dict_with_names=True

Obtén componentes mediante una lista de IDs.

get_components_by_names[[diffusers.ComponentsManager.get_components_by_names]]

get_components_by_names(names: list[str], collection: str | None = None)

Fuente

Parámetros:

names (list[str]) : lista de nombres de componentes

collection (str | None) : Colección opcional para filtrar

Devuelve: dict[str, Any]

Diccionario de componentes con los nombres de los componentes como claves

Excepciones: ValueError

• ValueError -- Si se encuentran nombres de componentes duplicados en los resultados de búsqueda

Obtén componentes mediante una lista de nombres, opcionalmente filtrados por colección.

get_ids[[diffusers.ComponentsManager.get_ids]]

get_ids(names: str | list[str] = None, collection: str | None = None)

Fuente

Parámetros:

names (str | list[str]) : lista de nombres de componentes

collection (str | None) : Colección opcional para filtrar

Devuelve: list[str]

lista de IDs de componentes

Obtén los ID de componentes mediante una lista de nombres, opcionalmente filtrada por colección.

get_model_info[[diffusers.ComponentsManager.get_model_info]]

get_model_info(component_id: str, fields: str | list[str] | None = None)

Fuente

Parámetros:

component_id (str) : Nombre del componente para el que se desea obtener información

fields (str | list[str] | None) : Campo(s) a devolver. Puede ser una cadena para un solo campo o una lista de campos. Si es None, utiliza la configuración available_info_fields.

Devuelve:

Diccionario que contiene los metadatos del componente solicitado. Si se especifica fields, devuelve solo esos campos. De lo contrario, devuelve todos los campos.

Obtén información completa sobre un componente.

get_one[[diffusers.ComponentsManager.get_one]]

get_one(component_id: str | None = None, name: str | None = None, collection: str | None = None, load_id: str | None = None)

Fuente

Parámetros:

component_id (str | None) : ID de componente opcional para obtener

name (str | None) : Nombre o patrón del componente

collection (str | None) : Colección opcional para filtrar

load_id (str | None) : load_id opcional para filtrar

Devuelve:

Un único componente

Excepciones: ValueError

• ValueError -- Si ningún componente coincide o si varios componentes coinciden

Obtén un componente individual mediante:

• búsqueda por nombre (coincidencia de patrones), colección o load_id.
• pasando un component_id Lanza un error si coinciden varios componentes o si no se encuentra ninguno.

eliminar[[diffusers.ComponentsManager.remove]]

remove(component_id: str = None)

Fuente

Parámetros:

component_id (str) : El ID del componente a eliminar

Eliminar un componente del ComponentsManager.

remove_from_collection[[diffusers.ComponentsManager.remove_from_collection]]

remove_from_collection(component_id: str, collection: str)

Fuente

Eliminar un componente de una colección.

search_components[[diffusers.ComponentsManager.search_components]]

search_components(names: str | None = None, collection: str | None = None, load_id: str | None = None, return_dict_with_names: bool = True)

Fuente

Parámetros:

names : Nombre(s) o patrón(es) de componentes Patrones: - "unet" : coincide con cualquier componente cuyo nombre base sea "unet" (p. ej., unet_123abc) - "!unet" : todo excepto los componentes cuyo nombre base sea "unet" - "unet*" : cualquier componente cuyo nombre base comience por "unet" - "!unet*" : cualquier componente cuyo nombre base NO comience por "unet" - "unet" : cualquier componente cuyo nombre base contenga "unet" - "!unet" : cualquier componente cuyo nombre base NO contenga "unet" - "refiner|vae|unet" : cualquier componente cuyo nombre base coincida exactamente con "refiner", "vae" o "unet" - "!refiner|vae|unet" : cualquier componente cuyo nombre base NO coincida exactamente con "refiner", "vae" o "unet" - "unet*|vae*" : cualquier componente cuyo nombre base comience por "unet" O comience por "vae"

collection : Colección opcional para filtrar

load_id : load_id opcional para filtrar por

return_dict_with_names : Si es True, devuelve un diccionario con los nombres de los componentes como claves y lanza un error si se encuentran múltiples componentes con el mismo nombre. Si es False, devuelve un diccionario con los IDs de los componentes como claves

Devuelve:

Diccionario que mapea los nombres de los componentes a los componentes si return_dict_with_names=True, o un diccionario que mapea los IDs de los componentes a los componentes si return_dict_with_names=False

Busque componentes por nombre mediante una coincidencia de patrones simple. Opcionalmente, filtre por colección o load_id.

set_offload_strategy[[diffusers.ComponentsManager.set_offload_strategy]]

set_offload_strategy(offload_strategy)

Fuente

Parámetros:

offload_strategy : Cualquier función invocable con la firma (hooks, model_id, model, execution_device) -> hooks: recibe los hooks de los modelos actualmente en el dispositivo y devuelve los que deben descargarse antes de que se cargue el modelo entrante. El valor predeterminado es AutoOffloadStrategy, que libera la combinación mínima suficiente.

Reemplaza la estrategia de offload en todos los modelos gestionados. Solo es válido mientras el offload automático a CPU esté habilitado.

InsertableDict[[diffusers.modular_pipelines.InsertableDict]]

diffusers.modular_pipelines.InsertableDict[[diffusers.modular_pipelines.InsertableDict]]

Fuente