stable-diffusion.cpp - C/C++ में लागू किया गया Diffusion मॉडल inference

 (github.com/leejet)
3 पॉइंट द्वारा GN⁺ 2023-08-21 | 1 टिप्पणियां | WhatsApp पर शेयर करें
  • यह SD, Flux, Wan श्रृंखला सहित Diffusion मॉडल inference को शुद्ध C/C++ में चलाने का टूल है, और बाहरी dependency के बिना हल्के implementation को लक्ष्य बनाता है
  • implementation ggml पर आधारित है और llama.cpp की तरह काम करने वाली Plain C/C++ संरचना है
  • समर्थित मॉडल दायरा image model, image editing model और video model में बंटा है, और SD1.x, SD2.x, SDXL, SD3/SD3.5, FLUX, Qwen Image, Wan2.1/Wan2.2, LTX-2.3 आदि को लक्षित करता है
  • feature दायरे में PhotoMaker, SD 1.5 के लिए Control Net, stable-diffusion-webui शैली का LoRA, LCM/LCM-LoRA, TAESD-आधारित latent decoding, ESRGAN upscaling, negative prompt, token weight tokenizer support शामिल हैं
  • execution backend हैं CPU, CUDA, Vulkan, Metal, OpenCL, SYCL; CPU में x86 architecture के AVX, AVX2, AVX512 support भी शामिल हैं
  • समर्थित platform हैं Linux, Mac OS, Windows, Android; Android पर Termux और Local Diffusion के जरिए इसे चलाया जा सकता है
  • weight format के रूप में .ckpt, .pth, .pt, .safetensors, .gguf समर्थित हैं, और conversion mode मॉडल weights को .gguf या .safetensors में बदलता है
  • बुनियादी उपयोग प्रवाह यह है कि releases page से prebuilt binary डाउनलोड करें या source से build करें, फिर मॉडल weights डाउनलोड करके ./bin/sd-cli -m ../models/v1-5-pruned-emaonly.safetensors -p "a lovely cat" जैसे रूप में image generation चलाएँ
  • memory usage optimization के लिए Flash Attention और VAE tiling processing उपलब्ध हैं, जबकि runtime और parameter के backend offloading तथा performance improvement अलग guide का विषय हैं
  • reproducibility options --rng cuda और --rng cpu में बंटे हैं, जिनका लक्ष्य क्रमशः stable-diffusion-webui GPU RNG और ComfyUI RNG के साथ consistency बनाए रखना है
  • PNG output में generation parameters को webui-compatible text string के रूप में embed किया जाता है
  • Golang, C#, Python, Rust, Flutter/Dart के लिए wrapper projects मौजूद हैं, और Jellybox, Local Diffusion, LocalAI, KoboldCpp आदि stable-diffusion.cpp को image generation backend के रूप में इस्तेमाल करते हैं
  • प्रोजेक्ट पर सक्रिय विकास जारी है और API तथा command-line options अक्सर बदल सकते हैं

संबंधित पढ़ाई

1 टिप्पणियां

 
GN⁺ 2023-08-21
Hacker News की राय

  • Llama.cpp/ggml LLM के लिए असाधारण रूप से अच्छी तरह फिट बैठता है
    इसकी memory requirements बड़ी हैं, quantization प्रभावी है, token generation हैरानीजनक रूप से serial है और memory bandwidth से बंधी रहती है, इसलिए यह CPU के लिए अच्छा है, और ggml के अनोखे CPU/GPU pipeline inference के लिए तो और भी बेहतर है
    लेकिन Stable Diffusion अलग है। Quantization उतना अच्छा काम नहीं करता, UNet में compute बहुत ज्यादा है, और batch image generation एक अकेले user के लिए भी प्रभावी और उपयोगी है। इसलिए यह GPU/integrated GPU के लिए ज्यादा उपयुक्त है, और Python implementation की hackability से बड़ा फायदा पाता है
    मुझे लगता है Stable Diffusion के लिए machine learning compilation से executable बनाना सही दिशा है। AITemplate पहले से ही बहुत तेज है https://github.com/VoltaML/voltaML-fast-stable-diffusion, और अगर कोई demo implementation को ठीक से पूरा कर दे तो TVM Vulkan भी बहुत promising है https://github.com/mlc-ai/web-stable-diffusion
    इसके अलावा pure PyTorch implementation की hackability भी ज्यादातर बनी रहती है

    • ऊपर वाला project भी सही GGML compile flags पास करने पर GPU को कुछ हद तक support करता है
      उदाहरण के लिए compile करते समय GGML_CUBLAS support होता है, और pure C/C++ की तुलना में काफी अच्छा speedup मिलता है
    • इसके उलट, जिन लोगों के पास 6GB से अधिक VRAM वाला NVIDIA GPU नहीं है लेकिन वे local पर इन neural networks के साथ experiment करना चाहते हैं, उनके लिए यह अच्छा है
      थोड़ा समय लगे तो भी इसे पुराने laptop पर चलाया जा सकता है
    • अगर मुझे सही याद है तो torch.compile से भी काफी अच्छा speedup मिला था, और मुझे याद है कि मैंने खुद इस पर काम किया था
      देखूंगा कि numbers मिल पाते हैं या नहीं

  • CLIP तक implement किया है, यह शानदार है
    सिर्फ उसे अलग निकालकर WebAssembly implementation में compile कर दें तो भी कमाल होगा
    Edit: लगता है किसी ने पहले ही https://github.com/monatis/clip.cpp बना रखा है। अब बस इसे WebAssembly में बदलना है

    • CLIP की बात चली है तो, OpenAI और Google के competition mode में जाने के बाद मुझे हमेशा चिंता रहती है कि अगला CLIP-स्तर का model public नहीं होगा
      यह सोचकर अफसोस होता है कि कहीं किसी secret vault में पहले से ही ज्यादा advanced CLIP-स्तर का model हो सकता है
      Edit: मेरा मतलब CLIP-2 नहीं, बल्कि CLIP जितनी महत्वपूर्ण प्रगति से है

  • Setup अविश्वसनीय रूप से आसान था, इसलिए मैंने पहली बार इसे तुरंत try किया
    जानना चाहता हूं कि कितनी speed सामान्य मानी जानी चाहिए
    Linux पर cmake .. -DGGML_OPENBLAS=ON के साथ AMD Ryzen 7 5700G पर चलाया, और discrete GPU नहीं है, सिर्फ integrated graphics है
    ./bin/sd -m ../models/sd-v1-4-ggml-model-f32.bin -p "a lovely cat" चलाने पर हर sampling step में करीब 12 सेकंड लगे, और पूरी sampling में 246.40 सेकंड लगे
    जानना चाहता हूं कि क्या यही expected performance है
    Edit: OpenBLAS install नहीं था, इसलिए उस flag का कोई असर नहीं हुआ

    • यह अच्छा है। मूल रूप से इसने वह कर दिया जो मैं एक साल पहले चाहता था[0]
      उस समय लगभग हर solution Python dependencies का ढेर मांगता था, install में बहुत समय लगता था और अंत में disk space खत्म हो जाने से fail हो जाता था
      सच में, literally कई gigabytes disk space को एक 799KB binary से replace कर दिया। Bonus के तौर पर, सबसे तेज दिखने वाले Q8_0 format का इस्तेमाल करें तो data भी करीब 2.3GB बचता है
      हालांकि default 512x512 image size के अलावा bug लगते हैं। 544x544 जैसे कुछ sizes assert failure करा देते हैं, 512x512 से छोटे sizes कभी-कभी garbage images बनाते हैं, और 384x384 से छोटे sizes में लगभग हमेशा ऐसा होता है
      [0] https://news.ycombinator.com/item?id=32555608
    • Model को quantize करना होगा, लेकिन प्रति iteration करीब 12 सेकंड सही लगते हैं
    • CPU-only, 8-bit quantization, Intel Core i7 4770S, 16GB DDR3 RAM, 10 साल पुराने fanless PC पर प्रति sampling step 32 सेकंड लगे, और output ठीक है

  • AI से जुड़े C/C++ implementations में कुछ खास आकर्षण है
    Code साफ और intuitive महसूस होता है, और ऐसा लगता है कि पूरी AI field हाथ में आ सकती है और सीखी जा सकती है
    क्या ऐसा इसलिए है क्योंकि Python ecosystem बहुत messy है?

    • Rewrites आम तौर पर code quality बढ़ाते हैं, और dependencies को ऐसे custom code से बदलना जो सिर्फ जरूरी काम करे, code quality को भी बढ़ाता है
      Python version भी speed के लिए C और C++ code इस्तेमाल करता है, लेकिन यहां सब कुछ एक ही language में है
      यानी साफ code को संभव बनाने वाले तीनों factors साथ काम कर रहे हैं

  • मशीन लर्निंग वाले लोगों को Python से बाहर निकलकर ऐसी भाषा इस्तेमाल करते देखना अच्छा लगता है, जो हार्डवेयर का बेहतर उपयोग करे और build/run के लिए खास environment सेट करने की जरूरत न पड़े

    • यह तुलना काफ़ी अजीब है
      सबसे पहले, मूल प्रोजेक्ट llama.cpp की तरह GPU इस्तेमाल नहीं करता, जबकि ज़्यादातर Python मशीन लर्निंग कोड GPU इस्तेमाल करता है। GPU का optimal उपयोग करने वाला Python कोड लिखना मुश्किल नहीं है। GPU को build/run के लिए खास environment कहा जा सकता है, लेकिन इस समस्या के लिए GPU कहीं ज़्यादा उपयुक्त माना जा सकता है
      दूसरा, मूल प्रोजेक्ट भी llama.cpp की तरह Stable Diffusion/LLaMA जैसे किसी खास मॉडल के ठीक से काम करने की पुष्टि हो जाने के बाद कुशल और बेहद specialized कोड बनाया गया है। इसके उलट Python जहाँ चमकता है, वह prototyping stage है, जब सही मॉडल अभी मिला नहीं होता। C++ में इतनी आसान और सुविधाजनक prototyping मैंने अभी तक नहीं देखी
      CPU पर मशीन लर्निंग के क्षेत्र में llama.cpp वाले लोग जो शानदार काम कर रहे हैं, उसे कमतर दिखाने का मेरा इरादा नहीं है। बस, जिन समस्याओं को वे हल कर रहे हैं वे बिल्कुल अलग हैं
    • काश हर मशीन लर्निंग मॉडल के लिए एक सरल C inference API होता, जिसे dependency और environment setup की अव्यवस्था के बिना लगभग किसी भी भाषा/प्लेटफ़ॉर्म से सीधे call किया जा सकता
    • मशीन लर्निंग stack में performance के लिए अहम components असल में Python में implement भी नहीं किए गए हैं
      अंदरूनी हिस्सा तो बहुत पहले से पूरा CUDA, C, C++ ही रहा है
      Python सिर्फ़ इन सबको जोड़ने वाला एक बहुत प्रभावी glue है
    • ऐसा काम करने वाले लोगों का सच में शुक्रिया
      इन models को बिना सिरदर्द वाली समस्याओं के चलाने का यही एकमात्र तरीका रहा है। फर्क बहुत बड़ा है। CUDA और Linux का combo भी अच्छा नहीं है, और AMD और Windows का combo तो बेहद खराब है। शायद ऐसा सिर्फ़ मेरे साथ नहीं है
    • यह दिलचस्प है कि मेरा CPU इनमें से कुछ को quantized form में GPU के लगभग बराबर speed पर चला सकता है
      क्या आखिरकार यह सब memory bandwidth की ही समस्या थी?
      GPU architecture सिर्फ़ compute capability ही नहीं, बल्कि working memory को compute units के पास रखने की भी संरचना है। हर unit के पास local memory होती है, जो global memory के साथ synchronize होती है। क्या यही एक बड़ा कारण है कि GPU ऐसे workloads में मजबूत होते हैं?

  • यह C++ जैसा दिखता है, फिर इसे C/C++ क्यों कहा गया होगा?

    • मेरी समझ में इसकी base dependency ggml C में लिखी गई है

  • आज इस repository को देखा, खींचा और Mac पर .dylib build किया, और Dart के ffi-gen tool से दिए गए header file से bindings generate किए
    Flutter के साथ experiment कर रहा हूँ, और subprocess चलाने से बचने के लिए FFI इस्तेमाल कर रहा हूँ
    नतीजे में बस तेज़ सिरदर्द और टूटी हुई app बची। कल साफ़ दिमाग से फिर कोशिश करूँगा
    फिर भी यह repository खुद बहुत बढ़िया है, और M1 पर f16 के साथ 10 मिनट के अंदर run भी हो गई

  • कई quantization levels के examples देखकर काफ़ी प्रभावित हुआ
    f16 से q8_0 में बदलाव quality loss से ज़्यादा direction change जैसा दिखता है। q5_1 का result q8_0 से अलग पहचानना मुश्किल लगता है
    high-precision model में determinism खो जाता है, लेकिन व्यवहार में यह काफ़ी usable हो सकता है

  • क्या benchmarks हैं?

    • यहाँ कुछ लोगों ने timing मापी है, और quantization व hardware के हिसाब से लगता है कि हर iteration में 15~20 सेकंड लगते हैं
      https://github.com/leejet/stable-diffusion.cpp/issues/1
    • cmake .. -DGGML_CUBLAS=ON -DCMAKE_CUDA_COMPILER=/opt/cuda/bin/nvcc command से compile करके NVIDIA GeForce RTX 2060 SUPER इस्तेमाल किया
      model को FP16 में convert किया था
      इस option में हर iteration का समय 8.5~9 सेकंड के बीच है, और एक image बनाने का कुल समय लगभग 200 सेकंड है