InfiniteTalk: generación de video con lip sync impulsada por audio y soporte para videos largos

MeiGen-AI/InfiniteTalk es un proyecto de generación de video impulsada por audio. Su objetivo es sincronizar audio de entrada con un video o una imagen de una persona, generando un nuevo video en el que la forma de la boca, el movimiento de la cabeza, la postura corporal y las expresiones faciales sigan el audio.

No está planteado como una herramienta simple de sustitución de boca. El README describe InfiniteTalk como un framework para sparse-frame video dubbing. Puede preservar la identidad en escenarios video-to-video, soporta generación de videos largos y también puede crear videos hablados a partir de una sola imagen y audio en flujos image-to-video.

Capacidades Principales

Las capacidades clave de InfiniteTalk son claras:

Generación video-to-video impulsada por audio.
Generación image-to-video a partir de una imagen y audio.
Sincronización no solo de labios, sino también de cabeza, cuerpo y expresiones.
Generación de videos largos.
En comparación con MultiTalk, la descripción del proyecto destaca menos deformaciones en manos y cuerpo, además de mayor precisión en lip sync.

Este tipo de proyecto sirve para doblaje de entrevistas, videos de humanos digitales, sincronización labial localizada, redoblaje de videos largos y expresión de personajes virtuales. Es más una herramienta de investigación e ingeniería que una aplicación de escritorio ligera y lista para usar.

Instalación

A continuación se conserva el proceso de instalación del README oficial. Conviene preparar antes un entorno Linux con CUDA, Conda, Git, suficiente VRAM y bastante espacio en disco. El nombre del entorno en el README se mantiene como multitalk.

Primero clona el repositorio y entra en el directorio:

1
2


git clone https://github.com/MeiGen-AI/InfiniteTalk.git
cd InfiniteTalk

1. Crear un entorno conda e instalar PyTorch y xformers

1
2
3
4


conda create -n multitalk python=3.10
conda activate multitalk
pip install torch==2.4.1 torchvision==0.19.1 torchaudio==2.4.1 --index-url https://download.pytorch.org/whl/cu121
pip install -U xformers==0.0.28 --index-url https://download.pytorch.org/whl/cu121

Esto usa el wheel de PyTorch correspondiente a CUDA 12.1. Si tu CUDA, driver o plataforma son distintos, ajusta el comando según la guía oficial de instalación de PyTorch.

2. Instalar dependencias de Flash-Attn

1
2
3
4
5
6


pip install misaki[en]
pip install ninja
pip install psutil
pip install packaging
pip install wheel
pip install flash_attn==2.7.4.post1

flash_attn es sensible a las versiones de CUDA, la toolchain de compilación y PyTorch. Si este paso falla, revisa primero si CUDA, nvcc, GCC, Python y el wheel de PyTorch son compatibles entre sí.

3. Instalar otras dependencias

1
2


pip install -r requirements.txt
conda install -c conda-forge librosa

4. Instalar FFmpeg

Dentro del entorno Conda puedes usar:

1

conda install -c conda-forge ffmpeg

También puedes instalarlo a nivel del sistema. El README da este ejemplo con yum:

1

sudo yum install ffmpeg ffmpeg-devel

Preparación De Modelos

InfiniteTalk necesita tres tipos de modelos:

Modelo	Uso
`Wan2.1-I2V-14B-480P`	Modelo base
`chinese-wav2vec2-base`	Codificador de audio
`MeiGen-InfiniteTalk`	Pesos de condición de audio de InfiniteTalk

El README usa huggingface-cli para descargar los modelos. Los comandos oficiales son:

1
2
3
4


huggingface-cli download Wan-AI/Wan2.1-I2V-14B-480P --local-dir ./weights/Wan2.1-I2V-14B-480P
huggingface-cli download TencentGameMate/chinese-wav2vec2-base --local-dir ./weights/chinese-wav2vec2-base
huggingface-cli download TencentGameMate/chinese-wav2vec2-base model.safetensors --revision refs/pr/1 --local-dir ./weights/chinese-wav2vec2-base
huggingface-cli download MeiGen-AI/InfiniteTalk --local-dir ./weights/InfiniteTalk

Si el entorno actual no tiene huggingface-cli, instala primero Hugging Face Hub:

1

pip install -U huggingface_hub

Algunos modelos pueden requerir iniciar sesión en Hugging Face o aceptar las condiciones de uso en la página del modelo. Tras la descarga, la estructura de directorios debería contener aproximadamente:

1
2
3
4


weights/
  Wan2.1-I2V-14B-480P/
  chinese-wav2vec2-base/
  InfiniteTalk/

Parámetros De Ejecución Comunes

El README enumera algunos parámetros importantes:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


--mode streaming: long video generation.
--mode clip: generate short video with one chunk.
--use_teacache: run with TeaCache.
--size infinitetalk-480: generate 480P video.
--size infinitetalk-720: generate 720P video.
--use_apg: run with APG.
--teacache_thresh: A coefficient used for TeaCache acceleration
—-sample_text_guide_scale： When not using LoRA, the optimal value is 5. After applying LoRA, the recommended value is 1.
—-sample_audio_guide_scale： When not using LoRA, the optimal value is 4. After applying LoRA, the recommended value is 2.
—-sample_audio_guide_scale： When not using LoRA, the optimal value is 4. After applying LoRA, the recommended value is 2.
--max_frame_num: The max frame length of the generated video, the default is 40 seconds(1000 frames).

Aquí se conserva la escritura original del README. En uso real, ten en cuenta que algunos prefijos parecen guiones de ancho completo o no estándar. Antes de copiar comandos, conviene comprobar si deberían ser --sample_text_guide_scale y --sample_audio_guide_scale estándar.

Ejemplo De Inferencia Con Una Sola GPU

Ejemplo oficial con una sola GPU:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


python generate_infinitetalk.py \
    --ckpt_dir weights/Wan2.1-I2V-14B-480P \
    --wav2vec_dir 'weights/chinese-wav2vec2-base' \
    --infinitetalk_dir weights/InfiniteTalk/single/infinitetalk.safetensors \
    --input_json examples/single_example_image.json \
    --size infinitetalk-480 \
    --sample_steps 40 \
    --mode streaming \
    --motion_frame 9 \
    --save_file infinitetalk_res

Para ejecutar en 720P, cambia --size a infinitetalk-720:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


python generate_infinitetalk.py \
    --ckpt_dir weights/Wan2.1-I2V-14B-480P \
    --wav2vec_dir 'weights/chinese-wav2vec2-base' \
    --infinitetalk_dir weights/InfiniteTalk/single/infinitetalk.safetensors \
    --input_json examples/single_example_image.json \
    --size infinitetalk-720 \
    --sample_steps 40 \
    --mode streaming \
    --motion_frame 9 \
    --save_file infinitetalk_res_720p

Para modo de baja VRAM, añade --num_persistent_param_in_dit 0:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


python generate_infinitetalk.py \
    --ckpt_dir weights/Wan2.1-I2V-14B-480P \
    --wav2vec_dir 'weights/chinese-wav2vec2-base' \
    --infinitetalk_dir weights/InfiniteTalk/single/infinitetalk.safetensors \
    --input_json examples/single_example_image.json \
    --size infinitetalk-480 \
    --sample_steps 40 \
    --num_persistent_param_in_dit 0 \
    --mode streaming \
    --motion_frame 9 \
    --save_file infinitetalk_res_lowvram

Multi-GPU, Varias Personas Y Gradio

Ejemplo de inferencia multi-GPU:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


GPU_NUM=8
torchrun --nproc_per_node=$GPU_NUM --standalone generate_infinitetalk.py \
    --ckpt_dir weights/Wan2.1-I2V-14B-480P \
    --wav2vec_dir 'weights/chinese-wav2vec2-base' \
    --infinitetalk_dir weights/InfiniteTalk/single/infinitetalk.safetensors \
    --dit_fsdp --t5_fsdp \
    --ulysses_size=$GPU_NUM \
    --input_json examples/single_example_image.json \
    --size infinitetalk-480 \
    --sample_steps 40 \
    --mode streaming \
    --motion_frame 9 \
    --save_file infinitetalk_res_multigpu

Ejemplo de animación con varias personas:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


python generate_infinitetalk.py \
    --ckpt_dir weights/Wan2.1-I2V-14B-480P \
    --wav2vec_dir 'weights/chinese-wav2vec2-base' \
    --infinitetalk_dir weights/InfiniteTalk/multi/infinitetalk.safetensors \
    --input_json examples/multi_example_image.json \
    --size infinitetalk-480 \
    --sample_steps 40 \
    --num_persistent_param_in_dit 0 \
    --mode streaming \
    --motion_frame 9 \
    --save_file infinitetalk_res_multiperson

Ejemplo de Gradio con pesos de una sola persona:

1
2
3
4
5
6


python app.py \
    --ckpt_dir weights/Wan2.1-I2V-14B-480P \
    --wav2vec_dir 'weights/chinese-wav2vec2-base' \
    --infinitetalk_dir weights/InfiniteTalk/single/infinitetalk.safetensors \
    --num_persistent_param_in_dit 0 \
    --motion_frame 9

Ejemplo de Gradio con pesos de varias personas:

1
2
3
4
5
6


python app.py \
    --ckpt_dir weights/Wan2.1-I2V-14B-480P \
    --wav2vec_dir 'weights/chinese-wav2vec2-base' \
    --infinitetalk_dir weights/InfiniteTalk/multi/infinitetalk.safetensors \
    --num_persistent_param_in_dit 0 \
    --motion_frame 9

Aceleración E Inferencia Cuantizada

El README también proporciona un ejemplo con FusioniX o Lightx2v. FusioniX requiere 8 steps, mientras que lightx2v requiere solo 4 steps.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


python generate_infinitetalk.py \
    --ckpt_dir weights/Wan2.1-I2V-14B-480P \
    --wav2vec_dir 'weights/chinese-wav2vec2-base' \
    --infinitetalk_dir weights/InfiniteTalk/single/infinitetalk.safetensors \
    --lora_dir weights/Wan2.1_I2V_14B_FusionX_LoRA.safetensors \
    --input_json examples/single_example_image.json \
    --lora_scale 1.0 \
    --size infinitetalk-480 \
    --sample_text_guide_scale 1.0 \
    --sample_audio_guide_scale 2.0 \
    --sample_steps 8 \
    --mode streaming \
    --motion_frame 9 \
    --sample_shift 2 \
    --num_persistent_param_in_dit 0 \
    --save_file infinitetalk_res_lora

El modelo cuantizado solo soporta ejecución con una sola GPU. Ejemplo oficial:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


python generate_infinitetalk.py \
    --ckpt_dir weights/Wan2.1-I2V-14B-480P \
    --wav2vec_dir 'weights/chinese-wav2vec2-base' \
    --infinitetalk_dir weights/InfiniteTalk/single/infinitetalk.safetensors \
    --input_json examples/single_example_image.json \
    --size infinitetalk-480 \
    --sample_steps 40 \
    --mode streaming \
    --quant fp8 \
    --quant_dir weights/InfiniteTalk/quant_models/infinitetalk_single_fp8.safetensors \
    --motion_frame 9 \
    --num_persistent_param_in_dit 0 \
    --save_file infinitetalk_res_quant

Aspectos A Tener En Cuenta

InfiniteTalk tiene dependencias pesadas y modelos grandes. Antes de desplegarlo, conviene comprobar varias cosas:

Si la GPU tiene suficiente VRAM. En máquinas con poca VRAM, prueba primero --num_persistent_param_in_dit 0 o el modelo cuantizado.
Si flash_attn puede instalarse correctamente con la combinación actual de CUDA y PyTorch.
Si los modelos de Hugging Face se descargaron completos y si las rutas coinciden con weights/... en los comandos.
Si el JSON de entrada coincide con el formato de los ejemplos.
720P, videos largos, varias personas e inferencia multi-GPU aumentan claramente los requisitos de recursos.

El README también advierte que, aunque FusionX LoRA puede acelerar la inferencia y mejorar la calidad, en videos de más de 1 minuto puede agravar el cambio de color y reducir la preservación de identidad. En I2V, la generación desde una sola imagen funciona mejor hasta 1 minuto; más allá de 1 minuto, el cambio de color se vuelve más evidente.

Resumen

InfiniteTalk es un proyecto de generación de video impulsada por audio orientado a investigación e ingeniería. Encaja en escenarios que necesitan lip sync para videos largos, doblaje de personajes, videos de humanos digitales y generación de video hablado a partir de imágenes.

Si solo quieres probarlo rápidamente, prepara primero el entorno y los modelos siguiendo la instalación oficial, y empieza con el ejemplo de 480P en una sola GPU. Cuando las rutas, dependencias y VRAM estén confirmadas, puedes probar 720P, varias personas, multi-GPU, aceleración con LoRA o el modelo cuantizado.

Referencia:

GitHub: https://github.com/MeiGen-AI/InfiniteTalk