stable-diffusion.cpp - Inferensi model Diffusion yang diimplementasikan dalam C/C++

• Alat untuk menjalankan inferensi model Diffusion termasuk keluarga SD, Flux, dan Wan dengan C/C++ murni, serta menargetkan implementasi ringan tanpa dependensi eksternal
• Implementasinya berbasis ggml dan menggunakan struktur Plain C/C++ yang bekerja dengan cara serupa llama.cpp
• Cakupan model yang didukung dibagi menjadi model gambar, model pengeditan gambar, dan model video, dengan target seperti SD1.x, SD2.x, SDXL, SD3/SD3.5, FLUX, Qwen Image, Wan2.1/Wan2.2, LTX-2.3, dan lainnya
• Cakupan fitur mencakup PhotoMaker, Control Net untuk SD 1.5, LoRA bergaya stable-diffusion-webui, LCM/LCM-LoRA, latent decoding berbasis TAESD, upscale ESRGAN, negative prompt, serta dukungan tokenizer berbobot token
• Backend eksekusi meliputi CPU, CUDA, Vulkan, Metal, OpenCL, dan SYCL, sementara CPU mencakup dukungan AVX, AVX2, dan AVX512 pada arsitektur x86
• Platform yang didukung adalah Linux, Mac OS, Windows, dan Android, dengan Android dijalankan melalui Termux dan Local Diffusion
• Format bobot yang didukung adalah .ckpt, .pth, .pt, .safetensors, dan .gguf, sedangkan mode konversi mengubah bobot model ke .gguf atau .safetensors
• Alur penggunaan dasarnya adalah mengunduh binary pra-build dari releases page atau membangun dari source, lalu mengunduh bobot model dan menjalankan pembuatan gambar dalam bentuk ./bin/sd-cli -m ../models/v1-5-pruned-emaonly.safetensors -p "a lovely cat"
• Fitur optimasi penggunaan memori menyediakan Flash Attention dan VAE tiling processing, sedangkan penyesuaian runtime, batch backend pada parameter, dan peningkatan performa dibahas dalam panduan terpisah
• Opsi reproduksibilitas dibagi menjadi --rng cuda dan --rng cpu, yang masing-masing menargetkan konsistensi dengan GPU RNG milik stable-diffusion-webui dan RNG milik ComfyUI
• Output PNG menyisipkan parameter generasi sebagai string teks yang kompatibel dengan webui
• Tersedia proyek wrapper untuk Golang, C#, Python, Rust, dan Flutter/Dart, dan Jellybox, Local Diffusion, LocalAI, KoboldCpp, serta lainnya menggunakan stable-diffusion.cpp sebagai backend pembuatan gambar
• Proyek ini sedang dikembangkan secara aktif dan API serta opsi command line dapat sering berubah

[GN⁺]

Pendapat di Hacker News

• Llama.cpp/ggml sangat cocok untuk LLM
  Kebutuhan memorinya besar, kuantisasi efektif, pembuatan token sangat serial dan terikat bandwidth memori sehingga cocok untuk CPU, dan bahkan lebih cocok lagi untuk inferensi pipeline CPU/GPU unik milik ggml
  Namun Stable Diffusion berbeda. Kuantisasi tidak bekerja sebaik itu, UNet sangat berat secara komputasi, dan pembuatan gambar secara batch efektif serta berguna bahkan untuk satu pengguna. Karena itu lebih cocok untuk GPU/GPU terintegrasi, dan sangat diuntungkan oleh kemudahan hackability implementasi Python
  Untuk Stable Diffusion, menurut saya arah yang tepat adalah membuat executable melalui kompilasi machine learning. AITemplate sudah sangat cepat https://github.com/VoltaML/voltaML-fast-stable-diffusion, dan TVM Vulkan juga sangat menjanjikan jika seseorang menyelesaikan implementasi demonya dengan benar https://github.com/mlc-ai/web-stable-diffusion
  Selain itu, sebagian besar hackability dari implementasi PyTorch murni tetap dipertahankan

  • Proyek di atas juga mendukung GPU sampai batas tertentu jika meneruskan flag kompilasi GGML yang benar
    Misalnya, GGML_CUBLAS didukung saat kompilasi, dan memberikan peningkatan kecepatan yang cukup lumayan dibanding C/C++ murni
  • Sebaliknya, ini bagus bagi orang yang tidak punya GPU NVIDIA dengan VRAM 6GB atau lebih, tetapi ingin mencoba-coba jaringan saraf ini secara lokal
    Meski memakan waktu, ini bisa dijalankan di laptop lama
  • Kalau ingatan saya benar, dengan torch.compile juga ada peningkatan kecepatan yang cukup bagus, dan saya ingat pernah mengerjakannya sendiri
    Saya akan coba cek apakah bisa menemukan angkanya

• Hebat juga sudah mengimplementasikan CLIP
  Sepertinya keren kalau bagian itu diekstrak terpisah lalu dikompilasi menjadi implementasi WebAssembly
  Edit: tampaknya sudah ada yang membuat https://github.com/monatis/clip.cpp. Sekarang tinggal dibuat versi WebAssembly

  • Mumpung membahas CLIP, saya selalu khawatir apakah model setingkat CLIP berikutnya tidak akan dirilis karena OpenAI dan Google sudah masuk mode kompetisi
    Rasanya disayangkan membayangkan mungkin sudah ada model setingkat CLIP yang lebih maju di suatu brankas rahasia
    Edit: yang saya maksud bukan CLIP-2, melainkan kemajuan yang tingkat kepentingannya setara dengan CLIP

• Konfigurasinya luar biasa mudah dipercaya, jadi untuk pertama kalinya saya langsung mencobanya
  Saya penasaran berapa kecepatan yang seharusnya dianggap normal
  Saya menjalankannya di Linux dengan cmake .. -DGGML_OPENBLAS=ON pada AMD Ryzen 7 5700G, tanpa GPU diskret, hanya grafis terintegrasi
  Saat menjalankan ./bin/sd -m ../models/sd-v1-4-ggml-model-f32.bin -p "a lovely cat", setiap tahap sampling memakan sekitar 12 detik, dan keseluruhan sampling memakan 246,40 detik
  Saya penasaran apakah ini performa yang diharapkan
  Edit: OpenBLAS ternyata tidak terpasang, jadi flag tersebut tidak berpengaruh

  • Ini bagus. Pada dasarnya ini melakukan hal yang saya inginkan setahun lalu[0]
    Saat itu hampir semua solusi membutuhkan tumpukan dependensi Python, pemasangannya terlalu lama, lalu akhirnya gagal karena kehabisan ruang disk
    Benar-benar, secara harfiah beberapa gigabyte ruang disk digantikan oleh satu binary 799KB. Sebagai bonus, jika memakai format Q8_0 yang tampaknya paling cepat, data juga hemat sekitar 2,3GB
    Namun tampaknya ada bug selain pada ukuran gambar default 512x512. Beberapa ukuran seperti 544x544 cenderung memicu kegagalan assert, ukuran yang lebih kecil dari 512x512 kadang menghasilkan gambar sampah, dan ukuran di bawah 384x384 hampir selalu begitu
    [0] https://news.ycombinator.com/item?id=32555608
  • Modelnya memang harus dikuantisasi, tetapi sekitar 12 detik per iterasi terdengar masuk akal
  • Di PC fanless berusia 10 tahun dengan CPU saja, kuantisasi 8-bit, Intel Core i7 4770S, RAM DDR3 16GB, butuh 32 detik per tahap sampling dan outputnya normal

• Ada daya tarik khusus pada implementasi C/C++ untuk hal-hal terkait AI
  Kodenya terasa rapi dan intuitif, dan membuat seluruh bidang AI tampak bisa digenggam serta dipelajari
  Apakah ini karena ekosistem Python terlalu berantakan?

  • Penulisan ulang umumnya meningkatkan kualitas kode, dan mengganti dependensi dengan kode khusus yang hanya melakukan hal yang diperlukan juga meningkatkan kualitas kode
    Versi Python juga memakai kode C dan C++ demi kecepatan, tetapi di sini semuanya ditulis dalam satu bahasa
    Jadi tiga faktor yang memungkinkan kode rapi bekerja bersama-sama

• Senang melihat orang-orang di bidang machine learning mulai keluar dari Python, dan memakai bahasa yang dapat memanfaatkan hardware secara optimal serta tidak perlu menyesuaikan lingkungan khusus untuk build dan eksekusi

  • Perbandingan yang cukup aneh
    Pertama, proyek di tulisan asli tidak memakai GPU seperti llama.cpp, sedangkan sebagian besar kode machine learning Python memakai GPU. Tidak sulit menulis kode Python yang memanfaatkan GPU secara optimal. GPU memang bisa disebut lingkungan khusus untuk build dan eksekusi, tetapi untuk masalah ini GPU bisa dibilang jauh lebih cocok
    Kedua, seperti llama.cpp, proyek di tulisan asli juga membuat kode yang efisien dan sangat terspesialisasi setelah dipastikan bahwa model tertentu seperti Stable Diffusion/LLaMA bekerja dengan baik. Sebaliknya, tempat Python bersinar adalah tahap prototyping ketika model yang tepat belum ditemukan. Saya belum pernah melihat prototyping di C++ yang semudah dan senyaman ini
    Bukan bermaksud meremehkan pekerjaan hebat yang dilakukan orang-orang llama.cpp di ranah machine learning di atas CPU. Hanya saja masalah yang mereka selesaikan benar-benar berbeda
  • Akan jauh lebih bagus kalau semua model machine learning punya API inferensi C sederhana, sehingga bisa dipanggil langsung dari hampir bahasa dan platform apa pun tanpa kekacauan dependensi dan konfigurasi lingkungan
  • Komponen yang penting untuk performa dalam stack machine learning sebenarnya juga tidak diimplementasikan dengan Python
    Bagian dalamnya sejak dulu semuanya CUDA, C, C++
    Python hanyalah lem yang sangat efektif untuk menyatukan semuanya
  • Saya sangat berterima kasih kepada orang-orang yang mengerjakan hal seperti ini
    Ini satu-satunya cara saya bisa menjalankan model-model ini tanpa masalah memusingkan. Bedanya sangat besar. Kombinasi CUDA dan Linux juga tidak bagus, dan kombinasi AMD dan Windows menyedihkan. Mungkin bukan hanya saya yang mengalaminya
  • Menarik bahwa CPU saya bisa menjalankan sebagian dari ini dalam bentuk terkuantisasi dengan kecepatan yang hampir mirip GPU
    Jadi pada akhirnya semuanya masalah bandwidth memori?
    Arsitektur GPU bukan hanya soal kemampuan komputasi, tetapi juga menempatkan memori kerja dekat dengan unit komputasi. Tiap unit memiliki memori lokal yang disinkronkan dengan memori global. Apakah ini salah satu alasan besar GPU kuat untuk pekerjaan seperti ini?

• Kelihatannya C++, jadi kenapa disebut C/C++?

  • Sejauh yang saya pahami, dependensi dasarnya, ggml, ditulis dalam C

• Hari ini saya melihat repo ini, mengambilnya, lalu membangun .dylib di Mac, dan membuat binding dari file header yang disediakan dengan tool ffi-gen milik Dart
  Saya sedang bereksperimen bersama Flutter, dan memakai FFI agar tidak perlu menjalankan subprocess
  Hasilnya, yang tersisa adalah sakit kepala berat dan aplikasi yang rusak. Besok saya akan mencoba lagi dengan pikiran yang lebih jernih
  Meski begitu, repo ini sendiri bagus, dan di M1 bisa berjalan dengan f16 dalam waktu kurang dari 10 menit

• Melihat contoh berbagai tingkat kuantisasi, ini cukup mengesankan
  Perubahan dari f16 ke q8_0 tampak lebih seperti perubahan arah daripada penurunan kualitas. Hasil q5_1 terlihat sulit dibedakan dari q8_0
  Pada model presisi tinggi, determinisme hilang, tetapi dalam praktiknya mungkin cukup layak dipakai

• Ada benchmark?

  • Beberapa orang di sini sudah mengukur waktu, dan tergantung kuantisasi serta hardware, tampaknya butuh sekitar 15–20 detik per iterasi
    https://github.com/leejet/stable-diffusion.cpp/issues/1
  • Saya mengompilasinya dengan perintah cmake .. -DGGML_CUBLAS=ON -DCMAKE_CUDA_COMPILER=/opt/cuda/bin/nvcc dan memakai NVIDIA GeForce RTX 2060 SUPER
    Modelnya dikonversi ke FP16
    Dengan opsi ini, waktu per iterasi berada di antara 8,5–9 detik, dan total waktu untuk membuat satu gambar sekitar 200 detik