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 चाहिए। ControlNet के साथ SDXL के लिए कम से कम 10GB VRAM सुनिश्चित करें।

क्यों ComfyUI?

नोड-आधारित कार्यप्रवाह - छवि जनरेशन के लिए दृश्य प्रोग्रामिंग
अधिकतम नियंत्रण - पाइपलाइन के हर चरण को बारीक रूप से समायोजित करें
कुशल - विकल्पों की तुलना में कम VRAM उपयोग
विस्तार योग्य - कस्टम नोड्स का विशाल इकोसिस्टम
वर्कफ़्लो साझाकरण - JSON के रूप में आयात/निर्यात

CLORE.AI पर त्वरित डिप्लॉय

Docker इमेज:

yanwk/comfyui-boot:cu126-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 मिलता है, तो जाँच करें:

सर्वर के पास 16GB+ RAM है
सर्वर में SDXL के लिए 8GB+ VRAM, FLUX के लिए 16GB+ है
मॉडल डाउनलोड करने के लिए नेटवर्क गति उपयुक्त है

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

जब CLORE.AI पर परिनियोजित हो, तो ComfyUI तक पहुँचें http_pub URL:

वेब 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:cu126-slim

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

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

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

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

# Install requirements
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 चेकपॉइंट्स

cd ComfyUI/models/checkpoints

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

# SDXL रिफाइनर
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

# Realistic Vision (फोटोरियलिस्टिक)
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 फ़ाइलें यहाँ रखें

बुनियादी वर्कफ़्लो

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

नोड जोड़ें:
- चेकपॉइंट लोड करें → मॉडल चुनें
- CLIP टेक्स्ट एन्कोड (x2) → सकारात्मक और नकारात्मक प्रॉम्प्ट
- खाली लैटेंट इमेज → आयाम सेट करें
- KSampler → सभी कनेक्ट करें
- VAE डीकोड → लैटेंट को इमेज में
- इमेज सेव करें → आउटपुट
कनेक्ट करें:

[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]

इमेज से इमेज

बदलेँ खाली लैटेंट इमेज के साथ:

इमेज लोड करें → आपका स्रोत इमेज
VAE एन्कोड → लैटेंट में रूपांतरित करें
समायोजित करें डिनोइज़ KSampler में (0.5-0.8)

ComfyUI मैनेजर

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

इंस्टॉलेशन

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

ComfyUI मैनेजर का उपयोग करना

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

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

फ़ीचर

कैसे पहुँचें

कस्टम नोड्स स्थापित करें

Manager → Install Custom Nodes

सभी नोड्स अपडेट करें

Manager → Update All

नोड्स अक्षम/सक्षम करें

Manager → Custom Nodes Manager

गायब नोड्स इंस्टॉल करें

Manager → Install Missing Custom Nodes

मॉडल जानकारी लाएँ

Manager → Model Manager

स्नैपशॉट पुनर्स्थापित करें

Manager → Snapshot Manager

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

क्लिक करें मैनेजर बटन
चुनें Install Custom Nodes
नाम से खोजें (उदा., "FLUX", "AnimateDiff")
क्लिक करें इंस्टॉल करें मनचाहे पैक पर
क्लिक करें जब कहा जाए तो पुनरारंभ करें
नए नोड्स राइट-क्लिक ऐड मेनू में प्रकट होते हैं

गायब नोड्स ऑटो-इंस्टॉल करें: जब आप ऐसा वर्कफ़्लो 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

# टेक्स्ट एन्कोडर्स
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": ["A stunning photorealistic landscape, golden hour lighting, 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

मॉडल लोडर

चेकपॉइंट लोड करें

UNETLoader

टेक्स्ट एन्कोडर

CLIPTextEncode

DualCLIPLoader + CLIPTextEncode

लैटेंट

खाली लैटेंट इमेज

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

मुख्य नोड्स: इमेज बैच, टेक्स्ट ऑपरेशन्स, इमेज एनालाइज़, कैश नोड, बस नोड, अपस्केल, मास्क ऑपरेशन्स

Manager द्वारा इंस्टॉल करें

क्लिक करें मैनेजर बटन
Install Custom Nodes
खोजें और इंस्टॉल करें
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

वर्कफ़्लो:

इमेज लोड करें → Canny एज डिटेक्टर
ControlNet लागू करें → KSampler
पोज/एज गाइडेंस के साथ जनरेट करें

अपस्केलिंग

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

वर्कफ़्लो:

कम रेस में इमेज जनरेट करें (768x768)
Upscale Image (Model) नोड
वैकल्पिक: विवरण के लिए img2img पास

SDXL + रिफाइनर

SDXL बेस के साथ जनरेट करें (स्टेप्स 1-20)
लैटेंट को SDXL रिफाइनर को पास करें (स्टेप्स 21-30)
अंतिम परिणाम VAE डीकोड करें

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

की

एक्शन

Ctrl+Enter

प्रॉम्प्ट कतार में जोड़ें

Ctrl+Shift+Enter

प्रॉम्प्ट कतार (आगामी) में जोड़ें

Ctrl+Z

पूर्ववत करें

Ctrl+Y

दोहराएँ

Ctrl+S

वर्कफ़्लो सहेजें

Ctrl+O

वर्कफ़्लो लोड करें

Ctrl+A

सभी चुनें

Delete

चयनित हटाएँ

Ctrl+M

नोड म्यूट करें

Ctrl+B

नोड बाईपास करें

API उपयोग

प्रॉम्प्ट कतार

import json
import urllib.request

# बाहरी पहुँच के लिए अपने http_pub URL का उपयोग करें:
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
import json

# बाहरी पहुँच के लिए, अपने http_pub URL के साथ wss:// उपयोग करें
ws = websocket.WebSocket()
ws.connect(f"wss://{SERVER}/ws")

while True:
    msg = json.loads(ws.recv())
    if msg['type'] == 'progress':
        print(f"Step {msg['data']['value']}/{msg['data']['max']}")
    elif msg['type'] == 'executed':
        print("Done!")
        break

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

--lowvram सक्षम करें <8GB VRAM के लिए
जब संभव हो fp16 का उपयोग करें मॉडल्स
सीमित VRAM के लिए बैच साइज 1 के लिए
टाइल्ड VAE उच्च-रेस इमेजेस के लिए
पूर्वावलोकन अक्षम करें तेज़ जनरेशन के लिए

GPU आवश्यकताएँ

मॉडल

न्यूनतम VRAM

अनुशंसित VRAM

न्यूनतम RAM

SD 1.5

4GB

8GB

16GB

SDXL

8GB

12GB

16GB

SDXL + ControlNet

10GB

16GB

FLUX

16GB

24GB

32GB

GPU प्रीसेट्स

RTX 3060 12GB (बजट)

# अनुकूलनों के साथ लॉन्च
python main.py --lowvram --force-fp16

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

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

RTX 3090 24GB (उत्तम)

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

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

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

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

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

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

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

A100 40GB/80GB (प्रोडक्शन)

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

# अनुशंसित सेटिंग्स:
# - SDXL: 1024x1024, बैच 8+
# - FLUX: 1024x1024, बैच 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

RAM जाँच करें: सर्वर में 16GB+ RAM होना चाहिए
VRAM जाँच करें: SDXL के लिए 8GB+, FLUX के लिए 16GB+
निर्भरता डाउनलोड हो रही हैं: पहली बार चलाने पर 5-10 मिनट लगेगा
मॉडल डाउनलोडिंग: बड़े मॉडल में अधिक समय लगता है

आउट ऑफ़ मेमोरी

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

# या fp16 को मजबूर करें
python main.py --force-fp16

काली छवियाँ

जांचें कि VAE लोड हुआ है
विभिन्न VAE आज़माएँ
इमेज साइज घटाएँ

धीमा जनरेशन

CUDA सक्षम करें
fp16 मॉडल का उपयोग करें
चरणों को कम करें (अक्सर 20-30 पर्याप्त होते हैं)

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

इन JSON वर्कफ़्लो को ComfyUI में आयात करें:

अगले कदम

ControlNet गाइड
Real-ESRGAN अपस्केलिंग
Kohya प्रशिक्षण - कस्टम LoRA प्रशिक्षण
Fooocus - सरल विकल्प

PreviousStable Diffusion WebUI NextFooocus

Last updated 1 day ago

Was this helpful?

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

hashtagक्यों ComfyUI?

hashtagCLORE.AI पर त्वरित डिप्लॉय

hashtagजांचें कि यह काम कर रहा है

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

hashtagइंस्टॉलेशन

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

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

hashtagनिर्देशिका संरचना

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

hashtagStable Diffusion चेकपॉइंट्स

hashtagVAE

hashtagLoRAs

hashtagबुनियादी वर्कफ़्लो

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

hashtagइमेज से इमेज

hashtagComfyUI मैनेजर

hashtagइंस्टॉलेशन

hashtagComfyUI मैनेजर का उपयोग करना

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

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

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

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

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

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

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

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

hashtagComfyUI-FLUX (XLabs-AI)

hashtagwas-node-suite

hashtagManager द्वारा इंस्टॉल करें

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

hashtagControlNet

hashtagअपस्केलिंग

hashtagSDXL + रिफाइनर

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

hashtagAPI उपयोग

hashtagप्रॉम्प्ट कतार

hashtagप्रगति के लिए WebSocket

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

hashtagGPU आवश्यकताएँ

hashtagGPU प्रीसेट्स

hashtagRTX 3060 12GB (बजट)

hashtagRTX 3090 24GB (उत्तम)

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

hashtagA100 40GB/80GB (प्रोडक्शन)

hashtagलागत अनुमान

hashtagसमस्याओं का निवारण

hashtagलंबे समय के लिए HTTP 502

hashtagआउट ऑफ़ मेमोरी

hashtagकाली छवियाँ

hashtagधीमा जनरेशन

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

hashtagअगले कदम

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

क्यों ComfyUI?

CLORE.AI पर त्वरित डिप्लॉय

जांचें कि यह काम कर रहा है

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

इंस्टॉलेशन

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

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

निर्देशिका संरचना

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

Stable Diffusion चेकपॉइंट्स

VAE

LoRAs

बुनियादी वर्कफ़्लो

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

इमेज से इमेज

ComfyUI मैनेजर

इंस्टॉलेशन

ComfyUI मैनेजर का उपयोग करना

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

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

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

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

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

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

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

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

ComfyUI-FLUX (XLabs-AI)

was-node-suite

Manager द्वारा इंस्टॉल करें

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

ControlNet

अपस्केलिंग

SDXL + रिफाइनर

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

API उपयोग

प्रॉम्प्ट कतार

प्रगति के लिए WebSocket

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

GPU आवश्यकताएँ

GPU प्रीसेट्स

RTX 3060 12GB (बजट)

RTX 3090 24GB (उत्तम)

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

A100 40GB/80GB (प्रोडक्शन)

लागत अनुमान

समस्याओं का निवारण

लंबे समय के लिए HTTP 502

आउट ऑफ़ मेमोरी

काली छवियाँ

धीमा जनरेशन

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

अगले कदम