Hugging Face: Imagem para Vídeo — Modelos, Spaces e Inferência Local

Imagem para vídeo no Hugging Face refere-se ao uso de modelos hospedados em huggingface.co sob a image-to-video tag de pipeline para transformar uma imagem estática em um clipe animado curto. Você interage com eles de três formas: demos Spaces interativas no navegador, a Inference API/Inference Endpoints, ou baixando os pesos e executando-os localmente com a diffusers biblioteca Python. Abaixo está o que realmente funciona, por modelo, por plataforma.

O que a image-to-video tag realmente cobre

A tag de pipeline filtra o Hub para modelos cuja entrada pretendida é uma imagem (opcionalmente mais um prompt de texto) e cuja saída é um vídeo curto, normalmente de 2–6 segundos a 16–24 fps. No momento da redação, as famílias de peso aberto mais ativas são:

Modelo	Autor	Saída típica	Licença dos pesos
Wan 2.2 I2V-A14B	Alibaba (Wan-AI)	720p, 5s, 24 fps	Apache 2.0
Wan 2.1 I2V-14B / I2V-1.3B	Alibaba (Wan-AI)	480p–720p, ~5s	Apache 2.0
Stable Video Diffusion (SVD)	Stability AI	576×1024, 14 quadros	SVD não comercial / comercial via Stability
SVD-XT	Stability AI	576×1024, 25 quadros	Igual ao SVD
LTX-Video	Lightricks	768×512, ~5s a 24 fps	Variante OpenRAIL-M
CogVideoX-5B-I2V	THUDM	720×480, 6s a 8 fps	Apache 2.0 (código), personalizada (pesos)
image-to-video	Bantikumar (comunidade)	Pequeno checkpoint de demonstração	Consulte o cartão do modelo

Sempre confirme a resolução, contagem de quadros e licença no próprio cartão do modelo — os autores atualizam esses dados. O cartão do Wan 2.2 está em huggingface.co/Wan-AI/Wan2.2-I2V-A14B, SVD-XT em huggingface.co/stabilityai/stable-video-diffusion-img2vid-xt, e LTX-Video em huggingface.co/Lightricks/LTX-Video.

Três formas de executar Hugging Face image to video

1. Spaces (sem instalação, apenas navegador)

Cada modelo I2V principal tem um ou mais Spaces da comunidade. Acesse huggingface.co/spaces, procure pelo nome do modelo (por exemplo, «Wan 2.2 I2V» ou «LTX-Video»), faça upload de uma imagem, digite um prompt opcional, clique Gere. Spaces gratuitos são executados em ZeroGPU compartilhado (fatias H200) com uma cota diária por usuário; se o Space estiver ocupado, você entrará na fila. Para produção, duplique o Space e anexe hardware pago nas configurações do Space.

2. Inference API e Inference Endpoints

O serverless Inference API suporta alguns modelos I2V diretamente; para outros você implementa um Inference Endpoint dedicado em um A10G, L4, L40S, A100 ou H100. Os endpoints são cobrados por hora de tempo de atividade da GPU, então deixar um em execução por um mês é caro; um endpoint A100-80GB 24/7 normalmente custa milhares de dólares por mês. Use o calculadora de self-hosting vs API para comparar com APIs de vídeo por segundo.

3. Inferência local com diffusers

O cliente de referência é o Hugging Face diffusers biblioteca. Instale:

pip install --upgrade diffusers transformers accelerate torch imageio imageio-ffmpeg

Exemplo mínimo de SVD-XT (do cartão do modelo):

import torch
from diffusers import StableVideoDiffusionPipeline
from diffusers.utils import load_image, export_to_video

pipe = StableVideoDiffusionPipeline.from_pretrained(
    "stabilityai/stable-video-diffusion-img2vid-xt",
    torch_dtype=torch.float16, variant="fp16"
)
pipe.enable_model_cpu_offload()

image = load_image("input.png").resize((1024, 576))
frames = pipe(image, decode_chunk_size=8, num_frames=25).frames[0]
export_to_video(frames, "out.mp4", fps=7)

Para o Wan 2.2, use WanImageToVideoPipeline; para o LTX-Video, use LTXImageToVideoPipeline. Verifique no cartão do modelo o nome exato da classe — diffusers adiciona novos pipelines a cada lançamento.

VRAM e hardware, honestamente

A geração I2V é mais exigente que a geração de imagens porque você está removendo ruído de vários quadros de um latente temporal simultaneamente. Os cartões dos modelos e o repositório diffusers indicam aproximadamente:

Modelo	VRAM nativa (fp16)	Com descarga para CPU / quantização
SVD / SVD-XT (576×1024)	~16–20 GB	~8–10 GB com enable_model_cpu_offload()
LTX-Video	~12–24 GB, dependendo da duração	Funciona em placas de 12 GB com descarga
Wan 2.1 I2V-1.3B	~8–12 GB	Funciona em uma RTX 3060 de 12 GB
Wan 2.2 I2V-A14B (720p)	~24 GB ou mais	Cabe em 16 GB com forks comunitários fp8/GGUF
CogVideoX-5B-I2V	~18–24 GB	~5 GB com descarga total (conforme indicado no cartão da THUDM)

Esses valores variam conforme resolução e número de quadros. Para uma visão geral da escalabilidade de memória GPU, consulte a lista de calculadora de VRAM e melhores GPUs para modelos locais — as mesmas placas (RTX 3090, 4090, 5090, A6000) também são ideais para geração de vídeos.

Windows

Instale o Python 3.10 ou 3.11 a partir de python.org e, em seguida, a versão CUDA do PyTorch em pytorch.org/get-started/locally compatível com seu driver NVIDIA. Crie um ambiente virtual (venv), pip install diffusers transformers accelerate, e defina HF_HOME para uma unidade com pelo menos 50 GB livres — os pesos do Wan e do CogVideoX são muito grandes. O Windows não oferece suporte a ROCm; usuários AMD devem usar WSL2 ou Linux. Para uma interface mais amigável, ComfyUI possui fluxos de trabalho nativos para SVD, Wan e LTX-Video.

macOS

Chips Apple Silicon (M1–M4) executam diffusers via MPS. Instale o PyTorch com suporte a MPS e, em seguida, passe torch_dtype=torch.float16 e .to("mps"). Na prática, o SVD gera um clipe de 25 quadros em vários minutos em um M2 Max; o Wan 2.2 A14B é inviável em qualquer sistema com menos de 64 GB de memória unificada. Atualmente, o LTX-Video é o modelo I2V mais utilizável em Macs devido à sua menor contagem de etapas. Macs Intel não possuem caminho funcional de GPU — use uma API hospedada em vez disso.

Linux

O Linux é a plataforma principal. Instale o driver NVIDIA e o runtime CUDA 12.x (incluído nos pacotes PyTorch), depois pip install diffusers transformers accelerate. Para uso com múltiplas GPUs ou clipes longos, utilize accelerate config e pipe.enable_sequential_cpu_offload(). xformers e torch.compile() proporcionam acelerações significativas para SVD e Wan em placas das famílias Ampere/Ada/Hopper.

Quando pular Hugging Face e usar uma API de vídeo hospedada

Se você precisa gerar apenas um clipe curto por dia, um Space ou uma placa RTX local são suficientes. Se necessita de desempenho confiável e alta vazão, APIs hospedadas por segundo costumam ser mais econômicas do que pagar por um endpoint ocioso com A100/H100:

• Wan 2.5 — a partir de US$ 0,05/segundo (mesma linha de modelos dos pesos abertos do Wan no Hub)
• Sora 2 — a partir de US$ 0,05/segundo; Sora 2 Pro a partir de US$ 0,15/segundo
• Veo 3.1 — a partir de US$ 0,05/segundo
• Kling 2.5 Turbo Pro — a partir de US$ 0,07/segundo

A US$ 0,05 por segundo, 1.000 clipes de cinco segundos custam US$ 250; alugar um H100 nas tarifas típicas de nuvem para obter a mesma vazão geralmente sai mais caro. Use o Calculadora de custos de API e navegue pelo banco de dados de modelos para conferir os preços atuais.

Perguntas frequentes

Existe um único modelo de “imagem para vídeo na Hugging Face” ao qual devo recorrer por padrão?

Não há um padrão único. Para pesos abertos e licenças permissivas, o Wan 2.2 I2V-A14B atualmente produz a melhor saída em 720p, mas exige 24 GB ou mais de VRAM. Em placas com 12 GB, as opções práticas são o LTX-Video ou o Wan 2.1 I2V-1.3B. O SVD-XT é mais antigo, mas muito bem documentado.

Posso usar esses modelos comercialmente?

Depende do checkpoint. Os modelos Wan 2.1/2.2, o código do CogVideoX e o LTX-Video têm licenças permissivas, mas cada um possui seus próprios termos; os pesos do Stable Video Diffusion são distribuídos sob uma licença comunitária da Stability, com uma camada comercial separada. Leia sempre a seção Licença do card do modelo antes de integrá-lo a qualquer produto.

Por que minha saída pisca ou parece um slideshow?

Geralmente um desses fatores: número insuficiente de etapas de inferência (aumente num_inference_steps), motion_bucket_id/guidance_scale definido muito baixo para o SVD, ou uma imagem de entrada cuja proporção de aspecto não corresponde à resolução de treinamento do modelo. Ajuste a resolução nativa do modelo (por exemplo, 1024×576 para o SVD-XT) antes de gerar.

É possível executar imagem para vídeo em um laptop com 8 GB de VRAM?

Apenas com os menores modelos e descarregamento agressivo. O Wan 2.1 I2V-1.3B e versões quantizadas do LTX-Video conseguem rodar, mas espere minutos por clipe. Para qualquer modelo maior, uma API hospedada ou um Space serão mais rápidos e econômicos do que tentar contornar erros de falta de memória (OOM).

O Ollama suporta imagem para vídeo?

Não. Ollama is focused on text and multimodal LLMs, not diffusion video pipelines. See the Guia do Ollama para saber quais funcionalidades ele cobre; para I2V, mantenha-se no diffusers ou no ComfyUI.

Quanto tempo leva a geração de um único clipe em uma GPU de consumo?

Ordem de grandeza: o SVD-XT em uma RTX 4090 gera um clipe de 25 quadros em bem menos de um minuto nas configurações padrão; o mesmo modelo com enable_model_cpu_offload() ativado em uma placa de 12 GB é várias vezes mais lento. O Wan 2.2 A14B em 720p é substancialmente mais pesado. Os valores exatos dependem da contagem de etapas, da resolução e da versão do PyTorch, portanto trate qualquer benchmark isolado como aproximado.