Buckets:

hf-doc-build
/

doc

Files

xet

hf-doc-build/doc / diffusers /main /es /optimization /fp16.md

mishig

about 3 hours ago

preview code

download

raw

14.8 kB

# Precisión y compilación

La baja precisión y la compilación son dos formas de acelerar la inferencia de Diffusers. Cargue los pesos en `bfloat16` o `float16` y, a continuación, compile el desruidador (el UNet o el transformer) con `torch.compile` o compilación regional.

## Tipo de datos del modelo

La precisión y el tipo de datos de los pesos del modelo afectan la velocidad de inferencia, ya que una mayor precisión requiere más memoria para cargarlos y más tiempo para realizar los cálculos. Diffusers carga los pesos del modelo en `float32` cuando se omite `dtype`, por lo que cambiar el tipo de datos es una forma sencilla de obtener una inferencia más rápida.

`bfloat16` es similar a `float16`, pero es más robusto ante errores numéricos. El soporte de hardware para `bfloat16` varía, pero la mayoría de las GPU modernas son capaces de admitir `bfloat16`.

```py
import torch
from diffusers import StableDiffusionXLPipeline
pipeline = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.bfloat16
).to("cuda")  # or "mps", "xpu", "cpu"
prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
pipeline(prompt, num_inference_steps=30).images[0]
```

`float16` es similar a `bfloat16`, pero puede ser más propenso a errores numéricos.

```py
import torch
from diffusers import StableDiffusionXLPipeline
pipeline = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
pipeline(prompt, num_inference_steps=30).images[0]
```

El modo [TensorFloat-32](https://blogs.nvidia.com/blog/2020/05/14/tensorfloat-32-precision-format/) (`tf32`) es compatible con las GPU NVIDIA Ampere y más recientes, y calcula las operaciones de convolución y multiplicación de matrices en `tf32`. El almacenamiento y las demás operaciones se mantienen en `float32`. Acelera las operaciones que se ejecutan en `float32`, por lo que resulta más útil cuando el pipeline o partes de él permanecen en `float32`.

PyTorch solo habilita el modo `tf32` para las convoluciones de forma predeterminada y es necesario habilitarlo explícitamente para las multiplicaciones de matrices.

```py
import torch
from diffusers import StableDiffusionXLPipeline
torch.backends.cuda.matmul.allow_tf32 = True
pipeline = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float32
).to("cuda")  # or "mps", "xpu", "cpu"
prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
pipeline(prompt, num_inference_steps=30).images[0]
```

Consulte la documentación de [entrenamiento con precisión mixta](https://huggingface.co/docs/transformers/en/perf_train_gpu_one#mixed-precision) para obtener más detalles.

## Atención de producto escalar

[La atención de producto escalar de puntos (SDPA)](https://pytorch.org/docs/stable/generated/torch.nn.functional.scaled_dot_product_attention.html) es la atención predeterminada en PyTorch 2.0 y versiones posteriores, a través de `AttnProcessor2_0` o el backend `native` del despachador de atención. PyTorch elige un kernel de SDPA para tu hardware. Para FlashAttention, SageAttention, xFormers, kernels de Hub y otros backends, consulta [Backends de atención](./attention_backends).

## torch.compile

[torch.compile](https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html) acelera la inferencia al compilar el código y las operaciones de PyTorch en kernels optimizados. Normalmente se compila el denoiser, que domina el tiempo de ejecución, ya sea `pipeline.unet` o `pipeline.transformer`, y a veces también el VAE.

Habilite los siguientes ajustes del compilador para obtener la máxima velocidad (consulte la [lista completa](https://github.com/pytorch/pytorch/blob/main/torch/_inductor/config.py) para más opciones).

```py
import torch
from diffusers import StableDiffusionXLPipeline
torch._inductor.config.conv_1x1_as_mm = True
torch._inductor.config.coordinate_descent_tuning = True
torch._inductor.config.epilogue_fusion = False
torch._inductor.config.coordinate_descent_check_all_directions = True
```

Carga y compila el denoiser y el VAE. Usa `pipeline.unet` en pipelines de UNet como Stable Diffusion XL, o `pipeline.transformer` en pipelines de Flux y estilo DiT. Hay varios modos diferentes entre los que puedes elegir, pero `"max-autotune"` busca los kernels más rápidos y usa CUDA graphs. Los CUDA graphs reducen la sobrecarga al lanzar múltiples operaciones de GPU a través de una sola operación de CPU.

Cambiar el diseño de memoria a [channels_last](./memory#torchchannelslast) también puede acelerar modelos con muchas convoluciones, como UNets y VAEs. Realice una prueba de rendimiento primero, ya que algunos modelos se ejecutan más lentamente.

```py
pipeline = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
pipeline.unet.to(memory_format=torch.channels_last)
pipeline.unet = torch.compile(
    pipeline.unet, mode="max-autotune", fullgraph=True
)
pipeline.vae.to(memory_format=torch.channels_last)
pipeline.vae.decode = torch.compile(
    pipeline.vae.decode,
    mode="max-autotune",
    fullgraph=True
)
prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
pipeline(prompt, num_inference_steps=30).images[0]
```

La compilación es lenta la primera vez, especialmente con `"max-autotune"`, porque el compilador busca kernels y luego sigue utilizando el mismo objeto de pipeline compilado (consulte [Caché de tiempo de compilación](https://docs.pytorch.org/tutorials/recipes/torch_compile_caching_tutorial.html) y [Configuración de caché](https://docs.pytorch.org/tutorials/recipes/torch_compile_caching_configuration_tutorial.html) para saber cómo configurar el comportamiento de la caché). Llamar al pipeline compilado con un tamaño de imagen diferente provoca una recompilación.

### Compilación de formas dinámicas

`torch.compile` mantiene un registro de las formas de entrada y las condiciones, y si estas son diferentes, recompila el modelo. Por ejemplo, si un modelo se compila con una imagen de resolución 1024x1024 y se utiliza con una imagen de una resolución diferente, se desencadena la recompilación.

Para evitar la recompilación, agregue `dynamic=True` para intentar generar un kernel más dinámico y así evitar la recompilación cuando cambien las condiciones.

```diff
+ torch.fx.experimental._config.use_duck_shape = False
+ pipeline.unet = torch.compile(
    pipeline.unet, fullgraph=True, dynamic=True
)
```

Especificar `use_duck_shape=False` indica al compilador si debe usar la misma variable simbólica para representar tamaños de entrada que son iguales. Para más detalles, consulta este [comentario](https://github.com/huggingface/diffusers/pull/11327#discussion_r2047659790).

No todos los modelos pueden beneficiarse de la compilación dinámica de forma predeterminada y pueden requerir cambios. Consulte este [PR](https://github.com/huggingface/diffusers/pull/11297/) que mejoró la implementación de [AuraFlowPipeline](/docs/diffusers/main/es/api/pipelines/aura_flow#diffusers.AuraFlowPipeline) para beneficiarse de la compilación dinámica.

Siéntase libre de abrir un problema si la compilación dinámica no funciona como se espera para un modelo de Diffusers.

### Compilación regional

La [compilación regional](https://docs.pytorch.org/tutorials/recipes/regional_compilation.html) reduce la latencia de inicio en frío al compilar únicamente los *bloques pequeños y repetidos con frecuencia* de un modelo, típicamente una capa de transformer, y permite reutilizar los artefactos compilados para cada ocurrencia posterior. Para muchas arquitecturas de difusión, esto ofrece mejoras de velocidad de ejecución comparables a la compilación de todo el grafo y puede reducir el tiempo de compilación hasta 8–10 veces.

Utilice el método [compile_repeated_blocks()](/docs/diffusers/main/es/api/models/overview#diffusers.ModelMixin.compile_repeated_blocks), un auxiliar que envuelve `torch.compile`, en el denoiser. Llámelo en `pipeline.unet` o `pipeline.transformer`, según el pipeline.

```py
import torch
from diffusers import StableDiffusionXLPipeline
pipeline = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    dtype=torch.float16,
).to("cuda")  # or "mps", "xpu", "cpu"
pipeline.unet.compile_repeated_blocks(fullgraph=True)
```

Para habilitar la compilación regional para un nuevo modelo, establezca `_repeated_blocks` con los nombres de las clases de los bloques repetidos (cadenas). Para el UNet de SDXL, use `BasicTransformerBlock`. Los desruidadores Transformer enumeran los nombres de sus propias clases de bloques repetidos de la misma manera.

```py
_repeated_blocks = ["BasicTransformerBlock"]
```

También existe un método [compile_regions](https://github.com/huggingface/accelerate/blob/273799c85d849a1954a4f2e65767216eb37fa089/src/accelerate/utils/other.py#L78) en [Accelerate](https://huggingface.co/docs/accelerate/index) que selecciona automáticamente los bloques candidatos de un modelo para compilar. El resto del grafo se compila por separado. Esto es útil para experimentos rápidos, ya que no hay tantas opciones para configurar qué bloques compilar o ajustar las banderas de compilación.

```bash
pip install -U accelerate
```

```py
import torch
from diffusers import StableDiffusionXLPipeline
from accelerate.utils import compile_regions
pipeline = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
pipeline.unet = compile_regions(pipeline.unet, mode="reduce-overhead", fullgraph=True)
```

[compile_repeated_blocks()](/docs/diffusers/main/es/api/models/overview#diffusers.ModelMixin.compile_repeated_blocks) es intencionalmente explícito. Enumera los bloques a repetir en `_repeated_blocks` y el helper solo compila esos bloques. Ofrece un comportamiento predecible y facilita razonar sobre la reutilización de la caché en una sola línea de código.

### Puntos de interrupción del grafo

Establezca `fullgraph=True` para que torch.compile genere un error ante una interrupción del grafo en lugar de dividir el grafo de forma silenciosa, lo cual reduce la aceleración.

### Sincronización de GPU

Después de cada predicción del denoiser, el pipeline llama al método `step` del scheduler, que indexa `sigmas`. Mantener `sigmas` en la GPU puede forzar una sincronización CPU↔GPU en cada paso. Ese coste es fácil de pasar por alto hasta que el denoiser se compila. Es preferible dejar `sigmas` en la CPU (los schedulers de Diffusers, como Euler, ya lo hacen).

### Benchmarks

Consulte el conjunto de datos [diffusers/benchmarks](https://huggingface.co/datasets/diffusers/benchmarks) para ver los datos de latencia de inferencia y uso de memoria de las tuberías compiladas.

El repositorio [diffusers-torchao](https://github.com/sayakpaul/diffusers-torchao#benchmarking-results) también contiene resultados de benchmarking para las versiones compiladas de Flux y CogVideoX.

## Kernels

[Kernels](https://huggingface.co/docs/kernels/index) es una biblioteca para construir, distribuir y cargar kernels de cómputo optimizados en el [Hub](https://huggingface.co/kernels-community). Admite kernels de [attention](./attention_backends#set-a-backend-on-the-model) y kernels CUDA personalizados para operaciones como RMSNorm, GEGLU, RoPE y AdaLN.

La guía de [Integración de pipelines de Diffusers](https://github.com/huggingface/kernels/blob/main/kernel-builder/skills/cuda-kernels/references/diffusers-integration.md) muestra cómo integrar un kernel con la habilidad [add cuda-kernels](https://github.com/huggingface/kernels/blob/main/kernel-builder/skills/cuda-kernels/SKILL.md). Esta habilidad permite que un agente, como Claude o Codex, escriba kernels personalizados dirigidos a un modelo específico y a tu hardware. La publicación [Custom kernels for all from Codex and Claude](https://huggingface.co/blog/custom-cuda-kernels-agent-skills) ofrece más detalles.

Por ejemplo, un kernel RMSNorm personalizado (generado por la habilidad `add cuda-kernels`) con [torch.compile](#torchcompile) acelera la generación de LTX-Video 1.43 veces en una H100.

<iframe src="https://huggingface.co/datasets/docs-benchmarks/kernel-ltx-video/embed/viewer/default/train" frameborder="0" width="100%" height="560px"
>

## Cuantización dinámica

La cuantización dinámica de activaciones int8 está disponible en [torchao](../quantization/torchao). Utilice [TorchAoConfig](/docs/diffusers/main/es/api/quantization#diffusers.TorchAoConfig) con una configuración como [`Int8DynamicActivationInt8WeightConfig`](https://docs.pytorch.org/ao/stable/api_reference/generated/torchao.quantization.Int8DynamicActivationInt8WeightConfig.html), o la API `quantize_` de torchao. No utilice el helper anterior `apply_dynamic_quant`.

## Matrices de proyección fusionadas

> [!WARNING]
> `~DiffusionPipeline.fuse_qkv_projections` es experimental.

Una entrada se proyecta en tres subespacios, representados por las matrices de proyección Q, K y V, en un bloque de atención. Estas proyecciones suelen calcularse por separado, pero se pueden combinar horizontalmente en una única matriz y realizar la proyección en un solo paso. Esto aumenta el tamaño de las multiplicaciones de matrices de las proyecciones de entrada y también mejora el impacto de la cuantización.

```py
pipeline.fuse_qkv_projections()
```

## Próximos pasos

- Lee la publicación de blog [Presenting Flux Fast: Making Flux go brrr on H100s](https://pytorch.org/blog/presenting-flux-fast-making-flux-go-brrr-on-h100s/) para saber más sobre cómo puedes combinar todas estas optimizaciones con [TorchInductor](https://docs.pytorch.org/docs/stable/torch.compiler.html) y [AOTInductor](https://docs.pytorch.org/docs/stable/torch.compiler_aot_inductor.html) para lograr una aceleración de ~2.5x utilizando las recetas de [flux-fast](https://github.com/huggingface/flux-fast).

    Estas recetas admiten hardware de AMD y [Flux.1 Kontext Dev](https://huggingface.co/black-forest-labs/FLUX.1-Kontext-dev).
- Consulte la publicación de blog [torch.compile and Diffusers: A Hands-On Guide to Peak Performance](https://pytorch.org/blog/torch-compile-and-diffusers-a-hands-on-guide-to-peak-performance/) para maximizar el rendimiento con `torch.compile` en modelos de difusión.

Xet Storage Details

Size:: 14.8 kB
Xet hash:: 359bc677505f8b9ce88efed1687a0f7ac6fb6b8939144ee956c7bf4b1adb3e46

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

	# Precisión y compilación

	La baja precisión y la compilación son dos formas de acelerar la inferencia de Diffusers. Cargue los pesos en `bfloat16` o `float16` y, a continuación, compile el desruidador (el UNet o el transformer) con `torch.compile` o compilación regional.

	## Tipo de datos del modelo

	La precisión y el tipo de datos de los pesos del modelo afectan la velocidad de inferencia, ya que una mayor precisión requiere más memoria para cargarlos y más tiempo para realizar los cálculos. Diffusers carga los pesos del modelo en `float32` cuando se omite `dtype`, por lo que cambiar el tipo de datos es una forma sencilla de obtener una inferencia más rápida.

	`bfloat16` es similar a `float16`, pero es más robusto ante errores numéricos. El soporte de hardware para `bfloat16` varía, pero la mayoría de las GPU modernas son capaces de admitir `bfloat16`.

	```py
	import torch
	from diffusers import StableDiffusionXLPipeline

	pipeline = StableDiffusionXLPipeline.from_pretrained(
	"stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.bfloat16
	).to("cuda") # or "mps", "xpu", "cpu"

	prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
	pipeline(prompt, num_inference_steps=30).images[0]
	```

	`float16` es similar a `bfloat16`, pero puede ser más propenso a errores numéricos.

	```py
	import torch
	from diffusers import StableDiffusionXLPipeline

	pipeline = StableDiffusionXLPipeline.from_pretrained(
	"stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16
	).to("cuda") # or "mps", "xpu", "cpu"

	prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
	pipeline(prompt, num_inference_steps=30).images[0]
	```

	El modo [TensorFloat-32](https://blogs.nvidia.com/blog/2020/05/14/tensorfloat-32-precision-format/) (`tf32`) es compatible con las GPU NVIDIA Ampere y más recientes, y calcula las operaciones de convolución y multiplicación de matrices en `tf32`. El almacenamiento y las demás operaciones se mantienen en `float32`. Acelera las operaciones que se ejecutan en `float32`, por lo que resulta más útil cuando el pipeline o partes de él permanecen en `float32`.

	PyTorch solo habilita el modo `tf32` para las convoluciones de forma predeterminada y es necesario habilitarlo explícitamente para las multiplicaciones de matrices.

	```py
	import torch
	from diffusers import StableDiffusionXLPipeline

	torch.backends.cuda.matmul.allow_tf32 = True

	pipeline = StableDiffusionXLPipeline.from_pretrained(
	"stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float32
	).to("cuda") # or "mps", "xpu", "cpu"

	prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
	pipeline(prompt, num_inference_steps=30).images[0]
	```

	Consulte la documentación de [entrenamiento con precisión mixta](https://huggingface.co/docs/transformers/en/perf_train_gpu_one#mixed-precision) para obtener más detalles.

	## Atención de producto escalar

	[La atención de producto escalar de puntos (SDPA)](https://pytorch.org/docs/stable/generated/torch.nn.functional.scaled_dot_product_attention.html) es la atención predeterminada en PyTorch 2.0 y versiones posteriores, a través de `AttnProcessor2_0` o el backend `native` del despachador de atención. PyTorch elige un kernel de SDPA para tu hardware. Para FlashAttention, SageAttention, xFormers, kernels de Hub y otros backends, consulta [Backends de atención](./attention_backends).

	## torch.compile

	[torch.compile](https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html) acelera la inferencia al compilar el código y las operaciones de PyTorch en kernels optimizados. Normalmente se compila el denoiser, que domina el tiempo de ejecución, ya sea `pipeline.unet` o `pipeline.transformer`, y a veces también el VAE.

	Habilite los siguientes ajustes del compilador para obtener la máxima velocidad (consulte la [lista completa](https://github.com/pytorch/pytorch/blob/main/torch/_inductor/config.py) para más opciones).

	```py
	import torch
	from diffusers import StableDiffusionXLPipeline

	torch._inductor.config.conv_1x1_as_mm = True
	torch._inductor.config.coordinate_descent_tuning = True
	torch._inductor.config.epilogue_fusion = False
	torch._inductor.config.coordinate_descent_check_all_directions = True
	```

	Carga y compila el denoiser y el VAE. Usa `pipeline.unet` en pipelines de UNet como Stable Diffusion XL, o `pipeline.transformer` en pipelines de Flux y estilo DiT. Hay varios modos diferentes entre los que puedes elegir, pero `"max-autotune"` busca los kernels más rápidos y usa CUDA graphs. Los CUDA graphs reducen la sobrecarga al lanzar múltiples operaciones de GPU a través de una sola operación de CPU.

	Cambiar el diseño de memoria a [channels_last](./memory#torchchannelslast) también puede acelerar modelos con muchas convoluciones, como UNets y VAEs. Realice una prueba de rendimiento primero, ya que algunos modelos se ejecutan más lentamente.

	```py
	pipeline = StableDiffusionXLPipeline.from_pretrained(
	"stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16
	).to("cuda") # or "mps", "xpu", "cpu"
	pipeline.unet.to(memory_format=torch.channels_last)
	pipeline.unet = torch.compile(
	pipeline.unet, mode="max-autotune", fullgraph=True
	)
	pipeline.vae.to(memory_format=torch.channels_last)
	pipeline.vae.decode = torch.compile(
	pipeline.vae.decode,
	mode="max-autotune",
	fullgraph=True
	)

	prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
	pipeline(prompt, num_inference_steps=30).images[0]
	```

	La compilación es lenta la primera vez, especialmente con `"max-autotune"`, porque el compilador busca kernels y luego sigue utilizando el mismo objeto de pipeline compilado (consulte [Caché de tiempo de compilación](https://docs.pytorch.org/tutorials/recipes/torch_compile_caching_tutorial.html) y [Configuración de caché](https://docs.pytorch.org/tutorials/recipes/torch_compile_caching_configuration_tutorial.html) para saber cómo configurar el comportamiento de la caché). Llamar al pipeline compilado con un tamaño de imagen diferente provoca una recompilación.

	### Compilación de formas dinámicas

	`torch.compile` mantiene un registro de las formas de entrada y las condiciones, y si estas son diferentes, recompila el modelo. Por ejemplo, si un modelo se compila con una imagen de resolución 1024x1024 y se utiliza con una imagen de una resolución diferente, se desencadena la recompilación.

	Para evitar la recompilación, agregue `dynamic=True` para intentar generar un kernel más dinámico y así evitar la recompilación cuando cambien las condiciones.

	```diff
	+ torch.fx.experimental._config.use_duck_shape = False
	+ pipeline.unet = torch.compile(
	pipeline.unet, fullgraph=True, dynamic=True
	)
	```

	Especificar `use_duck_shape=False` indica al compilador si debe usar la misma variable simbólica para representar tamaños de entrada que son iguales. Para más detalles, consulta este [comentario](https://github.com/huggingface/diffusers/pull/11327#discussion_r2047659790).

	No todos los modelos pueden beneficiarse de la compilación dinámica de forma predeterminada y pueden requerir cambios. Consulte este [PR](https://github.com/huggingface/diffusers/pull/11297/) que mejoró la implementación de [AuraFlowPipeline](/docs/diffusers/main/es/api/pipelines/aura_flow#diffusers.AuraFlowPipeline) para beneficiarse de la compilación dinámica.

	Siéntase libre de abrir un problema si la compilación dinámica no funciona como se espera para un modelo de Diffusers.

	### Compilación regional

	La [compilación regional](https://docs.pytorch.org/tutorials/recipes/regional_compilation.html) reduce la latencia de inicio en frío al compilar únicamente los bloques pequeños y repetidos con frecuencia de un modelo, típicamente una capa de transformer, y permite reutilizar los artefactos compilados para cada ocurrencia posterior. Para muchas arquitecturas de difusión, esto ofrece mejoras de velocidad de ejecución comparables a la compilación de todo el grafo y puede reducir el tiempo de compilación hasta 8–10 veces.

	Utilice el método [compile_repeated_blocks()](/docs/diffusers/main/es/api/models/overview#diffusers.ModelMixin.compile_repeated_blocks), un auxiliar que envuelve `torch.compile`, en el denoiser. Llámelo en `pipeline.unet` o `pipeline.transformer`, según el pipeline.

	```py
	import torch
	from diffusers import StableDiffusionXLPipeline

	pipeline = StableDiffusionXLPipeline.from_pretrained(
	"stabilityai/stable-diffusion-xl-base-1.0",
	dtype=torch.float16,
	).to("cuda") # or "mps", "xpu", "cpu"
	pipeline.unet.compile_repeated_blocks(fullgraph=True)
	```

	Para habilitar la compilación regional para un nuevo modelo, establezca `_repeated_blocks` con los nombres de las clases de los bloques repetidos (cadenas). Para el UNet de SDXL, use `BasicTransformerBlock`. Los desruidadores Transformer enumeran los nombres de sus propias clases de bloques repetidos de la misma manera.

	```py
	_repeated_blocks = ["BasicTransformerBlock"]
	```

	También existe un método [compile_regions](https://github.com/huggingface/accelerate/blob/273799c85d849a1954a4f2e65767216eb37fa089/src/accelerate/utils/other.py#L78) en [Accelerate](https://huggingface.co/docs/accelerate/index) que selecciona automáticamente los bloques candidatos de un modelo para compilar. El resto del grafo se compila por separado. Esto es útil para experimentos rápidos, ya que no hay tantas opciones para configurar qué bloques compilar o ajustar las banderas de compilación.

	```bash
	pip install -U accelerate
	```

	```py
	import torch
	from diffusers import StableDiffusionXLPipeline
	from accelerate.utils import compile_regions

	pipeline = StableDiffusionXLPipeline.from_pretrained(
	"stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16
	).to("cuda") # or "mps", "xpu", "cpu"
	pipeline.unet = compile_regions(pipeline.unet, mode="reduce-overhead", fullgraph=True)
	```

	[compile_repeated_blocks()](/docs/diffusers/main/es/api/models/overview#diffusers.ModelMixin.compile_repeated_blocks) es intencionalmente explícito. Enumera los bloques a repetir en `_repeated_blocks` y el helper solo compila esos bloques. Ofrece un comportamiento predecible y facilita razonar sobre la reutilización de la caché en una sola línea de código.

	### Puntos de interrupción del grafo

	Establezca `fullgraph=True` para que torch.compile genere un error ante una interrupción del grafo en lugar de dividir el grafo de forma silenciosa, lo cual reduce la aceleración.

	### Sincronización de GPU

	Después de cada predicción del denoiser, el pipeline llama al método `step` del scheduler, que indexa `sigmas`. Mantener `sigmas` en la GPU puede forzar una sincronización CPU↔GPU en cada paso. Ese coste es fácil de pasar por alto hasta que el denoiser se compila. Es preferible dejar `sigmas` en la CPU (los schedulers de Diffusers, como Euler, ya lo hacen).

	### Benchmarks

	Consulte el conjunto de datos [diffusers/benchmarks](https://huggingface.co/datasets/diffusers/benchmarks) para ver los datos de latencia de inferencia y uso de memoria de las tuberías compiladas.

	El repositorio [diffusers-torchao](https://github.com/sayakpaul/diffusers-torchao#benchmarking-results) también contiene resultados de benchmarking para las versiones compiladas de Flux y CogVideoX.

	## Kernels

	[Kernels](https://huggingface.co/docs/kernels/index) es una biblioteca para construir, distribuir y cargar kernels de cómputo optimizados en el [Hub](https://huggingface.co/kernels-community). Admite kernels de [attention](./attention_backends#set-a-backend-on-the-model) y kernels CUDA personalizados para operaciones como RMSNorm, GEGLU, RoPE y AdaLN.

	La guía de [Integración de pipelines de Diffusers](https://github.com/huggingface/kernels/blob/main/kernel-builder/skills/cuda-kernels/references/diffusers-integration.md) muestra cómo integrar un kernel con la habilidad [add cuda-kernels](https://github.com/huggingface/kernels/blob/main/kernel-builder/skills/cuda-kernels/SKILL.md). Esta habilidad permite que un agente, como Claude o Codex, escriba kernels personalizados dirigidos a un modelo específico y a tu hardware. La publicación [Custom kernels for all from Codex and Claude](https://huggingface.co/blog/custom-cuda-kernels-agent-skills) ofrece más detalles.

	Por ejemplo, un kernel RMSNorm personalizado (generado por la habilidad `add cuda-kernels`) con [torch.compile](#torchcompile) acelera la generación de LTX-Video 1.43 veces en una H100.

	<iframe src="https://huggingface.co/datasets/docs-benchmarks/kernel-ltx-video/embed/viewer/default/train" frameborder="0" width="100%" height="560px"
	>

	## Cuantización dinámica

	La cuantización dinámica de activaciones int8 está disponible en [torchao](../quantization/torchao). Utilice [TorchAoConfig](/docs/diffusers/main/es/api/quantization#diffusers.TorchAoConfig) con una configuración como [`Int8DynamicActivationInt8WeightConfig`](https://docs.pytorch.org/ao/stable/api_reference/generated/torchao.quantization.Int8DynamicActivationInt8WeightConfig.html), o la API `quantize_` de torchao. No utilice el helper anterior `apply_dynamic_quant`.

	## Matrices de proyección fusionadas

	> [!WARNING]
	> `~DiffusionPipeline.fuse_qkv_projections` es experimental.

	Una entrada se proyecta en tres subespacios, representados por las matrices de proyección Q, K y V, en un bloque de atención. Estas proyecciones suelen calcularse por separado, pero se pueden combinar horizontalmente en una única matriz y realizar la proyección en un solo paso. Esto aumenta el tamaño de las multiplicaciones de matrices de las proyecciones de entrada y también mejora el impacto de la cuantización.

	```py
	pipeline.fuse_qkv_projections()
	```

	## Próximos pasos

	- Lee la publicación de blog [Presenting Flux Fast: Making Flux go brrr on H100s](https://pytorch.org/blog/presenting-flux-fast-making-flux-go-brrr-on-h100s/) para saber más sobre cómo puedes combinar todas estas optimizaciones con [TorchInductor](https://docs.pytorch.org/docs/stable/torch.compiler.html) y [AOTInductor](https://docs.pytorch.org/docs/stable/torch.compiler_aot_inductor.html) para lograr una aceleración de ~2.5x utilizando las recetas de [flux-fast](https://github.com/huggingface/flux-fast).

	Estas recetas admiten hardware de AMD y [Flux.1 Kontext Dev](https://huggingface.co/black-forest-labs/FLUX.1-Kontext-dev).

	- Consulte la publicación de blog [torch.compile and Diffusers: A Hands-On Guide to Peak Performance](https://pytorch.org/blog/torch-compile-and-diffusers-a-hands-on-guide-to-peak-performance/) para maximizar el rendimiento con `torch.compile` en modelos de difusión.