Escolhendo uma placa para modelos de imagem e vídeo.

O que cada modelo precisa

Comece pela diferença que decide tudo o mais. Um modelo de linguagem carrega um cache de chave/valor que cresce a cada token de contexto, e é por isso que o mesmo modelo de 70B pode exigir 40 GB ou 140 GB dependendo de quanta conversa você mantém. Um modelo de difusão não tem cache nenhum. Ele lê um prompt, faz o denoising de um latente por um número fixo de passos, e esquece. Os pesos são, portanto, praticamente toda a questão de memória, e a resposta não muda quando seus prompts ficam mais longos.

Pesos mais uma margem de 15% em tempo de execução para ativações, o contexto CUDA e a fragmentação do alocador — a mesma margem que o configurador aplica, então você pode conferir esses números com ele. Não há coluna de contexto porque não há nada para colocar nela.

Duas linhas dessa tabela merecem atenção, porque são exatamente onde uma compra dá errado.

O que cada placa comporta

Toda máquina de uma placa só que alugamos, e a melhor precisão que cada uma comporta para os dois modelos mais exigentes. A coluna de largura de banda está ali para o próximo capítulo; leia-a depois de ler este.

Verde são os pesos de referência, âmbar é quantizado. Quantizar um modelo de difusão não é o almoço grátis que é para um modelo de linguagem: o mesmo prompt e a mesma seed geram uma imagem visivelmente diferente, geralmente um pouco mais suave. É uma boa troca em FP8 e uma decisão de julgamento em 4 bits.

Leia a coluna de preço de baixo para cima e o quadro é direto. NVIDIA L4, a $125 por mês, é a máquina mais barata que alugamos que comporta FLUX.1 dev de alguma forma — em FP8. A mais barata que comporta em BF16 completo é NVIDIA RTX A6000, a $286. Vídeo em precisão total começa nessa mesma placa.

A coluna que todo mundo lê errado

Aqui está a parte que separa o trabalho com imagem de tudo mais neste site, e é o motivo pelo qual a placa mais barata daquela tabela é uma armadilha.

Quando um modelo de linguagem gera um token, ele lê da memória cada peso ativo uma vez, faz uma pequena quantidade de aritmética com cada um, e escreve um único token. Ele faz isso de novo para o próximo token, e o seguinte. A placa passa a vida esperando pelo barramento de memória, e é por isso que nossas estimativas de throughput para modelos de linguagem são essencialmente a largura de banda dividida pelos pesos lidos, e por isso que a coluna de largura de banda é a que importa em um guia de serving.

Um passo de difusão não funciona assim. Os mesmos pesos são aplicados a um tensor latente de vinte a cinquenta vezes seguidas, e cada passada faz uma quantidade enorme de aritmética por byte buscado. Os pesos ficam residentes; o trabalho é de convoluções e atenção sobre um tensor pequeno. Isso inverte a restrição: um modelo de imagem é limitado pelo throughput do tensor, não pelo barramento de memória. Três coisas decorrem disso, e todas as três custam dinheiro se você errar.

Largura de banda por dólar é um proxy — um proxy aproximado — para a classe de placa que você está olhando, e no nosso catálogo isso coloca NVIDIA RTX 5090 e NVIDIA RTX 4090 em primeiro e segundo lugar por uma margem larga. Isso não é coincidência nem uma barganha que estamos empurrando para você: são as peças projetadas exatamente para esse tipo de aritmética, e elas ficam perto do fim da nossa lista de preços porque o mercado as precifica para jogos, não para clusters de treinamento.

Resolução, lote e vídeo

Os pesos são fixos. O que muda é o conjunto de trabalho, e ele muda com os pixels, não com os parâmetros. O latente em si é insignificante — são as ativações passando pela rede naquela resolução que enchem a placa.

latent_elements = (H / 8) * (W / 8) * C * batch
# C = 4 latent channels on SDXL, 16 on SD 3.5 and FLUX.

# 1024x1024, batch 1, SDXL:
128 * 128 * 4 * 1     = 65,536 elements   = 128 KB in FP16

# 2048x2048, batch 4, SDXL:
256 * 256 * 4 * 4     = 1,048,576         = 2 MB in FP16

# The latent is never the problem. The activations that pass through the
# network at that resolution are, and they scale by the SAME factor:
# doubling the edge quadruples the pixel count, and roughly quadruples
# the working set. Batch multiplies it linearly on top.

Três consequências práticas, na ordem em que você vai encontrá-las:

1. O pico geralmente é a decodificação do VAE, não o loop de amostragem. A decodificação expande o latente de volta à resolução total em uma única passada, e esse momento específico é o que dispara o erro de falta de memória bem no final de um job que vinha rodando bem por um minuto. A decodificação em blocos (tiled) resolve isso e custa um pouco de tempo.
2. Processar em lote é como você aproveita uma placa grande. Se o modelo deixa 20 GB sobrando, quatro imagens de uma vez é um uso muito melhor disso do que uma imagem com folga — os pesos são lidos uma vez para o lote inteiro, que é o único ponto em que um pipeline de difusão se comporta como uma tarefa limitada por largura de banda.
3. Vídeo adiciona uma dimensão, não uma porcentagem. Wan 2.1 video 14B gera um bloco de frames de uma vez, então os frames multiplicam o mesmo conjunto de trabalho que altura e largura já multiplicam. É por isso que um modelo de vídeo de 14 bilhões de parâmetros exige uma placa muito maior que um modelo de imagem de 12 bilhões de parâmetros, e por isso que a tabela de pesos acima subestima isso mais do que qualquer outra linha.

Subindo o ComfyUI

O ComfyUI é uma das imagens que podemos gravar na máquina antes da entrega, o que torna esta seção opcional. Se você preferir montar por conta própria, é um container e um túnel.

$ ssh root@203.0.113.42
$ nvidia-smi --query-gpu=name,memory.total --format=csv

# Checkpoints, LoRAs, ControlNets and VAEs on the fast local NVMe.
# This directory is the reason you are renting by the month.
$ mkdir -p /scratch/comfy/models
$ df -h /scratch

$ docker run -d --name comfy --restart unless-stopped \
    --gpus all --ipc=host \
    -v /scratch/comfy:/data \
    -p 127.0.0.1:8188:8188 \
    your-comfyui-image --listen 0.0.0.0 --port 8188

# From YOUR machine, not the server: a tunnel, then a local browser tab.
$ ssh -N -L 8188:127.0.0.1:8188 root@203.0.113.42
# http://127.0.0.1:8188

O que um mês compra

O motivo pelo qual trabalho com imagem combina com uma máquina mensal não é o preço da GPU. É a biblioteca. Uma instalação séria do ComfyUI são algumas centenas de gigabytes de checkpoints, LoRAs, ControlNets, upscalers e VAEs que você organizou e não quer baixar de novo.

Essa é a coluna para comparar, e é a que as plataformas por hora deixam de fora do destaque. Nelas, o disco é um item de cobrança separado, cobrado por gigabyte por mês, e continua sendo cobrado enquanto a instância está parada — ou você o apaga, e baixa de novo várias centenas de gigabytes na próxima vez que sentar para trabalhar.

Essa é a mesma armadilha que o ponto de equilíbrio por hora descreve, na forma que ela assume para trabalho com imagem. A cobrança por segundo parece segura porque você pode parar a instância, e ninguém para, porque parar significa perder a biblioteca. A pergunta honesta não é "quantas horas vou gerar" e sim "quantas horas essa máquina precisa existir" — e para quem tem um diretório de modelos organizado, a resposta é todas elas. O pagamento é uma transferência em cripto, não há taxa de instalação, e não perguntamos quem você é: os prompts, as LoRAs que você treinou e o trabalho de clientes que você ainda não entregou ficam em uma máquina em que só você tem root.

Quando não alugar uma placa

Preferimos que você não alugue uma dessas e se arrependa, então aqui estão os casos em que a resposta é não.

Em qualquer outro caso — uma biblioteca que você construiu, um pipeline que você está sempre mudando, jobs em lote que rodam durante a noite, ou um trabalho que simplesmente não deveria sair do seu próprio disco — uma placa dedicada por mês é o arranjo mais barato e mais tranquilo. O configurador vai te dizer, para cada nó do catálogo, se o modelo que você tem em mente cabe em uma placa antes de você pagar qualquer coisa.