# Modelos

🤗 Diffusers ofrece modelos preentrenados para algoritmos populares y módulos para crear sistemas de difusión personalizados. La función principal de los modelos es desruidar una muestra de entrada según la distribución modelada \\(p_{\theta}(x_{t-1}|x_{t})\\).

Todos los modelos se construyen a partir de la clase base [ModelMixin](/docs/diffusers/main/es/api/models/overview#diffusers.ModelMixin), que es un [`torch.nn.Module`](https://pytorch.org/docs/stable/generated/torch.nn.Module.html) que proporciona funcionalidad básica para guardar y cargar modelos, localmente y desde el Hugging Face Hub.

## ModelMixin[[diffusers.ModelMixin]]

#### diffusers.ModelMixin[[diffusers.ModelMixin]]

```python
diffusers.ModelMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L243)

Clase base para todos los modelos.

[ModelMixin](/docs/diffusers/main/es/api/models/overview#diffusers.ModelMixin) se encarga de almacenar la configuración del modelo y proporciona métodos para cargar, descargar y guardar modelos.

- **config_name** (`str`) -- Nombre del archivo para guardar un modelo al llamar a [save_pretrained()](/docs/diffusers/main/es/api/models/overview#diffusers.ModelMixin.save_pretrained).

#### compile_repeated_blocks[[diffusers.ModelMixin.compile_repeated_blocks]]

```python
compile_repeated_blocks(*args, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L1678)

Compila *solo* los submódulos que se repiten con frecuencia en un modelo (por ejemplo, las capas Transformer) en lugar de compilar el modelo completo. Esta técnica, a menudo denominada **compilación regional** (consulte la receta de PyTorch https://docs.pytorch.org/tutorials/recipes/regional_compilation.html), puede reducir de manera sustancial el tiempo de compilación de extremo a extremo, al mismo tiempo que conserva las mejoras de velocidad en tiempo de ejecución que se esperarían de una compilación completa con `torch.compile`.

El conjunto de submódulos que se compilan se detecta mediante la presencia del atributo **`_repeated_blocks`** en la definición del modelo. Defina este atributo en su subclase de modelo como una lista/tupla de nombres de clase (cadenas de texto). Se compilará cada módulo cuyo nombre de clase coincida.

Una vez descubiertos, cada submódulo coincidente se compila llamando a `submodule.compile(*args, **kwargs)`. Cualquier argumento posicional o por nombre que proporciones a `compile_repeated_blocks` se reenvía tal cual a `torch.compile`.

#### cuda[[diffusers.ModelMixin.cuda]]

```python
cuda(*args, **kwargs)
```

Un valor simulado para una ruta con puntos (p. ej. `torch.float32`): las cadenas de acceso a atributos y las llamadas se comportan como decoradores de paso, `repr` es la ruta con puntos, y su uso como clase base sustituye una base de `type` simple (PEP 560 `__mro_entries__`), de modo que las subclases reales conservan un metaclass normal y `inspect.signature` lee su `__init__` real en lugar del de un simulado.

#### dequantize[[diffusers.ModelMixin.dequantize]]

```python
dequantize()
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L894)

Des-cuantizar potencialmente el modelo en caso de que haya sido cuantizado mediante un método de cuantización que admita la des-cuantización.

#### disable_gradient_checkpointing[[diffusers.ModelMixin.disable_gradient_checkpointing]]

```python
disable_gradient_checkpointing()
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L327)

Desactiva el checkpointing de gradientes para el modelo actual (puede referirse a *activation checkpointing* o *checkpoint activations* en otros frameworks).

#### disable_npu_flash_attention[[diffusers.ModelMixin.disable_npu_flash_attention]]

```python
disable_npu_flash_attention()
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L358)

desactivar npu flash attention desde torch_npu

#### disable_xformers_memory_efficient_attention[[diffusers.ModelMixin.disable_xformers_memory_efficient_attention]]

```python
disable_xformers_memory_efficient_attention()
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L441)

Desactivar la atención eficiente en memoria de [xFormers](https://facebookresearch.github.io/xformers/).

#### disable_xla_flash_attention[[diffusers.ModelMixin.disable_xla_flash_attention]]

```python
disable_xla_flash_attention()
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L388)

Desactivar el kernel pallals de flash attention para torch_xla.

#### enable_gradient_checkpointing[[diffusers.ModelMixin.enable_gradient_checkpointing]]

```python
enable_gradient_checkpointing(gradient_checkpointing_func: typing.Optional[typing.Callable] = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L297)

**Parámetros:**

gradient_checkpointing_func (`Callable`, *opcional*) : La función que se utilizará para el checkpointing de gradientes. Si es `None`, se utiliza la función de checkpointing predeterminada de PyTorch (`torch.utils.checkpoint.checkpoint`).

Activa el checkpointing de gradientes para el modelo actual (puede referirse a *activation checkpointing* o *checkpoint activations* en otros frameworks).

#### enable_group_offload[[diffusers.ModelMixin.enable_group_offload]]

```python
enable_group_offload(onload_device: device, offload_device: device = torch.device(), offload_type: str = 'block_level', num_blocks_per_group: int | None = None, non_blocking: bool = False, use_stream: bool = False, record_stream: bool = False, low_cpu_mem_usage = False, offload_to_disk_path: str | None = None, block_modules: str | None = None, exclude_kwargs: str | None = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L532)

Activa el descargado de grupos para el modelo actual.

Consulte [apply_group_offloading()](/docs/diffusers/main/es/api/utilities#diffusers.hooks.apply_group_offloading) para obtener más información.

Ejemplo:

```python
>>> from diffusers import CogVideoXTransformer3DModel

>>> transformer = CogVideoXTransformer3DModel.from_pretrained(
...     "THUDM/CogVideoX-5b", subfolder="transformer", torch_dtype=torch.bfloat16
... )

>>> transformer.enable_group_offload(
...     onload_device=torch.device("cuda"),
...     offload_device=torch.device("cpu"),
...     offload_type="leaf_level",
...     use_stream=True,
... )
```

#### enable_layerwise_casting[[diffusers.ModelMixin.enable_layerwise_casting]]

```python
enable_layerwise_casting(storage_dtype: dtype = torch.float8_e4m3fn, compute_dtype: typing.Optional[torch.dtype] = None, skip_modules_pattern: tuple[str, ...] | None = None, skip_modules_classes: tuple[typing.Type[torch.nn.Module], ...] | None = None, non_blocking: bool = False)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L447)

**Parámetros:**

storage_dtype (`torch.dtype`) : El dtype al que se debe convertir el modelo para su almacenamiento.

compute_dtype (`torch.dtype`) : El dtype al que deben convertirse los pesos del modelo durante la pasada hacia adelante.

skip_modules_pattern (`tuple[str, ...]`, *opcional*) : Una lista de patrones para coincidir con los nombres de los módulos que se deben omitir durante el proceso de conversión por capas. Si se establece en `None`, se utilizan patrones de omisión predeterminados para ignorar ciertas capas internas de los módulos y las capas de PEFT.

skip_modules_classes (`tuple[Type[torch.nn.Module], ...]`, *opcional*) : Una lista de clases de módulos para omitir durante el proceso de conversión por capas.

non_blocking (`bool`, *opcional*, valor predeterminado `False`) : Si `True`, las operaciones de conversión de pesos son no bloqueantes.

Activa el casteo por capa para el modelo actual.

El casteo por capas es una técnica que convierte los pesos del modelo a un dtype de menor precisión para su almacenamiento, pero los convierte al vuelo a un dtype de mayor precisión para el cálculo. Este proceso puede reducir significativamente la huella de memoria de los pesos del modelo, pero puede provocar cierta degradación de la calidad en las salidas. La mayoría de las degradaciones son insignificantes y se deben principalmente al casteo de pesos en las capas de normalización y modulación.

Por defecto, la mayoría de los modelos en diffusers establecen el atributo `_skip_layerwise_casting_patterns` para ignorar las capas de patch embedding, positional embedding y normalización. Esto se debe a que estas capas son probablemente críticas en precisión para la calidad. Si deseas cambiar este comportamiento, puedes establecer el atributo `_skip_layerwise_casting_patterns` en `None`, o llamar a [apply_layerwise_casting()](/docs/diffusers/main/es/api/utilities#diffusers.hooks.apply_layerwise_casting) con argumentos personalizados.

Ejemplo:

Usando [enable_layerwise_casting()](/docs/diffusers/main/es/api/models/overview#diffusers.ModelMixin.enable_layerwise_casting):

```python
>>> from diffusers import CogVideoXTransformer3DModel

>>> transformer = CogVideoXTransformer3DModel.from_pretrained(
...     "THUDM/CogVideoX-5b", subfolder="transformer", torch_dtype=torch.bfloat16
... )

>>> # Enable layerwise casting via the model, which ignores certain modules by default
>>> transformer.enable_layerwise_casting(storage_dtype=torch.float8_e4m3fn, compute_dtype=torch.bfloat16)
```

#### enable_npu_flash_attention[[diffusers.ModelMixin.enable_npu_flash_attention]]

```python
enable_npu_flash_attention()
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L351)

Activar npu flash attention desde torch_npu

#### enable_xformers_memory_efficient_attention[[diffusers.ModelMixin.enable_xformers_memory_efficient_attention]]

```python
enable_xformers_memory_efficient_attention(attention_op: typing.Optional[typing.Callable] = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L409)

**Parámetros:**

attention_op (`Callable`, *opcional*) : Anula el operador `None` predeterminado para su uso como argumento `op` de la función [`memory_efficient_attention()`](https://facebookresearch.github.io/xformers/components/ops.html#xformers.ops.memory_efficient_attention) de xFormers.

Habilitar la atención eficiente en memoria desde [xFormers](https://facebookresearch.github.io/xformers/).

Cuando esta opción está habilitada, debería observar un menor uso de memoria de GPU y una posible aceleración durante la inferencia. No se garantiza una aceleración durante el entrenamiento.

> [!WARNING] > ⚠️ Cuando la atención eficiente en memoria y la atención segmentada están ambas habilitadas, la atención eficiente
attention tiene > precedencia.

Ejemplos:

```py
>>> import torch
>>> from diffusers import UNet2DConditionModel
>>> from xformers.ops import MemoryEfficientAttentionFlashAttentionOp

>>> model = UNet2DConditionModel.from_pretrained(
...     "stabilityai/stable-diffusion-2-1", subfolder="unet", torch_dtype=torch.float16
... )
>>> model = model.to("cuda")
>>> model.enable_xformers_memory_efficient_attention(attention_op=MemoryEfficientAttentionFlashAttentionOp)
```

#### enable_xla_flash_attention[[diffusers.ModelMixin.enable_xla_flash_attention]]

```python
enable_xla_flash_attention(partition_spec: typing.Optional[typing.Callable] = None, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L382)

Habilitar el kernel pallals de flash attention para torch_xla.

#### from_pretrained[[diffusers.ModelMixin.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike | None, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L906)

**Parámetros:**

pretrained_model_name_or_path (`str` o `os.PathLike`, *opcional*) : 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 [save_pretrained()](/docs/diffusers/main/es/api/models/overview#diffusers.ModelMixin.save_pretrained).

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.

dtype (`torch.dtype`, *opcional*) : Anula el `torch.dtype` predeterminado y carga el modelo con otro dtype.

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.

output_loading_info (`bool`, *opcional*, por defecto `False`) : Si se debe devolver también un diccionario que contenga las claves faltantes, las claves inesperadas y los mensajes de error.

local_files_only(`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben cargar únicamente los pesos y archivos de configuración del modelo locales. 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.

mirror (`str`, *opcional*) : Origen de espejo para resolver problemas de accesibilidad si estás descargando un modelo en China. No garantizamos la oportunidad ni la seguridad de la fuente, y debes consultar el sitio de espejo para obtener más información.

device_map (`int | str | torch.device` o `dict[str, int | str | torch.device]`, *opcional*) : Un mapa que especifica dónde debe ir cada submódulo. No es necesario definirlo para cada nombre de parámetro/buffer; una vez que un nombre de módulo dado está incluido, todos sus submódulos se enviarán al mismo dispositivo. El valor predeterminado es `None`, lo que significa que el modelo se cargará en la CPU. Ejemplos: ```py >>> from diffusers import AutoModel >>> import torch  >>> # This works. >>> model = AutoModel.from_pretrained( ...     "stabilityai/stable-diffusion-xl-base-1.0", subfolder="unet", device_map="cuda" ... ) >>> # This also works (integer accelerator device ID). >>> model = AutoModel.from_pretrained( ...     "stabilityai/stable-diffusion-xl-base-1.0", subfolder="unet", device_map=0 ... ) >>> # Specifying a supported offloading strategy like "auto" also works. >>> model = AutoModel.from_pretrained( ...     "stabilityai/stable-diffusion-xl-base-1.0", subfolder="unet", device_map="auto" ... ) >>> # Specifying a dictionary as `device_map` also works. >>> model = AutoModel.from_pretrained( ...     "stabilityai/stable-diffusion-xl-base-1.0", ...     subfolder="unet", ...     device_map={"": torch.device("cuda")}, ... ) ``` Establece `device_map="auto"` para que 🤗 Accelerate calcule automáticamente el `device_map` más optimizado. Para obtener más información sobre cada opción, consulta [el diseño de un device map](https://huggingface.co/docs/accelerate/en/concept_guides/big_model_inference#the-devicemap). También puedes referirte a la [documentación específica de Diffusers](https://huggingface.co/docs/diffusers/main/en/training/distributed_inference#model-sharding) para ejemplos más concretos.

max_memory (`Dict`, *opcional*) : Un diccionario de identificador de dispositivo para la memoria máxima. Si no se establece, se usará por defecto la memoria máxima disponible para cada GPU y la RAM de CPU disponible.

offload_folder (`str` o `os.PathLike`, *opcional*) : La ruta para descargar los pesos si `device_map` contiene el valor `"disk"`.

offload_state_dict (`bool`, *opcional*) : Si `True`, descarga temporalmente el state dict de la CPU al disco duro para evitar quedarse sin RAM de CPU si el peso del state dict de la CPU + el shard más grande del checkpoint no cabe. El valor predeterminado es `True` cuando hay alguna descarga al disco.

low_cpu_mem_usage (`bool`, *opcional*, por defecto `True` si la versión de torch >= 1.9.0, en caso contrario `False`) : Acelera la carga del modelo cargando solo los pesos preentrenados y no inicializando los pesos. Esto también intenta no usar más de 1x el tamaño del modelo en la memoria de CPU (incluida la memoria pico) mientras se carga el modelo. Solo se admite para PyTorch >= 1.9.0. Si estás usando una versión anterior de PyTorch, establecer este argumento en `True` generará un error.

variant (`str`, *opcional*) : Carga los pesos desde un nombre de archivo de `variant` especificado, como `"fp16"` o `"ema"`.

use_safetensors (`bool`, *opcional*, valor predeterminado `None`) : Si se establece en `None`, se descargan los pesos de `safetensors` si están disponibles **y** si la biblioteca `safetensors` está instalada. Si se establece en `True`, el modelo se carga forzosamente desde los pesos de `safetensors`. Si se establece en `False`, no se cargan los pesos de `safetensors`.

disable_mmap ('bool', *opcional*, valor predeterminado 'False') : Si se debe deshabilitar mmap al cargar un modelo de Safetensors. Esta opción puede ofrecer un mejor rendimiento cuando el modelo está en una unidad de red o en un disco duro, que pueden no manejar bien la naturaleza de búsquedas aleatorias de mmap.

use_flashpack (`bool`, *opcional*, valor predeterminado `False`) : Si se establece en `True`, el modelo se carga desde los pesos de `flashpack`.

flashpack_kwargs(`dict[str, Any]`, *opcional*, valor predeterminado `{}`) : Kwargs pasados a [`flashpack.deserialization.assign_from_file`](https://github.com/fal-ai/flashpack/blob/f1aa91c5cd9532a3dbf5bcc707ab9b01c274b76c/src/flashpack/deserialization.py#L408-L422)

Instanciar un modelo de PyTorch preentrenado a partir de una configuración de modelo preentrenado.

El modelo se configura en modo de evaluación - `model.eval()` - de forma predeterminada, y los módulos de dropout se desactivan. Para entrenar el modelo, devuélvalo al modo de entrenamiento con `model.train()`.

> [!TIP] > Para usar modelos privados o [con acceso restringido](https://huggingface.co/docs/hub/models-gated#gated-models), inicia sesión
con `hf > auth login`. También puedes activar el modo especial > ["offline-mode"](https://huggingface.co/diffusers/installation.html#offline-mode) para usar este método en un > entorno con cortafuegos.

Ejemplo:

```py
from diffusers import UNet2DConditionModel

unet = UNet2DConditionModel.from_pretrained("stable-diffusion-v1-5/stable-diffusion-v1-5", subfolder="unet")
```

Si obtienes el siguiente mensaje de error, necesitas ajustar los pesos para tu tarea de destino:

```bash
Some weights of UNet2DConditionModel were not initialized from the model checkpoint at stable-diffusion-v1-5/stable-diffusion-v1-5 and are newly initialized because the shapes did not match:
- conv_in.weight: found shape torch.Size([320, 4, 3, 3]) in the checkpoint and torch.Size([320, 9, 3, 3]) in the model instantiated
You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.
```

#### get_memory_footprint[[diffusers.ModelMixin.get_memory_footprint]]

```python
get_memory_footprint(return_buffers = True)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L2186)

**Parámetros:**

return_buffers (`bool`, *opcional*, valor predeterminado `True`) : Si se debe incluir el tamaño de los tensores de búfer en el cálculo de la huella de memoria. Los búferes son tensores que no requieren gradientes y no están registrados como parámetros. Por ejemplo, la media y la desviación estándar en las capas de normalización por lote. Consulte: https://discuss.pytorch.org/t/what-pytorch-means-by-buffers/120266/2

Obtén la huella de memoria de un modelo. Esto devolverá la huella de memoria del modelo actual en bytes. Útil para medir la huella de memoria del modelo actual y diseñar algunas pruebas. Solución inspirada en las discusiones de PyTorch: https://discuss.pytorch.org/t/gpu-memory-that-model-uses/56822/2

#### num_parameters[[diffusers.ModelMixin.num_parameters]]

```python
num_parameters(only_trainable: bool = False, exclude_embeddings: bool = False)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L2122)

**Parámetros:**

only_trainable (`bool`, *opcional*, por defecto `False`) : Si se debe devolver solo el número de parámetros entrenables.

exclude_embeddings (`bool`, *opcional*, por defecto `False`) : Si se debe devolver solo el número de parámetros que no son de incrustación.

**Devuelve:** `int`

El número de parámetros.

Obtener el número de parámetros (entrenables o no de incrustación) en el módulo.

Ejemplo:

```py
from diffusers import UNet2DConditionModel

model_id = "stable-diffusion-v1-5/stable-diffusion-v1-5"
unet = UNet2DConditionModel.from_pretrained(model_id, subfolder="unet")
unet.num_parameters(only_trainable=True)
859520964
```

#### reset_attention_backend[[diffusers.ModelMixin.reset_attention_backend]]

```python
reset_attention_backend()
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L667)

Restablece el backend de atención para el modelo. Las llamadas posteriores a `forward` usarán el valor predeterminado del entorno, si está configurado, o la atención de producto escalar de puntos nativa de torch.

#### save_pretrained[[diffusers.ModelMixin.save_pretrained]]

```python
save_pretrained(save_directory: str | os.PathLike, is_main_process: bool = True, save_function: typing.Optional[typing.Callable] = None, safe_serialization: bool = True, variant: str | None = None, max_shard_size: int | str = '10GB', push_to_hub: bool = False, use_flashpack: bool = False, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L686)

**Parámetros:**

save_directory (`str` o `os.PathLike`) : Directorio para guardar un modelo y su archivo de configuración. Se creará si no existe.

is_main_process (`bool`, *opcional*, valor predeterminado `True`) : Indica si el proceso que realiza esta llamada es el proceso principal o no. Útil durante el entrenamiento distribuido cuando es necesario llamar a esta función en todos los procesos. En este caso, establezca `is_main_process=True` solo en el proceso principal para evitar condiciones de carrera.

save_function (`Callable`) : La función que se utilizará para guardar el diccionario de estado. Útil durante el entrenamiento distribuido cuando necesitas reemplazar `torch.save` con otro método. Se puede configurar con la variable de entorno `DIFFUSERS_SAVE_MODE`.

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

variant (`str`, *opcional*) : Si se especifica, los pesos se guardan en el formato `pytorch_model.<variant>.bin`.

max_shard_size (`int` o `str`, por defecto `"10GB"`) : El tamaño máximo de un checkpoint antes de ser fragmentado. Los fragmentos del checkpoint tendrán cada uno un tamaño inferior a este valor. Si se expresa como una cadena de caracteres, debe consistir en dígitos seguidos de una unidad (como `"5GB"`). Si se expresa como un entero, la unidad son bytes. Tenga en cuenta que este límite se reducirá después de un cierto período de tiempo (a partir de octubre de 2024) para permitir a los usuarios actualizar a la última versión de `diffusers`. Esto se hace para establecer un tamaño predeterminado común para este argumento en diferentes bibliotecas del ecosistema de Hugging Face (`transformers` y `accelerate`, por ejemplo).

push_to_hub (`bool`, *opcional*, por defecto `False`) : Si se sube o no el modelo al Hugging Face Hub después de guardarlo. Puede especificar el repositorio al que desea subirlo con `repo_id` (por defecto, usará el nombre de `save_directory` en su espacio de nombres).

kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palabra clave adicionales que se pasan al método [push_to_hub()](/docs/diffusers/main/es/api/schedulers/overview#diffusers.utils.PushToHubMixin.push_to_hub).

Guarde un modelo y su archivo de configuración en un directorio para que pueda recargarse mediante el método de clase [from_pretrained()](/docs/diffusers/main/es/api/models/overview#diffusers.ModelMixin.from_pretrained).

#### set_attention_backend[[diffusers.ModelMixin.set_attention_backend]]

```python
set_attention_backend(backend: str)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L608)

**Parámetros:**

backend (`str`) : El nombre del backend a configurar. Debe ser uno de los backends disponibles definidos en `AttentionBackendName`. Los backends disponibles se encuentran en `diffusers.attention_dispatch.AttentionBackendName`. Por defecto, utiliza la atención de producto escalar nativa de torch como backend.

Establece el backend de atención para el modelo.

#### set_use_npu_flash_attention[[diffusers.ModelMixin.set_use_npu_flash_attention]]

```python
set_use_npu_flash_attention(valid: bool)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_utils.py#L335)

Establezca el interruptor para la atención flash de npu.

#### a[[diffusers.ModelMixin.to]]

```python
to(*args, **kwargs)
```

Un valor simulado para una ruta con puntos (p. ej. `torch.float32`): las cadenas de acceso a atributos y las llamadas se comportan como decoradores de paso, `repr` es la ruta con puntos, y su uso como clase base sustituye una base de `type` simple (PEP 560 `__mro_entries__`), de modo que las subclases reales conservan un metaclass normal y `inspect.signature` lee su `__init__` real en lugar del de un simulado.

## PushToHubMixin[[diffusers.utils.PushToHubMixin]]

#### diffusers.utils.PushToHubMixin[[diffusers.utils.PushToHubMixin]]

```python
diffusers.utils.PushToHubMixin()
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/utils/hub_utils.py#L491)

Un Mixin para subir un modelo, un programador o un pipeline al Hugging Face Hub.

#### push_to_hub[[diffusers.utils.PushToHubMixin.push_to_hub]]

```python
push_to_hub(repo_id: str, commit_message: str | None = None, private: bool | None = None, token: str | None = None, create_pr: bool = False, safe_serialization: bool = True, variant: str | None = None, subfolder: str | None = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/utils/hub_utils.py#L526)

**Parámetros:**

repo_id (`str`) : El nombre del repositorio al que deseas subir tus archivos de modelo, programador o pipeline. Debe incluir el nombre de tu organización cuando subas a una organización. `repo_id` también puede ser una ruta a un directorio local.

commit_message (`str`, *opcional*) : Mensaje para el commit al hacer push. El valor predeterminado es `"Upload {object}"`.

private (`bool`, *opcional*) : Si se debe hacer el repositorio privado. Si es `None` (predeterminado), el repositorio será público a menos que el valor predeterminado de la organización sea privado. Este valor se ignora si el repositorio ya existe.

token (`str`, *opcional*) : El token que se usará como autorización HTTP bearer para archivos remotos. El token generado al ejecutar `hf auth login` (guardado en `~/.huggingface`).

create_pr (`bool`, *opcional*, por defecto `False`) : Si se debe crear una PR con los archivos subidos o realizar el commit directamente.

safe_serialization (`bool`, *opcional*, por defecto `True`) : Si se deben convertir o no los pesos del modelo al formato `safetensors`.

variant (`str`, *opcional*) : Si se especifica, los pesos se guardan en el formato `pytorch_model.<variant>.bin`.

Sube archivos de modelo, programador o pipeline al 🤗 Hugging Face Hub.

Ejemplos:

```python
from diffusers import UNet2DConditionModel

unet = UNet2DConditionModel.from_pretrained("stabilityai/stable-diffusion-2", subfolder="unet")

# Push the `unet` to your namespace with the name "my-finetuned-unet".
unet.push_to_hub("my-finetuned-unet")

# Push the `unet` to an organization with the name "my-finetuned-unet".
unet.push_to_hub("your-org/my-finetuned-unet")
```