> 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

SD WebUI Forge क्लासिक AUTOMATIC1111 Stable Diffusion WebUI का एक अनुकूलित फोर्क है, जिसे lllyasviel टीम ने विकसित किया है। यह बहुत बेहतर VRAM प्रबंधन प्रदान करता है (4 GB GPU पर 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`

**पर्यावरण चर:**

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

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

### 1. CLORE.AI पर एक GPU सर्वर किराए पर लें

यहाँ जाएँ [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. अपने सर्वर में 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 को पुल और रन करें

**सामान्य लॉन्च:**

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

```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. अपने मॉडल का चयन करें **Checkpoint** ड्रॉपडाउन
3. प्रॉम्प्ट डालें: `"cinematic portrait of a warrior, golden hour, 8k photography"`
4. नकारात्मक प्रॉम्प्ट सेट करें: `"blurry, low resolution, watermark, ugly"`
5. चौड़ाई/ऊंचाई सेट करें: `1024x1024` SDXL के लिए, `512x768` SD1.5 के लिए
6. Steps सेट करें: 20–30, CFG: 7
7. पर क्लिक करें **Generate**

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

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

1. FLUX चेकपॉइंट चुनें (flux1-dev.safetensors)
2. के अंतर्गत **Forge**, उपयुक्त चुनें **Unet** और **VAE** यदि अलग फाइलें हों
3. प्रॉम्प्ट दर्ज करें (नकारात्मक प्रॉम्प्ट की जरूरत नहीं):

   ```
   सूर्यास्त पर एक मनोरम परिदृश्य, पहाड़ एक शुद्ध झील में परावर्तित,
   फोटोरियलिस्टिक, अल्ट्रा डिटेल्ड, पेशेवर फोटोग्राफी
   ```
4. Steps: 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. संदर्भ इमेज अपलोड करें (पोज़, डीप्थ, canny edge)
5. अपने संदर्भ प्रकार के अनुरूप प्रीप्रोसेसर और मॉडल चुनें
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": "a serene Japanese garden with cherry blossoms, watercolor style",
    "negative_prompt": "ugly, blurry, low quality",
    "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 city at night, neon lights, rain", "cyberpunk"),
    ("ancient forest, mystical fog, fantasy art", "fantasy"),
    ("minimalist logo design, geometric shapes, white background", "logo"),
    ("portrait of an elderly sailor, weathered face, oil painting", "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": "low quality, blurry, watermark",
            "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 मोड (SD1.5 6GB पर)                        |
| `--medvram-sdxl`                     | SDXL के लिए मध्यम VRAM (SDXL 8GB पर)                 |
| `--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 UI में एक जोड़ता है **Forge** पैनल जिसमें:

* **Forge Unet**: अनुकूलन बैकएंड चुनें (डिफ़ॉल्ट, bnb, आदि)
* **Diffusers Torch कंपाइलेशन**: 20-30% तेज़ जनरेशन के लिए सक्षम करें (पहली रन पर कंपाइल होता है)
* **GPU वेट्स**: 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 कंपाइलेशन सक्षम करें (Ampere+)

UI में Forge टैब में, सक्षम करें **Diffusers Torch कंपाइलेशन**. पहली जनरेशन को कंपाइल होने में 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+) के लिए, SD टैब में सक्षम करें **Tiled VAE** ताकि VAE OOM त्रुटियों से बचा जा सके।

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

UI में एक-एक करके जनरेट करने के बजाय, तेज थ्रूपुट के लिए API के साथ उपयोग करें `batch_size` ताकि तेज़ थ्रूपुट:

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

***

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

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

VAE प्रिसिशन समस्या। यह फ्लैग जोड़ें:

```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 और मॉडल हैश गणना की जाती है। बाद की स्टार्ट्स तेज़ होते हैं।

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

### समस्या: ब्राउज़र से UI एक्सेस नहीं कर पा रहे

सुनिश्चित करें कि Forge प्रोसेस बाइंड कर रहा है `0.0.0.0`:

* लॉन्च कमांड में जोड़ें `--listen` to CLI\_ARGS
* पुष्टि करें कि पोर्ट 7860 आपके CLORE.AI आर्डर पोर्ट सूची में है

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

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

***

## लिंक

* [GitHub (Forge)](https://github.com/lllyasviel/stable-diffusion-webui-forge)
* [GitHub (A1111 बेस)](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.12/gpu/hr            |
| प्रोडक्शन          | RTX 4090 (24GB)   | \~$0.70/gpu/hr            |
| बड़े पैमाने पर     | A100 80GB         | \~$1.20/gpu/hr            |

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


---

# 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.