# Kandinsky 2.2

> [!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.

Kandinsky 2.2, daha fotogerçekçi görseller üretebilen çok dilli metinden görselle modelidir. Model, metin istemlerinden görsel gömme (embedding) oluşturmak için bir görsel öncül (prior) modeli ve öncül modelin gömelerine dayalı olarak görseller üreten bir çözücü (decoder) modeli içerir. Bu nedenle Diffusers'ta Kandinsky 2.2 için iki ayrı betik bulacaksınız: biri öncül modeli eğitmek için, diğeri çözücü modelini eğitmek için. Her iki modeli ayrı ayrı eğitebilirsiniz ancak en iyi sonuçları almak için hem öncül hem de çözücü modellerini eğitmeniz gerekir.

GPU'nuzun türüne bağlı olarak, modeli belleğe sığdırmak ve eğitimi hızlandırmak için `gradient_checkpointing` (⚠️ önceki model için desteklenmiyor!), `mixed_precision` ve `gradient_accumulation_steps` özelliklerini etkinleştirmeniz gerekebilir. [xFormers](../optimization/attention_backends) ile bellek verimli dikkati (attention) etkinleştirerek bellek kullanımınızı daha da azaltabilirsiniz ([v0.0.16](https://github.com/huggingface/diffusers/issues/2234#issuecomment-1416931212) sürümü bazı GPU'larda eğitim sırasında başarısız olur, bu nedenle bunun yerine bir geliştirme sürümünü yüklemeniz gerekebilir).

Bu kılavuz, [train_text_to_image_prior.py](https://github.com/huggingface/diffusers/blob/main/examples/kandinsky2_2/text_to_image/train_text_to_image_prior.py) ve [train_text_to_image_decoder.py](https://github.com/huggingface/diffusers/blob/main/examples/kandinsky2_2/text_to_image/train_text_to_image_decoder.py) betiklerini inceleyerek bu betiklere daha aşina olmanıza ve kendi kullanım senaryonuza nasıl uyarlayabileceğinizi göstermenize yardımcı olur.

Betikleri ç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/kandinsky2_2/text_to_image
pip install -r requirements.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.

> [!TIP]
> Aşağıdaki bölümler, betiğin nasıl değiştirileceğini anlamak için önemli olan eğitim betikleri kısımlarını vurgular, ancak betiklerin her yönünü ayrıntılı olarak kapsamaz. Daha fazla bilgi edinmek isterseniz, betikleri okumaktan çekinmeyin ve herhangi bir sorunuz veya endişeniz varsa bize bildirin.

## Betik parametreleri

Eğitim betikleri, 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/6e68c71503682c8693cb5b06a4da4911dfd655ee/examples/kandinsky2_2/text_to_image/train_text_to_image_prior.py#L190) fonksiyonunda bulunur. Eğitim betikleri, 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, fp16 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_prior.py \
  --mixed_precision="fp16"
```

Parametrelerin çoğu [Metinden görüntüye](text2image#script-parameters) eğitim kılavuzundaki parametrelerle aynıdır, bu yüzden Kandinsky eğitim betiklerinin adım adım incelemesine doğrudan geçelim!

### 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_prior.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 öncül ve çözücü modellerinin eğitimini destekleyecek şekilde değiştirilmiştir. Bu kılavuz, Kandinsky 2.2 eğitim betiklerine özgü kodlara odaklanır.

[`main()`](https://github.com/huggingface/diffusers/blob/6e68c71503682c8693cb5b06a4da4911dfd655ee/examples/kandinsky2_2/text_to_image/train_text_to_image_prior.py#L441) fonksiyonu, veri setini hazırlama ve modeli eğitme kodlarını içerir.

Hemen fark edeceğiniz ana farklardan biri, eğitim betiğinin görüntüleri ön işlemek için bir [CLIPImageProcessor](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPImageProcessor) ve görüntüleri kodlamak için bir [CLIPVisionModelWithProjection](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPVisionModelWithProjection) modeli yüklemesidir - bir zamanlayıcı ve belirteçleyicinin yanı sıra:

```py
noise_scheduler = DDPMScheduler(beta_schedule="squaredcos_cap_v2", prediction_type="sample")
image_processor = CLIPImageProcessor.from_pretrained(
    args.pretrained_prior_model_name_or_path, subfolder="image_processor"
)
tokenizer = CLIPTokenizer.from_pretrained(args.pretrained_prior_model_name_or_path, subfolder="tokenizer")

with ContextManagers(deepspeed_zero_init_disabled_context_manager()):
    image_encoder = CLIPVisionModelWithProjection.from_pretrained(
        args.pretrained_prior_model_name_or_path, subfolder="image_encoder", dtype=weight_dtype
    ).eval()
    text_encoder = CLIPTextModelWithProjection.from_pretrained(
        args.pretrained_prior_model_name_or_path, subfolder="text_encoder", dtype=weight_dtype
    ).eval()
```

Kandinsky, gömme (embedding) üretmek için [PriorTransformer](/docs/diffusers/main/tr/api/models/prior_transformer#diffusers.PriorTransformer) kullanır; bu nedenle optimizatörü, prior modunun parametrelerini öğrenmesi için yapılandırmanız gerekir.

```py
prior = PriorTransformer.from_pretrained(args.pretrained_prior_model_name_or_path, subfolder="prior")
prior.train()
optimizer = optimizer_cls(
    prior.parameters(),
    lr=args.learning_rate,
    betas=(args.adam_beta1, args.adam_beta2),
    weight_decay=args.adam_weight_decay,
    eps=args.adam_epsilon,
)
```

Ardından, giriş açıklamaları tokenize edilir ve görüntüler [CLIPImageProcessor](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPImageProcessor) tarafından [ön işlenir](https://github.com/huggingface/diffusers/blob/6e68c71503682c8693cb5b06a4da4911dfd655ee/examples/kandinsky2_2/text_to_image/train_text_to_image_prior.py#L632):

```py
def preprocess_train(examples):
    images = [image.convert("RGB") for image in examples[image_column]]
    examples["clip_pixel_values"] = image_processor(images, return_tensors="pt").pixel_values
    examples["text_input_ids"], examples["text_mask"] = tokenize_captions(examples)
    return examples
```

Son olarak, [eğitim döngüsü](https://github.com/huggingface/diffusers/blob/6e68c71503682c8693cb5b06a4da4911dfd655ee/examples/kandinsky2_2/text_to_image/train_text_to_image_prior.py#L718) girdi görüntülerini latentlere dönüştürür, görüntü gömümlerine gürültü ekler ve bir tahmin yapar:

```py
model_pred = prior(
    noisy_latents,
    timestep=timesteps,
    proj_embedding=prompt_embeds,
    encoder_hidden_states=text_encoder_hidden_states,
    attention_mask=text_mask,
).predicted_image_embedding
```

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.

[`main()`](https://github.com/huggingface/diffusers/blob/6e68c71503682c8693cb5b06a4da4911dfd655ee/examples/kandinsky2_2/text_to_image/train_text_to_image_decoder.py#L440) fonksiyonu, veri setini hazırlama ve modeli eğitme kodlarını içerir.

Önceki modelin aksine, decoder, latentsleri görüntülere dönüştürmek için bir [VQModel](/docs/diffusers/main/tr/api/models/vq#diffusers.VQModel) başlatır ve bir [UNet2DConditionModel](/docs/diffusers/main/tr/api/models/unet2d-cond#diffusers.UNet2DConditionModel) kullanır:

```py
with ContextManagers(deepspeed_zero_init_disabled_context_manager()):
    vae = VQModel.from_pretrained(
        args.pretrained_decoder_model_name_or_path, subfolder="movq", dtype=weight_dtype
    ).eval()
    image_encoder = CLIPVisionModelWithProjection.from_pretrained(
        args.pretrained_prior_model_name_or_path, subfolder="image_encoder", dtype=weight_dtype
    ).eval()
unet = UNet2DConditionModel.from_pretrained(args.pretrained_decoder_model_name_or_path, subfolder="unet")
```

Ardından, betik birkaç görüntü dönüşümü ve bu dönüşümleri görüntülere uygulayıp piksel değerlerini döndüren bir [ön işleme](https://github.com/huggingface/diffusers/blob/6e68c71503682c8693cb5b06a4da4911dfd655ee/examples/kandinsky2_2/text_to_image/train_text_to_image_decoder.py#L622) işlevi içerir:

```py
def preprocess_train(examples):
    images = [image.convert("RGB") for image in examples[image_column]]
    examples["pixel_values"] = [train_transforms(image) for image in images]
    examples["clip_pixel_values"] = image_processor(images, return_tensors="pt").pixel_values
    return examples
```

Son olarak, [eğitim döngüsü](https://github.com/huggingface/diffusers/blob/6e68c71503682c8693cb5b06a4da4911dfd655ee/examples/kandinsky2_2/text_to_image/train_text_to_image_decoder.py#L706) görüntüleri latentlere dönüştürmeyi, gürültü eklemeyi ve gürültü artığını tahmin etmeyi yönetir.

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.

```py
model_pred = unet(noisy_latents, timesteps, None, added_cond_kwargs=added_cond_kwargs).sample[:, :4]
```

## 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 yapacaksınız, ancak [Create a dataset for training](create_dataset) kılavuzunu izleyerek kendi veri setinizi oluşturup üzerinde eğitim de yapabilirsiniz. Hub'daki veri setinin adını `DATASET_NAME` ortam değişkenine ayarlayın veya kendi dosyalarınız üzerinde eğitim yapıyorsanız, `TRAIN_DIR` ortam değişkenini veri setinize giden bir yola ayarlayın.

Birden fazla GPU üzerinde eğitim yapıyorsanız, `accelerate launch` komutuna `--multi_gpu` parametresini ekleyin.

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

```bash
export DATASET_NAME="lambdalabs/naruto-blip-captions"

accelerate launch --mixed_precision="fp16"  train_text_to_image_prior.py \
  --dataset_name=$DATASET_NAME \
  --resolution=768 \
  --train_batch_size=1 \
  --gradient_accumulation_steps=4 \
  --max_train_steps=15000 \
  --learning_rate=1e-05 \
  --max_grad_norm=1 \
  --checkpoints_total_limit=3 \
  --lr_scheduler="constant" \
  --lr_warmup_steps=0 \
  --validation_prompts="A robot naruto, 4k photo" \
  --report_to="wandb" \
  --push_to_hub \
  --output_dir="kandi2-prior-naruto-model"
```

```bash
export DATASET_NAME="lambdalabs/naruto-blip-captions"

accelerate launch --mixed_precision="fp16"  train_text_to_image_decoder.py \
  --dataset_name=$DATASET_NAME \
  --resolution=768 \
  --train_batch_size=1 \
  --gradient_accumulation_steps=4 \
  --gradient_checkpointing \
  --max_train_steps=15000 \
  --learning_rate=1e-05 \
  --max_grad_norm=1 \
  --checkpoints_total_limit=3 \
  --lr_scheduler="constant" \
  --lr_warmup_steps=0 \
  --validation_prompts="A robot naruto, 4k photo" \
  --report_to="wandb" \
  --push_to_hub \
  --output_dir="kandi2-decoder-naruto-model"
```

Eğitim tamamlandığında, yeni eğittiğiniz modeli çıkarım için kullanabilirsiniz!

```py
from diffusers import AutoPipelineForText2Image, DiffusionPipeline
import torch

prior_pipeline = DiffusionPipeline.from_pretrained(output_dir, dtype=torch.float16)
prior_components = {"prior_" + k: v for k,v in prior_pipeline.components.items()}
pipeline = AutoPipelineForText2Image.from_pretrained("kandinsky-community/kandinsky-2-2-decoder", **prior_components, dtype=torch.float16)

pipe.enable_model_cpu_offload()
prompt="A robot naruto, 4k photo"
image = pipeline(prompt=prompt, negative_prompt=negative_prompt).images[0]
```

> [!TIP]
> Kendi eğittiğiniz decoder checkpoint'i ile `kandinsky-community/kandinsky-2-2-decoder` yerini değiştirmekten çekinmeyin!

```py
from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained("path/to/saved/model", dtype=torch.float16)
pipeline.enable_model_cpu_offload()

prompt="A robot naruto, 4k photo"
image = pipeline(prompt=prompt).images[0]
```

Dekoder modeli için, ara sonuçları görüntülemek için faydalı olabilecek kaydedilmiş bir kontrol noktasından (checkpoint) çıkarım (inference) da gerçekleştirebilirsiniz. Bu durumda, kontrol noktasını UNet'e yükleyin:

```py
from diffusers import AutoPipelineForText2Image, UNet2DConditionModel

unet = UNet2DConditionModel.from_pretrained("path/to/saved/model" + "/checkpoint-<N>/unet")

pipeline = AutoPipelineForText2Image.from_pretrained("kandinsky-community/kandinsky-2-2-decoder", unet=unet, dtype=torch.float16)
pipeline.enable_model_cpu_offload()

image = pipeline(prompt="A robot naruto, 4k photo").images[0]
```

## Sonraki adımlar

Bir Kandinsky 2.2 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, interpolasyon) nasıl kullanılacağını ve bir ControlNet ile nasıl birleştirilebileceğini öğrenmek için [Kandinsky](../api/pipelines/kandinsky) kılavuzunu okuyun.
- Kişiselleştirilmiş bir Kandinsky 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!