Diffusion Modelleri
Gürültüden Görüntüye.

import numpy as np
import matplotlib.pyplot as plt

# ── Noise schedule (linear DDPM) ─────────────────────────────
T = 1000
beta_start, beta_end = 1e-4, 0.02
betas = np.linspace(beta_start, beta_end, T)          # (T,)

alphas = 1.0 - betas
alpha_bar = np.cumprod(alphas)                        # ᾱ_t

def forward_sample(x0: np.ndarray, t: int) -> tuple:
    """x_t = sqrt(ᾱ_t) * x0 + sqrt(1 - ᾱ_t) * ε"""
    ab = alpha_bar[t]
    eps = np.random.randn(*x0.shape)
    x_t = np.sqrt(ab) * x0 + np.sqrt(1.0 - ab) * eps
    return x_t, eps

# ── 5 adım görselleştirme ────────────────────────────────────
np.random.seed(42)
x0 = np.random.randn(64, 64)               # sahte 64×64 görüntü
timesteps = [0, 100, 250, 500, 750, 999]

for t in timesteps:
    x_t, _ = forward_sample(x0, t)
    signal_ratio = alpha_bar[t]
    noise_ratio = 1.0 - alpha_bar[t]
    print(f"t={t:4d} | ᾱ_t={signal_ratio:.4f} | "
          f"sinyal: {signal_ratio*100:.1f}% | gürültü: {noise_ratio*100:.1f}%")

# t=   0 | ᾱ_t=0.9999 | sinyal: 99.9% | gürültü:  0.1%
# t= 100 | ᾱ_t=0.9486 | sinyal: 94.9% | gürültü:  5.1%
# t= 250 | ᾱ_t=0.7939 | sinyal: 79.4% | gürültü: 20.6%
# t= 500 | ᾱ_t=0.4647 | sinyal: 46.5% | gürültü: 53.5%
# t= 750 | ᾱ_t=0.1534 | sinyal: 15.3% | gürültü: 84.7%
# t= 999 | ᾱ_t=0.0001 | sinyal:  0.0% | gürültü:100.0%

import torch
import numpy as np

# ── Basitleştirilmiş DDPM sampling loop ──────────────────────
def ddpm_sample(model, shape, betas, device="cuda"):
    """T adım geri giderek x_T'den x_0 üret."""
    T = len(betas)
    alphas = 1.0 - betas
    alpha_bar = torch.cumprod(torch.tensor(alphas), dim=0).to(device)

    # x_T: saf gürültüden başla
    x = torch.randn(*shape).to(device)

    model.eval()
    with torch.no_grad():
        for t in reversed(range(T)):         # T-1, T-2, ..., 0
            t_tensor = torch.full((shape[0],), t, dtype=torch.long).to(device)

            # Model gürültüyü tahmin eder
            eps_pred = model(x, t_tensor)           # ε_θ(x_t, t)

            # μ_θ hesapla
            alpha_t = alphas[t]
            alpha_bar_t = alpha_bar[t]
            beta_t = betas[t]

            coef = beta_t / torch.sqrt(1.0 - alpha_bar_t)
            mu = (1.0 / torch.sqrt(torch.tensor(alpha_t))) * (x - coef * eps_pred)

            # t=0 adımında gürültü ekleme
            if t > 0:
                z = torch.randn_like(x)
                sigma_t = torch.sqrt(torch.tensor(beta_t))
                x = mu + sigma_t * z
            else:
                x = mu                               # son adımda gürültüsüz

    return x                                         # x_0: üretilen görüntü

# ── Kullanım örneği ──────────────────────────────────────────
# model = UNet(...)  # eğitilmiş denoising U-Net
# betas = np.linspace(1e-4, 0.02, 1000)
# images = ddpm_sample(model, shape=(4, 3, 64, 64), betas=betas)
# # images: (4, 3, 64, 64) tensor, 4 üretilen görüntü

import torch
import torch.nn.functional as F

def train_step(model, optimizer, x0_batch, alpha_bar, device):
    """DDPM L_simple: tek eğitim adımı."""
    batch_size = x0_batch.size(0)

    # 1. Her örnek için rastgele t seç: t ∈ [0, T-1]
    t = torch.randint(0, len(alpha_bar), (batch_size,), device=device)

    # 2. Gerçek gürültü örnekle: ε ~ N(0, I)
    eps = torch.randn_like(x0_batch)

    # 3. x_t oluştur: reparameterization
    ab = alpha_bar[t].view(-1, 1, 1, 1)           # broadcast için reshape
    x_t = torch.sqrt(ab) * x0_batch + torch.sqrt(1.0 - ab) * eps

    # 4. Model gürültüyü tahmin eder
    eps_pred = model(x_t, t)

    # 5. L_simple: MSE(ε_pred, ε_gerçek)
    loss = F.mse_loss(eps_pred, eps)

    # 6. Backprop + optimizer adımı
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    return loss.item()

# ── Eğitim döngüsü ───────────────────────────────────────────
# for epoch in range(num_epochs):
#     for x0_batch in dataloader:
#         x0_batch = x0_batch.to(device)
#         loss = train_step(model, optimizer, x0_batch, alpha_bar, device)
#         # Tipik kayıp: başlangıçta ~1.0, yakınsayınca ~0.05-0.15

import numpy as np

T = 1000
t_arr = np.arange(T)

# ── 1. Linear schedule (DDPM orijinal) ──────────────────────
beta_linear = np.linspace(1e-4, 0.02, T)
alpha_bar_linear = np.cumprod(1.0 - beta_linear)
snr_linear = alpha_bar_linear / (1.0 - alpha_bar_linear)

# ── 2. Cosine schedule (IDDPM / Improved DDPM) ──────────────
s = 0.008                                           # offset sabiti
f_t = np.cos((t_arr / T + s) / (1 + s) * np.pi / 2) ** 2
f_0 = np.cos(s / (1 + s) * np.pi / 2) ** 2
alpha_bar_cosine = f_t / f_0
alpha_bar_cosine = np.clip(alpha_bar_cosine, 0, 0.9999)
snr_cosine = alpha_bar_cosine / (1.0 - alpha_bar_cosine)

# ── 3. Karras (EDM) sigma schedule ──────────────────────────
sigma_min, sigma_max = 0.002, 80.0
rho = 7.0                                          # EDM önerilen
step = t_arr / (T - 1)
sigma_karras = (
    sigma_max ** (1 / rho) + step *
    (sigma_min ** (1 / rho) - sigma_max ** (1 / rho))
) ** rho

# ── Karşılaştırma: SNR @ t=[0, 250, 500, 750, 999] ──────────
checkpoints = [0, 250, 500, 750, 999]
print(f"{'t':<6} {'SNR-Linear':<14} {'SNR-Cosine':<14}")
for t in checkpoints:
    print(f"{t:<6} {snr_linear[t]:<14.4f} {snr_cosine[t]:<14.4f}")
# t=0    SNR ~ 10000  (neredeyse temiz görüntü)
# t=500  Linear~0.86, Cosine~1.0 (daha dengeli)
# t=999  SNR ~ 0.0001 (tamamen gürültü)

from diffusers import UNet2DConditionModel

# SD 1.5 UNet yapısını yükle ve incele
unet = UNet2DConditionModel.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    subfolder="unet"
)

print("--- UNet Yapısı ---")
print(f"In channels:  {unet.config.in_channels}")    # 4 (latent)
print(f"Out channels: {unet.config.out_channels}")   # 4 (gürültü tahmini)
print(f"Cross-attn dim: {unet.config.cross_attention_dim}")  # 768
print(f"Block channels: {unet.config.block_out_channels}")
# (320, 640, 1280, 1280) — her encoder seviyesinin kanal sayısı

# Parametre sayısı
params = sum(p.numel() for p in unet.parameters())
print(f"Toplam parametre: {params/1e6:.1f}M")          # ~860M

# Down blocks: encoder
for i, block in enumerate(unet.down_blocks):
    print(f"Down {i}: {type(block).__name__}")
# Down 0: CrossAttnDownBlock2D  (resnet + cross-attention)
# Down 1: CrossAttnDownBlock2D
# Down 2: CrossAttnDownBlock2D
# Down 3: DownBlock2D           (sadece resnet)

# Mid block: bottleneck
print(f"Mid: {type(unet.mid_block).__name__}")
# Mid: UNetMidBlock2DCrossAttn

import torch
from diffusers import AutoencoderKL
from PIL import Image
from torchvision import transforms

# ── VAE yükle ────────────────────────────────────────────────
vae = AutoencoderKL.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    subfolder="vae",
    torch_dtype=torch.float16
).to("cuda")

# ── Görüntüyü latent uzaya encode et ────────────────────────
transform = transforms.Compose([
    transforms.Resize((512, 512)),
    transforms.ToTensor(),
    transforms.Normalize([0.5], [0.5])          # [-1, 1] aralığına normalize
])

img = Image.open("input.jpg").convert("RGB")
pixel_tensor = transform(img).unsqueeze(0).half().to("cuda")
print(f"Piksel tensör: {pixel_tensor.shape}")        # (1, 3, 512, 512)

with torch.no_grad():
    latent_dist = vae.encode(pixel_tensor)
    latent = latent_dist.latent_dist.sample()
    latent = latent * vae.config.scaling_factor      # SD'de 0.18215
print(f"Latent tensör: {latent.shape}")             # (1, 4, 64, 64)

# ── Latent'i tekrar görüntüye decode et ─────────────────────
with torch.no_grad():
    latent_unscaled = latent / vae.config.scaling_factor
    decoded = vae.decode(latent_unscaled).sample    # (1, 3, 512, 512)

# Tensor → PIL Image
decoded = (decoded.clamp(-1, 1) + 1) / 2           # [0, 1] aralığına
decoded_pil = transforms.ToPILImage()(decoded[0].cpu().float())
decoded_pil.save("reconstructed.jpg")
# Encode → Decode süreci görüntüde minimal kayıp oluşturur

import torch
from diffusers import StableDiffusionPipeline, DDIMScheduler

pipe = StableDiffusionPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    torch_dtype=torch.float16
).to("cuda")
pipe.scheduler = DDIMScheduler.from_config(pipe.scheduler.config)

# ── CFG'nin dahili çalışması (konseptüel) ───────────────────
def cfg_step(unet, latents, t, cond_emb, uncond_emb, cfg_scale):
    """Tek bir CFG denoising adımı."""
    # Her iki embeddingyi birleştir → tek forward pass
    latents_doubled = torch.cat([latents, latents])
    emb_doubled = torch.cat([uncond_emb, cond_emb])

    noise_pred = unet(latents_doubled, t, encoder_hidden_states=emb_doubled).sample
    noise_uncond, noise_cond = noise_pred.chunk(2)

    # CFG formülü: ε = ε_uncond + w * (ε_cond - ε_uncond)
    noise_guided = noise_uncond + cfg_scale * (noise_cond - noise_uncond)
    return noise_guided

# ── Basit kullanım (pipeline'ı kullanarak) ───────────────────
prompt = "a majestic snow leopard on a mountain peak, photorealistic"
negative = "blurry, low quality, cartoon, deformed"

for cfg in [3.0, 7.5, 12.0]:
    image = pipe(
        prompt,
        negative_prompt=negative,
        guidance_scale=cfg,
        num_inference_steps=30,
        generator=torch.Generator().manual_seed(42)
    ).images[0]
    image.save(f"cfg_{cfg}.png")

import torch
from diffusers import (
    StableDiffusionPipeline,
    DPMSolverMultistepScheduler,
    DDIMScheduler,
)

# ── Pipeline yükle ───────────────────────────────────────────
model_id = "runwayml/stable-diffusion-v1-5"
pipe = StableDiffusionPipeline.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    variant="fp16"
).to("cuda")

# ── Scheduler değiştir: DPMSolver (daha hızlı, kaliteli) ────
pipe.scheduler = DPMSolverMultistepScheduler.from_config(
    pipe.scheduler.config
)

# Bellek optimizasyonu (opsiyonel)
pipe.enable_attention_slicing()                   # düşük VRAM için
# pipe.enable_model_cpu_offload()                  # 6GB VRAM için
# pipe.enable_xformers_memory_efficient_attention() # hız için

# ── Temel parametrelerle görüntü üret ───────────────────────
prompt = "cinematic photo of a futuristic city at dusk, neon lights, "
prompt += "ultra detailed, 8k, photorealistic"
negative = "ugly, blurry, low resolution, watermark, text, deformed"

generator = torch.Generator(device="cuda").manual_seed(2024)

result = pipe(
    prompt=prompt,
    negative_prompt=negative,
    num_inference_steps=25,           # DPMSolver ile 25 yeterli
    guidance_scale=7.5,               # CFG scale
    width=512, height=512,
    num_images_per_prompt=4,          # tek seferde 4 görüntü
    generator=generator,
)

for i, img in enumerate(result.images):
    img.save(f"output_{i}.png")
    print(f"Kaydedildi: output_{i}.png")

import torch
import cv2
import numpy as np
from PIL import Image
from diffusers import ControlNetModel, StableDiffusionControlNetPipeline
from diffusers import UniPCMultistepScheduler

# ── Canny edge map üret ──────────────────────────────────────
def make_canny(image_path: str, low: int = 100, high: int = 200) -> Image:
    img = cv2.imread(image_path)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    edges = cv2.Canny(gray, low, high)              # ikili kenar haritası
    edges_rgb = cv2.cvtColor(edges, cv2.COLOR_GRAY2RGB)
    return Image.fromarray(edges_rgb)

# ── ControlNet + SD pipeline ─────────────────────────────────
controlnet = ControlNetModel.from_pretrained(
    "lllyasviel/sd-controlnet-canny",
    torch_dtype=torch.float16
)
pipe = StableDiffusionControlNetPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    controlnet=controlnet,
    torch_dtype=torch.float16
).to("cuda")
pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config)
pipe.enable_attention_slicing()

# ── Inference ────────────────────────────────────────────────
control_image = make_canny("reference.jpg")

result = pipe(
    prompt="a beautiful oil painting of a medieval castle, dramatic lighting",
    negative_prompt="blurry, modern, low quality",
    image=control_image,
    num_inference_steps=20,
    guidance_scale=7.5,
    controlnet_conditioning_scale=1.0,   # ControlNet etki gücü [0-2]
    generator=torch.Generator().manual_seed(99)
)

control_image.save("canny_map.png")      # Canny kenar haritası
result.images[0].save("controlled_output.png")
# Çıktı: referans görüntünün yapısını koruyarak yeni stilde üretim

import torch
from diffusers import StableDiffusionPipeline

# ── Base model + LoRA yükle ──────────────────────────────────
pipe = StableDiffusionPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    torch_dtype=torch.float16
).to("cuda")

# HuggingFace Hub'dan LoRA yükle
pipe.load_lora_weights(
    "CiroN2022/toy-face",         # HF repo veya yerel yol
    weight_name="toy_face_v2.safetensors"
)

# LoRA etki gücünü ayarla [0.0 - 1.0]
pipe.set_adapters(["default"], adapter_weights=[0.8])

image = pipe(
    "portrait of a toyface astronaut, soft lighting",
    num_inference_steps=30,
    guidance_scale=7.5,
    generator=torch.Generator().manual_seed(7)
).images[0]
image.save("lora_output.png")

# ── Birden fazla LoRA birleştirme (style mixing) ─────────────
pipe.load_lora_weights("lora_style_A.safetensors", adapter_name="styleA")
pipe.load_lora_weights("lora_style_B.safetensors", adapter_name="styleB")

# İki LoRA'yı farklı ağırlıklarla karıştır
pipe.set_adapters(
    ["styleA", "styleB"],
    adapter_weights=[0.6, 0.4]              # %60 A, %40 B
)

mixed = pipe(
    "a warrior in an enchanted forest, dramatic composition",
    num_inference_steps=35,
    guidance_scale=8.0,
).images[0]
mixed.save("style_mix.png")

# LoRA'yı kaldır (base model'e geri dön)
pipe.unload_lora_weights()