# Stable Diffusion XL

> [!WARNING]
> Bu script deneyseldir ve aşırı öğrenme (overfitting) ile katastrofik unutma gibi sorunlara düşmek kolaydır. Veri setinizde en iyi sonuçları almak için farklı hiperparametreleri denemenizi öneririz.

[Stable Diffusion XL (SDXL)](https://hf.co/papers/2307.01952), Stable Diffusion modelinin daha büyük ve daha güçlü bir sürümüdür ve daha yüksek çözünürlüklü görseller üretme kapasitesine sahiptir.

SDXL'in UNet'i 3 kat daha büyüktür ve model mimariye ikinci bir metin kodlayıcı ekler. Kullanılabilir donanımınıza bağlı olarak bu, çok yüksek hesaplama yoğunluğuna sahip olabilir ve Tesla T4 gibi bir tüketici GPU'sunda çalışmayabilir. Bu daha büyük modeli belleğe sığdırmak ve eğitimi hızlandırmak için `gradient_checkpointing`, `mixed_precision` ve `gradient_accumulation_steps` özelliklerini etkinleştirmeyi deneyin. [xFormers](../optimization/attention_backends) ile bellek verimli dikkati etkinleştirerek ve [bitsandbytes'](https://github.com/TimDettmers/bitsandbytes) 8 bitlik optimizatörünü kullanarak bellek kullanımınızı daha da azaltabilirsiniz.

Bu kılavuz, [train_text_to_image_sdxl.py](https://github.com/huggingface/diffusers/blob/main/examples/text_to_image/train_text_to_image_sdxl.py) eğitim betiğini inceleyerek onu daha yakından tanımanıza ve kendi kullanım senaryonuza nasıl uyarlayabileceğinizi göstermenize yardımcı olacaktır.

Betik çalıştırmadan önce, kütüphanenin kaynak kodundan yüklendiğinden emin olun:

```bash
git clone https://github.com/huggingface/diffusers
cd diffusers
pip install .
```

Ardından, eğitim betiğini içeren örnek klasörüne gidin ve kullandığınız betik için gerekli bağımlılıkları yükleyin:

```bash
cd examples/text_to_image
pip install -r requirements_sdxl.txt
```

> [!TIP]
> 🤗 Accelerate, birden fazla GPU/TPU ile veya karma hassasiyetle eğitim yapmanıza yardımcı olmak için tasarlanmış bir kütüphanedir. Donanımınıza ve ortamınıza göre eğitim kurulumunuzu otomatik olarak yapılandırır. Daha fazla bilgi edinmek için 🤗 Accelerate [Hızlı tur](https://huggingface.co/docs/accelerate/quicktour) sayfasına göz atın.

Bir 🤗 Accelerate ortamı başlatın:

```bash
accelerate config
```

Herhangi bir yapılandırma seçmeden varsayılan bir 🤗 Accelerate ortamı kurmak için:

```bash
accelerate config default
```

Ya da ortamınız, bir notebook gibi, etkileşimli bir kabuğu desteklemiyorsa, şunu kullanabilirsiniz:

```py
from accelerate.utils import write_basic_config

write_basic_config()
```

Son olarak, kendi veri setiniz üzerinde bir model eğitmek istiyorsanız, eğitim scriptiyle uyumlu bir veri seti oluşturma yöntemini öğrenmek için [Eğitim için veri seti oluşturma](create_dataset) kılavuzuna göz atın.

## Betik parametreleri

> [!TIP]
> Aşağıdaki bölümler, betiğin nasıl değiştirileceğini anlamak için önemli olan eğitim betiğinin kısımlarını vurgular, ancak betiğin her yönünü ayrıntılı olarak kapsamaz. Daha fazla bilgi edinmek isterseniz, [betiği](https://github.com/huggingface/diffusers/blob/main/examples/text_to_image/train_text_to_image_sdxl.py) okumaktan çekinmeyin ve herhangi bir sorunuz veya endişeniz varsa bize bildirin.

Eğitim betiği, eğitim çalışmanızı özelleştirmenize yardımcı olmak için birçok parametre sağlar. Tüm parametreler ve açıklamaları [`parse_args()`](https://github.com/huggingface/diffusers/blob/aab6de22c33cc01fb7bc81c0807d6109e2c998c9/examples/text_to_image/train_text_to_image_sdxl.py#L129) fonksiyonunda bulunur. Bu fonksiyon, eğitim batch boyutu ve öğrenme oranı gibi her parametre için varsayılan değerler sağlar, ancak isterseniz kendi değerlerinizi eğitim komutunda da belirleyebilirsiniz.

Örneğin, bf16 biçimini kullanarak karma hassasiyetle eğitimi hızlandırmak için eğitim komutuna `--mixed_precision` parametresini ekleyin:

```bash
accelerate launch train_text_to_image_sdxl.py \
  --mixed_precision="bf16"
```

Parametrelerin çoğu [Metinden görüntüye](text2image#script-parameters) eğitim kılavuzundaki parametrelerle aynıdır, bu nedenle bu kılavuzda SDXL eğitimine ilişkin parametrelere odaklanacaksınız.

- `--pretrained_vae_model_name_or_path`: önceden eğitilmiş bir VAE'nin yolu; SDXL VAE'sinin sayısal kararsızlıktan muzdarip olduğu bilinmektedir, bu nedenle bu parametre size daha iyi bir [VAE](https://huggingface.co/madebyollin/sdxl-vae-fp16-fix) belirtme imkanı tanır
- `--proportion_empty_prompts`: boş dizgilerle değiştirilecek görsel istemlerin oranı
- `--timestep_bias_strategy`: timestep içinde (daha erken mi yoksa daha geç mi) önyargı uygulanacağı konum; bu, modelin düşük veya yüksek frekanslı detayları öğrenmesini teşvik edebilir
- `--timestep_bias_multiplier`: timestep'e uygulanacak sapmanın ağırlığı
- `--timestep_bias_begin`: sapmanın uygulanmaya başlanacağı zaman adımı
- `--timestep_bias_end`: sapmanın uygulanmasının sona ereceği zaman adımı
- `--timestep_bias_portion`: önyargının uygulanacağı zaman adımlarının oranı

### Min-SNR ağırlıklandırma

[Min-SNR](https://huggingface.co/papers/2303.09556) ağırlıklandırma stratejisi, kaybı yeniden dengeleyerek daha hızlı yakınsama elde edilmesine yardımcı olarak eğitime katkıda bulunabilir. Eğitim betiği, `epsilon` (gürültü) veya `v_prediction` tahmin etmeyi destekler, ancak Min-SNR her iki tahmin türüyle de uyumludur. Bu ağırlıklandırma stratejisi yalnızca PyTorch tarafından desteklenir.

`--snr_gamma` parametresini ekleyin ve önerilen değer olan 5.0 olarak ayarlayın:

```bash
accelerate launch train_text_to_image_sdxl.py \
  --snr_gamma=5.0
```

## Eğitim betiği

Eğitim betiği, [Metinden görüntüye](text2image#training-script) eğitim kılavuzuna benzer; ancak SDXL eğitimini destekleyecek şekilde değiştirilmiştir. Bu kılavuz, SDXL eğitim betiğine özgü kodlara odaklanacaktır.

İşlevler oluşturarak başlar: [istemleri belirteçlere ayırmak](https://github.com/huggingface/diffusers/blob/aab6de22c33cc01fb7bc81c0807d6109e2c998c9/examples/text_to_image/train_text_to_image_sdxl.py#L478) için istem gömme değerlerini hesaplamak ve [VAE](https://github.com/huggingface/diffusers/blob/aab6de22c33cc01fb7bc81c0807d6109e2c998c9/examples/text_to_image/train_text_to_image_sdxl.py#L519) ile görüntü gömme değerlerini hesaplamak için. Ardından, uygulanacak adım sayısı ve adım sapma stratejisine bağlı olarak [adım ağırlıklarını üretmek](https://github.com/huggingface/diffusers/blob/aab6de22c33cc01fb7bc81c0807d6109e2c998c9/examples/text_to_image/train_text_to_image_sdxl.py#L531) için bir işlev oluşturacaksınız.

[`main()`](https://github.com/huggingface/diffusers/blob/aab6de22c33cc01fb7bc81c0807d6109e2c998c9/examples/text_to_image/train_text_to_image_sdxl.py#L572) işlevi içinde, bir tokenizer yüklenmesinin yanı sıra, SDXL mimarisi her birinden iki adet kullandığı için ikinci bir tokenizer ve metin kodlayıcı da yüklenir:

```py
tokenizer_one = AutoTokenizer.from_pretrained(
    args.pretrained_model_name_or_path, subfolder="tokenizer", revision=args.revision, use_fast=False
)
tokenizer_two = AutoTokenizer.from_pretrained(
    args.pretrained_model_name_or_path, subfolder="tokenizer_2", revision=args.revision, use_fast=False
)

text_encoder_cls_one = import_model_class_from_model_name_or_path(
    args.pretrained_model_name_or_path, args.revision
)
text_encoder_cls_two = import_model_class_from_model_name_or_path(
    args.pretrained_model_name_or_path, args.revision, subfolder="text_encoder_2"
)
```

[İstem ve gömme (embedding) değerleri](https://github.com/huggingface/diffusers/blob/aab6de22c33cc01fb7bc81c0807d6109e2c998c9/examples/text_to_image/train_text_to_image_sdxl.py#L857) önce hesaplanır ve bellekte tutulur; bu, daha küçük veri kümeleri için genellikle bir sorun değildir, ancak daha büyük veri kümelerinde bellek sorunlarına yol açabilir. Bu durumda, önceden hesaplanan gömme değerlerini ayrı olarak diske kaydetmeli ve eğitim süreci sırasında belleğe yüklemelisiniz (bu konudaki daha fazla tartışma için bu [PR](https://github.com/huggingface/diffusers/pull/4505)'a bakın).

```py
text_encoders = [text_encoder_one, text_encoder_two]
tokenizers = [tokenizer_one, tokenizer_two]
compute_embeddings_fn = functools.partial(
    encode_prompt,
    text_encoders=text_encoders,
    tokenizers=tokenizers,
    proportion_empty_prompts=args.proportion_empty_prompts,
    caption_column=args.caption_column,
)

train_dataset = train_dataset.map(compute_embeddings_fn, batched=True, new_fingerprint=new_fingerprint)
train_dataset = train_dataset.map(
    compute_vae_encodings_fn,
    batched=True,
    batch_size=args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps,
    new_fingerprint=new_fingerprint_for_vae,
)
```

Gömlemler hesaplandıktan sonra, metin kodlayıcı, VAE ve belirteçleyici, biraz bellek boşaltmak için silinir:

```py
del text_encoders, tokenizers, vae
gc.collect()
torch.cuda.empty_cache()
```

Son olarak, [eğitim döngüsü](https://github.com/huggingface/diffusers/blob/aab6de22c33cc01fb7bc81c0807d6109e2c998c9/examples/text_to_image/train_text_to_image_sdxl.py#L943) kalan her şeyi halleder. Bir zaman adımı önyargı stratejisi uygulamayı seçtiyseniz, zaman adımı ağırlıklarının hesaplandığını ve gürültü olarak eklendiğini göreceksiniz:

```py
weights = generate_timestep_weights(args, noise_scheduler.config.num_train_timesteps).to(
        model_input.device
    )
    timesteps = torch.multinomial(weights, bsz, replacement=True).long()

noisy_model_input = noise_scheduler.add_noise(model_input, noise, timesteps)
```

Eğitim döngüsünün nasıl çalıştığı hakkında daha fazla bilgi edinmek isterseniz, gürültü azaltma sürecinin temel kalıbını açıklayan [Understanding pipelines, models and schedulers](../using-diffusers/write_own_pipeline) eğitim materyaline göz atın.

## Betik başlat

Tüm değişikliklerinizi yaptıysanız veya varsayılan yapılandırmayla sorununuz yoksa, eğitim betiğini başlatmaya hazırsınız! 🚀

Kendi Naruto karakterlerinizi üretmek için [Naruto BLIP captions](https://huggingface.co/datasets/lambdalabs/naruto-blip-captions) veri seti üzerinde eğitim yapalım. Modeli ve veri setini (Hub’dan veya yerel bir yoldan) belirtmek için `MODEL_NAME` ve `DATASET_NAME` ortam değişkenlerini ayarlayın. Sayısal kararsızlıklardan kaçınmak için SDXL VAE dışında bir VAE’yi (Hub’dan veya yerel bir yoldan) `VAE_NAME` ile belirtmeniz de gerekir.

> [!TIP]
> Eğitim ilerlemesini Weights & Biases ile izlemek için eğitim komutuna `--report_to=wandb` parametresini ekleyin. Sonuçları takip etmek için eğitim komutuna `--validation_prompt` ve `--validation_epochs` parametrelerini de eklemeniz gerekir. Bu, modeli hata ayıklamak ve ara sonuçları görüntülemek için gerçekten faydalı olabilir.

```bash
export MODEL_NAME="stabilityai/stable-diffusion-xl-base-1.0"
export VAE_NAME="madebyollin/sdxl-vae-fp16-fix"
export DATASET_NAME="lambdalabs/naruto-blip-captions"

accelerate launch train_text_to_image_sdxl.py \
  --pretrained_model_name_or_path=$MODEL_NAME \
  --pretrained_vae_model_name_or_path=$VAE_NAME \
  --dataset_name=$DATASET_NAME \
  --enable_xformers_memory_efficient_attention \
  --resolution=512 \
  --center_crop \
  --random_flip \
  --proportion_empty_prompts=0.2 \
  --train_batch_size=1 \
  --gradient_accumulation_steps=4 \
  --gradient_checkpointing \
  --max_train_steps=10000 \
  --use_8bit_adam \
  --learning_rate=1e-06 \
  --lr_scheduler="constant" \
  --lr_warmup_steps=0 \
  --mixed_precision="fp16" \
  --report_to="wandb" \
  --validation_prompt="a cute Sundar Pichai creature" \
  --validation_epochs 5 \
  --checkpointing_steps=5000 \
  --output_dir="sdxl-naruto-model" \
  --push_to_hub
```

Eğitimi tamamladıktan sonra, yeni eğittiğiniz SDXL modelini çıkarım için kullanabilirsiniz!

```py
from diffusers import DiffusionPipeline
import torch

pipeline = DiffusionPipeline.from_pretrained("path/to/your/model", dtype=torch.float16).to("cuda")  # or "mps", "xpu", "cpu"

prompt = "A naruto with green eyes and red legs."
image = pipeline(prompt, num_inference_steps=30, guidance_scale=7.5).images[0]
image.save("naruto.png")
```

[PyTorch XLA](https://pytorch.org/xla), PyTorch’u TPU gibi XLA cihazlarında çalıştırmanızı sağlar ve bu daha hızlı olabilir. İlk ısınma adımı, modelin derlenip optimize edilmesi gerektiği için daha uzun sürer. Ancak, orijinal istemle **aynı uzunlukta** bir girdi üzerinde pipeline’ın sonraki çağrıları, optimize edilmiş grafın yeniden kullanılabilmesi sayesinde çok daha hızlıdır.

```py
from diffusers import DiffusionPipeline
import torch
import torch_xla.core.xla_model as xm

device = xm.xla_device()
pipeline = DiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-xl-base-1.0").to(device)

prompt = "A naruto with green eyes and red legs."
start = time()
image = pipeline(prompt, num_inference_steps=inference_steps).images[0]
print(f'Compilation time is {time()-start} sec')
image.save("naruto.png")

start = time()
image = pipeline(prompt, num_inference_steps=inference_steps).images[0]
print(f'Inference time is {time()-start} sec after compilation')
```

## Sonraki adımlar

Bir SDXL modeli eğittiğiniz için tebrikler! Yeni modelinizi nasıl kullanacağınızı öğrenmek için aşağıdaki kılavuzlar size yardımcı olabilir:

- Çeşitli farklı görevlerde (metinden görüntüye, görüntüden görüntüye, inpainting) nasıl kullanılacağını, refiner modelinin nasıl kullanılacağını ve farklı mikro-konumlama türlerini öğrenmek için [Stable Diffusion XL](../api/pipelines/stable_diffusion/stable_diffusion_xl) kılavuzunu okuyun.
- Kişiselleştirilmiş bir SDXL modelini yalnızca birkaç örnek görüntüyle nasıl eğitebileceğinizi öğrenmek için [DreamBooth](dreambooth) ve [LoRA](lora) eğitim kılavuzlarını inceleyin. Bu iki eğitim tekniği birleştirilebilir!