Self-hosted AI image generator के लिए सही hardware specs

एक self-hosted AI image generator को वास्तव में क्या चाहिए

एक self-hosted AI image generator में एक web app और एक model file होती है। App का नाम ComfyUI है, और यह किसी भी Linux box पर चल सकता है। Model ही तय करता है कि आपको किस hardware की आवश्यकता है। SDXL-class का एक checkpoint 6.94 GB की एक single file होती है, और इसे GPU memory में रहने की आवश्यकता होती है। यही एक तथ्य पूरे बजट को निर्धारित करता है, इसलिए कुछ भी किराए पर लेने से पहले नीचे दी गई hardware ladder को पढ़ें।

ईमानदार सारांश: एक CPU-only VPS software को install और serve कर सकता है, और यह पुराने Stable Diffusion 1.5 model के साथ 512x512 resolution पर प्रति image एक या दो मिनट में image generate कर सकता है। वही box यदि 1024x1024 पर SDXL चलाता है, तो उसे प्रति image दस से बीस मिनट का समय लगता है। यह कोई broken setup नहीं है। यह केवल गणित है, और यह guide इसे समझाती है।

मॉडल का आकार मशीन का चयन क्यों निर्धारित करता है

इमेज जनरेशन एक denoising लूप चलाता है। 30-स्टेप रेंडर, denoiser यानी SDXL के UNet को इमेज पर 30 बार चलाता है, और प्रत्येक पास में हर UNet वेट (weight) को पढ़ा जाता है। दो टेक्स्ट एनकोडर लूप से पहले एक बार चलते हैं और VAE लूप के बाद एक बार डिकोड करता है, इसलिए वे प्रति-स्टेप लागत का हिस्सा नहीं हैं। हाफ प्रिसिजन (half precision) पर SDXL का UNet 5.14 GB वेट का होता है, इसलिए इस सरल दृष्टिकोण में एक 30-स्टेप रेंडर तस्वीर दिखने से पहले लगभग 154 GB वेट को मेमोरी के माध्यम से प्रोसेस करता है, और इंटरमीडिएट टेंसर इसमें और अधिक भार जोड़ते हैं।

24 GB वीडियो मेमोरी (VRAM, जो ग्राफिक्स चिप के बगल में सोल्डर की गई मेमोरी होती है) वाला GPU प्रति सेकंड सैकड़ों गीगाबाइट की गति से डेटा पढ़ता है, और यह सभी 6.9 GB को एक साथ होल्ड कर सकता है। एक CPU VPS सिस्टम RAM को प्रति सेकंड दसियों गीगाबाइट की गति से पढ़ता है, और इसमें कन्वेल्शन्स (convolutions) के लिए कोई मैट्रिक्स हार्डवेयर नहीं होता, इसलिए वही लूप एक से दो ऑर्डर ऑफ मैग्नीट्यूड धीमा चलता है। यह वही मेमोरी-बैंडविड्थ तर्क है जो टेक्स्ट मॉडल पर लागू होता है, और इसे जब GPU वाला VPS वास्तव में पैसे के लायक होता है के साथ पढ़ना उपयोगी है।

इमेज जनरेशन, टेक्स्ट जनरेशन से एक महत्वपूर्ण तरीके से अलग है। एक चैट मॉडल टोकन स्ट्रीम करता है, इसलिए धीमी मशीन भी उपयोग करने योग्य लगती है क्योंकि शब्द आपके पढ़ते समय दिखाई देते हैं। एक इमेज केवल तभी दिखाई देती है जब अंतिम स्टेप पूरा हो जाता है। धीमे होने का मतलब है प्रोग्रेस बार को देखते रहना।

हार्डवेयर का स्तर, वास्तविक आंकड़ों के साथ

नीचे दिया गया ब्लॉक जुलाई 2026 तक, 1024x1024, 30 steps, Euler sampler पर एक SDXL इमेज के लिए सामान्य आंकड़े दर्शाता है। इन्हें केवल परिमाण के क्रम (order of magnitude) के रूप में देखें। आपका sampler, step count और resolution इन्हें बदल सकते हैं।

[
  {
    "label": "8 vCPU VPS, no GPU",
    "seconds_per_image": 780
  },
  {
    "label": "8GB VRAM GPU",
    "seconds_per_image": 32
  },
  {
    "label": "12GB VRAM GPU",
    "seconds_per_image": 18
  },
  {
    "label": "24GB VRAM GPU",
    "seconds_per_image": 9
  }
]

CPU वाली पंक्ति 780 सेकंड है, जो लगभग तेरह मिनट है। 24 GB वाला कार्ड 9 सेकंड है। यही वह अंतर है जिसके लिए आप भुगतान कर रहे हैं।

इस स्तर को इस तरह पढ़ें। 8 GB VRAM से नीचे, SDXL अभी भी चलता है, क्योंकि ComfyUI VRAM और system RAM को एक साथ प्रबंधित करता है और model weights को स्वचालित रूप से offload कर देता है। अक्टूबर 2026 तक, प्रोजेक्ट की README फाइल के अनुसार, इसकी न्यूनतम सीमा 4 GB VRAM और 8 GB system RAM है, जिसमें asynchronous weight streaming का उपयोग होता है। Offloading में हर step पर समय लगता है, इसलिए 6 GB वाला कार्ड तीस सेकंड के बजाय एक मिनट के करीब समय लेता है। 8 GB पर base model फिट हो जाता है और रेंडरिंग आरामदायक रहती है। 12 GB पर आप offloading के बिना checkpoint के साथ एक या दो ControlNet रख सकते हैं। 24 GB पर आप एक ही workflow में SDXL, refiner और upscaling चला सकते हैं, और LoRA adapters को अतिरिक्त जगह के साथ train कर सकते हैं। ट्रेनिंग इससे कम में भी हो सकती है: kohya-ss sd-scripts trainer के लिए SDXL ट्रेनिंग गाइड कहती है कि LoRA ट्रेनिंग 8 GB GPU मेमोरी के साथ की जा सकती है, जिसमें 10 GB की सिफारिश की गई है। वहां तक पहुँचने के लिए यह केवल U-Net को train करने, gradient checkpointing चालू करने, text encoder outputs और latents को cache करने, 8-bit optimizer या Adafactor का उपयोग करने, और 8 GB कार्ड पर LoRA dim को 4 से 8 तक कम करने के लिए कहती है। kohya_ss GUI के लिए LoRA गाइड, जो उन scripts को रैप करती है, अधिक सतर्क है: यह कहती है कि LoRA ट्रेनिंग के लिए कम से कम 12 GB मेमोरी वाले GPU का उपयोग करें।

CPU VPS क्या कर सकता है और क्या नहीं

यह लोगों की अपेक्षा से अधिक काम कर सकता है, लेकिन मार्केटिंग के दावों से कम। इसकी सीमाओं के बारे में स्पष्ट रहें।

एक CPU VPS पर ComfyUI इंस्टॉल किया जा सकता है, वेब इंटरफेस सर्व किया जा सकता है, मॉडल लाइब्रेरी रखी जा सकती है, क्यू (queue) चलाई जा सकती है और बिना GPU के भी इमेज जनरेट की जा सकती हैं। 8 आधुनिक vCPUs और 16 GB RAM के साथ Stable Diffusion 1.5 पर 512x512 रेजोल्यूशन और 20 स्टेप्स के लिए, प्रति इमेज लगभग 60 से 150 सेकंड का समय लग सकता है। रात भर चलने वाले बैच जॉब या क्यू के पीछे कम वॉल्यूम वाले इमेज एंडपॉइंट के लिए, यह वास्तव में ठीक है।

एक CPU VPS आपको इंटरैक्टिव काम करने की सुविधा नहीं दे सकता। प्रॉम्प्ट इटरेशन का मतलब है एक घंटे में बीस रेंडर, और प्रत्येक के लिए तेरह मिनट के हिसाब से आप केवल चार ही कर पाएंगे। यह ट्रेनिंग भी नहीं कर सकता। CPU पर LoRA फाइन-ट्यूनिंग घंटों में नहीं, बल्कि दिनों में मापी जाती है, इसलिए इसे अनुपलब्ध ही मानें।

CPU-only के लिए मेमोरी का नियम GPU नियम से अलग है। वेट्स (weights) सिस्टम RAM में लोड होते हैं, इसलिए आपको मॉडल के आकार के साथ-साथ वर्किंग स्पेस की भी आवश्यकता होती है: SDXL के लिए लगभग 16 GB RAM और SD 1.5 के लिए लगभग 8 GB। 4 GB वाला बॉक्स ComfyUI को स्टार्ट तो कर देगा, लेकिन पहले रेंडर के दौरान ही out-of-memory killer द्वारा इसे बंद कर दिया जाएगा, जो कि प्रक्रिया के अचानक गायब होने के रूप में Killed में dmesg के भीतर दिखाई देगा, जिसमें कोई Python traceback नहीं होगा।

GPU मशीन पर ComfyUI इंस्टॉल करें

ये upstream commands हैं। एक साफ Ubuntu 24.04 इंस्टॉलेशन से शुरुआत करें जिसमें NVIDIA driver पहले से मौजूद हो। सबसे पहले driver की पुष्टि करें, क्योंकि इस जाँच के बिना बाद में होने वाली हर विफलता एक जैसी ही दिखती है।

nvidia-smi

यह आपके कार्ड और CUDA version के साथ एक table print करेगा। command not found, या NVIDIA-SMI has failed because it couldn't communicate with the NVIDIA driver का मतलब है कि driver गायब है या upgrade के बाद kernel module load नहीं हुआ है। आगे बढ़ने से पहले इसे ठीक करें, क्योंकि ComfyUI चुपचाप CPU पर वापस चला जाएगा और आप software को दोष देंगे।

sudo apt update
sudo apt install -y git python3-venv python3-pip wget
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI
python3 -m venv venv
. venv/bin/activate
pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu130
pip install -r requirements.txt

Virtual environment कोई वैकल्पिक सलाह नहीं है। PyTorch एक बड़ी dependency tree खींचता है, और इसे किसी ऐसी मशीन पर system-wide इंस्टॉल करना जो कुछ और भी चलाती है, दूसरी चीज़ों को खराब करने का कारण बनता है। आगे बढ़ने से पहले पुष्टि करें कि PyTorch कार्ड को देख सकता है।

python -c "import torch; print(torch.cuda.is_available(), torch.cuda.get_device_name(0))"

True और आपके कार्ड का नाम आने का मतलब है कि stack काम कर रहा है। False का मतलब है कि जो wheel आपने इंस्टॉल किया है वह driver से मेल नहीं खाता, आमतौर पर इसलिए क्योंकि CPU-only torch wheel पहले से cached था। ऊपर दिए गए index URL के साथ इसे फिर से इंस्टॉल करें।

मॉडल प्राप्त करें और डिस्क के लिए योजना बनाएं

ComfyUI के साथ कोई weights नहीं आते हैं। Checkpoints को models/checkpoints में, VAE फाइलों को models/vae में, और LoRA adapters को models/loras में रखें।

cd ~/ComfyUI/models/checkpoints
wget https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/resolve/main/sd_xl_base_1.0.safetensors

हमेशा .ckpt के बजाय .safetensors को प्राथमिकता दें। एक .ckpt फाइल एक pickled Python object होती है, और इसे लोड करने पर इसे बनाने वाले का कोड निष्पादित (execute) हो जाता है। Safetensors फॉर्मेट में केवल tensors होते हैं, इसलिए एक दुर्भावनापूर्ण फाइल कुछ भी रन नहीं कर सकती।

स्टोरेज वह लागत है जिसे लोग भूल जाते हैं। एक SDXL base checkpoint 6.94 GB का होता है। Refiner 6 GB का होता है। एक SDXL ControlNet मॉडल का आकार छोटे Canny मॉडल के लिए 320 MB से लेकर half precision पर पूर्ण मॉडल के लिए 2.5 GB तक होता है। Upscaler छोटा होता है: मानक Real-ESRGAN x4plus मॉडल 67 MB का है, इसका anime मॉडल 17.9 MB का है, और इसका anime video मॉडल 2.5 MB का है। एक LoRA का आकार tens of megabytes से लेकर ByteDance के Hyper-SDXL adapters के लिए 787 MB तक होता है। जो भी इसका आनंद लेता है, वह एक सप्ताह के भीतर दूसरा और तीसरा base मॉडल डाउनलोड कर लेता है। एक कार्यशील इंस्टॉलेशन के लिए 100 GB डिस्क का बजट रखें, और outputs डायरेक्टरी पर भी नजर रखें: 1024x1024 PNG फाइलें प्रत्येक 1 से 2 MB की होती हैं, और एक unattended batch छोटी डिस्क को चुपचाप भर देता है। models/ और output/ को ऐसी वॉल्यूम पर रखें जिसे आप बढ़ा सकें, और अपनी workflow JSON फाइलों का बैकअप encrypted incremental backups to object storage जैसी किसी चीज़ से लें। Weights को दोबारा डाउनलोड किया जा सकता है। आपके द्वारा ट्यून किए गए workflows को नहीं।

इसे चलाएं और सुरक्षित रूप से एक्सेस करें

cd ~/ComfyUI
. venv/bin/activate
python main.py --listen 127.0.0.1 --port 8188

ComfyUI पोर्ट 8188 पर चलता है। केवल CPU वाले बॉक्स पर, --cpu जोड़ें, जो CUDA डिवाइस न मिलने पर फेल होने के बजाय CPU पाथ का उपयोग करने के लिए मजबूर करता है।

इसे 0.0.0.0 पर नहीं, बल्कि 127.0.0.1 पर बाइंड करें। ComfyUI में अब अकाउंट्स की सुविधा है, लेकिन उनमें से कोई भी आपके सर्वर को लॉक नहीं करता है। Settings के अंतर्गत User सेक्शन में लॉगिन करने से आप Comfy अकाउंट में साइन इन होते हैं, और यह लोकल इंस्टॉलेशन से काम करता है: Comfy के डॉक्स में ईमेल, Google, GitHub और API की साइन-इन की सूची दी गई है। डॉक्स इस अकाउंट को पार्टनर नोड्स और Comfy Cloud सब्सक्रिप्शन तक आपकी पहुंच के रूप में वर्णित करते हैं, और इनमें से कोई भी इसे आपके सर्वर को पासवर्ड से सुरक्षित करने के तरीके के रूप में प्रस्तुत नहीं करता है। --multi-user फ्लैग केवल प्रति-उपयोगकर्ता स्टोरेज को सक्षम करता है: अक्टूबर 2026 तक, सर्वर comfy-user रिक्वेस्ट हेडर से उपयोगकर्ता का नाम लेता है और किसी पासवर्ड की जांच नहीं करता है। जो कुछ भी इस पोर्ट तक पहुंचता है, वह जॉब्स को कतार में लगा सकता है, आपके द्वारा जेनरेट की गई हर इमेज को पढ़ सकता है, और यदि आपने इसे --enable-manager के साथ शुरू किया है, तो कस्टम नोड्स इंस्टॉल कर सकता है, जो आपके सर्वर पर आर्बिट्रेरी कोड निष्पादन (arbitrary code execution) है। इसके बजाय अपने लैपटॉप से SSH टनल के माध्यम से इसे एक्सेस करें।

ssh -N -L 8188:127.0.0.1:8188 you@your-server

फिर स्थानीय रूप से http://127.0.0.1:8188 खोलें। यदि आपको वास्तविक मल्टी-यूज़र एक्सेस की आवश्यकता है, तो इसके सामने ऑथेंटिकेशन वाला एक रिवर्स प्रॉक्सी रखें और ऐप को localhost पर बाइंड रखें। यही तर्क किसी भी अनधिकृत (unauthenticated) सेल्फ-होस्टेड सर्विस पर लागू होता है, और यह VPS पर Docker Compose डिप्लॉयमेंट में मानक पैटर्न है।

इसे systemd के अंतर्गत चालू रखें

एक रेंडर क्यू जो आपके SSH सत्र के बंद होने पर समाप्त हो जाती है, वह एक सर्विस नहीं है। इसे बिना लॉगिन वाले comfy यूजर के रूप में चलाएं, न कि स्वयं के रूप में: कस्टम नोड्स कोड होते हैं, और उस कोड को आपकी होम डायरेक्टरी तक पहुंच के साथ नहीं चलना चाहिए। यूजर बनाएं और इंस्टॉलेशन को उसके होम में ले जाएं:

sudo useradd --system --create-home --home-dir /home/comfy --shell /usr/sbin/nologin comfy
sudo mv ~/ComfyUI /home/comfy/
sudo chown -R comfy:comfy /home/comfy/ComfyUI

मूव करने के बाद भी वर्चुअल एनवायरनमेंट काम करता है, क्योंकि यूनिट सीधे इसके python को कॉल करती है। फिर /etc/systemd/system/comfyui.service लिखें।

[Unit]
Description=ComfyUI
After=network-online.target

[Service]
User=comfy
WorkingDirectory=/home/comfy/ComfyUI
ExecStart=/home/comfy/ComfyUI/venv/bin/python main.py --listen 127.0.0.1 --port 8188
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable --now comfyui
systemctl status comfyui

active (running) और To see the GUI go to: http://127.0.0.1:8188 पढ़ने वाली एक लॉग लाइन का मतलब है कि यह चालू है। ध्यान दें कि ExecStart सीधे वर्चुअल एनवायरनमेंट के अंदर इंटरप्रेटर का नाम देता है, क्योंकि systemd आपके शेल प्रोफाइल को रन नहीं करता है और activate कभी नहीं होता है।

बजट के अनुसार व्यावहारिक सुझाव

यदि आप image generation आज़माना चाहते हैं और गति की तुलना में लागत अधिक महत्वपूर्ण है, तो 16 GB RAM वाला CPU VPS लें, 512x512 पर SD 1.5 चलाएं, और प्रति image एक या दो मिनट का समय स्वीकार करें। यह शुरुआत करने का एक ईमानदार तरीका है, और इसकी लागत GPU वाले किसी भी विकल्प की तुलना में बहुत कम है। जब तक आप निर्णय नहीं ले लेते, तब तक model library और workflows को host करने के लिए भी यह सही जगह है।

यदि आप प्रतिदिन prompts को iterate करते हैं, तो GPU cloud से प्रति घंटे के हिसाब से कम से कम 12 GB VRAM वाला GPU किराए पर लें, और काम खत्म होने पर उसे बंद कर दें। Image generation एक रुक-रुक कर किया जाने वाला काम है, और मासिक बिल पर idle GPU का होना ही वह सबसे आम तरीका है जिससे लोग यहाँ अधिक खर्च कर देते हैं। Checkpoints को सस्ते block storage पर रखें और उन्हें mount करें।

यदि आप दूसरों को सेवा देते हैं, या नियमित रूप से LoRA adapters को train करते हैं, तो 24 GB VRAM और अपनी खुद की मशीन रखने की योजना बनाएं। sd-scripts SDXL guide का कहना है कि LoRA training को इसके memory-saving settings का उपयोग करके 8 GB के साथ किया जा सकता है, जिसमें 10 GB की सिफारिश की गई है, और kohya_ss GUI की LoRA guide कम से कम 12 GB मांगती है। sd-scripts guide में 24 GB का आंकड़ा batch size 1 पर पूर्ण SDXL fine-tuning के लिए है, इसलिए 24 GB का कार्ड LoRA के काम को संभाल लेता है और fine-tuning को भी पहुंच के भीतर रखता है। उस स्तर पर, वही machine आमतौर पर स्थानीय language model चलाकर भी अपनी लागत निकाल लेती है, जो Ollama के साथ self-hosting an LLM में वर्णित setup है।

आप चाहे जो भी विकल्प चुनें, किसी भी प्रकाशित आंकड़े पर विश्वास करने से पहले अपनी मशीन को मापें। एक ही prompt को पांच बार queue में डालें और ComfyUI द्वारा console में print किए गए seconds-per-iteration को पढ़ें। वह संख्या ही आपकी वास्तविक स्थिति है।

FAQ

क्या मैं बिना GPU के Stable Diffusion चला सकता हूँ?

हाँ। ComfyUI python main.py --cpu के साथ चलता है और बिना graphics card के भी वास्तविक images generate करता है। 8 आधुनिक vCPUs पर 512x512 पर Stable Diffusion 1.5 के लिए प्रति image लगभग 60 से 150 सेकंड, और 1024x1024 पर SDXL के लिए दस से बीस मिनट का समय मानकर चलें। यह overnight batches और कम-volume वाले endpoints के लिए काम करता है। यह prompt iteration के लिए काम नहीं करता है, और training पूरी तरह से पहुंच से बाहर है।

SDXL के लिए मुझे कितनी VRAM चाहिए?

8 GB VRAM, 1024x1024 पर SDXL को आसानी से चलाती है। उससे कम होने पर ComfyUI स्वचालित रूप से model weights को system RAM में offload कर देता है और फिर भी काम करता है। अक्टूबर 2026 तक, इसके README में 4 GB VRAM और 8 GB system RAM की न्यूनतम आवश्यकता बताई गई है, और प्रत्येक offloaded step में समय लगता है। 12 GB VRAM आपको checkpoint के साथ ControlNet रखने की सुविधा देती है, और 24 GB एक ही workflow में base, refiner और upscaling को कवर करती है। kohya-ss sd-scripts guide का कहना है कि यदि आप इसके memory-saving settings का उपयोग करते हैं तो SDXL LoRA training 8 GB के साथ की जा सकती है, जिसमें 10 GB की सिफारिश की गई है, जबकि kohya_ss GUI की LoRA guide कम से कम 12 GB मांगती है। पूर्ण SDXL fine-tuning के लिए batch size 1 पर 24 GB की आवश्यकता होती है।

models को कितनी disk space की आवश्यकता होती है?

अकेला SDXL base checkpoint 6.94 GB का है, और refiner लगभग 6 GB और जोड़ता है। SDXL ControlNet models half precision पर 320 MB से 2.5 GB तक की होती हैं, LoRA adapters दसियों megabytes से 787 MB तक के होते हैं, और Real-ESRGAN upscalers 2.5 MB से 67 MB तक के होते हैं। कुछ base models के साथ working install के लिए 100 GB का बजट रखें, और output directory पर अलग से नज़र रखें, क्योंकि 1024x1024 PNG files प्रत्येक 1 से 2 MB की होती हैं।

क्या ComfyUI को public internet पर expose करना सुरक्षित है?

नहीं। ComfyUI की settings में Comfy account login स्थानीय install से काम करता है, लेकिन यह आपको Comfy के partner nodes और cloud subscriptions तक पहुंच प्रदान करता है, और Comfy के docs में कहीं भी इसे आपके सर्वर के लिए सुरक्षा के रूप में प्रस्तुत नहीं किया गया है। --multi-user flag केवल password की जांच किए बिना प्रति-उपयोगकर्ता storage को अलग करता है। ComfyUI-Manager सक्षम होने पर, interface custom nodes install करता है, जो Python code है और आपके सर्वर पर चलता है, इसलिए एक खुला port remote code execution का जोखिम है। इसे 127.0.0.1 पर bind करें, ssh -N -L 8188:127.0.0.1:8188 you@your-server के साथ SSH tunnel के माध्यम से इसे access करें, और यदि एक से अधिक व्यक्ति को पहुंच की आवश्यकता हो तो इसके सामने एक authenticating reverse proxy रखें।

मेरा render बिना किसी error message के क्यों बंद हो गया?

dmesg में Killed के साथ process का गायब हो जाना और कोई Python traceback न मिलना Linux का out-of-memory killer है, न कि ComfyUI का कोई bug। केवल CPU वाली मशीन पर weights system RAM में रहते हैं, इसलिए SDXL को लगभग 16 GB और SD 1.5 को लगभग 8 GB RAM की आवश्यकता होती है, साथ ही working space भी चाहिए। RAM बढ़ाएं, swap जोड़ें, या छोटे model और कम resolution का उपयोग करें।