Lip Sync on KnightLi Blog

MultiTalk: generación de video conversacional multi-persona impulsada por audio

Mon, 15 Jun 2026 08:59:09 +0800

MeiGen-AI/MultiTalk es un proyecto de generación de video conversacional multi-persona impulsada por audio. Su paper se titula Let Them Talk: Audio-Driven Multi-Person Conversational Video Generation. El objetivo es generar videos de conversación con varias personas a partir de audio multi-stream, una imagen de referencia y prompts, manteniendo alineados el movimiento labial, la interacción y el control por prompt.

MultiTalk no se limita a humanos digitales de una sola persona. También enfatiza conversaciones multi-persona, canto, control interactivo y generación de personajes de estilo cartoon. Soporta salida 480P y 720P. El README indica que el código actual soporta principalmente inferencia 480P, mientras que 720P requiere varias GPU.

Capacidades Principales

Las capacidades de MultiTalk se pueden resumir así:

Generación de video impulsada por audio para una o varias personas.
Control de interacción de personajes virtuales mediante prompt.
Escenarios más generales como personajes cartoon y canto.
Salida 480P y 720P.
Generación de video de hasta unos 15 segundos.
Multi-GPU, TeaCache, APG, inferencia con baja VRAM, TTS, Gradio, aceleración LoRA y cuantización INT8.

Si quieres crear entrevistas multi-persona, videos de podcast, conversaciones con humanos digitales, interacción entre personajes o videos impulsados por TTS, MultiTalk encaja mejor que una herramienta de lip sync para una sola persona.

Instalación

A continuación se conserva el proceso de instalación del README oficial. Usa un entorno Linux con CUDA y prepara Conda, Git, suficiente VRAM y suficiente espacio en disco. El entorno del README se llama multitalk.

Primero clona el repositorio y entra en el directorio:

1
2

git clone https://github.com/meigen-ai/multitalk.git
cd multitalk

1. Crear un entorno conda e instalar PyTorch y xformers

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 para CUDA 12.1. Si tu driver, CUDA o plataforma son diferentes, ajusta el comando según la guía oficial de instalación de PyTorch.

2. Instalar Flash-Attn

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

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

3. Instalar otras dependencias

1
2

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

4. Instalar FFmpeg

En el 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

MultiTalk necesita estos modelos:

Modelo	Uso
`Wan2.1-I2V-14B-480P`	Modelo base
`chinese-wav2vec2-base`	Codificador de audio
`Kokoro-82M`	Pesos TTS
`MeiGen-MultiTalk`	Pesos de condición de audio de MultiTalk

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

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 hexgrad/Kokoro-82M --local-dir ./weights/Kokoro-82M
huggingface-cli download MeiGen-AI/MeiGen-MultiTalk --local-dir ./weights/MeiGen-MultiTalk

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

`1`	`pip install -U huggingface_hub`

Tras descargar, el directorio debería contener aproximadamente:

weights/
  Wan2.1-I2V-14B-480P/
  chinese-wav2vec2-base/
  Kokoro-82M/
  MeiGen-MultiTalk/

Enlazar O Copiar El Modelo MultiTalk

El README pide enlazar o copiar el modelo MultiTalk dentro del directorio Wan2.1-I2V-14B-480P.

Mediante enlaces simbólicos:

1
2
3

mv weights/Wan2.1-I2V-14B-480P/diffusion_pytorch_model.safetensors.index.json weights/Wan2.1-I2V-14B-480P/diffusion_pytorch_model.safetensors.index.json_old
sudo ln -s {Absolute path}/weights/MeiGen-MultiTalk/diffusion_pytorch_model.safetensors.index.json weights/Wan2.1-I2V-14B-480P/
sudo ln -s {Absolute path}/weights/MeiGen-MultiTalk/multitalk.safetensors weights/Wan2.1-I2V-14B-480P/

O copiando los archivos:

1
2
3

mv weights/Wan2.1-I2V-14B-480P/diffusion_pytorch_model.safetensors.index.json weights/Wan2.1-I2V-14B-480P/diffusion_pytorch_model.safetensors.index.json_old
cp weights/MeiGen-MultiTalk/diffusion_pytorch_model.safetensors.index.json weights/Wan2.1-I2V-14B-480P/
cp weights/MeiGen-MultiTalk/multitalk.safetensors weights/Wan2.1-I2V-14B-480P/

Si usas enlaces simbólicos, reemplaza {Absolute path} con tu ruta absoluta real. En Windows o WSL, comprueba también permisos de symlink y resolución de rutas.

Parámetros Comunes

El README lista estos parámetros:

--mode streaming: long video generation.
--mode clip: generate short video with one chunk.
--use_teacache: run with TeaCache.
--size multitalk-480: generate 480P video.
--size multitalk-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.

Se conserva la escritura original del README. Antes de copiar comandos, ten en cuenta que los guiones antes de sample_text_guide_scale y sample_audio_guide_scale quizá no sean -- estándar; conviene revisarlos manualmente.

Inferencia Con Una Persona

Una persona, una GPU:

python generate_multitalk.py \
    --ckpt_dir weights/Wan2.1-I2V-14B-480P \
    --wav2vec_dir 'weights/chinese-wav2vec2-base' \
    --input_json examples/single_example_1.json \
    --sample_steps 40 \
    --mode streaming \
    --use_teacache \
    --save_file single_long_exp

Una persona con baja VRAM:

python generate_multitalk.py \
    --ckpt_dir weights/Wan2.1-I2V-14B-480P \
    --wav2vec_dir 'weights/chinese-wav2vec2-base' \
    --input_json examples/single_example_1.json \
    --sample_steps 40 \
    --mode streaming \
    --num_persistent_param_in_dit 0 \
    --use_teacache \
    --save_file single_long_lowvram_exp

Una persona con varias GPU:

GPU_NUM=8
torchrun --nproc_per_node=$GPU_NUM --standalone generate_multitalk.py \
    --ckpt_dir weights/Wan2.1-I2V-14B-480P \
    --wav2vec_dir 'weights/chinese-wav2vec2-base' \
    --dit_fsdp --t5_fsdp \
    --ulysses_size=$GPU_NUM \
    --input_json examples/single_example_1.json \
    --sample_steps 40 \
    --mode streaming \
    --use_teacache \
    --save_file single_long_multigpu_exp

Una persona con TTS:

python generate_multitalk.py \
    --ckpt_dir weights/Wan2.1-I2V-14B-480P \
    --wav2vec_dir 'weights/chinese-wav2vec2-base' \
    --input_json examples/single_example_tts_1.json \
    --sample_steps 40 \
    --mode streaming \
    --num_persistent_param_in_dit 0 \
    --use_teacache \
    --save_file single_long_lowvram_tts_exp \
    --audio_mode tts

Inferencia Multi-Persona

Varias personas, una GPU:

python generate_multitalk.py \
    --ckpt_dir weights/Wan2.1-I2V-14B-480P \
    --wav2vec_dir 'weights/chinese-wav2vec2-base' \
    --input_json examples/multitalk_example_2.json \
    --sample_steps 40 \
    --mode streaming \
    --use_teacache \
    --save_file multi_long_exp

Varias personas con baja VRAM:

python generate_multitalk.py \
    --ckpt_dir weights/Wan2.1-I2V-14B-480P \
    --wav2vec_dir 'weights/chinese-wav2vec2-base' \
    --input_json examples/multitalk_example_2.json \
    --sample_steps 40 \
    --mode streaming \
    --num_persistent_param_in_dit 0 \
    --use_teacache \
    --save_file multi_long_lowvram_exp

Varias personas con varias GPU:

GPU_NUM=8
torchrun --nproc_per_node=$GPU_NUM --standalone generate_multitalk.py \
    --ckpt_dir weights/Wan2.1-I2V-14B-480P \
    --wav2vec_dir 'weights/chinese-wav2vec2-base' \
    --dit_fsdp --t5_fsdp --ulysses_size=$GPU_NUM \
    --input_json examples/multitalk_example_2.json \
    --sample_steps 40 \
    --mode streaming --use_teacache \
    --save_file multi_long_multigpu_exp

Varias personas con TTS:

python generate_multitalk.py \
    --ckpt_dir weights/Wan2.1-I2V-14B-480P \
    --wav2vec_dir 'weights/chinese-wav2vec2-base' \
    --input_json examples/multitalk_example_tts_1.json \
    --sample_steps 40 \
    --mode streaming \
    --num_persistent_param_in_dit 0 \
    --use_teacache \
    --save_file multi_long_lowvram_tts_exp \
    --audio_mode tts

FusionX, Cuantización Y Gradio

FusioniX o Lightx2v pueden reducir los pasos de muestreo. Ejemplo para una persona del README:

python generate_multitalk.py \
    --ckpt_dir weights/Wan2.1-I2V-14B-480P \
    --wav2vec_dir 'weights/chinese-wav2vec2-base' \
    --input_json examples/single_example_1.json \
    --lora_dir weights/Wan2.1_I2V_14B_FusionX_LoRA.safetensors \
    --lora_scale 1.0 \
    --sample_text_guide_scale 1.0 \
    --sample_audio_guide_scale 2.0 \
    --sample_steps 8 \
    --mode streaming \
    --num_persistent_param_in_dit 0 \
    --save_file single_long_lowvram_fusionx_exp \
    --sample_shift 2

Ejemplo multi-persona:

python generate_multitalk.py \
    --ckpt_dir weights/Wan2.1-I2V-14B-480P \
    --wav2vec_dir 'weights/chinese-wav2vec2-base' \
    --input_json examples/multitalk_example_2.json \
    --lora_dir weights/Wan2.1_I2V_14B_FusionX_LoRA.safetensors \
    --lora_scale 1.0 \
    --sample_text_guide_scale 1.0 \
    --sample_audio_guide_scale 2.0 \
    --sample_steps 8 \
    --mode streaming \
    --num_persistent_param_in_dit 0 \
    --save_file multi_long_lowvram_fusionx_exp

El modelo cuantizado INT8 solo soporta ejecución con una GPU:

python generate_multitalk.py \
    --ckpt_dir weights/Wan2.1-I2V-14B-480P \
    --wav2vec_dir 'weights/chinese-wav2vec2-base' \
    --input_json examples/multitalk_example_2.json \
    --sample_steps 40 \
    --mode streaming \
    --use_teacache \
    --quant int8 \
    --quant_dir weights/MeiGen-MultiTalk \
    --num_persistent_param_in_dit 0 \
    --save_file multi_long_lowvram_exp_quant

Cuantización con LoRA:

python generate_multitalk.py \
    --ckpt_dir weights/Wan2.1-I2V-14B-480P \
    --wav2vec_dir 'weights/chinese-wav2vec2-base' \
    --input_json examples/multitalk_example_1.json \
    --quant int8 \
    --quant_dir weights/MeiGen-MultiTalk \
    --lora_dir weights/MeiGen-MultiTalk/quant_models/quant_model_int8_FusionX.safetensors \
    --sample_text_guide_scale 1.0 \
    --sample_audio_guide_scale 2.0 \
    --sample_steps 8 \
    --mode streaming \
    --num_persistent_param_in_dit 0 \
    --save_file multi_long_lowvram_fusionx_exp_quant \
    --sample_shift 2

Ejemplo de Gradio:

python app.py \
    --lora_dir weights/Wan2.1_I2V_14B_FusionX_LoRA.safetensors \
    --lora_scale 1.0 \
    --num_persistent_param_in_dit 0 \
    --sample_shift 2

`1`	`python app.py --num_persistent_param_in_dit 0`

Ejemplo de Gradio cuantizado:

python app.py \
    --quant int8 \
    --quant_dir weights/MeiGen-MultiTalk \
    --lora_dir weights/MeiGen-MultiTalk/quant_models/quant_model_int8_FusionX.safetensors \
    --sample_shift 2 \
    --num_persistent_param_in_dit 0

Aspectos A Tener En Cuenta

MultiTalk tiene dependencias pesadas y modelos grandes. Antes de desplegarlo, conviene comprobar lo siguiente:

El código actual soporta principalmente inferencia 480P; 720P requiere varias GPU.
Las notas oficiales indican que audio CFG suele funcionar bien entre 3 y 5, y aumentar audio CFG puede mejorar el lip sync.
El modelo se entrenó con videos de 81 frames a 25 FPS. 81 frames suele funcionar mejor para seguir el prompt; clips más largos pueden reducir esa capacidad.
En generación de video largo, Audio CFG afecta la consistencia de color entre segmentos. Se puede probar un valor de 3 para reducir variaciones tonales.
El rango recomendado de --teacache_thresh es 0.2 a 0.5. Valores más altos pueden acelerar, pero también bajar la calidad.
En entornos con baja VRAM, prueba primero --num_persistent_param_in_dit 0, cuantización INT8 o soluciones comunitarias de baja VRAM.

El README también indica que TeaCache puede aportar una aceleración aproximada de 2 a 3 veces. El resultado real depende de la GPU, resolución, pasos de muestreo, número de personas y uso de LoRA o cuantización.

Resumen

MultiTalk es un proyecto de generación impulsada por audio para video conversacional multi-persona. Encaja con humanos digitales multi-persona, entrevistas, videos impulsados por TTS, interacción de personajes cartoon y canto.

Para una prueba rápida, prepara el entorno y los modelos siguiendo la instalación oficial, completa el enlace o copia del modelo y empieza con el ejemplo 480P de una persona. Cuando funcione, prueba gradualmente multi-persona, TTS, TeaCache, aceleración LoRA, cuantización INT8 y Gradio.

Referencia:

GitHub: https://github.com/meigen-ai/multitalk

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

Mon, 15 Jun 2026 08:50:52 +0800

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

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

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:

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:

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

Parámetros De Ejecución Comunes

El README enumera algunos parámetros importantes:

--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:

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:

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:

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:

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:

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:

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:

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.

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:

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