Imagens IA: Controle Total Com Código!

O Segredo Revelado: Crie Imagens de IA Surrealmente Perfeitas (Rápido e Fácil com Diffusers)!

Olá, pessoal! Aqui é o Lucas Tech, e hoje a gente vai mergulhar de cabeça em algo que eu amo: a criação de imagens com Inteligência Artificial! Se você já tentou gerar umas imagens e sentiu que faltava algo, ou que era lento demais, seus problemas acabaram! Prepare-se, porque vamos transformar você num mago da geração de imagens usando a biblioteca Diffusers, Stable Diffusion e algumas técnicas que vão mudar seu jogo. Bora turbinar suas criações?

Preparando o Terreno: Configuração Essencial

Primeiro passo, como em todo projeto de respeito, é organizar a casa! Vamos garantir que nosso ambiente esteja redondinho, sem conflitos, pra gente poder focar só na criação. É tipo preparar a bancada do seu laboratório secreto de IA! Vamos instalar tudo que precisamos e importar as bibliotecas essenciais. Ah, e fica tranquilo(a), já vamos otimizar tudo pra rodar liso!

Essa primeira leva de código é fundamental. Basicamente, estamos garantindo que todas as dependências estão no lugar certo e que o Pillow (uma biblioteca essencial para processamento de imagens) está na versão ideal. Depois, importamos os módulos do Diffusers que vão ser nossos melhores amigos nesse processo.

php
!pip -q uninstall -y pillow Pillow || true
!pip -q install –upgrade –force-reinstall “pillow<12.0”
!pip -q install –upgrade diffusers transformers accelerate safetensors huggingface_hub opencv-python

import os, math, random
import torch
import numpy as np
import cv2
from PIL import Image, ImageDraw, ImageFilter
from diffusers import (
StableDiffusionPipeline,
StableDiffusionInpaintPipeline,
ControlNetModel,
StableDiffusionControlNetPipeline,
UniPCMultistepScheduler,
)

Ferramentas Úteis para um Workflow Perfeito

Pra gente ter controle total e não se perder no meio do caminho, vamos criar umas funções auxiliares. Elas são pequenas, mas fazem uma diferença GIGANTE! Uma delas vai garantir que suas imagens sejam sempre iguais se você rodar o código de novo (adeus, aleatoriedade indesejada!), e a outra ajuda a organizar várias imagens numa grade, tipo um mural.

Ah, e claro, vamos ver se você está rodando na GPU (placa de vídeo) ou na CPU (processador principal) pra extrair o máximo de desempenho!

php
def seed_everything(seed=42):
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)

def to_grid(images, cols=2, bg=255):
if isinstance(images, Image.Image):
images = [images]
w, h = images[0].size
rows = math.ceil(len(images) / cols)
grid = Image.new(“RGB”, (colsw, rowsh), (bg, bg, bg))
for i, im in enumerate(images):
grid.paste(im, ((i % cols)w, (i // cols)h))
return grid

device = “cuda” if torch.cuda.is_available() else “cpu”
dtype = torch.float16 if device == “cuda” else torch.float32
print(“device:”, device, “| dtype:”, dtype)

O Começo de Tudo: Gerando Imagens Pelo Texto

Agora a mágica começa pra valer! Vamos carregar o coração do nosso sistema: o Stable Diffusion! É ele que vai pegar nossas ideias em texto e transformar em imagens. E pra deixar tudo ainda mais rápido e suave, vamos trocar o ‘motor’ dele por um agendador (scheduler) mais eficiente, o UniPCMultistepScheduler. É como dar um upgrade na performance do seu carro!

Depois, é só escrever o que a gente quer (o ‘prompt’) e o que não quer (o ‘negative_prompt’) e deixar a IA trabalhar. Essa é a nossa imagem de partida, nosso ‘ponto zero’ antes das otimizações e truques que vêm por aí!

php
seed_everything(7)
BASE_MODEL = “runwayml/stable-diffusion-v1-5”

pipe = StableDiffusionPipeline.from_pretrained(
BASE_MODEL,
torch_dtype=dtype,
safety_checker=None,
).to(device)

pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config)

if device == “cuda”:
pipe.enable_attention_slicing()
pipe.enable_vae_slicing()

prompt = “a cinematic photo of a futuristic street market at dusk, ultra-detailed, 35mm, volumetric lighting”
negative_prompt = “blurry, low quality, deformed, watermark, text”

img_text = pipe(
prompt=prompt,
negative_prompt=negative_prompt,
num_inference_steps=25,
guidance_scale=6.5,
width=768,
height=512,
).images[0]

Turbinando a Geração: Velocidade com LoRA e Controle com ControlNet

Bora acelerar esse processo? Sabe aqueles modelos LoRA que estão super em alta? Vamos usar um deles (o LCM-LoRA) pra deixar a geração de imagens muuuito mais rápida, com menos passos de difusão! É impressionante como a gente consegue resultados excelentes em segundos. É tipo botar um turbo na sua IA!

Mas não é só velocidade! E se eu te dissesse que dá pra ‘desenhar’ a estrutura da sua imagem e deixar a IA preencher os detalhes? É exatamente isso que o ControlNet faz! A gente cria um ‘esqueleto’ (aqui, usando bordas Canny) e o ControlNet usa isso como guia pra IA montar a cena. É o casamento perfeito entre sua visão e a criatividade da máquina!

php
LCM_LORA = “latent-consistency/lcm-lora-sdv1-5”
pipe.load_lora_weights(LCM_LORA)

try:
pipe.fuse_lora()
lora_fused = True
except Exception as e:
lora_fused = False
print(“LoRA fuse skipped:”, e)

fast_prompt = “a clean product photo of a minimal smartwatch on a reflective surface, studio lighting”
fast_images = []
for steps in [4, 6, 8]:
fast_images.append(
pipe(
prompt=fast_prompt,
negative_prompt=negative_prompt,
num_inference_steps=steps,
guidance_scale=1.5,
width=768,
height=512,
).images[0]
)

grid_fast = to_grid(fast_images, cols=3)
print(“LoRA fused:”, lora_fused)

W, H = 768, 512
layout = Image.new(“RGB”, (W, H), “white”)
draw = ImageDraw.Draw(layout)
draw.rectangle([40, 80, 340, 460], outline=”black”, width=6)
draw.ellipse([430, 110, 720, 400], outline=”black”, width=6)
draw.line([0, 420, W, 420], fill=”black”, width=5)

edges = cv2.Canny(np.array(layout), 80, 160)
edges = np.stack([edges]*3, axis=-1)
canny_image = Image.fromarray(edges)CONTROLNET = “lllyasviel/sd-controlnet-canny”
controlnet = ControlNetModel.from_pretrained(
CONTROLNET,
torch_dtype=dtype,
).to(device)

cn_pipe = StableDiffusionControlNetPipeline.from_pretrained(
BASE_MODEL,
controlnet=controlnet,
torch_dtype=dtype,
safety_checker=None,
).to(device)

cn_pipe.scheduler = UniPCMultistepScheduler.from_config(cn_pipe.scheduler.config)

if device == “cuda”:
cn_pipe.enable_attention_slicing()
cn_pipe.enable_vae_slicing()

cn_prompt = “a modern cafe interior, architectural render, soft daylight, high detail”
img_controlnet = cn_pipe(
prompt=cn_prompt,
negative_prompt=negative_prompt,
image=canny_image,
num_inference_steps=25,
guidance_scale=6.5,
controlnet_conditioning_scale=1.0,
).images[0]

Toque Final: Edições Locais com Inpainting

Ok, você gerou uma imagem incrível, mas quer mudar só um detalhezinho? Sem problemas! Com o Inpainting, a gente consegue ‘mascarar’ uma área específica da imagem e pedir pra IA criar algo novo só naquele pedacinho. É como ter um editor de fotos superpoderoso, mas que entende o que você quer dizer!

É perfeito pra corrigir falhas, adicionar elementos ou refinar partes sem estragar o resto da sua obra de arte. No final, vamos salvar tudo bonitinho pra você poder conferir cada etapa do nosso processo.

php
mask = Image.new(“L”, img_controlnet.size, 0)
mask_draw = ImageDraw.Draw(mask)
mask_draw.rectangle([60, 90, 320, 170], fill=255)
mask = mask.filter(ImageFilter.GaussianBlur(2))

inpaint_pipe = StableDiffusionInpaintPipeline.from_pretrained(
BASE_MODEL,
torch_dtype=dtype,
safety_checker=None,
).to(device)

inpaint_pipe.scheduler = UniPCMultistepScheduler.from_config(inpaint_pipe.scheduler.config)

if device == “cuda”:
inpaint_pipe.enable_attention_slicing()
inpaint_pipe.enable_vae_slicing()

inpaint_prompt = “a glowing neon sign that says ‘CAFÉ’, cyberpunk style, realistic lighting”

img_inpaint = inpaint_pipe(
prompt=inpaint_prompt,
negative_prompt=negative_prompt,
image=img_controlnet,
mask_image=mask,
num_inference_steps=30,
guidance_scale=7.0,
).images[0]

os.makedirs(“outputs”, exist_ok=True)
img_text.save(“outputs/text2img.png”)
grid_fast.save(“outputs/lora_fast_grid.png”)
layout.save(“outputs/layout.png”)
canny_image.save(“outputs/canny.png”)
img_controlnet.save(“outputs/controlnet.png”)
mask.save(“outputs/mask.png”)
img_inpaint.save(“outputs/inpaint.png”)

print(“Saved outputs:”, sorted(os.listdir(“outputs”)))
print(“Done.”)

Minha Visão

Poxa, que jornada incrível, não é? A gente viu como a biblioteca Diffusers não é só mais uma ferramenta, mas um verdadeiro canivete suíço para quem quer ir além na geração de imagens com IA. Sair de um simples ‘texto pra imagem’ e chegar a um controle tão fino de velocidade, estrutura e até edição localizada, tudo dentro do mesmo framework, é algo revolucionário. Pra mim, isso significa que a barreira entre a ideia e a imagem final está cada vez menor, abrindo um universo de possibilidades para artistas, desenvolvedores e qualquer um que sonhe em dar vida às suas criações digitais de forma eficiente e controlada. É a tecnologia nos capacitando para sermos ainda mais criativos!

E aí, galera tech! Qual dessas ferramentas – o LoRA pra velocidade, o ControlNet pra composição, ou o Inpainting pra retoques – vocês estão mais animados pra testar primeiro nas suas próprias criações de IA? Deixem suas ideias nos comentários!

Referência: Matéria Original