Accélérer la génération vidéo Wan2.1 avec DeepGPU - Container Compute Service

Les ressources de calcul de Container Compute Service (ACS) vous permettent de démarrer immédiatement, sans connaissance approfondie du matériel sous-jacent ni gestion des nœuds GPU. Facile à déployer et compatible avec le paiement à l'utilisation, ACS constitue une solution idéale pour l'inférence rentable de grands modèles de langage (LLM). Cette rubrique explique comment utiliser les ressources de calcul GPU d'ACS avec le plugin deepgpu-comfyui pour accélérer la génération vidéo Wan2.1.

Informations générales

ComfyUI

ComfyUI est une interface graphique (GUI) nodale permettant d'exécuter et de personnaliser Stable Diffusion, un modèle populaire de conversion texte-image. Son workflow visuel permet de construire des pipelines complexes de génération d'images par glisser-déposer de nœuds, sans écrire de code.

Modèle Wan

Wan (Tongyi Wanxiang) est un grand modèle d'art IA et de génération de contenu (AIGC) développé par le laboratoire Tongyi d'Alibaba. Il représente la branche de génération visuelle de la série de grands modèles Qianwen. Wan est le premier modèle d'art IA au monde à prendre en charge les invites en chinois. Doté de capacités multimodales, il génère des œuvres artistiques de haute qualité à partir de descriptions textuelles, d'esquisses dessinées à la main ou de transferts de style d'image.

Prérequis

Types de GPU pris en charge : L20 (GN8IS) et G49E.

Procédure

Étape 1 : Préparer les données du modèle

Créez un volume NAS ou OSS pour stocker les fichiers de modèle de manière persistante. Les étapes suivantes prennent un volume NAS comme exemple.

Pour plus d'informations sur la création d'un volume persistant, consultez Créer un système de fichiers NAS en tant que volume ou Utiliser un volume OSS provisionné statiquement .

Exécutez la commande suivante pour télécharger ComfyUI.

Assurez-vous que Git est installé dans votre environnement.
```
git clone https://github.com/comfyanonymous/ComfyUI.git
```

Exécutez les commandes ci-dessous pour télécharger les trois fichiers de modèle requis dans leurs répertoires correspondants sous ComfyUI. Pour plus d'informations sur les modèles, reportez-vous au projet Wan_2.1_ComfyUI_repackaged.

Pour garantir un téléchargement fluide, augmentez si nécessaire votre bande passante publique maximale. Le téléchargement dure environ 30 minutes.

Fichier wan2.1_t2v_14B_fp16.safetensors

cd ComfyUI/models/diffusion_models
wget https://modelscope.cn/models/Comfy-Org/Wan_2.1_ComfyUI_repackaged/resolve/master/split_files/diffusion_models/wan2.1_t2v_14B_fp16.safetensors

Fichier wan_2.1_vae.safetensors

cd ComfyUI/models/vae
wget https://modelscope.cn/models/Comfy-Org/Wan_2.1_ComfyUI_repackaged/resolve/master/split_files/vae/wan_2.1_vae.safetensors

Fichier umt5_xxl_fp8_e4m3fn_scaled.safetensors

cd ComfyUI/models/text_encoders
wget https://modelscope.cn/models/Comfy-Org/Wan_2.1_ComfyUI_repackaged/resolve/master/split_files/text_encoders/umt5_xxl_fp8_e4m3fn_scaled.safetensors

Téléchargez et décompressez ComfyUI-deepgpu.

cd ComfyUI/custom_nodes
wget https://aiacc-inference-public-v2.oss-cn-hangzhou.aliyuncs.com/deepgpu/comfyui/nodes/20250513/ComfyUI-deepgpu.tar.gz
tar zxf ComfyUI-deepgpu.tar.gz

Étape 2 : Déployer le service ComfyUI

Connectez-vous à la console ACS. Dans le volet de navigation de gauche, cliquez sur Clusters, puis sur le nom du cluster cible. Toujours dans le volet de navigation de gauche, choisissez Workloads > Deployments, puis cliquez sur Create from YAML dans le coin supérieur droit.

Cet exemple utilise un volume NAS monté. Copiez le modèle YAML suivant et cliquez sur Create.

Modifiez la valeur persistentVolumeClaim.claimName pour qu'elle corresponde au nom de votre demande de volume persistant (PVC).

Cet exemple utilise l'image inference-nv-pytorch 25.07 de la région Chine (Pékin) ( cn-beijing ) afin de réduire les temps de récupération d'image. Pour utiliser une image privée d'une autre région, ajustez le chemin de l'image dans le fichier YAML conformément aux instructions d' Utilisation .

L'image de conteneur de test utilisée dans cet exemple contient les plugins deepgpu-torch et deepgpu-comfyui préinstallés. Pour utiliser ces plugins dans d'autres environnements de conteneurs, contactez un architecte de solutions avant-vente (PDSA) afin d'obtenir les packages d'installation.

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: wanx-deployment
  name: wanx-deployment-test
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      app: wanx-deployment
  template:
    metadata:
      labels:
        alibabacloud.com/compute-class: gpu
        alibabacloud.com/compute-qos: default
        alibabacloud.com/gpu-model-series: L20 # Supported GPU types: L20 (GN8IS) and G49E
        app: wanx-deployment
    spec:
      containers:
      - command:
        - sh
        - -c
        - DEEPGPU_PUB_LS=true python3 /mnt/ComfyUI/main.py --listen 0.0.0.0 --port 7860
        image: acs-registry-vpc.cn-beijing.cr.aliyuncs.com/egslingjun/inference-nv-pytorch:25.07-vllm0.9.2-pytorch2.7-cu128-20250714-serverless
        imagePullPolicy: Always
        name: main
        resources:
          limits:
            nvidia.com/gpu: "1"
            cpu: "16"
            memory: 64Gi
          requests:
            nvidia.com/gpu: "1"
            cpu: "16"
            memory: 64Gi
        terminationMessagePath: /dev/termination-log
        terminationMessagePolicy: File
        volumeMounts:
        - mountPath: /dev/shm
          name: cache-volume
        - mountPath: /mnt # /mnt is the path in the pod where the NAS volume claim is mapped
          name: data
      dnsPolicy: ClusterFirst
      restartPolicy: Always
      schedulerName: default-scheduler
      securityContext: {}
      terminationGracePeriodSeconds: 30
      volumes:
      - emptyDir:
          medium: Memory
          sizeLimit: 500G
        name: cache-volume
      - name: data
        persistentVolumeClaim:
          claimName: wanx-nas # wanx-nas is the volume claim created from the NAS volume
---
apiVersion: v1
kind: Service
metadata:
  name: wanx-test
spec:
  type: LoadBalancer
  ports:
    - port: 7860
      protocol: TCP
      targetPort: 7860
  selector:
    app: wanx-deployment

Dans la boîte de dialogue qui s'affiche, cliquez sur View pour accéder à la page de détails de la charge de travail. Cliquez ensuite sur l'onglet Logs. Si la sortie suivante s'affiche, le service a démarré avec succès.

Device: cuda:0 NVIDIA L20 : cudaMallocAsync
Using pytorch attention
Python version: 3.12.7+gc (main, Jan 10 2025, 17:28:43) [GCC 13.3.0]
ComfyUI version: 0.3.45
****** User settings have been changed to be stored on the server instead of browser storage. ******
****** For multi-user setups add the --multi-user CLI argument to enable multiple user profiles. ******
ComfyUI frontend version: 1.23.4
[Prompt Server] web root: /opt/ac2/lib/python3.12/site-packages/comfyui_frontend_package/static
generated new fontManager
Import times for custom nodes:
   0.0 seconds: /mnt/ComfyUI/custom_nodes/websocket_image_save.py
  57.2 seconds: /mnt/ComfyUI/custom_nodes/ComfyUI-deepgpu
Context impl SQLiteImpl.
Will assume non-transactional DDL.
No target revision found.
Starting server
To see the GUI go to: http://0.0.0.0:7860

Étape 3 : Utiliser le plugin

Cliquez sur l'onglet Access Method pour obtenir l'External Endpoint du service, par exemple 8.xxx.xxx.114:7860.
Accédez à l'URL ComfyUI http://8.xxx.xxx.114:7860/ depuis votre navigateur. Dans l'interface ComfyUI, effectuez un clic droit, puis cliquez sur Add Node. Le plugin contient alors des nœuds de type DeepGPU.

Lors du premier accès à l'URL, le chargement peut prendre jusqu'à 5 minutes.

La catégorie DeepGPU comprend cinq nœuds : Apply DeepyTorch to diffusion model, Apply DeepyTorch to vae model, DeepyTorch Sampler to replace XlabsSampler, Save Image BASE64 of DeepGPU et Apply Pulid Flux of DeepGPU.
Nœud ApplyDeepyTorch
Le nœud ApplyDeepyTorch optimise les performances d'inférence du modèle. Insérez-le généralement après le dernier nœud de traitement de modèle du workflow, par exemple après Load Diffusion Model, Load Checkpoint ou LoraLoaderModelOnly. Les types de nœuds ApplyDeepyTorch sont les suivants :
```
from deepgpu_comfyui.node import \
    ApplyDeepyTorch, \
    ApplyDeepyTorchVae, \
    DeepyTorchSampler, \
    DeepSaveImageBase64, \
    ApplyPulidFluxDeepyTorch
NODE_CLASS_MAPPINGS = {
    "ApplyDeepyTorch": ApplyDeepyTorch,
    "ApplyDeepyTorchVae": ApplyDeepyTorchVae,
    "DeepyTorchSampler": DeepyTorchSampler,
    "DeepSaveImageBase64": DeepSaveImageBase64,
    "ApplyPulidFluxDeepyTorch": ApplyPulidFluxDeepyTorch,
}
NODE_DISPLAY_NAME_MAPPINGS = {
    "ApplyDeepyTorch": "Apply DeepyTorch to diffusion model",
    "ApplyDeepyTorchVae": "Apply DeepyTorch to vae model",
    "DeepyTorchSampler": "DeepyTorch Sampler to replace XlabsSampler",
    "DeepSaveImageBase64": "Save Image BASE64 of DeepGPU",
    "ApplyPulidFluxDeepyTorch": "Apply Pulid Flux of DeepGPU",
}
```

Étape 4 : Tester le workflow d'exemple

Téléchargez le fichier de workflow wan2.1 accéléré par DeepyTorch.

Workflow image-vers-vidéo

https://aiacc-inference-public-v2.oss-cn-hangzhou.aliyuncs.com/deepgpu/comfyui/wan/workflows/workflow_image_to_video_wan_1.3b_deepytorch.json

Workflow texte-vers-vidéo

https://aiacc-inference-public-v2.oss-cn-hangzhou.aliyuncs.com/deepgpu/comfyui/wan/workflows/workflow_text_to_video_wan_deepytorch.json

Cet exemple utilise le workflow texte-vers-vidéo accéléré. Dans ComfyUI, choisissez Workflow > Open, puis sélectionnez le fichier workflow_text_to_video_wan_deepytorch.json téléchargé.
Une fois le fichier de workflow ouvert, définissez Apply DeepyTorch to diffusion model > enable sur true pour activer l'accélération. Cliquez ensuite sur Run et attendez la génération de la vidéo.

Le workflow accéléré par DeepyTorch insère un nœud ApplyDeepyTorch après le nœud Load Diffusion Model.

Ce workflow d'exemple inclut les configurations de nœuds clés suivantes : le UNet Loader utilise le modèle wan2.1_t2v_14B_fp16.safetensors avec le type de données défini sur default ; le nœud Load CLIP utilise umt5_xxl_fp8_e4m3fn_scaled.safetensors avec le type défini sur wan ; le K-Sampler présente les paramètres steps réglés à 20, cfg à 6,0, sampler à uni_pc, scheduler à simple et denoising à 1,00 ; le nœud Load VAE utilise wan_2.1_vae.safetensors ; le nœud Empty Latent Video (Hunyuan) a width réglé à 832, height à 480, length à 81 et batch size à 1. Enfin, le paramètre dynamic du nœud Apply DeepyTorch to diffusion model est défini sur auto.
Cliquez sur le bouton Queue pour consulter le temps de génération vidéo et prévisualiser la vidéo.

La première exécution de test peut être plus longue. Exécutez le workflow deux ou trois fois supplémentaires pour obtenir des performances optimales.

Le panneau de file d'attente affiche les vignettes de trois clips vidéo générés, chacun nécessitant environ 630 secondes de génération. Des liens relient les nœuds pour transmettre les données tout au long du workflow. Le canevas principal présente l'ensemble des nœuds du workflow texte-vers-vidéo : UNet Loader (modèle : wan2.1_t2v_14B_fp16.safetensors, type de données : default), les nœuds CLIP Text Encode pour les invites positives et négatives, K-Sampler (steps : 20, cfg : 6,0, sampler : uni_pc, scheduler : simple, denoising : 1,00), Load VAE (wan_2.1_vae.safetensors), Empty Latent Video (Hunyuan) (width : 832, height : 480, length : 81, batch size : 1) et Apply DeepyTorch to diffusion model (enable : true, dynamic : auto).
(Facultatif) Pour tester le scénario non accéléré, redémarrez le service ComfyUI et utilisez le workflow suivant pour générer la vidéo.
```
https://aiacc-inference-public-v2.oss-cn-hangzhou.aliyuncs.com/deepgpu/comfyui/wan/workflows/workflow_text_to_video_wan.json
```