No início de agosto, a até então desconhecida startup Black Forest Labs, ou simplesmente BFL, apresentou outro modelo executável localmente para geração de imagens estáticas com base em prompts de texto – FLUX.1. Mais precisamente, estamos falando aqui de toda uma família de modelos, que inclui:
Tanto de acordo com as declarações dos desenvolvedores, quanto de acordo com as respostas entusiásticas da comunidade de entusiastas que não se cansam de brincar com o FLUX.1 desde o início de agosto, a capacidade, mesmo na versão schnell, de aderir literalmente ao instruções dadas no prompt (o que se chama de adesão imediata) e, mais ainda, para desenhar pincéis humanos. O novo produto é comparável apenas aos principais produtos comerciais nesse quesito – as versões mais recentes do Midjourney e do Dall-E – e é completamente superior às criações do Stable Diffusion, incluindo o SD3M que analisamos recentemente como uma primeira aproximação.
Às vezes, a grama é apenas grama, sem o menor perigo para as meninas retratadas nela (fonte: geração de IA baseada no modelo FLUX.1)
⇡#Talentos e eufemismos
A equipe BFL (alguém provavelmente está indo à moda antiga agora com a referência à “arma definitiva” – BFG do lendário Doom) inclui, em particular, pessoas como Andreas Blattmann, Dominik Lorenz, Patrick Esser (Patrick Esser e Robin Rombach . Os mesmos quatro estão presentes na lista de autores de uma publicação científica fundamental para o atual estágio de desenvolvimento da IA artística generativa – Síntese de Imagens de Alta Resolução com Modelos de Difusão Latente, publicada em abril de 2022. Na verdade, todos eles participaram no desenvolvimento de modelos generativos baseados nos princípios de difusão latente ( Difusão Estável) para a empresa Stability AI (e ainda antes – nos projetos CompVis e RunwayML) e em diferentes momentos a deixaram – para, obviamente, implementar seus próprios abordagem a tais tarefas, não limitada pelas aspirações e planos da gestão externa.
O site oficial bastante esparso da BFL descreve a missão da startup como “desenvolver e promover modelos de aprendizagem profunda generativos de última geração para mídias como imagens e vídeos, e capacitar a criatividade, a eficiência e a diversidade”. Observe que não há menções de “segurança” aqui, que estavam simplesmente repletas com o anúncio não muito tempo atrás do Stable Diffusion 3. Na verdade, com a exibição de meninas (vestidas) na grama, as versões públicas do FLUX .1 estou indo bem. Não é de surpreender que o novo chatbot Grok-2, criação da startup xAI, de propriedade de Elon Musk, se baseie no modelo de desenvolvimento BFL para criar imagens com base nas solicitações dos usuários, embora a escolha no atual mercado de geração de imagens online, especialmente comerciais, seja já excessivamente amplo: a empresa de Musk poderia arcar com qualquer parceria.
Do ponto de vista prático, o FLUX.1 já foi para o povo, como dizem. Nem algumas semanas se passaram desde a abertura do acesso a este modelo (incluindo a versão pro) no popular site de geração de imagens Civitai, e já são geradas quase 90% de todas as imagens que recebem o número máximo de reações por dia. por isso. Apesar do fato de que criar uma imagem com FLUX.1 [dev] “na configuração básica” (20 etapas, sem complementos como LoRA) custa 30 “bz-z-z” (buzz, moeda local que você pode comprar com dinheiro real , você pode ganhar dinheiro coletando reações de outros usuários às suas criações de sucesso) e com FLUX.1 [pro] – até 65 bz-z-z. Considerando que uma geração SDXL (mesmo com uma lista impressionante de LoRAs auxiliares e um grande número de etapas, de 35 a 50) raramente custa mais do que 7 a 12 bz-z-z. Além disso, as versões dev e schnell estão disponíveis para download nos PCs dos usuários do Civitai e do Hugging Face – não quero criar! Sim, eles são um pouco pesados – cerca de 23 GB cada. Sem excluir, aliás, o FLUX.1 [schnell] de alta velocidade: ele ocupa a mesma quantidade de espaço de memória que a versão dev, apenas é otimizado para produzir um resultado decente em todos os aspectos em menos de 20 iterações passos (passos ), como no caso de dev, mas por apenas 4. E embora à primeira vista um tamanho de arquivo tão impressionante possa parecer uma clara desvantagem para proprietários de placas de vídeo com menos de 24 GB de RAM, na prática isso é uma questão que pode ser resolvida e o que exatamente deve ser feito. Para resolvê-la, em breve a analisaremos em detalhes.
Três opções para implementar camadas de atenção paralelas na arquitetura de transformadores para modelos generativos (fonte: University of Colorado Colorado Springs)
Outra coisa é que a teoria do FLUX.1 está longe de ser clara. Para começar, o modelo em si é descrito de forma bastante esparsa por seus criadores, embora os lançamentos dos pontos de verificação Stable Diffusion fossem regularmente acompanhados por pelo menos breves artigos de revisão que esclarecem tanto as características arquitetônicas dos novos produtos quanto as complexidades de a interação do operador com eles: exibir quais objetos e cenas eles podem fazer melhor, o que prestar atenção ao compor dicas, etc. Em relação ao FLUX.1, tudo o que se sabe até agora é que os modelos desta série são construídos sobre com base em uma arquitetura híbrida que combina métodos de transformação e difusão, e que são capazes de escalar até 12 bilhões de parâmetros – deve-se assumir que o valor limite especificado é implementado pela versão “fechada” (disponível apenas através da API nos sites encarregados de hospedá-lo) versão pro. Um método especial de treinamento usando correspondência de fluxo ajuda a alcançar os resultados impressionantes demonstrados, devido aos quais o treinamento do sistema em modelagem generativa é acelerado, bem como a integração em sua composição de incorporação posicional com matrizes de rotação (incorporação posicional rotativa, RoPE) e camadas de atenção paralela (camadas de atenção paralela, PAL).
É graças à implementação bem-sucedida do RoPE que, aparentemente, os modelos FLUX.1 são tão bons em gerar imagens coerentes, ou seja, conectadas com alto detalhe – é quando, por exemplo, uma pessoa está contra o fundo de um cavalo e o as pernas de ambos, levando em consideração as sobreposições mútuas, são renderizadas em total conformidade com a aparência que teriam na realidade, sem se transformarem em uma bagunça homogênea e indistinta. Os PALs, por sua vez, são responsáveis pela consistência mútua de elementos individuais na imagem: digamos, se o sistema for solicitado a representar flores regando de um regador, a água na imagem gerada fluirá exatamente do bico (a menos que a dica de ferramenta declara explicitamente o contrário, é claro); para segurar o regador, quem cuida das flores, mesmo que esteja fora da moldura, vai segurar a alça, a posição da mão nesta alça será bem definida (polegar de um lado, outros quatro do outro) , etc. Os próprios desenvolvedores afirmam que em comparação com Midjourney v6.0, DALL·E 3 (HD) e SD3-Ultra, sua criação – especialmente na versão pro – acaba sendo superior ou pelo menos quase idêntica em quase todos respeitos. Desde subjetivos, como a qualidade da imagem final e sua “estética” (seja lá o que isso signifique), até outros bastante calculáveis matematicamente, como a precisão da correspondência da imagem com o que foi formulado na dica original, bem como a velocidade e eficiência energética de cada geração individual.
Esquerda: Comparação da família de modelos FLUX.1 com os melhores análogos competitivos de acordo com a classificação ELO Score combinada. No centro: comparação de cinco parâmetros dos mesmos modelos em testes subjetivos (qualidade visual, seguir uma dica, variabilidade nos tamanhos e proporções da tela, reprodução da tipografia, variedade de resultados). À direita: a mesma comparação de cinco parâmetros, mas separadamente para a versão schnell e o SD3 Turbo e SDXL Lightning, que são semelhantes em velocidade/consumo de recursos (fonte: BFL)
Outra incerteza importante que preocupou imediatamente os entusiastas do desenho de IA foi o licenciamento vago do middleware FLUX.1 [dev]. Tudo fica claro com a versão schnell: é distribuída sob a licença Apache 2.0, o que implica, em particular, a sua utilização comercial gratuita. Também não há dúvidas quanto ao pro: seus pesos não estão disponíveis publicamente, portanto ninguém de fora pode reivindicar seu uso comercial – apenas pelas imagens que gera. Observemos, para maior clareza, que os resultados da geração de qualquer modelo de IA (pelo menos nos Estados Unidos, cuja jurisdição está sujeita ao BFL) são oficialmente reconhecidos como não protegidos por direitos autorais, mesmo que a semente da imagem resultante tenha sido um texto , voz ou outro prompt composto por uma pessoa. Em outras palavras, uma imagem criada por qualquer uma das variedades FLUX.1 (seja por dinheiro, ou gratuitamente em um site de terceiros, ou no seu próprio PC) não pertence a ninguém – e pode ser usada livremente para ilustrar materiais comerciais, por exemplo. Mas a licença não comercial do FLUX.1 [dev] está escrita em uma linguagem um tanto confusa, o que parece permitir o uso deste modelo para fins de pesquisa (para entusiastas de treinamento com o mesmo LoRA ou inversões de texto baseadas nele) – mas ao mesmo tempo, proíbe seu uso com a finalidade de obter benefícios, ou seja, para criar tais modelos híbridos/derivativos, que seriam então disponibilizados para uso mediante o pagamento de uma taxa. De uma forma ou de outra, como não faremos nenhuma modificação nos modelos FLUX dentro do nosso “Workshop”, iremos gerar fotos a partir deles e publicá-las aqui, e ondetudo o que você quiser é totalmente gratuito para fins de pesquisa/ilustrativos.
⇡#E houve algumas conversas…
Assumiremos que os leitores regulares do nosso “Workshop” já possuem instalações dos ambientes de trabalho AUTOMATIC1111 e ComfyUI implantados em seus computadores. No momento em que escrevo este artigo, apenas ComfyUI e Forge (um projeto relacionado ao AUTOMATIC1111, mas desenvolvido de forma independente) poderiam se orgulhar de suporte total para FLUX, portanto não multiplicaremos as entidades e optaremos por experimentar FLUX – o nome do modelo , aliás, foi claramente escolhido para desvirtuar “Difusão Estável”, pois é traduzido como “movimento contínuo, oscilação, vaidade”, ou seja, uma completa falta de estabilidade – o já familiar ambiente de trabalho ComfyUI. Embora a interface do Forge, que é menos cheia de ação em termos de aplicação às novas séries de modelos da BFL, especialmente aqueles modificados em termos de compressão de checkpoint, receba as críticas mais positivas.
O ciclograma de referência para trabalhar com o ponto de verificação flux1-dev-fp8.safetensors é bastante lacônico
Conforme observado na última edição do Workshop, para experimentar novos modelos faz sentido instalar versões independentes separadas do ambiente de trabalho – felizmente, ele está disponível em uma versão autônoma, que envolve simplesmente descompactar do arquivo baixado para o diretório selecionado , sem instalação “normal” com registro de caminhos e variáveis de ambiente no registro do Windows. Ao mesmo tempo, isso ajuda a manter versões separadas do Python e pacotes adicionais que acompanham cada versão independente do ComfyUI, que protege instalações anteriores totalmente funcionais contra danos acidentais. Portanto, você só precisa baixar a última versão estável (0.1.2 no momento em que este artigo foi escrito), ou seja, o arquivo chamado ComfyUI_windows_portable_nvidia.7z, da página oficial deste ambiente de trabalho no GitHub, e descompactá-lo em seu diretório favorito . No nosso caso, vamos chamá-lo de ComfyUI_012 – apenas com uma indicação direta do número da versão. Lembramos, por precaução, que esta opção é apenas para execução em adaptadores gráficos NVIDIA ou diretamente em uma CPU AMD ou Intel (que, claro, será muito mais lenta): os proprietários de placas de vídeo AMD recebem uma muleta em na forma dos pacotes rocm e pytorch, que podem ser instalados via gerenciador de download pip.
A próxima etapa, como antes, é carregar os modelos executáveis reais. O autor do ambiente de trabalho que é relevante para nós desta vez, ComfyAnonimous, tem um guia bastante detalhado sobre como baixar várias versões do FLUX.1 [dev] e FLUX.1 [schnell] e seus ciclogramas de referência correspondentes – a propósito, o versão mais recente e “acelerada” do modelo, não a utilizaremos ativamente por motivos que serão explicados um pouco mais tarde. Como nosso sistema de teste possui um adaptador gráfico GTX 1070 com apenas 8 GB de memória de vídeo, vamos rolar até o final da página do manual – há uma seção “Versão FP8 Checkpoint simples de usar”. Ele contém um link para um repositório mantido pelo Comfy.Org (a equipe de entusiastas do desenho de IA que se reuniu em torno do ComfyAnonimous após sua saída do Stability AI), onde você pode baixar o arquivo flux1-dev-fp8.safetensors – uma versão truncada do conjunto de pesos para o modelo FLUX.1 [dev]. A questão é que os pesos BFL publicados originalmente estão no formato de ponto flutuante de 16 bits, FP16; e convertê-los (com engrossamento, é claro) em FP8 permite reduzir pela metade a quantidade de memória ocupada pelo modelo – ao custo, é claro, de alguma deterioração nos resultados de seu trabalho. Argumenta-se que a codificação de 8 bits é aproximadamente equivalente a 16 bits em termos de seguir fielmente uma determinada dica e construir imagens coerentes – mas lida pior com pequenos detalhes. De uma forma ou de outra, os proprietários de placas de vídeo de 8 GB não podem ser muito exigentes, então vamos baixar o arquivo especificado e colocá-lo no diretório ComfyUI/models/checkpoints/, padrão para colocar pontos de verificação.
«Com licença”, pergunta o leitor atento que decidiu seguir nosso guia à risca, “de que adianta, ter uma placa de vídeo de 8 GB, baixar até mesmo um modelo despojado se ele ainda ocupa 17,2 GB?” — e este é precisamente o tamanho do arquivo flux1-dev-fp8.safetensors proposto por Comfy.Org. A questão, porém, é que o ComfyUI (como, aliás, já há algum tempo também no Forge) implementou a capacidade de “colar” a RAM do computador com memória de vídeo – perfeitamente para programas executados nesses ambientes de trabalho, mas, é claro claro, com o fornecimento de desempenho menos alto do que se o modelo coubesse inteiramente na RAM de vídeo. No entanto, nosso sistema de teste possui atualmente 24 GB de RAM instalada, então o volume total disponível com memória de vídeo é de 32 GB – isso, estritamente falando, é suficiente para a versão FP16 do FLUX, que não é truncada em precisão (que discutiremos um pouco mais tarde). Sem dúvida, a transferência de dados entre dois tipos diferentes de memória através do barramento do sistema não pode deixar de afetar a velocidade de processamento do modelo – será na casa das dezenas (e seria bom se fossem as primeiras dezenas) de segundos para cada iteração .
O ciclograma para FLUX.1 [dev], que é implementado por um conjunto de submodelos, parece mais complicado, mas também é bastante lógico e consistente
É por isso que para PCs com memória de vídeo inferior a 16 GB é recomendado o uso de FLUX.1 [schnell] – ainda são 4 iterações por imagem, e não 20, com aproximadamente o mesmo tamanho de modelo em bytes. Porém, olhando para o futuro, notamos: FLUX é tão bom que com uma dica bem desenhada é bem possível obter um resultado esteticamente adequado, se não diretamente da primeira, então, condicionalmente, da terceira à oitava tentativa – que isto é, a duração da geração de cada imagem (se comparada com SDXL ou SD3M) é mais frequentemente compensada pela brevidade de uma série de tais imagens até que o usuário esteja satisfeito. É justamente por isso que a criação do BFL é atrativa: permite fugir do modo de “busca semi-cega” familiar aos operadores de “Camião” e “Overseas”, quando o PC está a funcionar em modo loop infinito (a dica e outros parâmetros de geração são estáveis, apenas o valor da semente muda) por uma hora, duas ou mais, produzindo uma imagem a cada 1-3 minutos. E de vez em quando eles abordam isso – mas apenas para verificar se apareceu de repente uma opção esteticamente excelente, adequada para processamento posterior usando a ferramenta inpaint ou um editor gráfico externo. O FLUX, via de regra, produz uma imagem que já é adequada para uso posterior “como está” após um número muito modesto de tentativas. Há, claro, algumas sutilezas aqui, iremos abordá-las em breve, mas a sensação geral do novo modelo é que a extração final do espaço latente de imagens composicional e esteticamente atraentes, à primeira vista, nas quais o operador satisfeito decide parar de gerar de acordo com a dica atual, ele produz emNo geral mais rápido que os anteriores (SD 1.5, SDXL, SD3M), não mais lento. Embora cada imagem individual, para ser honesto, leve minutos e dezenas de minutos para ser gerada.
⇡#Um canal amplo será útil
No material dedicado ao SD3M, já modificamos o arquivo de lançamento do ambiente de trabalho – run_nvidia_gpu.bat – para incluir uma chamada ao módulo Python externo venv (ambientes virtuais; caso o sistema não possua, você sempre pode instale-o) e, pelo contrário, remova uma série de otimizações realizadas especificamente para a versão autônoma. Neste caso, você ainda terá que usar essas otimizações – elas ativam, em particular, a “colagem” da RAM com a memória de vídeo, o que fornecerá ao pesado modelo FLUX a capacidade de rodar no modesto hardware do nosso PC de teste. Portanto – novamente, assumindo que AUTOMATIC1111 com venv já esteja implantado no sistema – vamos criar um novo arquivo BAT de inicialização chamado run_with_venv.bat e o seguinte conteúdo:
@Eco desligado
Eco %cd%
Ligue para ativar.bat
Eco venv ativado
Eco %cd%
Pausa
O parâmetro “–disable-auto-launch” ao iniciar o ambiente de trabalho bloqueia a abertura automática de sua interface web no navegador padrão. Por que deveria ser bloqueado? Sim, porque em um PC constantemente usado, provavelmente muitas abas estão abertas no navegador padrão, e é preferível usar ComfyUI com FLUX em outro que é iniciado tão raramente quanto possível – ou pelo menos, assustador dizer, em o Edge padrão para sistemas Windows. Quanto menos abas abertas, menos espaço na RAM o navegador ocupa, e como a RAM do sistema é colada neste caso com a RAM de vídeo para caber ali um modelo enorme, mais modesta será a lista de programas ativos em um determinado PC quando gera imagens, melhor. Claro, você sempre pode estimar a quantidade de RAM livre através do “Gerenciador de Tarefas”, e se for grande o suficiente, você ainda pode executar algo urgentemente necessário, mas aqueles que inicialmente têm recursos limitados devem usar os recursos computacionais com cuidado especial.
À esquerda está a geração de referência baseada no ciclograma de referência com o modelo flux1-dev-fp8.safetensors do manual ComfyAnonimous; à direita está o resultado da execução do mesmo modelo com os mesmos parâmetros em nosso PC de teste. As diferenças são provavelmente devido a diferenças nas versões venv/pytorch usadas (fonte: geração de IA baseada no modelo FLUX.1)
Depois de iniciar o ambiente de trabalho (o arquivo de modelo, 17,2 GB flux1-dev-fp8.safetensors, deve primeiro ser carregado – e mesmo antes de clicar duas vezes em run_with_venv.bat colocado no diretório ComfyUI/models/checkpoints/) nos favoritos para trabalhar com No seu navegador, de preferência um que não contenha nenhuma aba extra, você deve abrir a interface web em 127.0.0.1:8188 e certificar-se de que ela está acessível. Então, a partir da página já mencionada (sim, ela pode ser aberta temporariamente na próxima aba e fechada após o download), resta baixar o ciclograma de referência para este modelo de autoria do mesmo ComfyAnonimous na forma de um arquivo png – e simplesmente arraste-o com o mouse da janela do Explorer » para o campo de trabalho do ComfyUI. Todos os nós necessários com os parâmetros necessários, incluindo uma dica, serão exibidos imediatamente lá. Clicar no botão “Prompt de fila” na interface pobre do ambiente de trabalho iniciará o ciclograma para execução – e o resultado deverá ser uma imagem geralmente semelhante à original, contendo o ciclograma de referência.
Bem, tudo funciona, embora leve um tempo incrivelmente longo: em vez dos habituais SDXL 6-7 s por iteração (dos quais neste caso foram executados 20 – o parâmetro “steps” no nó “KSampler”) aqui cada iteração leva 60-70 Com. Mais de 20 minutos para uma foto – o quê?!
Olhando um pouco para o futuro, salientamos que, para justificar plenamente o tempo gasto na renderização de imagens com base em instruções de texto, o FLUX.1 requer uma divulgação muito mais completa do seu potencial – vários exemplos disso serão dados no final deste artigo. este artigo. E o primeiro passo para tal divulgação é a transição do ponto de verificação único flux1-dev-fp8.safetensors, que acabamos de usar, para um conjunto modular de submodelos que juntos formam um único FLUX.1 [dev], ou seja, para separar aplicativo:
60-70 s por iteração para FLUX.1 [dev] – isso é normal para 8 GB de RAM de vídeo
Na mesma página do ComfyAnonimous com exemplos estão os links necessários para download de todos os submodelos, tanto para FLUX.1 [dev] quanto para FLUX.1 [schnell]. Para começar, você precisará baixar pelo menos dois arquivos do repositório do submodelo CLIP no Hugging Face: o modelo clip_l necessário – o arquivo clip_l.safetensors (246 MB), bem como uma das duas opções para o modelo t5xxl: o preferido um – t5xxl_fp16.safetensors (9,79 GB) ou duas vezes reduzido (também através da conversão de FP16 para FP8) – t5xxl_fp8_e4m3fn.safetensors (4,89 GB). Recomenda-se usar a versão de 16 bits, que, claro, não caberá inteiramente em nossos 8 GB de RAM de vídeo – e portanto seu uso prolongará ainda mais a geração de imagens. No entanto, no modo de pesquisa livre, quando o ambiente de trabalho é iniciado em um loop infinito com uma mudança aleatória de semente e outros parâmetros inalterados, você só precisará recodificar o texto em tokens uma vez para cada dica – e, portanto, não faz sentido sacrificar a precisão neste caso. Além disso, a qualidade do trabalho do codificador afeta diretamente a qualidade da imagem final como um todo, da composição à paleta de cores, e não apenas nos detalhes finos, como no caso do submodelo UNet – por isso vale apostar nos quase 10 GB t5xxl_fp16 desde o início.
⇡#Orelhas ficam para fora
Então, vamos colocar os dois codificadores CLIP baixados no diretório ComfyUI/models/clip/. Em seguida, você precisará baixar o modelo UNet FLUX.1 [dev] – do próprio repositório BFL no Hugging Face ou da página do modelo especificado no Civitai. Este arquivo (flux-dev.safetensors) em sua codificação original de 16 bits ocupa 23,8 GB, e sua versão FP8 de um repositório alternativo (flux1-dev-fp8.safetensors) ocupa 11,9 GB. Você deve colocar um deles (ou ambos, se o espaço livre na partição lógica permitir) – atenção! – para o diretório ComfyUI/models/UNet/ – exatamente /UNet, não /checkpoints; precisamente porque este não é um ponto de verificação separado totalmente funcional, mas apenas um submodelo do conjunto. Aliás, não se deve confundir arquivos com tamanhos diferentes, mas sim com os mesmos nomes “flux1-dev-fp8.safetensors”, localizados nas pastas /checkpoints e /UNet: no primeiro há um checkpoint completo (obtido por ComfyAnonimous, presumivelmente, mesclando variantes FP8 de submodelos CLIP (grande) e UNet com a adição de um clip_l quase sem peso e o arquivo VAE correspondente), e no segundo – o mesmo submodelo UNet único. Façamos aqui uma ressalva ao mesmo tempo que a terminologia adotada neste caso é no mínimo controversa: o modelo do codificador T5XXL não é do tipo CLIP, e a implementação FLUX da formação de imagens no espaço latente através de transformadores (que mencionamos brevemente acima) difere da tecnologia UNet – mas de um ponto de vista prático isto não é muito significativo.
Agora só falta baixar o submodelo VAE do repositório oficial do BFL no Hugging Face – este é um arquivo de 335 MB chamado “ae.sft”, que pode ser colocado como está no diretório ComfyUI/models/vae/, ou primeiro renomeado para “ae.safetensors” – a versão atual do ComfyUI aceitará ambas as extensões. ComfyAnonimous também possui uma imagem com um ciclograma de referência para um conjunto de submodelos – vamos arrastá-lo do Explorer para o campo de trabalho e verificar se todos os nomes dos submodelos nos nós correspondentes correspondem àqueles com os quais vamos trabalhar. Por precaução, é melhor clicar no botão “Atualizar” na interface do ambiente de trabalho para atualizar as informações sobre o conteúdo dos diretórios. No nó “Load Diffusion Model”, por exemplo, flux1-dev-fp8.safetensors (versão UNet, não um ponto de verificação completo!) deve ser selecionado, no nó “DualCLIPLoader” – t5xxl_fp16.safetensors e clip_l.safetensors em as posições necessárias, e no nó “Load VAE” – ae.safetensors. Você não precisa mexer em mais nada – você pode iniciar o ComfyUI para execução.
No canto superior esquerdo está a geração de referência do ciclograma de referência com o modelo flux-dev.safetensors de 16 bits do manual ComfyAnonimous; canto superior direito – o resultado da execução do mesmo ciclograma com o modelo UNet flux1-dev-fp8.safetensors em nosso PC de teste, canto inferior esquerdo – também geração local, mas com flux-dev.safetensors de 16 bits, canto inferior direito – a mesma dica , seed, versões CLIP e outros parâmetros de geração, mas o submodelo principal é a versão FP8 do FLUX.1 [schnell] (fonte: geração de IA baseada no modelo FLUX.1)
Para a implementação FP8 do FLUX.1 [dev] com um conjunto de submodelos em nosso PC de teste, a velocidade média de execução foi de 72 s por iteração. Decente, é claro, mas apenas um pouco mais do que usar o ponto de verificação combinado do FP8 com o qual começamos. É interessante que se em vez de flux1-dev-fp8.safetensors no nó “Load Diffusion Model” você selecionar o submodelo UNet de 16 bits flux-dev.safetensors (assumindo que foi possível bombear quase 24 GB dele sem dificuldade), a qualidade nos detalhes melhorará um pouco – basta olhar atentamente para as íris dos olhos da raposa na foto e para os babados de seu avental – e a velocidade de execução permanecerá essencialmente a mesma, 74 s/it. E está claro o porquê: o modelo de formação de imagem no espaço latente em ambos os casos não cabe inteiramente na memória de vídeo, o que obriga o ambiente de trabalho a transferir continuamente dados entre o sistema e a RAM de vídeo – neste contexto, as diferenças entre 12 e 24 Os arquivos GB estão quase ocultos. Agora, se nosso adaptador gráfico tivesse pelo menos 12 GB de memória, a imagem seria fundamentalmente diferente.
Mencionemos brevemente que o FLUX.1 [schnell] em nosso sistema de teste (novamente, disponível no repositório já mencionado) também roda com uma velocidade típica semelhante – 67 s/it. Claro, se você considerar que são necessárias apenas 4 etapas para completar a imagem, o tempo total de geração é sensivelmente reduzido. Mas a qualidade geral, ou seja, o impacto estético subjetivo da imagem no espectador, é, em nossa opinião, menor na versão Schnell (veja a comparação acima de gerações obtidas usando modelos diferentes), portanto, pelo menos nesta fase, nós não entraremos em detalhes.
⇡#Você encomendou um quarteto?
Outro ponto importante: se para SD 1.5 a resolução nativa básica era de 0,25 megapixels (tela 512 × 512 pixels), para SDXL – 1 megapixel (1024 × 1024), então o FLUX foi treinado, segundo os desenvolvedores, em uma seleção extremamente ampla de teste imagens com resoluções de 0,1 a 2,0 megapixels. Ou seja, sem nenhum recurso adicional – Contratações. correção, ADetailer, etc. — o modelo permite gerar imediatamente imagens em uma tela, digamos, 1920 × 1072 pixels (cerca de 2 megapixels). Com todos os detalhes necessários, com a óbvia ausência de artefatos de ampliação, etc. – embora, é claro, ao custo de um processamento ainda mais longo de cada uma das 20 etapas básicas da geração. Mas, para ser sincero, às vezes vale a pena: foi graças às excelentes habilidades do FLUX.1 [dev] que, literalmente na terceira tentativa, conseguimos obter uma imagem completamente adequada de 2 megapixels de uma águia e um panda lutando. Ainda que a uma velocidade de 141 s/it., mas praticamente em qualidade fotográfica e sem contaminação mútua, o que nunca conseguimos sem o uso de ferramentas adicionais. E aqui – por favor, e mesmo em formato tão grande!
Separar com precisão objetos significativamente diferentes em uma imagem sem que propriedades significativas fluam entre eles – quando um panda tem cabeça de águia, uma águia tem patas com garras pretas, etc. – para os modelos SD 1.5 e SDXL a tarefa é quase impossível: seus codificadores CLIP são simplesmente não foi projetado para desafios semelhantes. A SD3M alcançou um progresso inegável neste sentido, como mostramos da última vez, precisamente graças ao envolvimento de três codificadores ao mesmo tempo, incluindo o T5XXL. Mas o FLUX.1 atinge uma altura que é verdadeiramente inatingível neste aspecto – pelo menos para outros modelos distribuídos gratuitamente que podem ser executados no PC para jogos mais poderoso.
Ilustremos esta ousada tese com o exemplo de uma imagem inspirada na famosa fábula de Krylov “Quarteto”. Lembramos que a composição de um quarteto de cordas clássico inclui dois violinos, uma viola e um violoncelo, e na maioria das vezes retratam um urso desajeitado com violoncelo (violoncelo inglês), uma cabra com viola (viola) e um violino é dado a um macaco travesso e a um burro. Digamos que o macaco deva tocar não um instrumento de tamanho real (violino), mas uma versão “folk”, mais simples (violino), e comporemos o seguinte, não muito extenso, mas repleto de dicas de detalhes:
Pintura digital hiper-realista de quatro animais em pé em um gramado repleto de flores: burro, macaco, urso e cabra. O burro toca violino, o macaquinho toca violino, o enorme urso toca violoncelo, a cabra toca viola
E aqui está: depois da quinta vez, o sistema gerou a partir dela uma imagem que corresponde quase exatamente à descrição – o que seria estranho de esperar até mesmo do SD3M. Aqui, até o macaco quase deixa cair o arco, até o urso bate no violoncelo, como um verdadeiro baixista de jazz no contrabaixo – ou seja, esta imagem seria bastante adequada como ilustração para a fábula original. Esta imagem em sua forma original (um arquivo PNG com um ciclograma integrado, que você pode simplesmente arrastar e soltar na área de trabalho do ComfyUI para experimentação adicional), como as outras gerações apresentadas aqui baseadas no modelo FLUX, pode ser baixada para download independente. estudar.
Os parâmetros de geração são quase padrão (como no ciclograma de referência ComfyAmonimous para a versão dev), apenas no nó “BasicScheduler” a opção “beta” está selecionada; modelo – FLUX.1 [dev] 32 bits, seed – 368019150651752, dica – no texto do artigo (fonte: geração de IA baseada no modelo FLUX.1)
A rigor, este é apenas o começo de nosso conhecimento do FLUX.1 [dev]. Este modelo, lembre-se, tem dois codificadores CLIP de texto em tokens – e, como mostra a prática, definir dicas para eles separadamente (acordados mutuamente, mas diferentes) fornece melhores resultados do que usar o mesmo texto para ambos, conforme implícito na referência ComfyAnonimous nós nos exemplos que vimos. Há também uma completa ausência de uma dica negativa – não porque o modelo não saiba como remover certas entidades da imagem, e não apenas adicioná-las, mas porque o parâmetro CFG nos ciclogramas de referência é igual a um – e isso é um ponto fundamental; em valores mais elevados, o sistema literalmente quebra. Aplicar uma dica negativa a uma imagem extraída do espaço latente requer definir o CFG pelo menos na posição 2 – e, portanto, simplesmente não faz sentido trabalhar com um nó adicional. Sim, já existem maneiras de contornar essa limitação e ainda fazer o FLUX.1 [dev] funcionar com negações, mas elas não são padronizadas.
Além disso: entre outros nós dos ciclogramas há um que nenhum dos modelos de Difusão Estável possuía – ele define uma “recomendação”, orientação, com valor padrão de 3,5. Acontece que diminuir esse valor leva a maior liberdade criativa do modelo devido ao aumento do desvio de uma determinada dica, e aumentá-lo, ao contrário, leva a uma adesão ainda mais literal a ele (mas com diminuição de detalhes). Esta é uma espécie de análogo do parâmetro CFG anterior, cujo significado de mudança era aproximadamente o mesmo, mas que agora, dada a arquitetura seriamente redesenhada do modelo, desempenha um papel visivelmente menor (e é precisamente por isso que os desenvolvedores recomendamos configurá-lo estritamente para “1”). Além disso, há outro novo nó “ModelSamplingFlux”: os parâmetros nele especificados são de particular importância ao trabalhar com telas não padronizadas – nos modelos anteriores não havia necessidade de tal ajuste.
Há muito mais sutilezas com o uso (sem falar no treinamento) do LoRA para FLUX.1, com modelos ControlNet específicos para ele, com gerações em cascata – quando, por exemplo, a primeira execução é feita com alto valor de orientação para registra com precisão os elementos básicos especificados nas dicas da imagem, e o segundo (no modo não texto para imagem, mas imagem para imagem) toma como base a saída do primeiro e, com um baixo valor de orientação, enriquece com todos os tipos de detalhes extraordinários… E isso sem falar nos métodos mais eficazes para compactar a imagem original do que o arquivo de modelo FP8, que ainda permitem encaixar um UNet totalmente funcional (que na verdade, como já mencionado, é não exatamente um UNet) em 8, 6 e até 4 GB de RAM de vídeo. E certamente falaremos sobre isso – e não só sobre isso!
Materiais relacionados:
A Apple recentemente relaxou as regras para serviços de jogos em nuvem na App Store,…
O interesse do Departamento de Justiça dos EUA nas atividades da Nvidia no mercado de…
O Departamento de Justiça dos EUA, conforme relatado pela Bloomberg, começou a convidar oficialmente a…
Antes do lançamento do jogo arcade de corrida de mundo aberto Test Drive Unlimited Solar…
O Google lançou oficialmente o Android 15, mas por enquanto apenas para desenvolvedores. Um lançamento…
A Samsung apresentou o primeiro laptop da nova série Galaxy Book5 - o modelo Galaxy…