Skip to content

Instantly share code, notes, and snippets.

@kleysonr
Last active June 14, 2025 19:27
Show Gist options
  • Save kleysonr/e2e11ede17cb4bcaecf587d3fb35a6d1 to your computer and use it in GitHub Desktop.
Save kleysonr/e2e11ede17cb4bcaecf587d3fb35a6d1 to your computer and use it in GitHub Desktop.
ComfyUI

Introdução

Source: https://github.com/Acly/krita-ai-diffusion/blob/main/ai_diffusion/presets/models.json

A função do clip_vision é extrair uma representação numérica (vetor de embedding) de uma imagem, de forma que essa representação possa ser comparada com textos ou usada como condição visual em modelos como o Stable Diffusion, IP-Adapter, ControlNet, entre outros.

Ou seja, o clip_vision é o encodificador visual do modelo CLIP (Contrastive Language–Image Pre-training), criado pela OpenAI. Ele transforma imagens em vetores, assim como o CLIP textual transforma textos em vetores — e ambos ficam no mesmo espaço vetorial, permitindo comparações entre texto e imagem.

Para que serve na prática?

1. Comparar imagens com textos

  • O clip_vision gera embeddings visuais.
  • O clip_text (outro componente do CLIP) gera embeddings de texto.
  • CLIP foi treinado para alinhar esses dois mundos: a imagem de “um cachorro” e o texto “a dog” estarão próximos no espaço vetorial.

2. IP-Adapter

  • O clip_vision pega uma imagem de referência (ex: um rosto ou estilo) e a transforma em um vetor.
  • Esse vetor é usado como condição (guidance) para gerar novas imagens parecidas ou no mesmo estilo.
  • Ele atua como condição de similaridade visual, influenciando o denoising no Stable Diffusion.

3. ControlNet e outras pipelines

  • Também pode ser usado como parte da entrada para controlar o conteúdo da imagem gerada, com base em uma imagem real ou estilizada.

Estrutura simplificada do CLIP

Texto → CLIP Text Encoder → vetor textual

Imagem → CLIP Vision Encoder → vetor visual

Se os dois vetores forem semelhantes, o CLIP acha que o texto descreve bem a imagem.

Exemplo prático no IP-Adapter

  1. Você fornece uma imagem de referência (por exemplo, o rosto de uma pessoa).
  2. O clip_vision gera um vetor.
  3. Esse vetor é passado ao IP-Adapter, que adapta o processo de geração para manter as características visuais da imagem.

Arquitetura (ViT-H vs ViT-G)

1. clip-vision_vit-h.safetensors

  • ViT-H (Vision Transformer - Huge): É uma versão grande do transformer visual da OpenAI.
  • Tamanho da imagem típico: 224×224 ou 336×336
  • Mais leve que o ViT-G, com menos parâmetros.
  • Geralmente usado em modelos baseados no Stable Diffusion 1.x / 2.1.
  • Indica que é usado com o IP-Adapter padrão, geralmente com Stable Diffusion 1.5 ou 2.1.
  • Arquitetura menor, útil em workflows mais leves ou compatíveis com versões anteriores do SD.

2. clip-vision_vit-g.safetensors

  • ViT-G (Vision Transformer - Giant): É uma versão ainda maior e mais poderosa do que ViT-H.
  • Usada no CLIP da versão SDXL (Stable Diffusion XL).
  • Treinada para ter maior capacidade de representação visual.
  • Requer mais memória e processamento.
  • Ideal para IP-Adapters voltados ao SDXL, que capturam mais detalhes visuais de imagem para imagem.
  • Pertence à pasta sdxl_models, sugerindo uso com Stable Diffusion XL.
  • Necessário para IP-Adapters para SDXL, que trabalham com resoluções maiores e contextos mais complexos.

Download

Os arquivos de clip_vision hospedados em https://huggingface.co/h94/IP-Adapter não são os originais fornecidos pela OpenAI. Eles são cópias ou reempacotamentos feitas pelo time do IP-Adapter, adaptadas para funcionar diretamente com suas pipelines, especialmente no ComfyUI.

Repositório: h94/IP-Adapter

  • É o repositório oficial do projeto IP-Adapter (criado por pesquisadores da Tencent).
  • Ele hospeda arquivos prontos para uso nos pipelines de geração de imagem, não necessariamente os pesos originais da OpenAI.

Os modelos CLIP originais

  • São da OpenAI, publicados originalmente em: https://github.com/openai/CLIP
  • Pesos oficiais estão disponíveis na forma .pt ou .pkl, não .safetensors.

O que foi feito no IP-Adapter. Os autores pegaram os encoders CLIP (como ViT-H, ViT-G) e:

  • Reconvertaram os modelos para o formato .safetensors;
  • Ajustaram os caminhos e estrutura de pastas;
  • Repackearam conforme o pipeline deles (ex: pasta sdxl_models/ para SDXL, models/ para SD 1.5);
  • Alteraram os nomes de arquivos para facilitar uso plug-and-play no ComfyUI.

Eles usam os mesmos pesos base, mas em formato e estrutura adaptados para uso prático no IP-Adapter e ComfyUI.

Introdução

Source: https://github.com/Acly/krita-ai-diffusion/blob/main/ai_diffusion/presets/models.json

ControlNet é uma extensão do Stable Diffusion que permite controlar com precisão a geração de imagens usando entradas auxiliares (imagens de pose, profundidade, bordas, rabiscos, etc.).

Por que isso é importante?

O Stable Diffusion padrão gera imagens a partir de texto, mas não tem controle estrutural — se você quiser uma pose específica, ou manter o layout de um cômodo, é quase impossível só com prompt.

O ControlNet resolve isso: ele “vê” a estrutura da imagem de entrada e obriga o modelo a segui-la.

Exemplo de entradas para ControlNet:

  • Um esqueleto de pose (OpenPose)
  • Um desenho de linhas (Lineart)
  • Um depth map
  • Um rabisco simples
  • Um QR code
  • Uma máscara para inpainting

O que são ControlNets com LoRA integrado?

LoRA (Low-Rank Adaptation) é uma técnica leve de fine-tuning que permite adaptar modelos grandes com baixo custo computacional, usando arquivos pequenos.

Então, o que é um ControlNet com LoRA?

É um modelo ControlNet compactado em um formato LoRA, com tamanho menor (geralmente 100–300MB) e que usa menos memória de GPU.

Ele funciona em conjunto com o modelo base, adicionando só o que é necessário para condicionar a imagem.

Comparando lado a lado

Característica ControlNet Completo ControlNet com LoRA
Tamanho do modelo Grande (700MB a 2GB) Pequeno (100–300MB)
Uso de memória GPU Mais alto Menor
Velocidade de carregamento Mais lento Mais rápido
Modularidade Menos modular Altamente modular
Compatibilidade Ampla (Automatic1111, ComfyUI, etc.) Requer suporte a LoRA
Aplicação prática Mais estável para uso intensivo Ideal para múltiplas variações e setups leves

Quando usar cada um?

Situação Recomendo usar...
Você quer mais precisão e robustez ControlNet completo
Está com GPU limitada (menos VRAM) ControlNet com LoRA
Precisa trocar rapidamente modelos LoRA
Vai montar uma pipeline altamente modular LoRA
Precisa do melhor resultado possível ControlNet completo

No ComfyUI, como se comportam?

  • ControlNet completo → usa um ControlNet Loader padrão.
  • ControlNet com LoRA → usa LoRA ControlNet Loader, combinando com um base model (geralmente control_v11p_sd15_xxx).

O que é esse repositório?

comfyanonymous é o repositório oficial mantido pelos desenvolvedores do ComfyUI ou pela comunidade central que o impulsiona. Ele hospeda modelos de ControlNet otimizados e compatíveis com o ComfyUI e derivados do Stable Diffusion 1.5.

É seguro baixar modelos desse repositório. Ele é usado por milhares de usuários da comunidade e é amplamente considerado confiável.

Modelos ControlNet

Modelos ControlNet especializados, otimizados para uso com Stable Diffusion 1.5 (SD15). Cada um tem uma função diferente para controlar ou condicionar a geração da imagem com base em informações auxiliares (como linhas, bordas, partes faltantes, etc.).

  • Todos são modelos .fp16, ou seja, com precisão de 16 bits (menor consumo de VRAM, ideal para GPUs com menos memória).
  • Requerem ComfyUI, Automatic1111 (com extensão ControlNet) ou outras UIs compatíveis com ControlNet.

Abaixo explico cada um deles:

1. (control_v11p_sd15_inpaint_fp16.safetensors)[https://huggingface.co/comfyanonymous/ControlNet-v1-1_fp16_safetensors/resolve/main/control_v11p_sd15_inpaint_fp16.safetensors]

  • Função: Inpainting — preencher ou reimaginar partes faltantes ou mascaradas da imagem.
  • Uso típico: remover objetos, restaurar partes danificadas, alterar seletivamente regiões da imagem.
  • Input: imagem com máscara (geralmente preta e branca).

2. (control_v11p_sd15_lineart_fp16.safetensors)[https://huggingface.co/comfyanonymous/ControlNet-v1-1_fp16_safetensors/resolve/main/control_v11p_sd15_lineart_fp16.safetensors]

  • Função: Lineart — usar um desenho de linhas (contornos) como base para gerar imagem colorida.
  • Uso típico: colorização de artes lineares, transformar esboços em imagens realistas ou estilizadas.
  • Input: imagem de contorno (line art) em preto e branco.

3. (control_v11p_sd15_softedge_fp16.safetensors)[https://huggingface.co/comfyanonymous/ControlNet-v1-1_fp16_safetensors/resolve/main/control_v11p_sd15_softedge_fp16.safetensors]

  • Função: Soft Edge Detection — captura as bordas suaves de uma imagem.
  • Uso típico: manter a estrutura e silhueta da imagem de entrada enquanto estiliza ou redesenha.
  • Input: mapa de bordas (edge map), geralmente gerado com algoritmos como HED (Holistically-Nested Edge Detection).

4. (control_v1p_sd15_qrcode_monster.safetensors)[https://huggingface.co/monster-labs/control_v1p_sd15_qrcode_monster/resolve/main/control_v1p_sd15_qrcode_monster.safetensors]

  • Função: QR Code embedding — permite gerar imagens que mantêm o QR Code funcional dentro da arte.
  • Uso típico: transformar QR Codes em ilustrações criativas sem comprometer a leitura por scanners.
  • Input: imagem de QR Code.

5. (control_v11p_sd15_canny_fp16)[https://huggingface.co/comfyanonymous/ControlNet-v1-1_fp16_safetensors/resolve/main/control_v11p_sd15_canny_fp16.safetensors]

  • Função: Canny Edge Detection — usa contornos extraídos por algoritmo de bordas rígidas (Canny).
  • Uso típico: gerar imagens mantendo a silhueta e estrutura da imagem de entrada com alta fidelidade.
  • Input: imagem com bordas Canny (preto e branco), destacando os contornos principais.

Modelos ControlNet integrado com LoRA

Os modelos listados abaixo agora são ControlNets com LoRA integrado (Low-Rank Adaptation) — indicados pelo prefixo control_lora_rank128_ — o que os diferencia dos primeiros modelos que são full weights (pesos completos do ControlNet).

1. (control_lora_rank128_v11f1e_sd15_tile_fp16)[https://huggingface.co/comfyanonymous/ControlNet-v1-1_fp16_safetensors/resolve/main/control_lora_rank128_v11f1e_sd15_tile_fp16.safetensors]

  • Função: Tile-based control — ajuda a gerar imagens com continuidade e consistência de padrões repetitivos ou pequenos blocos.
  • Uso comum: aumentar resolução, gerar imagens grandes com coerência local.
  • Input: imagem normal; o modelo segmenta e guia com base em tiles.

2. (control_lora_rank128_v11f1p_sd15_depth_fp16)[https://huggingface.co/comfyanonymous/ControlNet-v1-1_fp16_safetensors/resolve/main/control_lora_rank128_v11f1p_sd15_depth_fp16.safetensors]

  • Função: Depth Map — usa um mapa de profundidade (distância dos objetos da câmera) como guia.
  • Uso típico: manter a perspectiva e distância dos objetos.
  • Input: mapa de profundidade (gerado por MiDaS, ZoeDepth, etc.)

3. (control_lora_rank128_v11p_sd15_normalbae_fp16)[https://huggingface.co/comfyanonymous/ControlNet-v1-1_fp16_safetensors/resolve/main/control_lora_rank128_v11p_sd15_normalbae_fp16.safetensors]

  • Função: Surface Normals — usa o mapa de normais 3D da superfície.
  • Uso típico: manter o senso de volume, profundidade e ângulo da luz.
  • Input: normal map (cores RGB representam orientação da superfície).

4. (control_lora_rank128_v11p_sd15_openpose_fp16)[https://huggingface.co/comfyanonymous/ControlNet-v1-1_fp16_safetensors/resolve/main/control_lora_rank128_v11p_sd15_openpose_fp16.safetensors]

  • Função: OpenPose (skeleton) — guia a geração da imagem com base em um esqueleto de pose humana.
  • Uso típico: replicar poses específicas com precisão anatômica.
  • Input: imagem com skeleton renderizado (gerado por OpenPose ou ferramentas similares).

5. (control_lora_rank128_v11p_sd15_scribble_fp16)[https://huggingface.co/comfyanonymous/ControlNet-v1-1_fp16_safetensors/resolve/main/control_lora_rank128_v11p_sd15_scribble_fp16.safetensors]

  • Função: Scribble — usa rabiscos simples como guia.
  • Uso típico: transformar esboços soltos ou desenhos infantis em artes completas.
  • Input: imagem com traços soltos e simples.

6. (control_lora_rank128_v11p_sd15_seg_fp16)[https://huggingface.co/comfyanonymous/ControlNet-v1-1_fp16_safetensors/resolve/main/control_lora_rank128_v11p_sd15_seg_fp16.safetensors]

  • Função: Semantic Segmentation — usa mapas de segmentação semântica (cores diferentes para partes da imagem: céu, pessoa, carro...).
  • Uso típico: controle fino do conteúdo por área (ex: “céu aqui”, “floresta ali”).
  • Input: imagem com regiões segmentadas por cor (pode ser gerado por DeepLab, etc.)

Resumo visual (para clareza):

Modelo Tipo de Input Finalidade Principal
tile Imagem Detalhe repetitivo, upscale coerente
depth Depth map Manter perspectiva e distância
normalbae Mapa de normais (RGB) Preservar volume e forma
openpose Skeleton (pose) Recriar poses humanas específicas
scribble Rabiscos simples Geração criativa a partir de traços
seg Segmentação semântica Divisão lógica por áreas (céu, chão, etc.)

Introdução

Source: https://github.com/Acly/krita-ai-diffusion/blob/main/ai_diffusion/presets/models.json

Mesmas explicações e conceitos como no ControleNet SD15. Mas estes modelos são para Stable Diffusion XL.

Modelos

1. (control_v1p_sdxl_qrcode_monster.safetensors)[https://huggingface.co/monster-labs/control_v1p_sdxl_qrcode_monster/resolve/main/diffusion_pytorch_model.safetensors]

  • Função: QR Code embedding com suporte ao modelo SDXL
  • Uso típico: Permite gerar imagens artísticas onde o QR Code permanece funcional e legível, mesmo inserido visualmente em composições complexas.
  • Input: Uma imagem de QR Code puro (em preto e branco).
  • Modelo base: Compatível com Stable Diffusion XL (SDXL).
  • Exemplo de aplicação: Criar pôsteres, rótulos ou ilustrações com QR Codes integrados visualmente à arte sem perder sua capacidade de ser escaneado.
  • Origem: Desenvolvido por Monster Labs.

2. (controlnet-union-sdxl-1.0_promax.safetensors)[https://huggingface.co/xinsir/controlnet-union-sdxl-1.0/resolve/main/diffusion_pytorch_model_promax.safetensors]

  • Função: Modelo multimodal com suporte a múltiplas condições (multi-condition ControlNet)
  • Uso típico: Permite combinar vários tipos de controle simultaneamente, como depth, canny, pose, lineart, normal maps, etc., usando uma única instância de ControlNet, ideal para fluxos otimizados.
  • Input: Pode receber múltiplas condições ao mesmo tempo (ex: mapa de profundidade + canny + normal).
  • Modelo base: Compatível com SDXL.
  • Exemplo de aplicação: Criar imagens com maior precisão e controle, com menos carga computacional e maior coerência visual entre os tipos de input.
  • Origem: Desenvolvido por xinsir, com base na ideia de unificar os ControlNets separados.

Fontes

monster-labs/control_v1p_sdxl_qrcode_monster

  • Autor: Monster Labs
  • Tipo de conta: Verificada e ativa no Hugging Face.
  • Reputação: É o criador original de vários modelos voltados à incorporação de QR Codes nas artes com Stable Diffusion e ControlNet.
  • Confiabilidade: ✅ Alta. A comunidade utiliza extensivamente esses modelos, especialmente para projetos com QR Codes funcionais. O control_v1p_sdxl_qrcode_monster é uma versão otimizada para o SDXL da linha anterior v1p_sd15.

xinsir/controlnet-union-sdxl-1.0

  • Autor: xinsir
  • Tipo de conta: Usuário individual (não verificado institucionalmente).
  • Reputação: Reconhecido entre desenvolvedores avançados e usuários do ComfyUI por contribuições que otimizam e integram múltiplos ControlNets em um só modelo, o que reduz uso de VRAM e melhora compatibilidade com SDXL.
  • Confiabilidade: ⚠️ Moderada a Alta. Apesar de não ser de uma instituição, o modelo tem boa aceitação técnica, é funcional e é usado em fluxos compartilhados em fóruns como CivitAI, ComfyUI Discord e Reddit.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment