FLUX 3 Image Klein na prática: resultados impressionantes

Autoria: Prompt Engineer 48 · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: FLUX 3 Image Klein Hands-On is CRAZY · Canal: Prompt Engineer 48 · 05:13 · Assistir no YouTube

Tópicos: Geração de conteúdo com IA, Infraestrutura e hardware de IA, Modelos locais e open source, Modelos multimodais

Resumo

O vídeo demonstra a instalação e o uso do FLUX 3 Image Klein em uma GPU A40 alugada no RunPod, incluindo geração de imagens, edição, uso de múltiplas referências e layout com caixas delimitadoras. O modelo tem 5,6 bilhões de parâmetros, e a versão destilada gera imagens em cerca de 10 segundos, embora o upsampler de prompt possa acrescentar bastante tempo devido à troca entre CPU e GPU. Nos testes, o upsampler produziu mais detalhes e texto mais legível; a geração com múltiplas referências foi menos consistente entre seeds. A sessão custou cerca de 65 centavos de tempo de GPU, e a licença é gratuita para empresas com receita anual inferior a US$ 5 milhões.

Pontos-chave

O modelo tem 5,6 bilhões de parâmetros e os pesos ocupam cerca de 43 GB.
A demonstração usa uma GPU A40 com 48 GB de VRAM no RunPod, por US$ 0,59 por hora.
O modelo oferece geração de texto para imagem, edição de uma imagem e geração com até 10 imagens de referência.
O prompt upsampler transforma prompts curtos em descrições de cena mais detalhadas; no teste, levou 40 segundos para expandir um prompt de sete palavras.
Com o upsampler ativado, a imagem de uma loja de ramen teve mais detalhes e texto legível em comparação com o resultado sem o recurso.
A geração com múltiplas referências pode misturar as cenas; o apresentador recomenda testar mais de um seed.
As caixas delimitadoras orientam o posicionamento e a escala dos objetos, mas não funcionam como máscaras rígidas.
A geração usou menos de 23 GB de memória; a troca entre o upsampler e o modelo de imagem foi o principal fator de demora.
Segundo o vídeo, a licença é gratuita para empresas com receita anual inferior a US$ 5 milhões.

Capítulos

Início	Capítulo	Resumo
00:01	Modelo, recursos e licença	O apresentador apresenta o modelo, seus recursos, o prompt upsampler e as condições de licença.
01:04	Configuração no RunPod e instalação	Ele configura uma A40 no RunPod, obtém acesso aos pesos e ajusta o pipeline após um erro no upsampler.
02:07	Upsampler e geração de texto para imagem	O vídeo mostra a expansão de um prompt curto e compara imagens geradas com e sem o upsampler.
03:39	Edição, múltiplas referências e layout	O apresentador testa edição de imagem, combinação de referências e posicionamento de objetos com caixas delimitadoras.
04:41	Desempenho, custo e conclusão	Ele resume os tempos, o uso de memória, o custo da sessão e as condições da licença.

Citações

A versão destilada roda em 16 etapas, sem guidance. — 00:33

Neste teste, o upsampler me deu mais detalhes e texto legível. — 03:07

Com múltiplas referências, experimente mais de um seed. — 04:10

A parte lenta é a troca entre o upsampler e o modelo de imagem, não o modelo de imagem em si. — 04:41

Conceitos e entidades

FLUX 3 Image Klein (modelo): Modelo de geração e edição de imagens com 5,6 bilhões de parâmetros demonstrado no vídeo.
Black Forest Labs (empresa): Empresa indicada no vídeo como responsável pelo modelo.
RunPod (ferramenta): Plataforma usada para alugar e acessar a GPU A40 na demonstração.
A40 (ferramenta): GPU com 48 GB usada para executar o modelo no RunPod.
Diffusers (ferramenta): Biblioteca instalada para carregar o pipeline e baixar os pesos do modelo.
Gradio (ferramenta): Ferramenta usada para criar uma interface simples para os testes de geração e edição.
Hugging Face (empresa): Plataforma onde o apresentador aceitou a licença e criou um token para acessar os arquivos do modelo.
prompt upsampler (conceito): Modelo de linguagem separado que expande um prompt curto em uma descrição detalhada antes da geração da imagem.
multi-reference generation (conceito): Geração de imagens que usa várias imagens de referência para orientar o resultado.
bounding box layout (conceito): Método que orienta a posição e a escala de objetos por meio de caixas em uma grade.

Tradução completa (pt-BR)

00:01 5,6 bilhões de parâmetros, uma GPU A40 alugada e cerca de 10 segundos por imagem. Isso é o Flux Klein, e a máquina inteira custa 59 centavos por hora. Certo. Neste vídeo, vamos instalar o FLUX.3 image Klein no RunPod e executar quatro coisas em um pequeno app Gradio: texto para imagem, edição, geração com múltiplas referências e layout com caixas delimitadoras. Vale lembrar que os pesos têm cerca de 43 GB, por isso aluguei uma GPU em vez de usar meu laptop. Vamos testar. Então, o que é? É um modelo de 5,6 bilhões

00:33 de parâmetros da Black Forest Labs, lançado em 15 de outubro. Se você olhar aqui na página do modelo, ele faz texto para imagem, edição de imagem única e geração com múltiplas referências, com até 10 imagens de referência. A versão destilada roda em 16 etapas, sem orientação, e a licença é gratuita para empresas com receita anual inferior a US$ 5 milhões. Agora, há uma linha neste cartão que é fácil deixar passar. Ela diz: “Não use o modelo sem um upsampler de prompt.” Esse é um modelo de linguagem separado, de 18,8 GB, chamado Klein Pup, e ele transforma um

01:04 prompt curto em uma descrição completa da cena antes que o modelo de imagem o processe. Para a máquina, escolhi uma A40 com 48 GB no RunPod Secure Cloud, no data center EUS-E1. Custa 59 centavos por hora. Adicionei um disco de 120 GB para os pesos, usei o template RunPod PyTorch 2.8 e ativei o Jupyter para poder acessar um terminal. O acesso ao modelo é restrito, então você aceita a licença no Hugging Face e fornece um token ao pod. O token que eu tinha salvo no RunPod era do ano passado, e aqui você pode ver

01:36 que o Hugging Face respondeu que o nome de usuário ou a senha eram inválidos. Criei um token novo, e os arquivos passaram a ser baixados com acesso autorizado. Depois, um script instala a versão mais recente do diffusers pelo GitHub e baixa os pesos. Ignorei o checkpoint nativo duplicado e as variantes quantizadas, então foram baixados 37 GB, e toda a configuração ficou pronta em cerca de 3 minutos. Agora, foi aqui que fiquei preso. A versão mais recente do diffusers tem o upsampler integrado ao pipeline, então minha primeira execução travou com este erro: “non type object has no attribute apply chat template”.

02:07 O que você pode fazer é remover do pipeline o bloco de upsampling do prompt e executar o upsampler por conta própria. Deixo ele na CPU e só o movo para a GPU quando necessário. Meu primeiro prompt de teste tinha sete palavras: um bisão em uma paisagem geotérmica enevoada. O upsampler transformou isso em uma descrição de 227 palavras em 40 segundos, e a imagem levou 9,9 segundos. O pico de memória foi de 22,8 GB. Então, coloquei tudo isso em um pequeno app Gradio. À esquerda, há uma caixa de prompt, um espaço para adicionar imagens de referência, uma

02:37 caixa de seleção do upsampler, uma seed e uma caixa de layout. À direita, fica o resultado e, abaixo dele, a descrição exata enviada ao modelo. Primeiro, texto para imagem: digito “uma aconchegante casa de ramen à noite, na chuva”. Deixo o upsampler ligado, uso a seed três e clico em gerar. A primeira espera foi de cerca de 2 minutos porque o modelo alternou entre a CPU e a GPU, então acelerei o vídeo. E dá para ver que a placa diz “ramen aberto até tarde”. O quadro do menu está legível, e há um chef e dois clientes.

03:07 A etapa de geração da imagem em si levou 10,6 segundos. Agora, o mesmo prompt e a mesma seed, mas com o upsampler desligado. Esta terminou em cerca de 10 segundos porque não foi preciso alternar entre dispositivos. Dá para ver que ainda é uma boa imagem: a fachada de uma loja na chuva, mas a cena é mais simples e a placa não tem texto legível em inglês. Então, neste teste, o upsampler me deu mais detalhes e texto legível. Repare na diferença entre uma boa imagem e uma imagem com problemas. A seguir, uma edição. Adiciono a imagem do bisão e digito “mesma cena à noite, sob uma lua cheia, vapor iluminado por trás, luz azul fria”. Cerca de 70 segundos depois, você

03:39 consegue ver a lua, a luz azul e o mesmo bisão no mesmo terreno. A etapa de edição levou 20,6 segundos. Agora, múltiplas referências. Envio o bisão e a casa de ramen e peço que o bisão apareça dentro da loja. Com a seed um, dá para ver o bisão em pé no chão molhado, em frente ao balcão, sob as luzes quentes. Essa etapa levou 33,3 segundos. Mas quero ser honesto aqui. Com a seed zero, esse tipo de prompt misturou as

04:10 duas cenas. O chão geotérmico apareceu ao lado do bule e dentro da loja. Fiz cinco tentativas com três prompts, e duas ficaram boas, ambas com a seed um. Então, ao usar múltiplas referências, teste mais de uma seed. Por último, um layout com caixas delimitadoras. No prompt, marquei a maçã e o bule e, na caixa de layout, dei uma caixa para cada um em uma grade de 0 a 1.000. A caixa da maçã fica à esquerda, e a do bule, à direita. Dá para ver que a maçã aparece à esquerda e o bule à direita, e levou 9,7 segundos. O

04:41 cartão do modelo diz que as caixas definem o posicionamento e a escala, não uma máscara rígida; portanto, trate-as como orientação. Então, aqui estão os números deste teste. A40, texto para imagem: cerca de 10 segundos. Edição: 20,6. Múltiplas referências: 33,3. Layout: 9,7. A memória fica abaixo de 23 GB durante a geração. A parte lenta é a alternância entre o upsampler e o modelo de imagem, não o modelo de imagem em si. Em termos de custo, toda a sessão na A40, desde o aluguel do pod até a última gravação, custou cerca de 65 centavos de tempo de GPU.

05:13 E lembre-se da licença: é gratuita para empresas com receita anual inferior a US$ 5 milhões; caso contrário, você precisa de uma licença diferente. Então, neste vídeo, vimos como executar o FLUX.3 image Klein em uma A40 alugada no RunPod, com texto para imagem, edição, múltiplas referências e layout. Se tiver interesse, pode testar isso no seu próprio pod também e me contar como foi. O modelo é da Black Forest Labs. Até a próxima. Confira o próximo vídeo.

Transcrição original

[00:01] 5.6 billion parameters, one rented A40 GPU, and about 10 seconds a picture. That is Flux recline, and the whole machine costs 59 cents an hour. All right. In this video, we will install Flux three image client on RunPod and run four things in one small radio app: text to image, and edit a multi-reference shot, and a bounding box layout. Now, mind you, the weights are about 43 GB, which is why I rented a GPU instead of using my laptop. Let’s go ahead and test this out. So, what is it? It is a 5.6 billion

[00:33] parameter model from Forest Labs released on October 15th. If you look here on the model page, it does text to image, single image editing, and multi-reference generation with up to 10 reference images. The distilled version runs in 16 steps with no guidance, and the license is free for companies under $5 million in yearly revenue. Now, there is one line on this card that is easy to miss. It says, “Do not use the model without a prompt upsampler.” That is a separate 18.8 GB language model called Klein pup, and it turns a

[01:04] short prompt into a full scene caption before the image model sees it. For the machine, I picked an A40 with 48 GB on RunPod secure cloud in the EUS-E1 data center. It is 59 cents an hour. I added a 120 GB disk for the weights, used the RunPod PyTorch 2.8 template, and turned Jupiter on so I can reach a terminal. The model is gated, so you accept the license on Hugging Face and give the pod a token. The token I had saved on RunPod was from last year, and you can see here

[01:36] Hugging Face answered invalid username or password. I made a fresh token, and the files came back with access. Then, one script installs the latest diffusers from GitHub and downloads the weights. I skipped the duplicate native checkpoint and the quantized variants, so it pulled 37 GB, and a whole setup was done in about 3 minutes. Now, here’s where I got stuck. The newest diffusers has the upsampler built into the pipeline, so my first run crashed with this error, non type object has no attribute apply chat template.

[02:07] What you can do is remove the prompt upsample block from the pipeline and run the upsampler yourself. I keep it on the CPU and move it to the GPU only when it is needed. My first test prompt was seven words, a bison in a misty geothermal landscape. The upsampler turned it into a 227 word caption in 40 seconds and the image took 9.9 seconds. Peak memory was 22.8 gigabytes. So, I wrapped this in a small Gradio app. On the left, there is a prompt box, a place to drop reference images, a

[02:37] checkbox for the upsampler, a seed, and a layout box. On the right is the result and below it the exact caption that was sent to the model. First text to image, I type a cozy ramen shop at night in the rain. Keep the upsampler on seed three and click generate. That first wait was about 2 minutes because the model swapped between CPU and GPU, so I sped it up. And you can see the sign reads ramen open late. The menu board is readable and there’s a chef and two customers.

[03:07] The image step itself took 10.6 seconds. Now, the same prompt and the same seed with the upsampler off. This one finished in about 10 seconds because nothing has to swap. You can see it is still a good image, a rainy shop front, but the scene is simpler and the sign is not readable English. So, on this one test, the upsampler gave me more detail and readable text. Note the difference between a good image and a broken one. Next, an edit. I drop in the bison image and type same scene at night under a full moon steam lit from behind cool blue light. About 70 seconds later, you

[03:39] can see the moon, the blue light, and the same bison standing in the same terrain. The edit step took 20.6 seconds. Now, multi reference. I upload the bison and the ramen shop and ask for the bison standing inside the shop. With seed one, you can see the bison is standing on the wet floor in front of the counter under the warm lamps. This step took 33.3 seconds. But, I want to be honest here. With seed zero, this kind of prompt blended the

[04:10] two scenes instead. With geothermal ground showing up next to the teapot and inside the shop, I tried five runs on three prompts and two came out clean, both with seed one. So, with multi-reference, try more than one seed. Last one, a bounding box layout. In the prompt, I tagged the apple and the teapot, and in the layout box, I give each a box on a 0 to 1,000 grid. The apple box is on the left, the teapot box is on the right. You can see the apple lands on the left and the teapot on the right, and it took 9.7 seconds. The

[04:41] model card says boxes set placement and scale, not a hard mask, so treat them as guidance. So, here are the numbers from this. A40, text to image, about 10 seconds. Edit, 20.6. Multi-reference, 33.3. Layout, 9.7. Memory stays under 23 GB during generation. The slow part is the swap between the upsampler and the image model, not the image model itself. Cost-wise, the whole session on the A40 from renting the pod to the last recording was about 65 cents of GPU

[05:13] time. And remember the license, free under $5 million in yearly revenue, otherwise you need a different license. So, in this video, we have seen how we can run Flex 3 image client on a rented RunPod A40 with text to image, edit, multi-reference, and layout. If you’re interested, you can go ahead and try this on your own pod as well, and let me know how it goes. The model is from Black Forest Labs. I’ll see you in another one. Check out the next video.