> 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/stable-diffusion-3-5.md).

# Stable Diffusion 3.5

Clore.ai GPUs पर Stable Diffusion 3.5 का उपयोग करके सटीक टेक्स्ट रेंडरिंग के साथ उच्च-निष्ठा छवियाँ जनरेट करें।

Stability AI का Stable Diffusion 3.5 एक मल्टीमॉडल डिफ्यूज़न ट्रांसफ़ॉर्मर (MMDiT) है, जो ओपन-वेट इमेज जेनरेशन के लिए एक नया मानक स्थापित करता है। यह तीन वेरिएंट्स में आता है: **लार्ज** (8B पैरामीटर), **मध्यम** (2.5B पैरामीटर), और **लार्ज टर्बो** (8B, 4-स्टेप इनफ़ेरेंस के लिए डिस्टिल्ड)। इसकी सबसे खास विशेषता है इसका सटीक टेक्स्ट रेंडरिंग — SD 3.5 जनरेट की गई छवियों के भीतर पढ़ने योग्य टेक्स्ट को भरोसेमंद ढंग से रख सकता है, ऐसी क्षमता जिसमें अधिकांश पुराने मॉडल संघर्ष करते हैं।

पर [Clore.ai](https://clore.ai/) आप SD 3.5 को जितनी कम $0.05/घंटा लागत में आवश्यक GPU पावर किराए पर लेकर प्रति घंटे सैकड़ों छवियाँ जनरेट कर सकते हैं।

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

* **तीन वेरिएंट्स** — लार्ज (8B, सर्वोच्च गुणवत्ता), मीडियम (2.5B, तेज़ और हल्का), लार्ज टर्बो (8B, 4-स्टेप डिस्टिल्ड)।
* **सटीक टेक्स्ट रेंडरिंग** — छवियों के भीतर पढ़ने योग्य टेक्स्ट, साइन, लेबल और टाइपोग्राफी जनरेट करता है।
* **MMDiT आर्किटेक्चर** — उत्कृष्ट प्रॉम्प्ट पालन के लिए संयुक्त इमेज-टेक्स्ट अटेंशन।
* **1024×1024 मूल रेज़ोल्यूशन** — अपस्केलिंग हैक्स के बिना साफ़ आउटपुट।
* **लचीले आस्पेक्ट रेशियो** — गुणवत्ता खोए बिना गैर-वर्गाकार आउटपुट (768×1344, 1344×768, आदि) को संभालता है।
* **नेटिव diffusers सपोर्ट** — `StableDiffusion3Pipeline` में `diffusers >= 0.30`.
* **ओपन वेट्स** — Stability AI कम्युनिटी लाइसेंस; अधिकांश व्यावसायिक उपयोग के लिए मुफ़्त।

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

| घटक        | न्यूनतम        | अनुशंसित              |
| ---------- | -------------- | --------------------- |
| GPU VRAM   | 12 GB (मीडियम) | 24 GB (लार्ज / टर्बो) |
| System RAM | 16 GB          | 32 GB                 |
| डिस्क      | 20 GB          | 40 GB                 |
| Python     | 3.10+          | 3.11                  |
| CUDA       | 12.8+          | 12.8+                 |
| diffusers  | 0.30+          | नवीनतम                |

**Clore.ai GPU अनुशंसा:** एक **RTX 4090** (24 GB, $0.14–0.42/घंटा) तीनों वेरिएंट्स को पूरी गति से चलाता है। मीडियम मॉडल के लिए, एक **RTX 3090** (24 GB, $0.07–0.21/घंटा) या यहाँ तक कि 16 GB कार्ड भी पर्याप्त और सस्ता है।

## त्वरित शुरुआत

```bash
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu128
pip install diffusers transformers accelerate sentencepiece protobuf

python -c "import torch; print(torch.cuda.get_device_name(0))"
```

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

### SD 3.5 लार्ज — अधिकतम गुणवत्ता

```python
import torch
diffusers से import StableDiffusion3Pipeline करें

pipe = StableDiffusion3Pipeline.from_pretrained(
    "stabilityai/stable-diffusion-3.5-large",
    torch_dtype=torch.bfloat16,
)
pipe.to("cuda")

image = pipe(
    prompt=(
        "एक घिसा-पिटा लकड़ी का साइन जिस पर '24 घंटे खुला' लिखा है, जो लटक रहा है "
        "एक जंग लगी चेन से, एक नीयन-लाइट डाइनर के बाहर, बारिश की रात, प्रतिबिंब "
        "गीली डामर पर, सिनेमैटिक फ़ोटोग्राफ़ी"
    ),
    negative_prompt="धुंधला, विकृत टेक्स्ट, कम गुणवत्ता",
    guidance_scale=3.5,
    num_inference_steps=28,
    width=1024,
    height=1024,
    generator=torch.Generator("cuda").manual_seed(42),
).images[0]

image.save("diner_sign.png")
print("diner_sign.png सहेजा गया")
```

### SD 3.5 लार्ज टर्बो — 4-स्टेप तेज़ जनरेशन

```python
import torch
diffusers से import StableDiffusion3Pipeline करें

pipe = StableDiffusion3Pipeline.from_pretrained(
    "stabilityai/stable-diffusion-3.5-large-turbo",
    torch_dtype=torch.bfloat16,
).to("cuda")

# टर्बो वेरिएंट: केवल 4 स्टेप्स की ज़रूरत होती है, guidance_scale=0 (डिस्टिल्ड)
image = pipe(
    prompt="एक यांत्रिक घड़ी के मूवमेंट का मैक्रो फ़ोटो, जटिल गियर, सुनहरी रोशनी",
    guidance_scale=0.0,
    num_inference_steps=4,
    width=1024,
    height=1024,
).images[0]

image.save("watch_turbo.png")
```

### SD 3.5 मीडियम — हल्का विकल्प

```python
import torch
diffusers से import StableDiffusion3Pipeline करें

pipe = StableDiffusion3Pipeline.from_pretrained(
    "stabilityai/stable-diffusion-3.5-medium",
    torch_dtype=torch.float16,
).to("cuda")

image = pipe(
    prompt="एक आरामदायक कॉफ़ी शॉप के इंटीरियर का आइसोमेट्रिक दृश्य, पिक्सेल आर्ट शैली, गर्म रोशनी",
    guidance_scale=4.0,
    num_inference_steps=28,
    width=1024,
    height=1024,
).images[0]

image.save("coffee_shop_medium.png")
```

### अलग-अलग आस्पेक्ट रेशियो के साथ बैच जनरेशन

```python
import torch
diffusers से import StableDiffusion3Pipeline करें

pipe = StableDiffusion3Pipeline.from_pretrained(
    "stabilityai/stable-diffusion-3.5-large",
    torch_dtype=torch.bfloat16,
).to("cuda")

jobs = [
    {"prompt": "सूरजमुखी के खेत में एक अंतरिक्ष यात्री का पोर्ट्रेट", "w": 768, "h": 1344},
    {"prompt": "आइसलैंडिक हाइलैंड्स का पैनोरमिक दृश्य, उदास आसमान", "w": 1344, "h": 768},
    {"prompt": "संगमरमर की सतह पर परफ़्यूम की बोतल का उत्पाद फ़ोटो", "w": 1024, "h": 1024},
]

for i, job in enumerate(jobs):
    img = pipe(
        prompt=job["prompt"],
        guidance_scale=3.5,
        num_inference_steps=28,
        width=job["w"],
        height=job["h"],
    ).images[0]
    img.save(f"batch_{i:03d}.png")
    print(f"[{i+1}/{len(jobs)}] {job['w']}x{job['h']} पूरा हुआ")
```

## Clore.ai उपयोगकर्ताओं के लिए सुझाव

1. **इटरेशन के लिए टर्बो, फाइनल्स के लिए लार्ज** — प्रॉम्प्ट आइडियाज़ को जल्दी से एक्सप्लोर करने के लिए 4-स्टेप टर्बो वेरिएंट का उपयोग करें, फिर अंतिम रेंडर के लिए लार्ज (28 स्टेप्स) पर स्विच करें।
2. **guidance\_scale=3.5** — SD 3.5 लार्ज पुराने Stable Diffusion मॉडलों की तुलना में कम CFG पर सबसे अच्छा काम करता है। 5.0 से ऊपर जाने पर अक्सर अत्यधिक सैचुरेशन होता है।
3. **टर्बो को guidance\_scale=0 चाहिए** — डिस्टिल्ड मॉडल में guidance पहले से ही शामिल होता है; और जोड़ने से आउटपुट खराब होता है।
4. **छवियों में टेक्स्ट** — SD 3.5 का टेक्स्ट रेंडरिंग मज़बूत है, लेकिन परिपूर्ण नहीं। जिस सटीक टेक्स्ट को आप चाहते हैं, उसे कोट्स में रखें: `'24 घंटे खुला'`. इसे छोटा रखें (अधिकतम 3–5 शब्द)।
5. **वज़न कैश करें** — सेट करें `HF_HOME=/workspace/hf_cache` पर्सिस्टेंट स्टोरेज पर। लार्ज डिस्क पर लगभग 16 GB है।
6. **लार्ज के लिए bf16, मीडियम के लिए fp16** — 8B मॉडल bf16 में प्रशिक्षित किए गए थे; 2.5B मीडियम fp16 में ठीक चलता है।
7. **बैच को कुशलता से चलाएँ** — SD 3.5 लार्ज RTX 4090 पर लगभग 3 सेकंड में एक 1024×1024 छवि जनरेट करता है। बड़े पैमाने की जनरेशन के लिए रात भर बैच चलाएँ।
8. **HF लाइसेंस स्वीकार करें** — डाउनलोड करने से पहले आपको HuggingFace मॉडल पेज पर मॉडल लाइसेंस स्वीकार करना होगा। इसके साथ लॉग इन करें `huggingface-cli login`.

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

| समस्या                           | ठीक करें                                                                                                              |
| -------------------------------- | --------------------------------------------------------------------------------------------------------------------- |
| `OutOfMemoryError` लार्ज के साथ  | उपयोग करें `pipe.enable_model_cpu_offload()`; या मीडियम वेरिएंट पर स्विच करें                                         |
| छवि में गड़बड़ टेक्स्ट           | टेक्स्ट छोटा रखें (3–5 शब्द); इसे प्रॉम्प्ट में कोट्स में रखें; बढ़ाएँ `num_inference_steps` को 35                    |
| अत्यधिक सैचुरेटेड रंग            | कम करें `guidance_scale` — लार्ज के लिए 2.5–3.5 आज़माएँ; टर्बो के लिए 0.0 का उपयोग करें                               |
| मॉडल डाउनलोड करते समय 403 त्रुटि | लाइसेंस स्वीकार करें `https://huggingface.co/stabilityai/stable-diffusion-3.5-large` और चलाएँ `huggingface-cli login` |
| धीमी पहली रन                     | प्रारंभिक डाउनलोड लार्ज के लिए लगभग 16 GB है; बाद के रन कैश का उपयोग करते हैं                                         |
| `KeyError: 'text_encoder_3'`     | diffusers अपग्रेड करें: `pip install -U diffusers transformers`                                                       |
| काली छवि आउटपुट                  | सुनिश्चित करें `torch_dtype=torch.bfloat16` लार्ज/टर्बो के लिए; fp32 कुछ कार्ड्स पर चुपचाप विफल हो सकता है            |


---

# 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 by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.clore.ai/guides/guides_v2-hi/image-generation/stable-diffusion-3-5.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.