Qwen Image 2.1 + MiniMax H3: pipeline local de vídeo com quadros inicial e final

Talvez você já consiga criar bons quadros inicial e final no Qwen. O problema real é saber se o H3 consegue ligá-los em um único plano contínuo, sem trocar o personagem, inserir um corte indesejado ou chamar de “local” um caminho 2K dependente de API. Este guia propõe uma rota padrão: valide primeiro a cadeia 768p totalmente local, passe para 2K híbrido apenas quando a entrega exigir e compare H3 local e hospedado com entradas idênticas.

Comece aqui: use 768p local, a menos que realmente precise de 2K

Se você quer validar a passagem entre modelos, manter os arquivos na sua máquina ou localizar cortes inesperados, comece com 768p totalmente local. Escolha 2K híbrido apenas quando a entrega final exigir 2K e você aceitar chamadas remotas para H3-Context-IR e H3-Regenerate-2K.

Seu objetivo	Comece com	Por quê	Quando a recomendação muda
Provar que a cadeia inteira funciona	768p totalmente local	Há menos variáveis, então fica mais fácil separar problemas do Qwen e do H3	Avance quando 768p estiver estável e a entrega realmente exigir 2K
Manter os arquivos na sua máquina	768p totalmente local	Os quadros do Qwen e o H3-Base podem permanecer locais	Se 2K for obrigatório e APIs remotas forem proibidas, o caminho completo documentado não atende ao requisito; você precisará de outra solução 2K local
Entregar o vídeo final em 2K	2K híbrido	O caminho oficial completo ainda depende de dois módulos hospedados	Volte para 768p ou troque de solução se os arquivos não puderem sair da máquina
Decidir entre H3 local e hospedado	Valide primeiro 768p local e depois faça um teste pareado	Caso contrário, erros de implantação serão confundidos com qualidade do modelo	Fixe a rota de longo prazo após repetir o teste em vários tipos de plano

Não prometa compatibilidade apenas pelo nome da GPU. O exemplo SGLang da MiniMax usa quatro GPUs e a execução pública usou um DGX Spark; nenhum deles informa VRAM mínima nem comprova funcionamento em uma GPU comum de consumo.

O que pode realmente ficar na sua máquina

A geração de quadros no Qwen e o H3-Base em 768p podem ser locais; o caminho oficial completo em 2K não.

Etapa	Pode rodar localmente?	Limite documentado
Gerar e editar quadros inicial/final no Qwen Image 2.1	Sim	O repositório oficial oferece QwenImage21Pipeline, exemplos locais com Diffusers, tamanhos 2K nativos e até 10 imagens de referência
Converter os dois quadros em áudio e vídeo com MiniMax H3-Base	Sim	O checkpoint aberto FL2VA aceita zero, uma ou duas imagens; duas imagens ativam o modo de primeiro e último quadro, com validação local em 768p
H3-Context-IR	Não como implementação oficial completa local	A MiniMax o descreve como sistema hospedado de pré-processamento e orquestração, ausente da versão aberta; use a API ou crie um pré-processador próprio com o guia de prompts
H3-Regenerate-2K	Não com os componentes abertos atuais	O módulo ainda não foi aberto; o fluxo oficial completo em 2K o chama por API
Comparação com H3 hospedado	Não	Uma execução web/API é remota por definição e serve apenas como controle pareado

A MiniMax também documenta saída de 4–15 segundos, 24 FPS, áudio estéreo de 32 kHz e lado curto padrão de 768 pixels; o 2K é produzido com H3-Regenerate-2K. Esses são limites do modelo, não garantia de que qualquer configuração caberá no seu hardware.

Um teste público prova viabilidade, não um vencedor universal

Use o caso como desenho de teste, não como veredito de que o H3 local é sempre melhor.

O cineasta Sam Wasserman publicou uma execução local de ideia para imagem e vídeo em um DGX Spark usando Qwen Image 2.1 e MiniMax H3. O vídeo anexado tem cerca de oito segundos. Depois, afirmou ter reutilizado o mesmo prompt, as mesmas especificações e os mesmos quadros inicial e final no H3 Web pago. Segundo sua avaliação, o resultado web introduziu um corte indesejado, enquanto o local preservou a sequência pretendida.

Isso é útil como prova de viabilidade e como desenho de comparação. Não demonstra que o H3 local seja melhor em geral. As publicações não revelam comandos de instalação, pico de memória, tempo de geração, tratamento de áudio, seeds ou tentativas malsucedidas. A comparação também é do mesmo autor, com uma única entrada, e não uma replicação independente.

Etapa 1: reduza a ideia a um único plano contínuo

Peça um cenário, uma cadeia de ações e um estado final. Registre isso como contrato do plano: uma especificação curta para conferir tanto a instrução quanto o resultado.

Campo	O que definir
Sujeito e cenário	Pessoas, objetos, roupas, fundo e características de identidade que precisam permanecer estáveis
Estado inicial	Posição, pose, olhar, distância da câmera, composição e luz do primeiro quadro
Estado final	Apenas a mudança permitida no último quadro; evite trocar sujeito, lugar e câmera ao mesmo tempo
Trajeto do movimento	Como o sujeito se move, se a câmera se move e a ordem das ações
Restrições de continuidade	Instruções explícitas como “um plano contínuo”, “sem cortes” e “sem teletransporte”
Especificação de saída	Duração, proporção e necessidade de fala, ambiente ou música
Restrições negativas	Personagens, legendas, trocas de cena, substituição de fundo ou ações extras indesejadas

Se o teste pretende detectar cortes não solicitados, não peça vários locais, períodos ou uma montagem no mesmo prompt. Caso contrário, um corte pode ser interpretação razoável da instrução, não falha do modelo.

Por exemplo, “caminhe da porta até a mesa, pegue a xícara, sem cortes” funciona para testar primeiro e último quadro. “Saia da rua para um escritório e depois mostre um flashback da infância” exige várias cenas e não mede cortes inesperados de forma limpa.

Etapa 2: gere o primeiro quadro e edite-o para criar o último

Crie o último quadro editando o primeiro, em vez de gerar duas imagens independentes. Assim fica mais fácil preservar identidade, roupa, composição e fundo antes mesmo de o H3 começar.

O ID oficial é Qwen/Qwen-Image-2.1. O Qwen documenta componente visual de 7B parâmetros, Diffusers local, geração e edição, 2K nativo e até 10 imagens de referência.

pip install "torch>=2.4.0" "transformers>=5.17" accelerate pillow
pip install git+https://github.com/huggingface/diffusers

from pathlib import Path

import torch
from diffusers import QwenImage21Pipeline

first_prompt = Path("first_prompt.txt").read_text(encoding="utf-8").strip()
last_edit_prompt = Path("last_edit_prompt.txt").read_text(encoding="utf-8").strip()

pipe = QwenImage21Pipeline.from_pretrained(
    "Qwen/Qwen-Image-2.1",
    torch_dtype=torch.bfloat16,
).to("cuda")

first = pipe(
    prompt=first_prompt,
    width=2752,
    height=1536,
    num_inference_steps=40,
    generator=torch.Generator("cuda").manual_seed(42),
).images[0]
first.convert("RGB").save("first.png")

last = pipe(
    prompt=last_edit_prompt,
    image=first,
    width=2752,
    height=1536,
    num_inference_steps=40,
    generator=torch.Generator("cuda").manual_seed(43),
).images[0]
last.convert("RGB").save("last.png")

O código combina as interfaces oficiais de geração e edição de uma imagem; você fornece first_prompt e last_edit_prompt. Ele usa o tamanho 16:9 documentado 2752 × 1536, 40 passos e PNG RGB opacos. A documentação pública do H3 não explica o canal alfa nessa passagem, então quadros opacos removem uma variável, salvo se você já tiver validado RGBA separadamente.

Registre pelo menos:

• ID do modelo, versão do framework, prompt inicial e prompt de edição final;
• os dois seeds, largura, altura, passos e lista de referências;
• SHA-256, dimensões e modo de cor dos arquivos;
• estabilidade de identidade, roupa, composição, luz e fundo;
• se o quadro final mostra somente o estado final, e não toda a sequência de movimento.

O Qwen também documenta enable_model_cpu_offload() para memória limitada. Isso prova que existe uma rota de offload, mas não define VRAM mínima nem garante velocidade para este pipeline combinado.

Etapa 3: faça H3 local e hospedado lerem as mesmas entradas

Não digite parâmetros de memória em duas interfaces. Coloque imagens, prompt e configurações de saída em um único manifesto; seed, duração ou prompt reescrito podem invalidar toda a comparação.

experiment_id: "qwen-h3-001"
qwen_model: "Qwen/Qwen-Image-2.1"
h3_model: "MiniMaxAI/MiniMax-H3"
h3_variant: "fl2va"
prompt_file: "prompt.txt"
first_frame: "first.png"
last_frame: "last.png"
prompt_sha256: "<sha256>"
first_frame_sha256: "<sha256>"
last_frame_sha256: "<sha256>"
duration_seconds: "<same value>"
aspect_ratio: "<same value>"
local_seed: "<record if exposed>"
hosted_seed: "<record or not_exposed>"

As execuções local e hospedada devem ler esse registro. Se a interface hospedada esconder o seed, reescrever o prompt ou limitar a duração, use not_exposed ou salve o texto reescrito. Não finja igualdade quando ela não pode ser verificada: diferenças só são interpretáveis depois de controlar as entradas visíveis.

Etapa 4: faça o H3-Base local funcionar primeiro em 768p

Aceite primeiro o resultado 768p e deixe o 2K para depois. Quadros 2K do Qwen não tornam o vídeo local do H3-Base 2K.

A MiniMax publica dois checkpoints especializados. Aqui se usa MiniMax-H3 Base FL2VA, que gera áudio-vídeo a partir de texto, primeiro quadro, último quadro ou ambos em BF16. Os comandos oficiais de download e serviço SGLang são:

hf download MiniMaxAI/MiniMax-H3 \
  --include "FL2VA/*" \
  --local-dir MiniMax-H3

sglang serve \
  --model-path MiniMaxAI/MiniMax-H3 \
  --num-gpus 4 \
  --ulysses-degree 4 \
  --performance-mode speed \
  --host 0.0.0.0 \
  --port 30010 \
  --model-variant fl2va

O segundo comando é o exemplo de quatro GPUs da MiniMax. Não é uma configuração divulgada do DGX Spark de Wasserman nem um requisito mínimo. Ajuste-o apenas com a documentação do framework e registre cada mudança; não o apresente como prova de que toda máquina executará o H3.

Torne os dois quadros visíveis para o processo SGLang

O FL2VA aceita uma ou duas condições de imagem com role: "keyframe". O guia oficial do H3 no SGLang define frame_index: 0 como quadro inicial, frame_index: -1 como quadro final e [0, -1] como o conjunto dos dois extremos. O script reproduzível da MiniMax mostra apenas o primeiro quadro; a requisição abaixo usa os mesmos campos com as duas imagens.

A URI file:// é resolvida pelo processo servidor do SGLang, não pelo terminal que executa curl. Se ambos estiverem no mesmo host, os caminhos absolutos obtidos por realpath funcionam. Se o SGLang estiver em contêiner ou em outra máquina, monte ou copie os arquivos para lá e substitua FIRST_URI e LAST_URI por caminhos que o servidor realmente consiga ler.

Salve o contrato do plano em prompt.txt. Para 768p totalmente local, ele pode conter seu próprio prompt estruturado. Na rota híbrida 2K, coloque o resultado do H3-Context-IR no mesmo campo prompt e depois envie a saída do H3-Base ao H3-Regenerate-2K.

Envie o FL2VA, aguarde a conclusão e salve o MP4

O script segue o ciclo assíncrono documentado: cria a tarefa com POST /v1/videos e lê .id, consulta GET /v1/videos/{id} e só chama GET /v1/videos/{id}/content quando status vira completed. O cookbook oficial trata failed como falha terminal; qualquer outro status não vazio permanece no loop de espera.

set -euo pipefail

BASE_URL="${BASE_URL:-http://127.0.0.1:30010}"
FIRST_URI="${FIRST_URI:-file://$(realpath first.png)}"
LAST_URI="${LAST_URI:-file://$(realpath last.png)}"
PROMPT_FILE="${PROMPT_FILE:-prompt.txt}"
OUTPUT_FILE="${OUTPUT_FILE:-fl2va.mp4}"

payload=$(
  jq -n \
    --rawfile prompt "$PROMPT_FILE" \
    --arg first "$FIRST_URI" \
    --arg last "$LAST_URI" \
    '{
      model: "MiniMaxAI/MiniMax-H3",
      task: "fl2va",
      prompt: $prompt,
      seconds: 8,
      conditions: [
        {
          type: "image",
          uri: $first,
          role: "keyframe",
          frame_index: 0
        },
        {
          type: "image",
          uri: $last,
          role: "keyframe",
          frame_index: -1
        }
      ],
      target: {
        short_edge: 768,
        aspect_ratio: "auto",
        duration_seconds: 8
      },
      seed: 0
    }'
)

response=$(
  curl --fail-with-body --silent --show-error \
    --request POST \
    --url "$BASE_URL/v1/videos" \
    --header 'Content-Type: application/json' \
    --data-binary "$payload"
)

video_id=$(printf '%s\n' "$response" | jq -er '.id')
printf 'video_id=%s\n' "$video_id"

while true; do
  task_json=$(
    curl --fail-with-body --silent --show-error \
      --request GET \
      --url "$BASE_URL/v1/videos/$video_id"
  )
  status=$(printf '%s\n' "$task_json" | jq -er '.status')
  printf 'status=%s\n' "$status"

  case "$status" in
    completed)
      break
      ;;
    failed)
      printf '%s\n' "$task_json" | jq .
      exit 1
      ;;
    *)
      sleep 1
      ;;
  esac
done

curl --fail-with-body --silent --show-error --location \
  --request GET \
  --url "$BASE_URL/v1/videos/$video_id/content" \
  --output "$OUTPUT_FILE"

test -s "$OUTPUT_FILE"

if command -v ffprobe >/dev/null 2>&1; then
  ffprobe -v error \
    -show_entries stream=codec_type,codec_name,r_frame_rate,sample_rate,channels \
    -of default=noprint_wrappers=1 \
    "$OUTPUT_FILE"
fi

printf 'saved=%s\n' "$OUTPUT_FILE"

curl --fail-with-body interrompe em respostas fora de 2xx, e jq -e falha se .id ou .status não existirem. Ao receber failed, o script imprime o JSON completo da tarefa e sai com código diferente de zero; o caminho de sucesso também exige download concluído e MP4 não vazio.

Se ffprobe estiver instalado, o script mostra os fluxos de mídia. O contrato documentado pelo SGLang é um MP4 com vídeo H.264 a 24 FPS e uma faixa AAC estéreo a 32 kHz. Se a tarefa indicar completed, mas o arquivo estiver vazio, não decodificar ou tiver propriedades inesperadas, não avance para a comparação hospedada: verifique primeiro o log do SGLang, as URIs visíveis pelo servidor e o JSON da requisição.

Os campos e endpoints vêm do script FL2VA reproduzível oficial da MiniMax, do cookbook MiniMax-H3 do SGLang e do guia da API de vídeo do SGLang. A rota totalmente local termina aqui com um MP4 H3-Base em 768p; o 2K completo continua seguindo a rota híbrida descrita antes.

Etapa 5: compare com H3 hospedado somente após estabilizar a cadeia local

Não compare qualidade enquanto a cadeia local ainda falha. Caso contrário, erros de implantação, diferenças de entrada e comportamento do modelo ficam misturados. Mude apenas o local de execução:

1. Envie os mesmos bytes dos dois quadros e confira os hashes.
2. Reutilize prompt, duração, proporção, idioma e intenção de áudio.
3. Registre se web/API reescreve o prompt, expõe seed ou usa H3-Context-IR.
4. Preserve os arquivos originais; não edite, recodifique nem adicione música antes da comparação.
5. Oculte a origem e faça avaliação cega para reduzir o viés de “local deve ser melhor” ou “pago deve ser melhor”.

Para comparar custos, registre sua cobrança de API, o tempo de ocupação da máquina e o consumo de energia. Os rótulos “local” e “web pago” não mostram, sozinhos, qual rota é mais barata para sua carga.

Etapa 6: escolha a melhor rota para seus planos com uma única tabela

Primeiro confirme se o vídeo cumpre a tarefa criativa; só depois compare tempo e hardware. Um resultado de maior resolução que insere cortes repetidos ainda pode ser a pior opção de produção.

Critério	Como inspecionar	O que registrar
Fidelidade ao primeiro quadro	A abertura preserva sujeito, composição e objetos ou os substitui de imediato?	Desvio e timecode
Chegada ao último quadro	O vídeo alcança naturalmente o estado final ou salta para a imagem final?	Estado final e qualidade da transição
Continuidade do plano	Há cortes, teletransportes, trocas de cenário ou saltos temporais não pedidos?	Tempos dos cortes e capturas antes/depois
Estabilidade de identidade e fundo	Rosto, roupa, mãos, objetos e geometria do fundo permanecem estáveis?	Elemento afetado e duração
Trajeto	Sujeito e câmera seguem a ordem e direção combinadas?	Direção errada, salto de velocidade ou parada
Áudio	Quando solicitado, há faixa sincronizada e sem estalos ou conteúdo estranho?	Propriedades, desvio de sincronia e trecho anômalo
Especificação	Duração, proporção, FPS e resolução correspondem à configuração?	Metadados reais
Recursos	Tempo de parede, pico de memória do acelerador, RAM e tentativas	Logs brutos de cada execução, não estimativas
Repetibilidade	O mesmo problema reaparece ao repetir a entrada controlada?	Resultados repetidos e parâmetros aleatórios visíveis

A MiniMax diz que o H3 gera áudio estéreo de 32 kHz. As publicações de Wasserman não informam se o áudio foi ativado, preservado ou pós-processado. Você pode avaliar seu próprio resultado, mas não citar esse caso como validação da qualidade sonora.

Corrija a camada anterior em vez de repetir tudo

Um primeiro quadro errado é corrigido no Qwen, um problema de continuidade no H3 e uma divergência de resolução começa pela escolha entre 768p local e 2K híbrido. Diagnosticar por camada economiza mais tempo do que mudar todos os parâmetros de uma vez.

Sintoma	Verifique primeiro	Ação
O primeiro quadro já está errado	Etapa Qwen	Corrija prompt, referências e seed; não tente consertar uma composição ruim dentro do H3
Identidade ou fundo mudam no quadro final	Ativo passado pelo Qwen	Edite a partir do primeiro quadro, reduza mudanças e reutilize referências estáveis
Surge um corte inesperado	Prompt do H3 e restrições	Exija plano contínuo, remova linguagem de montagem/múltiplas cenas e repita com os mesmos hashes
O vídeo não chega ao final	Duração ou plano de movimento	Encurte a cadeia de ações e defina início–processo–fim
Áudio ausente ou incompatível	Variante H3, cliente e contêiner	Confirme checkpoint e rota de áudio-vídeo; marque execuções sem áudio equivalente como não comparáveis
Qwen fica sem memória	Implantação da imagem	Teste o CPU offload documentado e meça o impacto; não deduza VRAM mínima universal
H3 não inicia no hardware	Implantação H3	Siga o guia do framework; o exemplo oficial usa quatro GPUs, sem garantia para hardware de consumo
Local fica em 768p e 2K exige API	Limite do fluxo	É a arquitetura documentada, não falha; aceite 768p ou escolha 2K híbrido
Local e hospedado divergem muito	Entradas e pré-processamento	Confira reescrita do prompt, Context-IR, seed, duração, proporção e recodificação antes de culpar o modelo

Como escolher H3 local ou hospedado para uso contínuo

Decida com base no seu conjunto de planos, não na melhor amostra isolada. Inclua câmera estática, ação humana, transformação de objeto, diálogo e ambiente, guardando sucessos e falhas; separe estas medidas:

• duração do clipe, como os cerca de oito segundos do caso público;
• tempo de geração, intervalo entre envio e arquivo pronto, não divulgado no caso;
• especificações do modelo, vindas da documentação do fornecedor;
• uso real do hardware, medido no seu sistema, não inferido pelo nome do equipamento;
• um julgamento visual, válido para aquela execução e não conversível diretamente em taxa geral de vitória.

Se os arquivos não podem sair da sua máquina, mantenha 768p local como padrão. Se a entrega final precisa ser 2K e APIs remotas são aceitáveis, use 2K híbrido. Se continuidade é o principal, faça avaliação cega de H3 local e hospedado no mesmo conjunto de planos e prefira a rota que passa pela sua tabela com mais consistência. O caso público mostra que a rota local funciona e evitou um corte em um teste com a mesma entrada; não substitui suas repetições.

Verifique estes oito itens antes de executar

• A execução está marcada como “768p totalmente local” ou “2K híbrido”, sem misturar termos.
• Modelo Qwen, prompts, seeds, dimensões e referências foram registrados para ambos os quadros.
• Imagens e prompt têm hash, e as duas execuções H3 consomem as mesmas entradas.
• A execução local usa fl2va e é aceita primeiro como resultado H3-Base em 768p.
• Reescritas e parâmetros ocultos do serviço hospedado foram documentados honestamente.
• Os vídeos originais continuam sem edição e usam a mesma rubrica de continuidade, cortes, áudio e especificação.
• Tempo, pico de memória, tentativas e falhas vêm de logs.
• As conclusões se limitam às amostras, ao hardware e à data verificados.

Conclusão

A recomendação padrão é clara: crie localmente o primeiro e o último quadro com Qwen Image 2.1 e valide 768p local com MiniMax H3-Base fl2va. Mude para H3-Context-IR → H3-Base local → H3-Regenerate-2K apenas quando 2K for obrigatório e APIs remotas forem aceitáveis.

Em qualquer rota, congele quadros, prompt, duração e proporção, depois compare continuidade, cortes inesperados, áudio, tempo e uso de hardware com as mesmas entradas. Assim uma demonstração bonita vira um fluxo que você pode auditar, comparar e adotar com critério.

Referências

• Repositório oficial do Qwen Image 2.1
• Anúncio oficial de código aberto do MiniMax H3
• Requisição FL2VA reproduzível oficial do MiniMax H3
• Cookbook oficial do MiniMax-H3 no SGLang
• Guia da API de vídeo do SGLang Diffusion
• Execução local ponta a ponta de Sam Wasserman
• Comparação do mesmo autor com Web H3 usando as mesmas entradas

Fatos verificados em 26 de setembro de 2026.