Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /main /tr /api /pipelines /stable_diffusion /depth2img.md
mishig
about 12 hours ago
preview code
download
raw
30.4 kB
# Derinlikten görüntüye

  

Stable Diffusion modeli, [MiDaS](https://github.com/isl-org/MiDaS) kullanarak bir görüntüden derinlik çıkarabilir. Bu sayede, yeni görüntülerin oluşturulmasını koşullandırmak için bir metin istemi ve başlangıç görüntüsü ile görüntü yapısını korumak için bir `depth_map` iletebilirsiniz.

> [!TIP]
> Scheduler hızı ve kalitesi arasındaki ödünleşimi nasıl keşfedebileceğinizi ve pipeline bileşenlerini nasıl verimli bir şekilde yeniden kullanabileceğinizi öğrenmek için Stable Diffusion [İpuçları](overview#tips) bölümünü mutlaka inceleyin!
>
> Bir görev için resmi kontrol noktalarından birini kullanmakla ilgileniyorsanız, [CompVis](https://huggingface.co/CompVis) ve [Stability AI](https://huggingface.co/stabilityai) Hub kuruluşlarını keşfedin!

## StableDiffusionDepth2ImgPipeline[[diffusers.StableDiffusionDepth2ImgPipeline]]

#### diffusers.StableDiffusionDepth2ImgPipeline[[diffusers.StableDiffusionDepth2ImgPipeline]]

```python
diffusers.StableDiffusionDepth2ImgPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, depth_estimator: DPTForDepthEstimation, feature_extractor: DPTImageProcessorPil)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_depth2img.py#L92)

**Parametreler:**

vae ([AutoencoderKL](/docs/diffusers/main/tr/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Görüntüleri latent temsillere kodlamak ve bu temsillerden görüntülere çözmek için kullanılan Varyasyonel Oto-Kodlayıcı (VAE) modeli.

text_encoder ([CLIPTextModel](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTextModel)) : Donmuş metin kodlayıcı ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)).
tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTokenizer)) : Metni belirteçleştirmek için bir `CLIPTokenizer`.
unet ([UNet2DConditionModel](/docs/diffusers/main/tr/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Kodlanmış görüntü latentlerini gürültüden arındırmak için kullanılan bir `UNet2DConditionModel`.
scheduler ([SchedulerMixin](/docs/diffusers/main/tr/api/schedulers/overview#diffusers.SchedulerMixin)) : Kodlanmış görüntü latentlerini gürültüden arındırmak için `unet` ile birlikte kullanılacak bir zamanlayıcı. [DDIMScheduler](/docs/diffusers/main/tr/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/main/tr/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) veya [PNDMScheduler](/docs/diffusers/main/tr/api/schedulers/pndm#diffusers.PNDMScheduler) olabilir.
Stable Diffusion kullanılarak metin yönlendirmeli derinlik tabanlı görüntüden görüntüye üretim için Pipeline.
Bu model [DiffusionPipeline](/docs/diffusers/main/tr/api/pipelines/overview#diffusers.DiffusionPipeline) sınıfından devralınmıştır. Tüm pipeline'lar için uygulanan genel yöntemlerin (indirme, kaydetme, belirli bir cihazda çalıştırma vb.) belgelerini üst sınıfın dokümantasyonunda bulabilirsiniz.
Pipeline ayrıca aşağıdaki yükleme yöntemlerini devralır:
- Metinsel tersine çevirme gömme yüklemek için [load_textual_inversion()](/docs/diffusers/main/tr/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion)
- LoRA ağırlıklarını yüklemek için [load_lora_weights()](/docs/diffusers/main/tr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_weights)
- LoRA ağırlıklarını kaydetmek için [save_lora_weights()](/docs/diffusers/main/tr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.save_lora_weights)
#### __call__[[diffusers.StableDiffusionDepth2ImgPipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, depth_map: typing.Optional[torch.Tensor] = None, strength: float = 0.8, num_inference_steps: int | None = 50, guidance_scale: float | None = 7.5, negative_prompt: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float | None = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, cross_attention_kwargs: dict[str, typing.Any] | None = None, clip_skip: int | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list = ['latents'], **kwargs)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_depth2img.py#L634)
**Parametreler:**
prompt (`str` veya `list[str]`, *isteğe bağlı*) : Görsel üretimi yönlendirmek için istem veya istemler. Tanımlanmadıysa, `prompt_embeds` parametresini iletmeniz gerekir.

image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` veya `list[np.ndarray]`) : Başlangıç noktası olarak kullanılacak bir görüntü partisyonunu temsil eden `Image` veya tensör. `depth_map` `None` değilse, görüntü latentlerini yalnızca `image` olarak kabul edebilir.

depth_map (`torch.Tensor`, *isteğe bağlı*) : Görsel üretim süreci için ek koşullandırma olarak kullanılacak derinlik tahmini. Tanımlanmamışsa, derinlik `self.depth_estimator` ile otomatik olarak tahmin edilir.

strength (`float`, *opsiyonel*, varsayılan 0.8) : Referans `image`'in dönüştürülme derecesini belirtir. 0 ile 1 arasında olmalıdır. `image` bir başlangıç noktası olarak kullanılır ve `strength` değeri arttıkça daha fazla gürültü eklenir. Gürültü azaltma adımlarının sayısı, başlangıçta eklenen gürültü miktarına bağlıdır. `strength` 1 olduğunda eklenen gürültü maksimumdur ve gürültü azaltma süreci, `num_inference_steps` içinde belirtilen tam tekrar sayısı kadar çalışır. 1 değeri, `image`'ı fiilen yok sayar.

num_inference_steps (`int`, *isteğe bağlı*, varsayılan 50) : Gürültü azaltma adım sayısı. Daha fazla gürültü azaltma adımı genellikle daha yavaş çıkarım pahasına daha yüksek kaliteli bir görüntüye yol açar. Bu parametre `strength` tarafından modüle edilir.

guidance_scale (`float`, *opsiyonel*, varsayılan 7.5) : Daha yüksek bir guidance scale değeri, modelin `prompt` ile yakından ilişkili görseller üretmesini teşvik eder; bunun bedeli ise daha düşük görsel kalitedir. Guidance scale, `guidance_scale > 1` olduğunda etkinleşir.

negative_prompt (`str` veya `list[str]`, *isteğe bağlı*) : Görsel üretimde nelerin dahil edilmeyeceğini yönlendirmek için istem veya istemler. Tanımlanmadıysa bunun yerine `negative_prompt_embeds` parametresini geçmeniz gerekir. Yönlendirme kullanılmadığında (`guidance_scale < 1`) yok sayılır.

num_images_per_prompt (`int`, *isteğe bağlı*, varsayılan 1) : Her istem için üretilecek görsel sayısı.
eta (`float`, *isteğe bağlı*, varsayılan 0.0) : [DDIM](https://huggingface.co/papers/2010.02502) makalesindeki eta (η) parametresine karşılık gelir. Yalnızca [DDIMScheduler](/docs/diffusers/main/tr/api/schedulers/ddim#diffusers.DDIMScheduler) için geçerlidir ve diğer zamanlayıcılarda yok sayılır.
generator (`torch.Generator` veya `list[torch.Generator]`, *isteğe bağlı*) : Üretimi deterministik hale getirmek için bir [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html).
prompt_embeds (`torch.Tensor`, *isteğe bağlı*) : Önceden oluşturulmuş metin gömme değerleri. Metin girdilerini (istek ağırlıklandırması) kolayca ayarlamak için kullanılabilir. Sağlanmazsa, metin gömme değerleri `prompt` girdi argümanından üretilir.

negative_prompt_embeds (`torch.Tensor`, *isteğe bağlı*) : Ön oluşturulmuş negatif metin gömme değerleri. Metin girdilerini (istek ağırlıklandırması) kolayca ayarlamak için kullanılabilir. Sağlanmazsa, `negative_prompt_embeds`, `negative_prompt` girdi argümanından üretilir.

output_type (`str`, *isteğe bağlı*, varsayılan `"pil"`) : Üretilen görüntünün çıktı biçimi. `PIL.Image` veya `np.array` arasında seçim yapın.
return_dict (`bool`, *isteğe bağlı*, varsayılan `True`) : Düz bir tuple yerine [StableDiffusionPipelineOutput](/docs/diffusers/main/tr/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) döndürülüp döndürülmemesi.

cross_attention_kwargs (`dict`, *isteğe bağlı*) : Belirtilirse, [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py) içinde tanımlanan `AttentionProcessor`'ye aktarılan bir kwargs sözlüğü.

clip_skip (`int`, *isteğe bağlı*) : Prompt gömme hesaplamaları sırasında CLIP'ten atlanacak katman sayısı. 1 değeri, prompt gömme hesaplamaları için son öncesi katmanın çıktısının kullanılacağı anlamına gelir.
callback_on_step_end (`Callable`, *isteğe bağlı*) : Çıkarım sırasında her gürültü azaltma adımının sonunda çağrılan bir işlev. İşlev aşağıdaki argümanlarla çağrılır: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs`, `callback_on_step_end_tensor_inputs` tarafından belirtilen tüm tensörlerin listesini içerir.

callback_on_step_end_tensor_inputs (`list`, *isteğe bağlı*) : `callback_on_step_end` işlevi için girdi tensörlerinin listesi. Listede belirtilen tensörler, `callback_kwargs` argümanı olarak geçirilir. Yalnızca pipeline sınıfınızın `._callback_tensor_inputs` özniteliğinde listelenen değişkenleri dahil edebilirsiniz.

**Dönüş:** [StableDiffusionPipelineOutput](/docs/diffusers/main/tr/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) veya `tuple`

`return_dict` `True` ise [StableDiffusionPipelineOutput](/docs/diffusers/main/tr/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) döndürülür, aksi halde ilk öğesi üretilen görüntülerin listesini içeren bir `tuple` döndürülür.

Üretim için pipeline'ın çağrı fonksiyonu.

Örnekler:

```py
>>> import torch
>>> import requests
>>> from PIL import Image
>>> from diffusers import StableDiffusionDepth2ImgPipeline
>>> pipe = StableDiffusionDepth2ImgPipeline.from_pretrained(
...     "stabilityai/stable-diffusion-2-depth",
...     torch_dtype=torch.float16,
... )
>>> pipe.to("cuda")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> init_image = Image.open(requests.get(url, stream=True).raw)
>>> prompt = "two tigers"
>>> n_prompt = "bad, deformed, ugly, bad anotomy"
>>> image = pipe(prompt=prompt, image=init_image, negative_prompt=n_prompt, strength=0.7).images[0]
```

#### enable_attention_slicing[[diffusers.StableDiffusionDepth2ImgPipeline.enable_attention_slicing]]

```python
enable_attention_slicing(slice_size: str | int = 'auto')
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L2048)

**Parametreler:**

slice_size (`str` veya `int`, *isteğe bağlı*, varsayılan `"auto"`) : `"auto"` olduğunda, dikkat başlarına giden girdiyi ikiye böler, böylece dikkat iki adımda hesaplanır. `"max"` ise, her seferinde yalnızca bir dilim çalıştırılarak maksimum miktarda bellek tasarrufu sağlanır. Bir sayı sağlanırsa, `attention_head_dim // slice_size` kadar dilim kullanılır. Bu durumda `attention_head_dim`, `slice_size`'ın katı olmalıdır.
Dilimlenmiş dikkat (attention) hesaplamasını etkinleştirir. Bu seçenek etkinleştirildiğinde, dikkat modülü dikkat hesaplamasını birkaç adımda gerçekleştirmek için girdi tensörünü dilimlere böler. Birden fazla dikkat başlığı (attention head) varsa, hesaplama her başlık üzerinde sırayla yapılır. Bu, küçük bir hız kaybı karşılığında bellek tasarrufu sağlamak için faydalıdır.
> [!WARNING] > ⚠️ Zaten `scaled_dot_product_attention` (SDPA) kullanıyorsanız dikkat dilimlemeyi etkinleştirmeyin
from PyTorch > 2.0 or xFormers. Bu dikkat hesaplamaları zaten çok bellek verimlidir, bu yüzden bu işlevi etkinleştirmenize gerek yoktur. SDPA veya xFormers ile dikkat dilimlemeyi etkinleştirirseniz, ciddi yavaşlamalara yol açabilir!

Örnekler:

```py
>>> import torch
>>> from diffusers import StableDiffusionPipeline
>>> pipe = StableDiffusionPipeline.from_pretrained(
...     "stable-diffusion-v1-5/stable-diffusion-v1-5",
...     dtype=torch.float16,
...     use_safetensors=True,
... )
>>> prompt = "a photo of an astronaut riding a horse on mars"
>>> pipe.enable_attention_slicing()
>>> image = pipe(prompt).images[0]
```

#### disable_attention_slicing[[diffusers.StableDiffusionDepth2ImgPipeline.disable_attention_slicing]]

```python
disable_attention_slicing()
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L2085)

Dilimlenmiş dikkat hesaplamasını devre dışı bırakır. `enable_attention_slicing` daha önce çağrıldıysa, dikkat tek adımda hesaplanır.

#### enable_xformers_memory_efficient_attention[[diffusers.StableDiffusionDepth2ImgPipeline.enable_xformers_memory_efficient_attention]]

```python
enable_xformers_memory_efficient_attention(attention_op: typing.Optional[typing.Callable] = None)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L1993)

**Parametreler:**

attention_op (`Callable`, *isteğe bağlı*) : xFormers'in [`memory_efficient_attention()`](https://facebookresearch.github.io/xformers/components/ops.html#xformers.ops.memory_efficient_attention) fonksiyonunda `op` argümanı olarak kullanılmak üzere varsayılan `None` operatörünü geçersiz kılar.
[xFormers](https://facebookresearch.github.io/xformers/) ile bellek verimli dikkati etkinleştirin. Bu seçenek etkinleştirildiğinde, GPU bellek kullanımının daha düşük olduğunu ve çıkarım sırasında olası bir hızlanmayı gözlemlemelisiniz. Eğitim sırasında hızlanma garanti edilmemektedir.
> [!WARNING] > ⚠️ Hem memory efficient attention hem de sliced attention etkinleştirildiğinde, memory efficient
attention, > önceliğine sahiptir.
Örnekler:
```py
>>> import torch
>>> from diffusers import DiffusionPipeline
>>> from xformers.ops import MemoryEfficientAttentionFlashAttentionOp
>>> pipe = DiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-2-1", dtype=torch.float16)
>>> pipe = pipe.to("cuda")
>>> pipe.enable_xformers_memory_efficient_attention(attention_op=MemoryEfficientAttentionFlashAttentionOp)
>>> # Workaround for not accepting attention shape using VAE for Flash Attention
>>> pipe.vae.enable_xformers_memory_efficient_attention(attention_op=None)
```
#### disable_xformers_memory_efficient_attention[[diffusers.StableDiffusionDepth2ImgPipeline.disable_xformers_memory_efficient_attention]]
```python
disable_xformers_memory_efficient_attention()
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pipeline_utils.py#L2024)
[xFormers](https://facebookresearch.github.io/xformers/) için bellek verimli dikkati devre dışı bırakın.
#### load_textual_inversion[[diffusers.StableDiffusionDepth2ImgPipeline.load_textual_inversion]]
```python
load_textual_inversion(pretrained_model_name_or_path: str | list[str] | dict[str, torch.Tensor] | list[dict[str, torch.Tensor]], token: str | list[str] | None = None, tokenizer: 'PreTrainedTokenizer' | None = None, text_encoder: 'PreTrainedModel' | None = None, **kwargs)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/textual_inversion.py#L271)
**Parametreler:**
pretrained_model_name_or_path (`str` veya `os.PathLike` veya `list[str or os.PathLike]` veya `Dict` veya `list[Dict]`) : Aşağıdakilerden biri veya bunların bir listesi olabilir:  - Hub'da barındırılan önceden eğitilmiş bir modelin *model kimliği* (örneğin `sd-concepts-library/low-poly-hd-logos-icons`) olan bir dize. - Metinsel tersine çevirme ağırlıklarını içeren bir *dizin* yolu (örneğin `./my_text_inversion_directory/`). - Metinsel tersine çevirme ağırlıklarını içeren bir *dosya* yolu (örneğin `./my_text_inversions.pt`). - Bir [torch state dict](https://pytorch.org/tutorials/beginner/saving_loading_models.html#what-is-a-state-dict).

token (`str` veya `list[str]`, *isteğe bağlı*) : Metinsel ters çevirme ağırlıkları için kullanılacak jetonu geçersiz kılar. `pretrained_model_name_or_path` bir liste ise, `token` da eşit uzunlukta bir liste olmalıdır.

text_encoder ([CLIPTextModel](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTextModel), *isteğe bağlı*) : Donmuş metin kodlayıcı ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)). Belirtilmezse, fonksiyon self.tokenizer değerini alır.
tokenizer ([CLIPTokenizer](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPTokenizer), *isteğe bağlı*) : Metni tokenleştirmek için bir `CLIPTokenizer`. Belirtilmezse, fonksiyon self.tokenizer değerini alır.
weight_name (`str`, *isteğe bağlı*) : Özel bir ağırlık dosyasının adı. Bu, aşağıdaki durumlarda kullanılmalıdır:  - Kaydedilen metinsel ters çevirme dosyası 🤗 Diffusers biçimindeyse ancak `text_inv.bin` gibi belirli bir ağırlık adı altında kaydedildiyse. - Kaydedilen metinsel ters çevirme dosyası Automatic1111 biçimindeyse.

cache_dir (`str | os.PathLike`, *isteğe bağlı*) : Standart önbellek kullanılmıyorsa, indirilen önceden eğitilmiş model yapılandırmasının önbelleğe alındığı dizinin yolu.
force_download (`bool`, *isteğe bağlı*, varsayılan `False`) : Model ağırlıklarının ve yapılandırma dosyalarının (yeniden) indirilmesinin zorlanıp zorlanmayacağını belirler; önbellekteki sürümler varsa bunların üzerine yazar.

proxies (`dict[str, str]`, *isteğe bağlı*) : Protokol veya uç nokta bazında kullanılacak vekil sunucuların sözlüğü, örneğin `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Vekiller her istekte kullanılır.

local_files_only (`bool`, *isteğe bağlı*, varsayılan `False`) : Sadece yerel model ağırlıklarının ve yapılandırma dosyalarının yüklenip yüklenmeyeceğini belirtir. `True` olarak ayarlanırsa, model Hub'dan indirilmez.

hf_token (`str` veya *bool*, *isteğe bağlı*) : Uzaktaki dosyalar için HTTP bearer yetkilendirmesi olarak kullanılacak jeton. `True` ise, `diffusers-cli login` ile oluşturulan jeton (`~/.huggingface` içinde saklanır) kullanılır.
revision (`str`, *isteğe bağlı*, varsayılan `"main"`) : Kullanılacak belirli model sürümü. Bir dal adı, etiket adı, commit kimliği veya Git tarafından izin verilen herhangi bir tanımlayıcı olabilir.
subfolder (`str`, *isteğe bağlı*, varsayılan `""`) : Hub'da veya yerel olarak daha büyük bir model deposu içindeki bir model dosyasının alt klasör konumu.
mirror (`str`, *isteğe bağlı*) : Çin'de bir model indiriyorsanız erişilebilirlik sorunlarını çözmek için ayna kaynağı. Kaynağın güncelliğini veya güvenliğini garanti etmiyoruz; daha fazla bilgi için ayna sitesine başvurmalısınız.
[StableDiffusionPipeline](/docs/diffusers/main/tr/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline) metin kodlayıcısına Textual Inversion gömme değerlerini yükleyin (hem 🤗 Diffusers hem de Automatic1111 biçimleri desteklenir).
Örnek:
🤗 Diffusers biçiminde bir Textual Inversion gömme vektörü yüklemek için:
```py
from diffusers import StableDiffusionPipeline
import torch
model_id = "stable-diffusion-v1-5/stable-diffusion-v1-5"
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16).to("cuda")
pipe.load_textual_inversion("sd-concepts-library/cat-toy")
prompt = "A <cat-toy> backpack"
image = pipe(prompt, num_inference_steps=50).images[0]
image.save("cat-backpack.png")
```
Automatic1111 biçiminde bir Textual Inversion gömme vektörünü yüklemek için, vektörü önce indirin (örneğin [civitAI](https://civitai.com/models/3036?modelVersionId=9857) üzerinden) ve ardından vektörü yükleyin
yerel olarak:
```py
from diffusers import StableDiffusionPipeline
import torch
model_id = "stable-diffusion-v1-5/stable-diffusion-v1-5"
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16).to("cuda")
pipe.load_textual_inversion("./charturnerv2.pt", token="charturnerv2")
prompt = "charturnerv2, multiple views of the same character in the same outfit, a character turnaround of a woman wearing a black jacket and red shirt, best quality, intricate details."
image = pipe(prompt, num_inference_steps=50).images[0]
image.save("character.png")
```
#### load_lora_weights[[diffusers.StableDiffusionDepth2ImgPipeline.load_lora_weights]]
```python
load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L148)
**Parametreler:**

pretrained_model_name_or_path_or_dict (`str` veya `os.PathLike` veya `dict`) : [lora_state_dict()](/docs/diffusers/main/tr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) bkz.

adapter_name (`str`, *isteğe bağlı*) : Yüklenen adapter modeline atıfta bulunmak için kullanılacak adapter adı. Belirtilmezse, yüklenen adapterlerin toplam sayısını temsil eden i için `default_{i}` kullanılır.

low_cpu_mem_usage (`bool`, *isteğe bağlı*) : Rastgele ağırlıkları başlatmadan yalnızca önceden eğitilmiş LoRA ağırlıklarını yükleyerek model yükleme hızını artırır.
hotswap (`bool`, *optional*) : Defaults to `False`. Whether to substitute an existing (LoRA) adapter with the newly loaded adapter in-place. This means that, instead of loading an additional adapter, this will take the existing adapter weights and replace them with the weights of the new adapter. This can be faster and more memory efficient. However, the main advantage of hotswapping is that when the model is compiled with torch.compile, loading the new adapter does not require recompilation of the model. When using hotswapping, the passed `adapter_name` should be the name of an already loaded adapter.  If the new adapter and the old adapter have different ranks and/or LoRA alphas (i.e. scaling), you need to call an additional method before loading the adapter:  ```py pipeline = ...  # load diffusers pipeline max_rank = ...  # the highest rank among all LoRAs that you want to load # call *before* compiling and loading the LoRA adapter pipeline.enable_lora_hotswap(target_rank=max_rank) pipeline.load_lora_weights(file_name) # optionally compile the model now ```  Note that hotswapping adapters of the text encoder is not yet supported. There are some further limitations to this technique, which are documented here: https://huggingface.co/docs/peft/main/en/package_reference/hotswap
kwargs (`dict`, *isteğe bağlı*) : [lora_state_dict()](/docs/diffusers/main/tr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict)'e bakın.
`pretrained_model_name_or_path_or_dict` içinde belirtilen LoRA ağırlıklarını `self.unet` ve `self.text_encoder` içine yükler.

Tüm kwargs, `self.lora_state_dict`'ye iletilir.

State dict'in nasıl yüklendiğine dair daha fazla ayrıntı için [lora_state_dict()](/docs/diffusers/main/tr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.lora_state_dict) işlevine bakın.

`self.unet`'e durum sözlüğünün nasıl yüklendiğine dair daha fazla ayrıntı için [load_lora_into_unet()](/docs/diffusers/main/tr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_unet) işlevine bakın.

`self.text_encoder`'e durum sözlüğünün nasıl yüklendiğine dair daha fazla ayrıntı için [load_lora_into_text_encoder()](/docs/diffusers/main/tr/api/loaders/lora#diffusers.loaders.StableDiffusionLoraLoaderMixin.load_lora_into_text_encoder) işlevine bakın.

#### save_lora_weights[[diffusers.StableDiffusionDepth2ImgPipeline.save_lora_weights]]

```python
save_lora_weights(save_directory: str | os.PathLike, unet_lora_layers: dict = None, text_encoder_lora_layers: dict = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, unet_lora_adapter_metadata = None, text_encoder_lora_adapter_metadata = None)
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/loaders/lora_pipeline.py#L466)

**Parametreler:**

save_directory (`str` veya `os.PathLike`) : LoRA parametrelerinin kaydedileceği dizin. Var değilse oluşturulur.
unet_lora_layers (`dict[str, torch.nn.Module]` veya `dict[str, torch.Tensor]`) : `unet`'ye karşılık gelen LoRA katmanlarının state dict'i.
text_encoder_lora_layers (`dict[str, torch.nn.Module]` veya `dict[str, torch.Tensor]`) : `text_encoder`'a karşılık gelen LoRA katmanlarının durum sözlüğü. 🤗 Transformers'tan geldiği için metin kodlayıcı LoRA durum sözlüğünün açıkça geçirilmesi gerekir.

is_main_process (`bool`, *isteğe bağlı*, varsayılan `True`) : Bu işlemi çağıran sürecin ana süreç olup olmadığı. Dağıtık eğitim sırasında ve bu fonksiyonu tüm süreçlerde çağırmanız gerektiğinde kullanışlıdır. Bu durumda, yarış durumlarını (race condition) önlemek için `is_main_process=True` değerini yalnızca ana süreçte ayarlayın.

save_function (`Callable`) : Durum sözlüğünü (state dictionary) kaydetmek için kullanılacak işlev. Dağıtık eğitim sırasında `torch.save` yerine başka bir yöntem kullanmanız gerektiğinde faydalıdır. `DIFFUSERS_SAVE_MODE` ortam değişkeni ile yapılandırılabilir.
safe_serialization (`bool`, *isteğe bağlı*, varsayılan `True`) : Modelin `safetensors` ile mi yoksa geleneksel PyTorch yöntemiyle `pickle` kullanılarak mı kaydedileceğini belirtir.

unet_lora_adapter_metadata : state dict ile birlikte serialize edilecek unet ile ilişkili LoRA adapter meta verileri.
text_encoder_lora_adapter_metadata : Durum sözlüğüyle birlikte seri hale getirilecek metin kodlayıcıyla ilişkili LoRA adaptör meta verileri.
UNet ve metin kodlayıcıya karşılık gelen LoRA parametrelerini kaydedin.
#### encode_prompt[[diffusers.StableDiffusionDepth2ImgPipeline.encode_prompt]]
```python
encode_prompt(prompt, device, num_images_per_prompt, do_classifier_free_guidance, negative_prompt = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, lora_scale: float | None = None, clip_skip: int | None = None)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_depth2img.py#L204)
**Parametreler:**
prompt (`str` veya `list[str]`, *isteğe bağlı*) : kodlanacak istem
device : (`torch.device`): torch cihazı
num_images_per_prompt (`int`) : her istem için oluşturulacak görsel sayısı
do_classifier_free_guidance (`bool`) : sınıflandırıcı serbest yönlendirmenin (classifier free guidance) kullanılıp kullanılmayacağı
negative_prompt (`str` veya `list[str]`, *isteğe bağlı*) : Görsel üretimi yönlendirmemek için kullanılan istem veya istemler. Tanımlanmazsa, bunun yerine `negative_prompt_embeds` parametresinin geçirilmesi gerekir. Yönlendirme kullanılmadığında (yani `guidance_scale` değeri `1`'den küçükse) yok sayılır.
prompt_embeds (`torch.Tensor`, *isteğe bağlı*) : Ön oluşturulmuş metin gömme değerleri. Metin girdilerini kolayca ayarlamak için kullanılabilir, *ör.* istem ağırlıklandırması. Sağlanmazsa, metin gömme değerleri `prompt` girdi argümanından oluşturulur.
negative_prompt_embeds (`torch.Tensor`, *isteğe bağlı*) : Ön oluşturulmuş negatif metin gömme değerleri. Metin girdilerini kolayca ayarlamak için kullanılabilir, *ör.* istem ağırlıklandırması. Sağlanmazsa, negative_prompt_embeds, `negative_prompt` girdi argümanından oluşturulur.
lora_scale (`float`, *isteğe bağlı*) : LoRA katmanları yüklendiyse, metin kodlayıcısının tüm LoRA katmanlarına uygulanacak bir LoRA ölçeği.
clip_skip (`int`, *isteğe bağlı*) : Prompt gömme hesaplamaları sırasında CLIP'ten atlanacak katman sayısı. 1 değeri, prompt gömme hesaplamaları için son öncesi katmanın çıktısının kullanılacağı anlamına gelir.
İsteği metin kodlayıcı gizli durumlarına kodlar.
## StableDiffusionPipelineOutput[[diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput]]
#### diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput[[diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput]]
```python
diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray, nsfw_content_detected: list[bool] | None)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_output.py#L10)
**Parametreler:**
images (`list[PIL.Image.Image]` veya `np.ndarray`) : `batch_size` uzunluğunda gürültüsü azaltılmış PIL görüntülerinin listesi veya `(batch_size, height, width, num_channels)` biçiminde NumPy dizisi.

nsfw_content_detected (`list[bool]`) : Üretilen ilgili görüntünün "iş yerinde uygun olmayan" (nsfw) içerik içerip içermediğini gösteren liste veya güvenlik kontrolü yapılamadıysa `None`.

Stable Diffusion hatları için çıktı sınıfı.
Xet Storage Details

Size:: 30.4 kB
Xet hash:: a9e64792388750953a04ed115f2c0ac6f7ea37c711f132139bdd04ad94597bcb
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.