# Stable Diffusion WebUI

CLORE.AI GPU पर Stable Diffusion के लिए सबसे लोकप्रिय वेब इंटरफ़ेस।

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

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

| पैरामीटर      | न्यूनतम    | अनुशंसित |
| ------------- | ---------- | -------- |
| रैम           | 16GB       | 32GB+    |
| वीराम         | 8GB        | 12GB+    |
| नेटवर्क       | 500Mbps    | 1Gbps+   |
| स्टार्टअप समय | 10-20 मिनट | -        |

{% hint style="warning" %}
**स्टार्टअप समय:** पहली बार लॉन्च पर Python निर्भरताओं की स्थापना और बेस मॉडल डाउनलोड होता है (नेटवर्क स्पीड के आधार पर 10-20 मिनट)। इस समय दौरान HTTP 502 सामान्य है।
{% endhint %}

## क्यों SD WebUI?

* **फीचर-समृद्ध** - txt2img, img2img, इनपेंटिंग, आउटपेंटिंग
* **एक्सटेंशन्स** - प्लगइन्स की विशाल पारिस्थितिकी
* **यूज़र-फ्रेंडली** - सहज वेब इंटरफ़ेस
* **अच्छी तरह से डॉक्यूमेंटेड** - बड़ी समुदाय समर्थन

> 📚 देखें भी: [क्लाउड GPU पर Stable Diffusion कैसे चलाएँ](https://blog.clore.ai/how-to-run-stable-diffusion-cloud-gpu/)

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

**Docker इमेज:**

```
universonic/stable-diffusion-webui:latest
```

**पोर्ट्स:**

```
22/tcp
8080/http
```

**कमांड:**

```bash
./webui.sh --listen --xformers
```

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

डिप्लॉयमेंट के बाद, अपना खोजें `http_pub` URL में **मेरे ऑर्डर**:

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

{% hint style="info" %}
यदि आपको 20 मिनट से अधिक समय तक HTTP 502 मिलता है, तो जांचें:

1. सर्वर में 16GB+ RAM हो
2. सर्वर में 8GB+ VRAM हो
3. निर्भरताएँ डाउनलोड करने के लिए नेटवर्क स्पीड पर्याप्त हो
   {% endhint %}

## अपनी सेवा को एक्सेस करना

CLORE.AI पर डिप्लॉय होने पर, SD WebUI को निम्न के माध्यम से एक्सेस करें `http_pub` URL:

* **वेब UI:** `https://your-http-pub.clorecloud.net/`
* **API (यदि सक्षम):** `https://your-http-pub.clorecloud.net/sdapi/v1/`

{% hint style="info" %}
सभी `localhost:7860` नीचे के उदाहरण SSH के माध्यम से कनेक्ट होने पर काम करते हैं। बाहरी एक्सेस के लिए, इसे अपने से बदलें `https://your-http-pub.clorecloud.net/` URL.
{% endhint %}

## इंस्टॉलेशन

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

```bash
docker run -d --gpus all \
    -p 8080:8080 \
    -v sd-webui-data:/app/stable-diffusion-webui \
    universonic/stable-diffusion-webui:latest
```

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

```bash
# निर्भरताएँ इंस्टॉल करें
sudo apt install python3.10 python3.10-venv git wget

# रिपॉज़िटरी क्लोन करें
git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui.git
cd stable-diffusion-webui

# चलाएँ (स्वतः सब कुछ इंस्टॉल करता है)
./webui.sh --listen --xformers
```

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

```
stable-diffusion-webui/
├── models/
│   ├── Stable-diffusion/   # मुख्य मॉडल (.safetensors)
│   ├── Lora/               # LoRA मॉडल
│   ├── VAE/                # VAE मॉडल
│   ├── ControlNet/         # ControlNet मॉडल
│   └── ESRGAN/             # अपस्केलर्स
├── embeddings/             # टेक्स्चुअल इन्वर्शन
├── extensions/             # इंस्टॉल की गई एक्सटेंशन्स
├── outputs/                # जनरेट की गई इमेजेस
└── scripts/                # कस्टम स्क्रिप्ट्स
```

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

### चेकपॉइंट्स

```bash
cd models/Stable-diffusion

# SD 1.5
wget https://huggingface.co/runwayml/stable-diffusion-v1-5/resolve/main/v1-5-pruned.safetensors

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

# Realistic Vision (फोटोरियलिस्टिक)
wget "https://civitai.com/api/download/models/245598" -O realisticVision_v60B1.safetensors

# DreamShaper (कलात्मक)
wget "https://civitai.com/api/download/models/351306" -O dreamshaper_8.safetensors
```

### VAE (बेहतर रंग)

```bash
cd models/VAE

# SD 1.5 VAE
wget https://huggingface.co/stabilityai/sd-vae-ft-mse-original/resolve/main/vae-ft-mse-840000-ema-pruned.safetensors

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

## बेसिक उपयोग

### txt2img (टेक्स्ट से इमेज)

1. ड्रॉपडाउन से मॉडल चुनें
2. पॉज़िटिव प्रॉम्प्ट दर्ज करें: जो आप चाहते हैं
3. नेगेटिव प्रॉम्प्ट दर्ज करें: क्या बचना है
4. आयाम सेट करें (SD1.5 के लिए 512x512, SDXL के लिए 1024x1024)
5. Generate पर क्लिक करें

### img2img (इमेज से इमेज)

1. img2img टैब पर जाएँ
2. सोर्स इमेज अपलोड करें
3. वांछित बदलावों का वर्णन करने वाला प्रॉम्प्ट दर्ज करें
4. समायोजित करें **डिनॉइज़िंग स्ट्रेंथ** (0.3-0.8)
5. जनरेट करें

### इनपेंटिंग

1. img2img → Inpaint पर जाएँ
2. इमेज अपलोड करें
3. जिस क्षेत्र को बदलना है उस पर मास्क ड्रॉ करें
4. मास्क किए गए क्षेत्र के लिए प्रॉम्प्ट दर्ज करें
5. जनरेट करें

## आवश्यक सेटिंग्स

### जनरेशन सेटिंग्स

| सेटिंग    | SD 1.5          | SDXL            |
| --------- | --------------- | --------------- |
| चौड़ाई    | 512             | 1024            |
| ऊंचाई     | 512             | 1024            |
| स्टेप्स   | 20-30           | 20-40           |
| CFG स्केल | 7               | 5-7             |
| सैंपलर    | DPM++ 2M Karras | DPM++ 2M Karras |

### कमांड लाइन आर्गुमेंट्स

```bash
./webui.sh \
    --listen \              # बाहरी एक्सेस की अनुमति दें
    --port 7860 \           # पोर्ट नंबर
    --xformers \            # मेमोरी ऑप्टिमाइज़ेशन
    --enable-insecure-extension-access \  # एक्सटेंशन्स की अनुमति दें
    --api \                 # API सक्षम करें
    --no-half-vae           # काली इमेजेस ठीक करें
```

### कम VRAM के लिए

```bash
./webui.sh \
    --listen \
    --medvram \           # 6-8GB VRAM
    # या
    --lowvram \           # 4GB VRAM
    --xformers
```

## लोकप्रिय एक्सटेंशन्स

### जरूरी

| एक्सटेंशन                 | उद्देश्य                 |
| ------------------------- | ------------------------ |
| ControlNet                | मार्गदर्शित जनरेशन       |
| ADetailer                 | स्वचालित फेस/हैंड फ़िक्स |
| Ultimate SD Upscale       | बेहतर अपस्केलिंग         |
| sd-webui-segment-anything | सेगमेंटेशन               |
| Regional Prompter         | मल्टी-रीजन प्रॉम्प्ट्स   |

### एक्सटेंशन्स इंस्टॉल करें

1. जाएँ **एक्सटेंशन्स** टैब
2. क्लिक करें **उपलब्ध**
3. क्लिक करें **लोड करें से**
4. खोजें और इंस्टॉल करें
5. लागू करें और UI रीस्टार्ट करें

या मैन्युअल रूप से:

```bash
cd extensions
git clone https://github.com/Mikubill/sd-webui-controlnet.git
```

## ControlNet

### इंस्टॉलेशन

```bash
# एक्सटेंशन इंस्टॉल करें
cd extensions
git clone https://github.com/Mikubill/sd-webui-controlnet.git

# मॉडल डाउनलोड करें
cd ../models/ControlNet
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11p_sd15_canny.pth
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11p_sd15_openpose.pth
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11f1p_sd15_depth.pth
```

### उपयोग

1. ControlNet सेक्शन एक्सपैंड करें
2. कंट्रोल इमेज अपलोड करें
3. प्रीप्रोसेसर चुनें (Canny, OpenPose, आदि)
4. प्रीप्रोसेसर से मेल खाता मॉडल चुनें
5. जनरेट करें

## API उपयोग

इसके साथ सक्षम करें `--api` फ्लैग, फिर:

```python
import requests
import base64

# बाहरी एक्सेस के लिए, अपने http_pub URL का उपयोग करें:
API_URL = "https://your-http-pub.clorecloud.net"
# या SSH के माध्यम से: API_URL = "http://localhost:7860"

def txt2img(prompt, negative="", steps=20, width=512, height=512):
    response = requests.post(
        f"{API_URL}/sdapi/v1/txt2img",
        json={
            "prompt": prompt,
            "negative_prompt": negative,
            "steps": steps,
            "width": width,
            "height": height,
        }
    )
    return base64.b64decode(response.json()["images"][0])

# जनरेट करें और सेव करें
image_data = txt2img("A beautiful sunset over mountains")
with open("output.png", "wb") as f:
    f.write(image_data)
```

### img2img API

```python
import base64

def img2img(prompt, image_path, denoising=0.5):
    with open(image_path, "rb") as f:
        image_b64 = base64.b64encode(f.read()).decode()

    response = requests.post(
        f"{API_URL}/sdapi/v1/img2img",
        json={
            "prompt": prompt,
            "init_images": [image_b64],
            "denoising_strength": denoising,
            "steps": 30,
        }
    )
    return base64.b64decode(response.json()["images"][0])
```

## प्रॉम्प्ट लिखना

### बुनियादी संरचना

```
[विषय], [स्टाइल], [विवरण], [लाइटिंग], [क्वालिटी टैग्स]
```

### उदाहरण प्रॉम्प्ट्स

```
# पोर्ट्रेट
एक युवा महिला का पोर्ट्रेट, प्रोफेशनल फ़ोटोग्राफी,
सॉफ्ट लाइटिंग, शैलो डेप्थ ऑफ फील्ड, 8k uhd,
उच्च रूप से विस्तृत, फोटोरियलिस्टिक

# लैंडस्केप
सूर्यास्त पर भव्य पर्वतीय परिदृश्य, नाटकीय बादल,
गोल्डन आवर लाइटिंग, नेशनल जियोग्राफिक शैली,
8k वॉलपेपर्स, उच्च रूप से विस्तृत

# एनीमे
1girl, चांदी बाल, नीली आँखें, स्कूल यूनिफ़ॉर्म,
चेरी ब्लॉसम्स, वसंत, मास्टरपीस, सर्वश्रेष्ठ गुणवत्ता
```

### नेगेटिव प्रॉम्प्ट्स

```
# सामान्य
लोरेस, खराब एनाटॉमी, खराब हाथ, टेक्स्ट, एरर,
मिसिंग फिंगर्स, क्रॉप्ड, सबसे खराब क्वालिटी, कम गुणवत्ता,
jpeg आर्टिफैक्ट्स, सिग्नेचर, वॉटरमार्क, धुँधला

# फोटोरियलिस्टिक के लिए
कार्टून, एनीमे, इलस्ट्रेशन, पेंटिंग, ड्रॉइंग,
3d रेंडर, cgi
```

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

1. **xFormers सक्षम करें** - उल्लेखनीय गति वृद्धि
2. **VAE का उपयोग करें** - बेहतर रंग
3. **बैच साइज 1** - सीमित VRAM के लिए
4. **Hires Fix** - पहले छोटा जनरेट करें, फिर अपस्केल करें
5. **ADetailer** - ऑटो-फिक्स चेहरे

## GPU आवश्यकताएँ

| मॉडल              | न्यूनतम VRAM | अनुशंसित VRAM | न्यूनतम RAM |
| ----------------- | ------------ | ------------- | ----------- |
| SD 1.5            | 4GB          | 8GB           | 16GB        |
| SD 2.1            | 6GB          | 8GB           | 16GB        |
| SDXL              | 8GB          | 12GB          | 16GB        |
| ControlNet के साथ | +2GB         | +4GB          | 16GB        |

## GPU प्रीसेट्स

### RTX 3060 12GB (बजट)

```bash
# लॉन्च कमांड
./webui.sh --medvram --xformers

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

**सर्वश्रेष्ठ मॉडल:** SD 1.5, DreamShaper, RealisticVision

### RTX 3090 24GB (उत्तम)

```bash
# लॉन्च कमांड
./webui.sh --xformers

# अनुशंसित सेटिंग्स:
# - SD 1.5: 512x512, बैच 8, 30 स्टेप्स
# - SDXL: 1024x1024, बैच 2, 30 स्टेप्स
# - ControlNet + SD 1.5 बेहतरीन काम करते हैं
# - Hires fix को 2x पर काम करता है
```

**सर्वश्रेष्ठ मॉडल:** SDXL, Juggernaut, RealVisXL

### RTX 4090 24GB (परफॉर्मेंस)

```bash
# लॉन्च कमांड
./webui.sh --xformers --opt-sdp-attention

# अनुशंसित सेटिंग्स:
# - SD 1.5: 512x512, बैच 16, 30 स्टेप्स
# - SDXL: 1024x1024, बैच 4, 40 स्टेप्स
# - एक साथ कई ControlNets
# - Hires fix को 4x पर
```

**सर्वश्रेष्ठ मॉडल:** SDXL, Pony Diffusion, कोई भी हाई-रेज़ मॉडल

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

```bash
# लॉन्च कमांड
./webui.sh --opt-sdp-attention --no-half-vae

# अनुशंसित सेटिंग्स:
# - SDXL: 1024x1024, बैच 8+, 50 स्टेप्स
# - एक से अधिक ControlNet + IP-Adapter
# - Hires fix को 4096x4096 तक
# - वीडियो के लिए AnimateDiff
```

**बेहतरीन के लिए:** बैच जनरेशन, जटिल वर्कफ़्लो, वीडियो

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

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

| GPU      | वीराम | मूल्य/दिन  | SD1.5 गति   | SDXL गति   |
| -------- | ----- | ---------- | ----------- | ---------- |
| RTX 3060 | 12GB  | $0.15–0.30 | \~4 सेकंड   | \~12 सेकंड |
| RTX 3090 | 24GB  | $0.30–1.00 | \~2 सेकंड   | \~6 सेकंड  |
| RTX 4090 | 24GB  | $0.50–2.00 | \~1 सेकंड   | \~3 सेकंड  |
| A100     | 40GB  | $1.50–3.00 | \~0.5 सेकंड | \~2 सेकंड  |

*कीमतें USD/दिन में हैं। प्रदाता के अनुसार दरें भिन्न होती हैं — वर्तमान दरों के लिए जाँचें* [*CLORE.AI मार्केटप्लेस*](https://clore.ai/marketplace) *के लिए वर्तमान दरें।*

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

### लंबे समय तक HTTP 502

1. **रैम जाँचें:** सर्वर में 16GB+ RAM होना चाहिए
2. **वीराम जाँचें:** SDXL के लिए 8GB+ होना चाहिए
3. **निर्भरताएँ इंस्टॉल हो रही हैं:** पहला रन 10-20 मिनट लेता है
4. **धीमा नेटवर्क:** कम बैंडविड्थ से स्टार्टअप लंबा होता है

### काली इमेजेस

```bash
# लॉन्च आर्ग्स में जोड़ें
--no-half-vae
```

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

```bash
# ऑप्टिमाइज़ेशन का उपयोग करें
--medvram
--xformers
```

### एक्सटेंशन्स लोड नहीं हो रही हैं

```bash
--enable-insecure-extension-access
```

### धीमा जनरेशन

1. xFormers सक्षम करें
2. इमेज साइज कम करें
3. स्टेप्स घटाएँ (अक्सर 20 पर्याप्त हैं)

## अगले कदम

* [ComfyUI](https://docs.clore.ai/guides/guides_v2-hi/image-generation/comfyui) - अधिक उन्नत वर्कफ़्लो
* [FLUX.1](https://docs.clore.ai/guides/guides_v2-hi/image-generation/flux) - नवीनतम मॉडल
* [ControlNet](https://docs.clore.ai/guides/guides_v2-hi/image-processing/controlnet-advanced) - मार्गदर्शित जनरेशन
* [LoRA प्रशिक्षण](https://docs.clore.ai/guides/guides_v2-hi/training/kohya-training) - कस्टम मॉडल