# ControlNet

[ControlNet](https://hf.co/papers/2302.05543) modelleri, başka bir önceden eğitilmiş modelin üzerine eğitilen adaptörlerdir. Modelin ek bir giriş görüntüsüyle koşullandırılmasına olanak tanıyarak görüntü üretiminde daha yüksek bir kontrol derecesi sağlar. Giriş görüntüsü canny kenarı, derinlik haritası, insan pozu ve daha birçok şey olabilir.

Sınırlı vRAM'a sahip bir GPU üzerinde eğitim yapıyorsanız, eğitim komutunda `gradient_checkpointing`, `gradient_accumulation_steps` ve `mixed_precision` parametrelerini etkinleştirmeyi denemelisiniz. Ayrıca [xFormers](../optimization/attention_backends) ile bellek verimli dikkat (attention) kullanarak bellek kullanımınızı azaltabilirsiniz.

Bu kılavuz, [train_controlnet.py](https://github.com/huggingface/diffusers/blob/main/examples/controlnet/train_controlnet.py) eğitim betiğini inceleyerek onu tanımanıza ve kendi kullanım senaryonuza nasıl uyarlayabileceğinizi göstermek için hazırlanmıştı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/controlnet
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 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/controlnet/train_controlnet.py) okumaktan çekinmeyin ve herhangi bir sorunuz veya endişeniz varsa bize bildirin.

## Betik parametreleri

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/64603389da01082055a901f2883c4810d1144edb/examples/controlnet/train_controlnet.py#L231) 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, fp16 biçimini kullanarak karma hassasiyetle eğitimi hızlandırmak için eğitim komutuna `--mixed_precision` parametresini ekleyin:

```bash
accelerate launch train_controlnet.py \
  --mixed_precision="fp16"
```

Çok temel ve önemli parametreler [Metinden görüntüye](text2image#script-parameters) eğitim kılavuzunda anlatıldığından, bu kılavuz yalnızca ControlNet için ilgili parametrelere odaklanmaktadır:

- `--max_train_samples`: eğitim örneklerinin sayısı; daha hızlı eğitim için bu değer düşürülebilir, ancak gerçekten büyük veri kümelerini akış olarak kullanmak istiyorsanız eğitim komutunuza bu parametreyi ve `--streaming` parametresini dahil etmeniz gerekir
- `--gradient_accumulation_steps`: geriye yayılım (backward pass) yapılmadan önce birikmesi gereken güncelleme adım sayısı; bu, GPU belleğinizin genellikle kaldırabileceğinden daha büyük bir parti boyutuyla eğitim yapmanızı sağlar

### 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_controlnet.py \
  --snr_gamma=5.0
```

## Eğitim betiği

Betik parametrelerinde olduğu gibi, eğitim betiğinin genel bir tanıtımı [Metinden görüntüye](text2image#training-script) eğitim kılavuzunda sunulmaktadır. Bunun yerine bu kılavuz, ControlNet betiğinin ilgili bölümlerine odaklanır.

Eğitim betiği, veri setini görüntü dönüşümleri ve başlık tokenizasyonu ile ön işlemek için [`make_train_dataset`](https://github.com/huggingface/diffusers/blob/64603389da01082055a901f2883c4810d1144edb/examples/controlnet/train_controlnet.py#L582) işlevine sahiptir. Alışıldık başlık tokenizasyonu ve görüntü dönüşümlerinin yanı sıra, betiğin koşullandırma görüntüsü için de dönüşümler içerdiğini göreceksiniz.

> [!TIP]
> TPU üzerinde bir veri seti akışı yapıyorsanız, görüntüler için optimize edilmemiş 🤗 Datasets kütüphanesi nedeniyle performans darboğaza takılabilir. Maksimum verimi sağlamak için [WebDataset](https://github.com/webdataset/webdataset), [TorchData](https://github.com/pytorch/data) ve [TensorFlow Datasets](https://www.tensorflow.org/datasets/tfless_tfds) gibi diğer veri seti biçimlerini incelemeniz önerilir.

```py
conditioning_image_transforms = transforms.Compose(
    [
        transforms.Resize(args.resolution, interpolation=transforms.InterpolationMode.BILINEAR),
        transforms.CenterCrop(args.resolution),
        transforms.ToTensor(),
    ]
)
```

[`main()`](https://github.com/huggingface/diffusers/blob/64603389da01082055a901f2883c4810d1144edb/examples/controlnet/train_controlnet.py#L713) işlevi içinde tokenizer, metin kodlayıcı, zamanlayıcı ve modellerin yüklenmesine dair kodu bulabilirsiniz. ControlNet modelinin mevcut ağırlıklardan ya da bir UNet’ten rastgele başlatılarak yüklenmesi de burada yapılır:

```py
if args.controlnet_model_name_or_path:
    logger.info("Loading existing controlnet weights")
    controlnet = ControlNetModel.from_pretrained(args.controlnet_model_name_or_path)
else:
    logger.info("Initializing controlnet weights from unet")
    controlnet = ControlNetModel.from_unet(unet)
```

[optimizer](https://github.com/huggingface/diffusers/blob/64603389da01082055a901f2883c4810d1144edb/examples/controlnet/train_controlnet.py#L871), ControlNet parametrelerini güncellemek üzere yapılandırılır:

```py
params_to_optimize = controlnet.parameters()
optimizer = optimizer_class(
    params_to_optimize,
    lr=args.learning_rate,
    betas=(args.adam_beta1, args.adam_beta2),
    weight_decay=args.adam_weight_decay,
    eps=args.adam_epsilon,
)
```

Son olarak, [eğitim döngüsünde](https://github.com/huggingface/diffusers/blob/64603389da01082055a901f2883c4810d1144edb/examples/controlnet/train_controlnet.py#L943), koşullandırma metin gömme değerleri ve görüntü, ControlNet modelinin down ve mid bloklarına iletilir:

```py
encoder_hidden_states = text_encoder(batch["input_ids"])[0]
controlnet_image = batch["conditioning_pixel_values"].to(dtype=weight_dtype)

down_block_res_samples, mid_block_res_sample = controlnet(
    noisy_latents,
    timesteps,
    encoder_hidden_states=encoder_hidden_states,
    controlnet_cond=controlnet_image,
    return_dict=False,
)
```

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

Şimdi eğitim betiğini başlatmaya hazırsınız! 🚀

Bu kılavuz [fusing/fill50k](https://huggingface.co/datasets/fusing/fill50k) veri setini kullanır ancak isterseniz kendi veri setinizi oluşturup kullanabilirsiniz ([Eğitim için veri seti oluşturma](create_dataset) kılavuzuna bakın).

Ortam değişkeni `MODEL_NAME`'i Hub'daki bir model kimliğine veya yerel bir modele giden yola, `OUTPUT_DIR`'i ise modelin kaydedilmesini istediğiniz konuma ayarlayın.

Eğitiminizi koşullandırmak için aşağıdaki görüntüleri indirin:

```bash
wget https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/controlnet_training/conditioning_image_1.png
wget https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/controlnet_training/conditioning_image_2.png
```

Betik başlatmadan önce bir şey daha! Kullandığınız GPU'ya bağlı olarak, bir ControlNet eğitmek için belirli optimizasyonları etkinleştirmeniz gerekebilir. Bu betiğin varsayılan yapılandırması ~38GB vRAM gerektirir. Birden fazla GPU üzerinde eğitim yapıyorsanız, `accelerate launch` komutuna `--multi_gpu` parametresini ekleyin.

16 GB'lik bir GPU'da, eğitim çalışmanızı optimize etmek için bitsandbytes 8-bit optimizatörünü ve gradient checkpointing'i kullanabilirsiniz. bitsandbytes'ı yükleyin:

```py
pip install bitsandbytes
```

Ardından, eğitim komutunuza aşağıdaki parametreyi ekleyin:

```bash
accelerate launch train_controlnet.py \
  --gradient_checkpointing \
  --use_8bit_adam \
```

12 GB'lik bir GPU'da, bellek kullanımını azaltmak için bitsandbytes 8-bit optimizatör, gradient checkpointing, xFormers kullanmanız ve sıfır yerine gradyanları `None` olarak ayarlamanız gerekir.

```bash
accelerate launch train_controlnet.py \
  --use_8bit_adam \
  --gradient_checkpointing \
  --enable_xformers_memory_efficient_attention \
  --set_grads_to_none \
```

8 GB'lik bir GPU'da, daha az GPU belleğiyle eğitim yapabilmek için vRAM'deki bazı tensörleri CPU'ya veya NVME'ye aktarmak için [DeepSpeed](https://www.deepspeed.ai/) kullanmanız gerekir.

🤗 Accelerate ortamınızı yapılandırmak için aşağıdaki komutu çalıştırın:

```bash
accelerate config
```

Yapılandırma sırasında DeepSpeed stage 2 kullanmak istediğinizi onaylayın. Artık DeepSpeed stage 2, fp16 karışık hassasiyet ve model parametreleri ile optimizör durumunun CPU'ya aktarılmasını birleştirerek 8 GB vRAM altında eğitim yapmak mümkün olmalıdır. Dezavantajı, bunun daha fazla sistem RAM'i (~25 GB) gerektirmesidir. Daha fazla yapılandırma seçeneği için [DeepSpeed belgelerini](https://huggingface.co/docs/accelerate/usage_guides/deepspeed) inceleyin. Yapılandırma dosyanız aşağıdaki gibi görünmelidir:

```bash
compute_environment: LOCAL_MACHINE
deepspeed_config:
  gradient_accumulation_steps: 4
  offload_optimizer_device: cpu
  offload_param_device: cpu
  zero3_init_flag: false
  zero_stage: 2
distributed_type: DEEPSPEED
```

Varsayılan Adam optimizatörünü de anlamlı bir hızlanma için DeepSpeed’in optimize edilmiş Adam sürümü olan [`deepspeed.ops.adam.DeepSpeedCPUAdam`](https://deepspeed.readthedocs.io/en/latest/optimizers.html#adam-cpu) olarak değiştirmelisiniz. `DeepSpeedCPUAdam`’in etkinleştirilmesi, sisteminizin CUDA araç zinciri sürümünün PyTorch ile birlikte yüklenen sürümle aynı olmasını gerektirir.

bitsandbytes 8-bit optimizers şu anda DeepSpeed ile uyumlu görünmüyor.

Bitti! Eğitim komutunuza ek parametreler eklemenize gerek yok.

```bash
export MODEL_DIR="stable-diffusion-v1-5/stable-diffusion-v1-5"
export OUTPUT_DIR="path/to/save/model"

accelerate launch train_controlnet.py \
 --pretrained_model_name_or_path=$MODEL_DIR \
 --output_dir=$OUTPUT_DIR \
 --dataset_name=fusing/fill50k \
 --resolution=512 \
 --learning_rate=1e-5 \
 --validation_image "./conditioning_image_1.png" "./conditioning_image_2.png" \
 --validation_prompt "red circle with blue background" "cyan circle with brown floral background" \
 --train_batch_size=1 \
 --gradient_accumulation_steps=4 \
 --push_to_hub
```

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

```py
from diffusers import StableDiffusionControlNetPipeline, ControlNetModel
from diffusers.utils import load_image
import torch

controlnet = ControlNetModel.from_pretrained("path/to/controlnet", dtype=torch.float16)
pipeline = StableDiffusionControlNetPipeline.from_pretrained(
    "path/to/base/model", controlnet=controlnet, dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"

control_image = load_image("./conditioning_image_1.png")
prompt = "pale golden rod circle with old lace background"

generator = torch.manual_seed(0)
image = pipeline(prompt, num_inference_steps=20, generator=generator, image=control_image).images[0]
image.save("./output.png")
```

## Stable Diffusion XL

Stable Diffusion XL (SDXL), yüksek çözünürlüklü görüntüler üreten güçlü bir metinden görüntüye modelidir ve mimarisine ikinci bir metin kodlayıcı ekler. SDXL modeli için bir ControlNet adaptörü eğitmek için [`train_controlnet_sdxl.py`](https://github.com/huggingface/diffusers/blob/main/examples/controlnet/train_controlnet_sdxl.py) betiğini kullanın.

SDXL eğitim betiği, [SDXL eğitimi](sdxl) kılavuzunda daha ayrıntılı olarak ele alınmaktadır.

## Sonraki adımlar

Kendi ControlNet'inizi 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 görevlerde çıkarım için [ControlNet kullanmayı](../using-diffusers/controlnet) öğrenin.

