ดาวน์โหลด stable fast - ดาวน์โหลดซอร์สโค้ด stable fast

มั่นคงอย่างรวดเร็ว

? การประกาศสำคัญ?

หลังจากความล่าช้าหนึ่งปีฉันยินดีที่จะประกาศว่าฉันวางแผนที่จะสร้างโครงการใหม่ที่สะดวกสบายเพื่อให้ความเร็วการอนุมานที่เร็วที่สุดสำหรับทุกรุ่นที่ทำงานกับ ComfyUI เพิ่งเริ่มต้นและฉันหวังว่ามันจะเป็นโครงการที่ยอดเยี่ยม? .. โปรดมุ่งเน้นไปที่มันและให้คำติชมฉัน!

บันทึก

การพัฒนาที่ใช้งานอยู่บน stable-fast ได้ถูกหยุดชั่วคราว ขณะนี้ฉันกำลังทำงานกับ torch._dynamo ใหม่โครงการตามโครงการที่กำหนดเป้าหมายไปยังรุ่นใหม่เช่น stable-cascade , SD3 และ Sora เช่น MModels มันจะเร็วขึ้นและยืดหยุ่นมากขึ้นรวมถึงการสนับสนุนแบ็กเอนด์ฮาร์ดแวร์มากกว่า CUDA

ยินดีต้อนรับการติดต่อ

ช่อง Discord

stable-fast ได้รับประสิทธิภาพการอนุมานของ SOTA ใน ทุก รุ่นของ Diffuser แม้จะมี StableVideoDiffusionPipeline ล่าสุด และแตกต่างจาก TensorRT หรือ AITemplate ซึ่งใช้เวลาหลายสิบนาทีในการรวบรวมโมเดล stable-fast ใช้เวลาเพียงไม่กี่วินาทีในการรวบรวมโมเดล stable-fast ยังรองรับ dynamic shape LoRA และ ControlNet ออกจากกล่อง

แบบอย่าง	คบเพลิง	Torch.compile	ไอ	OneFlow	Tensorrt	เร็ว
SD 1.5 (MS)	พ.ศ. 2440	1510	1158	1003	991	995
SVD-XT (s)	83	70				47

หมายเหตุ : ในระหว่างการเปรียบเทียบ TensorRT จะถูกทดสอบด้วย static batch size และ CUDA Graph enabled ในขณะที่ stable-fast ทำงานด้วยรูปร่างแบบไดนามิก

มั่นคงอย่างรวดเร็ว
- การแนะนำ
  - นี่คืออะไร?
  - ความแตกต่างกับห้องสมุดเร่งความเร็วอื่น ๆ
- การติดตั้ง
  - ติดตั้งล้อ prebuilt
  - ติดตั้งจากแหล่งที่มา
- การใช้งาน
  - เพิ่มประสิทธิภาพ StablediffusionPipeline
  - เพิ่มประสิทธิภาพไปป์ไลน์ LCM
  - เพิ่มประสิทธิภาพ stableVideodiffusionPipeline
  - สลับ lora แบบไดนามิก
  - การหาปริมาณแบบจำลอง
  - วิธีการทั่วไปบางอย่างในการเร่ง Pytorch
- การเปรียบเทียบประสิทธิภาพ
  - RTX 4080 (512x512, ขนาดแบทช์ 1, FP16, ใน WSL2)
  - H100
  - A100
- ความเข้ากันได้
- การแก้ไขปัญหา

การแนะนำ

นี่คืออะไร?

stable-fast เป็นกรอบการเพิ่มประสิทธิภาพการอนุมานน้ำหนักเบาพิเศษสำหรับ HuggingFace diffusers บน Nvidia GPU stable-fast ให้การเพิ่มประสิทธิภาพการอนุมานที่รวดเร็วเป็นพิเศษโดยใช้เทคนิคและคุณสมบัติที่สำคัญบางอย่าง:

CUDNN Convolution Fusion : stable-fast ใช้ชุดของตัวดำเนินการ CUDNN CUDNN FUSION CUDNN ที่สมบูรณ์และเข้ากันได้อย่างเต็มที่สำหรับการรวมกันของ Conv + Bias + Add + Act รูปแบบการคำนวณ
ความแม่นยำต่ำและ Fused GEMM : stable-fast ใช้ชุดของตัวดำเนินการ GEMM ที่หลอมรวมซึ่งคำนวณด้วยความแม่นยำ fp16 ซึ่งเร็วกว่าค่าเริ่มต้นของ Pytorch (อ่านและเขียนด้วย fp16 ในขณะที่คำนวณด้วย fp32 )
Fused Linear Geglu : stable-fast สามารถหลอมรวม GEGLU(x, W, V, b, c) = GELU(xW + b) ⊗ (xV + c) ลงในเคอร์เนล cuda หนึ่งตัว
NHWC & Fused Groupnorm : stable-fast ใช้ตัวดำเนินการ Fused NHWC GroupNorm + Silu ที่ได้รับการปรับปรุงอย่างสูงพร้อมกับ Triton ของ OpenAI ซึ่งไม่จำเป็นต้องใช้ผู้ประกอบการเปลี่ยนรูปแบบหน่วยความจำ
แบบจำลองที่ติดตามอย่างสมบูรณ์ : stable-fast ช่วยปรับปรุง torch.jit.trace อินเตอร์เฟสเพื่อให้เหมาะสมยิ่งขึ้นสำหรับการติดตามโมเดลที่ซับซ้อน เกือบทุกส่วนของ StableDiffusionPipeline/StableVideoDiffusionPipeline สามารถติดตามและแปลงเป็น Torchscript มันมีความเสถียรมากกว่า torch.compile และมีค่าใช้จ่าย CPU ที่ต่ำกว่าอย่างมีนัยสำคัญมากกว่า torch.compile และรองรับ การควบคุม และ LORA
กราฟ CUDA : stable-fast สามารถจับภาพ UNet , VAE และ TextEncoder ลงในรูปแบบกราฟ CUDA ซึ่งสามารถลดค่าใช้จ่าย CPU เมื่อขนาดแบทช์มีขนาดเล็ก การใช้งานนี้ยังรองรับรูปร่างแบบไดนามิก
ความสนใจแบบหลายหัวหลอมรวม : stable-fast เพียงแค่ใช้ xformers และทำให้เข้ากันได้กับ Torchscript

เป้าหมายต่อไปของฉันคือการรักษา stable-fast เป็นหนึ่งในกรอบการเพิ่มประสิทธิภาพการอนุมานที่เร็วที่สุดสำหรับ diffusers และยังให้การลดความเร็วและการลด VRAM สำหรับ transformers ในความเป็นจริงฉันใช้ stable-fast เพื่อเพิ่มประสิทธิภาพ LLM และบรรลุการเร่งความเร็วที่สำคัญ แต่ฉันยังคงต้องทำงานบางอย่างเพื่อให้มีความเสถียรและใช้งานง่ายขึ้นและให้ส่วนต่อประสานผู้ใช้ที่มีเสถียรภาพ

ความแตกต่างกับห้องสมุดเร่งความเร็วอื่น ๆ

FAST : stable-fast รับการปรับให้เหมาะสมที่สุดสำหรับ huggingface diffusers มันบรรลุประสิทธิภาพสูงในหลายห้องสมุด และให้ความเร็วในการรวบรวมที่รวดเร็วมากภายในเวลาเพียงไม่กี่วินาที มันเร็วกว่าคบเพลิงอย่างมาก torch.compile , TensorRT และ AITemplate ในเวลารวบรวม
น้อยที่สุด : ทำงานได้ stable-fast เป็นเฟรมเวิร์กปลั๊กอินสำหรับ PyTorch มันใช้ประโยชน์จากฟังก์ชั่น PyTorch ที่มีอยู่และโครงสร้างพื้นฐานและเข้ากันได้กับเทคนิคการเร่งความเร็วอื่น ๆ รวมถึงเทคนิคการปรับจูนที่เป็นที่นิยมและโซลูชั่นการปรับใช้
ความเข้ากันได้สูงสุด : stable-fast เข้ากันได้กับ HuggingFace Diffusers ทุกชนิดและรุ่น PyTorch นอกจากนี้ยังเข้ากันได้กับ ControlNet และ LoRA และยังรองรับ StableVideoDiffusionPipeline ล่าสุดออกจากกล่อง!

การติดตั้ง

หมายเหตุ : ปัจจุบัน stable-fast ในขณะนี้มีการทดสอบบน Linux และ WSL2 in Windows เท่านั้น คุณต้องติดตั้ง pytorch ด้วยการสนับสนุน CUDA ในตอนแรก (แนะนำให้แนะนำจาก 1.12 ถึง 2.1)

ฉันทดสอบ stable-fast ด้วย torch>=2.1.0 , xformers>=0.0.22 และ triton>=2.1.0 บน CUDA 12.1 และ Python 3.10 เวอร์ชันอื่นอาจสร้างและทำงานได้สำเร็จ แต่ไม่รับประกัน

ติดตั้งล้อ prebuilt

ดาวน์โหลดล้อที่สอดคล้องกับระบบของคุณจากหน้ารีลีสและติดตั้งด้วย pip3 install <wheel file>

ขณะนี้ทั้งล้อ Linux และ Windows มีให้บริการ

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

หมายเหตุ : การใช้งานนอก sfast.compilers ไม่รับประกันว่าจะเข้ากันได้ย้อนหลัง

หมายเหตุ : เพื่อให้ได้ประสิทธิภาพที่ดีที่สุด xformers และ triton>=2.1.0 จำเป็นต้องติดตั้งและเปิดใช้งาน คุณอาจต้องสร้าง xformers จากแหล่งที่มาเพื่อให้เข้ากันได้กับ PyTorch ของคุณ

การใช้งาน

เพิ่มประสิทธิภาพ StablediffusionPipeline

stable-fast สามารถเพิ่มประสิทธิภาพ StableDiffusionPipeline และ 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 )

อ้างถึงตัวอย่าง/optimize_stable_diffusion_pipeline.py สำหรับรายละเอียดเพิ่มเติม

คุณสามารถตรวจสอบ colab นี้เพื่อดูว่ามันทำงานอย่างไรกับ T4 GPU:

เพิ่มประสิทธิภาพไปป์ไลน์ LCM

stable-fast สามารถเพิ่มประสิทธิภาพไปป์ไลน์ latent consistency model ใหม่ล่าสุดและบรรลุการเร่งความเร็วที่สำคัญ

อ้างถึงตัวอย่าง/optimize_lcm_pipeline.py สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับวิธีการเพิ่มประสิทธิภาพแบบจำลอง SD ปกติด้วย LCM Lora อ้างถึงตัวอย่าง/optimize_lcm_pipeline.py สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับวิธีการปรับรุ่น LCM แบบสแตนด์อโลนให้เหมาะสม

เพิ่มประสิทธิภาพ stableVideodiffusionPipeline

stable-fast สามารถเพิ่มประสิทธิภาพ StableVideoDiffusionPipeline ใหม่ล่าสุดและบรรลุการเร่งความเร็ว 2x

อ้างถึงตัวอย่าง/optimize_stable_video_diffusion_pipeline.py สำหรับรายละเอียดเพิ่มเติม

สลับ lora แบบไดนามิก

รองรับการสลับ LORA แบบไดนามิก แต่คุณต้องทำงานพิเศษ เป็นไปได้เนื่องจากกราฟที่รวบรวมและ CUDA Graph แบ่งปันข้อมูลที่รองรับ (พอยน์เตอร์) เดียวกันกับโมเดล UNET ดั้งเดิม ดังนั้นสิ่งที่คุณต้องทำคือการอัปเดตพารามิเตอร์ของรุ่น UNET ดั้งเดิม

รหัสต่อไปนี้จะถือว่าคุณได้โหลด LORA และรวบรวมโมเดลแล้วและคุณต้องการเปลี่ยนไปใช้ LORA อื่น

หากคุณไม่ได้เปิดใช้งานกราฟ CUDA และเก็บไว้ใน preserve_parameters = True สิ่งต่าง ๆ อาจจะง่ายขึ้นมาก รหัสต่อไปนี้อาจไม่จำเป็นต้องใช้

 # 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 ขยายฟังก์ชั่น quantize_dynamic ของ Pytorch และให้ตัวดำเนินการเชิงเส้นเชิงปริมาณแบบไดนามิกบนแบ็กเอนด์ CUDA ด้วยการเปิดใช้งานคุณจะได้รับการลด VRAM เล็กน้อยสำหรับ diffusers และการลด VRAM ที่สำคัญสำหรับ transformers และ cound จะได้รับการเร่งความเร็วที่อาจเกิดขึ้น (ไม่เสมอไป)

สำหรับ SD XL คาดว่าจะเห็นการลดลงของ VRAM 2GB ด้วยขนาดภาพ 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 )

อ้างถึงตัวอย่าง/optimize_stable_diffusion_pipeline.py สำหรับรายละเอียดเพิ่มเติม

วิธีการทั่วไปบางอย่างในการเร่ง 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

การเปรียบเทียบประสิทธิภาพ

ประสิทธิภาพแตกต่างกันอย่างมากในการกำหนดค่าฮาร์ดแวร์/ซอฟต์แวร์/แพลตฟอร์ม/ไดรเวอร์ที่แตกต่างกัน มันยากมากที่จะเกณฑ์มาตรฐานอย่างแม่นยำ และการเตรียมสภาพแวดล้อมสำหรับการเปรียบเทียบก็เป็นงานที่ยากเช่นกัน ฉันได้ทดสอบในบางแพลตฟอร์มมาก่อน แต่ผลลัพธ์อาจยังไม่ถูกต้อง โปรดทราบว่าเมื่อทำการเปรียบเทียบแถบความคืบหน้าแสดงโดย tqdm อาจไม่ถูกต้องเนื่องจากลักษณะแบบอะซิงโครนัสของ CUDA เพื่อแก้ปัญหานี้ฉันใช้ CUDA Event เพื่อวัดความเร็วของการวนซ้ำต่อวินาทีอย่างแม่นยำ

คาดว่า stable-fast จะทำงานได้ดีขึ้นใน GPU รุ่นใหม่และรุ่น CUDA รุ่นใหม่ สำหรับ GPU ที่มีอายุมากกว่าการเพิ่มประสิทธิภาพอาจมี จำกัด ในระหว่างการเปรียบเทียบแถบความคืบหน้าอาจทำงานไม่ถูกต้องเนื่องจากลักษณะอะซิงโครนัสของ Cuda

RTX 4080 (512x512, ขนาดแบทช์ 1, FP16, ใน WSL2)

นี่คือพีซีเกมส่วนตัวของฉัน? มันมีซีพียูที่ทรงพลังกว่าจากผู้ให้บริการคลาวด์เซิร์ฟเวอร์

กรอบ	SD 1.5	SD XL (1024x1024)	SD 1.5 Controlnet
Vanilla Pytorch (2.1.0)	29.5 มัน/s	4.6 มัน/s	19.7 มัน/s
Torch.compile (2.1.0, Max-Autotune)	40.0 มัน/s	6.1 มัน/s	21.8 มัน/s
AITEMPLATE	44.2 มัน/s
OneFlow	53.6 มัน/s
auto1111 webui	17.2 มัน/s	3.6 มัน/s
Auto1111 WebUI (พร้อม SDPA)	24.5 มัน/s	4.3 มัน/s
tensorrt (auto1111 webui)	40.8 มัน/s
การสาธิตอย่างเป็นทางการของ Tensorrt	52.6 มัน/s
มีความเสถียร (กับ Xformers & Triton)	51.6 มัน/s	9.1 มัน/s	36.7 มัน/s

H100

ขอบคุณสำหรับความช่วยเหลือ @consceleratus และ @harishp ฉันได้ทดสอบความเร็วใน H100

กรอบ	SD 1.5	SD XL (1024x1024)	SD 1.5 Controlnet
Vanilla Pytorch (2.1.0)	54.5 มัน/s	14.9 มัน/s	35.8 มัน/s
Torch.compile (2.1.0, Max-Autotune)	66.0 มัน/s	18.5 มัน/s
มีความเสถียร (กับ Xformers & Triton)	104.6 มัน/s	21.6 มัน/s	72.6 มัน/s

A100

ขอบคุณสำหรับความช่วยเหลือของ @supersecurehuman และ @ @jon-chuang การเปรียบเทียบบน A100 พร้อมให้บริการแล้ว

กรอบ	SD 1.5	SD XL (1024x1024)	SD 1.5 Controlnet
Vanilla Pytorch (2.1.0)	35.6 มัน/s	8.7 มัน/s	25.1 มัน/s
Torch.compile (2.1.0, Max-Autotune)	41.9 มัน/s	10.0 มัน/s
มีความเสถียร (กับ Xformers & Triton)	61.8 มัน/s	11.9 มัน/s	41.1 มัน/s

ความเข้ากันได้

แบบอย่าง	ที่ได้รับการสนับสนุน
กอดใบหน้า diffusers (1.5/2.1/xl)	ใช่
ด้วย Controlnet	ใช่
กับ Lora	ใช่
รูปแบบความสอดคล้องแฝง	ใช่
SDXL Turbo	ใช่
การแพร่กระจายวิดีโอที่เสถียร	ใช่

ฟังก์ชั่น	ที่ได้รับการสนับสนุน
รูปร่างแบบไดนามิก	ใช่
ส่งข้อความถึงรูปภาพ	ใช่
รูปภาพเป็นภาพ	ใช่
ภาพในภาพวาด	ใช่