# Model bileşenlerini device_map ile GPU'lar arasında dağıtın

`device_map` argümanı, model bileşenlerini ayrı GPU'lara yerleştirir. Bir model tek bir GPU'ya sığmıyorsa ve GPU'larınız hızlı bir bağlantıya sahip değilse bunu kullanın. Diğer stratejilerle karşılaştırmak için [Distributed inference](../training/distributed_inference) bölümüne, `device_map` için daha fazla seçenek için ise [Device placement](./memory#device-placement) bölümüne bakın.

Aşağıdaki örnek, her bileşeni yalnızca ona ihtiyaç duyan aşamada yükler ve büyük olanları iki GPU arasında dağıtmak için `device_map` kullanır.

## İsteği kodla

Metin kodlayıcıları ayrı GPU'lara yerleştirmek için `device_map="balanced"` değerini ayarlayın. Her GPU'nun kullanabileceği bellek miktarını sınırlamak için `max_memory` parametresini kullanın. Yalnızca metin kodlayıcıların yüklenmesini sağlamak için `transformer` ve `vae` değerlerini `None` olarak ayarlayın.

```py
from diffusers import FluxPipeline
import torch

prompt = """
cinematic film still of a cat sipping a margarita in a pool in Palm Springs, California
highly detailed, high budget hollywood movie, cinemascope, moody, epic, gorgeous, film grain
"""

pipeline = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    transformer=None,
    vae=None,
    device_map="balanced",
    max_memory={0: "16GB", 1: "16GB"},
    dtype=torch.bfloat16
)
with torch.no_grad():
    print("Encoding prompts.")
    prompt_embeds, pooled_prompt_embeds, text_ids = pipeline.encode_prompt(
        prompt=prompt, prompt_2=None, max_sequence_length=512
    )
```

Metin gömcelerine sahip olduğunuzda, transformer için yer açmak üzere metin kodlayıcıları GPU'dan kaldırın.

```py
import gc

def flush():
    gc.collect()
    torch.cuda.empty_cache()
    torch.cuda.reset_max_memory_allocated()
    torch.cuda.reset_peak_memory_stats()

del pipeline.text_encoder
del pipeline.text_encoder_2
del pipeline.tokenizer
del pipeline.tokenizer_2
del pipeline

flush()
```

## Parçalı dönüştürücü ile gürültü azaltma

`device_map="auto"` değerini ayarlayarak Accelerate'in dönüştürücüyü yerleştirmesini sağlayın. İlk GPU'yu doldurmadan diğerine geçmez ve yalnızca GPU'ların belleği tükendiğinde CPU veya diski kullanır. İki küçük GPU'da dönüştürücü, her ikisi arasında bölünmüş olarak konumlandırılır. CPU veya diskte bulunan ağırlıklar çıkarımı yavaşlatır.

```py
from diffusers import AutoModel
import torch

transformer = AutoModel.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    subfolder="transformer",
    device_map="auto",
    dtype=torch.bfloat16
)
```

> [!TIP]
> Dönüştürücünün cihazlar arasında nasıl dağıtıldığını görmek için `transformer.hf_device_map` değerini kontrol edin. `device_map` ile yüklenen bir pipeline, her bileşenin nereye yerleştirildiğini gösteren bir `hf_device_map` özniteliğine de sahiptir.

Sadece dönüştürücüyle bir pipeline yükleyin ve `output_type="latent"` ayarlayın; böylece görseller yerine latentler döner.

```py
pipeline = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    text_encoder=None,
    text_encoder_2=None,
    tokenizer=None,
    tokenizer_2=None,
    vae=None,
    transformer=transformer,
    dtype=torch.bfloat16
)

print("Running denoising.")
height, width = 768, 1360
latents = pipeline(
    prompt_embeds=prompt_embeds,
    pooled_prompt_embeds=pooled_prompt_embeds,
    num_inference_steps=50,
    guidance_scale=3.5,
    height=height,
    width=width,
    output_type="latent",
).images
```

## Latentleri çözümlen

Bellekten pipeline ve transformer'ı kaldırın ve latents'leri çözmek için bir VAE yükleyin. VAE, tek bir GPU'ya sığacak kadar küçüktür.

```py
import torch
from diffusers import AutoencoderKL
from diffusers.image_processor import VaeImageProcessor

del pipeline.transformer
del pipeline
del transformer

flush()

vae = AutoencoderKL.from_pretrained(
    "black-forest-labs/FLUX.1-dev", subfolder="vae", dtype=torch.bfloat16
).to("cuda")  # or "mps", "xpu", "cpu"
vae_scale_factor = 2 ** (len(vae.config.block_out_channels) - 1)
image_processor = VaeImageProcessor(vae_scale_factor=vae_scale_factor)

with torch.no_grad():
    print("Running decoding.")
    latents = FluxPipeline._unpack_latents(latents, height, width, vae_scale_factor)
    latents = (latents / vae.config.scaling_factor) + vae.config.shift_factor

    image = vae.decode(latents, return_dict=False)[0]
    image = image_processor.postprocess(image, output_type="pil")
    image[0].save("split_transformer.png")
```

Belirli bir aşamada ihtiyacınız olan modelleri seçici olarak yükleyip boşaltarak ve en büyük modelleri birden çok GPU arasında paylaştırarak, tüketici GPU'larında büyük modellerle çıkarım (inference) çalıştırabilirsiniz.