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

# Wan2.1 Video

Создавайте высококачественные видео с помощью моделей Alibaba Wan2.1 text-to-video и image-to-video на GPU CLORE.AI.

{% hint style="success" %}
Все примеры можно запускать на GPU-серверах, арендованных через [маркетплейс CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

## Почему Wan2.1?

* **Высокое качество** - Генерация видео высочайшего уровня
* **Несколько режимов** - Текст-в-видео, изображение-в-видео
* **Разные размеры** - От 1,3 млрд до 14 млрд параметров
* **Длинные видео** - До 81 кадра
* **Открытые веса** - лицензия Apache 2.0

## Варианты модели

| Модель          | Параметры | VRAM  | Разрешение | Кадры |
| --------------- | --------- | ----- | ---------- | ----- |
| Wan2.1-T2V-1.3B | 1.3B      | 8 ГБ  | 480p       | 81    |
| Wan2.1-T2V-14B  | 14B       | 24 ГБ | 720p       | 81    |
| Wan2.1-I2V-14B  | 14B       | 24 ГБ | 720p       | 81    |

## Быстрое развертывание на CLORE.AI

**Docker-образ:**

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

**Порты:**

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

**Команда:**

```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='Промпт'),
        gr.Slider(20, 100, value=50, label='Шаги'),
        gr.Slider(16, 81, value=49, step=8, label='Кадры'),
        gr.Number(value=-1, label='Сид')
    ],
    outputs=gr.Video(),
    title='Wan2.1 - Текст в видео'
).launch(server_name='0.0.0.0', server_port=7860)
"
```

## Доступ к вашему сервису

После развертывания найдите свой `http_pub` URL в **Мои заказы**:

1. Перейдите на **Мои заказы** страницу
2. Нажмите на свой заказ
3. Найдите `http_pub` URL (например, `abc123.clorecloud.net`)

Используйте `https://YOUR_HTTP_PUB_URL` вместо `localhost` в примерах ниже.

## Требования к оборудованию

| Модель   | Минимальная GPU | Рекомендуется | Оптимально |
| -------- | --------------- | ------------- | ---------- |
| 1.3B T2V | RTX 3070 8GB    | RTX 3090 24GB | RTX 4090   |
| 14B T2V  | RTX 4090 24GB   | A100 40 ГБ    | A100 80 ГБ |
| 14B I2V  | RTX 4090 24GB   | A100 40 ГБ    | A100 80 ГБ |

## Установка

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

## Текст-в-видео

### Базовое использование (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 = "Кот играет с мячом в солнечном саду"

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

### Высокое качество (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 = "Кинематографичный кадр дракона, летящего над горами на закате, 4K, детализированный"

output = pipe(
    prompt=prompt,
    negative_prompt="размытое, низкое качество, искажённое",
    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)
```

## Изображение в видео

### Анимация изображения

```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()

# Загрузить входное изображение
image = load_image("input.jpg")

prompt = "Человек на изображении начинает идти вперёд"

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

## Изображение-в-видео с Wan2.1-I2V-14B

{% hint style="info" %}
Wan2.1-I2V-14B анимирует статичное изображение с помощью текстового промпта, задающего движение. Требуется **24 ГБ VRAM** (рекомендуются RTX 4090 или A100 40GB).
{% endhint %}

### Сведения о модели

| Параметр                | Значение                           |
| ----------------------- | ---------------------------------- |
| Идентификатор модели    | `Wan-AI/Wan2.1-I2V-14B-480P`       |
| Параметры               | 14 миллиардов                      |
| Требуемая VRAM          | **24 ГБ**                          |
| Максимальное разрешение | 480p (854×480) или 720p (1280×720) |
| Макс. кадров            | 81                                 |
| Лицензия                | Apache 2.0                         |

### Требования к оборудованию

| GPU        | VRAM  | Статус            |
| ---------- | ----- | ----------------- |
| RTX 4090   | 24 ГБ | ✅ Рекомендуется   |
| RTX 3090   | 24 ГБ | ✅ Поддерживается  |
| A100 40 ГБ | 40 ГБ | ✅ Оптимально      |
| A100 80 ГБ | 80 ГБ | ✅ Лучшее качество |
| RTX 3080   | 10 ГБ | ❌ Недостаточно    |

### Быстрый CLI-скрипт

Сохранить как `generate_i2v.py` и выполните:

```bash
python generate_i2v.py --model Wan-AI/Wan2.1-I2V-14B-480P --image input.jpg --prompt "камера медленно отъезжает назад"
```

### generate\_i2v.py — полный скрипт

```python
#!/usr/bin/env python3
"""
CLI-скрипт Wan2.1 Image-to-Video.
Использование: python generate_i2v.py --model Wan-AI/Wan2.1-I2V-14B-480P \
           --image input.jpg --prompt "камера медленно отъезжает назад"
"""

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")
    parser.add_argument(
        "--model",
        type=str,
        default="Wan-AI/Wan2.1-I2V-14B-480P",
        help="Идентификатор модели на Hugging Face (по умолчанию: Wan-AI/Wan2.1-I2V-14B-480P)",
    )
    parser.add_argument(
        "--image",
        type=str,
        required=True,
        help="Путь к входному изображению (JPEG или PNG)",
    )
    parser.add_argument(
        "--prompt",
        type=str,
        required=True,
        help='Текстовый промпт, описывающий желаемое движение (например, "камера медленно отъезжает назад")',
    )
    parser.add_argument(
        "--negative-prompt",
        type=str,
        default="размытое, низкое качество, искажённое, рывки движения, артефакты",
        help="Негативный промпт для предотвращения нежелательных артефактов",
    )
    parser.add_argument(
        "--frames",
        type=int,
        default=49,
        help="Количество кадров для генерации видео (по умолчанию: 49, максимум: 81)",
    )
    parser.add_argument(
        "--steps",
        type=int,
        default=50,
        help="Количество шагов диффузии (по умолчанию: 50)",
    )
    parser.add_argument(
        "--guidance",
        type=float,
        default=7.0,
        help="Шкала guidance без учителя (по умолчанию: 7.0)",
    )
    parser.add_argument(
        "--seed",
        type=int,
        default=-1,
        help="Случайный seed для воспроизводимости (-1 = случайный)",
    )
    parser.add_argument(
        "--fps",
        type=int,
        default=16,
        help="FPS выходного видео (по умолчанию: 16)",
    )
    parser.add_argument(
        "--output",
        type=str,
        default="output_i2v.mp4",
        help="Путь к выходному видеофайлу (по умолчанию: output_i2v.mp4)",
    )
    parser.add_argument(
        "--height",
        type=int,
        default=480,
        help="Высота выходного видео в пикселях (по умолчанию: 480)",
    )
    parser.add_argument(
        "--width",
        type=int,
        default=854,
        help="Ширина выходного видео в пикселях (по умолчанию: 854)",
    )
    parser.add_argument(
        "--cpu-offload",
        action="store_true",
        default=True,
        help="Включить выгрузку модели на CPU для экономии VRAM (по умолчанию: True)",
    )
    parser.add_argument(
        "--vae-tiling",
        action="store_true",
        default=False,
        help="Включить тайлинг VAE для вывода высокого разрешения",
    )
    return parser.parse_args()


def load_and_resize_image(image_path: str, width: int, height: int) -> Image.Image:
    """Загрузить изображение по пути и изменить размер до целевых размеров."""
    if not os.path.exists(image_path):
        print(f"[ERROR] Изображение не найдено: {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] Изображение загружено: {image_path} ({original_size[0]}x{original_size[1]}) → изменено до {width}x{height}")
    return img


def load_pipeline(model_id: str, cpu_offload: bool, vae_tiling: bool):
    """Загрузить I2V-пайплайн Wan с оптимизацией памяти."""
    print(f"[INFO] Загрузка модели: {model_id}")
    print(f"[INFO] Доступен CUDA: {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} ГБ VRAM)")
        if vram_gb < 23:
            print("[WARN] Обнаружено менее 24 ГБ VRAM — включите --cpu-offload или используйте модель 1.3B")

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

    if cpu_offload:
        print("[INFO] Включается CPU offload модели")
        pipe.enable_model_cpu_offload()
    else:
        pipe.to("cuda")

    if vae_tiling:
        print("[INFO] Включается тайлинг VAE для генерации высокого разрешения")
        pipe.enable_vae_tiling()

    return pipe


def generate_video(pipe, args) -> None:
    """Запустить I2V-пайплайн и сохранить выходное видео."""
    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] Используется seed: {args.seed}")
    else:
        print("[INFO] Используется случайный seed")

    print(f"[INFO] Генерируется {args.frames} кадров в {args.width}x{args.height}")
    print(f"[INFO] Шаги: {args.steps} | Guidance: {args.guidance} | FPS: {args.fps}")
    print(f"[INFO] Промпт: {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] Видео сохранено в: {os.path.abspath(args.output)}")
    duration = args.frames / args.fps
    print(f"[INFO] Длительность: {duration:.1f}с при {args.fps}fps ({args.frames} кадров)")


def main():
    args = parse_args()

    if not torch.cuda.is_available():
        print("[ERROR] CUDA GPU не найдена. Для Wan2.1-I2V-14B требуется GPU с поддержкой CUDA.", file=sys.stderr)
        sys.exit(1)

    pipe = load_pipeline(args.model, args.cpu_offload, args.vae_tiling)
    generate_video(pipe, args)
    print("[DONE] Генерация изображение-в-видео завершена!")


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

### Продвинутый I2V-пайплайн (Python API)

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

# ── Загрузка пайплайна ──────────────────────────────────────────────────────────────
pipe = WanImageToVideoPipeline.from_pretrained(
    "Wan-AI/Wan2.1-I2V-14B-480P",
    torch_dtype=torch.float16,
)
pipe.enable_model_cpu_offload()   # держит VRAM ниже 24 ГБ
pipe.enable_vae_tiling()          # опционально: помогает для 720p

# ── Загрузка и подготовка входного изображения ───────────────────────────────────
image = load_image("input.jpg").resize((854, 480))

# ── Генерация ───────────────────────────────────────────────────────────────────
prompt = "камера медленно отъезжает назад, открывая весь пейзаж"
negative_prompt = "размытое, низкое качество, искажённое, мерцание, артефакты"

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

output = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    image=image,
    num_frames=49,          # ~3 секунды при 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("Сохранено: i2v_output.mp4")
```

### Советы по промптам для I2V

| Цель                 | Пример промпта                                           |
| -------------------- | -------------------------------------------------------- |
| Движение камеры      | `"камера медленно отъезжает от объекта"`                 |
| Параллакс-эффект     | `"лёгкое параллакс-движение, смещение глубины резкости"` |
| Анимация персонажа   | `"фигура поворачивает голову и улыбается"`               |
| Анимация природы     | `"листья шуршат на лёгком ветру, меняется освещение"`    |
| Абстрактное движение | `"цвета закручиваются и смешиваются, плавное движение"`  |

### Советы по памяти для I2V (GPU 24 ГБ)

```python
# Обязательно на GPU 24 ГБ
pipe.enable_model_cpu_offload()

# Опционально: снижает пик VRAM примерно на 10%
pipe.enable_vae_tiling()
pipe.enable_vae_slicing()

# Очищать между запусками
import gc
gc.collect()
torch.cuda.empty_cache()
```

## Примеры промптов

### Природа и пейзажи

```python
prompts = [
    "Таймлапс облаков, движущихся над горными вершинами, драматичное освещение",
    "Океанские волны разбиваются о камни, замедленная съёмка, кинематографично",
    "Северное сияние танцует в ночном небе, яркие цвета",
    "Лес осенью с опадающими листьями, спокойная атмосфера"
]
```

### Животные и персонажи

```python
prompts = [
    "Золотистый ретривер бежит через поле цветов",
    "Бабочка выходит из кокона, макросъёмка",
    "Самурай вытаскивает меч, драматичное освещение",
    "Робот идёт по улицам футуристического города"
]
```

### Абстрактное и художественное

```python
prompts = [
    "Цветная краска закручивается в воде, абстрактное искусство",
    "Геометрические фигуры трансформируются и изменяются, неоновые цвета",
    "Капли чернил растекаются в молоке, макрофотография"
]
```

## Расширенные настройки

### Качество vs скорость

```python
# Быстрый предпросмотр
output = pipe(
    prompt=prompt,
    num_frames=17,
    num_inference_steps=25,
    guidance_scale=5.0
)

# Сбалансировано
output = pipe(
    prompt=prompt,
    num_frames=49,
    num_inference_steps=50,
    guidance_scale=7.0
)

# Максимальное качество
output = pipe(
    prompt=prompt,
    num_frames=81,
    num_inference_steps=100,
    guidance_scale=7.5
)
```

### Параметры разрешения

```python
# 480p (модель 1.3B)
output = pipe(prompt, height=480, width=854, num_frames=49)

# 720p (модель 14B)
output = pipe(prompt, height=720, width=1280, num_frames=49)

# 1080p (модель 14B, высокая VRAM)
output = pipe(prompt, height=1080, width=1920, num_frames=33)
```

## Пакетная генерация

```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 = [
    "Ракета стартует в космос",
    "Рыбы плавают в коралловом рифе",
    "Дождь падает на городскую улицу ночью"
]

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

for i, prompt in enumerate(prompts):
    print(f"Генерация {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

```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="Промпт", lines=2),
        gr.Textbox(label="Негативный промпт", value="размытое, низкое качество"),
        gr.Slider(17, 81, value=49, step=8, label="Кадры"),
        gr.Slider(20, 100, value=50, step=5, label="Шаги"),
        gr.Slider(3, 12, value=7, step=0.5, label="Guidance"),
        gr.Number(value=-1, label="Сид")
    ],
    outputs=gr.Video(label="Сгенерированное видео"),
    title="Wan2.1 - Генерация текста в видео",
    description="Генерируйте видео по текстовым промптам. Работает на CLORE.AI."
)

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

## Оптимизация памяти

```python
# Включить все оптимизации
pipe.enable_model_cpu_offload()
pipe.enable_vae_tiling()
pipe.enable_vae_slicing()

# Для очень низкой VRAM
pipe.enable_sequential_cpu_offload()

# Очищать кэш между генерациями
torch.cuda.empty_cache()
```

## Производительность

| Модель | Разрешение | Кадры | GPU        | Время     |
| ------ | ---------- | ----- | ---------- | --------- |
| 1.3B   | 480p       | 49    | RTX 4090   | \~2 мин   |
| 1.3B   | 480p       | 49    | A100 40 ГБ | \~1,5 мин |
| 14B    | 720p       | 49    | A100 40 ГБ | \~5 мин   |
| 14B    | 720p       | 81    | A100 80 ГБ | \~8 мин   |

## Оценка стоимости

Типичные расценки маркетплейса CLORE.AI:

| GPU           | Почасовая ставка | \~49 видео по 49 кадров/час |
| ------------- | ---------------- | --------------------------- |
| RTX 3090 24GB | \~$0.06          | \~20 (1.3B)                 |
| RTX 4090 24GB | \~$0.10          | \~30 (1.3B)                 |
| A100 40 ГБ    | \~$0.17          | \~40 (1.3B) / \~12 (14B)    |
| A100 80 ГБ    | \~$0.25          | \~8 (14B high-res)          |

*Цены могут отличаться. Проверьте* [*маркетплейс CLORE.AI*](https://clore.ai/marketplace) *актуальные тарифы.*

## Устранение неполадок

### Недостаточно памяти

```python
# Используйте меньшую модель
pipe = WanPipeline.from_pretrained("alibaba-pai/Wan2.1-T2V-1.3B")

# Включить все оптимизации
pipe.enable_model_cpu_offload()
pipe.enable_vae_tiling()

# Уменьшить число кадров
output = pipe(prompt, num_frames=17)

# Уменьшить разрешение
output = pipe(prompt, height=480, width=854)
```

### Низкое качество

* Увеличьте число шагов (75-100)
* Пишите более подробные промпты
* Используйте негативные промпты
* Попробуйте модель 14B для лучшего качества

### Видео слишком короткое

* Увеличьте `num_frames` (макс. 81)
* Используйте интерполяцию RIFE для интерполяции кадров
* Объединяйте несколько генераций

### Артефакты/мерцание

* Увеличьте коэффициент guidance
* Используйте фиксированный seed для согласованности
* Постобработайте с помощью стабилизации видео

## Wan2.1 против других

| Функция       | Wan2.1     | Hunyuan | SVD     | CogVideoX |
| ------------- | ---------- | ------- | ------- | --------- |
| Качество      | Отлично    | Отлично | Хорошо  | Отлично   |
| Скорость      | Быстро     | Средне  | Быстро  | Медленно  |
| Макс. кадров  | 81         | 129     | 25      | 49        |
| Разрешение    | 720p       | 720p    | 576p    | 720p      |
| Поддержка I2V | Да         | Да      | Да      | Да        |
| Лицензия      | Apache 2.0 | Открыть | Открыть | Открыть   |

**Используйте Wan2.1, когда:**

* Нужна генерация видео с открытым исходным кодом
* Нужна высокая скорость генерации
* Требуется лицензия Apache 2.0
* Нужен баланс качества и скорости

## Дальнейшие шаги

* [Hunyuan Video](/guides/guides_v2-ru/generaciya-video/hunyuan-video.md) - Альтернатива T2V
* [OpenSora](/guides/guides_v2-ru/generaciya-video/opensora.md) - Альтернатива Open Sora
* [Stable Video Diffusion](/guides/guides_v2-ru/generaciya-video/stable-video-diffusion.md) - Анимация изображений
* [Интерполяция RIFE](/guides/guides_v2-ru/obrabotka-video/rife-interpolation.md) - Интерполяция кадров


---

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