> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-hi/image-generation/sd-webui-forge.md).

# 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 तक।

{% hint style="success" %}
सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं, जिन्हें किराए पर लिया गया है [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace).
{% endhint %}

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

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

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

## 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 मार्केटप्लेस](https://clore.ai/marketplace):

* **बजट 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 करें

```bash
ssh -p <PORT> root@<SERVER_IP>
```

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

```bash
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 करें

**मानक लॉन्च:**

```bash
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 सक्षम और अतिरिक्त परफ़ॉर्मेंस फ़्लैग्स के साथ:**

```bash
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):**

```bash
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):**

```bash
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. स्टार्टअप मॉनिटर करें

```bash
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: सर्वर पर सीधे डाउनलोड करें**

```bash
# 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**

```bash
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 प्रदान करता है:

```python
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: बैच जनरेशन स्क्रिप्ट

```python
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 का उपयोग करें

```bash
--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 के लिए:

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

***

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

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

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

```bash
--no-half-vae
```

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

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

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

1. `--medvram-sdxl` (SDXL के लिए)
2. `--medvram` (SD1.5 के लिए)
3. छवि का रिज़ॉल्यूशन कम करें
4. `--lowvram` (अंतिम उपाय, बहुत धीमा)

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

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

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

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

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

```bash
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)](https://github.com/lllyasviel/stable-diffusion-webui-forge)
* [GitHub (A1111 base)](https://github.com/AUTOMATIC1111/stable-diffusion-webui)
* [Docker Hub (nykk3)](https://hub.docker.com/r/nykk3/stable-diffusion-webui-forge)
* [CivitAI (मॉडल्स)](https://civitai.com)
* [FLUX मॉडल्स](https://huggingface.co/black-forest-labs)
* [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace)

***

## 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](https://clore.ai/bare-metal) |

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


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-hi/image-generation/sd-webui-forge.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.