> 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-de/gesicht-and-identitat/facefusion.md).

# FaceFusion

Professionelles Werkzeug zum Gesichtertausch und zur Verbesserung.

{% hint style="success" %}
Alle Beispiele können auf GPU-Servern ausgeführt werden, die über [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Mieten auf CLORE.AI

1. Besuchen Sie [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Nach GPU-Typ, VRAM und Preis filtern
3. Wählen **On-Demand** (Festpreis) oder **Spot** (Gebotspreis)
4. Konfigurieren Sie Ihre Bestellung:
   * Docker-Image auswählen
   * Ports festlegen (TCP für SSH, HTTP für Web-UIs)
   * Umgebungsvariablen bei Bedarf hinzufügen
   * Startbefehl eingeben
5. Zahlung auswählen: **CLORE**, **BTC**, oder **USDT/USDC**
6. Bestellung erstellen und auf Bereitstellung warten

### Zugriff auf Ihren Server

* Verbindungsdetails finden Sie in **Meine Bestellungen**
* Webschnittstellen: Verwenden Sie die HTTP-Port-URL
* SSH: `ssh -p <port> root@<proxy-address>`

## Was ist FaceFusion?

FaceFusion bietet:

* Hochwertiger Gesichtertausch
* Gesichtsverbesserung
* Altersänderung
* Expressionsübertragung
* Videoverarbeitung

## Ressourcen

* **GitHub:** [facefusion/facefusion](https://github.com/facefusion/facefusion)
* **Dokumentation:** [docs.facefusion.io](https://docs.facefusion.io/)
* **Discord:** [FaceFusion Community](https://discord.gg/facefusion)

## Empfohlene Hardware

| Komponente | Minimum       | Empfohlen     | Optimal       |
| ---------- | ------------- | ------------- | ------------- |
| GPU        | RTX 3060 12GB | RTX 4080 16GB | RTX 4090 24GB |
| VRAM       | 8GB           | 16GB          | 24GB          |
| CPU        | 8 Kerne       | 16 Kerne      | 32 Kerne      |
| RAM        | 16GB          | 32GB          | 64GB          |
| Speicher   | 50GB SSD      | 100GB NVMe    | 200GB NVMe    |
| Internet   | 100 Mbps      | 500 Mbps      | 1 Gbps        |

## Schnelle Bereitstellung auf CLORE.AI

**Docker-Image:**

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

**Ports:**

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

**Befehl:**

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

## Zugriff auf Ihren Dienst

Nach der Bereitstellung finden Sie Ihre `http_pub` URL in **Meine Bestellungen**:

1. Gehen Sie zur **Meine Bestellungen** Seite
2. Klicken Sie auf Ihre Bestellung
3. Finden Sie die `http_pub` URL (z. B., `abc123.clorecloud.net`)

Verwenden Sie `https://IHRE_HTTP_PUB_URL` anstelle von `localhost` in den Beispielen unten.

## Installation

```bash

# FaceFusion installieren
pip install facefusion

# Oder aus dem Quellcode
git clone https://github.com/facefusion/facefusion.git
cd facefusion
pip install -r requirements.txt
```

## Was Sie erstellen können

### Unterhaltung

* Vorbereitung für Filmdub
* Fan-erstellte Inhalte
* Meme-Erstellung

### Professionell

* Virtuelle Anprobe für Mode
* Personalisierte Marketingmaßnahmen
* Datenschutzschutz in Videos

### Kreative Projekte

* Kunstinstallationen
* Musikvideoeffekte
* Kurzfilmproduktion

**Wichtig:** Immer verantwortungsbewusst und mit Einwilligung verwenden.

## Grundlegende Verwendung

### Weboberfläche

```bash

# Web-UI starten
facefusion run --ui-layouts default

# Zugriff unter http://localhost:7860
```

### Kommandozeile

```bash

# Ein Bild Gesichtertausch
facefusion headless-run \
    --source-paths source_face.jpg \
    --target-path target_image.jpg \
    --output-path result.jpg \
    --face-swapper-model inswapper_128

# Video-Gesichtertausch
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

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

# Verarbeite Bild
result = swapper.process(
    source_image="source_face.jpg",
    target_image="target.jpg"
)

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

## Gesichtsverbesserung

```bash

# Gesichtsqualität verbessern
facefusion headless-run \
    --target-path input.jpg \
    --output-path enhanced.jpg \
    --face-enhancer-model gfpgan_1.4 \
    --face-enhancer-blend 80
```

## Mehrere Gesichter

```bash

# Bestimmte Gesichter tauschen
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
```

## Videobearbeitung

```bash

# Voller Video-Gesichtertausch mit Verbesserung
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
```

## Batch-Verarbeitung

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

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

# Quellgesicht
source = "my_face.jpg"

# Zielbilder
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"Verarbeite: {target}")

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

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

## Gradio Benutzerdefinierte Oberfläche

```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="Quelle Gesicht"),
        gr.Image(type="filepath", label="Zielbild"),
        gr.Checkbox(label="Ergebnis verbessern", value=True)
    ],
    outputs=gr.Image(label="Ergebnis"),
    title="FaceFusion - Gesichtertausch",
    description="Professioneller Gesichtertausch auf CLORE.AI-Servern"
)

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

## Qualitätseinstellungen

### Tauschmodelle

| Modell               | Qualität  | Geschwindigkeit | VRAM |
| -------------------- | --------- | --------------- | ---- |
| inswapper\_128       | Gut       | Schnell         | 4GB  |
| inswapper\_128\_fp16 | Gut       | Schneller       | 2GB  |
| simswap\_256         | Besser    | Mittel          | 6GB  |
| simswap\_512         | Am besten | Langsam         | 10GB |

### Verbesserungsmodelle

| Modell         | Qualität  | Geschwindigkeit |
| -------------- | --------- | --------------- |
| gfpgan\_1.4    | Großartig | Mittel          |
| codeformer     | Am besten | Langsam         |
| gpen\_bfr\_512 | Gut       | Schnell         |

## Leistung

| Aufgabe        | Auflösung | GPU      | Zeit   |
| -------------- | --------- | -------- | ------ |
| Einzelnes Bild | 1024x1024 | RTX 3090 | 0.5s   |
| Einzelnes Bild | 1024x1024 | RTX 4090 | 0.3s   |
| Video (1 Min)  | 1080p     | RTX 4090 | 5 Min  |
| Video (1 Min)  | 1080p     | A100     | 3 Min. |

## Häufige Probleme & Lösungen

### Kein Gesicht erkannt

**Problem:** "Kein Gesicht in Quelle/Ziel gefunden"

**Lösungen:**

* Stelle sicher, dass das Gesicht deutlich sichtbar ist
* Das Gesicht sollte mindestens 64x64 Pixel groß sein
* Verwenden Sie Front- oder leicht seitliche Fotos
* Gute Beleuchtung erforderlich

### Schlechter Tausch

**Problem:** Ergebnis wirkt unnatürlich

**Lösungen:**

```bash

# Besseres Modell und Verbesserung verwenden
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
```

### Videoverarbeitung langsam

**Problem:** Dauert zu lange für Videos

**Lösungen:**

* Verwenden Sie den CUDA-Ausführungsanbieter
* Erhöhen Sie die Anzahl der Threads
* Verwenden Sie fp16-Modell für Geschwindigkeit
* Auf A100 für beste Leistung ausführen

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

### Farbabweichung

**Problem:** Das getauschte Gesicht hat eine andere Farbe

**Lösungen:**

* Gesicht-Farbkorrektur aktivieren
* Beleuchtung zwischen Quelle und Ziel anpassen
* Nachbearbeitung mit Farbkorrektur

### Speicherprobleme

**Problem:** Speicherüberschreitung bei Video

**Lösungen:**

```bash

# Speicherverbrauch reduzieren
facefusion headless-run \
    --video-memory-strategy tolerant \
    --execution-thread-count 2
```

## Fehlerbehebung

### Schlechte Qualität des Gesichtertauschs

* Verwenden Sie Quellbilder mit höherer Auflösung
* Sorgen Sie für gute Beleuchtung in beiden Bildern
* Probieren Sie andere Gesichtsverbesserungsmodelle

### "Kein Gesicht erkannt"

* Das Gesicht muss klar sichtbar sein
* Vermeiden Sie Seitenprofile
* Überprüfen Sie, ob das Bild nicht zu klein ist

### Videoverarbeitung hängt

* Große Videos benötigen mehr RAM
* In kleineren Segmenten verarbeiten
* Verwenden Sie SSD-Speicher für temporäre Dateien

### Modelle werden nicht heruntergeladen

* Überprüfen Sie die Internetverbindung
* Führen Sie mit aus `--download-models` Flag
* Manuell von HuggingFace herunterladen

## Kostenabschätzung

Typische CLORE.AI-Marktplatztarife (Stand 2024):

| GPU       | Stundensatz | Tagessatz | 4-Stunden-Sitzung |
| --------- | ----------- | --------- | ----------------- |
| 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           |

*Preise variieren je nach Anbieter und Nachfrage. Prüfen Sie* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *auf aktuelle Preise.*

**Geld sparen:**

* Verwenden Sie **Spot** Markt für flexible Workloads (oft 30–50% günstiger)
* Bezahlen mit **CLORE** Token
* Preise bei verschiedenen Anbietern vergleichen

## Nächste Schritte

* [InstantID](/guides/guides_v2-de/gesicht-and-identitat/instantid.md) - Identitätserhalt
* [LivePortrait](/guides/guides_v2-de/talking-heads/liveportrait.md) - Porträtanimation
* [GFPGAN](/guides/guides_v2-de/bildverarbeitung/gfpgan-face-restore.md) - Gesichtsrestauration


---

# 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-de/gesicht-and-identitat/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.