stable fast
v1.0.5
Después de un año de retraso, me complace anunciar que planeo construir un nuevo proyecto Comfy-Waveed para proporcionar la velocidad de inferencia más rápida para todos los modelos que se ejecutan con ComfyUI . Acaba de comenzar y espero que sea un gran proyecto. ¿Sigue enfocándome en ello y dame comentarios?
NOTA
El desarrollo activo en stable-fast se ha detenido. Actualmente estoy SD3 en Sora nuevo proyecto stable-cascade torch._dynamo . Sería más rápido y más flexible, además de admitir más backends de hardware en lugar de CUDA .
El contacto es bienvenido.
Canal de discordia
stable-fast alcanza el rendimiento de inferencia de SOTA en todo tipo de modelos de difusores, incluso con el último StableVideoDiffusionPipeline . Y a diferencia de TensorRT o AITemplate , que tarda docenas de minutos en compilar un modelo, stable-fast solo tarda unos segundos en compilar un modelo. stable-fast también admite dynamic shape , LoRA y ControlNet fuera de la caja.
| Modelo | antorcha | antorcha.compile | AIT | un solo flujo | Tensor | paso rápido |
|---|---|---|---|---|---|---|
| SD 1.5 (MS) | 1897 | 1510 | 1158 | 1003 | 991 | 995 |
| SVD-AT (s) | 83 | 70 | 47 |
Nota : Durante la evaluación comparativa, TensorRT se prueba con static batch size y CUDA Graph enabled mientras que stable-fast se ejecuta con forma dinámica.
stable-fast es un marco de optimización de inferencia ultra liviano para los difusores de la cara de abrazo en las GPU NVIDIA . stable-fast proporciona una optimización de inferencia súper rápida al utilizar algunas técnicas y características clave:
stable-fast implementa una serie de operadores de fusión de convolución CUDNN completamente funcional y totalmente compatible para todos los tipos de combinaciones de patrones de computación Conv + Bias + Add + Act .stable-fast implementa una serie de operadores GEMM fusionados que calculan con precisión fp16 , que es rápida que los valores predeterminados de Pytorch (lea y escriba con fp16 mientras se calculan con fp32 ).stable-fast puede fusionar GEGLU(x, W, V, b, c) = GELU(xW + b) ⊗ (xV + c) en un núcleo CUDA.stable-fast implementa un operador NHWC GroupNorm + Silu altamente optimizado con Triton de OpenAI, que elimina la necesidad de operadores de permutación de formato de memoria.stable-fast mejora la interfaz torch.jit.trace para que sea más adecuado para el rastreo de modelos complejos. Casi todas las partes de StableDiffusionPipeline/StableVideoDiffusionPipeline se pueden rastrear y convertirse en antorchscript . Es más estable que torch.compile y tiene una sobrecarga de CPU significativamente más baja que torch.compile y admite Controlnet y Lora .stable-fast puede capturar el UNet , VAE y TextEncoder en formato de gráfico CUDA, que puede reducir la sobrecarga de la CPU cuando el tamaño de lote es pequeño. Esta implementación también admite la forma dinámica.stable-fast solo usa Xformers y lo hace compatible con Torchscript . Mi próximo objetivo es mantener stable-fast como uno de los marcos de optimización de inferencia más rápidos para diffusers y también proporcionar una reducción de aceleración y VRAM para transformers . De hecho, ya uso stable-fast para optimizar LLM y lograr una aceleración significativa. Pero todavía necesito hacer un trabajo para que sea más estable y fácil de usar y proporcionar una interfaz de usuario estable.
stable-fast está especialmente optimizado para los difusores de Huggingface . Logra un alto rendimiento en muchas bibliotecas. Y proporciona una velocidad de compilación muy rápida en solo unos segundos. Es significativamente más rápido que torch.compile , TensorRT y AITemplate en el tiempo de compilación.stable-fast funciona como un marco de complemento para PyTorch . Utiliza la funcionalidad e infraestructuras PyTorch existentes y es compatible con otras técnicas de aceleración, así como técnicas populares de ajuste fino y soluciones de implementación.stable-fast es compatible con todo tipo de HuggingFace Diffusers y versiones PyTorch . También es compatible con ControlNet y LoRA . ¡E incluso admite el último StableVideoDiffusionPipeline de la caja! NOTA : stable-fast solo solo se prueba en Linux y WSL2 in Windows . Debe instalar Pytorch con soporte CUDA al principio (se sugieren versiones de 1.12 a 2.1).
Solo pruebo stable-fast con torch>=2.1.0 , xformers>=0.0.22 y triton>=2.1.0 en CUDA 12.1 y Python 3.10 . Otras versiones pueden construir y funcionar con éxito, pero eso no está garantizado.
Descargue la rueda correspondiente a su sistema desde la página de versiones e instálela con pip3 install <wheel file> .
Actualmente, tanto las ruedas de Linux como Windows están disponibles.
# Change cu121 to your CUDA version and <wheel file> to the path of the wheel file.
# And make sure the wheel file is compatible with your PyTorch version.
pip3 install --index-url https://download.pytorch.org/whl/cu121
' torch>=2.1.0 ' ' xformers>=0.0.22 ' ' triton>=2.1.0 ' ' diffusers>=0.19.3 '
' <wheel file> ' # Make sure you have CUDNN/CUBLAS installed.
# https://developer.nvidia.com/cudnn
# https://developer.nvidia.com/cublas
# Install PyTorch with CUDA and other packages at first.
# Windows user: Triton might be not available, you could skip it.
# NOTE: 'wheel' is required or you will meet `No module named 'torch'` error when building.
pip3 install wheel ' torch>=2.1.0 ' ' xformers>=0.0.22 ' ' triton>=2.1.0 ' ' diffusers>=0.19.3 '
# (Optional) Makes the build much faster.
pip3 install ninja
# Set TORCH_CUDA_ARCH_LIST if running and building on different GPU types.
# You can also install the latest stable release from PyPI.
# pip3 install -v -U stable-fast
pip3 install -v -U git+https://github.com/chengzeyi/stable-fast.git@main#egg=stable-fast
# (this can take dozens of minutes) Nota : No se garantiza que cualquier uso fuera de sfast.compilers sea compatible con retroceso.
Nota : Para obtener el mejor rendimiento, es necesario instalar y habilitar xformers y OpenAI's triton>=2.1.0 . Es posible que deba construir xformers desde la fuente para que sea compatible con su PyTorch .
stable-fast es capaz de optimizar StableDiffusionPipeline y StableDiffusionPipelineXL directamente.
import time
import torch
from diffusers import ( StableDiffusionPipeline ,
EulerAncestralDiscreteScheduler )
from sfast . compilers . diffusion_pipeline_compiler import ( compile ,
CompilationConfig )
def load_model ():
model = StableDiffusionPipeline . from_pretrained (
'runwayml/stable-diffusion-v1-5' ,
torch_dtype = torch . float16 )
model . scheduler = EulerAncestralDiscreteScheduler . from_config (
model . scheduler . config )
model . safety_checker = None
model . to ( torch . device ( 'cuda' ))
return model
model = load_model ()
config = CompilationConfig . Default ()
# xformers and Triton are suggested for achieving best performance.
try :
import xformers
config . enable_xformers = True
except ImportError :
print ( 'xformers not installed, skip' )
try :
import triton
config . enable_triton = True
except ImportError :
print ( 'Triton not installed, skip' )
# CUDA Graph is suggested for small batch sizes and small resolutions to reduce CPU overhead.
# But it can increase the amount of GPU memory used.
# For StableVideoDiffusionPipeline it is not needed.
config . enable_cuda_graph = True
model = compile ( model , config )
kwarg_inputs = dict (
prompt =
'(masterpiece:1,2), best quality, masterpiece, best detailed face, a beautiful girl' ,
height = 512 ,
width = 512 ,
num_inference_steps = 30 ,
num_images_per_prompt = 1 ,
)
# NOTE: Warm it up.
# The initial calls will trigger compilation and might be very slow.
# After that, it should be very fast.
for _ in range ( 3 ):
output_image = model ( ** kwarg_inputs ). images [ 0 ]
# Let's see it!
# Note: Progress bar might work incorrectly due to the async nature of CUDA.
begin = time . time ()
output_image = model ( ** kwarg_inputs ). images [ 0 ]
print ( f'Inference time: { time . time () - begin :.3f } s' )
# Let's view it in terminal!
from sfast . utils . term_image import print_image
print_image ( output_image , max_width = 80 )Consulte Ejemplos/Optimize_Stable_Diffusion_Pipeline.py para obtener más detalles.
Puede consultar este Colab para ver cómo funciona en T4 GPU:
stable-fast es capaz de optimizar la tubería latent consistency model más nueva y lograr una aceleración significativa.
Consulte Ejemplos/Optimize_LCM_Pipeline.py para obtener más detalles sobre cómo optimizar el modelo SD normal con LCM Lora. Consulte Ejemplos/Optimize_LCM_Pipeline.py para obtener más detalles sobre cómo optimizar el modelo LCM independiente.
stable-fast es capaz de optimizar el nuevo StableVideoDiffusionPipeline y lograr una aceleración 2x
Consulte Ejemplos/Optimize_Stable_Video_Diffusion_Pipeline.py para obtener más detalles
Cambiar a Lora dinámicamente es compatible, pero debe hacer un trabajo adicional. Es posible porque el gráfico compilado y CUDA Graph comparten los mismos datos de subestimación (punteros) con el modelo UNET original. Por lo tanto, todo lo que necesita hacer es actualizar los parámetros del modelo Unet original en el lugar.
El siguiente código supone que ya ha cargado un Lora y compiló el modelo, y desea cambiar a otra Lora.
Si no habilita el gráfico CUDA y mantiene preserve_parameters = True , las cosas podrían ser mucho más fáciles. Es posible que ni siquiera se necesite el siguiente código.
# load_state_dict with assign=True requires torch >= 2.1.0
def update_state_dict ( dst , src ):
for key , value in src . items ():
# Do inplace copy.
# As the traced forward function shares the same underlaying data (pointers),
# this modification will be reflected in the traced forward function.
dst [ key ]. copy_ ( value )
# Switch "another" LoRA into UNet
def switch_lora ( unet , lora ):
# Store the original UNet parameters
state_dict = unet . state_dict ()
# Load another LoRA into unet
unet . load_attn_procs ( lora )
# Inplace copy current UNet parameters to the original unet parameters
update_state_dict ( state_dict , unet . state_dict ())
# Load the original UNet parameters back.
# We use assign=True because we still want to hold the references
# of the original UNet parameters
unet . load_state_dict ( state_dict , assign = True )
switch_lora ( compiled_model . unet , lora_b_path ) stable-fast extiende la funcionalidad quantize_dynamic de Pytorch y proporciona un operador lineal cuantificado dinámicamente en CUDA Backend. Al habilitarlo, puede obtener una ligera reducción de VRAM para diffusers y una reducción significativa de VRAM para transformers , y el aco obtiene una aceleración potencial (no siempre).
Para SD XL , se espera que vea la reducción de VRAM de 2GB con un tamaño de imagen de 1024x1024 .
def quantize_unet ( m ):
from diffusers . utils import USE_PEFT_BACKEND
assert USE_PEFT_BACKEND
m = torch . quantization . quantize_dynamic ( m , { torch . nn . Linear },
dtype = torch . qint8 ,
inplace = True )
return m
model . unet = quantize_unet ( model . unet )
if hasattr ( model , 'controlnet' ):
model . controlnet = quantize_unet ( model . controlnet )Consulte Ejemplos/Optimize_Stable_Diffusion_Pipeline.py para obtener más detalles.
# TCMalloc is highly suggested to reduce CPU overhead
# https://github.com/google/tcmalloc
LD_PRELOAD=/path/to/libtcmalloc.so python3 ... import packaging . version
import torch
if packaging . version . parse ( torch . __version__ ) >= packaging . version . parse ( '1.12.0' ):
torch . backends . cuda . matmul . allow_tf32 = True El rendimiento varía mucho en diferentes configuraciones de hardware/software/plataforma/controlador. Es muy difícil comparar con precisión. Y preparar el entorno para la evaluación comparativa también es un trabajo difícil. He probado en algunas plataformas antes, pero los resultados aún pueden ser inexactos. Tenga en cuenta que cuando la evaluación comparativa, la barra de progreso mostrada por tqdm puede ser inexacta debido a la naturaleza asincrónica de CUDA. Para resolver este problema, uso CUDA Event para medir la velocidad de las iteraciones por segundo con precisión.
Se espera que stable-fast funcione mejor en las GPU más nuevas y las nuevas versiones de CUDA. En las GPU más antiguas, el aumento del rendimiento podría ser limitado. Durante la evaluación comparativa, la barra de progreso podría funcionar incorrectamente debido a la naturaleza asincrónica de Cuda.
¿Esta es mi PC de juego personal? Tiene una CPU más potente que las de los proveedores de servidores en la nube.
| Estructura | SD 1.5 | SD XL (1024x1024) | SD 1.5 Controlnet |
|---|---|---|---|
| Vanilla Pytorch (2.1.0) | 29.5 it/s | 4.6 It/s | 19.7 es/s |
| Torch.compile (2.1.0, Max-Autotune) | 40.0 it/s | 6.1 es/s | 21.8 it/s |
| Aitemplate | 44.2 it/s | ||
| Un solo flujo | 53.6 it/s | ||
| Auto1111 Webui | 17.2 it/s | 3.6 It/s | |
| Auto1111 WebUI (con SDPA) | 24.5 it/s | 4.3 It/s | |
| Tensorrt (Auto1111 WebUI) | 40.8 it/s | ||
| Demostración oficial de tensorrt | 52.6 it/s | ||
| Estable-rápido (con Xformers y Triton) | 51.6 it/s | 9.1 it/s | 36.7 it/s |
Gracias por la ayuda de @Consceleratus y @Harishp , he probado la velocidad en H100.
| Estructura | SD 1.5 | SD XL (1024x1024) | SD 1.5 Controlnet |
|---|---|---|---|
| Vanilla Pytorch (2.1.0) | 54.5 it/s | 14.9 es/s | 35.8 it/s |
| Torch.compile (2.1.0, Max-Autotune) | 66.0 it/s | 18.5 es/s | |
| Estable-rápido (con Xformers y Triton) | 104.6 es/s | 21.6 it/s | 72.6 it/s |
Gracias por la ayuda de @supersecurehuman y @Jon-chuang , la evaluación comparativa en A100 ya está disponible.
| Estructura | SD 1.5 | SD XL (1024x1024) | SD 1.5 Controlnet |
|---|---|---|---|
| Vanilla Pytorch (2.1.0) | 35.6 it/s | 8.7 es/s | 25.1 it/s |
| Torch.compile (2.1.0, Max-Autotune) | 41.9 it/s | 10.0 it/s | |
| Estable-rápido (con Xformers y Triton) | 61.8 it/s | 11.9 es/s | 41.1 it/s |
| Modelo | Compatible |
|---|---|
| Difusores de la cara abrazando (1.5/2.1/xl) | Sí |
| Con controlnet | Sí |
| Con lora | Sí |
| Modelo de consistencia latente | Sí |
| Sdxl turbo | Sí |
| Difusión de video estable | Sí |
| Funcionalidad | Compatible |
|---|---|
| Forma dinámica | Sí |
| Texto a imagen | Sí |
| Imagen a imagen | Sí |
| Inpenación de imágenes | Sí |
| Marco de la interfaz de usuario | Compatible | Enlace |
|---|---|---|
| Automático1111 | Ceñudo | |
| SD siguiente | Sí | SD Next |
| Conserfyui | Sí | ComfyUI_stable_fast |
| Sistema operativo | Compatible |
|---|---|
| Linux | Sí |
| Windows | Sí |
| Windows WSL | Sí |
Consulte DOC/Solución de problemas.md para obtener más detalles.
Y puede unirse al canal Discord para pedir ayuda.
