Corrija automaticamente rostos e mãos de IA em centenas de imagens com o ComfyUI e o Flux

Um fluxo em lote que encontra as mãos e os rostos numa pasta de imagens de IA, re-renderiza só essas áreas em resolução maior com o Flux e salva as imagens corrigidas: máscaras do Florence 2 mais o SEGS detailer do Impact Pack.

Anton Tenitsky13 de outubro de 20265 min de leituraVersão em vídeo abaixo

Este guia foi traduzido do inglês com IA e pode conter erros. Leia o original.

Uma comparação de antes e depois de uma guerreira gerada com um sabre de luz vermelho, com as mãos e o rosto re-renderizados

Imagens de IA muitas vezes saem com mãos quebradas e rostos estranhos, sobretudo em tomadas de corpo inteiro. Corrigi-las uma a uma não funciona quando você tem centenas. Este fluxo faz em lote: percorre uma pasta, encontra as mãos (e os rostos) por descrição, re-renderiza só essas áreas com o Flux em resolução maior e salva a imagem corrigida.

Ele precisa do Flux, então pelo menos 12 GB de VRAM. Se você só precisa corrigir uma imagem ocasional à mão, meu fluxo de inpainting para mãos, mais simples, também roda na nuvem.

Em resumo

  • Encontrar: o Florence 2 mascara «hands» ou «face» a partir de uma descrição em texto.
  • Corrigir: o SEGS detailer do Impact Pack recorta essa área, renderiza a 512 px e a cola de volta.
  • Ajustes: 20 steps, denoise 0,65–0,7.
  • Espere repetir: muitas tentativas não ficam boas; fique com a melhor.
  • Cascata: corrija as mãos e depois passe essa imagem a um segundo detailer para o rosto.

Por que as mãos dão errado, e como isto resolve

As mãos geralmente quebram por causa da resolução, não porque o modelo não saiba desenhá-las. Renderize um retrato em close com uma mão junto ao rosto, e a mão ocupa muitos pixels e sai bem. Numa imagem de corpo inteiro, a mesma mão recebe só alguns pixels, e é daí que vêm os dedos extras. Na minha imagem de teste o rosto estava bom e as mãos não.

Então o fluxo faz o que um retocador faria: recorta a área problemática, a amplia, a redesenha em detalhe e a põe de volta.

Fluxo 1: corrija um elemento numa pasta

Carregue a pasta

Load Image Batch com o caminho da pasta colado e o modo em incremental image, para cada execução pegar a próxima imagem. Um nó de pré-visualização mostra em qual imagem está.

Encontre as mãos com o Florence 2

O pacote ComfyUI-Florence2 fornece o carregador do modelo; o modelo é baixado automaticamente na primeira execução. Usei o large (fine-tuned); o base é mais rápido e também deu bons resultados, então eu tentaria esse da próxima vez.

O nó carregador do modelo Florence 2 e o grupo de extração de máscara no ComfyUI
O modelo Florence 2 alimenta o grupo de extração de máscara.

No nó do Florence 2, defina a tarefa como caption to phrase grounding e digite o que encontrar, aqui «hands». O Florence 2 faz muito mais (descrever uma imagem, ler texto), mas esta tarefa é a que encontra uma área a partir de uma frase e devolve a sua máscara. Falo mais disso em mascarando qualquer coisa com o Florence 2.

Uma pré-visualização de máscara mostrando a área branca onde as mãos foram encontradas
A máscara que o Florence 2 encontrou para «hands».

Suavize a máscara e transforme-a em um segmento

  • O Gaussian Blur Mask suaviza as bordas, porque uma máscara de borda dura pode deixar uma emenda visível.
  • O Mask to SEGS transforma a máscara num segmento, o formato com que o detailer trabalha.

Re-renderize com o SEGS detailer

O nó Detailer (SEGS) do Impact Pack recorta cada segmento e o escala de modo que o seu guide size seja 512 px, proporcionalmente. Isso dá à mão muito mais pixels com que trabalhar, e é daí que vem a melhora.

O nó Detailer SEGS com guide size 512, 20 steps, CFG 1.0, sampler euler e denoise 0,65
O detailer: guide size 512, 20 steps, denoise 0,65.

Ele recebe as mesmas entradas de uma geração normal:

  • Modelo: Flux dev, VAE e o DualCLIPLoader com os dois codificadores de texto do Flux.
  • Prompt positivo com Flux Guidance. Escrevi algo como «two hands, five fingers»; funciona mesmo quando só uma mão está visível. O negativo fica vazio.

Só dois ajustes realmente importam:

  • Steps: 20. De 20 a 30 funciona, e 20 é sinceramente bom o bastante.
  • Denoise: 0,65–0,7. É quanto da área original é redesenhado. Abaixo de cerca de 0,5, o modelo cria algo aleatório ali (um veículo no lugar de uma mão, ou outro rosto). Em 0,9 ele mantém a mesma mão quebrada.

Compare e salve

Um rgthree image comparer mostra o antes e o depois, e o resultado é salvo. As mãos corrigidas às vezes saem um pouco menores, embora não seja muito perceptível.

Espere rodar várias vezes

Esta é a parte importante: muitas vezes de 60 a 80% das tentativas não ficam boas. Rode repetidamente e escolha as melhores.

Uma mulher gerada de terno branco meditando numa nave espacial, do lote sendo corrigido
Uma imagem do lote. Aqui a máscara pegou a figura inteira e redesenhou tudo.

Às vezes o resultado surpreende. Numa imagem a máscara deu defeito e cobriu a figura inteira, então o detailer redesenhou tudo: corrigiu a mão escondendo-a, melhorou o rosto e os pés, e mudou bastante o desenho do terno. É o que você obteria com um prompt como «person». Em outra imagem, as mãos saíram piores do que antes. Continue rodando.

Fluxo 2: mãos e depois rosto

Para corrigir o rosto também, encadeie um segundo detailer:

  1. O primeiro grupo mascara as mãos e as corrige, como acima.
  2. A imagem de saída dele vai para uma segunda extração de máscara, buscando «face», e um segundo SEGS detailer.
Uma comparação de antes e depois de uma guerreira com um sabre de luz vermelho, mãos e rosto corrigidos
Mãos corrigidas na primeira passada, o rosto na segunda.

No meu teste o rosto passou de não muito humano a convincente, e uma mão saiu ótima (a outra precisou de mais algumas execuções).

Não duplique nós de modelo. Cada nó que carrega um modelo o mantém na memória da GPU. Carregue o Florence 2, o Flux, os codificadores de texto e o VAE uma vez e conecte-os a todos os detailers. Duplicados enchem a sua VRAM muito rápido sem nenhum benefício.

Dá para continuar encadeando (botas, depois fundo), mas fica impraticável rápido. Mãos e rostos são onde importa.

Opcional: várias pastas de uma vez

Também montei uma versão que passa três pastas pela mesma correção, todas compartilhando os mesmos nós de Florence 2, Flux, codificador de texto e VAE. Sinceramente, é mais um teste do que algo de que você precise. Mas se você tem conjuntos diferentes (medieval, fantasia, ficção científica) com correções diferentes para cada um, duplique os grupos, dê a cada um seu próprio Load Image Batch e conecte-os aos modelos compartilhados.

Um grande grafo do ComfyUI com três grupos de nós de máscara e detailer compartilhando os mesmos carregadores de modelo
Três pastas, um único conjunto de modelos compartilhados.

Todos os fluxos estão no meu Patreon, e o fluxo de inpainting de correção única está no RunComfy com minutos de teste gratuitos. Se você não tem 12 GB de VRAM, uma GPU alugada também serve; veja minha introdução ao RunPod.

O link do RunComfy é um link de indicação, assim como meu link de indicação do RunPod: novas contas do RunPod que se cadastram com o Google ganham de US$ 5 a US$ 500 em crédito após seus primeiros US$ 10, e eu recebo uma pequena comissão.

Assista à versão em vídeo (10:11)

Tudo o que está acima também está no vídeo, se você preferir acompanhar na tela. O vídeo está em inglês.

Perguntas frequentes

Por que a IA erra mãos e rostos em imagens de corpo inteiro?

Resolução. Numa imagem de corpo inteiro, uma mão ou um rosto recebe poucos pixels. O mesmo modelo renderiza bem as mãos num close. A correção é recortar essa área, renderizá-la em resolução maior e colá-la de volta.

Que denoise devo usar para corrigir mãos?

Entre 0,65 e 0,7. Abaixo de cerca de 0,5 o modelo inventa algo aleatório ali; em 0,9 ele mantém a mão quebrada.

Com que frequência a correção funciona?

Nem sempre: nas minhas execuções, muitas vezes de 60 a 80% das tentativas não ficavam boas. Rode várias vezes e fique com o melhor resultado.

Quanta VRAM preciso?

Pelo menos 12 GB para o Flux. Carregue cada modelo uma vez e conecte-o a todos os detailers, porque nós de modelo duplicados ocupam memória cada um.

Anton Tenitsky é artista 3D com mais de 15 anos em computação gráfica, que trabalhou com Nickelodeon, Gameloft, Marvel Rivals e muitos outros clientes. Mais sobre mim

Guias relacionados