Wan2.1 Video

Создавайте видео с помощью модели Wan2.1 от Alibaba на GPU Clore.ai

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

Все примеры можно запускать на GPU-серверах, арендованных через маркетплейс CLORE.AI.

Почему 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

Команда:

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 ГБ

Установка

pip install diffusers transformers accelerate torch

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

Базовое использование (1,3B)

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)

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)

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

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

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

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

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

Параметр	Значение
Идентификатор модели	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 и выполните:

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

generate_i2v.py — полный скрипт

#!/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)

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 ГБ)

# Обязательно на 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()

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

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

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

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

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

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

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

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

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

# Быстрый предпросмотр
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
)

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

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

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

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

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)

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

# Включить все оптимизации
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 актуальные тарифы.

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

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

# Используйте меньшую модель
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 - Альтернатива T2V

• OpenSora - Альтернатива Open Sora

• Stable Video Diffusion - Анимация изображений

• Интерполяция RIFE - Интерполяция кадров