# Hunyuan Video

Erstelle hochwertige Videos mit Tencents Open-Source Hunyuan Video.

{% 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 Hunyuan Video?

Hunyuan Video von Tencent bietet:

* Hochwertige Text-zu-Video-Generierung
* Video-Clips über 5 Sekunden
* 720p Auflösung
* Open-Source und kommerziell nutzbar

## Ressourcen

* **Modell:** [tencent/HunyuanVideo](https://huggingface.co/tencent/HunyuanVideo)
* **GitHub:** [Tencent/HunyuanVideo](https://github.com/Tencent/HunyuanVideo)
* **Paper:** [HunyuanVideo Paper](https://arxiv.org/abs/2412.03603)

## Empfohlene Hardware

| Komponente | Minimum       | Empfohlen  | Optimal    |
| ---------- | ------------- | ---------- | ---------- |
| GPU        | RTX 4090 24GB | A100 40GB  | A100 80GB  |
| VRAM       | 24GB          | 40GB       | 80GB       |
| CPU        | 8 Kerne       | 16 Kerne   | 32 Kerne   |
| RAM        | 32GB          | 64GB       | 128GB      |
| Speicher   | 100GB NVMe    | 200GB NVMe | 500GB NVMe |
| Internet   | 500 Mbps      | 1 Gbps     | 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
git clone https://github.com/Tencent/HunyuanVideo.git && \
cd HunyuanVideo && \
pip install -r requirements.txt && \
python sample_video.py --prompt "Eine Katze, die in einem Garten spaziert"
```

## 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
git clone https://github.com/Tencent/HunyuanVideo.git
cd HunyuanVideo
pip install -r requirements.txt

# Modelle herunterladen
python download_models.py
```

## Was Sie erstellen können

### Marketing-Inhalte

* Produktpräsentationsvideos
* Clips für soziale Medien
* Werbeanimationen

### Kreative Projekte

* Konzepte für Musikvideos
* Prototypen für Kurzfilme
* Kunstinstallationen

### Bildung & Ausbildung

* Entwürfe für Erklärvideos
* Konzepte für Schulungsmaterial
* Visualisierung von Konzepten

## Grundlegende Verwendung

```python
import torch
from diffusers import HunyuanVideoPipeline
from diffusers.utils import export_to_video

pipe = HunyuanVideoPipeline.from_pretrained(
    "tencent/HunyuanVideo",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()
pipe.vae.enable_tiling()

prompt = "Ein majestätischer Adler, der über schneebedeckte Berge gleitet, filmische Beleuchtung, 4K"

video_frames = pipe(
    prompt=prompt,
    num_frames=45,
    num_inference_steps=50,
    guidance_scale=7.0
).frames[0]

export_to_video(video_frames, "eagle.mp4", fps=15)
```

## Erweiterte Generierung

```python
import torch
from diffusers import HunyuanVideoPipeline
from diffusers.utils import export_to_video

pipe = HunyuanVideoPipeline.from_pretrained(
    "tencent/HunyuanVideo",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()
pipe.vae.enable_tiling()
pipe.vae.enable_slicing()

video_frames = pipe(
    prompt="Zeitraffer einer Blüte, die sich öffnet, Makrofotografie, detaillierte Blütenblätter",
    negative_prompt="verschwommen, niedrige Qualität, verzerrt, hässlich",
    num_frames=45,
    height=544,
    width=960,
    num_inference_steps=50,
    guidance_scale=7.0,
    generator=torch.Generator("cuda").manual_seed(42)
).frames[0]

export_to_video(video_frames, "flower_bloom.mp4", fps=15)
```

## Prompt-Beispiele

### Natur & Landschaften

```python
prompts = [
    "Polarlichter, die über einem zugefrorenen See tanzen, Zeitraffer, ätherisch",
    "Ozeanwellen, die an einem vulkanischen schwarzen Sandstrand brechen, Zeitlupe",
    "Gewitter über einem Weizenfeld, dramatische Beleuchtung, 4K",
    "Kirschblüten, die in einem japanischen Garten fallen, Frühling, friedlich"
]
```

### Sci-Fi & Fantasy

```python
prompts = [
    "Raumschiff startet aus einer futuristischen Stadt, filmisch, detailreich",
    "Drache fliegt durch Wolken bei Sonnenuntergang, episch, Fantasy",
    "Roboter läuft durch neonbeleuchtete Straßen, Cyberpunk, Regen",
    "Magisches Portal öffnet sich in einem uralten Wald, mystische Lichter"
]
```

### Abstrakt & Künstlerisch

```python
prompts = [
    "Tintentropfen, die sich im Wasser ausbreiten, Makro, farbenfroh, abstrakt",
    "Geometrische Formen, die sich verwandeln und morphieren, Motion Graphics",
    "Lichtmalerei in der Dunkelheit, Langzeitbelichtungseffekt, lebendig"
]
```

## Batch-Erzeugung

```python
import os
import torch
from diffusers import HunyuanVideoPipeline
from diffusers.utils import export_to_video

pipe = HunyuanVideoPipeline.from_pretrained("tencent/HunyuanVideo", torch_dtype=torch.float16)
pipe.to("cuda")
pipe.enable_model_cpu_offload()
pipe.vae.enable_tiling()

prompts = [
    "Unterwasser-Korallenriff mit bunten Fischen, die schwimmen",
    "Stadtverkehr-Zeitraffer bei Nacht, Lichtspuren",
    "Schmetterling schlüpft aus dem Kokon, Naturdokumentation"
]

output_dir = "./videos"
os.makedirs(output_dir, exist_ok=True)

for i, prompt in enumerate(prompts):
    print(f"Erzeuge {i+1}/{len(prompts)}: {prompt[:50]}...")

    video_frames = pipe(
        prompt=prompt,
        num_frames=45,
        num_inference_steps=50,
        guidance_scale=7.0
    ).frames[0]

    export_to_video(video_frames, f"{output_dir}/video_{i:03d}.mp4", fps=15)
```

## Gradio-Oberfläche

```python
import gradio as gr
import torch
from diffusers import HunyuanVideoPipeline
from diffusers.utils import export_to_video
import tempfile

pipe = HunyuanVideoPipeline.from_pretrained("tencent/HunyuanVideo", torch_dtype=torch.float16)
pipe.to("cuda")
pipe.enable_model_cpu_offload()
pipe.vae.enable_tiling()

def generate(prompt, negative_prompt, num_frames, steps, guidance, seed):
    generator = torch.Generator("cuda").manual_seed(seed) if seed > 0 else None

    video_frames = pipe(
        prompt=prompt,
        negative_prompt=negative_prompt,
        num_frames=num_frames,
        num_inference_steps=steps,
        guidance_scale=guidance,
        generator=generator
    ).frames[0]

    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as f:
        export_to_video(video_frames, f.name, fps=15)
        return f.name

demo = gr.Interface(
    fn=generate,
    inputs=[
        gr.Textbox(label="Prompt", lines=3),
        gr.Textbox(label="Negativer Prompt", value="verschwommen, niedrige Qualität"),
        gr.Slider(16, 60, value=45, step=1, label="Frames"),
        gr.Slider(20, 100, value=50, step=5, label="Steps"),
        gr.Slider(3, 12, value=7, step=0.5, label="Guidance"),
        gr.Number(value=-1, label="Seed")
    ],
    outputs=gr.Video(label="Generated Video"),
    title="Hunyuan Video - Text zu Video auf CLORE.AI"
)

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

## Leistung

| Auflösung | Frames | GPU       | Zeit    |
| --------- | ------ | --------- | ------- |
| 544x960   | 45     | RTX 4090  | \~5 Min |
| 544x960   | 45     | A100 40GB | \~3 Min |
| 544x960   | 45     | A100 80GB | \~2 Min |
| 720x1280  | 45     | A100 80GB | \~4 Min |

## Häufige Probleme & Lösungen

### Kein Speicher mehr

**Problem:** CUDA: kein Speicher auf 24GB GPU

**Lösungen:**

```python

# Aktivieren Sie alle Speicheroptimierungen
pipe.enable_model_cpu_offload()
pipe.enable_sequential_cpu_offload()  # Aggressiver
pipe.vae.enable_tiling()
pipe.vae.enable_slicing()

# Reduzieren Sie Frames und Auflösung
video = pipe(prompt, num_frames=24, height=480, width=720).frames[0]
```

### Langsame Generierung

**Problem:** Dauert zu lange zu generieren

**Lösungen:**

* Reduzieren `num_inference_steps` (30-40 liefert immer noch gute Ergebnisse)
* Reduzieren `num_frames` (24 Frames = 1,6 s bei 15 fps)
* Verwenden Sie GPU A100 für schnellere Verarbeitung
* Stellen Sie sicher, dass Sie NVMe-Speicher zum Laden des Modells haben

### Schlechte Videoqualität

**Problem:** Verschwommene oder inkonsistente Bewegung

**Lösungen:**

* Erhöhen Sie `num_inference_steps` auf 75-100
* Anpassen `guidance_scale` (6-8 funktioniert am besten)
* Schreiben Sie detailliertere Prompts
* Fügen Sie negative Prompts hinzu, um Probleme zu vermeiden

### Video-Artefakte

**Problem:** Flackern oder zeitliche Inkonsistenzen

**Lösungen:**

* Verwenden Sie einen konsistenten Seed für Reproduzierbarkeit
* Vermeiden Sie Prompts mit schnellen Bewegungen
* Nachbearbeitung mit Video-Stabilisierung

## Fehlerbehebung

{% hint style="danger" %}
**Kein Speicher mehr**
{% endhint %}

* Hunyuan benötigt mindestens 24GB VRAM
* Verwenden Sie A100 40GB/80GB für beste Ergebnisse
* Reduzieren Sie Videolänge/Auflösung

### Videoerstellung schlägt fehl

* Überprüfen Sie, ob alle Modell-Dateien korrekt heruntergeladen wurden
* Stellen Sie genügend Festplattenspeicher sicher (100GB+)
* Überprüfen Sie die Kompatibilität von CUDA und PyTorch

### Schlechte Videoqualität

* Erhöhen Sie die Inferenzschritte
* Verwenden Sie beschreibendere Prompts
* Überprüfen Sie, ob die Eingangsauflösung den Erwartungen entspricht

### Langsame Generierung

* Die Videoerzeugung ist rechenintensiv
* Verwenden Sie A100/H100 für schnellere Ergebnisse
* Erwägen Sie zunächst kürzere Clips

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

* CogVideoX - Alternative T2V
* Wan2.1 Video - Eine weitere T2V-Option
* AnimateDiff - Bildanimation