# 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](https://docs.clore.ai/guides/guides_v2-de/gesicht-and-identitat/instantid) - Identitätserhalt
* [LivePortrait](https://docs.clore.ai/guides/guides_v2-de/sprechende-kopfe/liveportrait) - Porträtanimation
* [GFPGAN](https://docs.clore.ai/guides/guides_v2-de/bildverarbeitung/gfpgan-face-restore) - Gesichtsrestauration