> 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 Face-Swapping und Enhancing auf Clore.ai-GPUs

Professionelles Tool zum Gesichtstausch und zur Gesichtsverbesserung.

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

## Mieten auf CLORE.AI

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

### Greife auf deinen Server zu

* Verbindungsdetails finden in **Meine Bestellungen**
* Web-Oberflächen: Verwende die HTTP-Port-URL
* SSH: `ssh -p <port> root@<proxy-address>`

## Was ist FaceFusion?

FaceFusion bietet:

* Hochwertiger Gesichtstausch
* Gesichtsverbesserung
* Altersänderung
* Ausdrucksübertragung
* Videobearbeitung

## 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 12 GB | RTX 4080 16 GB | RTX 4090 24GB |
| VRAM       | 8 GB           | 16 GB          | 24 GB         |
| CPU        | 8 Kerne        | 16 Kerne       | 32 Kerne      |
| RAM        | 16 GB          | 32 GB          | 64 GB         |
| Speicher   | 50 GB SSD      | 100 GB NVMe    | 200 GB NVMe   |
| Internet   | 100 Mbit/s     | 500 Mbit/s     | 1 Gbit/s      |

## Schnellbereitstellung auf CLORE.AI

**Docker-Image:**

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

**Ports:**

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

**Befehl:**

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

## Auf deinen Dienst zugreifen

Nach der Bereitstellung findest du deine `http_pub` URL in **Meine Bestellungen**:

1. Gehe zu **Meine Bestellungen** Seite
2. Klicke auf deine Bestellung
3. Finde die `http_pub` URL (z. B. `abc123.clorecloud.net`)

Verwende `https://YOUR_HTTP_PUB_URL` anstelle von `localhost` in den folgenden Beispielen.

## 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 der Filmsynchronisation
* Von Fans erstellte Inhalte
* Meme-Erstellung

### Professionell

* Virtuelle Anprobe für Mode
* Personalisierte Vermarktung
* Datenschutz in Videos

### Kreative Projekte

* Kunstinstallationen
* Musikvideoeffekte
* Kurzfilmproduktion

**Wichtig:** Immer verantwortungsvoll und mit Zustimmung verwenden.

## Grundlegende Verwendung

### Weboberfläche

```bash

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

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

### Kommandozeile

```bash

# Gesichtstausch bei einem einzelnen Bild
facefusion headless-run \\
    --source-paths source_face.jpg \\
    --target-path target_image.jpg \\
    --output-path result.jpg \\
    --face-swapper-model inswapper_128

# Gesichtstausch im Video
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"
)

# Bild verarbeiten
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
```

## Videoverarbeitung

```bash

# Vollständiger Gesichtstausch im Video 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}")
```

## Benutzerdefinierte Gradio-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="Quellgesicht"),
        gr.Image(type="filepath", label="Zielbild"),
        gr.Checkbox(label="Ergebnis verbessern", value=True)
    ],
    outputs=gr.Image(label="Ergebnis"),
    title="FaceFusion - Gesichtstausch",
    description="Professioneller Gesichtstausch auf CLORE.AI-Servern"
)

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

## Qualitätseinstellungen

### Swap-Modelle

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

### 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   |
| -------------- | --------- | -------- | ------ |
| Einzelbild     | 1024x1024 | RTX 3090 | 0,5 s  |
| Einzelbild     | 1024x1024 | RTX 4090 | 0,3 s  |
| Video (1 Min.) | 1080p     | RTX 4090 | 5 Min. |
| Video (1 Min.) | 1080p     | A100     | 3 Min. |

## Häufige Probleme & Lösungen

### Gesicht nicht erkannt

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

**Lösungen:**

* Stellen Sie sicher, dass das Gesicht klar sichtbar ist
* Das Gesicht sollte mindestens 64x64 Pixel groß sein
* Frontale oder leicht seitliche Fotos verwenden
* Gute Beleuchtung erforderlich

### Schlechte Qualität beim Gesichtstausch

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

### Langsame Videobearbeitung

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

**Lösungen:**

* CUDA-Ausführungsanbieter verwenden
* Thread-Anzahl erhöhen
* Für Geschwindigkeit fp16-Modell verwenden
* Für beste Leistung auf A100 verarbeiten

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

* Gesichtsfarbkorrektur aktivieren
* Beleuchtung zwischen Quelle und Ziel anpassen
* Nachbearbeitung mit Farbkorrektur

### Speicherprobleme

**Problem:** Nicht genügend Speicher beim Video

**Lösungen:**

```bash

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

## Fehlerbehebung

### Schlechte Face-Swap-Qualität

* Höher aufgelöste Quellbilder verwenden
* Für gute Beleuchtung in beiden Bildern sorgen
* Verschiedene Gesicht-Verbesserungsmodelle ausprobieren

### "Kein Gesicht erkannt"

* Das Gesicht muss klar sichtbar sein
* Seitenprofile vermeiden
* Prüfen, dass das Bild nicht zu klein ist

### Videoverarbeitung hängt

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

### Modelle werden nicht heruntergeladen

* Internetverbindung prüfen
* Ausführen mit `--download-models` Schalter
* Manuell von HuggingFace herunterladen

## Kostenschätzung

Übliche CLORE.AI-Marktplatzpreise (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           |

*Die Preise variieren je nach Anbieter und Nachfrage. Prüfen Sie* [*CLORE.AI-Marktplatz*](https://clore.ai/marketplace) *für aktuelle Preise.*

**Geld sparen:**

* Nutzen Sie den **Spot** Markt für unterbrechbare Arbeit — etwa ein Drittel der Server bietet Spot-Preise unter dem On-Demand-Preis (Median ca. 13 % Rabatt), der Rest ist gleichauf
* Bezahlen Sie mit **CLORE** Tokens
* Vergleichen Sie Preise zwischen verschiedenen Anbietern

## Nächste Schritte

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


---

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