> 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/fooocus-simple-sd.md).

# Fooocus

Fooocus के साथ छवियाँ बनाएं - Stable Diffusion का उपयोग करने का सबसे आसान तरीका।

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

## CLORE.AI पर किराये पर लेना

1. पर जाएँ [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace)
2. GPU प्रकार, VRAM, और मूल्य के अनुसार फ़िल्टर करें
3. चुनें **ऑन-डिमांड** (निश्चित दर) या **स्पॉट** (बिड प्राइस)
4. अपना ऑर्डर कॉन्फ़िगर करें:
   * Docker इमेज चुनें
   * पोर्ट सेट करें (SSH के लिए TCP, वेब UI के लिए HTTP)
   * यदि आवश्यक हो तो एनवायरनमेंट वेरिएबल जोड़ें
   * स्टार्टअप कमांड दर्ज करें
5. भुगतान चुनें: **CLORE**, **BTC**, या **USDT/USDC**
6. ऑर्डर बनाएं और डिप्लॉयमेंट का इंतज़ार करें

### अपने सर्वर तक पहुँचें

* कनेक्शन विवरण में खोजें **मेरे ऑर्डर**
* वेब इंटरफेस: HTTP पोर्ट URL का उपयोग करें
* SSH: `ssh -p <port> root@<proxy-address>`

## Fooocus क्या है?

Fooocus एक सरलीकृत Stable Diffusion इंटरफ़ेस है जो कि:

* शून्य कॉन्फ़िगरेशन की आवश्यकता
* डिफ़ॉल्ट रूप से SDXL का उपयोग करता है
* बिल्ट-इन स्टाइल और प्रीसेट शामिल हैं
* सभी अनुकूलन स्वतः संभालता है

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

| गुणवत्ता      | न्यूनतम VRAM | अनुशंसित      |
| ------------- | ------------ | ------------- |
| बेसिक         | 4GB          | RTX 3060      |
| मानक          | 8GB          | RTX 3070      |
| उच्च गुणवत्ता | 12GB+        | RTX 3090/4090 |

## त्वरित तैनाती

**Docker इमेज:**

```
pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel
```

**पोर्ट:**

```
22/tcp
7865/http
```

**कमांड:**

```bash
apt-get update && apt-get install -y git libgl1 libglib2.0-0 && \
cd /workspace && \
git clone https://github.com/lllyasviel/Fooocus.git && \
cd Fooocus && \
pip install -r requirements_versions.txt && \
python launch.py --listen 0.0.0.0 --port 7865
```

## अपनी सेवा तक पहुँचना

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

1. जाएँ **मेरे ऑर्डर** पृष्ठ
2. अपने ऑर्डर पर क्लिक करें
3. खोजें `http_pub` URL (उदा., `abc123.clorecloud.net`)

उपयोग करें `https://YOUR_HTTP_PUB_URL` की बजाय `localhost` नीचे दिए उदाहरणों में।

## पहला लॉन्च

पहली बार चलाने पर, Fooocus स्वचालित रूप से डाउनलोड करता है:

* SDXL बेस मॉडल (\~6.5GB)
* SDXL रिफाइनर (\~6GB)
* आवश्यक एम्बेडिंग्स

पहले लॉन्च पर इसमें 10-15 मिनट लगते हैं।

## Fooocus का उपयोग करना

### मूल जनरेशन

1. खोलें `http://<proxy>:<port>`
2. अपना प्रॉम्प्ट दर्ज करें
3. "Generate" पर क्लिक करें

बस इतना ही! किसी सेटिंग की आवश्यकता नहीं।

### शैलियाँ

Fooocus में 200+ बिल्ट-इन शैलियाँ शामिल हैं:

**लोकप्रिय शैलियाँ:**

* Fooocus Enhance - बेहतर विवरण
* Fooocus Sharp - तीखे किनारे
* Cinematic - फिल्म जैसी रंगत
* Anime - जापानी एनिमेशन
* Photographic - वास्तविक फ़ोटोज़ जैसा

### क्वालिटी प्रीसेट्स

| प्रीसेट     | स्पीड    | गुणवत्ता   |
| ----------- | -------- | ---------- |
| स्पीड       | तेज़     | अच्छा      |
| गुणवत्ता    | मध्यम    | बहुत अच्छा |
| अत्यधिक गति | सबसे तेज | बेसिक      |

## उन्नत फ़ीचर

### अڈवांस्ड मोड सक्षम करें

पहुँचने के लिए "Advanced" चेकबॉक्स पर क्लिक करें:

* नेगेटिव प्रॉम्प्ट्स
* आस्पेक्ट रेशियो
* इमेज की संख्या
* रैंडम सीड नियंत्रण

### इमेज-टू-इमेज

1. "Input Image" टैब सक्षम करें
2. स्रोत छवि अपलोड करें
3. मोड चुनें:
   * **अपस्केल** - रिज़ॉल्यूशन बढ़ाएँ
   * **वैराय** - वेरिएशन्स बनाएँ
   * **इनपेंट** - हिस्सों को संपादित करें

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

```
1. छवि अपलोड करें
2. "Inpaint or Outpaint" पर क्लिक करें
3. बदलने वाले क्षेत्रों पर मास्क बनाएं
4. जो जनरेट करना है उसका वर्णन करें
5. Generate पर क्लिक करें
```

### आउटपेंटिंग

बॉर्डर के बाहर छवियों का विस्तार करें:

1. छवि अपलोड करें
2. "Inpaint or Outpaint" चुनें
3. दिशा बॉक्स चेक करें (Left, Right, Top, Bottom)
4. कैनवास बढ़ाने के लिए जनरेट करें

## LoRA का उपयोग करना

### LoRA डाउनलोड करें

```bash
cd /workspace/Fooocus/models/loras
wget https://civitai.com/api/download/models/<model_id> -O my_lora.safetensors
```

### LoRA लागू करें

1. "Model" टैब पर जाएँ
2. ड्रॉपडाउन में LoRA चुनें
3. वज़न समायोजित करें (0.5-1.0)

## कस्टम मॉडल

### कस्टम चेकपॉइंट जोड़ें

```bash
cd /workspace/Fooocus/models/checkpoints

# मॉडल डाउनलोड करें
wget https://huggingface.co/model/file.safetensors
```

नए मॉडल देखने के लिए UI रिफ्रेश करें या रिस्टार्ट करें।

### अनुशंसित मॉडल

| मॉडल           | शैली           | आकार  |
| -------------- | -------------- | ----- |
| Juggernaut XL  | फोटोरियलिस्टिक | 6.5GB |
| DreamShaper XL | कलात्मक        | 6.5GB |
| RealVisXL      | वास्तविक       | 6.5GB |
| Animagine XL   | ऐनिमे          | 6.5GB |

## फ़ेस स्वैप

बिल्ट-इन फेस स्वैप फ़ीचर:

1. "Image Prompt" टैब सक्षम करें
2. चेहरे की छवि अपलोड करें
3. टाइप के रूप में "FaceSwap" सेट करें
4. फेस प्रॉम्प्ट के साथ जनरेट करें

## अपस्केलिंग

### बिल्ट-इन अपस्केलर

1. "Upscale or Vary" में छवि अपलोड करें
2. "Upscale (2x)" चुनें
3. Generate

### वैराय विकल्प

* **Vary (Subtle)** - छोटे परिवर्तन
* **Vary (Strong)** - महत्वपूर्ण परिवर्तन

## छवि का वर्णन करें

रिवर्स प्रॉम्प्ट इंजीनियरिंग:

1. "Describe" टैब पर जाएँ
2. छवि अपलोड करें
3. प्रॉम्प्ट सुझाव प्राप्त करें

## प्रदर्शन अनुकूलन

### 8GB VRAM के लिए

```bash
python launch.py --listen 0.0.0.0 --always-offload-from-vram
```

### 6GB VRAM के लिए

```bash
python launch.py --listen 0.0.0.0 --always-low-vram
```

### 4GB VRAM के लिए

```bash
python launch.py --listen 0.0.0.0 --always-cpu
```

## बैच प्रोसेसिंग

### एकाधिक छवियाँ जनरेट करें

Advanced मोड में:

* "Image Number" को इच्छित संख्या पर सेट करें
* सभी छवियाँ अलग-अलग सीड के साथ जनरेट होती हैं

### प्रॉम्प्ट सूची

वेरिएशन्स के लिए वाइल्डकार्ड का उपयोग करें:

```
a {red|blue|green} car on the street
```

विभिन्न रंगों के साथ 3 छवियाँ जनरेट करता है।

## API एक्सेस

### API सक्षम करें

```bash
python launch.py --listen 0.0.0.0 --port 7865
```

### API एंडपॉइंट

```python
import requests

response = requests.post(
    "http://localhost:7865/v1/generation/text-to-image",
    json={
        "prompt": "a beautiful sunset over mountains",
        "negative_prompt": "",
        "style_selections": ["Fooocus Enhance"],
        "performance_selection": "Quality",
        "aspect_ratios_selection": "1024×1024",
        "image_number": 1,
        "image_seed": -1,
    }
)

# इमेज प्राप्त करें
image_data = response.json()
```

## प्रीसेट्स

### कस्टम प्रीसेट बनाएं

संपादित करें `presets/default.json`:

```json
{
    "default_model": "juggernautXL.safetensors",
    "default_refiner": "None",
    "default_loras": [
        ["detail_lora.safetensors", 0.5]
    ],
    "default_styles": ["Fooocus Enhance", "Cinematic"]
}
```

### प्रीसेट के साथ लॉन्च करें

```bash
python launch.py --preset anime
```

## तुलना: Fooocus बनाम अन्य

| फ़ीचर         | Fooocus  | A1111           | ComfyUI   |
| ------------- | -------- | --------------- | --------- |
| सेटअप         | कोई नहीं | मध्यम           | जटिल      |
| सीखने की वक्र | आसान     | मध्यम           | कठिन      |
| लचीलापन       | कम       | ऊँचा            | सबसे ऊँचा |
| उत्तम हेतु    | शुरुआती  | पावर उपयोगकर्ता | डेवलपर्स  |

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

### आउट ऑफ़ मेमोरी

```bash

# लो VRAM मोड का उपयोग करें
python launch.py --always-low-vram

# या रिफाइनर अक्षम करें

# UI में: Model टैब > Refiner > None
```

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

* "Extreme Speed" प्रीसेट सक्षम करें
* रिफाइनर अक्षम करें
* छोटा रिज़ॉल्यूशन उपयोग करें

### मॉडल लोड नहीं हो रहा

```bash

# जांचें कि मॉडल मौजूद है
ls -la /workspace/Fooocus/models/checkpoints/

# फ़ाइल आकार जांचें (SDXL के लिए ~6GB होना चाहिए)
du -h /workspace/Fooocus/models/checkpoints/*.safetensors
```

### काली छवियाँ

* CFG स्केल कम करें
* सीड बदलें
* विभिन्न प्रॉम्प्ट आज़माएँ

## परिणाम डाउनलोड करें

```bash

# छवियाँ outputs फ़ोल्डर में हैं
scp -P <port> -r root@<proxy>:/workspace/Fooocus/outputs/ ./
```

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

सामान्य CLORE.AI मार्केटप्लेस दरें (2024 के अनुसार):

| GPU       | घंटात्मक दर | दैनिक दर | 4-घंटे सत्र |
| --------- | ----------- | -------- | ----------- |
| RTX 3060  | \~$0.03     | \~$0.70  | \~$0.12     |
| RTX 3090  | \~$0.06     | \~$1.50  | \~$0.25     |
| RTX 4090  | \~$0.10     | \~$2.30  | \~$0.40     |
| A100 40GB | \~$0.17     | \~$4.00  | \~$0.70     |
| A100 80GB | \~$0.25     | \~$6.00  | \~$1.00     |

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

**पैसे बचाएँ:**

* उपयोग करें **स्पॉट** लचीले वर्कलोड के लिए मार्केट (अक्सर 30-50% सस्ता)
* भुगतान करें **CLORE** टोकन के साथ
* विभिन्न प्रदाताओं के बीच कीमतों की तुलना करें

## अगले कदम

* Stable Diffusion WebUI - अधिक नियंत्रण
* ComfyUI वर्कफ़्लो - नोड-आधारित
* FLUX Generation - नया मॉडल


---

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

```
GET https://docs.clore.ai/guides/guides_v2-hi/image-generation/fooocus-simple-sd.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.