Container Compute Service:Accelerate Wan2.1 video generation with DeepGPU

ComfyUI

ComfyUI es una interfaz gráfica de usuario (GUI) basada en nodos para ejecutar y personalizar Stable Diffusion, un modelo popular de texto a imagen. Utiliza un flujo de trabajo visual que permite construir canalizaciones complejas de generación de imágenes mediante arrastrar y soltar nodos, sin escribir código.

Modelo Wan

Wan (Tongyi Wanxiang) es un modelo grande de arte con IA y de texto a imagen (AIGC) desarrollado por Tongyi Lab de Alibaba. Constituye la rama de generación visual de la serie de modelos grandes Qianwen. Wan es el primer modelo de arte con IA del mundo compatible con indicaciones en chino. Cuenta con capacidades multimodales y genera obras de alta calidad a partir de descripciones de texto, bocetos dibujados a mano o transferencias de estilo de imagen.

Paso 1: Preparar los datos del modelo

Cree un volumen NAS u OSS para almacenar los archivos del modelo de forma persistente. A continuación se utiliza un volumen NAS como ejemplo.

Para obtener más información sobre cómo crear un volumen persistente, consulte Create a NAS file system as a volume o Use a statically provisioned OSS volume .

1. Ejecute el siguiente comando para descargar ComfyUI.

   Asegúrese de que Git esté instalado en su entorno.

   git clone https://github.com/comfyanonymous/ComfyUI.git

2. Ejecute los siguientes comandos para descargar los tres archivos de modelo obligatorios en sus directorios correspondientes dentro de ComfyUI. Para más información sobre los modelos, consulte el proyecto Wan_2.1_ComfyUI_repackaged.

   Para garantizar una descarga fluida, es posible que deba aumentar el ancho de banda público máximo. La descarga tarda aproximadamente 30 minutos.

   1. El archivo 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 

   2. El archivo 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

   3. El archivo 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

3. Descargue y descomprima 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

Paso 2: Desplegar el servicio ComfyUI

1. Inicie sesión en la consola de ACS. En el panel de navegación izquierdo, haga clic en Clusters. Haga clic en el nombre del clúster de destino. En el panel de navegación izquierdo, elija Workloads > Deployments y, a continuación, haga clic en Create from YAML en la esquina superior derecha.

2. Este ejemplo utiliza un volumen NAS montado. Copie la siguiente plantilla YAML y haga clic en Create.

   Modifique el valor de persistentVolumeClaim.claimName para que coincida con el nombre de su solicitud de volumen persistente (PVC).

   Este ejemplo utiliza la imagen inference-nv-pytorch 25.07 de la región China (Beijing) ( cn-beijing ) para minimizar los tiempos de extracción de la imagen. Si desea usar una imagen privada de otra región, ajuste la ruta de la imagen en el archivo YAML según Usage .

   La imagen de contenedor de prueba utilizada en este ejemplo tiene preinstalados los plugins deepgpu-torch y deepgpu-comfyui. Si necesita usar estos plugins en otros entornos de contenedores, comuníquese con un arquitecto de soluciones preventa (PDSA) para obtener los paquetes de instalación.

   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

3. En el cuadro de diálogo que aparece, haga clic en View para ir a la página de detalles de la carga de trabajo. Haga clic en la pestaña Logs. Si se muestra la siguiente salida, el servicio se inició correctamente.

   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

Paso 3: Usar el plugin

1. Haga clic en la pestaña Access Method para obtener el External Endpoint del servicio, por ejemplo, 8.xxx.xxx.114:7860.

2. Acceda a la URL de ComfyUI http://8.xxx.xxx.114:7860/ desde su navegador. En la interfaz de ComfyUI, haga clic derecho y luego haga clic en Add Node; verá que el plugin contiene nodos de tipo DeepGPU.

   La primera vez que acceda a la URL, la carga puede tardar hasta 5 minutos.

   La categoría DeepGPU contiene cinco nodos: Apply DeepyTorch to diffusion model, Apply DeepyTorch to vae model, DeepyTorch Sampler to replace XlabsSampler, Save Image BASE64 of DeepGPU y Apply Pulid Flux of DeepGPU.

   Nodo ApplyDeepyTorch

   El nodo ApplyDeepyTorch optimiza el rendimiento de la inference del modelo. En la mayoría de los casos, insértelo después del último nodo de procesamiento del modelo en el flujo de trabajo, por ejemplo, tras Load Diffusion Model, Load Checkpoint o LoraLoaderModelOnly. Los tipos de nodo ApplyDeepyTorch son los siguientes:

   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",
   }

Paso 4: Probar el flujo de trabajo de ejemplo

1. Descargue el archivo del flujo de trabajo wan2.1 acelerado con DeepyTorch.

   1. Flujo de trabajo de imagen a video

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

   2. Flujo de trabajo de texto a video

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

2. Este ejemplo utiliza el flujo de trabajo acelerado de texto a video. En ComfyUI, elija Workflow > Open y seleccione el archivo workflow_text_to_video_wan_deepytorch.json descargado.

3. Después de abrir el archivo del flujo de trabajo, establezca Apply DeepyTorch to diffusion model > enable en true. Esto habilita la aceleración. Luego, haga clic en Run y espere a que se genere el video.

   El flujo de trabajo acelerado con DeepyTorch inserta un nodo ApplyDeepyTorch después del nodo Load Diffusion Model.

   Este flujo de trabajo de ejemplo incluye las siguientes configuraciones clave de nodos: UNet Loader usa el modelo wan2.1_t2v_14B_fp16.safetensors con el tipo de datos establecido en default; el nodo Load CLIP usa umt5_xxl_fp8_e4m3fn_scaled.safetensors con el tipo definido en wan; en K-Sampler, steps se establece en 20, cfg en 6.0, sampler en uni_pc, scheduler en simple y denoising en 1.00; el nodo Load VAE usa wan_2.1_vae.safetensors; en el nodo Empty Latent Video (Hunyuan), width se establece en 832, height en 480, length en 81 y batch size en 1. La configuración dynamic del nodo Apply DeepyTorch to diffusion model se establece en auto.

4. Haga clic en el botón Queue para consultar el tiempo de generación del video y obtener una vista previa.

   La primera ejecución de prueba puede tardar más. Ejecute el flujo de trabajo dos o tres veces adicionales para obtener un rendimiento óptimo.

   El panel de la cola muestra miniaturas de tres clips de video generados, cada uno con un tiempo de generación aproximado de 630 segundos. Los enlaces conectan los nodos para pasar los datos a través del flujo de trabajo. El lienzo principal muestra todos los nodos del flujo de trabajo de texto a video: UNet Loader (modelo: wan2.1_t2v_14B_fp16.safetensors, tipo de datos: default), los nodos CLIP Text Encode para las indicaciones positivas y negativas, K-Sampler (pasos: 20, cfg: 6.0, sampler: uni_pc, scheduler: simple, denoising: 1.00), Load VAE (wan_2.1_vae.safetensors), Empty Latent Video (Hunyuan) (ancho: 832, alto: 480, longitud: 81, tamaño de lote: 1) y Apply DeepyTorch to diffusion model (enable: true, dynamic: auto).

5. (Opcional) Para probar el escenario sin aceleración, reinicie el servicio ComfyUI y utilice el siguiente flujo de trabajo para generar el video.

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