Buckets:

hf-doc-build
/

doc

Files

xet

hf-doc-build/doc / diffusers /v0.43.0 /zh /optimization /speed-memory-optims.md

mishig

2 days ago

preview code

download

raw

8.28 kB

# 编译和卸载量化模型

优化模型通常需要在[推理速度](./fp16)和[内存占用](./memory)之间进行权衡。例如，[缓存](./cache)虽然可以提升推理速度，但由于需要存储中间注意力层的输出，也会增加内存消耗。一种更为均衡的优化策略是将模型量化、[torch.compile](./fp16#torchcompile)以及多种[卸载方法](./memory#offloading)相结合。

> [!TIP]
> 请参阅 [torch.compile](./fp16#torchcompile) 指南，以了解有关编译的更多信息以及在此处如何应用它们。例如，区域编译可以在不牺牲任何加速效果的情况下显著缩短编译时间。

在图像生成中，将量化与[模型卸载](./memory#model-offloading)相结合，通常能在质量、速度和内存之间取得最佳平衡。组卸载在图像生成中效果不佳，因为如果计算内核完成得更快，通常无法*完全*重叠数据传输。这会导致 CPU 和 GPU 之间产生一定的通信开销。

对于视频生成，结合量化和 [group-offloading](./memory#group-offloading) 通常效果更好，因为视频模型更受计算限制。

下表提供了 Flux 优化策略组合及其对延迟和内存使用影响的比较。

| 组合 | 延迟（秒） | 内存使用量（GB） |
|---|---|---|
| 量化  | 32.602 | 14.9453 |
| 量化，torch.compile  | 25.847 | 14.9448 |
| 量化、torch.compile、模型 CPU 卸载 | 32.312 | 12.2369 |

这些结果是在 Flux 上使用 RTX 4090 进行基准测试得出的。transformer 和 text_encoder 组件已进行量化。如果您想评估自己的模型，请参阅基准测试脚本。
本指南将演示如何使用 [bitsandbytes](../quantization/bitsandbytes#torchcompile) 编译并卸载量化模型。请确保你使用的是 [PyTorch nightly](https://pytorch.org/get-started/locally/) 以及 bitsandbytes 的最新版本。
虽然本示例使用了 bitsandbytes，但其他量化后端（例如 [TorchAO](../quantization/torchao)）也支持这些功能。
```bash
pip install -U bitsandbytes
```
## 量化与 torch.compile
首先对模型进行[量化](../quantization/overview)以降低存储所需的内存，然后对其进行[编译](./fp16#torchcompile)以加速推理。
配置 [Dynamo](https://docs.pytorch.org/docs/stable/torch.compiler_dynamo_overview.html) 的 `capture_dynamic_output_shape_ops = True`，以在编译 bitsandbytes 模型时处理动态输出。
```py
import torch
from diffusers import DiffusionPipeline
from diffusers.quantizers import PipelineQuantizationConfig
torch._dynamo.config.capture_dynamic_output_shape_ops = True

# quantize
pipeline_quant_config = PipelineQuantizationConfig(
    quant_backend="bitsandbytes_4bit",
    quant_kwargs={"load_in_4bit": True, "bnb_4bit_quant_type": "nf4", "bnb_4bit_compute_dtype": torch.bfloat16},
    components_to_quantize=["transformer", "text_encoder_2"],
)
pipeline = DiffusionPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    quantization_config=pipeline_quant_config,
    dtype=torch.bfloat16,
).to("cuda")  # or "mps", "xpu", "cpu"
# compile
pipeline.transformer.to(memory_format=torch.channels_last)
pipeline.transformer.compile(mode="max-autotune", fullgraph=True)
pipeline("""
    cinematic film still of a cat sipping a margarita in a pool in Palm Springs, California
    highly detailed, high budget hollywood movie, cinemascope, moody, epic, gorgeous, film grain
"""
).images[0]
```
## 量化、torch.compile 和卸载

除了量化和 torch.compile，如果还需要进一步降低内存占用，可以尝试使用 offloading。Offloading 会根据计算需求，将各个层或模型组件在 CPU 和 GPU 之间进行移动。

在卸载过程中配置 [Dynamo](https://docs.pytorch.org/docs/stable/torch.compiler_dynamo_overview.html) 的 `cache_size_limit` 以避免过度重新编译，并设置 `capture_dynamic_output_shape_ops = True` 以在处理 bitsandbytes 模型的编译时应对动态输出。

[模型 CPU 卸载](./memory#model-offloading)会在需要计算时，将单个流水线组件（例如 transformer 模型）移至 GPU。否则，该组件会被卸载到 CPU。

```py
import torch
from diffusers import DiffusionPipeline
from diffusers.quantizers import PipelineQuantizationConfig
torch._dynamo.config.cache_size_limit = 1000
torch._dynamo.config.capture_dynamic_output_shape_ops = True
# quantize
pipeline_quant_config = PipelineQuantizationConfig(
    quant_backend="bitsandbytes_4bit",
    quant_kwargs={"load_in_4bit": True, "bnb_4bit_quant_type": "nf4", "bnb_4bit_compute_dtype": torch.bfloat16},
    components_to_quantize=["transformer", "text_encoder_2"],
)
pipeline = DiffusionPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    quantization_config=pipeline_quant_config,
    dtype=torch.bfloat16,
).to("cuda")  # or "mps", "xpu", "cpu"
# model CPU offloading
pipeline.enable_model_cpu_offload()
# compile
pipeline.transformer.compile()
pipeline(
    "cinematic film still of a cat sipping a margarita in a pool in Palm Springs, California, highly detailed, high budget hollywood movie, cinemascope, moody, epic, gorgeous, film grain"
).images[0]
```

[组卸载](./memory#group-offloading)会将单个流水线组件（例如 transformer 模型）的内部层移至 GPU 进行计算，并在不需要时将其卸载。同时，它利用 [CUDA stream](./memory#cuda-stream) 特性预取下一层以执行。

通过重叠计算和数据传输，它比模型 CPU 卸载更快，同时还能节省内存。

```py
# pip install ftfy
import torch
from diffusers import AutoModel, DiffusionPipeline
from diffusers.hooks import apply_group_offloading
from diffusers.utils import export_to_video
from diffusers.quantizers import PipelineQuantizationConfig
from transformers import UMT5EncoderModel
torch._dynamo.config.cache_size_limit = 1000
torch._dynamo.config.capture_dynamic_output_shape_ops = True
# quantize
pipeline_quant_config = PipelineQuantizationConfig(
    quant_backend="bitsandbytes_4bit",
    quant_kwargs={"load_in_4bit": True, "bnb_4bit_quant_type": "nf4", "bnb_4bit_compute_dtype": torch.bfloat16},
    components_to_quantize=["transformer", "text_encoder"],
)
text_encoder = UMT5EncoderModel.from_pretrained(
    "Wan-AI/Wan2.1-T2V-14B-Diffusers", subfolder="text_encoder", dtype=torch.bfloat16
)
pipeline = DiffusionPipeline.from_pretrained(
    "Wan-AI/Wan2.1-T2V-14B-Diffusers",
    quantization_config=pipeline_quant_config,
    dtype=torch.bfloat16,
).to("cuda")  # or "mps", "xpu", "cpu"
# group offloading
onload_device = torch.device("cuda")
offload_device = torch.device("cpu")
pipeline.transformer.enable_group_offload(
    onload_device=onload_device,
    offload_device=offload_device,
    offload_type="leaf_level",
    use_stream=True,
    non_blocking=True
)
pipeline.vae.enable_group_offload(
    onload_device=onload_device,
    offload_device=offload_device,
    offload_type="leaf_level",
    use_stream=True,
    non_blocking=True
)
apply_group_offloading(
    pipeline.text_encoder,
    onload_device=onload_device,
    offload_type="leaf_level",
    use_stream=True,
    non_blocking=True
)
# compile
pipeline.transformer.compile()
prompt = """
The camera rushes from far to near in a low-angle shot, 
revealing a white ferret on a log. It plays, leaps into the water, and emerges, as the camera zooms in 
for a close-up. Water splashes berry bushes nearby, while moss, snow, and leaves blanket the ground. 
Birch trees and a light blue sky frame the scene, with ferns in the foreground. Side lighting casts dynamic 
shadows and warm highlights. Medium composition, front view, low angle, with depth of field.
"""
negative_prompt = """
Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality, 
low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, 
misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards
"""
output = pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    num_frames=81,
    guidance_scale=5.0,
).frames[0]
export_to_video(output, "output.mp4", fps=16)
```

Xet Storage Details

Size:: 8.28 kB
Xet hash:: 9ceac799ea074a3900fb0b78176f96d2a82940a60e98c2a47e442a63567885f1

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

	# 编译和卸载量化模型

	优化模型通常需要在[推理速度](./fp16)和[内存占用](./memory)之间进行权衡。例如，[缓存](./cache)虽然可以提升推理速度，但由于需要存储中间注意力层的输出，也会增加内存消耗。一种更为均衡的优化策略是将模型量化、[torch.compile](./fp16#torchcompile)以及多种[卸载方法](./memory#offloading)相结合。

	> [!TIP]
	> 请参阅 [torch.compile](./fp16#torchcompile) 指南，以了解有关编译的更多信息以及在此处如何应用它们。例如，区域编译可以在不牺牲任何加速效果的情况下显著缩短编译时间。

	在图像生成中，将量化与[模型卸载](./memory#model-offloading)相结合，通常能在质量、速度和内存之间取得最佳平衡。组卸载在图像生成中效果不佳，因为如果计算内核完成得更快，通常无法完全重叠数据传输。这会导致 CPU 和 GPU 之间产生一定的通信开销。

	对于视频生成，结合量化和 [group-offloading](./memory#group-offloading) 通常效果更好，因为视频模型更受计算限制。

	下表提供了 Flux 优化策略组合及其对延迟和内存使用影响的比较。

	\| 组合 \| 延迟（秒） \| 内存使用量（GB） \|
	\|---\|---\|---\|
	\| 量化 \| 32.602 \| 14.9453 \|
	\| 量化，torch.compile \| 25.847 \| 14.9448 \|
	\| 量化、torch.compile、模型 CPU 卸载 \| 32.312 \| 12.2369 \|

	这些结果是在 Flux 上使用 RTX 4090 进行基准测试得出的。transformer 和 text_encoder 组件已进行量化。如果您想评估自己的模型，请参阅基准测试脚本。

	本指南将演示如何使用 [bitsandbytes](../quantization/bitsandbytes#torchcompile) 编译并卸载量化模型。请确保你使用的是 [PyTorch nightly](https://pytorch.org/get-started/locally/) 以及 bitsandbytes 的最新版本。

	虽然本示例使用了 bitsandbytes，但其他量化后端（例如 [TorchAO](../quantization/torchao)）也支持这些功能。

	```bash
	pip install -U bitsandbytes
	```

	## 量化与 torch.compile

	首先对模型进行[量化](../quantization/overview)以降低存储所需的内存，然后对其进行[编译](./fp16#torchcompile)以加速推理。

	配置 [Dynamo](https://docs.pytorch.org/docs/stable/torch.compiler_dynamo_overview.html) 的 `capture_dynamic_output_shape_ops = True`，以在编译 bitsandbytes 模型时处理动态输出。

	```py
	import torch
	from diffusers import DiffusionPipeline
	from diffusers.quantizers import PipelineQuantizationConfig

	torch._dynamo.config.capture_dynamic_output_shape_ops = True

	# quantize
	pipeline_quant_config = PipelineQuantizationConfig(
	quant_backend="bitsandbytes_4bit",
	quant_kwargs={"load_in_4bit": True, "bnb_4bit_quant_type": "nf4", "bnb_4bit_compute_dtype": torch.bfloat16},
	components_to_quantize=["transformer", "text_encoder_2"],
	)
	pipeline = DiffusionPipeline.from_pretrained(
	"black-forest-labs/FLUX.1-dev",
	quantization_config=pipeline_quant_config,
	dtype=torch.bfloat16,
	).to("cuda") # or "mps", "xpu", "cpu"

	# compile
	pipeline.transformer.to(memory_format=torch.channels_last)
	pipeline.transformer.compile(mode="max-autotune", fullgraph=True)
	pipeline("""
	cinematic film still of a cat sipping a margarita in a pool in Palm Springs, California
	highly detailed, high budget hollywood movie, cinemascope, moody, epic, gorgeous, film grain
	"""
	).images[0]
	```

	## 量化、torch.compile 和卸载

	除了量化和 torch.compile，如果还需要进一步降低内存占用，可以尝试使用 offloading。Offloading 会根据计算需求，将各个层或模型组件在 CPU 和 GPU 之间进行移动。

	在卸载过程中配置 [Dynamo](https://docs.pytorch.org/docs/stable/torch.compiler_dynamo_overview.html) 的 `cache_size_limit` 以避免过度重新编译，并设置 `capture_dynamic_output_shape_ops = True` 以在处理 bitsandbytes 模型的编译时应对动态输出。

	[模型 CPU 卸载](./memory#model-offloading)会在需要计算时，将单个流水线组件（例如 transformer 模型）移至 GPU。否则，该组件会被卸载到 CPU。

	```py
	import torch
	from diffusers import DiffusionPipeline
	from diffusers.quantizers import PipelineQuantizationConfig

	torch._dynamo.config.cache_size_limit = 1000
	torch._dynamo.config.capture_dynamic_output_shape_ops = True

	# quantize
	pipeline_quant_config = PipelineQuantizationConfig(
	quant_backend="bitsandbytes_4bit",
	quant_kwargs={"load_in_4bit": True, "bnb_4bit_quant_type": "nf4", "bnb_4bit_compute_dtype": torch.bfloat16},
	components_to_quantize=["transformer", "text_encoder_2"],
	)
	pipeline = DiffusionPipeline.from_pretrained(
	"black-forest-labs/FLUX.1-dev",
	quantization_config=pipeline_quant_config,
	dtype=torch.bfloat16,
	).to("cuda") # or "mps", "xpu", "cpu"

	# model CPU offloading
	pipeline.enable_model_cpu_offload()

	# compile
	pipeline.transformer.compile()
	pipeline(
	"cinematic film still of a cat sipping a margarita in a pool in Palm Springs, California, highly detailed, high budget hollywood movie, cinemascope, moody, epic, gorgeous, film grain"
	).images[0]
	```

	[组卸载](./memory#group-offloading)会将单个流水线组件（例如 transformer 模型）的内部层移至 GPU 进行计算，并在不需要时将其卸载。同时，它利用 [CUDA stream](./memory#cuda-stream) 特性预取下一层以执行。

	通过重叠计算和数据传输，它比模型 CPU 卸载更快，同时还能节省内存。

	```py
	# pip install ftfy
	import torch
	from diffusers import AutoModel, DiffusionPipeline
	from diffusers.hooks import apply_group_offloading
	from diffusers.utils import export_to_video
	from diffusers.quantizers import PipelineQuantizationConfig
	from transformers import UMT5EncoderModel

	torch._dynamo.config.cache_size_limit = 1000
	torch._dynamo.config.capture_dynamic_output_shape_ops = True

	# quantize
	pipeline_quant_config = PipelineQuantizationConfig(
	quant_backend="bitsandbytes_4bit",
	quant_kwargs={"load_in_4bit": True, "bnb_4bit_quant_type": "nf4", "bnb_4bit_compute_dtype": torch.bfloat16},
	components_to_quantize=["transformer", "text_encoder"],
	)

	text_encoder = UMT5EncoderModel.from_pretrained(
	"Wan-AI/Wan2.1-T2V-14B-Diffusers", subfolder="text_encoder", dtype=torch.bfloat16
	)
	pipeline = DiffusionPipeline.from_pretrained(
	"Wan-AI/Wan2.1-T2V-14B-Diffusers",
	quantization_config=pipeline_quant_config,
	dtype=torch.bfloat16,
	).to("cuda") # or "mps", "xpu", "cpu"

	# group offloading
	onload_device = torch.device("cuda")
	offload_device = torch.device("cpu")

	pipeline.transformer.enable_group_offload(
	onload_device=onload_device,
	offload_device=offload_device,
	offload_type="leaf_level",
	use_stream=True,
	non_blocking=True
	)
	pipeline.vae.enable_group_offload(
	onload_device=onload_device,
	offload_device=offload_device,
	offload_type="leaf_level",
	use_stream=True,
	non_blocking=True
	)
	apply_group_offloading(
	pipeline.text_encoder,
	onload_device=onload_device,
	offload_type="leaf_level",
	use_stream=True,
	non_blocking=True
	)

	# compile
	pipeline.transformer.compile()

	prompt = """
	The camera rushes from far to near in a low-angle shot,
	revealing a white ferret on a log. It plays, leaps into the water, and emerges, as the camera zooms in
	for a close-up. Water splashes berry bushes nearby, while moss, snow, and leaves blanket the ground.
	Birch trees and a light blue sky frame the scene, with ferns in the foreground. Side lighting casts dynamic
	shadows and warm highlights. Medium composition, front view, low angle, with depth of field.
	"""
	negative_prompt = """
	Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality,
	low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured,
	misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards
	"""

	output = pipeline(
	prompt=prompt,
	negative_prompt=negative_prompt,
	num_frames=81,
	guidance_scale=5.0,
	).frames[0]
	export_to_video(output, "output.mp4", fps=16)
	```