# 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)