Hugging Face's logo

Buckets:
hf-doc-build
/
doc

Files
xet
hf-doc-build/doc / diffusers /main /es /api /modular_diffusers /pipeline_components.md
mishig's picture
mishig
preview code
|
download
raw
16.5 kB
# Componentes y configuraciones
## ComponentSpec[[diffusers.ComponentSpec]]
#### diffusers.ComponentSpec[[diffusers.ComponentSpec]]
```python
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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline_utils.py#L98)
**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]]
```python
create(config: diffusers.configuration_utils.FrozenDict | dict[str, typing.Any] | None = None, **kwargs)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline_utils.py#L267)
Crea el componente usando from_config con config.
#### decode_load_id[[diffusers.ComponentSpec.decode_load_id]]
```python
decode_load_id(load_id: str)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline_utils.py#L228)
**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]]
```python
from_component(name: str, component: Any)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline_utils.py#L149)
**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]]
```python
load(**kwargs)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline_utils.py#L295)
Cargue el componente usando from_pretrained.
#### loading_fields[[diffusers.ComponentSpec.loading_fields]]
```python
loading_fields()
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline_utils.py#L209)
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]]
```python
diffusers.ConfigSpec(name: str, default: Any, description: str | None = None)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline_utils.py#L360)
Especificación de un parámetro de configuración de pipeline.
## ComponentsManager[[diffusers.ComponentsManager]]
#### diffusers.ComponentsManager[[diffusers.ComponentsManager]]
```python
diffusers.ComponentsManager()
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/components_manager.py#L296)
Un registro central y un sistema de gestión para los componentes de modelos en varias tuberías.
[ComponentsManager](/docs/diffusers/main/es/api/modular_diffusers/pipeline_components#diffusers.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.
> [!WARNING] > Esta es una función experimental y es probable que cambie en el futuro.
Ejemplo:
```python
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]]
```python
add(name: str, component: Any, collection: str | None = None)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/components_manager.py#L393)
**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]]
```python
disable_auto_cpu_offload()
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/components_manager.py#L795)
Desactivar el descargado automático de CPU para todos los componentes.
#### enable_auto_cpu_offload[[diffusers.ComponentsManager.enable_auto_cpu_offload]]
```python
enable_auto_cpu_offload(device: str | int | torch.device = None, memory_reserve_margin = '3GB', offload_strategy = None)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/components_manager.py#L701)
**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]]
```python
get_components_by_ids(ids: list[str], return_dict_with_names: bool | None = True)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/components_manager.py#L1104)
**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]]
```python
get_components_by_names(names: list[str], collection: str | None = None)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/components_manager.py#L1137)
**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]]
```python
get_ids(names: str | list[str] = None, collection: str | None = None)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/components_manager.py#L1086)
**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]]
```python
get_model_info(component_id: str, fields: str | list[str] | None = None)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/components_manager.py#L812)
**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]]
```python
get_one(component_id: str | None = None, name: str | None = None, collection: str | None = None, load_id: str | None = None)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/components_manager.py#L1041)
**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]]
```python
remove(component_id: str = None)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/components_manager.py#L485)
**Parámetros:**
component_id (str) : El ID del componente a eliminar
Eliminar un componente del ComponentsManager.
#### remove_from_collection[[diffusers.ComponentsManager.remove_from_collection]]
```python
remove_from_collection(component_id: str, collection: str)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/components_manager.py#L467)
Eliminar un componente de una colección.
#### search_components[[diffusers.ComponentsManager.search_components]]
```python
search_components(names: str | None = None, collection: str | None = None, load_id: str | None = None, return_dict_with_names: bool = True)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/components_manager.py#L515)
**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]]
```python
set_offload_strategy(offload_strategy)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/components_manager.py#L779)
**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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/modular_pipeline_utils.py#L60)

Xet Storage Details

Size:
16.5 kB
·
Xet hash:
ca9bca8683300df6c533a9a6a8c5234265aef13de01918c90219066e31f7e1ed

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.