SD WebUI Forge

Clore.ai GPUs पर ऑप्टिमाइज़्ड VRAM मैनेजमेंट और FLUX सपोर्ट के साथ Stable Diffusion WebUI Forge डिप्लॉय करें

SD WebUI Forge, क्लासिक AUTOMATIC1111 Stable Diffusion WebUI का एक अनुकूलित फोर्क है, जिसे lllyasviel टीम ने विकसित किया है। यह VRAM प्रबंधन में काफी बेहतर है (4 GB GPUs पर SDXL सक्षम करता है), मूल FLUX मॉडल समर्थन, तेज़ जनरेशन गति, और सभी A1111 एक्सटेंशनों व मॉडलों के साथ पूर्ण पिछली संगतता प्रदान करता है। CLORE.AI का लचीला GPU मार्केटप्लेस आपको Forge के लिए एकदम सही GPU चुनने देता है — बजट कार्ड्स से लेकर शीर्ष-स्तरीय A100s तक।

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

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

पैरामीटर	न्यूनतम	अनुशंसित
RAM	8 GB	16 GB+
VRAM	4 GB	12 GB+
डिस्क	30 GB	200 GB+
GPU	NVIDIA GTX 1650 4GB+	RTX 3090, RTX 4090

Forge का मुख्य लाभ इसका VRAM ऑप्टिमाइज़र है: यह केवल 4 GB VRAM पर भी SDXL चला सकता है (धीमी गति के साथ)। FLUX मॉडलों के लिए, 12 GB VRAM व्यावहारिक न्यूनतम है, जबकि पूर्ण गुणवत्ता और गति के लिए 24 GB बेहतर है।

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

Docker इमेज: nykk3/stable-diffusion-webui-forge:latest

पोर्ट: 22/tcp, 7860/http

Environment Variables:

वेरिएबल	उदाहरण	विवरण
CLI_ARGS	--xformers --medvram	अतिरिक्त CLI आर्ग्युमेंट्स
COMMANDLINE_ARGS	--api --listen	वैकल्पिक CLI args env

चरण-दर-चरण सेटअप

1. CLORE.AI पर GPU Server किराए पर लें

यहाँ जाएँ CLORE.AI मार्केटप्लेस:

• बजट SD1.5: GTX 1660/2060 (6 GB) — 512/768px के लिए भरपूर

• SDXL सक्षम: RTX 3080/3090 (10–24 GB)

• FLUX सक्षम: RTX 4090/A6000 (24+ GB)

• अधिकतम गुणवत्ता: बैच जनरेशन के लिए A100 80GB

2. अपने Server में SSH करें

ssh -p <PORT> root@<SERVER_IP>

3. स्टोरेज डायरेक्टरी बनाएँ

mkdir -p /root/sd-forge/{models,outputs,extensions,configs}
mkdir -p /root/sd-forge/models/{Stable-diffusion,VAE,Lora,ControlNet,embeddings,ESRGAN}

4. SD WebUI Forge को Pull और Run करें

मानक लॉन्च:

docker run -d \\
  --name sd-forge \
  --gpus all \\
  -p 7860:7860 \
  -v /root/sd-forge/models:/app/stable-diffusion-webui/models \
  -v /root/sd-forge/outputs:/app/stable-diffusion-webui/outputs \
  -v /root/sd-forge/extensions:/app/stable-diffusion-webui/extensions \
  nykk3/stable-diffusion-webui-forge:latest

API सक्षम और अतिरिक्त परफ़ॉर्मेंस फ़्लैग्स के साथ:

docker run -d \\
  --name sd-forge \
  --gpus all \\
  -p 7860:7860 \
  -v /root/sd-forge/models:/app/stable-diffusion-webui/models \
  -v /root/sd-forge/outputs:/app/stable-diffusion-webui/outputs \
  -v /root/sd-forge/extensions:/app/stable-diffusion-webui/extensions \
  -e CLI_ARGS="--api --xformers --enable-insecure-extension-access" \
  nykk3/stable-diffusion-webui-forge:latest

लो VRAM मोड (4-6 GB GPUs):

docker run -d \\
  --name sd-forge \
  --gpus all \\
  -p 7860:7860 \
  -v /root/sd-forge/models:/app/stable-diffusion-webui/models \
  -v /root/sd-forge/outputs:/app/stable-diffusion-webui/outputs \
  -e CLI_ARGS="--api --medvram-sdxl --opt-sdp-attention" \
  nykk3/stable-diffusion-webui-forge:latest

अधिकतम परफ़ॉर्मेंस (24+ GB VRAM):

docker run -d \\
  --name sd-forge \
  --gpus all \\
  -p 7860:7860 \
  -v /root/sd-forge/models:/app/stable-diffusion-webui/models \
  -v /root/sd-forge/outputs:/app/stable-diffusion-webui/outputs \
  -e CLI_ARGS="--api --xformers --no-half-vae" \
  nykk3/stable-diffusion-webui-forge:latest

5. स्टार्टअप मॉनिटर करें

docker logs -f sd-forge

इनकी तलाश करें:

Running on local URL:  http://0.0.0.0:7860

पहली बार चलाने पर स्टार्टअप में आम तौर पर 2–5 मिनट लगते हैं।

6. वेब इंटरफ़ेस तक पहुँचें

पोर्ट 7860 के लिए आपका CLORE.AI http_pub URL:

https://<order-id>-7860.clore.ai/

7. मॉडल जोड़ें

विधि 1: वेब UI में CivitAI के माध्यम से डाउनलोड करें

• पर जाएँ Extensions → Installed → Models (कुछ संस्करणों में)

• या Settings में URL डाउनलोडर का उपयोग करें

विधि 2: सर्वर पर सीधे डाउनलोड करें

# SDXL बेस मॉडल डाउनलोड करें
cd /root/sd-forge/models/Stable-diffusion
wget -O "sd_xl_base_1.0.safetensors" \
  "https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/resolve/main/sd_xl_base_1.0.safetensors"

# FLUX.1-schnell डाउनलोड करें (तेज़ FLUX मॉडल)
wget -O "flux1-schnell.safetensors" \
  "https://huggingface.co/black-forest-labs/FLUX.1-schnell/resolve/main/flux1-schnell.safetensors"

विधि 3: HuggingFace CLI

docker exec -it sd-forge bash -c "
pip install huggingface_hub
huggingface-cli download stabilityai/stable-diffusion-xl-base-1.0 \
  sd_xl_base_1.0.safetensors \
  --local-dir /app/stable-diffusion-webui/models/Stable-diffusion/
"

---

उपयोग के उदाहरण

उदाहरण 1: वेब UI के माध्यम से टेक्स्ट से इमेज

1. अपने CLORE.AI URL पर Forge UI खोलें

2. अपना मॉडल यहाँ से चुनें चेकपॉइंट ड्रॉपडाउन

3. प्रॉम्प्ट दर्ज करें: "एक योद्धा का सिनेमैटिक पोर्ट्रेट, गोल्डन आवर, 8k फोटोग्राफी"

4. नेगेटिव प्रॉम्प्ट सेट करें: "धुंधला, कम रिज़ॉल्यूशन, वॉटरमार्क, बदसूरत"

5. चौड़ाई/ऊँचाई सेट करें: 1024x1024 SDXL के लिए, 512x768 SD1.5 के लिए

6. स्टेप्स सेट करें: 20–30, CFG: 7

7. क्लिक करें जनरेट करें

उदाहरण 2: FLUX जनरेशन

FLUX मॉडल अलग तरह से काम करते हैं — कोई नेगेटिव प्रॉम्प्ट नहीं, उच्च गुणवत्ता:

1. FLUX चेकपॉइंट चुनें (flux1-dev.safetensors)

2. इसके अंतर्गत Forge, उपयुक्त चुनें Unet और VAE यदि अलग फ़ाइलें हों

3. प्रॉम्प्ट दर्ज करें (नेगेटिव प्रॉम्प्ट की आवश्यकता नहीं):

   सूर्यास्त के समय एक मनमोहक परिदृश्य, एक निर्मल झील में प्रतिबिंबित पहाड़,
   फोटोरियलिस्टिक, अति-विस्तृत, पेशेवर फोटोग्राफी

4. स्टेप्स: 20, CFG: 1.0 (FLUX कम CFG का उपयोग करता है)

5. सैम्पलर: Euler या DPM++ 2M

उदाहरण 3: ControlNet-निर्देशित जनरेशन

1. ControlNet एक्सटेंशन इंस्टॉल करें (यदि पहले से इंस्टॉल नहीं है):

   • पर जाएँ Extensions → Available → Load from

   • "ControlNet" खोजें और इंस्टॉल करें

2. ControlNet मॉडल यहाँ डाउनलोड करें /root/sd-forge/models/ControlNet/

3. txt2img में, इसे विस्तृत करें ControlNet अनुभाग

4. संदर्भ छवि अपलोड करें (pose, depth, canny edge)

5. अपने संदर्भ प्रकार से मेल खाने वाला preprocessor और model चुनें

6. Generate — आउटपुट संदर्भ संरचना का पालन करेगा

उदाहरण 4: API उपयोग

के साथ --api फ़्लैग, Forge एक REST API प्रदान करता है:

import requests
import base64
import io
from PIL import Image

BASE_URL = "http://localhost:7860"  # या CLORE.AI http_pub URL

# टेक्स्ट से इमेज
payload = {
    "prompt": "चेरी ब्लॉसम्स वाला एक शांत जापानी उद्यान, वॉटरकलर शैली",
    "negative_prompt": "बदसूरत, धुंधला, कम गुणवत्ता",
    "steps": 25,
    "cfg_scale": 7,
    "width": 1024,
    "height": 1024,
    "sampler_name": "DPM++ 2M",
    "batch_size": 1,
}

response = requests.post(f"{BASE_URL}/sdapi/v1/txt2img", json=payload)
result = response.json()

# इमेज सेव करें
for i, img_b64 in enumerate(result["images"]):
    img_data = base64.b64decode(img_b64)
    img = Image.open(io.BytesIO(img_data))
    img.save(f"output_{i}.png")
    print(f"Saved output_{i}.png")

उदाहरण 5: बैच जनरेशन स्क्रिप्ट

import requests
import base64
import io
from PIL import Image
import os

BASE_URL = "http://localhost:7860"

prompts = [
    ("रात में साइबरपंक शहर, नीयन लाइट्स, बारिश", "cyberpunk"),
    ("प्राचीन जंगल, रहस्यमय कोहरा, फैंटेसी कला", "fantasy"),
    ("मिनिमलिस्ट लोगो डिज़ाइन, ज्यामितीय आकृतियाँ, सफेद पृष्ठभूमि", "logo"),
    ("एक वृद्ध नाविक का पोर्ट्रेट, जर्जर चेहरा, ऑयल पेंटिंग", "portrait"),
]

os.makedirs("batch_output", exist_ok=True)

for prompt_text, filename in prompts:
    print(f"Generating: {filename}...")
    response = requests.post(
        f"{BASE_URL}/sdapi/v1/txt2img",
        json={
            "prompt": prompt_text,
            "negative_prompt": "कम गुणवत्ता, धुंधला, वॉटरमार्क",
            "steps": 25,
            "cfg_scale": 7,
            "width": 1024,
            "height": 1024,
        },
    )
    
    if response.status_code == 200:
        img_b64 = response.json()["images"][0]
        img = Image.open(io.BytesIO(base64.b64decode(img_b64)))
        img.save(f"batch_output/{filename}.png")
        print(f"  Saved batch_output/{filename}.png")
    else:
        print(f"  Error: {response.status_code}")

---

कॉन्फ़िगरेशन

मुख्य CLI आर्ग्युमेंट्स

आर्ग्युमेंट	विवरण
--api	REST API सक्षम करें
--listen	सभी इंटरफ़ेस पर सुनें (CLORE.AI के लिए आवश्यक)
--port 7860	पोर्ट बदलें
--xformers	xFormers attention सक्षम करें (तेज़, कम VRAM)
--medvram	मध्यम VRAM मोड (6GB पर SD1.5)
--medvram-sdxl	SDXL के लिए मध्यम VRAM (8GB पर SDXL)
--lowvram	लो VRAM मोड (बहुत धीमा, कोई भी GPU)
--no-half	float32 का उपयोग करें (अधिक VRAM, अधिक स्थिर)
--no-half-vae	VAE को float32 में रखें (काली इमेज से बचाता है)
--opt-sdp-attention	PyTorch scaled dot product attention
--enable-insecure-extension-access	एक्सटेंशन इंस्टॉलेशन की अनुमति दें
--skip-version-check	Python/torch संस्करण जाँच छोड़ें

Forge-विशिष्ट सेटिंग्स

Forge जोड़ता है एक Forge UI में एक पैनल, जिसमें:

• Forge Unet: ऑप्टिमाइज़ेशन बैकएंड चुनें (default, bnb, आदि)

• Diffusers Torch Compilation: 20-30% तेज़ जनरेशन के लिए सक्षम करें (पहली बार रन compile करता है)

• GPU Weights: GPU बनाम CPU पर कितना रखना है

---

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

1. 20-30% कम VRAM के लिए xFormers का उपयोग करें

--xformers

अधिकांश GPUs पर स्वतः प्रदर्शन सुधारता है।

2. Forge का VRAM ऑप्टिमाइज़र

Forge, A1111 से बेहतर तरीके से VRAM को स्वतः प्रबंधित करता है। बस --medvram-sdxl फ़्लैग का उपयोग SDXL के लिए 8-12 GB GPUs पर करें और बाकी इसे संभालने दें।

3. Torch Compilation सक्षम करें (Ampere+)

UI में Forge टैब में, इसे सक्षम करें Diffusers Torch Compilation. पहली जनरेशन को compile होने में 2-3 मिनट लगते हैं, लेकिन बाद की 20-30% तेज़ होती हैं।

4. इष्टतम Steps/Sampler संयोजन

लक्ष्य	सैंपलर	स्टेप्स	CFG
गति	DPM++ SDE Karras	15-20	7
गुणवत्ता	DPM++ 2M Karras	25-35	7
कलात्मक	Euler a	20-30	5-7
FLUX	Euler	20	1

5. 2K+ रिज़ॉल्यूशन के लिए Tile VAE का उपयोग करें

अत्यधिक उच्च रिज़ॉल्यूशन (2048×2048+) के लिए, इसे सक्षम करें Tiled VAE SD टैब में ताकि VAE OOM त्रुटियों से बचा जा सके।

6. API के साथ लोकली बैच करें

UI में एक-एक करके जनरेट करने के बजाय, API का उपयोग करें batch_size तेज़ throughput के लिए:

payload = {
    "prompt": "...",
    "batch_size": 4,  # एक बार में 4 इमेज जनरेट करें
    "n_iter": 2,      # 2 iterations चलाएँ = कुल 8 इमेज
}

---

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

समस्या: काली या हरी इमेज

VAE precision समस्या। यह फ़्लैग जोड़ें:

--no-half-vae

या इसका उपयोग करें sdxl-vae-fp16-fix.safetensors VAE.

समस्या: "CUDA out of memory"

क्रम से प्रयास करें:

1. --medvram-sdxl (SDXL के लिए)

2. --medvram (SD1.5 के लिए)

3. छवि का रिज़ॉल्यूशन कम करें

4. --lowvram (अंतिम उपाय, बहुत धीमा)

समस्या: एक्सटेंशन लोड नहीं हो रहे

# एक्सटेंशन एक्सेस की अनुमति दें
-e CLI_ARGS="--enable-insecure-extension-access"

फिर UI में Extensions टैब से इंस्टॉल करें।

समस्या: स्टार्टअप में बहुत समय लग रहा है

पहली बार चलाने पर सामान्य — PyTorch और मॉडल hashes निकाले जाते हैं। बाद के स्टार्ट तेज़ होते हैं।

docker logs -f sd-forge  # प्रगति देखें

समस्या: ब्राउज़र से UI तक पहुँच नहीं पा रहे

सुनिश्चित करें कि Forge process यहाँ bind हो 0.0.0.0:

• जोड़ें --listen CLI_ARGS में

• सत्यापित करें कि पोर्ट 7860 आपकी CLORE.AI order port list में है

समस्या: मॉडल ड्रॉपडाउन में नहीं दिख रहा

इसे रखने के बाद .safetensors फ़ाइलें सही फ़ोल्डर में रखने के बाद, क्लिक करें 🔄 रिफ़्रेश Checkpoint dropdown के पास।

---

लिंक्स

• GitHub (Forge)

• GitHub (A1111 base)

• Docker Hub (nykk3)

• CivitAI (मॉडल्स)

• FLUX मॉडल्स

• CLORE.AI मार्केटप्लेस

---

Clore.ai GPU अनुशंसाएँ

उपयोग-प्रकरण	अनुशंसित GPU	Clore.ai पर अनुमानित लागत
विकास/परीक्षण	RTX 3090 (24GB)	$0.07–0.21/gpu/hr
प्रोडक्शन	RTX 4090 (24GB)	$0.14–0.42/gpu/hr
बड़े पैमाने पर	A100 80GB	bare metal

💡 इस गाइड के सभी उदाहरण Clore.ai GPU servers पर तैनात किए जा सकते हैं। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण root access.