Vidéo (expérimental)#

Apprenez à utiliser Xinference pour générer des vidéos

Introduction#

L’API Video fournit un moyen d’interagir avec la vidéo :

Le point de terminaison texte-vers-vidéo crée une vidéo à partir d’une invite textuelle, en partant de zéro.
Le point de terminaison Image-to-video crée une vidéo à partir d’une image depuis le début.
L’interface firstlastframe-to-video génère une vidéo basée sur la transition entre la première et la dernière image.

API	Endpoint
Text-to-Video API	/v1/video/generations
Image-to-Video API	/v1/video/generations/image
FirstLastFrame-to-Video API	/v1/video/generations/flf

Liste des modèles supportés#

L’API texte-vers-vidéo dans Xinference prend en charge les modèles suivants :

Dans Xinference, l’API image-vers-vidéo prend en charge les modèles suivants :

Les modèles suivants dans Xinference prennent en charge l’interface firstlastframe-to-video :

Wan2.1-flf2v-14B-720p

Démarrage rapide#

vidéo généré à partir de texte#

Vous pouvez essayer l’API text-to-video via cURL ou Xinference.

curl -X 'POST' \
  'http://<XINFERENCE_HOST>:<XINFERENCE_PORT>/v1/video/generations' \
  -H 'accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "<MODEL_UID>",
    "prompt": "<your prompt>"
  }'

from xinference.client import Client

client = Client("http://<XINFERENCE_HOST>:<XINFERENCE_PORT>")

model = client.get_model("<MODEL_UID>")
input_text = "an apple"
model.text_to_video(input_text)

Générer une vidéo à partir d’une image#

Vous pouvez essayer d’utiliser l’API image-to-video via cURL ou Xinference.

curl -X 'POST' \
  'http://<XINFERENCE_HOST>:<XINFERENCE_PORT>/v1/video/generations/image' \
  -F model=<MODEL_UID> \
  -F image=@xxx.jpg \
  -F prompt=<prompt>

from xinference.client import Client

client = Client("http://<XINFERENCE_HOST>:<XINFERENCE_PORT>")

model = client.get_model("<MODEL_UID>")
with open("xxx.jpg", "rb") as f:
    prompt = ""
    model.image_to_video(image=f.read(), prompt=prompt)

Vidéo générée à partir des première et dernière images#

Vous pouvez tester l’interface firstlastframe-to-video via cURL ou le client Python de Xinference :

curl -X 'POST' \
  'http://<XINFERENCE_HOST>:<XINFERENCE_PORT>/v1/video/generations/flf' \
  -F model=<MODEL_UID> \
  -F first_frame=@xxx.jpg \
  -F last_frame=@xxx2.jpg \
  -F prompt=<prompt>

from xinference.client import Client

client = Client("http://<XINFERENCE_HOST>:<XINFERENCE_PORT>")

model = client.get_model("<MODEL_UID>")
with open("xxx.jpg", "rb") as f1, open("xxx2.jpg", "rb") as f2:
    prompt = ""
    model.flf_to_video(first_frame=f1.read(), last_frame=f2.read(), prompt=prompt)

Optimisation de la mémoire#

La génération de vidéos consomme une grande quantité de mémoire vidéo. Par exemple, l’exécution de CogVideoX peut utiliser environ 35 Go de mémoire vidéo.

Xinference prend en charge plusieurs options pour optimiser l’utilisation de la mémoire vidéo (VRAM).

Déchargement CPU ou déchargement groupé au niveau bloc.
Conversion de type par couches (Layerwise casting).

Note

Le déchargement CPU et le déchargement groupé au niveau des blocs ne peuvent pas être activés simultanément, mais la conversion de type couche par couche peut être utilisée en combinaison avec l’un d’eux.

Déchargement du CPU#

Le déchargement CPU conserve les poids du modèle sur le CPU, ne les chargeant sur le GPU que lors de l’exécution de la propagation avant. Il convient aux scénarios où la mémoire vidéo est extrêmement limitée, mais a un impact significatif sur les performances.

Lorsque vous utilisez un GPU avec moins de 24 Go de mémoire vidéo, il est recommandé d’ajouter --cpu_offload True lors du démarrage du modèle. Pour l’interface Web UI, vous pouvez ajouter l’option supplémentaire cpu_offload, en définissant sa valeur sur True.

xinference launch --model-name Wan2.1-i2v-14B-480p --model-type video --cpu_offload True

Déchargement de regroupement au niveau des blocs#

Le déchargement par groupe de niveau bloc regroupe plusieurs couches internes du modèle (telles que torch.nn.ModuleList ou torch.nn.Sequential) et charge ces groupes du CPU vers le GPU selon les besoins pendant l’inférence. Par rapport au déchargement CPU, il utilise plus de mémoire mais a un impact moindre sur les performances.

Pour la ligne de commande, ajoutez l’option --group_offload True ; pour l’interface Web UI, ajoutez une option supplémentaire group_offload, définie à True.

En activant les flux CUDA, nous pouvons accélérer l’inférence par déchargement groupé. Cependant, l’utilisation des flux CUDA nécessite de déplacer les paramètres du modèle vers la mémoire fixe. Cette allocation est gérée en arrière-plan par Pytorch et peut entraîner une augmentation significative de l’utilisation de la RAM CPU. Si votre RAM CPU est au moins deux fois la taille du modèle, envisagez d’utiliser cette option. Activez les flux CUDA en ajoutant --use_stream True dans la ligne de commande ; pour l’interface Web, ajoutez une option supplémentaire use_stream avec la valeur True.

xinference launch --model-name Wan2.1-i2v-14B-480p --model-type video --group_offload True --use_stream True

Appliquer la conversion de type couche par couche au Transformer#

La conversion par couches abaisse les poids de chaque couche en torch.float8_e4m3fn, les élève temporairement en torch.bfloat16 pendant la propagation avant de la couche, puis les rétablit en torch.float8_e4m3fn par la suite. Cette approche réduit les besoins en mémoire d’environ 50 %, bien que la qualité vidéo produite soit légèrement dégradée en raison du compromis sur la précision. Pour activer la conversion par couches, ajoutez --layerwise_cast True dans la ligne de commande ; pour l’interface Web, ajoutez une option supplémentaire layerwise_cast avec la valeur définie sur True.

Cet exemple nécessitera 20 Go de mémoire vidéo.

xinference launch --model-name Wan2.1-i2v-14B-480p --model-type video --layerwise_cast True --cpu_offload True