StreamDiffusion: โซลูชันระดับไปป์ไลน์สำหรับการสร้างแบบโต้ตอบได้แบบเรียลไทม์

 (github.com/cumulo-autumn)
1 คะแนน โดย GN⁺ 2023-12-25 | 1 ความคิดเห็น | แชร์ทาง WhatsApp
  • StreamDiffusion เป็นไปป์ไลน์ที่ปรับปรุงการสร้างภาพด้วย diffusion ให้เหมาะกับการสร้างแบบโต้ตอบได้แบบเรียลไทม์ โดยมีเป้าหมายเพื่อยกระดับประสิทธิภาพของเทคนิคการสร้างภาพแบบ diffusion เดิม
  • ความสามารถหลักประกอบด้วย Stream Batch, Residual Classifier-Free Guidance, Stochastic Similarity Filter, IO Queues, การคำนวณ KV-cache ล่วงหน้า และเครื่องมือเร่งความเร็วโมเดล
  • ในสภาพแวดล้อม RTX 4090, Core i9-13900K, Ubuntu 22.04.3 LTS นั้น SD-turbo ทำได้ Txt2Img 106.16fps และ Img2Img 93.897fps ที่ denoising step 1
  • เดโมแบบเรียลไทม์มีอยู่ใน demo/realtime-txt2img และ demo/realtime-img2img โดยเดโม Img2Img ใช้ ฟีดเว็บแคมสด หรือการจับภาพหน้าจอจากเว็บเบราว์เซอร์
  • ใช้งานโดยครอบ StableDiffusionPipeline ของ Diffusers และสามารถตั้งค่าให้รันได้เร็วขึ้นด้วยการรวม LCM-LoRA, Tiny VAE, xformers และการเร่งด้วย TensorRT

วัตถุประสงค์และประสิทธิภาพของ StreamDiffusion

  • StreamDiffusion เป็น diffusion pipeline สำหรับการสร้างแบบโต้ตอบได้แบบเรียลไทม์
  • มีเป้าหมายเพื่อเพิ่มประสิทธิภาพให้กับเทคนิคการสร้างภาพแบบ diffusion ที่มีอยู่ในปัจจุบัน
  • งานวิจัยเชื่อมไปยัง arXiv 2312.12491 และ Hugging Face Papers
  • สภาพแวดล้อมที่ใช้วัดประสิทธิภาพการสร้างภาพด้วยไปป์ไลน์ที่เสนอมีดังนี้
    • GPU: RTX 4090
    • CPU: Core i9-13900K
    • OS: Ubuntu 22.04.3 LTS
  • ตารางประสิทธิภาพ
    • SD-turbo: denoising step 1, Txt2Img 106.16fps, Img2Img 93.897fps
    • LCM-LoRA + KohakuV2: denoising step 4, Txt2Img 38.023fps, Img2Img 37.133fps

ความสามารถหลัก

  • Stream Batch

    • ทำให้การประมวลผลข้อมูลง่ายขึ้นด้วยงานแบบแบตช์ที่มีประสิทธิภาพ

  • Residual Classifier-Free Guidance

    • เป็นกลไก guidance ที่ปรับปรุงแล้วเพื่อลดความซ้ำซ้อนของการคำนวณ

  • Stochastic Similarity Filter

    • เป็นเทคนิคการกรองขั้นสูงที่ช่วยเพิ่มประสิทธิภาพการใช้ GPU

  • IO Queues

    • ช่วยให้การรันลื่นไหลขึ้นด้วยการจัดการงานอินพุตและเอาต์พุตอย่างมีประสิทธิภาพ

  • Pre-Computation for KV-Caches

    • เพิ่มความเร็วในการประมวลผลด้วยการปรับกลยุทธ์การแคชให้เหมาะสม

  • Model Acceleration Tools

    • ใช้เครื่องมือต่าง ๆ เพื่อเพิ่มประสิทธิภาพและเร่งความเร็วของโมเดล

การติดตั้งและวิธีรัน

  • สามารถติดตั้ง StreamDiffusion ได้ด้วย pip, conda และ Docker
  • ตัวอย่างสภาพแวดล้อม Python ที่แนะนำคือ conda ที่ใช้ python=3.10 หรือ venv
  • ตัวอย่างการติดตั้ง PyTorch แยกระหว่าง CUDA 11.8 และ CUDA 12.1
    • CUDA 11.8: torch==2.1.0, torchvision==0.16.0, xformers
    • CUDA 12.1: torch==2.1.0, torchvision==0.16.0, xformers
  • วิธีติดตั้งสำหรับผู้ใช้
    • แนะนำเวอร์ชันล่าสุด: pip install git+https://github.com/cumulo-autumn/StreamDiffusion.git@main/…]
    • เวอร์ชันเสถียร: pip install streamdiffusion[tensorrt]
    • ติดตั้งส่วนขยาย TensorRT ด้วย python -m streamdiffusion.tools.install-tensorrt
  • หากติดตั้งเวอร์ชันเสถียรบน Windows อาจต้องติดตั้ง pywin32 เพิ่มเติม
  • การติดตั้งด้วย Docker มุ่งสำหรับสภาพแวดล้อมที่เตรียม TensorRT ไว้แล้ว และรันด้วยออปชัน --gpus all หลัง docker build

เดโมและตัวอย่างการใช้งาน

  • ตัวอย่างสามารถรันได้จากไดเรกทอรี examples
  • เดโม Txt2Img แบบเรียลไทม์อยู่ในไดเรกทอรี demo/realtime-txt2img
  • เดโม Img2Img แบบเรียลไทม์อยู่ในไดเรกทอรี demo/realtime-img2img
    • สามารถใช้ ฟีดเว็บแคมสด หรือการจับภาพหน้าจอจากเว็บเบราว์เซอร์ได้
  • ขั้นตอนการใช้งานพื้นฐานคือโหลด StableDiffusionPipeline ของ Diffusers แล้วครอบด้วย StreamDiffusion
  • ตัวอย่าง Img2Img โหลดโมเดล KBlueLeaf/kohaku-v2.1 และตั้งค่าสตรีมด้วย t_index_list=[32, 45]
    • หากโมเดลไม่ใช่ LCM ให้ใช้ load_lcm_lora() และ fuse_lora()
    • เพื่อการเร่งความเร็วเพิ่มเติม ใช้ Tiny VAE ของ madebyollin/taesd
    • เปิดใช้งาน attention แบบประหยัดหน่วยความจำของ xformers ด้วย enable_xformers_memory_efficient_attention()
  • ตัวอย่าง Txt2Img ใช้ t_index_list=[0, 16, 32, 45] และแนะนำให้ใช้ cfg_type="none" สำหรับ text-to-image
  • จำนวน warmup ควรมีอย่างน้อย len(t_index_list) x frame_buffer_size

การเร่งด้วย TensorRT

  • เพื่อให้การสร้างทำงานได้เร็วขึ้น สามารถแทนที่โค้ดเปิดใช้งาน xformers ด้วยโค้ดเร่งความเร็ว TensorRT
  • ใช้ accelerate_with_tensorrt จาก streamdiffusion.acceleration.tensorrt
  • ตัวอย่างการตั้งค่าส่ง stream, "engines", max_batch_size=2
  • ต้องมีส่วนขยาย TensorRT และการสร้างเอนจินใช้เวลา
  • หลังสร้างเอนจินแล้ว จะรันได้เร็วกว่าในตัวอย่างก่อนหน้า

Stochastic Similarity Filter

  • Stochastic Similarity Filter ช่วยลดงานแปลงผลเมื่ออินพุตวิดีโอมีการเปลี่ยนแปลงจากเฟรมก่อนหน้าน้อย
  • การลดงานแปลงผลช่วยลดภาระการประมวลผลของ GPU
  • วิธีใช้งานคือเรียก stream.enable_similar_image_filter()
  • อาร์กิวเมนต์ที่ตั้งค่าได้
    • similar_image_filter_threshold: ค่า threshold ความคล้ายระหว่างเฟรมก่อนหน้าและเฟรมปัจจุบัน ก่อนพักการประมวลผลชั่วคราว
    • similar_image_filter_max_skip_frame: ช่วงสูงสุดที่อนุญาตระหว่างการพัก ก่อนกลับมาทำการแปลงผลต่อ

Residual CFG

  • RCFG เป็นวิธีประมาณการทำงานของ CFG ด้วยความซับซ้อนเชิงคำนวณที่แข่งขันได้กับกรณีไม่ใช้ CFG
  • สามารถกำหนดได้ผ่านอาร์กิวเมนต์ cfg_type ของ StreamDiffusion
  • RCFG มี 2 ประเภท
    • RCFG Self-Negative: วิธีที่ไม่มีรายการกำหนด negative prompt
    • RCFG Onetime-Negative: วิธีที่สามารถกำหนด negative prompt ได้
  • การเปรียบเทียบความซับซ้อนเชิงคำนวณ
    • ไม่ใช้ CFG: N
    • CFG ปกติ: 2N
    • RCFG Self-Negative: N
    • RCFG Onetime-Negative: N+1
  • ค่าของ cfg_type มีดังนี้
    • ไม่ใช้ CFG: "none"
    • CFG ปกติ: "full"
    • RCFG Self-Negative: "self"
    • RCFG Onetime-Negative: "initialize"
  • delta มีผลผ่อนปรนที่ใช้ควบคุมผลของ RCFG

โมเดลและทรัพยากรที่ใช้

  • วิดีโอและเดโมภาพในรีโพซิทอรีสร้างด้วย LCM-LoRA + KohakuV2, SD-Turbo
  • โมเดล KohakuV2 ดาวน์โหลดได้จาก Civitai และ Hugging Face
  • SD-Turbo ใช้งานได้บน Hugging Face Space เช่นกัน

บทความที่เกี่ยวข้อง

1 ความคิดเห็น

 
GN⁺ 2023-12-25
ความคิดเห็นจาก Hacker News

  • บทความบน Arxiv อยู่ที่นี่: https://arxiv.org/abs/2312.12491
    คิดว่าน่าจะทำให้เร็วกว่าเกณฑ์วัดพื้นฐานบน 4090 ได้อีก ผมได้ถึง 10fps ด้วย SDXL Turbo แบบวนซ้ำ 1 ครั้งโดยไม่ต้องปรับแต่งด้วยซ้ำ
    แต่การปรับปรุงอย่าง ตัวกรองความคล้ายเชิงความน่าจะเป็น ที่ช่วยเลี่ยงการสร้างภาพที่ไม่จำเป็น ดูเหมาะสำหรับการได้ผลลัพธ์เร็ว ๆ โดยไม่ต้องล็อก GPU ไว้ที่ 100% ตลอดเวลา

  • มันแทบจะไม่สมจริงเลย รู้สึกเหมือน 10 ปีผ่านไปภายใน 1 ปี

    • ผมกำลังรอให้มันทำงานแทนผมได้ แล้วจะได้รันบน PC และเชื่อมกับ Slack ไว้ แบบนั้นนายจ้างก็จะได้ผลลัพธ์ใกล้เคียงกับตอนที่ผมทำเอง ส่วนผมก็ยังรับเงินเดือนได้โดยไม่ต้องใช้เวลาทำงานจริง และในที่สุดก็น่าจะไปโฟกัสกับงานอดิเรกได้ สุดท้ายทุกอย่างก็จะไหลไปทางนี้ใช่ไหม?
    • ตอนนี้ ระบบนิเวศ AI โอเพนซอร์ส ทั้งหมดให้ความรู้สึกแบบนี้เลย แทบทุกวันมีความก้าวหน้าใหม่ที่ทำให้สิ่งที่เคยคิดว่าเป็นไปไม่ได้กลายเป็นไปได้ และตามการเปลี่ยนแปลงให้ทันยากจริง ๆ
    • ในฐานะนักพัฒนา frontend ตอนนี้ผมเริ่มเข้าใจคนที่เคยบ่นว่าตามวงการ frontend ไม่ทันเพราะมันเปลี่ยนเร็วเกินไปแล้ว
    • ซอฟต์แวร์พวกนี้พัฒนาเร็วกว่าความเร็วที่ผม apt-get install เสียอีก
    • ทำให้นึกถึงเกมแนว incremental (https://www.reddit.com/r/incremental_games/) แต่เกมพวกนั้นไม่ควรเริ่มเล่นนะ วันหยุดอาจพังได้

  • เพิ่งลองเดโม realtime-text2img มา รู้สึกว่าการใช้ npm สำหรับ frontend มันเกินความจำเป็นสำหรับงานนี้ไปหน่อย ผมแก้ให้ สร้างแค่ 1 ภาพ แทน 16 ภาพ และบนแล็ปท็อป RTX-3080 ก็ทำงานได้ดี น่าจะได้ประมาณ 2 ภาพต่อวินาที
    แก้ไข: เดโม examples\screen ให้ความรู้สึกแทบจะเรียลไทม์ หน้าต่างแสดงว่า 4fps แต่ไม่แน่ใจว่าหมายถึงอะไรกันแน่
    แก้ไข: แต่ ความแรงของการลบ noise ของ img2img ต่ำมาก ภาพที่ส่งกลับมาจึงต่างจากภาพต้นฉบับเพียงเล็กน้อยมาก

    • อยากรู้ว่าคุณภาพจริง ความหลากหลาย และความสอดคล้องกับ prompt เป็นอย่างไร ตอนนี้ผมใช้ GPU ไม่ได้หลายวันเลยตรวจเองไม่ได้
      บทความโมเดลสร้างภาพตัดสินได้ยากเสมอก่อนจะได้ลองรันเอง เพราะต้องเอาให้ reviewer ดู จึงเลี่ยงไม่ได้ที่จะใส่ผลลัพธ์ที่คัดมาแล้ว ผมไม่ได้คิดว่านี่เป็นเรื่องดี แต่คิดว่านี่คือความจริงในตอนนี้
      ที่นี่ใช้ autoencoder ขนาดเล็กหรือเปล่า? Artspew ก็ทำแบบนั้นและได้ FPS สูงกว่า แต่ไม่ได้ใช้ TensorRT ใช้ Triton แทน และคุณภาพแย่มาก ถึงอย่างนั้นก็ยังเจ๋งอยู่ดี
      ไม่ว่าคุณภาพจริงจะต่ำกว่าที่แสดงไว้มากแค่ไหนก็ยังน่าประทับใจ แต่ในทางปฏิบัติก็รู้ได้ยาก

  • สงสัยว่า 100fps หมายความว่าสามารถป้อนอินพุตใหม่ทุก 10ms และรับเอาต์พุตใหม่ทุก 10ms ได้หรือเปล่า หรือถ้าจะได้ throughput เฉลี่ยต้องรวมอินพุตเป็น batch เพื่อประมวลผลเป็นชุด?

    • ยังไม่ได้ลองเอง แต่เดาว่าไม่น่าต้องใช้ batch processing
      ส่วนที่ช้าของโมเดลคือขั้นตอนโหลดโมเดล พอโมเดลถูกโหลดขึ้นมาแล้วก็ส่งอินพุตอะไรก็ได้ตามต้องการ
      มีสัญชาตญาณว่าการ parse และส่งข้อมูลภาพไม่น่าจะเป็นคอขวดตรงนี้

  • มันทำงานได้ทันทีเกือบตามที่เอกสารบอก เดโมพวกนี้ส่วนใหญ่มักพังและโยน error ลึก ๆ แปลก ๆ ออกมาเยอะ แต่อันนี้โอเค
    ทำมาดี คุ้มที่จะลอง ถ้าอยากสร้างภาพที่ไม่ใช่แนวอนิเมะ ให้เปลี่ยนโมเดลใน server.py ของ realtime-txt2img ได้ เช่น ตั้งเป็น https://huggingface.co/runwayml/stable-diffusion-v1-5 ก็ทำงานได้ดี
    ผลลัพธ์เร็วจริง ๆ ไม่ได้ยอดเยี่ยมแต่เร็ว ถ้าเปลี่ยนเป็น SDXL ผ่าน LCM-LoRA https://huggingface.co/latent-consistency ผลอาจดีขึ้น แต่จากจุดนั้นจะเริ่มยาก และจะเริ่มเจอ crash ลึกลับแบบที่พูดถึงข้างต้น เป็นจุดที่ต้องลงแรงทำงานจริงแล้ว
    สภาพแวดล้อมของผมคือ 4090/3990x/CUDA 12.2/debian sid ผลอาจต่างกันตามเครื่อง

  • เดโมที่ตัวละครผู้หญิงขยับเข้าออกเฟรมทำงานอย่างไร? เป็น ControlNet หรือเปล่า?

    • เป็นอินพุตวิดีโอ ตามบทความบอกว่า ตัวกรองความคล้ายเชิงความน่าจะเป็น จะลดงานแปลงภาพเมื่อเฟรมก่อนหน้ากับอินพุตวิดีโอเปลี่ยนแปลงน้อย เพื่อช่วยลดภาระประมวลผลของ GPU กรอบสีแดงใน GIF ด้านบนคือตัวอย่างนั้น
    • ตอนนี้มี GitHub issue เปิดไว้เพื่อเพิ่มการรองรับ ControlNet อยู่ ดังนั้นไม่น่าจะใช่ ControlNet ดูเหมือนเป็นแค่ img2img ที่ใช้ prompt และสเกล rcfg
    • งั้นหมายความว่าด้านซ้ายคือภาพต้นฉบับ และด้านขวาคือภาพผลลัพธ์ใช่ไหม?

  • บน Apple Silicon ได้ fps ประมาณเท่าไหร่?

    • เป็น 0 เพราะไม่มี การรองรับ MPS
      แต่ในระดับราคาเดียวกันตอนนี้ ถ้านับเครื่อง refurbished ประมาณ 1,800 ดอลลาร์ M1 Max 64GB Studio จะช้ากว่า RTX 4090 24GB ราว 13 เท่าในงาน generative AI อย่าง SD1.5 และ SDXL
    • ผมรัน SDXL Turbo ด้วย DrawThings บน M1 Pro และ RAM 32GB อยู่
      ภาพ 512x512 แบบ 5 steps สร้างได้ใน 5 วินาที ไม่ได้ใช้ refiner, upscaler หรือ face restoration
      เท่าที่ผมรู้ DrawThings ยังไม่ได้ปรับให้เหมาะกับ SDXL Turbo หรือการสร้างแบบ pipeline
      อ้างอิงเพิ่ม ถ้าสร้างภาพ 2k x 2k, 50 steps ด้วย SDXL Base+Refiner และเปิด face restoration จะใช้เวลาประมาณ 120 วินาที
    • อย่างน้อยก็น่าจะได้ราว 1/8 แต่ถ้าบน Apple รันได้อย่างน้อย 24fps คงสุดยอดมาก อาจเป็นไปได้ถ้าใช้ interpolation บางระดับ
      โดยเฉพาะถ้าเป็นแนวอนิเมะ โดยพื้นฐานแล้วมักวาดหนึ่งภาพต่อทุก 2 เฟรม ดังนั้น 12fps ก็น่าจะพอรับได้

  • มีวิดีโอให้ดูอยู่ที่ไหนไหม?