ComfyUI

Clore.ai पर ComfyUI के साथ नोड-आधारित Stable Diffusion इंटरफ़ेस

CLORE.AI GPUs पर अधिकतम लचीलेपन के साथ Stable Diffusion के लिए नोड-आधारित इंटरफ़ेस।

सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं, जिन्हें किराए पर लिया गया है CLORE.AI मार्केटप्लेस.

सर्वर आवश्यकताएँ

पैरामीटर	न्यूनतम	अनुशंसित
RAM	16GB	32GB+
VRAM	8GB (SDXL)	12GB+
नेटवर्क	500Mbps	1Gbps+
प्रारंभ समय	5-10 मिनट	-

स्टार्टअप समय: पहली बार लॉन्च करने पर निर्भरताएँ और मॉडल डाउनलोड होते हैं (नेटवर्क गति के अनुसार 5-10 मिनट)। इस दौरान HTTP 502 सामान्य है।

महत्वपूर्ण: FLUX मॉडल्स के साथ ComfyUI के लिए 16GB+ VRAM चाहिए। SDXL with ControlNet के लिए, कम से कम 10GB VRAM सुनिश्चित करें।

ComfyUI क्यों?

• नोड-आधारित वर्कफ़्लो - छवि जनरेशन के लिए विज़ुअल प्रोग्रामिंग

• अधिकतम नियंत्रण - पाइपलाइन के हर चरण को बारीकी से समायोजित करें

• कुशल - विकल्पों की तुलना में कम VRAM उपयोग

• विस्तारयोग्य - कस्टम नोड्स का विशाल इकोसिस्टम

• वर्कफ़्लो साझा करना - JSON के रूप में आयात/निर्यात

CLORE.AI पर त्वरित परिनियोजन

Docker इमेज:

yanwk/comfyui-boot:cu130-slim

पोर्ट:

22/tcp
8188/http

पर्यावरण:

CLI_ARGS=--listen 0.0.0.0

सत्यापित करें कि यह काम कर रहा है

डिप्लॉयमेंट के बाद, अपना http_pub URL यहाँ मेरे ऑर्डर:

# जाँचें कि UI सुलभ है या नहीं (पहली बार चलाने पर 5-10 मिनट लग सकते हैं)
curl https://your-http-pub.clorecloud.net/

यदि आपको 15 मिनट से अधिक समय तक HTTP 502 मिलता है, तो जाँचें:

1. सर्वर में 16GB+ RAM है

2. सर्वर में SDXL के लिए 8GB+ VRAM, FLUX के लिए 16GB+ VRAM है

3. मॉडल डाउनलोड करने के लिए नेटवर्क गति पर्याप्त है

अपनी सेवा तक पहुँचना

CLORE.AI पर डिप्लॉय करने पर, ComfyUI तक इस माध्यम से पहुँचें: http_pub URL:

• Web UI: https://your-http-pub.clorecloud.net/

• API: https://your-http-pub.clorecloud.net/prompt

• WebSocket: wss://your-http-pub.clorecloud.net/ws

सभी localhost:8188 नीचे दिए गए उदाहरण SSH के माध्यम से कनेक्ट होने पर काम करते हैं। बाहरी पहुँच के लिए, इसे अपने https://your-http-pub.clorecloud.net/ URL से बदलें।

इंस्टॉलेशन

Docker का उपयोग करना (अनुशंसित)

docker run -d --gpus all \
  -p 8188:8188 \
  -v comfyui-data:/root \
  -e CLI_ARGS="--listen 0.0.0.0" \
  yanwk/comfyui-boot:cu130-slim

मैन्युअल इंस्टॉलेशन

# रिपॉजिटरी क्लोन करें
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI

# वर्चुअल वातावरण बनाएँ
python -m venv venv
source venv/bin/activate

# PyTorch को CUDA के साथ इंस्टॉल करें
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu128

# आवश्यकताएँ इंस्टॉल करें
pip install -r requirements.txt

# चलाएँ
python main.py --listen 0.0.0.0

डायरेक्टरी संरचना

ComfyUI/
├── models/
│   ├── checkpoints/     # SD मॉडल्स (.safetensors)
│   ├── loras/           # LoRA मॉडल्स
│   ├── vae/             # VAE मॉडल्स
│   ├── controlnet/      # ControlNet मॉडल्स
│   ├── upscale_models/  # अपस्केलर्स
│   └── clip/            # CLIP मॉडल्स
├── input/               # इनपुट छवियाँ
├── output/              # जनरेट की गई छवियाँ
└── custom_nodes/        # एक्सटेंशन्स

मॉडल डाउनलोड करें

Stable Diffusion Checkpoints

cd ComfyUI/models/checkpoints

# SDXL Base
wget https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/resolve/main/sd_xl_base_1.0.safetensors

# SDXL Refiner
wget https://huggingface.co/stabilityai/stable-diffusion-xl-refiner-1.0/resolve/main/sd_xl_refiner_1.0.safetensors

# SD 1.5 (छोटा, तेज़)
wget https://huggingface.co/runwayml/stable-diffusion-v1-5/resolve/main/v1-5-pruned.safetensors

# यथार्थवादी विज़न (फोटोरियलिस्टिक)
wget https://huggingface.co/SG161222/Realistic_Vision_V6.0_B1_noVAE/resolve/main/Realistic_Vision_V6.0_B1_fp16.safetensors

VAE

cd ComfyUI/models/vae

# SDXL VAE
wget https://huggingface.co/stabilityai/sdxl-vae/resolve/main/sdxl_vae.safetensors

# SD 1.5 VAE (बेहतर रंग)
wget https://huggingface.co/stabilityai/sd-vae-ft-mse-original/resolve/main/vae-ft-mse-840000-ema-pruned.safetensors

LoRAs

cd ComfyUI/models/loras

# CivitAI या HuggingFace से डाउनलोड करें
# .safetensors फ़ाइलें यहाँ रखें

बेसिक वर्कफ़्लो

टेक्स्ट से इमेज

1. नोड जोड़ें:

   • Load Checkpoint → मॉडल चुनें

   • CLIP Text Encode (x2) → सकारात्मक और नकारात्मक प्रॉम्प्ट

   • Empty Latent Image → आयाम सेट करें

   • KSampler → सभी को कनेक्ट करें

   • VAE Decode → latent को image में बदलें

   • Save Image → आउटपुट

2. कनेक्ट करें:

[Checkpoint] → MODEL → [KSampler]
[Checkpoint] → CLIP → [CLIP Text Encode +]
[Checkpoint] → CLIP → [CLIP Text Encode -]
[Checkpoint] → VAE → [VAE Decode]
[Text Encode +] → CONDITIONING → [KSampler]
[Text Encode -] → CONDITIONING → [KSampler]
[Empty Latent] → LATENT → [KSampler]
[KSampler] → LATENT → [VAE Decode]
[VAE Decode] → IMAGE → [Save Image]

Image to Image

बदलें Empty Latent Image को इससे:

1. Load Image → आपकी स्रोत छवि

2. VAE Encode → latent में बदलें

3. समायोजित करें डीनॉइज़ KSampler में (0.5-0.8)

ComfyUI Manager

ComfyUI Manager एक आवश्यक एक्सटेंशन है जो custom nodes को इंस्टॉल, अपडेट और प्रबंधित करने के लिए GUI जोड़ता है। यह ComfyUI को विस्तारित करने का मानक तरीका है।

इंस्टॉलेशन

cd ComfyUI/custom_nodes
git clone https://github.com/ltdrdata/ComfyUI-Manager.git
# ComfyUI रीस्टार्ट करें — टूलबार में एक "Manager" बटन दिखाई देगा

ComfyUI Manager का उपयोग

रीस्टार्ट के बाद, एक Manager बटन ComfyUI इंटरफ़ेस के ऊपर-दाएँ दिखाई देता है।

मुख्य विशेषताएँ:

विशेषता	कैसे एक्सेस करें
कस्टम नोड्स इंस्टॉल करें	Manager → Install Custom Nodes
सभी नोड्स अपडेट करें	Manager → Update All
नोड्स निष्क्रिय/सक्रिय करें	Manager → Custom Nodes Manager
गुम नोड्स इंस्टॉल करें	Manager → Install Missing Custom Nodes
मॉडल जानकारी प्राप्त करें	Manager → Model Manager
स्नैपशॉट पुनर्स्थापित करें	Manager → Snapshot Manager

वर्कफ़्लो: नया नोड पैक इंस्टॉल करना

1. क्लिक करें Manager बटन

2. चुनें Install Custom Nodes

3. नाम से खोजें (जैसे, "FLUX", "AnimateDiff")

4. क्लिक करें इंस्टॉल वांछित पैक पर

5. क्लिक करें रीस्टार्ट जब संकेत मिले

6. नए नोड्स राइट-क्लिक ऐड मेनू में दिखाई देते हैं

गुम नोड्स ऑटो-इंस्टॉल करें: जब आप ऐसा वर्कफ़्लो JSON इम्पोर्ट करते हैं जिसमें ऐसे नोड्स हों जो आपके पास नहीं हैं, Manager उन्हें पहचानता है और स्वतः इंस्टॉल करने की पेशकश करता है Install Missing Custom Nodes.

नोड्स को अपडेट रखना

# CLI से (GUI के विकल्प के रूप में):
cd ComfyUI/custom_nodes/ComfyUI-Manager
git pull

# या UI में Manager → Update All का उपयोग करें

---

ComfyUI में FLUX वर्कफ़्लो

FLUX मानक SD मॉडलों से अलग नोड संरचना का उपयोग करता है। नीचे एक पूर्ण FLUX.1-dev वर्कफ़्लो है।

आवश्यक फ़ाइलें

वर्कफ़्लो चलाने से पहले, डाउनलोड करें:

# FLUX मॉडल (dev या schnell)
cd ComfyUI/models/unet
wget https://huggingface.co/black-forest-labs/FLUX.1-dev/resolve/main/flux1-dev.safetensors

# Text encoders
cd ../clip
wget https://huggingface.co/comfyanonymous/flux_text_encoders/resolve/main/clip_l.safetensors
wget https://huggingface.co/comfyanonymous/flux_text_encoders/resolve/main/t5xxl_fp16.safetensors

# VAE
cd ../vae
wget https://huggingface.co/black-forest-labs/FLUX.1-dev/resolve/main/ae.safetensors

FLUX.1-dev वर्कफ़्लो JSON

इस रूप में सहेजें flux_dev_workflow.json और इसके माध्यम से इम्पोर्ट करें लोड करें ComfyUI में बटन:

{
  "last_node_id": 12,
  "last_link_id": 20,
  "nodes": [
    {
      "id": 1,
      "type": "UNETLoader",
      "pos": [100, 100],
      "size": [300, 60],
      "inputs": [],
      "outputs": [{"name": "MODEL", "type": "MODEL", "links": [1]}],
      "properties": {},
      "widgets_values": ["flux1-dev.safetensors", "default"]
    },
    {
      "id": 2,
      "type": "DualCLIPLoader",
      "pos": [100, 200],
      "size": [350, 80],
      "inputs": [],
      "outputs": [{"name": "CLIP", "type": "CLIP", "links": [2, 3]}],
      "properties": {},
      "widgets_values": ["clip_l.safetensors", "t5xxl_fp16.safetensors", "flux"]
    },
    {
      "id": 3,
      "type": "CLIPTextEncode",
      "pos": [500, 150],
      "size": [425, 180],
      "inputs": [{"name": "clip", "type": "CLIP", "link": 2}],
      "outputs": [{"name": "CONDITIONING", "type": "CONDITIONING", "links": [4]}],
      "properties": {},
      "widgets_values": ["एक शानदार फोटोरियलिस्टिक परिदृश्य, गोल्डन आवर लाइटिंग, 8K"]
    },
    {
      "id": 4,
      "type": "EmptySD3LatentImage",
      "pos": [100, 350],
      "size": [300, 100],
      "inputs": [],
      "outputs": [{"name": "LATENT", "type": "LATENT", "links": [5]}],
      "properties": {},
      "widgets_values": [1024, 1024, 1]
    },
    {
      "id": 5,
      "type": "ModelSamplingFlux",
      "pos": [500, 350],
      "size": [300, 80],
      "inputs": [{"name": "model", "type": "MODEL", "link": 1}],
      "outputs": [{"name": "MODEL", "type": "MODEL", "links": [6]}],
      "properties": {},
      "widgets_values": [1.15, 0.5, 1024, 1024]
    },
    {
      "id": 6,
      "type": "KSampler",
      "pos": [850, 250],
      "size": [350, 240],
      "inputs": [
        {"name": "model", "type": "MODEL", "link": 6},
        {"name": "positive", "type": "CONDITIONING", "link": 4},
        {"name": "negative", "type": "CONDITIONING", "link": 7},
        {"name": "latent_image", "type": "LATENT", "link": 5}
      ],
      "outputs": [{"name": "LATENT", "type": "LATENT", "links": [8]}],
      "properties": {},
      "widgets_values": [42, "fixed", 20, 3.5, "euler", "simple", 1.0]
    },
    {
      "id": 7,
      "type": "CLIPTextEncode",
      "pos": [500, 500],
      "size": [300, 60],
      {"inputs": [{"name": "clip", "type": "CLIP", "link": 3}],
      "outputs": [{"name": "CONDITIONING", "type": "CONDITIONING", "links": [7]}],
      "properties": {},
      "widgets_values": [""]
    },
    {
      "id": 8,
      "type": "VAELoader",
      "pos": [100, 500],
      "size": [300, 60],
      "inputs": [],
      "outputs": [{"name": "VAE", "type": "VAE", "links": [9]}],
      "properties": {},
      "widgets_values": ["ae.safetensors"]
    },
    {
      "id": 9,
      "type": "VAEDecode",
      "pos": [1250, 300],
      "size": [210, 46],
      "inputs": [
        {"name": "samples", "type": "LATENT", "link": 8},
        {"name": "vae", "type": "VAE", "link": 9}
      ],
      "outputs": [{"name": "IMAGE", "type": "IMAGE", "links": [10]}],
      "properties": {}
    },
    {
      "id": 10,
      "type": "SaveImage",
      "pos": [1500, 300],
      "size": [300, 270],
      "inputs": [{"name": "images", "type": "IMAGE", "link": 10}],
      "outputs": [],
      "properties": {},
      "widgets_values": ["flux_output"]
    }
  ],
  "links": [
    [1, 1, 0, 5, 0, "MODEL"],
    [2, 2, 0, 3, 0, "CLIP"],
    [3, 2, 0, 7, 0, "CLIP"],
    [4, 3, 0, 6, 1, "CONDITIONING"],
    [5, 4, 0, 6, 3, "LATENT"],
    [6, 5, 0, 6, 0, "MODEL"],
    [7, 7, 0, 6, 2, "CONDITIONING"],
    [8, 6, 0, 9, 0, "LATENT"],
    [9, 8, 0, 9, 1, "VAE"],
    [10, 9, 0, 10, 0, "IMAGE"]
  ],
  "groups": [],
  "config": {},
  "extra": {"ds": {"scale": 0.8, "offset": [0, 0]}},
  "version": 0.4
}

FLUX.1-schnell वर्कफ़्लो (4 चरण)

schnell के लिए, ऊपर दिए JSON में KSampler सेटिंग्स बदलें:

• num_inference_steps: 4

• cfg: 1.0

• scheduler: "simple"

• मॉडल फ़ाइल: flux1-schnell.safetensors

या UI के माध्यम से सेट करें: KSampler → steps: 4, cfg: 1.0, sampler: euler, scheduler: simple

मुख्य नोड अंतर: FLUX बनाम SD

नोड	SD/SDXL	FLUX
मॉडल लोडर	Load Checkpoint	UNETLoader
टेक्स्ट एन्कोडर	CLIPTextEncode	DualCLIPLoader + CLIPTextEncode
Latent	Empty Latent Image	EmptySD3LatentImage
अतिरिक्त	—	ModelSamplingFlux
नकारात्मक प्रॉम्प्ट	आवश्यक	वैकल्पिक (खाली छोड़ें)

---

आवश्यक कस्टम नोड्स

अनुशंसित नोड पैक्स

नोड पैक	GitHub	उपयोग-प्रकरण
ComfyUI-Manager	ltdrdata/ComfyUI-Manager	अन्य सभी नोड्स इंस्टॉल और प्रबंधित करें
ComfyUI-FLUX	XLabs-AI/x-flux-comfyui	FLUX ControlNet नोड्स
was-node-suite	WASasquatch/was-node-suite-comfyui	100+ उपयोगी नोड्स
ComfyUI-Impact-Pack	ltdrdata/ComfyUI-Impact-Pack	चेहरा पहचान, SAM, ADetailer
ComfyUI-Inspire-Pack	ltdrdata/ComfyUI-Inspire-Pack	उन्नत सैम्पलर, वर्कफ़्लो
ComfyUI-AnimateDiff	Kosinkadink/ComfyUI-AnimateDiff-Evolved	वीडियो / एनीमेशन निर्माण
ComfyUI-VideoHelperSuite	Kosinkadink/ComfyUI-VideoHelperSuite	वीडियो I/O हैंडलिंग
ComfyUI-GGUF	city96/ComfyUI-GGUF	क्वांटाइज़्ड GGUF मॉडल चलाएँ
ComfyUI-KJNodes	kijai/ComfyUI-KJNodes	यूटिलिटी और मास्क नोड्स
rgthree-comfy	rgthree/rgthree-comfy	वर्कफ़्लो सहायक, बेहतर UI

ComfyUI-FLUX (XLabs-AI)

ComfyUI के अंदर FLUX के लिए ControlNet सपोर्ट जोड़ता है:

cd ComfyUI/custom_nodes
git clone https://github.com/XLabs-AI/x-flux-comfyui
cd x-flux-comfyui
pip install -r requirements.txt

नोड्स जोड़ता है: ControlNet लागू करें (FLUX), ControlNet मॉडल लोड करें (FLUX), XFlux सैम्पलर

was-node-suite

उन्नत वर्कफ़्लो के लिए 100 से अधिक यूटिलिटी नोड्स:

cd ComfyUI/custom_nodes
git clone https://github.com/WASasquatch/was-node-suite-comfyui
cd was-node-suite-comfyui
pip install -r requirements.txt

मुख्य नोड्स: Image Batch, Text Operations, Image Analyze, Cache Node, Bus Node, Upscale, Mask operations

मैनेजर के माध्यम से इंस्टॉल करें

1. क्लिक करें Manager बटन

2. Install Custom Nodes

3. खोजें और इंस्टॉल करें

4. ComfyUI पुनः आरंभ करें

उन्नत वर्कफ़्लो

ControlNet

# ControlNet मॉडल डाउनलोड करें
cd ComfyUI/models/controlnet

# Canny
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11p_sd15_canny.pth

# Depth
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11f1p_sd15_depth.pth

# OpenPose
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11p_sd15_openpose.pth

वर्कफ़्लो:

1. इमेज लोड करें → Canny Edge Detector

2. ControlNet लागू करें → KSampler

3. पोज़/एज गाइडेंस के साथ जनरेट करें

अपस्केलिंग

# अपस्केलर डाउनलोड करें
cd ComfyUI/models/upscale_models
wget https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth

वर्कफ़्लो:

1. कम रिज़ॉल्यूशन (768x768) पर इमेज जनरेट करें

2. Upscale Image (Model) नोड

3. वैकल्पिक: डिटेल के लिए img2img पास

SDXL + Refiner

1. SDXL बेस के साथ जनरेट करें (स्टेप्स 1-20)

2. लैटेंट को SDXL रिफाइनर को पास करें (स्टेप्स 21-30)

3. अंतिम परिणाम को VAE Decode करें

कीबोर्ड शॉर्टकट

कुंजी	क्रिया
Ctrl+Enter	प्रॉम्प्ट कतार में डालें
Ctrl+Shift+Enter	प्रॉम्प्ट कतार में डालें (आगे)
Ctrl+Z	पूर्ववत करें
Ctrl+Y	फिर से करें
Ctrl+S	वर्कफ़्लो सहेजें
Ctrl+O	वर्कफ़्लो लोड करें
सभी चुनें	Delete
चयनित हटाएँ	Ctrl+M
नोड म्यूट करें	Ctrl+B
नोड बायपास करें	प्रॉम्प्ट कतार में डालें

API उपयोग

# बाहरी पहुँच के लिए, अपना http_pub URL उपयोग करें:

import json
import urllib.request

SERVER = "your-http-pub.clorecloud.net"
# या SSH के माध्यम से: SERVER = "localhost:8188"
def queue_prompt(prompt, server=SERVER):

data = json.dumps({"prompt": prompt}).encode('utf-8')
    req = urllib.request.Request(f"https://{server}/prompt", data=data)
    urllib.request.urlopen(req)
    # वर्कफ़्लो JSON लोड करें और कतार में डालें

with open("workflow.json") as f:
workflow = json.load(f)
    queue_prompt(workflow)
प्रगति के लिए WebSocket

import websocket

# बाहरी पहुँच के लिए, अपने http_pub URL के साथ wss:// उपयोग करें
import json

ws = websocket.WebSocket()
ws.connect(f"wss://{SERVER}/ws")
msg = json.loads(ws.recv())

while True:
    if msg['type'] == 'progress':
    print(f"स्टेप {msg['data']['value']}/{msg['data']['max']}")
        elif msg['type'] == 'executed':
    print("पूरा हुआ!")
        print("पूरा हुआ!")
        break

प्रदर्शन सुझाव

1. --lowvram सक्षम करें 8GB से कम VRAM के लिए

2. fp16 का उपयोग करें जहाँ संभव हो मॉडल

3. बैच साइज 1 सीमित VRAM के लिए

4. Tiled VAE उच्च-रिज़ॉल्यूशन छवियों के लिए

5. प्रिव्यू अक्षम करें तेज़ जनरेशन के लिए

GPU आवश्यकताएँ

मॉडल	न्यूनतम VRAM	अनुशंसित VRAM	न्यूनतम RAM
SD 1.5	4GB	8GB	16GB
SDXL	8GB	12GB	16GB
SDXL + ControlNet	10GB	16GB	16GB
FLUX	16GB	24GB	32GB

GPU प्रीसेट्स

RTX 3060 12GB (बजट)

# ऑप्टिमाइज़ेशन के साथ लॉन्च करें
python main.py --lowvram --force-fp16

# अनुशंसित सेटिंग्स:
# - SDXL: 768x768, batch 1
# - SD 1.5: 512x512, batch 4
# - VAE टाइलिंग उपयोग करें
# - 20-30 steps

इसके लिए सर्वोत्तम: SD 1.5, SDXL (सीमाओं के साथ)

RTX 3090 24GB (इष्टतम)

# मानक लॉन्च
python main.py --force-fp16

# अनुशंसित सेटिंग्स:
# - SDXL: 1024x1024, batch 2
# - FLUX schnell: 1024x1024, batch 1-2
# - ControlNet + SDXL अच्छी तरह काम करता है
# - 30-50 steps

इसके लिए सर्वोत्तम: SDXL, ControlNet वर्कफ़्लो, मध्यम FLUX

RTX 4090 24GB (प्रदर्शन)

# पूर्ण गति लॉन्च
python main.py

# अनुशंसित सेटिंग्स:
# - SDXL: 1024x1024, batch 4
# - FLUX dev: 1024x1024, batch 1-2
# - कई ControlNets के साथ जटिल वर्कफ़्लो
# - गुणवत्ता के लिए 50+ steps

इसके लिए सर्वोत्तम: FLUX, जटिल वर्कफ़्लो, बैच जनरेशन

A100 40GB/80GB (उत्पादन)

# अधिकतम प्रदर्शन
python main.py --highvram

# अनुशंसित सेटिंग्स:
# - SDXL: 1024x1024, batch 8+
# - FLUX: 1024x1024, batch 2-4
# - कई मॉडल एक साथ लोड किए गए
# - उच्च-रिज़ॉल्यूशन आउटपुट (2048x2048)

इसके लिए सर्वोत्तम: उत्पादन वर्कलोड, FLUX, उच्च-रिज़ॉल्यूशन जनरेशन

लागत का अनुमान

CLORE.AI मार्केटप्लेस की सामान्य दरें:

GPU	VRAM	मूल्य/दिन	SDXL गति
RTX 3060	12GB	$0.15–0.30	~15 सेकंड/इमेज
RTX 3090	24GB	$0.30–1.00	~8 सेकंड/इमेज
RTX 4090	24GB	$0.50–2.00	~4 सेकंड/इमेज
A100	40GB	$1.50–3.00	~3 सेकंड/इमेज

मूल्य USD/दिन में हैं। दरें प्रदाता के अनुसार बदलती हैं — देखें CLORE.AI मार्केटप्लेस वर्तमान दरों के लिए।

समस्या निवारण

लंबे समय तक HTTP 502

1. RAM जाँचें: सर्वर में 16GB+ RAM होनी चाहिए

2. VRAM जाँचें: SDXL के लिए 8GB+, FLUX के लिए 16GB+

3. निर्भरताएँ डाउनलोड हो रही हैं: पहली बार चलाने में 5-10 मिनट लगते हैं

4. मॉडल डाउनलोड हो रहा है: बड़े मॉडल अधिक समय लेते हैं

मेमोरी समाप्त

# कम VRAM मोड के साथ चलाएँ
python main.py --lowvram

# या fp16 को बाध्य करें
python main.py --force-fp16

काली छवियाँ

• जाँचें कि VAE लोड है

• अलग VAE आज़माएँ

• इमेज का आकार कम करें

धीमी जनरेशन

• CUDA सक्षम करें

• fp16 मॉडल का उपयोग करें

• स्टेप्स कम करें (20-30 अक्सर पर्याप्त होते हैं)

वर्कफ़्लो उदाहरण

ComfyUI में ये JSON वर्कफ़्लो इम्पोर्ट करें:

• बेसिक txt2img

• SDXL + Refiner

• ControlNet Canny

• AnimateDiff वीडियो

अगले चरण

• ControlNet मार्गदर्शिका

• Real-ESRGAN अपस्केलिंग

• Kohya प्रशिक्षण - कस्टम LoRAs प्रशिक्षित करें

• Fooocus - सरल विकल्प