# Tăng tốc suy luận Mô hình Diffusion chạy chậm ở giai đoạn suy luận vì quá trình tạo ra là một quy trình lặp, trong đó nhiễu được tinh chỉnh dần thành hình ảnh hoặc video qua một số lượng "bước" nhất định. Để tăng tốc quá trình này, bạn có thể thử nghiệm với các [schedulers](../api/schedulers/overview) khác nhau, giảm độ chính xác của trọng số mô hình để tính toán nhanh hơn, sử dụng các cơ chế chú ý tiết kiệm bộ nhớ hơn, và nhiều phương pháp khác. Kết hợp và sử dụng các kỹ thuật này cùng nhau để tăng tốc độ suy luận nhanh hơn so với việc chỉ sử dụng một kỹ thuật đơn lẻ. Hướng dẫn này sẽ trình bày cách tăng tốc suy luận. ## Loại dữ liệu của mô hình Độ chính xác và kiểu dữ liệu của trọng số mô hình ảnh hưởng đến tốc độ suy luận vì độ chính xác cao hơn đòi hỏi nhiều bộ nhớ hơn để nạp và nhiều thời gian hơn để thực hiện các phép tính. PyTorch nạp trọng số mô hình ở float32 hoặc độ chính xác đầy đủ theo mặc định, do đó việc thay đổi kiểu dữ liệu là một cách đơn giản để nhanh chóng đạt được suy luận nhanh hơn. bfloat16 tương tự như float16 nhưng có khả năng chống lỗi số tốt hơn. Hỗ trợ phần cứng cho bfloat16 khác nhau tùy theo thiết bị, nhưng hầu hết các GPU hiện đại đều có khả năng hỗ trợ 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 tương tự bfloat16 nhưng có thể dễ gặp lỗi số hơn. ```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] ``` Chế độ [TensorFloat-32 (tf32)](https://blogs.nvidia.com/blog/2020/05/14/tensorfloat-32-precision-format/) được hỗ trợ trên GPU NVIDIA Ampere và nó thực hiện các phép toán tích chập và nhân ma trận trong tf32. Việc lưu trữ và các phép toán khác được giữ ở float32. Điều này cho phép tính toán nhanh hơn đáng kể khi kết hợp với bfloat16 hoặc float16. PyTorch chỉ bật chế độ tf32 cho các phép convolution theo mặc định và bạn sẽ cần bật nó một cách rõ ràng cho các phép nhân ma trận. ```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.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] ``` Tham khảo tài liệu [huấn luyện độ chính xác hỗn hợp](https://huggingface.co/docs/transformers/en/perf_train_gpu_one#mixed-precision) để biết thêm chi tiết. ## Chú ý tích vô hướng có tỷ lệ > [!TIP] > Chú ý tiết kiệm bộ nhớ được tối ưu hóa cho tốc độ suy luận *và* [lượng bộ nhớ sử dụng](./memory#memory-efficient-attention)! [Scaled dot product attention (SDPA)](https://pytorch.org/docs/stable/generated/torch.nn.functional.scaled_dot_product_attention.html) triển khai một số backend attention, [FlashAttention](https://github.com/Dao-AILab/flash-attention), [xFormers](https://github.com/facebookresearch/xformers), và một bản triển khai C++ native. Nó tự động chọn backend tối ưu nhất cho phần cứng của bạn. SDPA được bật mặc định nếu bạn đang sử dụng PyTorch >= 2.0 và không cần thêm bất kỳ thay đổi nào vào mã của bạn. Tuy nhiên, bạn có thể thử nghiệm với các backend attention khác nếu muốn tự chọn. Ví dụ bên dưới sử dụng context manager [torch.nn.attention.sdpa_kernel](https://pytorch.org/docs/stable/generated/torch.nn.attention.sdpa_kernel.html) để bật attention hiệu quả. ```py from torch.nn.attention import SDPBackend, sdpa_kernel 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" with sdpa_kernel(SDPBackend.EFFICIENT_ATTENTION): image = pipeline(prompt, num_inference_steps=30).images[0] ``` ## torch.compile [torch.compile](https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html) tăng tốc độ suy luận bằng cách biên dịch mã và các thao tác PyTorch thành các kernel được tối ưu hóa. Diffusers thường biên dịch các model có cường độ tính toán cao hơn như UNet, transformer hoặc VAE. Bật các cài đặt trình biên dịch sau để đạt tốc độ tối đa (xem [danh sách đầy đủ](https://github.com/pytorch/pytorch/blob/main/torch/_inductor/config.py) để biết thêm các tùy chọn). ```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 ``` Tải và biên dịch UNet và VAE. Có một số chế độ khác nhau để bạn lựa chọn, nhưng `"max-autotune"` tối ưu cho tốc độ nhanh nhất bằng cách biên dịch thành một CUDA graph. CUDA graphs thực sự giảm thiểu overhead bằng cách khởi chạy nhiều thao tác GPU thông qua một thao tác CPU duy nhất. > [!TIP] > Với PyTorch 2.3.1, bạn có thể kiểm soát hành vi cache của torch.compile. Điều này đặc biệt hữu ích cho các chế độ biên dịch như `"max-autotune"`, vốn thực hiện tìm kiếm lưới trên một số cờ biên dịch để tìm cấu hình tối ưu. Tìm hiểu thêm trong hướng dẫn [Compile Time Caching in torch.compile](https://pytorch.org/tutorials/recipes/torch_compile_caching_tutorial.html). Việc thay đổi bố trí bộ nhớ thành [channels_last](./memory#torchchannelslast) cũng tối ưu hóa bộ nhớ và tốc độ suy luận. ```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.vae.to(memory_format=torch.channels_last) pipeline.unet = torch.compile( pipeline.unet, mode="max-autotune", fullgraph=True ) 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] ``` Việc biên dịch diễn ra chậm ở lần đầu tiên, nhưng sau khi được biên dịch, tốc độ sẽ nhanh hơn đáng kể. Hãy cố gắng chỉ sử dụng pipeline đã biên dịch cho cùng một loại thao tác suy luận. Việc gọi pipeline đã biên dịch với kích thước ảnh khác sẽ kích hoạt lại quá trình biên dịch, gây chậm và kém hiệu quả. ### Biên dịch hình dạng động > [!TIP] > Hãy luôn sử dụng phiên bản nightly của PyTorch để có hỗ trợ tốt hơn. `torch.compile` theo dõi hình dạng đầu vào và các điều kiện, và nếu chúng khác đi, nó sẽ biên dịch lại mô hình. Ví dụ, nếu một mô hình được biên dịch trên ảnh có độ phân giải 1024x1024 và được sử dụng trên ảnh có độ phân giải khác, quá trình biên dịch lại sẽ được kích hoạt. Để tránh biên dịch lại, hãy thêm `dynamic=True` để cố gắng tạo ra một kernel động hơn, giúp tránh việc biên dịch lại khi các điều kiện thay đổi. ```diff + torch.fx.experimental._config.use_duck_shape = False + pipeline.unet = torch.compile( pipeline.unet, fullgraph=True, dynamic=True ) ``` Việc chỉ định `use_duck_shape=False` hướng dẫn trình biên dịch xem có nên sử dụng cùng một biến biểu tượng để đại diện cho các kích thước đầu vào giống nhau hay không. Để biết thêm chi tiết, hãy xem [lời bình](https://github.com/huggingface/diffusers/pull/11327#discussion_r2047659790) này. Không phải tất cả các model đều có thể hưởng lợi từ biên dịch động ngay từ đầu và có thể cần được điều chỉnh. Tham khảo [PR](https://github.com/huggingface/diffusers/pull/11297/) này đã cải thiện triển khai [AuraFlowPipeline](/docs/diffusers/v0.43.0/vi/api/pipelines/aura_flow#diffusers.AuraFlowPipeline) để tận dụng biên dịch động. Hãy mở một issue nếu biên dịch động không hoạt động như mong đợi với một mô hình Diffusers. ### Biên dịch theo vùng [Biên dịch theo vùng](https://docs.pytorch.org/tutorials/recipes/regional_compilation.html) giảm độ trễ khởi động lạnh bằng cách chỉ biên dịch *khối nhỏ và lặp lại thường xuyên* của một mô hình - thường là một lớp transformer - và cho phép tái sử dụng các sản phẩm đã biên dịch cho mọi lần xuất hiện tiếp theo. Đối với nhiều kiến trúc khuếch tán, điều này mang lại tốc độ chạy thời gian thực tương đương với biên dịch toàn đồ thị và giảm thời gian biên dịch từ 8 đến 10 lần. Sử dụng phương thức [compile_repeated_blocks()](/docs/diffusers/v0.43.0/vi/api/models/overview#diffusers.ModelMixin.compile_repeated_blocks), một hàm trợ giúp bọc `torch.compile`, trên bất kỳ thành phần nào, chẳng hạn như mô hình transformer, như minh họa bên dưới. ```py # pip install -U diffusers 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" # compile only the repeated transformer layers inside the UNet pipeline.unet.compile_repeated_blocks(fullgraph=True) ``` Để bật biên dịch theo vùng cho một mô hình mới, hãy thêm thuộc tính `_repeated_blocks` vào lớp mô hình, chứa tên các lớp (dưới dạng chuỗi) của các khối mà bạn muốn biên dịch. ```py class MyUNet(ModelMixin): _repeated_blocks = ("Transformer2DModel",) # ← compiled by default ``` > [!TIP] > Để xem thêm các ví dụ biên dịch theo khu vực, hãy xem [PR](https://github.com/huggingface/diffusers/pull/11705) tham chiếu. Ngoài ra, [Accelerate](https://huggingface.co/docs/accelerate/index) còn có phương thức [compile_regions](https://github.com/huggingface/accelerate/blob/273799c85d849a1954a4f2e65767216eb37fa089/src/accelerate/utils/other.py#L78) tự động chọn các khối ứng viên trong mô hình để biên dịch. Phần đồ thị còn lại được biên dịch riêng biệt. Điều này hữu ích cho các thí nghiệm nhanh vì có ít tùy chọn hơn để bạn thiết lập khối nào cần biên dịch hoặc điều chỉnh cờ biên dịch. ```py # pip install -U accelerate 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/v0.43.0/vi/api/models/overview#diffusers.ModelMixin.compile_repeated_blocks) được thiết kế để rõ ràng một cách có chủ đích. Hãy liệt kê các khối cần lặp lại trong `_repeated_blocks` và hàm trợ giúp chỉ biên dịch các khối đó. Nó mang lại hành vi có thể dự đoán được và dễ suy luận về việc tái sử dụng cache chỉ trong một dòng mã. ### Điểm ngắt đồ thị Việc chỉ định `fullgraph=True` trong torch.compile là rất quan trọng để đảm bảo không có sự ngắt mạch (graph breaks) trong mô hình cơ bản. Điều này cho phép bạn tận dụng torch.compile mà không bị suy giảm hiệu suất. Đối với UNet và VAE, điều này thay đổi cách bạn truy cập các biến trả về. ```diff - latents = unet( - latents, timestep=timestep, encoder_hidden_states=prompt_embeds -).sample + latents = unet( + latents, timestep=timestep, encoder_hidden_states=prompt_embeds, return_dict=False +)[0] ``` ### Đồng bộ GPU Hàm `step()` được [gọi](https://github.com/huggingface/diffusers/blob/1d686bac8146037e97f3fd8c56e4063230f71751/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl.py#L1228) trên scheduler sau mỗi lần denoiser đưa ra dự đoán, và biến `sigmas` được [truy cập theo chỉ số](https://github.com/huggingface/diffusers/blob/1d686bac8146037e97f3fd8c56e4063230f71751/src/diffusers/schedulers/scheduling_euler_discrete.py#L476). Khi đặt trên GPU, nó gây ra độ trễ do đồng bộ hóa giao tiếp giữa CPU và GPU. Hiện tượng này trở nên rõ rệt hơn khi denoiser đã được biên dịch. Nhìn chung, `sigmas` nên [giữ trên CPU](https://github.com/huggingface/diffusers/blob/35a969d297cba69110d175ee79c59312b9f49e1e/src/diffusers/schedulers/scheduling_euler_discrete.py#L240) để tránh đồng bộ hóa giao tiếp và độ trễ. > [!TIP] > Tham khảo bài viết trên 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/) để tối đa hóa hiệu suất với `torch.compile` cho các mô hình khuếch tán. ### Benchmarks Tham khảo bộ dữ liệu [diffusers/benchmarks](https://huggingface.co/datasets/diffusers/benchmarks) để xem dữ liệu về độ trễ suy luận và mức sử dụng bộ nhớ của các pipeline đã biên dịch. Kho [diffusers-torchao](https://github.com/sayakpaul/diffusers-torchao#benchmarking-results) cũng chứa các kết quả benchmark cho các phiên bản đã biên dịch của Flux và CogVideoX. ## Kernels [Kernels](https://huggingface.co/docs/kernels/index) là một thư viện để xây dựng, phân phối và nạp các kernel tính toán tối ưu trên [Hub](https://huggingface.co/kernels-community). Nó hỗ trợ các kernel [attention](./attention_backends#setattentionbackend) và các kernel CUDA tùy chỉnh cho các phép toán như RMSNorm, GEGLU, RoPE và AdaLN. Hướng dẫn [Tích hợp Pipeline Diffusers](https://github.com/huggingface/kernels/blob/main/kernel-builder/skills/cuda-kernels/references/diffusers-integration.md) cho thấy cách tích hợp một kernel với kỹ năng [add cuda-kernels](https://github.com/huggingface/kernels/blob/main/kernel-builder/skills/cuda-kernels/SKILL.md). Kỹ năng này cho phép một agent, chẳng hạn như Claude hoặc Codex, viết các kernel tùy chỉnh nhắm đến một mô hình cụ thể và phần cứng của bạn. > [!TIP] > Cài đặt kỹ năng [add cuda-kernels](https://github.com/huggingface/kernels/blob/main/kernel-builder/skills/cuda-kernels/SKILL.md) để hướng dẫn một agent cách viết kernel. Bài đăng trên blog [Custom kernels for all from Codex and Claude](https://huggingface.co/blog/custom-cuda-kernels-agent-skills) đề cập chi tiết hơn về vấn đề này. Ví dụ, một kernel RMSNorm tùy chỉnh (được tạo bởi kỹ năng `add cuda-kernels`) kết hợp với [torch.compile](#torchcompile) giúp tăng tốc độ tạo video LTX-Video lên 1,43 lần trên H100.