stable fast
v1.0.5
Après un an de retard, je suis heureux d'annoncer que je prévois de construire un nouveau projet confortable pour fournir la vitesse d'inférence la plus rapide à tous les modèles fonctionnant avec ComfyUI . Ça vient de commencer et j'espère que ce sera un excellent projet? .. Veuillez continuer à vous concentrer dessus et me donner des commentaires ?!
NOTE
Le développement actif sur stable-fast a été interrompu. Je SD3 actuellement sur un nouveau projet basé Sora torch._dynamo stable-cascade Il serait plus rapide et plus flexible, ainsi que de prendre en charge plus de backsings matériels plutôt que CUDA .
Le contact est accueilli.
Canal de discorde
stable-fast atteint les performances d'inférence SOTA sur toutes sortes de modèles de diffuseurs, même avec le dernier StableVideoDiffusionPipeline . Et contrairement à TensorRT ou AITemplate , qui prend des dizaines de minutes pour compiler un modèle, stable-fast ne prend que quelques secondes pour compiler un modèle. stable-fast prend également en charge dynamic shape , LoRA et ControlNet hors de la boîte.
| Modèle | torche | torche | Ait | un flux unique | Tensorrt | stable |
|---|---|---|---|---|---|---|
| SD 1.5 (MS) | 1897 | 1510 | 1158 | 1003 | 991 | 995 |
| SVD-XT (S) | 83 | 70 | 47 |
Remarque : Pendant l'analyse comparative, TensorRT est testé avec static batch size et CUDA Graph enabled tandis que stable-fast fonctionne avec une forme dynamique.
stable-fast est un cadre d'optimisation d'inférence ultra légers pour les diffuseurs de câlins sur les GPU NVIDIA . stable-fast offre une optimisation d'inférence super rapide en utilisant certaines techniques et fonctionnalités clés:
stable-fast implémente une série d'opérateurs de fusion de convolution CUDNN entièrement fonctionnels et entièrement compatibles pour toutes sortes de combinaisons de modèles de calcul Conv + Bias + Add + Act .stable-fast implémente une série d'opérateurs GEMM fusionnés qui calculent avec la précision fp16 , qui est rapide que les défaillances de Pytorch (lire et écrire avec fp16 tout en étant calculé avec fp32 ).stable-fast est capable de fusionner GEGLU(x, W, V, b, c) = GELU(xW + b) ⊗ (xV + c) en un noyau Cuda.stable-fast implémente un opérateur GroupNorm + Silu Fusé à fond hautement optimisé avec Triton d'OpenAI, ce qui élimine le besoin d'opérateurs de permutation de format de mémoire.stable-fast améliore l'interface torch.jit.trace pour la rendre plus appropriée pour le traçage des modèles complexes. Presque toutes les parties de StableDiffusionPipeline/StableVideoDiffusionPipeline peuvent être tracées et converties en torchscript . Il est plus stable que torch.compile et a une surcharge CPU nettement plus faible que torch.compile et prend en charge ControlNet et Lora .stable-fast peut capturer l' UNet , VAE et TextEncoder dans le format du graphique CUDA, ce qui peut réduire le cpu aérien lorsque la taille du lot est petite. Cette implémentation prend également en charge la forme dynamique.stable-fast utilise simplement des XFormors et le rend compatible avec TorchScript . Mon prochain objectif est de rester stable-fast en tant que l'un des cadres d'optimisation des inférences les plus rapides pour diffusers et d'offrir à la fois la réduction de l'accélération et du VRAM pour transformers . En fait, j'utilise déjà stable-fast pour optimiser les LLM et atteindre une accélération significative. Mais j'ai encore besoin de faire un certain travail pour le rendre plus stable et plus facile à utiliser et à fournir une interface utilisateur stable.
stable-fast est spécialement optimisé pour les diffuseurs de câlins . Il atteint une performance élevée dans de nombreuses bibliothèques. Et il offre une vitesse de compilation très rapide en quelques secondes. Il est nettement plus rapide que torch.compile , TensorRT et AITemplate en temps de compilation.stable-fast fonctionne comme un cadre de plugin pour PyTorch . Il utilise les fonctionnalités et les infrastructures PyTorch existantes et est compatible avec d'autres techniques d'accélération, ainsi que les techniques de réglage des amendes et les solutions de déploiement populaires.stable-fast est compatible avec toutes sortes de HuggingFace Diffusers et de versions PyTorch . Il est également compatible avec ControlNet et LoRA . Et il prend même en charge le dernier StableVideoDiffusionPipeline hors de la boîte! Remarque : stable-fast est actuellement testé uniquement sur Linux et WSL2 in Windows . Vous devez installer Pytorch avec le support CUDA au début (les versions de 1,12 à 2.1 sont suggérées).
Je teste uniquement stable-fast avec torch>=2.1.0 , xformers>=0.0.22 et triton>=2.1.0 sur CUDA 12.1 et Python 3.10 . D'autres versions pourraient construire et fonctionner avec succès, mais ce n'est pas garanti.
Téléchargez la roue correspondant à votre système à partir de la page des versions et installez-la avec pip3 install <wheel file> .
Actuellement, les roues Linux et Windows sont 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) Remarque : Toute utilisation en dehors de sfast.compilers n'est pas garantie d'être compatible en arrière.
REMARQUE : Pour obtenir les meilleures performances, xformers et triton>=2.1.0 doivent être installés et activés. Vous devrez peut-être construire xformers à partir de la source pour le rendre compatible avec votre PyTorch .
stable-fast est capable d'optimiser directement StableDiffusionPipeline et StableDiffusionPipelineXL .
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 )Reportez-vous aux exemples / Optimize_stable_diffusion_pipeline.py pour plus de détails.
Vous pouvez vérifier ce colab pour voir comment il fonctionne sur T4 GPU:
stable-fast est capable d'optimiser le nouveau pipeline latent consistency model et d'atteindre une accélération significative.
Reportez-vous aux exemples / optimiser_lcm_pipeline.py pour plus de détails sur la façon d'optimiser le modèle SD normal avec LCM LORA. Reportez-vous aux exemples / optimiser_lcm_pipeline.py pour plus de détails sur la façon d'optimiser le modèle LCM autonome.
stable-fast est capable d'optimiser le plus récent StableVideoDiffusionPipeline et d'atteindre une accélération 2x
Reportez-vous aux exemples / optimiser_stable_video_diffusion_pipeline.py pour plus de détails
Le changement de LORA est pris en charge dynamiquement, mais vous devez faire un travail supplémentaire. C'est possible car le graphique compilé et CUDA Graph partagent les mêmes données sous-jacentes (pointeurs) avec le modèle UNET original. Il vous suffit donc de mettre à jour les paramètres du modèle UNE d'origine en place.
Le code suivant suppose que vous avez déjà chargé une LORA et compilé le modèle, et vous souhaitez passer à une autre LORA.
Si vous n'activez pas le graphique CUDA et que vous gardez preserve_parameters = True , les choses pourraient être beaucoup plus faciles. Le code suivant peut même ne pas être nécessaire.
# 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 étend la fonctionnalité quantize_dynamic de Pytorch et fournit un opérateur linéaire quantifié dynamiquement sur le backend CUDA. En l'activant, vous pouvez obtenir une légère réduction de VRAM pour diffusers et une réduction importante de VRAM pour transformers , et Cound obtient une accélération potentielle (pas toujours).
Pour SD XL , il devrait voir la réduction de VRAM de 2GB avec une taille d'image 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 )Reportez-vous aux exemples / Optimize_stable_diffusion_pipeline.py pour plus de détails.
# 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 Les performances varient très considérablement selon les différentes configurations matérielles / logiciels / plate-forme / pilote. Il est très difficile de comparer avec précision. Et préparer l'environnement pour l'analyse comparative est également un travail difficile. J'ai déjà testé sur certaines plateformes, mais les résultats peuvent toujours être inexacts. Notez que lors de l'analyse comparative, la barre de progression montrée par tqdm peut être inexacte en raison de la nature asynchrone de CUDA. Pour résoudre ce problème, j'utilise CUDA Event pour mesurer avec précision la vitesse des itérations par seconde.
stable-fast devrait mieux fonctionner sur les GPU plus récents et les versions CUDA plus récentes. Sur les GPU plus anciens, l'augmentation des performances pourrait être limitée. Pendant l'analyse comparative, la barre de progrès pourrait fonctionner incorrectement en raison de la nature asynchrone de Cuda.
C'est mon PC de jeu personnel ?. Il a un CPU plus puissant que ceux des fournisseurs de serveurs cloud.
| Cadre | SD 1.5 | SD XL (1024x1024) | ControlNet SD 1.5 |
|---|---|---|---|
| Vanille Pytorch (2.1.0) | 29.5 it / s | 4.6 IT / S | 19.7 it / s |
| torch.comPile (2.1.0, Max-Autotune) | 40.0 it / s | 6.1 it / s | 21.8 it / s |
| Aitemplat | 44.2 it / s | ||
| Un flux unique | 53.6 it / s | ||
| Webui Auto1111 | 17.2 IT / S | 3.6 IT / S | |
| Auto1111 Webui (avec SDPA) | 24.5 it / s | 4.3 IT / S | |
| Tensorrt (Auto1111 webui) | 40.8 IT / S | ||
| Démo officiel de Tensorrt | 52.6 it / s | ||
| Stable-Fast (avec Xformers & Triton) | 51.6 it / s | 9.1 it / s | 36.7 it / s |
Merci pour l'aide de @Consceleratus et @HarishP , j'ai testé la vitesse sur H100.
| Cadre | SD 1.5 | SD XL (1024x1024) | ControlNet SD 1.5 |
|---|---|---|---|
| Vanille Pytorch (2.1.0) | 54.5 IT / S | 14.9 it / s | 35.8 IT / S |
| torch.comPile (2.1.0, Max-Autotune) | 66.0 IT / S | 18.5 it / s | |
| Stable-Fast (avec Xformers & Triton) | 104.6 IT / S | 21.6 it / s | 72.6 it / s |
Merci pour l'aide de @SupersECureHuman et @ Jon-Chuang , l'analyse comparative sur A100 est maintenant disponible.
| Cadre | SD 1.5 | SD XL (1024x1024) | ControlNet SD 1.5 |
|---|---|---|---|
| Vanille Pytorch (2.1.0) | 35.6 it / s | 8.7 it / s | 25.1 it / s |
| torch.comPile (2.1.0, Max-Autotune) | 41.9 it / s | 10.0 it / s | |
| Stable-Fast (avec Xformers & Triton) | 61.8 it / s | 11.9 it / s | 41.1 it / s |
| Modèle | Soutenu |
|---|---|
| Diffuseurs de face étreintes (1,5 / 2,1 / xl) | Oui |
| Avec ControlNet | Oui |
| Avec Lora | Oui |
| Modèle de cohérence latente | Oui |
| Sdxl turbo | Oui |
| Diffusion vidéo stable | Oui |
| Fonctionnalité | Soutenu |
|---|---|
| Forme dynamique | Oui |
| Texte à l'image | Oui |
| Image à l'image | Oui |
| Image Intainting | Oui |
| Cadre d'interface utilisateur | Soutenu | Lien |
|---|---|---|
| Automatique1111 | Vider | |
| SD suivant | Oui | SD Next |
| Comfyui | Oui | ComfyUI_stable_fast |
| Système opérateur | Soutenu |
|---|---|
| Linux | Oui |
| Fenêtre | Oui |
| Windows WSL | Oui |
Reportez-vous à doc / dépannage.md pour plus de détails.
Et vous pouvez rejoindre le canal Discord pour demander de l'aide.
