Génération vidéo IA

Générez des vidéos avec SVD, AnimateDiff et plus encore sur Clore.ai

Générez des vidéos à l'aide de Stable Video Diffusion, AnimateDiff et d'autres modèles.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

Louer sur CLORE.AI

1. Visitez la place de marché CLORE.AI

2. Filtrez par type de GPU, VRAM et prix

3. Choisissez À la demande (tarif fixe) ou Spot (prix d'enchère)

4. Configurez votre commande :

   • Sélectionnez l'image Docker

   • Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)

   • Ajoutez des variables d'environnement si nécessaire

   • Entrez la commande de démarrage

5. Sélectionnez le paiement : CLORE, BTC, ou USDT/USDC

6. Créez la commande et attendez le déploiement

Accédez à votre serveur

• Trouvez les détails de connexion dans Mes commandes

• Interfaces web : utilisez l'URL du port HTTP

• SSH : ssh -p <port> root@<proxy-address>

Modèles disponibles

Modèle	Type	VRAM	Durée
SVD	Image vers vidéo	16 Go	4 secondes
SVD-XT	Image vers vidéo	20 Go	4 secondes
AnimateDiff	Texte vers vidéo	12 Go	2-4 secondes
CogVideoX	Texte vers vidéo	24GB	6 secondes

Stable Video Diffusion (SVD)

Déploiement rapide

Image Docker :

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

Ports :

22/tcp
7860/http

Commande :

pip install diffusers transformers accelerate gradio imageio && \\
python svd_server.py

Accéder à votre service

Après le déploiement, trouvez votre http_pub URL dans Mes commandes:

1. Accédez à Mes commandes la page

2. Cliquez sur votre commande

3. Trouvez le http_pub URL (par ex., abc123.clorecloud.net)

Utilisez https://YOUR_HTTP_PUB_URL au lieu de localhost dans les exemples ci-dessous.

Script SVD

import torch
from diffusers import StableVideoDiffusionPipeline
from PIL import Image
import imageio

# Charger le modèle
pipe = StableVideoDiffusionPipeline.from_pretrained(
    "stabilityai/stable-video-diffusion-img2vid-xt",
    torch_dtype=torch.float16,
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

# Charger et redimensionner l'image
image = Image.open("input.png").resize((1024, 576))

# Générer la vidéo
frames = pipe(
    image,
    decode_chunk_size=8,
    num_frames=25,
    motion_bucket_id=127,
    noise_aug_strength=0.02
).frames[0]

# Enregistrer en GIF
imageio.mimsave("output.gif", frames, fps=6)

# Enregistrer en MP4
imageio.mimsave("output.mp4", frames, fps=6)

SVD avec interface Gradio

import gradio as gr
import torch
from diffusers import StableVideoDiffusionPipeline
from PIL import Image
import imageio
import tempfile

pipe = StableVideoDiffusionPipeline.from_pretrained(
    "stabilityai/stable-video-diffusion-img2vid-xt",
    torch_dtype=torch.float16,
)
pipe.enable_model_cpu_offload()

def generate_video(image, motion_bucket, fps, num_frames):
    image = image.resize((1024, 576))

    frames = pipe(
        image,
        decode_chunk_size=4,
        num_frames=num_frames,
        motion_bucket_id=motion_bucket,
    ).frames[0]

    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as f:
        imageio.mimsave(f.name, frames, fps=fps)
        return f.name

demo = gr.Interface(
    fn=generate_video,
    inputs=[
        gr.Image(type="pil", label="Image d’entrée"),
        gr.Slider(1, 255, value=127, label="Quantité de mouvement"),
        gr.Slider(1, 30, value=6, label="FPS"),
        gr.Slider(14, 25, value=25, label="Images")
    ],
    outputs=gr.Video(label="Vidéo générée"),
)

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

AnimateDiff

Installation

pip install diffusers transformers accelerate

Générer une vidéo à partir de texte

import torch
from diffusers import AnimateDiffPipeline, MotionAdapter, DDIMScheduler
import imageio

# Charger le module d'adaptation du mouvement
adapter = MotionAdapter.from_pretrained("guoyww/animatediff-motion-adapter-v1-5-2")

# Charger le pipeline
pipe = AnimateDiffPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    motion_adapter=adapter,
    torch_dtype=torch.float16,
)
pipe.scheduler = DDIMScheduler.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    subfolder="scheduler",
    clip_sample=False,
    timestep_spacing="linspace",
    beta_schedule="linear",
    steps_offset=1,
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

# Générer
output = pipe(
    prompt="Un chat marchant dans un jardin, de belles fleurs, une journée ensoleillée",
    negative_prompt="mauvaise qualité, flou",
    num_frames=16,
    guidance_scale=7.5,
    num_inference_steps=25,
)

# Enregistrer
frames = output.frames[0]
imageio.mimsave("animatediff.gif", frames, fps=8)

AnimateDiff avec modèle personnalisé

from diffusers import AnimateDiffPipeline, MotionAdapter, EulerDiscreteScheduler

adapter = MotionAdapter.from_pretrained("guoyww/animatediff-motion-adapter-v1-5-2")

# Utiliser un checkpoint personnalisé (par exemple, RealisticVision)
pipe = AnimateDiffPipeline.from_pretrained(
    "SG161222/Realistic_Vision_V5.1_noVAE",
    motion_adapter=adapter,
    torch_dtype=torch.float16,
)

AnimateDiff dans ComfyUI

Installer les nœuds

cd /workspace/ComfyUI/custom_nodes
git clone https://github.com/Kosinkadink/ComfyUI-AnimateDiff-Evolved.git
git clone https://github.com/Kosinkadink/ComfyUI-VideoHelperSuite.git

Télécharger les modèles de mouvement

cd /workspace/ComfyUI/custom_nodes/ComfyUI-AnimateDiff-Evolved/models
wget https://huggingface.co/guoyww/animatediff/resolve/main/mm_sd_v15_v2.ckpt

CogVideoX

Texte vers vidéo

import torch
from diffusers import CogVideoXPipeline
import imageio

pipe = CogVideoXPipeline.from_pretrained(
    "THUDM/CogVideoX-2b",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

prompt = "Un drone survolant un magnifique paysage montagneux au coucher du soleil"

video = pipe(
    prompt=prompt,
    num_videos_per_prompt=1,
    num_inference_steps=50,
    num_frames=49,
    guidance_scale=6,
).frames[0]

imageio.mimsave("cogvideo.mp4", video, fps=8)

Mise à l'échelle vidéo

Real-ESRGAN pour la vidéo

import cv2
import torch
from basicsr.archs.rrdbnet_arch import RRDBNet
from realesrgan import RealESRGANer

model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32, scale=4)
upsampler = RealESRGANer(
    scale=4,
    model_path='RealESRGAN_x4plus.pth',
    model=model,
    tile=400,
    tile_pad=10,
    pre_pad=0,
    half=True
)

# Traiter la vidéo image par image
cap = cv2.VideoCapture("input.mp4")

# ... mettre à l'échelle chaque image

Interpolation (vidéos fluides)

Interpolation d'images FILM

# Installation
pip install tensorflow tensorflow_hub

import tensorflow as tf
import tensorflow_hub as hub

model = hub.load("https://tfhub.dev/google/film/1")

def interpolate(frame1, frame2, num_interpolations=3):
    # Renvoie les images interpolées entre frame1 et frame2
    ...

RIFE (temps réel)

pip install rife-ncnn-vulkan-python

from rife_ncnn_vulkan import Rife
rife = Rife(gpu_id=0)

# Interpoler les images

Génération de vidéos par lot

prompts = [
    "Une fusée décollant dans l'espace",
    "Des vagues de l'océan se brisant sur des rochers",
    "Un papillon volant parmi les fleurs",
]

for i, prompt in enumerate(prompts):
    print(f"Generating {i+1}/{len(prompts)}")
    output = pipe(prompt, num_frames=16)
    imageio.mimsave(f"video_{i:03d}.mp4", output.frames[0], fps=8)

Conseils mémoire

Pour une VRAM limitée

# Activer le déchargement sur le CPU
pipe.enable_model_cpu_offload()

# Activer le découpage du VAE
pipe.enable_vae_slicing()

# Activer le découpage de l'attention
pipe.enable_attention_slicing()

# Réduire le nombre d'images
num_frames = 14  # Au lieu de 25

Décodage par blocs

frames = pipe(
    image,
    decode_chunk_size=2,  # Décoder 2 images à la fois
    num_frames=25,
).frames[0]

Conversion de la sortie

GIF en MP4

ffmpeg -i input.gif -movflags faststart -pix_fmt yuv420p -vf "scale=trunc(iw/2)*2:trunc(ih/2)*2" output.mp4

Suite d'images en vidéo

ffmpeg -framerate 8 -i frame_%04d.png -c:v libx264 -pix_fmt yuv420p output.mp4

Ajouter de l'audio

ffmpeg -i video.mp4 -i audio.mp3 -c:v copy -c:a aac -shortest output_with_audio.mp4

Performances

Modèle	GPU	Images	Temps
SVD-XT	RTX 3090	25	~120s
SVD-XT	RTX 4090	25	~80s
SVD-XT	A100	25	~50s
AnimateDiff	RTX 3090	16	~30s
CogVideoX	A100	49	~180s

Estimation des coûts

Tarifs typiques du marché CLORE.AI (en 2024) :

GPU	Tarif horaire	Tarif journalier	Session de 4 heures
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 40 Go	~$0.17	~$4.00	~$0.70
A100 80 Go	~$0.25	~$6.00	~$1.00

Les prix varient selon le fournisseur et la demande. Vérifiez la place de marché CLORE.AI les tarifs actuels.

Économisez de l'argent :

• Utilisez le Spot marché pour les travaux interrompables — environ un tiers des serveurs ont un prix spot inférieur au tarif à la demande (médiane ~13 % de remise), les autres s'alignent dessus

• Payez avec CLORE jetons

• Comparez les prix entre différents fournisseurs

Dépannage

Erreur OOM

• Réduire num_frames

• Activer le déchargement CPU

• Utiliser un decode_chunk_size plus petit

Vidéo scintillante

• Augmenter num_inference_steps

• Essayer un autre motion_bucket_id

• Utiliser l'interpolation d'images

Qualité médiocre

• Utiliser une entrée à plus haute résolution (SVD)

• De meilleurs prompts (AnimateDiff)

• Augmenter guidance_scale