> 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

Clore.ai पर Fooocus के साथ आसान Stable Diffusion इमेज जनरेशन

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)
   * यदि आवश्यक हो तो environment variables जोड़ें
   * स्टार्टअप कमांड दर्ज करें
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.11.0-cuda12.8-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 - स्पष्ट किनारे
* सिनेमैटिक - फ़िल्मी लुक
* ऐनिमे - जापानी एनीमेशन
* फ़ोटोग्राफ़िक - यथार्थवादी फ़ोटो

### गुणवत्ता प्रीसेट

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

## उन्नत सुविधाएँ

### उन्नत मोड सक्षम करें

इन तक पहुँचने के लिए "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. जनरेट करें

### विविधता विकल्प

* **विविधता (सूक्ष्म)** - छोटे बदलाव
* **विविधता (मजबूत)** - बड़े बदलाव

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

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

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
```

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

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

उन्नत मोड में:

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

### प्रॉम्प्ट कतार

विविधताओं के लिए वाइल्डकार्ड का उपयोग करें:

```
सड़क पर एक {लाल|नीली|हरी} कार
```

अलग-अलग रंगों वाली 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={
        "पहाड़ों के ऊपर एक सुंदर सूर्यास्त",
        "negative_prompt": "",
        "style_selections": ["Fooocus Enhance"],
        "performance_selection": "गुणवत्ता",
        "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": "कोई नहीं",
    "default_loras": [
        ["detail_lora.safetensors", 0.5]
    ],
    "default_styles": ["Fooocus Enhance", "सिनेमैटिक"]
}
```

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

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

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

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

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

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

```bash

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

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

# UI में: Model टैब > Refiner > कोई नहीं
```

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

* "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) *वर्तमान दरों के लिए।*

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

* का उपयोग करें **स्पॉट** बाधित किए जा सकने वाले कार्य के लिए मार्केट — लगभग एक-तिहाई सर्वरों की स्पॉट कीमत ऑन-डिमांड से कम होती है (मध्य \~13% छूट), बाकी उससे मेल खाते हैं
* से भुगतान करें **CLORE** टोकन
* विभिन्न प्रदाताओं के बीच कीमतों की तुलना करें

## अगले चरण

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


---

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