Génération vidéo IA

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

Générez des vidéos en utilisant Stable Video Diffusion, AnimateDiff et d'autres modèles.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

Location sur CLORE.AI

1. Visitez CLORE.AI Marketplace

2. Filtrer par type de GPU, VRAM et prix

3. Choisir À 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@<adresse-proxy>

Modèles disponibles

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

Stable Video Diffusion (SVD)

Déploiement rapide

Image Docker :

pytorch/pytorch:2.5.1-cuda12.4-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. Aller à la Mes commandes page

2. Cliquez sur votre commande

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

Utilisez https://VOTRE_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="Generated Video"),
)

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 l'adaptateur de 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, belles fleurs, 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 ex., 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)

Amélioration vidéo (upscaling)

Real-ESRGAN pour 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")

# ... améliorer chaque image

Interpolation (Vidéos fluides)

FILM Frame Interpolation

# Installer
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):
    # Retourne 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 par lot de vidéos

prompts = [
    "Un lanceur de fusée s'envolant dans l'espace",
    "Les vagues de l'océan s'écrasant sur les rochers",
    "Un papillon volant parmi les fleurs",
]

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

Astuces mémoire

Pour VRAM limitée

# Activer le déchargement vers 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 sortie

GIF vers MP4

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

Séquence d'images vers 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 (à partir de 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 40GB	~$0.17	~$4.00	~$0.70
A100 80GB	~$0.25	~$6.00	~$1.00

Les prix varient selon le fournisseur et la demande. Vérifiez CLORE.AI Marketplace pour les tarifs actuels.

Économisez de l'argent :

• Utilisez Spot market pour les charges de travail flexibles (souvent 30-50 % moins cher)

• Payer avec CLORE jetons

• Comparer les prix entre différents fournisseurs

Dépannage

Erreur OOM

• Réduire num_frames

• Activer le déchargement vers le CPU

• Utiliser un decode_chunk_size plus petit

Vidéo scintillante

• Augmenter num_inference_steps

• Essayer un motion_bucket_id différent

• Utiliser l'interpolation d'images

Mauvaise qualité

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

• Meilleurs prompts (AnimateDiff)

• Augmenter guidance_scale