Vídeo (experimental)#

Aprenda a usar o Xinference para gerar vídeos.

Introdução#

A API de Vídeo fornece maneiras de interagir com vídeos:

O endpoint Text-to-video cria um vídeo do zero a partir de um prompt de texto.
O endpoint de imagem para vídeo cria um vídeo a partir do zero com base em uma imagem.
A interface firstlastframe-to-video gera um vídeo com base na transição entre o primeiro e o último quadro.

API	Endpoint
Text-to-Video API	/v1/video/generations
Image-to-Video API	/v1/video/generations/image
FirstLastFrame-to-Video API	/v1/video/generations/flf

Lista de modelos suportados#

A API de texto para vídeo no Xinference suporta os seguintes modelos:

A API de imagem para vídeo no Xinference suporta os seguintes modelos:

No Xinference suporta os seguintes modelos para usar a interface firstlastframe-to-video:

Wan2.1-flf2v-14B-720p

Início Rápido#

Vídeo gerado a partir de texto#

Você pode experimentar a API text-to-video via cURL ou Xinference.

curl -X 'POST' \
  'http://<XINFERENCE_HOST>:<XINFERENCE_PORT>/v1/video/generations' \
  -H 'accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "<MODEL_UID>",
    "prompt": "<your prompt>"
  }'

from xinference.client import Client

client = Client("http://<XINFERENCE_HOST>:<XINFERENCE_PORT>")

model = client.get_model("<MODEL_UID>")
input_text = "an apple"
model.text_to_video(input_text)

Geração de vídeo a partir de imagem#

Você pode tentar usar a API image-to-video através do cURL ou Xinference.

curl -X 'POST' \
  'http://<XINFERENCE_HOST>:<XINFERENCE_PORT>/v1/video/generations/image' \
  -F model=<MODEL_UID> \
  -F image=@xxx.jpg \
  -F prompt=<prompt>

from xinference.client import Client

client = Client("http://<XINFERENCE_HOST>:<XINFERENCE_PORT>")

model = client.get_model("<MODEL_UID>")
with open("xxx.jpg", "rb") as f:
    prompt = ""
    model.image_to_video(image=f.read(), prompt=prompt)

Vídeo de geração de quadros inicial e final#

Você pode experimentar a interface firstlastframe-to-video via cURL ou pelo cliente Python do Xinference:

curl -X 'POST' \
  'http://<XINFERENCE_HOST>:<XINFERENCE_PORT>/v1/video/generations/flf' \
  -F model=<MODEL_UID> \
  -F first_frame=@xxx.jpg \
  -F last_frame=@xxx2.jpg \
  -F prompt=<prompt>

from xinference.client import Client

client = Client("http://<XINFERENCE_HOST>:<XINFERENCE_PORT>")

model = client.get_model("<MODEL_UID>")
with open("xxx.jpg", "rb") as f1, open("xxx2.jpg", "rb") as f2:
    prompt = ""
    model.flf_to_video(first_frame=f1.read(), last_frame=f2.read(), prompt=prompt)

Otimização de memória#

A geração de vídeos consome uma grande quantidade de memória de vídeo. Por exemplo, executar o CogVideoX pode utilizar cerca de 35 GB de memória de vídeo.

O Xinference suporta várias opções para otimizar o uso de memória de vídeo (VRAM) do modelo de vídeo.

Descarregamento da CPU ou descarregamento em nível de bloco.
Conversão de tipo por camada (Layerwise casting).

Nota

A descarga de CPU e a descarga em nível de bloco não podem ser ativadas simultaneamente, mas a conversão de tipo camada por camada pode ser usada em conjunto com uma delas.

Descarga de CPU#

O descarregamento da CPU mantém os pesos do modelo na CPU, carregando-os na GPU apenas durante a propagação direta. É adequado para cenários com memória de vídeo extremamente limitada, mas impacta significativamente o desempenho.

Ao usar GPUs com menos de 24 GB de VRAM, recomenda-se adicionar --cpu_offload True ao iniciar o modelo. Para Web UI, adicione a opção extra cpu_offload com o valor definido como True.

xinference launch --model-name Wan2.1-i2v-14B-480p --model-type video --cpu_offload True

Tradução direta para português brasileiro:#

Block-level grouping offloading agrupa múltiplas camadas internas do modelo (como torch.nn.ModuleList ou torch.nn.Sequential) e carrega esses grupos da CPU para a GPU conforme necessário durante a inferência. Em comparação com o offloading da CPU, ele usa mais memória, mas tem um impacto menor no desempenho.

Para a linha de comando, adicione a opção --group_offload True; para a Web UI, adicione uma opção extra group_offload, definindo o valor como True.

Ao ativar o CUDA Stream, podemos acelerar a inferência de descarregamento em grupo. No entanto, o uso de CUDA Stream requer a movimentação dos parâmetros do modelo para a memória fixa. Essa alocação é tratada pelo PyTorch em segundo plano e pode resultar em um aumento significativo no uso de RAM da CPU. Se sua RAM da CPU tiver pelo menos o dobro do tamanho do modelo, considere usar esta opção. Ative o CUDA Stream adicionando --use_stream True na linha de comando; para a interface web, adicione uma opção extra use_stream com valor True.

xinference launch --model-name Wan2.1-i2v-14B-480p --model-type video --group_offload True --use_stream True

Aplica a conversão de tipo camada por camada ao Transformer#

A conversão de tipo por camada reduzirá o peso de cada camada para torch.float8_e4m3fn, promoverá temporariamente para torch.bfloat16 durante a passagem direta da camada e, em seguida, restaurará para torch.float8_e4m3fn posteriormente. Este método reduz os requisitos de memória em aproximadamente 50%, mas a qualidade do vídeo gerado diminuirá ligeiramente devido ao compromisso de precisão. Ative a conversão de tipo por camada adicionando --layerwise_cast True na linha de comando; para a interface web, adicione uma opção extra layerwise_cast com o valor definido como True.

Este exemplo exigirá 20GB de memória de vídeo.

xinference launch --model-name Wan2.1-i2v-14B-480p --model-type video --layerwise_cast True --cpu_offload True