# FaceFusion

पेशेवर फेस स्वैपिंग और उन्नयन उपकरण।

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

## FaceFusion क्या है?

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

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

## संसाधन

* **GitHub:** [facefusion/facefusion](https://github.com/facefusion/facefusion)
* **दस्तावेज़ीकरण:** [docs.facefusion.io](https://docs.facefusion.io/)
* **डिस्कॉर्ड:** [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.5.1-cuda12.4-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
```

### Python 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"Processing: {target}")

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

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

## Gradio कस्टम इंटरफ़ेस

```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="Source Face"),
        gr.Image(type="filepath", label="Target Image"),
        gr.Checkbox(label="Enhance Result", value=True)
    ],
    outputs=gr.Image(label="Result"),
    title="FaceFusion - Face Swapping",
    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 execution provider का उपयोग करें
* थ्रेड संख्या बढ़ाएँ
* गति के लिए 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) *वर्तमान दरों के लिए।*

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

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

## अगले कदम

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


---

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