Unduh stable fast - Unduh kode sumber stable fast

Cepat stabil

? Pengumuman penting?

Setelah satu tahun penundaan, saya senang mengumumkan saya berencana untuk membangun proyek baru yang nyaman untuk memberikan kecepatan inferensi tercepat untuk semua model yang berjalan dengan ComfyUI . Ini baru saja dimulai dan saya harap ini akan menjadi proyek yang hebat? .. tolong tetap fokus padanya dan beri saya umpan balik?!

CATATAN

Pengembangan aktif pada stable-fast telah dijeda. Saat ini saya sedang mengerjakan proyek berbasis torch._dynamo baru yang menargetkan model baru seperti stable-cascade , SD3 dan Sora seperti mmodels. Ini akan lebih cepat dan lebih fleksibel, serta mendukung lebih banyak cadangan perangkat keras daripada CUDA .

Kontak disambut.

Saluran Perselisihan

stable-fast mencapai kinerja inferensi SOTA pada semua jenis model diffuser, bahkan dengan StableVideoDiffusionPipeline terbaru. Dan tidak seperti TensorRT atau AITemplate , yang membutuhkan lusinan menit untuk menyusun model, stable-fast hanya membutuhkan beberapa detik untuk menyusun model. stable-fast juga mendukung dynamic shape , LoRA dan ControlNet di luar kotak.

Model	obor	obor	AIT	OneFlow	Tensorrt	stabil cepat
SD 1.5 (MS)	1897	1510	1158	1003	991	995
Svd-x (s)	83	70				47

Catatan : Selama benchmarking, TensorRT diuji dengan static batch size dan CUDA Graph enabled saat stable-fast berjalan dengan bentuk dinamis.

Cepat stabil
- Perkenalan
  - Apa ini?
  - Perbedaan dengan perpustakaan akselerasi lainnya
- Instalasi
  - Pasang roda prebuilt
  - Instal dari sumber
- Penggunaan
  - Optimalkan StablediffusionPipeline
  - Mengoptimalkan pipa LCM
  - Optimalkan StableVideOdiffusionPipeline
  - Beralih secara dinamis Lora
  - Kuantisasi model
  - Beberapa metode umum untuk mempercepat pytorch
- Perbandingan Kinerja
  - RTX 4080 (512x512, Ukuran Batch 1, FP16, di WSL2)
  - H100
  - A100
- Kesesuaian
- Pemecahan masalah

Perkenalan

Apa ini?

stable-fast adalah kerangka optimasi inferensi yang sangat ringan untuk diffuser huggingface pada NVIDIA GPU . stable-fast memberikan optimasi inferensi super cepat dengan memanfaatkan beberapa teknik dan fitur utama:

CUDNN Convolution Fusion : stable-fast mengimplementasikan serangkaian operator fusi CUDNN convolution yang sepenuhnya fungsional dan kompatibel sepenuhnya untuk semua jenis kombinasi pola komputasi Conv + Bias + Add + Act .
Presisi rendah & gemm yang menyatu : stable-fast mengimplementasikan serangkaian operator GEMM yang menyatu yang menghitung dengan presisi fp16 , yang cepat dari default Pytorch (baca & tulis dengan fp16 saat menghitung dengan fp32 ).
Geglu linier yang menyatu : stable-fast mampu menggabungkan GEGLU(x, W, V, b, c) = GELU(xW + b) ⊗ (xV + c) menjadi satu kernel cuda.
NHWC & FUSE GroupNorm : stable-fast mengimplementasikan operator NHWC GroupNorm + Silu yang sangat dioptimalkan dengan Triton Openai, yang menghilangkan kebutuhan operator permutasi format memori.
Model yang dilacak sepenuhnya : stable-fast meningkatkan antarmuka torch.jit.trace untuk membuatnya lebih tepat untuk melacak model kompleks. Hampir setiap bagian dari StableDiffusionPipeline/StableVideoDiffusionPipeline dapat dilacak dan dikonversi menjadi Torchscript . Ini lebih stabil torch.compile torch.compile .
Grafik CUDA : stable-fast dapat menangkap format grafik CUDA UNet , VAE dan TextEncoder ke dalam CUDA, yang dapat mengurangi overhead CPU ketika ukuran batch kecil. Implementasi ini juga mendukung bentuk dinamis.
Perhatian multi-lead yang menyatu : stable-fast hanya menggunakan xformers dan membuatnya kompatibel dengan Torchscript .

Tujuan saya berikutnya adalah menjaga stable-fast sebagai salah satu kerangka kerja optimasi inferensi tercepat untuk diffusers dan juga memberikan pengurangan speedup dan VRAM untuk transformers . Bahkan, saya sudah menggunakan stable-fast untuk mengoptimalkan LLM dan mencapai percepatan yang signifikan. Tetapi saya masih perlu melakukan beberapa pekerjaan untuk membuatnya lebih stabil dan mudah digunakan dan menyediakan antarmuka pengguna yang stabil.

Perbedaan dengan perpustakaan akselerasi lainnya

Cepat : stable-fast dioptimalkan untuk diffuser huggingface . Ini mencapai kinerja tinggi di banyak perpustakaan. Dan memberikan kecepatan kompilasi yang sangat cepat hanya dalam beberapa detik. Ini secara signifikan TensorRT AITemplate daripada torch.compile .
Minimal : stable-fast berfungsi sebagai kerangka kerja plugin untuk PyTorch . Ini menggunakan fungsionalitas dan infrastruktur PyTorch yang ada dan kompatibel dengan teknik akselerasi lainnya, serta teknik penyempurnaan dan solusi penyebaran yang populer.
Kompatibilitas maksimum : stable-fast kompatibel dengan semua jenis HuggingFace Diffusers dan versi PyTorch . Ini juga kompatibel dengan ControlNet dan LoRA . Dan itu bahkan mendukung StableVideoDiffusionPipeline terbaru di luar kotak!

Instalasi

CATATAN : stable-fast saat ini hanya diuji di Linux dan WSL2 in Windows . Anda perlu menginstal Pytorch dengan dukungan CUDA pada awalnya (versi dari 1,12 hingga 2.1 disarankan).

Saya hanya menguji stable-fast dengan torch>=2.1.0 , xformers>=0.0.22 dan triton>=2.1.0 pada CUDA 12.1 dan Python 3.10 . Versi lain mungkin membangun dan berjalan dengan sukses tetapi itu tidak dijamin.

Pasang roda prebuilt

Unduh roda yang sesuai dengan sistem Anda dari halaman rilis dan instal dengan pip3 install <wheel file> .

Saat ini roda Linux dan Windows tersedia.

 # 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> '

Instal dari sumber

 # 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)

CATATAN : Penggunaan apa pun di luar sfast.compilers .

Catatan : Untuk mendapatkan kinerja terbaik, xformers dan triton>=2.1.0 perlu diinstal dan diaktifkan. Anda mungkin perlu membangun xformers dari sumber untuk membuatnya kompatibel dengan PyTorch Anda.

Penggunaan

Optimalkan StablediffusionPipeline

stable-fast mampu mengoptimalkan StableDiffusionPipeline dan StableDiffusionPipelineXL secara langsung.

 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 )

Lihat contoh/optimize_stable_diffusion_pipeline.py untuk detail lebih lanjut.

Anda dapat memeriksa colab ini untuk melihat cara kerjanya di T4 GPU:

Mengoptimalkan pipa LCM

stable-fast mampu mengoptimalkan pipa latent consistency model terbaru dan mencapai percepatan yang signifikan.

Lihat contoh/optimize_lcm_pipeline.py untuk detail lebih lanjut tentang cara mengoptimalkan model SD normal dengan LCM LORA. Lihat contoh/optimize_lcm_pipeline.py untuk detail lebih lanjut tentang cara mengoptimalkan model LCM mandiri.

Optimalkan StableVideOdiffusionPipeline

stable-fast mampu mengoptimalkan StableVideoDiffusionPipeline terbaru dan mencapai speedup 2x

Lihat contoh/optimize_stable_video_diffusion_pipeline.py untuk detail lebih lanjut

Beralih secara dinamis Lora

Beralih Lora secara dinamis didukung tetapi Anda perlu melakukan beberapa pekerjaan tambahan. Dimungkinkan karena grafik yang dikompilasi dan CUDA Graph berbagi data dasar yang sama (pointer) dengan model UNET asli. Jadi yang perlu Anda lakukan adalah memperbarui parameter model UNET asli di tempat.

Kode berikut mengasumsikan Anda telah memuat LORA dan menyusun model, dan Anda ingin beralih ke LORA lain.

Jika Anda tidak mengaktifkan grafik CUDA dan tetap preserve_parameters = True , segalanya bisa jauh lebih mudah. Kode berikut bahkan mungkin tidak diperlukan.

 # 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 )

Kuantisasi model

stable-fast memperluas fungsionalitas quantize_dynamic Pytorch dan menyediakan operator linier yang dikuantisasi secara dinamis pada backend CUDA. Dengan mengaktifkannya, Anda bisa mendapatkan sedikit pengurangan VRAM untuk diffusers dan pengurangan VRAM yang signifikan untuk transformers , dan Cound mendapatkan speedup potensial (tidak selalu).

Untuk SD XL , diharapkan dapat melihat pengurangan VRAM 2GB dengan ukuran gambar 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 )

Lihat contoh/optimize_stable_diffusion_pipeline.py untuk detail lebih lanjut.

Beberapa metode umum untuk mempercepat pytorch

 # 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

Perbandingan Kinerja

Kinerja sangat bervariasi di berbagai konfigurasi perangkat keras/perangkat lunak/platform/driver. Sangat sulit untuk membandingkan secara akurat. Dan mempersiapkan lingkungan untuk pembandingan juga merupakan pekerjaan yang sulit. Saya telah menguji beberapa platform sebelumnya tetapi hasilnya mungkin masih tidak akurat. Perhatikan bahwa ketika pembandingan, bilah kemajuan yang ditunjukkan oleh tqdm mungkin tidak akurat karena sifat cuda yang asinkron. Untuk mengatasi masalah ini, saya menggunakan CUDA Event untuk mengukur kecepatan iterasi per detik secara akurat.

stable-fast diharapkan bekerja lebih baik pada GPU yang lebih baru dan versi CUDA yang lebih baru. Pada GPU yang lebih lama, peningkatan kinerja mungkin terbatas. Selama benchmarking, bilah kemajuan mungkin tidak berhasil karena sifat cuda yang tidak sinkron.

RTX 4080 (512x512, Ukuran Batch 1, FP16, di WSL2)

Ini adalah PC game pribadi saya?. Ini memiliki CPU yang lebih kuat daripada yang dari penyedia server cloud.

Kerangka	SD 1.5	SD XL (1024x1024)	SD 1.5 ControlNet
Vanilla Pytorch (2.1.0)	29.5 itu/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.
AItemplate	44.2 IT/S.
OneFlow	53.6 IT/S.
AUTO1111 WEBUI	17.2 IT/S.	3.6 IT/S.
Auto1111 WebUI (dengan SDPA)	24.5 IT/S.	4.3 IT/S.
Tensorrt (Auto1111 Webui)	40.8 IT/S.
Demo resmi Tensorrt	52.6 IT/S.
stabil-cepat (dengan xformers & triton)	51.6 IT/S.	9.1 IT/S.	36.7 IT/S.

H100

Terima kasih atas bantuan @Consceleratus dan @harishp , saya telah menguji kecepatan pada H100.

Kerangka	SD 1.5	SD XL (1024x1024)	SD 1.5 ControlNet
Vanilla 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.
stabil-cepat (dengan xformers & triton)	104.6 IT/S.	21.6 IT/S.	72.6 IT/S.

A100

Terima kasih atas bantuan @SuperSecurehuman dan @Jon-Chuang , benchmarking di A100 tersedia sekarang.

Kerangka	SD 1.5	SD XL (1024x1024)	SD 1.5 ControlNet
Vanilla 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.
stabil-cepat (dengan xformers & triton)	61.8 IT/S.	11.9 IT/S.	41.1 IT/S.