> 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/video-generierung/wan-video.md).

# Wan2.1 Video

Erzeugen Sie hochwertige Videos mit Alibabas Wan2.1 Text-zu-Video- und Bild-zu-Video-Modellen auf CLORE.AI-GPUs.

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

## Warum Wan2.1?

* **Hohe Qualität** - State-of-the-art Videoerzeugung
* **Mehrere Modi** - Text-zu-Video, Bild-zu-Video
* **Verschiedene Größen** - 1,3B bis 14B Parameter
* **Lange Videos** - Bis zu 81 Bilder
* **Offene Gewichte** - Apache-2.0-Lizenz

## Modellvarianten

| Modell          | Parameter | VRAM | Auflösung | Frames |
| --------------- | --------- | ---- | --------- | ------ |
| Wan2.1-T2V-1.3B | 1,3B      | 8GB  | 480p      | 81     |
| Wan2.1-T2V-14B  | 14B       | 24GB | 720p      | 81     |
| Wan2.1-I2V-14B  | 14B       | 24GB | 720p      | 81     |

## 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 diffusers transformers accelerate gradio && \
python -c "
import gradio as gr
import torch
from diffusers import WanPipeline
from diffusers.utils import export_to_video

pipe = WanPipeline.from_pretrained('alibaba-pai/Wan2.1-T2V-1.3B', torch_dtype=torch.float16)
pipe.to('cuda')
pipe.enable_model_cpu_offload()

def generate(prompt, steps, frames, seed):
    generator = torch.Generator('cuda').manual_seed(seed) if seed > 0 else None
    output = pipe(prompt, num_frames=frames, num_inference_steps=steps, generator=generator)
    export_to_video(output.frames[0], 'output.mp4', fps=16)
    return 'output.mp4'

gr.Interface(
    fn=generate,
    inputs=[
        gr.Textbox(label='Prompt'),
        gr.Slider(20, 100, value=50, label='Steps'),
        gr.Slider(16, 81, value=49, step=8, label='Frames'),
        gr.Number(value=-1, label='Seed')
    ],
    outputs=gr.Video(),
    title='Wan2.1 - Text to Video'
).launch(server_name='0.0.0.0', server_port=7860)
"
```

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

## Hardware-Anforderungen

| Modell   | Minimale GPU  | Empfohlen     | Optimal   |
| -------- | ------------- | ------------- | --------- |
| 1,3B T2V | RTX 3070 8GB  | RTX 3090 24GB | RTX 4090  |
| 14B T2V  | RTX 4090 24GB | A100 40GB     | A100 80GB |
| 14B I2V  | RTX 4090 24GB | A100 40GB     | A100 80GB |

## Installation

```bash
pip install diffusers transformers accelerate torch
```

## Text-zu-Video

### Grundlegende Nutzung (1,3B)

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

pipe = WanPipeline.from_pretrained(
    "alibaba-pai/Wan2.1-T2V-1.3B",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

prompt = "Eine Katze spielt mit einem Ball in einem sonnigen Garten"

output = pipe(
    prompt=prompt,
    num_frames=49,
    num_inference_steps=50,
    guidance_scale=7.0
)

export_to_video(output.frames[0], "cat_video.mp4", fps=16)
```

### Hohe Qualität (14B)

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

pipe = WanPipeline.from_pretrained(
    "alibaba-pai/Wan2.1-T2V-14B",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()
pipe.enable_vae_tiling()

prompt = "Kinematische Aufnahme eines Drachen, der bei Sonnenuntergang über Berge fliegt, 4K, detailliert"

output = pipe(
    prompt=prompt,
    negative_prompt="verschwommen, niedrige Qualität, verzerrt",
    num_frames=81,
    height=720,
    width=1280,
    num_inference_steps=50,
    guidance_scale=7.0
)

export_to_video(output.frames[0], "dragon.mp4", fps=24)
```

## Bild-zu-Video

### Ein Bild animieren

```python
import torch
from diffusers import WanI2VPipeline
from diffusers.utils import load_image, export_to_video

pipe = WanI2VPipeline.from_pretrained(
    "alibaba-pai/Wan2.1-I2V-14B",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

# Lade Eingabebild
image = load_image("input.jpg")

prompt = "Die Person auf dem Bild beginnt, nach vorne zu gehen"

output = pipe(
    prompt=prompt,
    image=image,
    num_frames=49,
    num_inference_steps=50,
    guidance_scale=7.0
)

export_to_video(output.frames[0], "animated.mp4", fps=16)
```

## Bild-zu-Video mit Wan2.1-I2V-14B

{% hint style="info" %}
Wan2.1-I2V-14B animiert ein statisches Bild und verwendet dazu einen Textprompt, um die Bewegung zu steuern. Erfordert **24GB VRAM** (RTX 4090 oder A100 40GB empfohlen).
{% endhint %}

### Modelldetails

| Eigenschaft        | Wert                                |
| ------------------ | ----------------------------------- |
| Modell-ID          | `Wan-AI/Wan2.1-I2V-14B-480P`        |
| Parameter          | 14 Milliarden                       |
| Benötigter VRAM    | **24GB**                            |
| Maximale Auflösung | 480p (854×480) oder 720p (1280×720) |
| Maximale Frames    | 81                                  |
| Lizenz             | Apache 2.0                          |

### Hardware-Anforderungen

| GPU       | VRAM | Status           |
| --------- | ---- | ---------------- |
| RTX 4090  | 24GB | ✅ Empfohlen      |
| RTX 3090  | 24GB | ✅ Unterstützt    |
| A100 40GB | 40GB | ✅ Optimal        |
| A100 80GB | 80GB | ✅ Beste Qualität |
| RTX 3080  | 10GB | ❌ Unzureichend   |

### Schnelles CLI-Skript

Speichern als `generate_i2v.py` und ausführen:

```bash
python generate_i2v.py --model Wan-AI/Wan2.1-I2V-14B-480P --image input.jpg --prompt "camera slowly zooms out"
```

### generate\_i2v.py — vollständiges Skript

```python
#!/usr/bin/env python3
"""
Wan2.1 Bild-zu-Video CLI-Skript.
Verwendung: python generate_i2v.py --model Wan-AI/Wan2.1-I2V-14B-480P \
           --image input.jpg --prompt "camera slowly zooms out"
"""

import argparse
import os
import sys
import torch
from diffusers import WanImageToVideoPipeline
from diffusers.utils import load_image, export_to_video
from PIL import Image


def parse_args():
    parser = argparse.ArgumentParser(description="Wan2.1 Image-to-Video Generator")
    parser.add_argument(
        "--model",
        type=str,
        default="Wan-AI/Wan2.1-I2V-14B-480P",
        help="Modell-ID von Hugging Face (Standard: Wan-AI/Wan2.1-I2V-14B-480P)",
    )
    parser.add_argument(
        "--image",
        type=str,
        required=True,
        help="Pfad zum Eingabebild (JPEG oder PNG)",
    )
    parser.add_argument(
        "--prompt",
        type=str,
        required=True,
        help='Text-Prompt, der die gewünschte Bewegung beschreibt (z. B. "camera slowly zooms out")',
    )
    parser.add_argument(
        "--negative-prompt",
        type=str,
        default="verschwommen, niedrige Qualität, verzerrt, ruckartige Bewegung, Artefakte",
        help="Negativer Prompt, um unerwünschte Artefakte zu vermeiden",
    )
    parser.add_argument(
        "--frames",
        type=int,
        default=49,
        help="Anzahl der zu erzeugenden Videoframes (Standard: 49, max: 81)",
    )
    parser.add_argument(
        "--steps",
        type=int,
        default=50,
        help="Anzahl der Diffusionsschritte (Standard: 50)",
    )
    parser.add_argument(
        "--guidance",
        type=float,
        default=7.0,
        help="Classifier-free Guidance Scale (Standard: 7.0)",
    )
    parser.add_argument(
        "--seed",
        type=int,
        default=-1,
        help="Zufalls-Seed für Reproduzierbarkeit (-1 = zufällig)",
    )
    parser.add_argument(
        "--fps",
        type=int,
        default=16,
        help="Ausgabevideo-FPS (Standard: 16)",
    )
    parser.add_argument(
        "--output",
        type=str,
        default="output_i2v.mp4",
        help="Pfad der Ausgabevideodatei (Standard: output_i2v.mp4)",
    )
    parser.add_argument(
        "--height",
        type=int,
        default=480,
        help="Ausgabevideo-Höhe in Pixel (Standard: 480)",
    )
    parser.add_argument(
        "--width",
        type=int,
        default=854,
        help="Ausgabevideo-Breite in Pixel (Standard: 854)",
    )
    parser.add_argument(
        "--cpu-offload",
        action="store_true",
        default=True,
        help="Aktiviere Modell-CPU-Offload, um VRAM zu sparen (Standard: True)",
    )
    parser.add_argument(
        "--vae-tiling",
        action="store_true",
        default=False,
        help="Aktiviere VAE-Tiling für hochauflösende Ausgaben",
    )
    return parser.parse_args()


def load_and_resize_image(image_path: str, width: int, height: int) -> Image.Image:
    """Lädt Bild vom Pfad und skaliert auf die Zielgröße."""
    if not os.path.exists(image_path):
        print(f"[ERROR] Image not found: {image_path}", file=sys.stderr)
        sys.exit(1)

    img = Image.open(image_path).convert("RGB")
    original_size = img.size
    img = img.resize((width, height), Image.LANCZOS)
    print(f"[INFO] Loaded image: {image_path} ({original_size[0]}x{original_size[1]}) → resized to {width}x{height}")
    return img


def load_pipeline(model_id: str, cpu_offload: bool, vae_tiling: bool):
    """Lädt die Wan I2V-Pipeline mit Speicheroptimierungen."""
    print(f"[INFO] Loading model: {model_id}")
    print(f"[INFO] CUDA available: {torch.cuda.is_available()}")
    if torch.cuda.is_available():
        vram_gb = torch.cuda.get_device_properties(0).total_memory / 1e9
        print(f"[INFO] GPU: {torch.cuda.get_device_name(0)} ({vram_gb:.1f} GB VRAM)")
        if vram_gb < 23:
            print("[WARN] Weniger als 24GB VRAM erkannt — aktivieren Sie --cpu-offload oder verwenden Sie das 1,3B-Modell")

    pipe = WanImageToVideoPipeline.from_pretrained(
        model_id,
        torch_dtype=torch.float16,
    )

    if cpu_offload:
        print("[INFO] Aktivierung des Modell-CPU-Offloads")
        pipe.enable_model_cpu_offload()
    else:
        pipe.to("cuda")

    if vae_tiling:
        print("[INFO] Aktivierung von VAE-Tiling für Hochauflösungs-Generierung")
        pipe.enable_vae_tiling()

    return pipe


def generate_video(pipe, args) -> None:
    """Führt die I2V-Pipeline aus und speichert das Ausgabevideo."""
    image = load_and_resize_image(args.image, args.width, args.height)

    generator = None
    if args.seed >= 0:
        generator = torch.Generator("cuda").manual_seed(args.seed)
        print(f"[INFO] Using seed: {args.seed}")
    else:
        print("[INFO] Using random seed")

    print(f"[INFO] Generating {args.frames} frames at {args.width}x{args.height}")
    print(f"[INFO] Steps: {args.steps} | Guidance: {args.guidance} | FPS: {args.fps}")
    print(f"[INFO] Prompt: {args.prompt}")

    output = pipe(
        prompt=args.prompt,
        negative_prompt=args.negative_prompt,
        image=image,
        num_frames=args.frames,
        height=args.height,
        width=args.width,
        num_inference_steps=args.steps,
        guidance_scale=args.guidance,
        generator=generator,
    )

    export_to_video(output.frames[0], args.output, fps=args.fps)
    print(f"[INFO] Video saved to: {os.path.abspath(args.output)}")
    duration = args.frames / args.fps
    print(f"[INFO] Duration: {duration:.1f}s at {args.fps}fps ({args.frames} frames)")


def main():
    args = parse_args()

    if not torch.cuda.is_available():
        print("[ERROR] CUDA GPU nicht gefunden. Wan2.1-I2V-14B benötigt eine CUDA-fähige GPU.", file=sys.stderr)
        sys.exit(1)

    pipe = load_pipeline(args.model, args.cpu_offload, args.vae_tiling)
    generate_video(pipe, args)
    print("[DONE] Bild-zu-Video-Erzeugung abgeschlossen!")


if __name__ == "__main__":
    main()
```

### Erweiterte I2V-Pipeline (Python-API)

```python
import torch
from diffusers import WanImageToVideoPipeline
from diffusers.utils import load_image, export_to_video
from PIL import Image

# ── Pipeline laden ──────────────────────────────────────────────────────────────
pipe = WanImageToVideoPipeline.from_pretrained(
    "Wan-AI/Wan2.1-I2V-14B-480P",
    torch_dtype=torch.float16,
)
pipe.enable_model_cpu_offload()   # hält den VRAM unter 24GB
pipe.enable_vae_tiling()          # optional: hilft für 720p

# ── Eingabebild laden & vorbereiten ───────────────────────────────────────────────
image = load_image("input.jpg").resize((854, 480))

# ── Generieren ───────────────────────────────────────────────────────────────────
prompt = "camera slowly zooms out, revealing the full landscape"
negative_prompt = "verschwommen, niedrige Qualität, verzerrt, flackern, Artefakte"

generator = torch.Generator("cuda").manual_seed(42)

output = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    image=image,
    num_frames=49,          # ~3 Sekunden bei 16fps
    height=480,
    width=854,
    num_inference_steps=50,
    guidance_scale=7.5,
    generator=generator,
)

export_to_video(output.frames[0], "i2v_output.mp4", fps=16)
print("Gespeichert: i2v_output.mp4")
```

### I2V Prompt-Tipps

| Ziel               | Prompt-Beispiel                                                    |
| ------------------ | ------------------------------------------------------------------ |
| Kamerabewegung     | `"camera slowly zooms out from the subject"`                       |
| Parallaxeeffekt    | `"subtile Parallaxbewegung, Änderung der Schärfentiefe"`           |
| Charakteranimation | `"die Figur dreht den Kopf und lächelt"`                           |
| Naturanimation     | `"Blätter rascheln in einer sanften Brise, Licht verschiebt sich"` |
| Abstrakte Bewegung | `"Farben wirbeln und verschmelzen, fließende Bewegung"`            |

### Speichertipps für I2V (24GB-GPUs)

```python
# Auf 24GB-GPUs obligatorisch
pipe.enable_model_cpu_offload()

# Optional: reduziert den Spitzen-VRAM um ~10%
pipe.enable_vae_tiling()
pipe.enable_vae_slicing()

# Zwischen Durchläufen bereinigen
import gc
gc.collect()
torch.cuda.empty_cache()
```

## Prompt-Beispiele

### Natur & Landschaften

```python
prompts = [
    "Zeitraffer von Wolken, die sich über Berggipfel bewegen, dramatische Beleuchtung",
    "Ozeanwellen, die gegen Felsen schlagen, Zeitlupe, filmisch",
    "Nordlichter, die am Nachthimmel tanzen, lebendige Farben",
    "Wald im Herbst mit fallenden Blättern, friedliche Atmosphäre"
]
```

### Tiere & Charaktere

```python
prompts = [
    "Ein Golden Retriever, der durch ein Blumenfeld rennt",
    "Ein Schmetterling, der aus seinem Kokon schlüpft, Makroaufnahme",
    "Samurai-Krieger, der sein Schwert zieht, dramatische Beleuchtung",
    "Roboter, der durch futuristische Stadtstraßen läuft"
]
```

### Abstrakt & Künstlerisch

```python
prompts = [
    "Bunte Farbe, die sich im Wasser wirbelt, abstrakte Kunst",
    "Geometrische Formen, die sich verwandeln und morphen, Neonfarben",
    "Tintentröpfchen, die sich in Milch ausbreiten, Makrofotografie"
]
```

## Erweiterte Einstellungen

### Qualität vs. Geschwindigkeit

```python
# Schnelle Vorschau
output = pipe(
    prompt=prompt,
    num_frames=17,
    num_inference_steps=25,
    guidance_scale=5.0
)

# Ausgewogen
output = pipe(
    prompt=prompt,
    num_frames=49,
    num_inference_steps=50,
    guidance_scale=7.0
)

# Maximale Qualität
output = pipe(
    prompt=prompt,
    num_frames=81,
    num_inference_steps=100,
    guidance_scale=7.5
)
```

### Auflösungsoptionen

```python
# 480p (1,3B-Modell)
output = pipe(prompt, height=480, width=854, num_frames=49)

# 720p (14B-Modell)
output = pipe(prompt, height=720, width=1280, num_frames=49)

# 1080p (14B-Modell, hoher VRAM)
output = pipe(prompt, height=1080, width=1920, num_frames=33)
```

## Batch-Erzeugung

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

pipe = WanPipeline.from_pretrained("alibaba-pai/Wan2.1-T2V-1.3B", torch_dtype=torch.float16)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

prompts = [
    "Ein Raketenstart ins All",
    "Fische, die im Korallenriff schwimmen",
    "Regen, der nachts auf einer Stadtstraße fällt"
]

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

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

    output = pipe(
        prompt=prompt,
        num_frames=49,
        num_inference_steps=50
    )

    export_to_video(output.frames[0], f"{output_dir}/video_{i:03d}.mp4", fps=16)
    torch.cuda.empty_cache()
```

## Gradio-Oberfläche

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

pipe = WanPipeline.from_pretrained("alibaba-pai/Wan2.1-T2V-1.3B", torch_dtype=torch.float16)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

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

    output = pipe(
        prompt=prompt,
        negative_prompt=negative_prompt,
        num_frames=frames,
        num_inference_steps=steps,
        guidance_scale=guidance,
        generator=generator
    )

    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as f:
        export_to_video(output.frames[0], f.name, fps=16)
        return f.name

demo = gr.Interface(
    fn=generate_video,
    inputs=[
        gr.Textbox(label="Prompt", lines=2),
        gr.Textbox(label="Negativer Prompt", value="verschwommen, niedrige Qualität"),
        gr.Slider(17, 81, value=49, step=8, 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="Generiertes Video"),
    title="Wan2.1 - Text to Video Generation",
    description="Erzeugen Sie Videos aus Text-Prompts. Läuft auf CLORE.AI."
)

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

## Speicheroptimierung

```python
# Aktivieren Sie alle Optimierungen
pipe.enable_model_cpu_offload()
pipe.enable_vae_tiling()
pipe.enable_vae_slicing()

# Für sehr wenig VRAM
pipe.enable_sequential_cpu_offload()

# Cache zwischen Generierungen leeren
torch.cuda.empty_cache()
```

## Leistung

| Modell | Auflösung | Frames | GPU       | Zeit      |
| ------ | --------- | ------ | --------- | --------- |
| 1,3B   | 480p      | 49     | RTX 4090  | \~2 min   |
| 1,3B   | 480p      | 49     | A100 40GB | \~1,5 min |
| 14B    | 720p      | 49     | A100 40GB | \~5 Min   |
| 14B    | 720p      | 81     | A100 80GB | \~8 Min.  |

## Kostenabschätzung

Typische CLORE.AI-Marktplatzpreise:

| GPU           | Stundensatz | \~49-Frame-Videos/Stunde |
| ------------- | ----------- | ------------------------ |
| RTX 3090 24GB | \~$0.06     | \~20 (1,3B)              |
| RTX 4090 24GB | \~$0.10     | \~30 (1,3B)              |
| A100 40GB     | \~$0.17     | \~40 (1,3B) / \~12 (14B) |
| A100 80GB     | \~$0.25     | \~8 (14B hochauflösend)  |

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

## Fehlerbehebung

### Kein Speicher mehr

```python
# Kleineres Modell verwenden
pipe = WanPipeline.from_pretrained("alibaba-pai/Wan2.1-T2V-1.3B")

# Aktivieren Sie alle Optimierungen
pipe.enable_model_cpu_offload()
pipe.enable_vae_tiling()

# Frames reduzieren
output = pipe(prompt, num_frames=17)

# Auflösung reduzieren
output = pipe(prompt, height=480, width=854)
```

### Schlechte Qualität

* Erhöhen Sie die Schritte (75-100)
* Schreiben Sie detailliertere Prompts
* Verwenden Sie negative Prompts
* Probieren Sie das 14B-Modell für bessere Qualität

### Video zu kurz

* Erhöhen Sie `num_frames` (max. 81)
* Verwenden Sie RIFE-Interpolation für Frame-Interpolation
* Ketten Sie mehrere Generierungen

### Artefakte/Flackern

* Erhöhen Sie den Guidance-Scale
* Verwenden Sie einen festen Seed für Konsistenz
* Nachbearbeitung mit Video-Stabilisierung

## Wan2.1 vs. Andere

| Funktion          | Wan2.1        | Hunyuan       | SVD     | CogVideoX |
| ----------------- | ------------- | ------------- | ------- | --------- |
| Qualität          | Ausgezeichnet | Ausgezeichnet | Gut     | Großartig |
| Geschwindigkeit   | Schnell       | Mittel        | Schnell | Langsam   |
| Maximale Frames   | 81            | 129           | 25      | 49        |
| Auflösung         | 720p          | 720p          | 576p    | 720p      |
| I2V-Unterstützung | Ja            | Ja            | Ja      | Ja        |
| Lizenz            | Apache 2.0    | Öffnen        | Öffnen  | Öffnen    |

**Verwenden Sie Wan2.1 wenn:**

* Offene-Source-Videoerzeugung benötigt wird
* Schnelle Erzeugungsgeschwindigkeit gewünscht ist
* Apache-2.0-Lizenz erforderlich
* Ausgewogenes Verhältnis von Qualität/Geschwindigkeit benötigt wird

## Nächste Schritte

* [Hunyuan Video](/guides/guides_v2-de/video-generierung/hunyuan-video.md) - Alternative T2V
* [OpenSora](/guides/guides_v2-de/video-generierung/opensora.md) - Alternative zu Open Sora
* [Stable Video Diffusion](/guides/guides_v2-de/video-generierung/stable-video-diffusion.md) - Bildanimation
* [RIFE-Interpolation](/guides/guides_v2-de/videoverarbeitung/rife-interpolation.md) - Frame-Interpolation


---

# 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/video-generierung/wan-video.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.