Nodo ComfyUI WanFunControlToVideo

Este nodo se ha añadido para soportar el modelo Wan Fun Control en video, introducido después de este commit.

• Propósito: Preparar la información condicional necesaria para generar videos utilizando el modelo Wan 2.1 Fun Control.

El nodo WanFunControlToVideo es una adición de ComfyUI para soportar el modelo Wan Fun Control en video, diseñado para aprovechar el control WanFun en la generación de videos.

Este nodo actúa como el punto central para preparar la información condicional necesaria e inicializar el espacio latente, guiando el proceso de generación de video utilizando el modelo Wan 2.1 Fun. El nombre del nodo indica claramente su función: acepta diversas entradas y las convierte en un formato adecuado para controlar la generación de video dentro del marco WanFun.

La posición del nodo en la jerarquía de nodos de ComfyUI indica que opera en las primeras etapas del pipeline de generación de video, enfocándose en manipular las señales condicionales antes de la muestreo o decodificación real de los fotogramas de video.

Análisis detallado del nodo WanFunControlToVideo

Parámetros de entrada

Parámetros de salida

Ejemplo de flujo de trabajo del nodo

Visite Ejemplo de flujo de trabajo del nodo Wan Fun Control para conocer cómo ComfyUI soporta nativamente el modelo Wan Fun Control.

Código fuente del nodo

Código fuente del nodo, versión del código 3661c833bcc41b788a7c9f0e7bc48524f8ee5f82

class WanFunControlToVideo:
    @classmethod
    def INPUT_TYPES(s):
        return {"required": {"positive": ("CONDITIONING", ),
                             "negative": ("CONDITIONING", ),
                             "vae": ("VAE", ),
                             "width": ("INT", {"default": 832, "min": 16, "max": nodes.MAX_RESOLUTION, "step": 16}),
                             "height": ("INT", {"default": 480, "min": 16, "max": nodes.MAX_RESOLUTION, "step": 16}),
                             "length": ("INT", {"default": 81, "min": 1, "max": nodes.MAX_RESOLUTION, "step": 4}),
                             "batch_size": ("INT", {"default": 1, "min": 1, "max": 4096}),
                },
                "optional": {"clip_vision_output": ("CLIP_VISION_OUTPUT", ),
                             "start_image": ("IMAGE", ),
                             "control_video": ("IMAGE", ),
                }}
 
    RETURN_TYPES = ("CONDITIONING", "CONDITIONING", "LATENT")
    RETURN_NAMES = ("positive", "negative", "latent")
    FUNCTION = "encode"
 
    CATEGORY = "conditioning/video_models"
 
    def encode(self, positive, negative, vae, width, height, length, batch_size, start_image=None, clip_vision_output=None, control_video=None):
        latent = torch.zeros([batch_size, 16, ((length - 1) // 4) + 1, height // 8, width // 8], device=comfy.model_management.intermediate_device())
        concat_latent = torch.zeros([batch_size, 16, ((length - 1) // 4) + 1, height // 8, width // 8], device=comfy.model_management.intermediate_device())
        concat_latent = comfy.latent_formats.Wan21().process_out(concat_latent)
        concat_latent = concat_latent.repeat(1, 2, 1, 1, 1)
 
        if start_image is not None:
            start_image = comfy.utils.common_upscale(start_image[:length].movedim(-1, 1), width, height, "bilinear", "center").movedim(1, -1)
            concat_latent_image = vae.encode(start_image[:, :, :, :3])
            concat_latent[:,16:,:concat_latent_image.shape[2]] = concat_latent_image[:,:,:concat_latent.shape[2]]
 
        if control_video is not None:
            control_video = comfy.utils.common_upscale(control_video[:length].movedim(-1, 1), width, height, "bilinear", "center").movedim(1, -1)
            concat_latent_image = vae.encode(control_video[:, :, :, :3])
            concat_latent[:,:16,:concat_latent_image.shape[2]] = concat_latent_image[:,:,:concat_latent.shape[2]]
 
        positive = node_helpers.conditioning_set_values(positive, {"concat_latent_image": concat_latent})
        negative = node_helpers.conditioning_set_values(negative, {"concat_latent_image": concat_latent})
 
        if clip_vision_output is not None:
            positive = node_helpers.conditioning_set_values(positive, {"clip_vision_output": clip_vision_output})
            negative = node_helpers.conditioning_set_values(negative, {"clip_vision_output": clip_vision_output})
 
        out_latent = {}
        out_latent["samples"] = latent
        return (positive, negative, out_latent)

Análisis de la función encode

La función encode en el nodo WanFunControlToVideo es responsable de convertir los parámetros de entrada en información condicional y espacio latente, que se utilizarán para el modelo de generación de video posterior.

La función primero inicializa un tensor latente vacío llamado latent, con una forma específica: [batch_size, 16, ((length - 1) // 4) + 1, height // 8, width // 8]. Este tensor se coloca en comfy.model_management.intermediate_device(), que generalmente es una GPU disponible. A continuación, se inicializa otro tensor latente llamado concat_latent con la misma forma que latent, para almacenar la información codificada de las entradas opcionales start_image y control_video.

Después de procesar las entradas visuales opcionales, el tensor concat_latent ahora contiene la información codificada de start_image y control_video (si se proporciona), y se utiliza la función node_helpers.conditioning_set_values para agregarla a la información condicional positiva y negativa bajo la clave “concat_latent_image”.

Finalmente, la función verifica si se ha proporcionado clip_vision_output. Si se proporciona, también se agrega a las condiciones positivas y negativas bajo la clave “clip_vision_output”. Esto permite que las características visuales extraídas por el modelo CLIP refinen aún más el proceso de generación.

Otras consideraciones sobre Wan Fun Control

WanFun Control se utiliza principalmente en la serie de modelos Wan 2.1. Este método se inspira en ControlNet, una técnica poderosa ampliamente utilizada en la generación de imágenes, que ajusta la salida a través de diversas entradas espaciales y estructurales. WanFun Control extiende estos principios al dominio temporal del video, permitiendo a los usuarios tener un alto grado de influencia sobre el contenido del video generado, superando las limitaciones de los métodos impulsados únicamente por texto. Utiliza información visual extraída de videos de entrada (como mapas de profundidad, contornos de bordes (Canny) o poses humanas (OpenPose)) para facilitar la creación de videos controlados.

La serie de modelos Wan 2.1 es la base de WanFun Control, ofreciendo diferentes variantes de parámetros, incluidos los modelos 1.3B y 14B, lo que permite a los usuarios equilibrar los recursos computacionales con la calidad y complejidad de salida deseadas.

El concepto básico de WanFun Control es utilizar pistas visuales de videos de referencia para guiar el proceso creativo de la IA. Los usuarios pueden proporcionar un “video de control” que refleja el movimiento o la disposición espacial deseada, en lugar de depender únicamente de indicaciones textuales para determinar el movimiento, la estructura y el estilo del video generado. Esto permite crear videos con características específicas de manera más directa e intuitiva. Por ejemplo, un usuario puede proporcionar un video de una persona caminando, y el sistema de control WanFun generará un nuevo video con un sujeto diferente realizando la misma acción de caminar, mientras sigue la descripción del aspecto del sujeto y la escena general en las indicaciones textuales. Este enfoque estructurado de generación de video, que combina datos visuales con descripciones textuales, resulta en salidas con mayor precisión de movimiento, efectos estilísticos mejorados y la capacidad de lograr transformaciones visuales más intencionadas.

Modelos y repositorios de código relacionados

• Wan-Video/Wan2.1: modelo de generación de video a gran escala, abierto y avanzado
• Wan2.1-Fun-1.3B-Control
• Wan2.1-Fun-14B-Control
• VideoX-Fun