Buckets:
| # Kandinsky 2.1 | |
| Kandinsky 2.1, [Arseniy Shakhmatov](https://github.com/cene555), [Anton Razzhigaev](https://github.com/razzant), [Aleksandr Nikolich](https://github.com/AlexWortega), [Vladimir Arkhipkin](https://github.com/oriBetelgeuse), [Igor Pavlov](https://github.com/boomb0om), [Andrey Kuznetsov](https://github.com/kuznetsoffandrey) ve [Denis Dimitrov](https://github.com/denndimitrov) tarafından oluşturulmuştur. | |
| GitHub sayfasındaki açıklaması: | |
| *Kandinsky 2.1, Dall-E 2 ve Latent diffusion'dan en iyi uygulamaları devralırken bazı yeni fikirler de sunar. Metin ve görüntü kodlayıcı olarak CLIP modelini ve CLIP modalitelerinin latent uzayları arasında difüzyon görüntü önceliğini (eşlemeyi) kullanır. Bu yaklaşım, modelin görsel performansını artırır ve görüntü birleştirme ile metin yönlendirmeli görüntü manipülasyonunda yeni ufuklar açar.* | |
| Orijinal kod tabanı [ai-forever/Kandinsky-2](https://github.com/ai-forever/Kandinsky-2) adresinde bulunabilir. | |
| > [!TIP] | |
| > Görselden görsel, metinden görsel ve inpainting gibi görevler için resmi model checkpoint'lerini Hub'daki [Kandinsky Community](https://huggingface.co/kandinsky-community) kuruluşunda bulabilirsiniz. | |
| > [!TIP] | |
| > Scheduler'lar [kılavuzunu](../../using-diffusers/schedulers) inceleyerek scheduler hızı ve kalitesi arasındaki ödünleşimi nasıl keşfedebileceğinizi öğrenin ve aynı bileşenleri birden fazla pipeline'a nasıl verimli bir şekilde yükleyebileceğinizi öğrenmek için [pipeline'lar arasında bileşenleri yeniden kullanma](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) bölümüne göz atın. | |
| Aşağıdaki kütüphanelerin yüklü olduğundan emin olun. | |
| ```py | |
| # uncomment to install the necessary libraries in Colab | |
| #!pip install -q diffusers transformers accelerate | |
| ``` | |
| > [!WARNING] | |
| > Kandinsky 2.1 ve 2.2 kullanımı çok benzerdir! Tek fark, Kandinsky 2.2'nin latentleri çözerken `prompt` girdisini kabul etmemesidir. Bunun yerine Kandinsky 2.2, çözümleme sırasında yalnızca `image_embeds` kabul eder. | |
| > | |
| > | |
| > | |
| > Kandinsky 3 daha sade bir mimariye sahiptir ve önceden bir model gerektirmez. Bu, kullanımının [Stable Diffusion XL](./stable_diffusion/stable_diffusion_xl) gibi diğer difüzyon modelleriyle aynı olduğu anlamına gelir. | |
| ## Metinden görüntüye | |
| Kandinsky modellerini herhangi bir görev için kullanmak için her zaman önce, prompt'u kodlamak ve görsel gömme (embedding) değerlerini üretmek üzere prior hattını (prior pipeline) yapılandırmakla başlarsınız. Prior hattı ayrıca `""` negatif prompt'una karşılık gelen `negative_image_embeds` değerlerini de üretir. Daha iyi sonuçlar için prior hattına gerçek bir `negative_prompt` iletebilirsiniz, ancak bu, prior hattının etkili batch boyutunu 2 katına çıkarır. | |
| ```py | |
| from diffusers import KandinskyPriorPipeline, KandinskyPipeline | |
| import torch | |
| prior_pipeline = KandinskyPriorPipeline.from_pretrained("kandinsky-community/kandinsky-2-1-prior", dtype=torch.float16).to("cuda") # or "mps", "xpu", "cpu" | |
| pipeline = KandinskyPipeline.from_pretrained("kandinsky-community/kandinsky-2-1", dtype=torch.float16).to("cuda") | |
| prompt = "A alien cheeseburger creature eating itself, claymation, cinematic, moody lighting" | |
| negative_prompt = "low quality, bad quality" # optional to include a negative prompt, but results are usually better | |
| image_embeds, negative_image_embeds = prior_pipeline(prompt, negative_prompt, guidance_scale=1.0).to_tuple() | |
| ``` | |
| Şimdi tüm istemleri ve gömme değerlerini bir görüntü oluşturmak için [KandinskyPipeline](/docs/diffusers/main/tr/api/pipelines/kandinsky#diffusers.KandinskyPipeline) bileşenine iletin: | |
| ```py | |
| image = pipeline(prompt, image_embeds=image_embeds, negative_prompt=negative_prompt, negative_image_embeds=negative_image_embeds, height=768, width=768).images[0] | |
| image | |
| ``` | |
| ```py | |
| from diffusers import KandinskyV22PriorPipeline, KandinskyV22Pipeline | |
| import torch | |
| prior_pipeline = KandinskyV22PriorPipeline.from_pretrained("kandinsky-community/kandinsky-2-2-prior", dtype=torch.float16).to("cuda") # or "mps", "xpu", "cpu" | |
| pipeline = KandinskyV22Pipeline.from_pretrained("kandinsky-community/kandinsky-2-2-decoder", dtype=torch.float16).to("cuda") | |
| prompt = "A alien cheeseburger creature eating itself, claymation, cinematic, moody lighting" | |
| negative_prompt = "low quality, bad quality" # optional to include a negative prompt, but results are usually better | |
| image_embeds, negative_image_embeds = prior_pipeline(prompt, guidance_scale=1.0).to_tuple() | |
| ``` | |
| Bir görüntü oluşturmak için `image_embeds` ve `negative_image_embeds` değerlerini [KandinskyV22Pipeline](/docs/diffusers/main/tr/api/pipelines/kandinsky_v22#diffusers.KandinskyV22Pipeline) bileşenine iletin: | |
| ```py | |
| image = pipeline(image_embeds=image_embeds, negative_image_embeds=negative_image_embeds, height=768, width=768).images[0] | |
| image | |
| ``` | |
| Kandinsky 3 önceden bir model gerektirmediğinden doğrudan [Kandinsky3Pipeline](/docs/diffusers/main/tr/api/pipelines/kandinsky3#diffusers.Kandinsky3Pipeline) yükleyip bir istem (prompt) geçirerek bir görsel üretebilirsiniz: | |
| ```py | |
| from diffusers import Kandinsky3Pipeline | |
| import torch | |
| pipeline = Kandinsky3Pipeline.from_pretrained("kandinsky-community/kandinsky-3", variant="fp16", dtype=torch.float16) | |
| pipeline.enable_model_cpu_offload() | |
| prompt = "A alien cheeseburger creature eating itself, claymation, cinematic, moody lighting" | |
| image = pipeline(prompt).images[0] | |
| image | |
| ``` | |
| 🤗 Diffusers ayrıca [KandinskyCombinedPipeline](/docs/diffusers/main/tr/api/pipelines/kandinsky#diffusers.KandinskyCombinedPipeline) ve [KandinskyV22CombinedPipeline](/docs/diffusers/main/tr/api/pipelines/kandinsky_v22#diffusers.KandinskyV22CombinedPipeline) ile uçtan uca bir API sunar; bu sayede prior ve metinden görüntüye pipeline'ı ayrı ayrı yüklemenize gerek kalmaz. Birleşik pipeline, hem prior modelini hem de decoder'ı otomatik olarak yükler. İsterseniz prior pipeline için farklı değerleri `prior_guidance_scale` ve `prior_num_inference_steps` parametreleriyle belirleyebilirsiniz. | |
| [AutoPipelineForText2Image](/docs/diffusers/main/tr/api/pipelines/auto_pipeline#diffusers.AutoPipelineForText2Image) kullanarak altta birleşik pipeline'ları otomatik olarak çağırın: | |
| ```py | |
| from diffusers import AutoPipelineForText2Image | |
| import torch | |
| pipeline = AutoPipelineForText2Image.from_pretrained("kandinsky-community/kandinsky-2-1", dtype=torch.float16) | |
| pipeline.enable_model_cpu_offload() | |
| prompt = "A alien cheeseburger creature eating itself, claymation, cinematic, moody lighting" | |
| negative_prompt = "low quality, bad quality" | |
| image = pipeline(prompt=prompt, negative_prompt=negative_prompt, prior_guidance_scale=1.0, guidance_scale=4.0, height=768, width=768).images[0] | |
| image | |
| ``` | |
| ```py | |
| from diffusers import AutoPipelineForText2Image | |
| import torch | |
| pipeline = AutoPipelineForText2Image.from_pretrained("kandinsky-community/kandinsky-2-2-decoder", dtype=torch.float16) | |
| pipeline.enable_model_cpu_offload() | |
| prompt = "A alien cheeseburger creature eating itself, claymation, cinematic, moody lighting" | |
| negative_prompt = "low quality, bad quality" | |
| image = pipeline(prompt=prompt, negative_prompt=negative_prompt, prior_guidance_scale=1.0, guidance_scale=4.0, height=768, width=768).images[0] | |
| image | |
| ``` | |
| ## Görselden görseli | |
| Görselden görseli için, başlangıç görselini ve görseli koşullandırmak için metin komutunu pipeline'a iletin. Önce önceki pipeline'ı yükleyerek başlayın: | |
| ```py | |
| import torch | |
| from diffusers import KandinskyImg2ImgPipeline, KandinskyPriorPipeline | |
| prior_pipeline = KandinskyPriorPipeline.from_pretrained("kandinsky-community/kandinsky-2-1-prior", dtype=torch.float16, use_safetensors=True).to("cuda") # or "mps", "xpu", "cpu" | |
| pipeline = KandinskyImg2ImgPipeline.from_pretrained("kandinsky-community/kandinsky-2-1", dtype=torch.float16, use_safetensors=True).to("cuda") | |
| ``` | |
| ```py | |
| import torch | |
| from diffusers import KandinskyV22Img2ImgPipeline, KandinskyPriorPipeline | |
| prior_pipeline = KandinskyPriorPipeline.from_pretrained("kandinsky-community/kandinsky-2-2-prior", dtype=torch.float16, use_safetensors=True).to("cuda") # or "mps", "xpu", "cpu" | |
| pipeline = KandinskyV22Img2ImgPipeline.from_pretrained("kandinsky-community/kandinsky-2-2-decoder", dtype=torch.float16, use_safetensors=True).to("cuda") | |
| ``` | |
| Kandinsky 3, önceden bir model gerektirmediğinden doğrudan image-to-image hattını yükleyebilirsiniz: | |
| ```py | |
| from diffusers import Kandinsky3Img2ImgPipeline | |
| from diffusers.utils import load_image | |
| import torch | |
| pipeline = Kandinsky3Img2ImgPipeline.from_pretrained("kandinsky-community/kandinsky-3", variant="fp16", dtype=torch.float16) | |
| pipeline.enable_model_cpu_offload() | |
| ``` | |
| Koşullama için bir görüntü indirin: | |
| ```py | |
| from diffusers.utils import load_image | |
| # download image | |
| url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg" | |
| original_image = load_image(url) | |
| original_image = original_image.resize((768, 512)) | |
| ``` | |
| Önceki boru hattıyla `image_embeds` ve `negative_image_embeds` değerlerini oluşturun: | |
| ```py | |
| prompt = "A fantasy landscape, Cinematic lighting" | |
| negative_prompt = "low quality, bad quality" | |
| image_embeds, negative_image_embeds = prior_pipeline(prompt, negative_prompt).to_tuple() | |
| ``` | |
| Şimdi orijinal görüntüyü, tüm istemleri ve gömme değerlerini bir görüntü üretmek için pipeline'a iletin: | |
| ```py | |
| from diffusers.utils import make_image_grid | |
| image = pipeline(prompt, negative_prompt=negative_prompt, image=original_image, image_embeds=image_embeds, negative_image_embeds=negative_image_embeds, height=768, width=768, strength=0.3).images[0] | |
| make_image_grid([original_image.resize((512, 512)), image.resize((512, 512))], rows=1, cols=2) | |
| ``` | |
| ```py | |
| from diffusers.utils import make_image_grid | |
| image = pipeline(image=original_image, image_embeds=image_embeds, negative_image_embeds=negative_image_embeds, height=768, width=768, strength=0.3).images[0] | |
| make_image_grid([original_image.resize((512, 512)), image.resize((512, 512))], rows=1, cols=2) | |
| ``` | |
| ```py | |
| image = pipeline(prompt, negative_prompt=negative_prompt, image=image, strength=0.75, num_inference_steps=25).images[0] | |
| image | |
| ``` | |
| 🤗 Diffusers ayrıca [KandinskyImg2ImgCombinedPipeline](/docs/diffusers/main/tr/api/pipelines/kandinsky#diffusers.KandinskyImg2ImgCombinedPipeline) ve [KandinskyV22Img2ImgCombinedPipeline](/docs/diffusers/main/tr/api/pipelines/kandinsky_v22#diffusers.KandinskyV22Img2ImgCombinedPipeline) ile uçtan uca bir API sunar; bu sayede prior ve image-to-image pipeline'larını ayrı ayrı yüklemenize gerek kalmaz. Birleşik pipeline, hem prior modelini hem de decoder'ı otomatik olarak yükler. İsterseniz prior pipeline için farklı değerleri `prior_guidance_scale` ve `prior_num_inference_steps` parametreleriyle belirleyebilirsiniz. | |
| Birleşik pipeline'ların arkasında otomatik olarak çağrılmasını sağlamak için [AutoPipelineForImage2Image](/docs/diffusers/main/tr/api/pipelines/auto_pipeline#diffusers.AutoPipelineForImage2Image) kullanın: | |
| ```py | |
| from diffusers import AutoPipelineForImage2Image | |
| from diffusers.utils import make_image_grid, load_image | |
| import torch | |
| pipeline = AutoPipelineForImage2Image.from_pretrained("kandinsky-community/kandinsky-2-1", dtype=torch.float16, use_safetensors=True) | |
| pipeline.enable_model_cpu_offload() | |
| prompt = "A fantasy landscape, Cinematic lighting" | |
| negative_prompt = "low quality, bad quality" | |
| url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg" | |
| original_image = load_image(url) | |
| original_image.thumbnail((768, 768)) | |
| image = pipeline(prompt=prompt, negative_prompt=negative_prompt, image=original_image, strength=0.3).images[0] | |
| make_image_grid([original_image.resize((512, 512)), image.resize((512, 512))], rows=1, cols=2) | |
| ``` | |
| ```py | |
| from diffusers import AutoPipelineForImage2Image | |
| from diffusers.utils import make_image_grid, load_image | |
| import torch | |
| pipeline = AutoPipelineForImage2Image.from_pretrained("kandinsky-community/kandinsky-2-2-decoder", dtype=torch.float16) | |
| pipeline.enable_model_cpu_offload() | |
| prompt = "A fantasy landscape, Cinematic lighting" | |
| negative_prompt = "low quality, bad quality" | |
| url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg" | |
| original_image = load_image(url) | |
| original_image.thumbnail((768, 768)) | |
| image = pipeline(prompt=prompt, negative_prompt=negative_prompt, image=original_image, strength=0.3).images[0] | |
| make_image_grid([original_image.resize((512, 512)), image.resize((512, 512))], rows=1, cols=2) | |
| ``` | |
| ## Inpainting | |
| > [!WARNING] | |
| > ⚠️ Kandinsky modelleri artık maskelenmiş alanı siyah pikseller yerine ⬜️ **beyaz pikseller** ile temsil eder. Üretim ortamında [KandinskyInpaintPipeline](/docs/diffusers/main/tr/api/pipelines/kandinsky#diffusers.KandinskyInpaintPipeline) kullanıyorsanız, maskenin beyaz pikseller kullanacak şekilde değiştirilmesi gerekir: | |
| > | |
| > ```py | |
| > # For PIL input | |
| > import PIL.ImageOps | |
| > mask = PIL.ImageOps.invert(mask) | |
| > | |
| > # For PyTorch and NumPy input | |
| > mask = 1 - mask | |
| > ``` | |
| Inpainting için orijinal görüntüyü, orijinal görüntüde değiştirilecek alanın maskesini ve inpainting yapılacak içeriğin metin komutunu (prompt) kullanmanız gerekir. Önceki pipeline'ı yükleyin: | |
| ```py | |
| from diffusers import KandinskyInpaintPipeline, KandinskyPriorPipeline | |
| from diffusers.utils import load_image, make_image_grid | |
| import torch | |
| import numpy as np | |
| from PIL import Image | |
| prior_pipeline = KandinskyPriorPipeline.from_pretrained("kandinsky-community/kandinsky-2-1-prior", dtype=torch.float16, use_safetensors=True).to("cuda") # or "mps", "xpu", "cpu" | |
| pipeline = KandinskyInpaintPipeline.from_pretrained("kandinsky-community/kandinsky-2-1-inpaint", dtype=torch.float16, use_safetensors=True).to("cuda") | |
| ``` | |
| ```py | |
| from diffusers import KandinskyV22InpaintPipeline, KandinskyV22PriorPipeline | |
| from diffusers.utils import load_image, make_image_grid | |
| import torch | |
| import numpy as np | |
| from PIL import Image | |
| prior_pipeline = KandinskyV22PriorPipeline.from_pretrained("kandinsky-community/kandinsky-2-2-prior", dtype=torch.float16, use_safetensors=True).to("cuda") # or "mps", "xpu", "cpu" | |
| pipeline = KandinskyV22InpaintPipeline.from_pretrained("kandinsky-community/kandinsky-2-2-decoder-inpaint", dtype=torch.float16, use_safetensors=True).to("cuda") | |
| ``` | |
| Başlangıç görüntüsünü yükleyin ve bir maske oluşturun: | |
| ```py | |
| init_image = load_image("https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/kandinsky/cat.png") | |
| mask = np.zeros((768, 768), dtype=np.float32) | |
| # mask area above cat's head | |
| mask[:250, 250:-250] = 1 | |
| ``` | |
| Önceki boru hattıyla gömme (embedding) değerlerini oluşturun: | |
| ```py | |
| prompt = "a hat" | |
| prior_output = prior_pipeline(prompt) | |
| ``` | |
| Şimdi başlangıç görüntüsünü, maskesini, istemini ve gömümelerini bir görüntü üretmek için hattın (pipeline) içine iletin: | |
| ```py | |
| output_image = pipeline(prompt, image=init_image, mask_image=mask, **prior_output, height=768, width=768, num_inference_steps=150).images[0] | |
| mask = Image.fromarray((mask*255).astype('uint8'), 'L') | |
| make_image_grid([init_image, mask, output_image], rows=1, cols=3) | |
| ``` | |
| ```py | |
| output_image = pipeline(image=init_image, mask_image=mask, **prior_output, height=768, width=768, num_inference_steps=150).images[0] | |
| mask = Image.fromarray((mask*255).astype('uint8'), 'L') | |
| make_image_grid([init_image, mask, output_image], rows=1, cols=3) | |
| ``` | |
| Ayrıca, prior ve decoder pipeline'larını birlikte arka planda çağırmak için uçtan uca [KandinskyInpaintCombinedPipeline](/docs/diffusers/main/tr/api/pipelines/kandinsky#diffusers.KandinskyInpaintCombinedPipeline) ve [KandinskyV22InpaintCombinedPipeline](/docs/diffusers/main/tr/api/pipelines/kandinsky_v22#diffusers.KandinskyV22InpaintCombinedPipeline) bileşenlerini de kullanabilirsiniz. Bunun için [AutoPipelineForInpainting](/docs/diffusers/main/tr/api/pipelines/auto_pipeline#diffusers.AutoPipelineForInpainting) bileşenini kullanın: | |
| ```py | |
| import torch | |
| import numpy as np | |
| from PIL import Image | |
| from diffusers import AutoPipelineForInpainting | |
| from diffusers.utils import load_image, make_image_grid | |
| pipe = AutoPipelineForInpainting.from_pretrained("kandinsky-community/kandinsky-2-1-inpaint", dtype=torch.float16) | |
| pipe.enable_model_cpu_offload() | |
| init_image = load_image("https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/kandinsky/cat.png") | |
| mask = np.zeros((768, 768), dtype=np.float32) | |
| # mask area above cat's head | |
| mask[:250, 250:-250] = 1 | |
| prompt = "a hat" | |
| output_image = pipe(prompt=prompt, image=init_image, mask_image=mask).images[0] | |
| mask = Image.fromarray((mask*255).astype('uint8'), 'L') | |
| make_image_grid([init_image, mask, output_image], rows=1, cols=3) | |
| ``` | |
| ```py | |
| import torch | |
| import numpy as np | |
| from PIL import Image | |
| from diffusers import AutoPipelineForInpainting | |
| from diffusers.utils import load_image, make_image_grid | |
| pipe = AutoPipelineForInpainting.from_pretrained("kandinsky-community/kandinsky-2-2-decoder-inpaint", dtype=torch.float16) | |
| pipe.enable_model_cpu_offload() | |
| init_image = load_image("https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/kandinsky/cat.png") | |
| mask = np.zeros((768, 768), dtype=np.float32) | |
| # mask area above cat's head | |
| mask[:250, 250:-250] = 1 | |
| prompt = "a hat" | |
| output_image = pipe(prompt=prompt, image=original_image, mask_image=mask).images[0] | |
| mask = Image.fromarray((mask*255).astype('uint8'), 'L') | |
| make_image_grid([init_image, mask, output_image], rows=1, cols=3) | |
| ``` | |
| ## İnterpolasyon | |
| Interpolation, görsel ve metin gömme (embedding) uzayları arasındaki gizli uzayı (latent space) keşfetmenizi sağlar; bu, öncül modelin (prior model) ara çıktılarının bir kısmını görmek için harika bir yoldur. Öncül hattı (pipeline) ve interpolate etmek istediğiniz iki görseli yükleyin: | |
| ```py | |
| from diffusers import KandinskyPriorPipeline, KandinskyPipeline | |
| from diffusers.utils import load_image, make_image_grid | |
| import torch | |
| prior_pipeline = KandinskyPriorPipeline.from_pretrained("kandinsky-community/kandinsky-2-1-prior", dtype=torch.float16, use_safetensors=True).to("cuda") # or "mps", "xpu", "cpu" | |
| img_1 = load_image("https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/kandinsky/cat.png") | |
| img_2 = load_image("https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/kandinsky/starry_night.jpeg") | |
| make_image_grid([img_1.resize((512,512)), img_2.resize((512,512))], rows=1, cols=2) | |
| ``` | |
| ```py | |
| from diffusers import KandinskyV22PriorPipeline, KandinskyV22Pipeline | |
| from diffusers.utils import load_image, make_image_grid | |
| import torch | |
| prior_pipeline = KandinskyV22PriorPipeline.from_pretrained("kandinsky-community/kandinsky-2-2-prior", dtype=torch.float16, use_safetensors=True).to("cuda") # or "mps", "xpu", "cpu" | |
| img_1 = load_image("https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/kandinsky/cat.png") | |
| img_2 = load_image("https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/kandinsky/starry_night.jpeg") | |
| make_image_grid([img_1.resize((512,512)), img_2.resize((512,512))], rows=1, cols=2) | |
| ``` | |
| bir kedi | |
| Van Gogh'un Yıldızlı Gece tablosu | |
| İçpolarmak istediğiniz metinleri veya görselleri belirtin ve her metin veya görsel için ağırlıkları ayarlayın. Ağırlıkların içpolarmayı nasıl etkilediğini görmek için ağırlıklarla deneyler yapın! | |
| ```py | |
| images_texts = ["a cat", img_1, img_2] | |
| weights = [0.3, 0.3, 0.4] | |
| ``` | |
| Gömlemeleri oluşturmak için `interpolate` fonksiyonunu çağırın ve ardından bunları pipeline'a geçirerek görüntüyü oluşturun: | |
| ```py | |
| # prompt can be left empty | |
| prompt = "" | |
| prior_out = prior_pipeline.interpolate(images_texts, weights) | |
| pipeline = KandinskyPipeline.from_pretrained("kandinsky-community/kandinsky-2-1", dtype=torch.float16, use_safetensors=True).to("cuda") # or "mps", "xpu", "cpu" | |
| image = pipeline(prompt, **prior_out, height=768, width=768).images[0] | |
| image | |
| ``` | |
| ```py | |
| # prompt can be left empty | |
| prompt = "" | |
| prior_out = prior_pipeline.interpolate(images_texts, weights) | |
| pipeline = KandinskyV22Pipeline.from_pretrained("kandinsky-community/kandinsky-2-2-decoder", dtype=torch.float16, use_safetensors=True).to("cuda") # or "mps", "xpu", "cpu" | |
| image = pipeline(prompt, **prior_out, height=768, width=768).images[0] | |
| image | |
| ``` | |
| ## ControlNet | |
| > [!WARNING] | |
| > ⚠️ ControlNet yalnızca Kandinsky 2.2 için desteklenir! | |
| ControlNet, derinlik haritası veya kenar algılama gibi ek girdilerle büyük önceden eğitilmiş difüzyon modellerinin koşullandırılmasını sağlar. Örneğin, Kandinsky 2.2'yi bir derinlik haritasıyla koşullandırarak modelin derinlik görüntüsünün yapısını anlamasını ve korumasını sağlayabilirsiniz. | |
| Bir görüntü yükleyelim ve derinlik haritasını çıkaralım: | |
| ```py | |
| from diffusers.utils import load_image | |
| img = load_image( | |
| "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/kandinskyv22/cat.png" | |
| ).resize((768, 768)) | |
| img | |
| ``` | |
| Ardından 🤗 Transformers'tan `depth-estimation` [Pipeline](https://huggingface.co/docs/transformers/main/en/main_classes/pipelines#transformers.Pipeline)'ını kullanarak görüntüyü işleyebilir ve derinlik haritasını alabilirsiniz: | |
| ```py | |
| import torch | |
| import numpy as np | |
| from transformers import pipeline | |
| def make_hint(image, depth_estimator): | |
| image = depth_estimator(image)["depth"] | |
| image = np.array(image) | |
| image = image[:, :, None] | |
| image = np.concatenate([image, image, image], axis=2) | |
| detected_map = torch.from_numpy(image).float() / 255.0 | |
| hint = detected_map.permute(2, 0, 1) | |
| return hint | |
| depth_estimator = pipeline("depth-estimation") | |
| hint = make_hint(img, depth_estimator).unsqueeze(0).half().to("cuda") # or "mps", "xpu", "cpu" | |
| ``` | |
| ### Metinden görüntüye[[controlnet-text-to-image]] | |
| Önceki hattı ve [KandinskyV22ControlnetPipeline](/docs/diffusers/main/tr/api/pipelines/kandinsky_v22#diffusers.KandinskyV22ControlnetPipeline) bileşenini yükleyin: | |
| ```py | |
| from diffusers import KandinskyV22PriorPipeline, KandinskyV22ControlnetPipeline | |
| prior_pipeline = KandinskyV22PriorPipeline.from_pretrained( | |
| "kandinsky-community/kandinsky-2-2-prior", dtype=torch.float16, use_safetensors=True | |
| ).to("cuda") # or "mps", "xpu", "cpu" | |
| pipeline = KandinskyV22ControlnetPipeline.from_pretrained( | |
| "kandinsky-community/kandinsky-2-2-controlnet-depth", dtype=torch.float16 | |
| ).to("cuda") | |
| ``` | |
| Bir istem ve negatif istemden görüntü gömme değerlerini oluşturun: | |
| ```py | |
| prompt = "A robot, 4k photo" | |
| negative_prior_prompt = "lowres, text, error, cropped, worst quality, low quality, jpeg artifacts, ugly, duplicate, morbid, mutilated, out of frame, extra fingers, mutated hands, poorly drawn hands, poorly drawn face, mutation, deformed, blurry, dehydrated, bad anatomy, bad proportions, extra limbs, cloned face, disfigured, gross proportions, malformed limbs, missing arms, missing legs, extra arms, extra legs, fused fingers, too many fingers, long neck, username, watermark, signature" | |
| generator = torch.Generator(device="cuda").manual_seed(43) # or "mps", "xpu", "cpu" | |
| image_emb, zero_image_emb = prior_pipeline( | |
| prompt=prompt, negative_prompt=negative_prior_prompt, generator=generator | |
| ).to_tuple() | |
| ``` | |
| Son olarak, görsel gömme değerlerini ve derinlik görselini [KandinskyV22ControlnetPipeline](/docs/diffusers/main/tr/api/pipelines/kandinsky_v22#diffusers.KandinskyV22ControlnetPipeline) içine geçirerek bir görsel oluşturun: | |
| ```py | |
| image = pipeline(image_embeds=image_emb, negative_image_embeds=zero_image_emb, hint=hint, num_inference_steps=50, generator=generator, height=768, width=768).images[0] | |
| image | |
| ``` | |
| ### Görselden görseli[[controlnet-image-to-image]] | |
| ControlNet ile görüntüden görüntüye için şunu kullanmanız gerekir: | |
| - Bir metin komutu ve bir görüntüden görüntü gömme değerlerini üretmek için [KandinskyV22PriorEmb2EmbPipeline](/docs/diffusers/main/tr/api/pipelines/kandinsky_v22#diffusers.KandinskyV22PriorEmb2EmbPipeline) kullanın | |
| - Başlangıç görüntüsünden ve görüntü gömcelerinden bir görüntü üretmek için [KandinskyV22ControlnetImg2ImgPipeline](/docs/diffusers/main/tr/api/pipelines/kandinsky_v22#diffusers.KandinskyV22ControlnetImg2ImgPipeline) kullanın | |
| 🤗 Transformers'taki `depth-estimation` [Pipeline](https://huggingface.co/docs/transformers/main/en/main_classes/pipelines#transformers.Pipeline) ile bir kedinin başlangıç görüntüsünün derinlik haritasını işleyip çıkarın: | |
| ```py | |
| import torch | |
| import numpy as np | |
| from diffusers import KandinskyV22PriorEmb2EmbPipeline, KandinskyV22ControlnetImg2ImgPipeline | |
| from diffusers.utils import load_image | |
| from transformers import pipeline | |
| img = load_image( | |
| "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/kandinskyv22/cat.png" | |
| ).resize((768, 768)) | |
| def make_hint(image, depth_estimator): | |
| image = depth_estimator(image)["depth"] | |
| image = np.array(image) | |
| image = image[:, :, None] | |
| image = np.concatenate([image, image, image], axis=2) | |
| detected_map = torch.from_numpy(image).float() / 255.0 | |
| hint = detected_map.permute(2, 0, 1) | |
| return hint | |
| depth_estimator = pipeline("depth-estimation") | |
| hint = make_hint(img, depth_estimator).unsqueeze(0).half().to("cuda") # or "mps", "xpu", "cpu" | |
| ``` | |
| Önceki hattı ve [KandinskyV22ControlnetImg2ImgPipeline](/docs/diffusers/main/tr/api/pipelines/kandinsky_v22#diffusers.KandinskyV22ControlnetImg2ImgPipeline)'i yükleyin: | |
| ```py | |
| prior_pipeline = KandinskyV22PriorEmb2EmbPipeline.from_pretrained( | |
| "kandinsky-community/kandinsky-2-2-prior", dtype=torch.float16, use_safetensors=True | |
| ).to("cuda") # or "mps", "xpu", "cpu" | |
| pipeline = KandinskyV22ControlnetImg2ImgPipeline.from_pretrained( | |
| "kandinsky-community/kandinsky-2-2-controlnet-depth", dtype=torch.float16 | |
| ).to("cuda") | |
| ``` | |
| Görsel gömme (embeddings) oluşturmak için metin komutunu ve başlangıç görselini prior hattına (pipeline) iletin: | |
| ```py | |
| prompt = "A robot, 4k photo" | |
| negative_prior_prompt = "lowres, text, error, cropped, worst quality, low quality, jpeg artifacts, ugly, duplicate, morbid, mutilated, out of frame, extra fingers, mutated hands, poorly drawn hands, poorly drawn face, mutation, deformed, blurry, dehydrated, bad anatomy, bad proportions, extra limbs, cloned face, disfigured, gross proportions, malformed limbs, missing arms, missing legs, extra arms, extra legs, fused fingers, too many fingers, long neck, username, watermark, signature" | |
| generator = torch.Generator(device="cuda").manual_seed(43) # or "mps", "xpu", "cpu" | |
| img_emb = prior_pipeline(prompt=prompt, image=img, strength=0.85, generator=generator) | |
| negative_emb = prior_pipeline(prompt=negative_prior_prompt, image=img, strength=1, generator=generator) | |
| ``` | |
| Şimdi başlangıç görüntüsünden ve görüntü gömcelerinden bir görüntü üretmek için [KandinskyV22ControlnetImg2ImgPipeline](/docs/diffusers/main/tr/api/pipelines/kandinsky_v22#diffusers.KandinskyV22ControlnetImg2ImgPipeline) çalıştırabilirsiniz: | |
| ```py | |
| image = pipeline(image=img, strength=0.5, image_embeds=img_emb.image_embeds, negative_image_embeds=negative_emb.image_embeds, hint=hint, num_inference_steps=50, generator=generator, height=768, width=768).images[0] | |
| make_image_grid([img.resize((512, 512)), image.resize((512, 512))], rows=1, cols=2) | |
| ``` | |
| ## Optimizasyonlar | |
| Kandinsky, eşlemeleri üretmek için bir ön işleme hattı ve gizli değişkenleri (latents) bir görüntüye dönüştürmek için ikinci bir işleme hattı gerektirdiği için benzersizdir. Optimizasyon çabaları, hesaplamaların büyük bölümünün yapıldığı yer olan ikinci işleme hattına odaklanmalıdır. Kandinsky'nin çıkarım (inference) sırasında performansını iyileştirmek için bazı ipuçları aşağıda verilmiştir. | |
| 1. PyTorch < 2.0 kullanıyorsanız [xFormers](../../optimization/attention_backends) etkinleştirin: | |
| ```diff | |
| from diffusers import DiffusionPipeline | |
| import torch | |
| pipe = DiffusionPipeline.from_pretrained("kandinsky-community/kandinsky-2-1", dtype=torch.float16) | |
| + pipe.enable_xformers_memory_efficient_attention() | |
| ``` | |
| 2. PyTorch >= 2.0 kullanıyorsanız, ölçekli nokta çarpımı dikkatini (SDPA) otomatik olarak kullanmak için `torch.compile` etkinleştirin: | |
| ```diff | |
| pipe.unet.to(memory_format=torch.channels_last) | |
| + pipe.unet = torch.compile(pipe.unet, mode="reduce-overhead", fullgraph=True) | |
| ``` | |
| Bu, dikkat işleyicisini [AttnAddedKVProcessor2_0](/docs/diffusers/main/tr/api/attnprocessor#diffusers.models.attention_processor.AttnAddedKVProcessor2_0) kullanacak şekilde açıkça ayarlamaktan farklı değildir: | |
| ```py | |
| from diffusers.models.attention_processor import AttnAddedKVProcessor2_0 | |
| pipe.unet.set_attn_processor(AttnAddedKVProcessor2_0()) | |
| ``` | |
| 3. Bellek dışı (out-of-memory) hatalarını önlemek için modeli [enable_model_cpu_offload()](/docs/diffusers/main/tr/api/pipelines/overview#diffusers.DiffusionPipeline.enable_model_cpu_offload) ile CPU'ya taşıyın: | |
| ```diff | |
| from diffusers import DiffusionPipeline | |
| import torch | |
| pipe = DiffusionPipeline.from_pretrained("kandinsky-community/kandinsky-2-1", dtype=torch.float16) | |
| + pipe.enable_model_cpu_offload() | |
| ``` | |
| 4. Varsayılan olarak metinden görüntüye pipeline [DDIMScheduler](/docs/diffusers/main/tr/api/schedulers/ddim#diffusers.DDIMScheduler) kullanır ancak çıkarım hızı ile görüntü kalitesi arasındaki dengeyi nasıl etkilediğini görmek için [DDPMScheduler](/docs/diffusers/main/tr/api/schedulers/ddpm#diffusers.DDPMScheduler) gibi başka bir zamanlayıcıyla değiştirebilirsiniz: | |
| ```py | |
| from diffusers import DDPMScheduler | |
| from diffusers import DiffusionPipeline | |
| scheduler = DDPMScheduler.from_pretrained("kandinsky-community/kandinsky-2-1", subfolder="ddpm_scheduler") | |
| pipe = DiffusionPipeline.from_pretrained("kandinsky-community/kandinsky-2-1", scheduler=scheduler, dtype=torch.float16, use_safetensors=True).to("cuda") # or "mps", "xpu", "cpu" | |
| ``` | |
| ## KandinskyPriorPipeline[[diffusers.KandinskyPriorPipeline]] | |
| #### diffusers.KandinskyPriorPipeline[[diffusers.KandinskyPriorPipeline]] | |
| ```python | |
| diffusers.KandinskyPriorPipeline(prior: PriorTransformer, image_encoder: CLIPVisionModelWithProjection, text_encoder: CLIPTextModelWithProjection, tokenizer: CLIPTokenizer, scheduler: UnCLIPScheduler, image_processor: CLIPImageProcessorPil) | |
| ``` | |
| [Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_prior.py#L136) | |
| **Parametreler:** | |
| prior ([PriorTransformer](/docs/diffusers/main/tr/api/models/prior_transformer#diffusers.PriorTransformer)) : Metin gömümünden görüntü gömümünü yaklaşık olarak elde etmek için kullanılan standart unCLIP önceli. | |
| image_encoder (`CLIPVisionModelWithProjection`) : Donmuş görüntü kodlayıcı. | |
| text_encoder (`CLIPTextModelWithProjection`) : Donmuş metin kodlayıcı. | |
| tokenizer (`CLIPTokenizer`) : [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer) sınıfının tokenizer'ı. | |
| scheduler (`UnCLIPScheduler`) : `prior` ile birlikte kullanılarak gömme (embedding) üretmek için kullanılacak bir zamanlayıcı (scheduler). | |
| Kandinsky için görüntü öncesi (prior) üretme hattı | |
| Bu model [DiffusionPipeline](/docs/diffusers/main/tr/api/pipelines/overview#diffusers.DiffusionPipeline) sınıfından devralır. Kütüphanenin tüm pipeline'lar için uyguladığı genel yöntemler (indirme veya kaydetme, belirli bir cihazda çalıştırma vb.) için üst sınıf belgelendirmesine bakın. | |
| #### __call__[[diffusers.KandinskyPriorPipeline.__call__]] | |
| ```python | |
| __call__(prompt: str | list[str], negative_prompt: str | list[str] | None = None, num_images_per_prompt: int = 1, num_inference_steps: int = 25, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, guidance_scale: float = 4.0, output_type: str | None = 'pt', return_dict: bool = True) | |
| ``` | |
| [Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_prior.py#L405) | |
| **Parametreler:** | |
| prompt (`str` veya `list[str]`) : Görsel üretimi yönlendirmek için istem veya istemler. | |
| negative_prompt (`str` veya `list[str]`, *isteğe bağlı*) : Görsel üretimi yönlendirmemek için kullanılan istem veya istemler. Yönlendirme kullanılmadığında yok sayılır (yani `guidance_scale` `1`'den küçükse 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ı. | |
| num_inference_steps (`int`, *isteğe bağlı*, varsayılan 25) : 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. | |
| generator (`torch.Generator` veya `list[torch.Generator]`, *isteğe bağlı*) : Üretimi deterministik hale getirmek için bir veya [torch üreteci(leri)](https://pytorch.org/docs/stable/generated/torch.Generator.html) listesi. | |
| latents (`torch.Tensor`, *isteğe bağlı*) : Görsel üretimi için girdi olarak kullanılacak, Gauss dağılımından örneklenen önceden oluşturulmuş gürültülü latentler. Farklı istemlerle aynı üretimi ayarlamak için kullanılabilir. Sağlanmazsa, sağlanan rastgele `generator` kullanılarak örneklem yoluyla bir latent tensörü oluşturulur. | |
| guidance_scale (`float`, *isteğe bağlı*, varsayılan 4.0) : [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598)'de tanımlandığı gibi yönlendirme ölçeği. `guidance_scale`, [Imagen Paper](https://huggingface.co/papers/2205.11487)'deki 2. denklemindeki `w` olarak tanımlanır. Yönlendirme ölçeği, `guidance_scale > 1` olarak ayarlanarak etkinleştirilir. Daha yüksek yönlendirme ölçeği, genellikle daha düşük görüntü kalitesi pahasına, `prompt` ile yakından ilişkili görüntülerin üretilmesini teşvik eder. | |
| output_type (`str`, *isteğe bağlı*, varsayılan `"pt"`) : generate image çıktısının biçimi. Şunlardan birini seçin: `"np"` (`np.array`) veya `"pt"` (`torch.Tensor`). | |
| return_dict (`bool`, *isteğe bağlı*, varsayılan `True`) : Düz bir tuple yerine [ImagePipelineOutput](/docs/diffusers/main/tr/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) döndürülüp döndürülmemesi. | |
| **Dönüş:** `KandinskyPriorPipelineOutput` veya `tuple` | |
| Üretim için pipeline çağrıldığında tetiklenen işlev. | |
| Örnekler: | |
| ```py | |
| >>> from diffusers import KandinskyPipeline, KandinskyPriorPipeline | |
| >>> import torch | |
| >>> pipe_prior = KandinskyPriorPipeline.from_pretrained("kandinsky-community/kandinsky-2-1-prior") | |
| >>> pipe_prior.to("cuda") | |
| >>> prompt = "red cat, 4k photo" | |
| >>> out = pipe_prior(prompt) | |
| >>> image_emb = out.image_embeds | |
| >>> negative_image_emb = out.negative_image_embeds | |
| >>> pipe = KandinskyPipeline.from_pretrained("kandinsky-community/kandinsky-2-1") | |
| >>> pipe.to("cuda") | |
| >>> image = pipe( | |
| ... prompt, | |
| ... image_embeds=image_emb, | |
| ... negative_image_embeds=negative_image_emb, | |
| ... height=768, | |
| ... width=768, | |
| ... num_inference_steps=100, | |
| ... ).images | |
| >>> image[0].save("cat.png") | |
| ``` | |
| #### interpolate[[diffusers.KandinskyPriorPipeline.interpolate]] | |
| ```python | |
| interpolate(images_and_prompts: list, weights: list, num_images_per_prompt: int = 1, num_inference_steps: int = 25, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, negative_prior_prompt: str | None = None, negative_prompt: str = '', guidance_scale: float = 4.0, device = None) | |
| ``` | |
| [Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_prior.py#L180) | |
| **Parametreler:** | |
| images_and_prompts (`list[str | PIL.Image.Image | torch.Tensor]`) : görüntü üretimini yönlendirmek için istemler ve görüntülerin listesi. | |
| weights : (`list[float]`): `images_and_prompts` içindeki her koşul için ağırlıklar listesi | |
| num_images_per_prompt (`int`, *isteğe bağlı*, varsayılan 1) : Her istem için üretilecek görsel sayısı. | |
| num_inference_steps (`int`, *isteğe bağlı*, varsayılan 25) : 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. | |
| generator (`torch.Generator` veya `list[torch.Generator]`, *isteğe bağlı*) : Üretimi deterministik hale getirmek için bir veya [torch üreteci(leri)](https://pytorch.org/docs/stable/generated/torch.Generator.html) listesi. | |
| latents (`torch.Tensor`, *isteğe bağlı*) : Görsel üretimi için girdi olarak kullanılacak, Gauss dağılımından örneklenen önceden oluşturulmuş gürültülü latentler. Farklı istemlerle aynı üretimi ayarlamak için kullanılabilir. Sağlanmazsa, sağlanan rastgele `generator` kullanılarak örneklem yoluyla bir latent tensörü oluşturulur. | |
| negative_prior_prompt (`str`, *isteğe bağlı*) : Öncül difüzyon sürecini yönlendirmemek için kullanılan istem. Yönlendirme kullanılmadığında yok sayılır (yani `guidance_scale` `1`'den küçükse yok sayılır). | |
| negative_prompt (`str` veya `list[str]`, *isteğe bağlı*) : Görsel üretimi yönlendirmemek için kullanılan istem. Yönlendirme kullanılmadığında yok sayılır (yani `guidance_scale` `1`'den küçükse yok sayılır). | |
| guidance_scale (`float`, *isteğe bağlı*, varsayılan 4.0) : [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598)'de tanımlandığı gibi yönlendirme ölçeği. `guidance_scale`, [Imagen Paper](https://huggingface.co/papers/2205.11487)'deki 2. denklemindeki `w` olarak tanımlanır. Yönlendirme ölçeği, `guidance_scale > 1` olarak ayarlanarak etkinleştirilir. Daha yüksek yönlendirme ölçeği, genellikle daha düşük görüntü kalitesi pahasına, `prompt` ile yakından ilişkili görüntülerin üretilmesini teşvik eder. | |
| **Dönüş:** `KandinskyPriorPipelineOutput` veya `tuple` | |
| İçpolalama için önceki hattı kullanırken çağrılan işlev. | |
| Örnekler: | |
| ```py | |
| >>> from diffusers import KandinskyPriorPipeline, KandinskyPipeline | |
| >>> from diffusers.utils import load_image | |
| >>> import PIL | |
| >>> import torch | |
| >>> from torchvision import transforms | |
| >>> pipe_prior = KandinskyPriorPipeline.from_pretrained( | |
| ... "kandinsky-community/kandinsky-2-1-prior", torch_dtype=torch.float16 | |
| ... ) | |
| >>> pipe_prior.to("cuda") | |
| >>> img1 = load_image( | |
| ... "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" | |
| ... "/kandinsky/cat.png" | |
| ... ) | |
| >>> img2 = load_image( | |
| ... "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" | |
| ... "/kandinsky/starry_night.jpeg" | |
| ... ) | |
| >>> images_texts = ["a cat", img1, img2] | |
| >>> weights = [0.3, 0.3, 0.4] | |
| >>> image_emb, zero_image_emb = pipe_prior.interpolate(images_texts, weights) | |
| >>> pipe = KandinskyPipeline.from_pretrained("kandinsky-community/kandinsky-2-1", torch_dtype=torch.float16) | |
| >>> pipe.to("cuda") | |
| >>> image = pipe( | |
| ... "", | |
| ... image_embeds=image_emb, | |
| ... negative_image_embeds=zero_image_emb, | |
| ... height=768, | |
| ... width=768, | |
| ... num_inference_steps=150, | |
| ... ).images[0] | |
| >>> image.save("starry_cat.png") | |
| ``` | |
| ## KandinskyPipeline[[diffusers.KandinskyPipeline]] | |
| #### diffusers.KandinskyPipeline[[diffusers.KandinskyPipeline]] | |
| ```python | |
| diffusers.KandinskyPipeline(text_encoder: MultilingualCLIP, tokenizer: XLMRobertaTokenizer, unet: UNet2DConditionModel, scheduler: diffusers.schedulers.scheduling_ddim.DDIMScheduler | diffusers.schedulers.scheduling_ddpm.DDPMScheduler, movq: VQModel) | |
| ``` | |
| [Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky.py#L81) | |
| **Parametreler:** | |
| text_encoder (`MultilingualCLIP`) : Donmuş metin kodlayıcı. | |
| tokenizer (`XLMRobertaTokenizer`) : Sınıfın | |
| scheduler (`DDIMScheduler` | `DDPMScheduler`) : `unet` ile birlikte kullanılarak görüntü latentleri üretmek için kullanılacak bir zamanlayıcı. | |
| unet ([UNet2DConditionModel](/docs/diffusers/main/tr/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Görsel gömümünü gürültüsüzleştirmek için koşullu U-Net mimarisi. | |
| movq ([VQModel](/docs/diffusers/main/tr/api/models/vq#diffusers.VQModel)) : Latentlerden görüntü üretmek için MoVQ Dekodlayıcı. | |
| Kandinsky kullanılarak metinden görüntüye üretim hattı | |
| Bu model [DiffusionPipeline](/docs/diffusers/main/tr/api/pipelines/overview#diffusers.DiffusionPipeline) sınıfından devralır. Kütüphanenin tüm pipeline'lar için uyguladığı genel yöntemler (indirme veya kaydetme, belirli bir cihazda çalıştırma vb.) için üst sınıf belgelendirmesine bakın. | |
| #### __call__[[diffusers.KandinskyPipeline.__call__]] | |
| ```python | |
| __call__(prompt: str | list[str], image_embeds: typing.Union[torch.Tensor, list[torch.Tensor]], negative_image_embeds: typing.Union[torch.Tensor, list[torch.Tensor]], negative_prompt: str | list[str] | None = None, height: int = 512, width: int = 512, num_inference_steps: int = 100, guidance_scale: float = 4.0, num_images_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int = 1, return_dict: bool = True) | |
| ``` | |
| [Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky.py#L236) | |
| **Parametreler:** | |
| prompt (`str` veya `list[str]`) : Görsel üretimi yönlendirmek için istem veya istemler. | |
| image_embeds (`torch.Tensor` veya `list[torch.Tensor]`) : Metin istemcisi için klip gömme görselleri, görsel üretimini koşullandırmak için kullanılacaktır. | |
| negative_image_embeds (`torch.Tensor` veya `list[torch.Tensor]`) : Negatif metin istemi için klip gömme görselleri, görsel üretimini koşullandırmak için kullanılacaktır. | |
| negative_prompt (`str` veya `list[str]`, *isteğe bağlı*) : Görsel üretimi yönlendirmemek için kullanılan istem veya istemler. Yönlendirme kullanılmadığında yok sayılır (yani `guidance_scale` `1`'den küçükse yok sayılır). | |
| height (`int`, *isteğe bağlı*, varsayılan 512) : Üretilen görüntünün piksel cinsinden yüksekliği. | |
| width (`int`, *isteğe bağlı*, varsayılan 512) : Üretilen görüntünün piksel cinsinden genişliği. | |
| num_inference_steps (`int`, *isteğe bağlı*, varsayılan 100) : 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. | |
| guidance_scale (`float`, *isteğe bağlı*, varsayılan 4.0) : [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598)'de tanımlandığı gibi yönlendirme ölçeği. `guidance_scale`, [Imagen Paper](https://huggingface.co/papers/2205.11487)'deki 2. denklemindeki `w` olarak tanımlanır. Yönlendirme ölçeği, `guidance_scale > 1` olarak ayarlanarak etkinleştirilir. Daha yüksek yönlendirme ölçeği, genellikle daha düşük görüntü kalitesi pahasına, `prompt` ile yakından ilişkili görüntülerin üretilmesini teşvik eder. | |
| num_images_per_prompt (`int`, *isteğe bağlı*, varsayılan 1) : Her istem için üretilecek görsel sayısı. | |
| generator (`torch.Generator` veya `list[torch.Generator]`, *isteğe bağlı*) : Üretimi deterministik hale getirmek için bir veya [torch üreteci(leri)](https://pytorch.org/docs/stable/generated/torch.Generator.html) listesi. | |
| latents (`torch.Tensor`, *isteğe bağlı*) : Görsel üretimi için girdi olarak kullanılacak, Gauss dağılımından örneklenen önceden oluşturulmuş gürültülü latentler. Farklı istemlerle aynı üretimi ayarlamak için kullanılabilir. Sağlanmazsa, sağlanan rastgele `generator` kullanılarak örneklem yoluyla bir latent tensörü oluşturulur. | |
| output_type (`str`, *isteğe bağlı*, varsayılan `"pil"`) : Üretilen görüntünün çıktı biçimi. Şunlardan birini seçin: `"pil"` (`PIL.Image.Image`), `"np"` (`np.array`) veya `"pt"` (`torch.Tensor`). | |
| callback (`Callable`, *isteğe bağlı*) : Çıkarım sırasında her `callback_steps` adımda çağrılan bir işlev. İşlev aşağıdaki argümanlarla çağrılır: `callback(step: int, timestep: int, latents: torch.Tensor)`. | |
| callback_steps (`int`, *isteğe bağlı*, varsayılan 1) : `callback` fonksiyonunun çağrılma sıklığı. Belirtilmezse, callback her adımda çağrılır. | |
| return_dict (`bool`, *isteğe bağlı*, varsayılan `True`) : Düz bir tuple yerine [ImagePipelineOutput](/docs/diffusers/main/tr/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) döndürülüp döndürülmemesi. | |
| **Dönüş:** [ImagePipelineOutput](/docs/diffusers/main/tr/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) veya `tuple` | |
| Üretim için pipeline çağrıldığında tetiklenen işlev. | |
| Örnekler: | |
| ```py | |
| >>> from diffusers import KandinskyPipeline, KandinskyPriorPipeline | |
| >>> import torch | |
| >>> pipe_prior = KandinskyPriorPipeline.from_pretrained("kandinsky-community/Kandinsky-2-1-prior") | |
| >>> pipe_prior.to("cuda") | |
| >>> prompt = "red cat, 4k photo" | |
| >>> out = pipe_prior(prompt) | |
| >>> image_emb = out.image_embeds | |
| >>> negative_image_emb = out.negative_image_embeds | |
| >>> pipe = KandinskyPipeline.from_pretrained("kandinsky-community/kandinsky-2-1") | |
| >>> pipe.to("cuda") | |
| >>> image = pipe( | |
| ... prompt, | |
| ... image_embeds=image_emb, | |
| ... negative_image_embeds=negative_image_emb, | |
| ... height=768, | |
| ... width=768, | |
| ... num_inference_steps=100, | |
| ... ).images | |
| >>> image[0].save("cat.png") | |
| ``` | |
| ## KandinskyCombinedPipeline[[diffusers.KandinskyCombinedPipeline]] | |
| #### diffusers.KandinskyCombinedPipeline[[diffusers.KandinskyCombinedPipeline]] | |
| ```python | |
| diffusers.KandinskyCombinedPipeline(text_encoder: MultilingualCLIP, tokenizer: XLMRobertaTokenizer, unet: UNet2DConditionModel, scheduler: diffusers.schedulers.scheduling_ddim.DDIMScheduler | diffusers.schedulers.scheduling_ddpm.DDPMScheduler, movq: VQModel, prior_prior: PriorTransformer, prior_image_encoder: CLIPVisionModelWithProjection, prior_text_encoder: CLIPTextModelWithProjection, prior_tokenizer: CLIPTokenizer, prior_scheduler: UnCLIPScheduler, prior_image_processor: CLIPImageProcessorPil) | |
| ``` | |
| [Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_combined.py#L113) | |
| **Parametreler:** | |
| text_encoder (`MultilingualCLIP`) : Donmuş metin kodlayıcı. | |
| tokenizer (`XLMRobertaTokenizer`) : Sınıfın | |
| scheduler (`DDIMScheduler` | `DDPMScheduler`) : `unet` ile birlikte kullanılarak görüntü latentleri üretmek için kullanılacak bir zamanlayıcı. | |
| unet ([UNet2DConditionModel](/docs/diffusers/main/tr/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Görsel gömümünü gürültüsüzleştirmek için koşullu U-Net mimarisi. | |
| movq ([VQModel](/docs/diffusers/main/tr/api/models/vq#diffusers.VQModel)) : Latentlerden görüntü üretmek için MoVQ Dekodlayıcı. | |
| prior_prior ([PriorTransformer](/docs/diffusers/main/tr/api/models/prior_transformer#diffusers.PriorTransformer)) : Metin gömümünden görüntü gömümünü yaklaşık olarak elde etmek için kullanılan standart unCLIP önceli. | |
| prior_image_encoder (`CLIPVisionModelWithProjection`) : Donmuş görüntü kodlayıcı. | |
| prior_text_encoder (`CLIPTextModelWithProjection`) : Donmuş metin kodlayıcı. | |
| prior_tokenizer (`CLIPTokenizer`) : [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer) sınıfının tokenizer'ı. | |
| prior_scheduler (`UnCLIPScheduler`) : `prior` ile birlikte kullanılarak gömme (embedding) üretmek için kullanılacak bir zamanlayıcı (scheduler). | |
| Kandinsky kullanılarak metinden görüntüye üretim için Birleşik Pipeline | |
| Bu model [DiffusionPipeline](/docs/diffusers/main/tr/api/pipelines/overview#diffusers.DiffusionPipeline) sınıfından devralır. Kütüphanenin tüm pipeline'lar için uyguladığı genel yöntemler (indirme veya kaydetme, belirli bir cihazda çalıştırma vb.) için üst sınıf belgelendirmesine bakın. | |
| #### __call__[[diffusers.KandinskyCombinedPipeline.__call__]] | |
| ```python | |
| __call__(prompt: str | list[str], negative_prompt: str | list[str] | None = None, num_inference_steps: int = 100, guidance_scale: float = 4.0, num_images_per_prompt: int = 1, height: int = 512, width: int = 512, prior_guidance_scale: float = 4.0, prior_num_inference_steps: int = 25, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int = 1, return_dict: bool = True) | |
| ``` | |
| [Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_combined.py#L215) | |
| **Parametreler:** | |
| prompt (`str` veya `list[str]`) : Görsel üretimi yönlendirmek için istem veya istemler. | |
| negative_prompt (`str` veya `list[str]`, *isteğe bağlı*) : Görsel üretimi yönlendirmemek için kullanılan istem veya istemler. Yönlendirme kullanılmadığında yok sayılır (yani `guidance_scale` `1`'den küçükse 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ı. | |
| num_inference_steps (`int`, *isteğe bağlı*, varsayılan 100) : 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. | |
| height (`int`, *isteğe bağlı*, varsayılan 512) : Üretilen görüntünün piksel cinsinden yüksekliği. | |
| width (`int`, *isteğe bağlı*, varsayılan 512) : Üretilen görüntünün piksel cinsinden genişliği. | |
| prior_guidance_scale (`float`, *isteğe bağlı*, varsayılan 4.0) : [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598)'de tanımlandığı gibi yönlendirme ölçeği. `guidance_scale`, [Imagen Paper](https://huggingface.co/papers/2205.11487)'deki 2. denklemindeki `w` olarak tanımlanır. Yönlendirme ölçeği, `guidance_scale > 1` olarak ayarlanarak etkinleştirilir. Daha yüksek yönlendirme ölçeği, genellikle daha düşük görüntü kalitesi pahasına, `prompt` ile yakından ilişkili görüntülerin üretilmesini teşvik eder. | |
| prior_num_inference_steps (`int`, *isteğe bağlı*, varsayılan 100) : 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. | |
| guidance_scale (`float`, *isteğe bağlı*, varsayılan 4.0) : [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598)'de tanımlandığı gibi yönlendirme ölçeği. `guidance_scale`, [Imagen Paper](https://huggingface.co/papers/2205.11487)'deki 2. denklemindeki `w` olarak tanımlanır. Yönlendirme ölçeği, `guidance_scale > 1` olarak ayarlanarak etkinleştirilir. Daha yüksek yönlendirme ölçeği, genellikle daha düşük görüntü kalitesi pahasına, `prompt` ile yakından ilişkili görüntülerin üretilmesini teşvik eder. | |
| generator (`torch.Generator` veya `list[torch.Generator]`, *isteğe bağlı*) : Üretimi deterministik hale getirmek için bir veya [torch üreteci(leri)](https://pytorch.org/docs/stable/generated/torch.Generator.html) listesi. | |
| latents (`torch.Tensor`, *isteğe bağlı*) : Görsel üretimi için girdi olarak kullanılacak, Gauss dağılımından örneklenen önceden oluşturulmuş gürültülü latentler. Farklı istemlerle aynı üretimi ayarlamak için kullanılabilir. Sağlanmazsa, sağlanan rastgele `generator` kullanılarak örneklem yoluyla bir latent tensörü oluşturulur. | |
| output_type (`str`, *isteğe bağlı*, varsayılan `"pil"`) : Üretilen görüntünün çıktı biçimi. Şunlardan birini seçin: `"pil"` (`PIL.Image.Image`), `"np"` (`np.array`) veya `"pt"` (`torch.Tensor`). | |
| callback (`Callable`, *isteğe bağlı*) : Çıkarım sırasında her `callback_steps` adımda çağrılan bir işlev. İşlev aşağıdaki argümanlarla çağrılır: `callback(step: int, timestep: int, latents: torch.Tensor)`. | |
| callback_steps (`int`, *isteğe bağlı*, varsayılan 1) : `callback` fonksiyonunun çağrılma sıklığı. Belirtilmezse, callback her adımda çağrılır. | |
| return_dict (`bool`, *isteğe bağlı*, varsayılan `True`) : Düz bir tuple yerine [ImagePipelineOutput](/docs/diffusers/main/tr/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) döndürülüp döndürülmemesi. | |
| **Dönüş:** [ImagePipelineOutput](/docs/diffusers/main/tr/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) veya `tuple` | |
| Üretim için pipeline çağrıldığında tetiklenen işlev. | |
| Örnekler: | |
| ```py | |
| from diffusers import AutoPipelineForText2Image | |
| import torch | |
| pipe = AutoPipelineForText2Image.from_pretrained( | |
| "kandinsky-community/kandinsky-2-1", torch_dtype=torch.float16 | |
| ) | |
| pipe.enable_model_cpu_offload() | |
| prompt = "A lion in galaxies, spirals, nebulae, stars, smoke, iridescent, intricate detail, octane render, 8k" | |
| image = pipe(prompt=prompt, num_inference_steps=25).images[0] | |
| ``` | |
| #### enable_sequential_cpu_offload[[diffusers.KandinskyCombinedPipeline.enable_sequential_cpu_offload]] | |
| ```python | |
| enable_sequential_cpu_offload(gpu_id: int | None = None, device: typing.Union[torch.device, str] = None) | |
| ``` | |
| [Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_combined.py#L196) | |
| 🤗 Accelerate kullanarak tüm modellerin (`unet`, `text_encoder`, `vae` ve `safety checker` state dict'leri) CPU'ya aktarılır ve bellek kullanımı önemli ölçüde azaltılır. Modeller `torch.device('meta')` konumuna taşınır ve yalnızca ilgili alt modülün `forward` metodu çağrıldığında GPU'ya yüklenir. Aktarma işlemi alt modül bazında gerçekleşir. `enable_model_cpu_offload` kullanılarak elde edilen tasarrufa kıyasla bellek tasarrufu daha yüksektir, ancak performans daha düşüktür. | |
| ## KandinskyImg2ImgPipeline[[diffusers.KandinskyImg2ImgPipeline]] | |
| #### diffusers.KandinskyImg2ImgPipeline[[diffusers.KandinskyImg2ImgPipeline]] | |
| ```python | |
| diffusers.KandinskyImg2ImgPipeline(text_encoder: MultilingualCLIP, movq: VQModel, tokenizer: XLMRobertaTokenizer, unet: UNet2DConditionModel, scheduler: DDIMScheduler) | |
| ``` | |
| [Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_img2img.py#L93) | |
| **Parametreler:** | |
| text_encoder (`MultilingualCLIP`) : Donmuş metin kodlayıcı. | |
| tokenizer (`XLMRobertaTokenizer`) : Sınıfın | |
| scheduler ([DDIMScheduler](/docs/diffusers/main/tr/api/schedulers/ddim#diffusers.DDIMScheduler)) : `unet` ile birlikte kullanılarak görüntü latentleri üretmek için kullanılacak bir zamanlayıcı. | |
| unet ([UNet2DConditionModel](/docs/diffusers/main/tr/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Görsel gömümünü gürültüsüzleştirmek için koşullu U-Net mimarisi. | |
| movq ([VQModel](/docs/diffusers/main/tr/api/models/vq#diffusers.VQModel)) : MoVQ görüntü kodlayıcısı ve çözücü | |
| Kandinsky kullanılarak 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ır. Kütüphanenin tüm pipeline'lar için uyguladığı genel yöntemler (indirme veya kaydetme, belirli bir cihazda çalıştırma vb.) için üst sınıf belgelendirmesine bakın. | |
| #### __call__[[diffusers.KandinskyImg2ImgPipeline.__call__]] | |
| ```python | |
| __call__(prompt: str | list[str], image: typing.Union[torch.Tensor, list[torch.Tensor], PIL.Image.Image, list[PIL.Image.Image]], image_embeds: Tensor, negative_image_embeds: Tensor, negative_prompt: str | list[str] | None = None, height: int = 512, width: int = 512, num_inference_steps: int = 100, strength: float = 0.3, guidance_scale: float = 7.0, num_images_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, output_type: str | None = 'pil', callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int = 1, return_dict: bool = True) | |
| ``` | |
| [Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_img2img.py#L297) | |
| **Parametreler:** | |
| prompt (`str` veya `list[str]`) : Görsel üretimi yönlendirmek için istem veya istemler. | |
| image (`torch.Tensor`, `PIL.Image.Image`) : Sürecin başlangıç noktası olarak kullanılacak, bir görüntü veya görüntü grubunu temsil eden `Image` veya tensör. | |
| image_embeds (`torch.Tensor` veya `list[torch.Tensor]`) : Metin istemcisi için klip gömme görselleri, görsel üretimini koşullandırmak için kullanılacaktır. | |
| negative_image_embeds (`torch.Tensor` veya `list[torch.Tensor]`) : Negatif metin istemi için klip gömme görselleri, görsel üretimini koşullandırmak için kullanılacaktır. | |
| negative_prompt (`str` veya `list[str]`, *isteğe bağlı*) : Görsel üretimi yönlendirmemek için kullanılan istem veya istemler. Yönlendirme kullanılmadığında yok sayılır (yani `guidance_scale` `1`'den küçükse yok sayılır). | |
| height (`int`, *isteğe bağlı*, varsayılan 512) : Üretilen görüntünün piksel cinsinden yüksekliği. | |
| width (`int`, *isteğe bağlı*, varsayılan 512) : Üretilen görüntünün piksel cinsinden genişliği. | |
| num_inference_steps (`int`, *isteğe bağlı*, varsayılan 100) : 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. | |
| strength (`float`, *opsiyonel*, varsayılan 0.3) : Kavramsal olarak, referans `image`'in ne kadar dönüştürüleceğini belirtir. 0 ile 1 arasında olmalıdır. `image` bir başlangıç noktası olarak kullanılacak ve `strength` değeri arttıkça ona daha fazla gürültü eklenecektir. 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ü maksimum seviyede olacak ve gürültü azaltma süreci, `num_inference_steps` içinde belirtilen tam tekrar sayısı kadar çalışacaktır. Dolayısıyla 1 değeri, `image`'i temelde yok sayar. | |
| guidance_scale (`float`, *isteğe bağlı*, varsayılan 4.0) : [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598)'de tanımlandığı gibi yönlendirme ölçeği. `guidance_scale`, [Imagen Paper](https://huggingface.co/papers/2205.11487)'deki 2. denklemindeki `w` olarak tanımlanır. Yönlendirme ölçeği, `guidance_scale > 1` olarak ayarlanarak etkinleştirilir. Daha yüksek yönlendirme ölçeği, genellikle daha düşük görüntü kalitesi pahasına, `prompt` ile yakından ilişkili görüntülerin üretilmesini teşvik eder. | |
| num_images_per_prompt (`int`, *isteğe bağlı*, varsayılan 1) : Her istem için üretilecek görsel sayısı. | |
| generator (`torch.Generator` veya `list[torch.Generator]`, *isteğe bağlı*) : Üretimi deterministik hale getirmek için bir veya [torch üreteci(leri)](https://pytorch.org/docs/stable/generated/torch.Generator.html) listesi. | |
| output_type (`str`, *isteğe bağlı*, varsayılan `"pil"`) : Üretilen görüntünün çıktı biçimi. Şunlardan birini seçin: `"pil"` (`PIL.Image.Image`), `"np"` (`np.array`) veya `"pt"` (`torch.Tensor`). | |
| callback (`Callable`, *isteğe bağlı*) : Çıkarım sırasında her `callback_steps` adımda çağrılan bir işlev. İşlev aşağıdaki argümanlarla çağrılır: `callback(step: int, timestep: int, latents: torch.Tensor)`. | |
| callback_steps (`int`, *isteğe bağlı*, varsayılan 1) : `callback` fonksiyonunun çağrılma sıklığı. Belirtilmezse, callback her adımda çağrılır. | |
| return_dict (`bool`, *isteğe bağlı*, varsayılan `True`) : Düz bir tuple yerine [ImagePipelineOutput](/docs/diffusers/main/tr/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) döndürülüp döndürülmemesi. | |
| **Dönüş:** [ImagePipelineOutput](/docs/diffusers/main/tr/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) veya `tuple` | |
| Üretim için pipeline çağrıldığında tetiklenen işlev. | |
| Örnekler: | |
| ```py | |
| >>> from diffusers import KandinskyImg2ImgPipeline, KandinskyPriorPipeline | |
| >>> from diffusers.utils import load_image | |
| >>> import torch | |
| >>> pipe_prior = KandinskyPriorPipeline.from_pretrained( | |
| ... "kandinsky-community/kandinsky-2-1-prior", torch_dtype=torch.float16 | |
| ... ) | |
| >>> pipe_prior.to("cuda") | |
| >>> prompt = "A red cartoon frog, 4k" | |
| >>> image_emb, zero_image_emb = pipe_prior(prompt, return_dict=False) | |
| >>> pipe = KandinskyImg2ImgPipeline.from_pretrained( | |
| ... "kandinsky-community/kandinsky-2-1", torch_dtype=torch.float16 | |
| ... ) | |
| >>> pipe.to("cuda") | |
| >>> init_image = load_image( | |
| ... "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" | |
| ... "/kandinsky/frog.png" | |
| ... ) | |
| >>> image = pipe( | |
| ... prompt, | |
| ... image=init_image, | |
| ... image_embeds=image_emb, | |
| ... negative_image_embeds=zero_image_emb, | |
| ... height=768, | |
| ... width=768, | |
| ... num_inference_steps=100, | |
| ... strength=0.2, | |
| ... ).images | |
| >>> image[0].save("red_frog.png") | |
| ``` | |
| ## KandinskyImg2ImgCombinedPipeline[[diffusers.KandinskyImg2ImgCombinedPipeline]] | |
| #### diffusers.KandinskyImg2ImgCombinedPipeline[[diffusers.KandinskyImg2ImgCombinedPipeline]] | |
| ```python | |
| diffusers.KandinskyImg2ImgCombinedPipeline(text_encoder: MultilingualCLIP, tokenizer: XLMRobertaTokenizer, unet: UNet2DConditionModel, scheduler: diffusers.schedulers.scheduling_ddim.DDIMScheduler | diffusers.schedulers.scheduling_ddpm.DDPMScheduler, movq: VQModel, prior_prior: PriorTransformer, prior_image_encoder: CLIPVisionModelWithProjection, prior_text_encoder: CLIPTextModelWithProjection, prior_tokenizer: CLIPTokenizer, prior_scheduler: UnCLIPScheduler, prior_image_processor: CLIPImageProcessorPil) | |
| ``` | |
| [Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_combined.py#L331) | |
| **Parametreler:** | |
| text_encoder (`MultilingualCLIP`) : Donmuş metin kodlayıcı. | |
| tokenizer (`XLMRobertaTokenizer`) : Sınıfın | |
| scheduler (`DDIMScheduler` | `DDPMScheduler`) : `unet` ile birlikte kullanılarak görüntü latentleri üretmek için kullanılacak bir zamanlayıcı. | |
| unet ([UNet2DConditionModel](/docs/diffusers/main/tr/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Görsel gömümünü gürültüsüzleştirmek için koşullu U-Net mimarisi. | |
| movq ([VQModel](/docs/diffusers/main/tr/api/models/vq#diffusers.VQModel)) : Latentlerden görüntü üretmek için MoVQ Dekodlayıcı. | |
| prior_prior ([PriorTransformer](/docs/diffusers/main/tr/api/models/prior_transformer#diffusers.PriorTransformer)) : Metin gömümünden görüntü gömümünü yaklaşık olarak elde etmek için kullanılan standart unCLIP önceli. | |
| prior_image_encoder (`CLIPVisionModelWithProjection`) : Donmuş görüntü kodlayıcı. | |
| prior_text_encoder (`CLIPTextModelWithProjection`) : Donmuş metin kodlayıcı. | |
| prior_tokenizer (`CLIPTokenizer`) : [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer) sınıfının tokenizer'ı. | |
| prior_scheduler (`UnCLIPScheduler`) : `prior` ile birlikte kullanılarak gömme (embedding) üretmek için kullanılacak bir zamanlayıcı (scheduler). | |
| Kandinsky kullanılarak görüntüden görüntüye üretim için Birleşik Pipeline | |
| Bu model [DiffusionPipeline](/docs/diffusers/main/tr/api/pipelines/overview#diffusers.DiffusionPipeline) sınıfından devralır. Kütüphanenin tüm pipeline'lar için uyguladığı genel yöntemler (indirme veya kaydetme, belirli bir cihazda çalıştırma vb.) için üst sınıf belgelendirmesine bakın. | |
| #### __call__[[diffusers.KandinskyImg2ImgCombinedPipeline.__call__]] | |
| ```python | |
| __call__(prompt: str | list[str], image: typing.Union[torch.Tensor, list[torch.Tensor], PIL.Image.Image, list[PIL.Image.Image]], negative_prompt: str | list[str] | None = None, num_inference_steps: int = 100, guidance_scale: float = 4.0, num_images_per_prompt: int = 1, strength: float = 0.3, height: int = 512, width: int = 512, prior_guidance_scale: float = 4.0, prior_num_inference_steps: int = 25, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int = 1, return_dict: bool = True) | |
| ``` | |
| [Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_combined.py#L434) | |
| **Parametreler:** | |
| prompt (`str` veya `list[str]`) : Görsel üretimi yönlendirmek için istem veya istemler. | |
| image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` veya `list[np.ndarray]`) : `Image` veya bir görüntü grubunu temsil eden tensör, süreç için başlangıç noktası olarak kullanılacaktır. Latent'ler doğrudan geçiriliyorsa, `image` olarak görüntü latent'lerini de kabul edebilir; bu durumda yeniden kodlanmaz. | |
| negative_prompt (`str` veya `list[str]`, *isteğe bağlı*) : Görsel üretimi yönlendirmemek için kullanılan istem veya istemler. Yönlendirme kullanılmadığında yok sayılır (yani `guidance_scale` `1`'den küçükse 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ı. | |
| num_inference_steps (`int`, *isteğe bağlı*, varsayılan 100) : 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. | |
| height (`int`, *isteğe bağlı*, varsayılan 512) : Üretilen görüntünün piksel cinsinden yüksekliği. | |
| width (`int`, *isteğe bağlı*, varsayılan 512) : Üretilen görüntünün piksel cinsinden genişliği. | |
| strength (`float`, *opsiyonel*, varsayılan 0.3) : Kavramsal olarak, referans `image`'in ne kadar dönüştürüleceğini belirtir. 0 ile 1 arasında olmalıdır. `image` bir başlangıç noktası olarak kullanılacak ve `strength` değeri arttıkça ona daha fazla gürültü eklenecektir. 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ü maksimum seviyede olacak ve gürültü azaltma süreci, `num_inference_steps` içinde belirtilen tam tekrar sayısı kadar çalışacaktır. Dolayısıyla 1 değeri, `image`'i temelde yok sayar. | |
| prior_guidance_scale (`float`, *isteğe bağlı*, varsayılan 4.0) : [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598)'de tanımlandığı gibi yönlendirme ölçeği. `guidance_scale`, [Imagen Paper](https://huggingface.co/papers/2205.11487)'deki 2. denklemindeki `w` olarak tanımlanır. Yönlendirme ölçeği, `guidance_scale > 1` olarak ayarlanarak etkinleştirilir. Daha yüksek yönlendirme ölçeği, genellikle daha düşük görüntü kalitesi pahasına, `prompt` ile yakından ilişkili görüntülerin üretilmesini teşvik eder. | |
| prior_num_inference_steps (`int`, *isteğe bağlı*, varsayılan 100) : 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. | |
| guidance_scale (`float`, *isteğe bağlı*, varsayılan 4.0) : [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598)'de tanımlandığı gibi yönlendirme ölçeği. `guidance_scale`, [Imagen Paper](https://huggingface.co/papers/2205.11487)'deki 2. denklemindeki `w` olarak tanımlanır. Yönlendirme ölçeği, `guidance_scale > 1` olarak ayarlanarak etkinleştirilir. Daha yüksek yönlendirme ölçeği, genellikle daha düşük görüntü kalitesi pahasına, `prompt` ile yakından ilişkili görüntülerin üretilmesini teşvik eder. | |
| generator (`torch.Generator` veya `list[torch.Generator]`, *isteğe bağlı*) : Üretimi deterministik hale getirmek için bir veya [torch üreteci(leri)](https://pytorch.org/docs/stable/generated/torch.Generator.html) listesi. | |
| latents (`torch.Tensor`, *isteğe bağlı*) : Görsel üretimi için girdi olarak kullanılacak, Gauss dağılımından örneklenen önceden oluşturulmuş gürültülü latentler. Farklı istemlerle aynı üretimi ayarlamak için kullanılabilir. Sağlanmazsa, sağlanan rastgele `generator` kullanılarak örneklem yoluyla bir latent tensörü oluşturulur. | |
| output_type (`str`, *isteğe bağlı*, varsayılan `"pil"`) : Üretilen görüntünün çıktı biçimi. Şunlardan birini seçin: `"pil"` (`PIL.Image.Image`), `"np"` (`np.array`) veya `"pt"` (`torch.Tensor`). | |
| callback (`Callable`, *isteğe bağlı*) : Çıkarım sırasında her `callback_steps` adımda çağrılan bir işlev. İşlev aşağıdaki argümanlarla çağrılır: `callback(step: int, timestep: int, latents: torch.Tensor)`. | |
| callback_steps (`int`, *isteğe bağlı*, varsayılan 1) : `callback` fonksiyonunun çağrılma sıklığı. Belirtilmezse, callback her adımda çağrılır. | |
| return_dict (`bool`, *isteğe bağlı*, varsayılan `True`) : Düz bir tuple yerine [ImagePipelineOutput](/docs/diffusers/main/tr/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) döndürülüp döndürülmemesi. | |
| **Dönüş:** [ImagePipelineOutput](/docs/diffusers/main/tr/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) veya `tuple` | |
| Üretim için pipeline çağrıldığında tetiklenen işlev. | |
| Örnekler: | |
| ```py | |
| from diffusers import AutoPipelineForImage2Image | |
| import torch | |
| import requests | |
| from io import BytesIO | |
| from PIL import Image | |
| import os | |
| pipe = AutoPipelineForImage2Image.from_pretrained( | |
| "kandinsky-community/kandinsky-2-1", torch_dtype=torch.float16 | |
| ) | |
| pipe.enable_model_cpu_offload() | |
| prompt = "A fantasy landscape, Cinematic lighting" | |
| negative_prompt = "low quality, bad quality" | |
| url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg" | |
| response = requests.get(url) | |
| image = Image.open(BytesIO(response.content)).convert("RGB") | |
| image.thumbnail((768, 768)) | |
| image = pipe(prompt=prompt, image=original_image, num_inference_steps=25).images[0] | |
| ``` | |
| #### enable_sequential_cpu_offload[[diffusers.KandinskyImg2ImgCombinedPipeline.enable_sequential_cpu_offload]] | |
| ```python | |
| enable_sequential_cpu_offload(gpu_id: int | None = None, device: typing.Union[torch.device, str] = None) | |
| ``` | |
| [Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_combined.py#L414) | |
| Offloads all models to CPU using accelerate, significantly reducing memory usage. When called, unet, text_encoder, vae and safety checker have their state dicts saved to CPU and then are moved to a `torch.device('meta') and loaded to GPU only when their specific submodule has its `forward` method called. Note that offloading happens on a submodule basis. Memory savings are higher than with `enable_model_cpu_offload`, but performance is lower. | |
| ## KandinskyInpaintPipeline[[diffusers.KandinskyInpaintPipeline]] | |
| #### diffusers.KandinskyInpaintPipeline[[diffusers.KandinskyInpaintPipeline]] | |
| ```python | |
| diffusers.KandinskyInpaintPipeline(text_encoder: MultilingualCLIP, movq: VQModel, tokenizer: XLMRobertaTokenizer, unet: UNet2DConditionModel, scheduler: DDIMScheduler) | |
| ``` | |
| [Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_inpaint.py#L245) | |
| **Parametreler:** | |
| text_encoder (`MultilingualCLIP`) : Donmuş metin kodlayıcı. | |
| tokenizer (`XLMRobertaTokenizer`) : Sınıfın | |
| scheduler ([DDIMScheduler](/docs/diffusers/main/tr/api/schedulers/ddim#diffusers.DDIMScheduler)) : `unet` ile birlikte kullanılarak görüntü latentleri üretmek için kullanılacak bir zamanlayıcı. | |
| unet ([UNet2DConditionModel](/docs/diffusers/main/tr/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Görsel gömümünü gürültüsüzleştirmek için koşullu U-Net mimarisi. | |
| movq ([VQModel](/docs/diffusers/main/tr/api/models/vq#diffusers.VQModel)) : MoVQ görüntü kodlayıcısı ve çözücü | |
| Kandinsky2.1 kullanarak metin yönlendirmeli görsel inpainting için Pipeline | |
| Bu model [DiffusionPipeline](/docs/diffusers/main/tr/api/pipelines/overview#diffusers.DiffusionPipeline) sınıfından devralır. Kütüphanenin tüm pipeline'lar için uyguladığı genel yöntemler (indirme veya kaydetme, belirli bir cihazda çalıştırma vb.) için üst sınıf belgelendirmesine bakın. | |
| #### __call__[[diffusers.KandinskyInpaintPipeline.__call__]] | |
| ```python | |
| __call__(prompt: str | list[str], image: typing.Union[torch.Tensor, PIL.Image.Image], mask_image: typing.Union[PIL.Image.Image, torch.Tensor, numpy.ndarray], image_embeds: Tensor, negative_image_embeds: Tensor, negative_prompt: str | list[str] | None = None, height: int = 512, width: int = 512, num_inference_steps: int = 100, guidance_scale: float = 4.0, num_images_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int = 1, return_dict: bool = True) | |
| ``` | |
| [Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_inpaint.py#L401) | |
| **Parametreler:** | |
| prompt (`str` veya `list[str]`) : Görsel üretimi yönlendirmek için istem veya istemler. | |
| image (`torch.Tensor`, `PIL.Image.Image` veya `np.ndarray`) : `Image`, veya sürecin başlangıç noktası olarak kullanılacak bir görüntü veya görüntü partisini temsil eden tensör. | |
| mask_image (`PIL.Image.Image`,`torch.Tensor` veya `np.ndarray`) : `image` öğesini maskelemek için bir `Image` veya bir görüntü grubunu temsil eden bir tensör. Maske içindeki beyaz pikseller yeniden boyanacak, siyah pikseller ise korunacaktır. Pytorch tensörünü maske olarak yalnızca geçtiğiniz görüntü bir pytorch tensörü ise iletebilirsiniz ve bu tensör 3 kanal yerine tek bir renk kanalı (L) içermelidir; bu nedenle beklenen şekil `(B, 1, H, W,)`, `(B, H, W)`, `(1, H, W)` veya `(H, W)` olmalıdır. Görüntü bir PIL görüntüsü veya numpy dizisi ise maske de bir PIL görüntüsü veya numpy dizisi olmalıdır. PIL görüntüsü olması durumunda, kullanılmadan önce tek kanala (parlaklık) dönüştürülür. Numpy dizisi olması durumunda beklenen şekil `(H, W)`'dir. | |
| image_embeds (`torch.Tensor` veya `list[torch.Tensor]`) : Metin istemcisi için klip gömme görselleri, görsel üretimini koşullandırmak için kullanılacaktır. | |
| negative_image_embeds (`torch.Tensor` veya `list[torch.Tensor]`) : Negatif metin istemi için klip gömme görselleri, görsel üretimini koşullandırmak için kullanılacaktır. | |
| negative_prompt (`str` veya `list[str]`, *isteğe bağlı*) : Görsel üretimi yönlendirmemek için kullanılan istem veya istemler. Yönlendirme kullanılmadığında yok sayılır (yani `guidance_scale` `1`'den küçükse yok sayılır). | |
| height (`int`, *isteğe bağlı*, varsayılan 512) : Üretilen görüntünün piksel cinsinden yüksekliği. | |
| width (`int`, *isteğe bağlı*, varsayılan 512) : Üretilen görüntünün piksel cinsinden genişliği. | |
| num_inference_steps (`int`, *isteğe bağlı*, varsayılan 100) : 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. | |
| guidance_scale (`float`, *isteğe bağlı*, varsayılan 4.0) : [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598)'de tanımlandığı gibi yönlendirme ölçeği. `guidance_scale`, [Imagen Paper](https://huggingface.co/papers/2205.11487)'deki 2. denklemindeki `w` olarak tanımlanır. Yönlendirme ölçeği, `guidance_scale > 1` olarak ayarlanarak etkinleştirilir. Daha yüksek yönlendirme ölçeği, genellikle daha düşük görüntü kalitesi pahasına, `prompt` ile yakından ilişkili görüntülerin üretilmesini teşvik eder. | |
| num_images_per_prompt (`int`, *isteğe bağlı*, varsayılan 1) : Her istem için üretilecek görsel sayısı. | |
| generator (`torch.Generator` veya `list[torch.Generator]`, *isteğe bağlı*) : Üretimi deterministik hale getirmek için bir veya [torch üreteci(leri)](https://pytorch.org/docs/stable/generated/torch.Generator.html) listesi. | |
| latents (`torch.Tensor`, *isteğe bağlı*) : Görsel üretimi için girdi olarak kullanılacak, Gauss dağılımından örneklenen önceden oluşturulmuş gürültülü latentler. Farklı istemlerle aynı üretimi ayarlamak için kullanılabilir. Sağlanmazsa, sağlanan rastgele `generator` kullanılarak örneklem yoluyla bir latent tensörü oluşturulur. | |
| output_type (`str`, *isteğe bağlı*, varsayılan `"pil"`) : Üretilen görüntünün çıktı biçimi. Şunlardan birini seçin: `"pil"` (`PIL.Image.Image`), `"np"` (`np.array`) veya `"pt"` (`torch.Tensor`). | |
| callback (`Callable`, *isteğe bağlı*) : Çıkarım sırasında her `callback_steps` adımda çağrılan bir işlev. İşlev aşağıdaki argümanlarla çağrılır: `callback(step: int, timestep: int, latents: torch.Tensor)`. | |
| callback_steps (`int`, *isteğe bağlı*, varsayılan 1) : `callback` fonksiyonunun çağrılma sıklığı. Belirtilmezse, callback her adımda çağrılır. | |
| return_dict (`bool`, *isteğe bağlı*, varsayılan `True`) : Düz bir tuple yerine [ImagePipelineOutput](/docs/diffusers/main/tr/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) döndürülüp döndürülmemesi. | |
| **Dönüş:** [ImagePipelineOutput](/docs/diffusers/main/tr/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) veya `tuple` | |
| Üretim için pipeline çağrıldığında tetiklenen işlev. | |
| Örnekler: | |
| ```py | |
| >>> from diffusers import KandinskyInpaintPipeline, KandinskyPriorPipeline | |
| >>> from diffusers.utils import load_image | |
| >>> import torch | |
| >>> import numpy as np | |
| >>> pipe_prior = KandinskyPriorPipeline.from_pretrained( | |
| ... "kandinsky-community/kandinsky-2-1-prior", torch_dtype=torch.float16 | |
| ... ) | |
| >>> pipe_prior.to("cuda") | |
| >>> prompt = "a hat" | |
| >>> image_emb, zero_image_emb = pipe_prior(prompt, return_dict=False) | |
| >>> pipe = KandinskyInpaintPipeline.from_pretrained( | |
| ... "kandinsky-community/kandinsky-2-1-inpaint", torch_dtype=torch.float16 | |
| ... ) | |
| >>> pipe.to("cuda") | |
| >>> init_image = load_image( | |
| ... "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" | |
| ... "/kandinsky/cat.png" | |
| ... ) | |
| >>> mask = np.zeros((768, 768), dtype=np.float32) | |
| >>> mask[:250, 250:-250] = 1 | |
| >>> out = pipe( | |
| ... prompt, | |
| ... image=init_image, | |
| ... mask_image=mask, | |
| ... image_embeds=image_emb, | |
| ... negative_image_embeds=zero_image_emb, | |
| ... height=768, | |
| ... width=768, | |
| ... num_inference_steps=50, | |
| ... ) | |
| >>> image = out.images[0] | |
| >>> image.save("cat_with_hat.png") | |
| ``` | |
| ## KandinskyInpaintCombinedPipeline[[diffusers.KandinskyInpaintCombinedPipeline]] | |
| #### diffusers.KandinskyInpaintCombinedPipeline[[diffusers.KandinskyInpaintCombinedPipeline]] | |
| ```python | |
| diffusers.KandinskyInpaintCombinedPipeline(text_encoder: MultilingualCLIP, tokenizer: XLMRobertaTokenizer, unet: UNet2DConditionModel, scheduler: diffusers.schedulers.scheduling_ddim.DDIMScheduler | diffusers.schedulers.scheduling_ddpm.DDPMScheduler, movq: VQModel, prior_prior: PriorTransformer, prior_image_encoder: CLIPVisionModelWithProjection, prior_text_encoder: CLIPTextModelWithProjection, prior_tokenizer: CLIPTokenizer, prior_scheduler: UnCLIPScheduler, prior_image_processor: CLIPImageProcessorPil) | |
| ``` | |
| [Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_combined.py#L572) | |
| **Parametreler:** | |
| text_encoder (`MultilingualCLIP`) : Donmuş metin kodlayıcı. | |
| tokenizer (`XLMRobertaTokenizer`) : Sınıfın | |
| scheduler (`DDIMScheduler` | `DDPMScheduler`) : `unet` ile birlikte kullanılarak görüntü latentleri üretmek için kullanılacak bir zamanlayıcı. | |
| unet ([UNet2DConditionModel](/docs/diffusers/main/tr/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Görsel gömümünü gürültüsüzleştirmek için koşullu U-Net mimarisi. | |
| movq ([VQModel](/docs/diffusers/main/tr/api/models/vq#diffusers.VQModel)) : Latentlerden görüntü üretmek için MoVQ Dekodlayıcı. | |
| prior_prior ([PriorTransformer](/docs/diffusers/main/tr/api/models/prior_transformer#diffusers.PriorTransformer)) : Metin gömümünden görüntü gömümünü yaklaşık olarak elde etmek için kullanılan standart unCLIP önceli. | |
| prior_image_encoder (`CLIPVisionModelWithProjection`) : Donmuş görüntü kodlayıcı. | |
| prior_text_encoder (`CLIPTextModelWithProjection`) : Donmuş metin kodlayıcı. | |
| prior_tokenizer (`CLIPTokenizer`) : [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer) sınıfının tokenizer'ı. | |
| prior_scheduler (`UnCLIPScheduler`) : `prior` ile birlikte kullanılarak gömme (embedding) üretmek için kullanılacak bir zamanlayıcı (scheduler). | |
| Kandinsky kullanılarak üretim için Birleşik Pipeline | |
| Bu model [DiffusionPipeline](/docs/diffusers/main/tr/api/pipelines/overview#diffusers.DiffusionPipeline) sınıfından devralır. Kütüphanenin tüm pipeline'lar için uyguladığı genel yöntemler (indirme veya kaydetme, belirli bir cihazda çalıştırma vb.) için üst sınıf belgelendirmesine bakın. | |
| #### __call__[[diffusers.KandinskyInpaintCombinedPipeline.__call__]] | |
| ```python | |
| __call__(prompt: str | list[str], image: typing.Union[torch.Tensor, list[torch.Tensor], PIL.Image.Image, list[PIL.Image.Image]], mask_image: typing.Union[torch.Tensor, list[torch.Tensor], PIL.Image.Image, list[PIL.Image.Image]], negative_prompt: str | list[str] | None = None, num_inference_steps: int = 100, guidance_scale: float = 4.0, num_images_per_prompt: int = 1, height: int = 512, width: int = 512, prior_guidance_scale: float = 4.0, prior_num_inference_steps: int = 25, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int = 1, return_dict: bool = True) | |
| ``` | |
| [Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_combined.py#L675) | |
| **Parametreler:** | |
| prompt (`str` veya `list[str]`) : Görsel üretimi yönlendirmek için istem veya istemler. | |
| image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` veya `list[np.ndarray]`) : `Image` veya bir görüntü grubunu temsil eden tensör, süreç için başlangıç noktası olarak kullanılacaktır. Latent'ler doğrudan geçiriliyorsa, `image` olarak görüntü latent'lerini de kabul edebilir; bu durumda yeniden kodlanmaz. | |
| mask_image (`np.array`) : `image`'ı maskelemek için bir görüntü partisini temsil eden Tensor. Maskedeki beyaz pikseller yeniden boyanırken, siyah pikseller korunur. `mask_image` bir PIL görüntüsü ise, kullanılmadan önce tek kanala (parlaklık) dönüştürülür. Bir tensör ise, 3 yerine tek bir renk kanalı (L) içermelidir; bu nedenle beklenen şekil `(B, H, W, 1)` olmalıdır. | |
| negative_prompt (`str` veya `list[str]`, *isteğe bağlı*) : Görsel üretimi yönlendirmemek için kullanılan istem veya istemler. Yönlendirme kullanılmadığında yok sayılır (yani `guidance_scale` `1`'den küçükse 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ı. | |
| num_inference_steps (`int`, *isteğe bağlı*, varsayılan 100) : 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. | |
| height (`int`, *isteğe bağlı*, varsayılan 512) : Üretilen görüntünün piksel cinsinden yüksekliği. | |
| width (`int`, *isteğe bağlı*, varsayılan 512) : Üretilen görüntünün piksel cinsinden genişliği. | |
| prior_guidance_scale (`float`, *isteğe bağlı*, varsayılan 4.0) : [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598)'de tanımlandığı gibi yönlendirme ölçeği. `guidance_scale`, [Imagen Paper](https://huggingface.co/papers/2205.11487)'deki 2. denklemindeki `w` olarak tanımlanır. Yönlendirme ölçeği, `guidance_scale > 1` olarak ayarlanarak etkinleştirilir. Daha yüksek yönlendirme ölçeği, genellikle daha düşük görüntü kalitesi pahasına, `prompt` ile yakından ilişkili görüntülerin üretilmesini teşvik eder. | |
| prior_num_inference_steps (`int`, *isteğe bağlı*, varsayılan 100) : 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. | |
| guidance_scale (`float`, *isteğe bağlı*, varsayılan 4.0) : [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598)'de tanımlandığı gibi yönlendirme ölçeği. `guidance_scale`, [Imagen Paper](https://huggingface.co/papers/2205.11487)'deki 2. denklemindeki `w` olarak tanımlanır. Yönlendirme ölçeği, `guidance_scale > 1` olarak ayarlanarak etkinleştirilir. Daha yüksek yönlendirme ölçeği, genellikle daha düşük görüntü kalitesi pahasına, `prompt` ile yakından ilişkili görüntülerin üretilmesini teşvik eder. | |
| generator (`torch.Generator` veya `list[torch.Generator]`, *isteğe bağlı*) : Üretimi deterministik hale getirmek için bir veya [torch üreteci(leri)](https://pytorch.org/docs/stable/generated/torch.Generator.html) listesi. | |
| latents (`torch.Tensor`, *isteğe bağlı*) : Görsel üretimi için girdi olarak kullanılacak, Gauss dağılımından örneklenen önceden oluşturulmuş gürültülü latentler. Farklı istemlerle aynı üretimi ayarlamak için kullanılabilir. Sağlanmazsa, sağlanan rastgele `generator` kullanılarak örneklem yoluyla bir latent tensörü oluşturulur. | |
| output_type (`str`, *isteğe bağlı*, varsayılan `"pil"`) : Üretilen görüntünün çıktı biçimi. Şunlardan birini seçin: `"pil"` (`PIL.Image.Image`), `"np"` (`np.array`) veya `"pt"` (`torch.Tensor`). | |
| callback (`Callable`, *isteğe bağlı*) : Çıkarım sırasında her `callback_steps` adımda çağrılan bir işlev. İşlev aşağıdaki argümanlarla çağrılır: `callback(step: int, timestep: int, latents: torch.Tensor)`. | |
| callback_steps (`int`, *isteğe bağlı*, varsayılan 1) : `callback` fonksiyonunun çağrılma sıklığı. Belirtilmezse, callback her adımda çağrılır. | |
| return_dict (`bool`, *isteğe bağlı*, varsayılan `True`) : Düz bir tuple yerine [ImagePipelineOutput](/docs/diffusers/main/tr/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) döndürülüp döndürülmemesi. | |
| **Dönüş:** [ImagePipelineOutput](/docs/diffusers/main/tr/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) veya `tuple` | |
| Üretim için pipeline çağrıldığında tetiklenen işlev. | |
| Örnekler: | |
| ```py | |
| from diffusers import AutoPipelineForInpainting | |
| from diffusers.utils import load_image | |
| import torch | |
| import numpy as np | |
| pipe = AutoPipelineForInpainting.from_pretrained( | |
| "kandinsky-community/kandinsky-2-1-inpaint", torch_dtype=torch.float16 | |
| ) | |
| pipe.enable_model_cpu_offload() | |
| prompt = "A fantasy landscape, Cinematic lighting" | |
| negative_prompt = "low quality, bad quality" | |
| original_image = load_image( | |
| "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" "/kandinsky/cat.png" | |
| ) | |
| mask = np.zeros((768, 768), dtype=np.float32) | |
| # Let's mask out an area above the cat's head | |
| mask[:250, 250:-250] = 1 | |
| image = pipe(prompt=prompt, image=original_image, mask_image=mask, num_inference_steps=25).images[0] | |
| ``` | |
| #### enable_sequential_cpu_offload[[diffusers.KandinskyInpaintCombinedPipeline.enable_sequential_cpu_offload]] | |
| ```python | |
| enable_sequential_cpu_offload(gpu_id: int | None = None, device: typing.Union[torch.device, str] = None) | |
| ``` | |
| [Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_combined.py#L655) | |
| Offloads all models to CPU using accelerate, significantly reducing memory usage. When called, unet, text_encoder, vae and safety checker have their state dicts saved to CPU and then are moved to a `torch.device('meta') and loaded to GPU only when their specific submodule has its `forward` method called. Note that offloading happens on a submodule basis. Memory savings are higher than with `enable_model_cpu_offload`, but performance is lower. | |
Xet Storage Details
- Size:
- 89.9 kB
- Xet hash:
- 830b22580490ece6806f38d313638280084c302e4f7f2712f373d0c7be4ef8cf
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.