> 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/face-and-identity/facefusion.md).

# FaceFusion

Clore.ai GPUs पर प्रोफ़ेशनल फेस स्वैपिंग और एन्हांसमेंट

पेशेवर चेहरे की अदला-बदली और संवर्द्धन उपकरण।

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

## FaceFusion क्या है?

FaceFusion प्रदान करता है:

* उच्च-गुणवत्ता वाली चेहरे की अदला-बदली
* चेहरा संवर्द्धन
* उम्र में बदलाव
* अभिव्यक्ति स्थानांतरण
* वीडियो प्रसंस्करण

## संसाधन

* **GitHub:** [facefusion/facefusion](https://github.com/facefusion/facefusion)
* **दस्तावेज़ीकरण:** [docs.facefusion.io](https://docs.facefusion.io/)
* **Discord:** [FaceFusion समुदाय](https://discord.gg/facefusion)

## अनुशंसित हार्डवेयर

| घटक     | न्यूनतम       | अनुशंसित      | उत्तम         |
| ------- | ------------- | ------------- | ------------- |
| GPU     | RTX 3060 12GB | RTX 4080 16GB | RTX 4090 24GB |
| VRAM    | 8GB           | 16GB          | 24GB          |
| CPU     | 8 कोर         | 16 कोर        | 32 कोर        |
| RAM     | 16GB          | 32GB          | 64GB          |
| स्टोरेज | 50GB SSD      | 100GB NVMe    | 200GB NVMe    |
| इंटरनेट | 100 Mbps      | 500 Mbps      | 1 Gbps        |

## CLORE.AI पर त्वरित परिनियोजन

**Docker इमेज:**

```
pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel
```

**पोर्ट:**

```
22/tcp
7860/http
```

**कमांड:**

```bash
pip install facefusion && \
facefusion run --ui-layouts default
```

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

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

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

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

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

```bash

# FaceFusion इंस्टॉल करें
pip install facefusion

# या स्रोत से
git clone https://github.com/facefusion/facefusion.git
cd facefusion
pip install -r requirements.txt
```

## आप क्या बना सकते हैं

### मनोरंजन

* फिल्म डबिंग की तैयारी
* फैन-निर्मित सामग्री
* मीम निर्माण

### पेशेवर

* फैशन के लिए वर्चुअल ट्राई-ऑन
* व्यक्तिगत विपणन
* वीडियो में गोपनीयता सुरक्षा

### रचनात्मक परियोजनाएँ

* कला प्रतिष्ठान
* संगीत वीडियो प्रभाव
* लघु फिल्म निर्माण

**महत्वपूर्ण:** हमेशा ज़िम्मेदारी से और सहमति के साथ उपयोग करें।

## मूल उपयोग

### वेब इंटरफ़ेस

```bash

# वेब UI शुरू करें
facefusion run --ui-layouts default

# http://localhost:7860 पर पहुँचें
```

### कमांड लाइन

```bash

# एकल छवि चेहरा अदला-बदली
facefusion headless-run \
    --source-paths source_face.jpg \
    --target-path target_image.jpg \
    --output-path result.jpg \
    --face-swapper-model inswapper_128

# वीडियो चेहरा अदला-बदली
facefusion headless-run \
    --source-paths source_face.jpg \
    --target-path input_video.mp4 \
    --output-path output_video.mp4 \
    --face-swapper-model inswapper_128 \
    --execution-providers cuda
```

### पायथन API

```python
from facefusion import core
from facefusion.processors.frame.face_swapper import FaceSwapper

# आरंभ करें
swapper = FaceSwapper(
    model="inswapper_128",
    device="cuda"
)

# छवि संसाधित करें
result = swapper.process(
    source_image="source_face.jpg",
    target_image="target.jpg"
)

result.save("swapped.jpg")
```

## चेहरा संवर्द्धन

```bash

# चेहरे की गुणवत्ता बढ़ाएँ
facefusion headless-run \
    --target-path input.jpg \
    --output-path enhanced.jpg \
    --face-enhancer-model gfpgan_1.4 \
    --face-enhancer-blend 80
```

## एकाधिक चेहरे

```bash

# विशिष्ट चेहरों की अदला-बदली
facefusion headless-run \
    --source-paths face1.jpg face2.jpg \
    --target-path group_photo.jpg \
    --output-path result.jpg \
    --face-selector-mode reference \
    --reference-face-position 0 1
```

## वीडियो प्रोसेसिंग

```bash

# संवर्द्धन के साथ पूर्ण वीडियो चेहरा अदला-बदली
facefusion headless-run \
    --source-paths source_face.jpg \
    --target-path input_video.mp4 \
    --output-path output_video.mp4 \
    --face-swapper-model inswapper_128 \
    --face-enhancer-model gfpgan_1.4 \
    --execution-providers cuda \
    --execution-thread-count 4 \
    --video-encoder libx264 \
    --video-quality 18
```

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

```python
import os
from facefusion import core
from facefusion.processors.frame.face_swapper import FaceSwapper

swapper = FaceSwapper(model="inswapper_128", device="cuda")

# स्रोत चेहरा
source = "my_face.jpg"

# लक्ष्य छवियाँ
targets = [f for f in os.listdir("./targets") if f.endswith(('.jpg', '.png'))]

os.makedirs("./results", exist_ok=True)

for target in targets:
    print(f"प्रसंस्करण: {target}")

    result = swapper.process(
        source_image=source,
        target_image=f"./targets/{target}"
    )

    result.save(f"./results/swapped_{target}")
```

## ग्रैडियो कस्टम इंटरफ़ेस

```python
import gradio as gr
from facefusion.processors.frame.face_swapper import FaceSwapper

swapper = FaceSwapper(model="inswapper_128", device="cuda")

def swap_faces(source_image, target_image, enhance):
    result = swapper.process(
        source_image=source_image,
        target_image=target_image,
        enhance=enhance
    )
    return result

demo = gr.Interface(
    fn=swap_faces,
    inputs=[
        gr.Image(type="filepath", label="स्रोत चेहरा"),
        gr.Image(type="filepath", label="लक्ष्य छवि"),
        gr.Checkbox(label="परिणाम संवर्द्धित करें", value=True)
    ],
    outputs=gr.Image(label="परिणाम"),
    title="FaceFusion - चेहरे की अदला-बदली",
    description="CLORE.AI सर्वरों पर पेशेवर चेहरे की अदला-बदली"
)

demo.launch(server_name="0.0.0.0", server_port=7860)
```

## गुणवत्ता सेटिंग्स

### स्वैप मॉडल

| मॉडल                 | गुणवत्ता  | गति   | VRAM |
| -------------------- | --------- | ----- | ---- |
| inswapper\_128       | अच्छा     | तेज़  | 4GB  |
| inswapper\_128\_fp16 | अच्छा     | तेज़  | 2GB  |
| simswap\_256         | बेहतर     | मध्यम | 6GB  |
| simswap\_512         | सर्वोत्तम | धीमा  | 10GB |

### संवर्द्धन मॉडल

| मॉडल           | गुणवत्ता  | गति   |
| -------------- | --------- | ----- |
| gfpgan\_1.4    | उत्कृष्ट  | मध्यम |
| codeformer     | सर्वोत्तम | धीमा  |
| gpen\_bfr\_512 | अच्छा     | तेज़  |

## प्रदर्शन

| कार्य           | रिज़ॉल्यूशन | GPU      | समय    |
| --------------- | ----------- | -------- | ------ |
| एकल छवि         | 1024x1024   | RTX 3090 | 0.5s   |
| एकल छवि         | 1024x1024   | RTX 4090 | 0.3s   |
| वीडियो (1 मिनट) | 1080p       | RTX 4090 | 5 मिनट |
| वीडियो (1 मिनट) | 1080p       | A100     | 3 मिनट |

## सामान्य समस्याएँ और समाधान

### चेहरा नहीं मिला

**समस्या:** "स्रोत/लक्ष्य में कोई चेहरा नहीं मिला"

**समाधान:**

* सुनिश्चित करें कि चेहरा स्पष्ट रूप से दिखाई दे
* चेहरा कम से कम 64x64 पिक्सेल का होना चाहिए
* सामने से या हल्के कोण की तस्वीरें उपयोग करें
* अच्छी रोशनी आवश्यक है

### खराब गुणवत्ता वाली अदला-बदली

**समस्या:** परिणाम अप्राकृतिक लगता है

**समाधान:**

```bash

# बेहतर मॉडल और संवर्द्धन का उपयोग करें
facefusion headless-run \
    --source-paths source.jpg \
    --target-path target.jpg \
    --output-path result.jpg \
    --face-swapper-model simswap_256 \
    --face-enhancer-model gfpgan_1.4 \
    --face-enhancer-blend 80
```

### वीडियो प्रसंस्करण धीमा

**समस्या:** वीडियो के लिए बहुत समय लगता है

**समाधान:**

* CUDA निष्पादन प्रदाता का उपयोग करें
* थ्रेड संख्या बढ़ाएँ
* गति के लिए fp16 मॉडल उपयोग करें
* सर्वोत्तम प्रदर्शन के लिए A100 पर संसाधित करें

```bash
facefusion headless-run \
    --execution-providers cuda \
    --execution-thread-count 8 \
    --face-swapper-model inswapper_128_fp16
```

### रंग में असंगति

**समस्या:** अदला-बदली किए गए चेहरे का रंग अलग है

**समाधान:**

* चेहरे के रंग सुधार को सक्षम करें
* स्रोत और लक्ष्य की रोशनी मिलाएँ
* रंग ग्रेडिंग के साथ पश्च-प्रसंस्करण करें

### मेमोरी संबंधी समस्याएँ

**समस्या:** वीडियो पर मेमोरी समाप्त

**समाधान:**

```bash

# मेमोरी उपयोग कम करें
facefusion headless-run \
    --video-memory-strategy tolerant \
    --execution-thread-count 2
```

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

### चेहरे की अदला-बदली की गुणवत्ता खराब है

* उच्च-रिज़ॉल्यूशन स्रोत छवियाँ उपयोग करें
* दोनों छवियों में अच्छी रोशनी सुनिश्चित करें
* विभिन्न चेहरे संवर्द्धक मॉडल आज़माएँ

### "कोई चेहरा नहीं मिला"

* चेहरा स्पष्ट रूप से दिखाई देना चाहिए
* साइड प्रोफ़ाइल से बचें
* जाँचें कि छवि बहुत छोटी न हो

### वीडियो प्रसंस्करण अटक गया है

* बड़े वीडियो को अधिक RAM चाहिए
* छोटे खंडों में संसाधित करें
* अस्थायी फ़ाइलों के लिए SSD स्टोरेज उपयोग करें

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

* इंटरनेट कनेक्शन जाँचें
* इसके साथ चलाएँ `--download-models` फ़्लैग
* HuggingFace से मैन्युअल रूप से डाउनलोड करें

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

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** टोकन
* विभिन्न प्रदाताओं के बीच कीमतों की तुलना करें

## अगले चरण

* [InstantID](/guides/guides_v2-hi/face-and-identity/instantid.md) - पहचान संरक्षण
* [LivePortrait](/guides/guides_v2-hi/talking-heads/liveportrait.md) - पोर्ट्रेट एनीमेशन
* [GFPGAN](/guides/guides_v2-hi/image-processing/gfpgan-face-restore.md) - चेहरा पुनर्स्थापन


---

# 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/face-and-identity/facefusion.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.