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)、[Denis Dimitrov](https://github.com/denndimitrov) によって作成されました。
そのGitHubページの説明は以下の通りです:
*Kandinsky 2.1 は、Dall-E 2 と Latent diffusion の優れたプラクティスを継承しつつ、いくつかの新しいアイデアを導入しています。テキストおよび画像エンコーダーとして CLIP モデルを使用し、CLIP のモダリティ間の潜在空間の間に拡散画像事前分布（マッピング）を適用します。このアプローチにより、モデルの視覚的なパフォーマンスが向上し、画像のブレンドやテキスト主導の画像操作において新たな可能性が広がります。*
元のコードベースは [ai-forever/Kandinsky-2](https://github.com/ai-forever/Kandinsky-2) で確認できます。
> [!TIP]
> Hub上の[Kandinsky Community](https://huggingface.co/kandinsky-community)組織では、テキストから画像への変換、画像から画像への変換、インペインティングなどのタスク向けの公式モデルチェックポイントを確認できます。
> [!TIP]
> スケジューラーのトレードオフ、すなわち速度と品質のバランスをどのように探求するかを学ぶには、[ガイド](../../using-diffusers/schedulers)を必ずご確認ください。また、同じコンポーネントを複数のパイプラインに効率的に読み込む方法については、[パイプライン間でコンポーネントを再利用する](../../using-diffusers/loading#reusing-models-in-multiple-pipelines)セクションを参照してください。
以下のライブラリがインストールされていることを確認してください。
```py
# uncomment to install the necessary libraries in Colab
#!pip install -q diffusers transformers accelerate
```
> [!WARNING]
> Kandinsky 2.1 と 2.2 の使い方は非常に似ています! 唯一の違いは、Kandinsky 2.2 は latents をデコードする際に `prompt` を入力として受け付けないことです。代わりに、Kandinsky 2.2 はデコード時に `image_embeds` のみを接受します。
>
>
>
> Kandinsky 3 はより簡潔なアーキテクチャを持ち、事前モデルを必要としません。そのため、[Stable Diffusion XL](./stable_diffusion/stable_diffusion_xl) などの他の拡散モデルと同様に使用できます。
## テキストから画像へ
Kandinsky モデルを任意のタスクに使用する場合、常にまず prior パイプラインを設定して、プロンプトをエンコードし、画像埋め込みを生成します。prior パイプラインは、ネガティブプロンプト `""` に対応する `negative_image_embeds` も生成します。より良い結果を得るには、実際の `negative_prompt` を prior パイプラインに渡すことができますが、これにより prior パイプラインの有効なバッチサイズが 2 倍になります。
```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()
```
次に、すべてのプロンプトと埋め込みを[KandinskyPipeline](/docs/diffusers/main/ja/api/pipelines/kandinsky#diffusers.KandinskyPipeline)に渡し、画像を生成します:
```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()
```
`image_embeds`と`negative_image_embeds`を[KandinskyV22Pipeline](/docs/diffusers/main/ja/api/pipelines/kandinsky_v22#diffusers.KandinskyV22Pipeline)に渡して画像を生成します:
```py
image = pipeline(image_embeds=image_embeds, negative_image_embeds=negative_image_embeds, height=768, width=768).images[0]
image
```
Kandinsky 3 は事前モデルを必要としないため、[Kandinsky3Pipeline](/docs/diffusers/main/ja/api/pipelines/kandinsky3#diffusers.Kandinsky3Pipeline) を直接読み込み、プロンプトを渡して画像を生成できます。
```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 は、[KandinskyCombinedPipeline](/docs/diffusers/main/ja/api/pipelines/kandinsky#diffusers.KandinskyCombinedPipeline) と [KandinskyV22CombinedPipeline](/docs/diffusers/main/ja/api/pipelines/kandinsky_v22#diffusers.KandinskyV22CombinedPipeline) を通じたエンドツーエンドの API も提供しています。これにより、prior と text-to-image のパイプラインを個別にロードする必要はありません。統合パイプラインは、prior モデルとデコーダーの両方を自動的にロードします。必要に応じて、`prior_guidance_scale` と `prior_num_inference_steps` パラメータを使用して、prior パイプラインに異なる値を設定することもできます。
[AutoPipelineForText2Image](/docs/diffusers/main/ja/api/pipelines/auto_pipeline#diffusers.AutoPipelineForText2Image) を使用すると、内部で統合されたパイプラインが自動的に呼び出されます。
```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
```
## 画像から画像へ
画像から画像への生成では、初期画像とテキストプロンプトをパイプラインに渡して、画像の条件付けを行います。まず、priorパイプラインを読み込みます:
```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 は事前モデルを必要としないため、image-to-image パイプラインを直接ロードできます:
```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()
```
条件付けに使用する画像をダウンロードします:
```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))
```
以前のパイプラインで`image_embeds`と`negative_image_embeds`を生成します:
```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()
```
次に、元の画像、すべてのプロンプトと埋め込みをパイプラインに渡し、画像を生成します:
```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 は、[KandinskyImg2ImgCombinedPipeline](/docs/diffusers/main/ja/api/pipelines/kandinsky#diffusers.KandinskyImg2ImgCombinedPipeline) および [KandinskyV22Img2ImgCombinedPipeline](/docs/diffusers/main/ja/api/pipelines/kandinsky_v22#diffusers.KandinskyV22Img2ImgCombinedPipeline) によるエンドツーエンドの API も提供しています。これにより、prior と image-to-image パイプラインを個別に読み込む必要はありません。統合パイプラインは、prior モデルとデコーダーの両方を自動的に読み込みます。必要に応じて、`prior_guidance_scale` および `prior_num_inference_steps` パラメータを使用して、prior パイプラインに異なる値を設定することもできます。
[AutoPipelineForImage2Image](/docs/diffusers/main/ja/api/pipelines/auto_pipeline#diffusers.AutoPipelineForImage2Image) を使用すると、内部で統合されたパイプラインが自動的に呼び出されます:
```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)
```
## インペインティング
> [!WARNING]
> ⚠️ Kandinsky モデルでは、マスク領域を黒ピクセルではなく ⬜️ **白ピクセル** で表すようになりました。[KandinskyInpaintPipeline](/docs/diffusers/main/ja/api/pipelines/kandinsky#diffusers.KandinskyInpaintPipeline) を本番環境で使用している場合は、マスクを白ピクセルを使用するように変更する必要があります。
>
> ```py
> # For PIL input
> import PIL.ImageOps
> mask = PIL.ImageOps.invert(mask)
>
> # For PyTorch and NumPy input
> mask = 1 - mask
> ```
インペインティングには、元の画像、元の画像内で置き換える領域のマスク、そしてインペインティングする内容を示すテキストプロンプトが必要です。以前のパイプラインを読み込みます:
```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")
```
初期画像を読み込み、マスクを作成します:
```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
```
既存のパイプラインで埋め込みを生成します:
```py
prompt = "a hat"
prior_output = prior_pipeline(prompt)
```
次に、初期画像、マスク、プロンプトおよび埋め込みをパイプラインに渡し、画像を生成します:
```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)
```
エンドツーエンドの[KandinskyInpaintCombinedPipeline](/docs/diffusers/main/ja/api/pipelines/kandinsky#diffusers.KandinskyInpaintCombinedPipeline)と[KandinskyV22InpaintCombinedPipeline](/docs/diffusers/main/ja/api/pipelines/kandinsky_v22#diffusers.KandinskyV22InpaintCombinedPipeline)を使用すると、内部でpriorパイプラインとdecoderパイプラインをまとめて呼び出すことができます。これには[AutoPipelineForInpainting](/docs/diffusers/main/ja/api/pipelines/auto_pipeline#diffusers.AutoPipelineForInpainting)を使用します:
```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)
```
## 補間
Interpolationは、画像とテキストの埋め込みの間の潜在空間を探索することを可能にし、事前モデルの中間出力の一部を確認するクールな方法です。事前パイプラインと、補間したい2つの画像を読み込みます:
```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)
```
猫
ゴッホの絵画「星月夜」
補間するテキストや画像を指定し、各テキストや画像の重みを設定します。重みを調整して、補間への影響を確認してみてください!
```py
images_texts = ["a cat", img_1, img_2]
weights = [0.3, 0.3, 0.4]
```
`interpolate`関数を呼び出して埋め込みを生成し、それをパイプラインに渡して画像を生成します。
```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はKandinsky 2.2でのみサポートされています！
ControlNetは、深度マップやエッジ検出などの追加入力を用いて、大規模な事前学習済み拡散モデルを条件付けすることを可能にします。例えば、Kandinsky 2.2を深度マップで条件付けると、モデルは深度画像の構造を理解し、それを保持します。
画像を読み込み、深度マップを抽出してみましょう:
```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
```
その後、🤗 Transformers の [Pipeline](https://huggingface.co/docs/transformers/main/en/main_classes/pipelines#transformers.Pipeline) `depth-estimation` を使用して画像を処理し、深度マップを取得できます:
```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"
```
### テキストから画像へ[[controlnet-text-to-image]]
パイプラインと[KandinskyV22ControlnetPipeline](/docs/diffusers/main/ja/api/pipelines/kandinsky_v22#diffusers.KandinskyV22ControlnetPipeline)を読み込みます:
```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")
```
プロンプトとネガティブプロンプトから画像埋め込みを生成します:
```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()
```
最後に、画像埋め込みと深度画像を[KandinskyV22ControlnetPipeline](/docs/diffusers/main/ja/api/pipelines/kandinsky_v22#diffusers.KandinskyV22ControlnetPipeline)に渡して、画像を生成します:
```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
```
### 画像から画像へ[[controlnet-image-to-image]]
ControlNet を用いた画像から画像への生成には、以下を使用する必要があります。
- [KandinskyV22PriorEmb2EmbPipeline](/docs/diffusers/main/ja/api/pipelines/kandinsky_v22#diffusers.KandinskyV22PriorEmb2EmbPipeline) を使用して、テキストプロンプトと画像から画像埋め込みを生成します
- 初期画像と画像埋め込みから画像を生成するために[KandinskyV22ControlnetImg2ImgPipeline](/docs/diffusers/main/ja/api/pipelines/kandinsky_v22#diffusers.KandinskyV22ControlnetImg2ImgPipeline)を使用します
🤗 Transformers の [Pipeline](https://huggingface.co/docs/transformers/main/en/main_classes/pipelines#transformers.Pipeline) `depth-estimation` を使用して、猫の初期画像の深度マップを処理して抽出します:
```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"
```
以前の pipeline と [KandinskyV22ControlnetImg2ImgPipeline](/docs/diffusers/main/ja/api/pipelines/kandinsky_v22#diffusers.KandinskyV22ControlnetImg2ImgPipeline) を読み込みます:
```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")
```
テキストプロンプトと初期画像を prior パイプラインに渡して、画像の埋め込みを生成します:
```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)
```
これで、初期画像と画像埋め込みから画像を生成するために[KandinskyV22ControlnetImg2ImgPipeline](/docs/diffusers/main/ja/api/pipelines/kandinsky_v22#diffusers.KandinskyV22ControlnetImg2ImgPipeline)を実行できます。
```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)
```
## 最適化
Kandinsky は、マッピングを生成するための事前のパイプラインと、潜変数（latents）を画像にデコードするための第2のパイプラインの両方を必要とする点で独特です。計算の大部分は第2のパイプラインで行われるため、最適化の努力はそちらに集中させるべきです。以下は、推論時の Kandinsky のパフォーマンスを向上させるためのヒントです。
1. PyTorch < 2.0 を使用している場合は、[xFormers](../../optimization/attention_backends) を有効にしてください:
```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 を使用している場合は、`torch.compile` を有効にして、スケーリングドットプロダクトアテンション（SDPA）を自動的に使用するようにしてください。
```diff
pipe.unet.to(memory_format=torch.channels_last)
+ pipe.unet = torch.compile(pipe.unet, mode="reduce-overhead", fullgraph=True)
```
これは、アテンションプロセッサとして [AttnAddedKVProcessor2_0](/docs/diffusers/main/ja/api/attnprocessor#diffusers.models.attention_processor.AttnAddedKVProcessor2_0) を明示的に設定する場合と同じです:
```py
from diffusers.models.attention_processor import AttnAddedKVProcessor2_0
pipe.unet.set_attn_processor(AttnAddedKVProcessor2_0())
```
3. メモリ不足エラーを回避するために、[enable_model_cpu_offload()](/docs/diffusers/main/ja/api/pipelines/overview#diffusers.DiffusionPipeline.enable_model_cpu_offload) を使用してモデルを CPU にオフロードします:
```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. デフォルトでは、テキストから画像を生成するパイプラインは[DDIMScheduler](/docs/diffusers/main/ja/api/schedulers/ddim#diffusers.DDIMScheduler)を使用しますが、[DDPMScheduler](/docs/diffusers/main/ja/api/schedulers/ddpm#diffusers.DDPMScheduler)などの別のスケジューラーに置き換えることで、推論速度と画像品質のトレードオフにどのように影響するかを確認できます。
```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)
```
[ソース](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_prior.py#L135)
**パラメータ:**
prior ([PriorTransformer](/docs/diffusers/main/ja/api/models/prior_transformer#diffusers.PriorTransformer)) : テキスト埋め込みから画像埋め込みを近似するための、unCLIPの正規化された事前分布モデル。
image_encoder (`CLIPVisionModelWithProjection`) : 凍結された画像エンコーダー。
text_encoder (`CLIPTextModelWithProjection`) : 凍結されたテキストエンコーダー。
tokenizer (`CLIPTokenizer`) : クラス [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer) の Tokenizer。
scheduler (`UnCLIPScheduler`) : `prior` と組み合わせて使用し、画像埋め込みを生成するためのスケジューラ。
Kandinsky用の画像事前分布を生成するためのPipeline
このモデルは [DiffusionPipeline](/docs/diffusers/main/ja/api/pipelines/overview#diffusers.DiffusionPipeline) を継承しています。ライブラリがすべてのパイプラインに対して実装している汎用的なメソッド（ダウンロードや保存、特定のデバイスでの実行など）については、スーパークラスのドキュメントを参照してください。
#### __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)
```
[ソース](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_prior.py#L404)
**パラメータ:**
prompt (`str` または `list[str]`) : 画像生成をガイドするためのプロンプト、またはプロンプトのリスト。
negative_prompt (`str` または `list[str]`、*省略可能*) : 画像生成をガイドしないプロンプト、またはプロンプトのリスト。`guidance_scale` が `1` 未満の場合、無視されます（ガイドを使用していない場合、無視されます）。
num_images_per_prompt (`int`、*任意*、デフォルトは 1) : プロンプトごとに生成する画像の数。
num_inference_steps (`int`, *optional*, デフォルトは 25) : デノイジングのステップ数です。デノイジングのステップ数を増やすと、推論速度が遅くなる代わりに、通常はより高品質な画像が得られます。
generator (`torch.Generator` または `list[torch.Generator]`、*任意*) : 生成を決定論的にするための [torch ジェネレーター](https://pytorch.org/docs/stable/generated/torch.Generator.html) 1 つまたはそのリスト。
latents (`torch.Tensor`, *任意*) : イメージ生成の入力として使用される、ガウス分布からサンプリングされた事前生成されたノイジー・ラテンツ。異なるプロンプトで同じ生成を調整するために使用できます。指定されない場合、指定されたランダムな`generator`を使用してサンプリングを行い、ラテンツのテンソルが生成されます。
guidance_scale (`float`、*任意*、デフォルト値は 4.0) : [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598)で定義されているガイダンススケールです。`guidance_scale` は、[Imagen Paper](https://huggingface.co/papers/2205.11487)の式 2 の `w` として定義されています。`guidance_scale > 1` を設定することで、ガイダンススケールが有効になります。ガイダンススケールを高くすると、`prompt` のテキストと密接に関連した画像の生成が促されますが、通常は画像の品質が低下する傾向があります。
output_type (`str`、*任意*、デフォルトは`"pt"`) : 生成画像の出力形式。`"np"` (`np.array`) または `"pt"` (`torch.Tensor`) から選択します。
return_dict (`bool`、*任意*、デフォルトは`True`) : プレーンなタプルではなく、[ImagePipelineOutput](/docs/diffusers/main/ja/api/pipelines/consistency_models#diffusers.ImagePipelineOutput)を返すかどうか。
**戻り値:** `KandinskyPriorPipelineOutput` または `tuple`
生成用のパイプラインを呼び出したときに実行される関数。
例:
```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[typing.Union[str, PIL.Image.Image, torch.Tensor]], weights: list[float], 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)
```
[ソース](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_prior.py#L179)
**パラメータ:**
images_and_prompts (`list[str | PIL.Image.Image | torch.Tensor]`) : 画像生成をガイドするためのプロンプトと画像のリスト。
weights : (`list[float]`): `images_and_prompts` 内の各条件に対する重みのリスト
num_images_per_prompt (`int`、*任意*、デフォルトは 1) : プロンプトごとに生成する画像の数。
num_inference_steps (`int`, *optional*, デフォルトは 25) : デノイジングのステップ数です。デノイジングのステップ数を増やすと、推論速度が遅くなる代わりに、通常はより高品質な画像が得られます。
generator (`torch.Generator` または `list[torch.Generator]`、*任意*) : 生成を決定論的にするための [torch ジェネレーター](https://pytorch.org/docs/stable/generated/torch.Generator.html) 1 つまたはそのリスト。
latents (`torch.Tensor`, *任意*) : イメージ生成の入力として使用される、ガウス分布からサンプリングされた事前生成されたノイジー・ラテンツ。異なるプロンプトで同じ生成を調整するために使用できます。指定されない場合、指定されたランダムな`generator`を使用してサンプリングを行い、ラテンツのテンソルが生成されます。
negative_prior_prompt (`str`, *任意*) : 事前拡散プロセスをガイドしないためのプロンプト。ガイダンスを使用していない場合は無視されます（つまり、`guidance_scale`が`1`未満の場合は無視されます）。
negative_prompt (`str` または `list[str]`、*省略可能*) : 画像生成をガイドしないプロンプト。`guidance_scale` が `1` 未満の場合（つまり、ガイダンスを使用していない場合）は無視されます。
guidance_scale (`float`、*任意*、デフォルト値は 4.0) : [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598)で定義されているガイダンススケールです。`guidance_scale` は、[Imagen Paper](https://huggingface.co/papers/2205.11487)の式 2 の `w` として定義されています。`guidance_scale > 1` を設定することで、ガイダンススケールが有効になります。ガイダンススケールを高くすると、`prompt` のテキストと密接に関連した画像の生成が促されますが、通常は画像の品質が低下する傾向があります。
**戻り値:** `KandinskyPriorPipelineOutput` または `tuple`
補間のために先行パイプラインを使用する際に呼び出される関数。
例:
```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)
```
[ソース](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky.py#L81)
**パラメータ:**
text_encoder (`MultilingualCLIP`) : 凍結されたテキストエンコーダー。
tokenizer (`XLMRobertaTokenizer`) : クラス
scheduler (`DDIMScheduler` | `DDPMScheduler`) : `unet` と組み合わせて使用し、画像の潜在変数を生成するためのスケジューラ。
unet ([UNet2DConditionModel](/docs/diffusers/main/ja/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : 画像埋め込みのノイズ除去を行う条件付き U-Net アーキテクチャ。
movq ([VQModel](/docs/diffusers/main/ja/api/models/vq#diffusers.VQModel)) : 潜在変数から画像を生成するための MoVQ デコーダー。
Kandinsky を使用したテキストから画像への生成パイプライン
このモデルは [DiffusionPipeline](/docs/diffusers/main/ja/api/pipelines/overview#diffusers.DiffusionPipeline) を継承しています。ライブラリがすべてのパイプラインに対して実装している汎用的なメソッド（ダウンロードや保存、特定のデバイスでの実行など）については、スーパークラスのドキュメントを参照してください。
#### __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)
```
[ソース](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky.py#L236)
**パラメータ:**
prompt (`str` または `list[str]`) : 画像生成をガイドするためのプロンプト、またはプロンプトのリスト。
image_embeds (`torch.Tensor` または `list[torch.Tensor]`) : テキストプロンプトのクリップ画像埋め込みです。画像生成の条件付けに使用されます。
negative_image_embeds (`torch.Tensor` または `list[torch.Tensor]`) : 負のテキストプロンプトに対するクリップ画像埋め込み。画像生成の条件付けに使用されます。
negative_prompt (`str` または `list[str]`、*省略可能*) : 画像生成をガイドしないプロンプト、またはプロンプトのリスト。`guidance_scale` が `1` 未満の場合、無視されます（ガイドを使用していない場合、無視されます）。
height (`int`、*任意*、デフォルト値は 512) : 生成される画像のピクセル単位の縦幅。
width (`int`、*optional*、デフォルトは 512) : 生成される画像の幅（ピクセル単位）。
num_inference_steps (`int`、*optional*、デフォルト値は 100) : デノイジングのステップ数です。デノイジングのステップ数を増やすと、推論速度が遅くなる代わりに、通常はより高品質な画像が得られます。
guidance_scale (`float`、*任意*、デフォルト値は 4.0) : [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598)で定義されているガイダンススケールです。`guidance_scale` は、[Imagen Paper](https://huggingface.co/papers/2205.11487)の式 2 の `w` として定義されています。`guidance_scale > 1` を設定することで、ガイダンススケールが有効になります。ガイダンススケールを高くすると、`prompt` のテキストと密接に関連した画像の生成が促されますが、通常は画像の品質が低下する傾向があります。
num_images_per_prompt (`int`、*任意*、デフォルトは 1) : プロンプトごとに生成する画像の数。
generator (`torch.Generator` または `list[torch.Generator]`、*任意*) : 生成を決定論的にするための [torch ジェネレーター](https://pytorch.org/docs/stable/generated/torch.Generator.html) 1 つまたはそのリスト。
latents (`torch.Tensor`, *任意*) : イメージ生成の入力として使用される、ガウス分布からサンプリングされた事前生成されたノイジー・ラテンツ。異なるプロンプトで同じ生成を調整するために使用できます。指定されない場合、指定されたランダムな`generator`を使用してサンプリングを行い、ラテンツのテンソルが生成されます。
output_type (`str`、*任意*、デフォルトは `"pil"`) : 生成画像の出力形式。以下のいずれかを選択します: `"pil"` (`PIL.Image.Image`)、`"np"` (`np.array`)、または `"pt"` (`torch.Tensor`)。
callback (`Callable`、*任意*) : 推論中に`callback_steps`ステップごとに呼び出される関数です。この関数は、以下の引数とともに呼び出されます: `callback(step: int, timestep: int, latents: torch.Tensor)`。
callback_steps (`int`、*optional*、デフォルトは 1) : `callback` 関数が呼び出される頻度です。指定しない場合、callback はすべてのステップで呼び出されます。
return_dict (`bool`、*任意*、デフォルトは`True`) : プレーンなタプルではなく、[ImagePipelineOutput](/docs/diffusers/main/ja/api/pipelines/consistency_models#diffusers.ImagePipelineOutput)を返すかどうか。
**戻り値:** [ImagePipelineOutput](/docs/diffusers/main/ja/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) または `tuple`
生成用のパイプラインを呼び出したときに実行される関数。
例:
```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)
```
[ソース](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_combined.py#L113)
**パラメータ:**
text_encoder (`MultilingualCLIP`) : 凍結されたテキストエンコーダー。
tokenizer (`XLMRobertaTokenizer`) : クラス
scheduler (`DDIMScheduler` | `DDPMScheduler`) : `unet` と組み合わせて使用し、画像の潜在変数を生成するためのスケジューラ。
unet ([UNet2DConditionModel](/docs/diffusers/main/ja/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : 画像埋め込みのノイズ除去を行う条件付き U-Net アーキテクチャ。
movq ([VQModel](/docs/diffusers/main/ja/api/models/vq#diffusers.VQModel)) : 潜在変数から画像を生成するための MoVQ デコーダー。
prior_prior ([PriorTransformer](/docs/diffusers/main/ja/api/models/prior_transformer#diffusers.PriorTransformer)) : テキスト埋め込みから画像埋め込みを近似するための、unCLIPの正規化された事前分布モデル。
prior_image_encoder (`CLIPVisionModelWithProjection`) : 凍結された画像エンコーダー。
prior_text_encoder (`CLIPTextModelWithProjection`) : 凍結されたテキストエンコーダー。
prior_tokenizer (`CLIPTokenizer`) : クラス [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer) の Tokenizer。
prior_scheduler (`UnCLIPScheduler`) : `prior` と組み合わせて使用し、画像埋め込みを生成するためのスケジューラ。
Kandinsky を使用したテキストから画像への生成を行う統合 Pipeline
このモデルは [DiffusionPipeline](/docs/diffusers/main/ja/api/pipelines/overview#diffusers.DiffusionPipeline) を継承しています。ライブラリがすべてのパイプラインに対して実装している汎用的なメソッド（ダウンロードや保存、特定のデバイスでの実行など）については、スーパークラスのドキュメントを参照してください。
#### __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)
```
[ソース](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_combined.py#L215)
**パラメータ:**
prompt (`str` または `list[str]`) : 画像生成をガイドするためのプロンプト、またはプロンプトのリスト。
negative_prompt (`str` または `list[str]`、*省略可能*) : 画像生成をガイドしないプロンプト、またはプロンプトのリスト。`guidance_scale` が `1` 未満の場合、無視されます（ガイドを使用していない場合、無視されます）。
num_images_per_prompt (`int`、*任意*、デフォルトは 1) : プロンプトごとに生成する画像の数。
num_inference_steps (`int`、*optional*、デフォルト値は 100) : デノイジングのステップ数です。デノイジングのステップ数を増やすと、推論速度が遅くなる代わりに、通常はより高品質な画像が得られます。
height (`int`、*任意*、デフォルト値は 512) : 生成される画像のピクセル単位の縦幅。
width (`int`、*optional*、デフォルトは 512) : 生成される画像の幅（ピクセル単位）。
prior_guidance_scale (`float`、*任意*、デフォルト値は 4.0) : [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598)で定義されているガイダンススケールです。`guidance_scale` は、[Imagen Paper](https://huggingface.co/papers/2205.11487)の式 2 の `w` として定義されています。`guidance_scale > 1` を設定することで、ガイダンススケールが有効になります。ガイダンススケールを高くすると、`prompt` のテキストと密接に関連した画像の生成が促されますが、通常は画像の品質が低下する傾向があります。
prior_num_inference_steps (`int`、*optional*、デフォルト値は 100) : デノイジングのステップ数です。デノイジングのステップ数を増やすと、推論速度が遅くなる代わりに、通常はより高品質な画像が得られます。
guidance_scale (`float`、*任意*、デフォルト値は 4.0) : [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598)で定義されているガイダンススケールです。`guidance_scale` は、[Imagen Paper](https://huggingface.co/papers/2205.11487)の式 2 の `w` として定義されています。`guidance_scale > 1` を設定することで、ガイダンススケールが有効になります。ガイダンススケールを高くすると、`prompt` のテキストと密接に関連した画像の生成が促されますが、通常は画像の品質が低下する傾向があります。
generator (`torch.Generator` または `list[torch.Generator]`、*任意*) : 生成を決定論的にするための [torch ジェネレーター](https://pytorch.org/docs/stable/generated/torch.Generator.html) 1 つまたはそのリスト。
latents (`torch.Tensor`, *任意*) : イメージ生成の入力として使用される、ガウス分布からサンプリングされた事前生成されたノイジー・ラテンツ。異なるプロンプトで同じ生成を調整するために使用できます。指定されない場合、指定されたランダムな`generator`を使用してサンプリングを行い、ラテンツのテンソルが生成されます。
output_type (`str`、*任意*、デフォルトは `"pil"`) : 生成画像の出力形式。以下のいずれかを選択します: `"pil"` (`PIL.Image.Image`)、`"np"` (`np.array`)、または `"pt"` (`torch.Tensor`)。
callback (`Callable`、*任意*) : 推論中に`callback_steps`ステップごとに呼び出される関数です。この関数は、以下の引数とともに呼び出されます: `callback(step: int, timestep: int, latents: torch.Tensor)`。
callback_steps (`int`、*optional*、デフォルトは 1) : `callback` 関数が呼び出される頻度です。指定しない場合、callback はすべてのステップで呼び出されます。
return_dict (`bool`、*任意*、デフォルトは`True`) : プレーンなタプルではなく、[ImagePipelineOutput](/docs/diffusers/main/ja/api/pipelines/consistency_models#diffusers.ImagePipelineOutput)を返すかどうか。
**戻り値:** [ImagePipelineOutput](/docs/diffusers/main/ja/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) または `tuple`
生成用のパイプラインを呼び出したときに実行される関数。
例:
```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)
```
[ソース](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_combined.py#L196)
🤗 Accelerate を使用して、すべてのモデル（`unet`、`text_encoder`、`vae`、および `safety checker` の state dict）を CPU にオフロードし、メモリ使用量を大幅に削減します。モデルは `torch.device('meta')` に移動され、特定のサブモジュールの `forward` メソッドが呼び出されたときにのみ GPU にロードされます。オフロードはサブモジュール単位で行われます。`enable_model_cpu_offload` を使用する場合よりもメモリ削減効果は高いですが、パフォーマンスは低くなります。
## KandinskyImg2ImgPipeline[[diffusers.KandinskyImg2ImgPipeline]]
#### diffusers.KandinskyImg2ImgPipeline[[diffusers.KandinskyImg2ImgPipeline]]
```python
diffusers.KandinskyImg2ImgPipeline(text_encoder: MultilingualCLIP, movq: VQModel, tokenizer: XLMRobertaTokenizer, unet: UNet2DConditionModel, scheduler: DDIMScheduler)
```
[ソース](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_img2img.py#L92)
**パラメータ:**
text_encoder (`MultilingualCLIP`) : 凍結されたテキストエンコーダー。
tokenizer (`XLMRobertaTokenizer`) : クラス
scheduler ([DDIMScheduler](/docs/diffusers/main/ja/api/schedulers/ddim#diffusers.DDIMScheduler)) : `unet`と組み合わせて使用し、画像の潜在変数を生成するためのスケジューラ。
unet ([UNet2DConditionModel](/docs/diffusers/main/ja/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : 画像埋め込みのノイズ除去を行う条件付き U-Net アーキテクチャ。
movq ([VQModel](/docs/diffusers/main/ja/api/models/vq#diffusers.VQModel)) : MoVQ画像エンコーダーおよびデコーダー
Kandinsky を使用した画像から画像への生成のための Pipeline
このモデルは [DiffusionPipeline](/docs/diffusers/main/ja/api/pipelines/overview#diffusers.DiffusionPipeline) を継承しています。ライブラリがすべてのパイプラインに対して実装している汎用的なメソッド（ダウンロードや保存、特定のデバイスでの実行など）については、スーパークラスのドキュメントを参照してください。
#### __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)
```
[ソース](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_img2img.py#L296)
**パラメータ:**
prompt (`str` または `list[str]`) : 画像生成をガイドするためのプロンプト、またはプロンプトのリスト。
image (`torch.Tensor`、`PIL.Image.Image`) : プロセスの開始点として使用される、`Image` または画像バッチを表すテンソル。
image_embeds (`torch.Tensor` または `list[torch.Tensor]`) : テキストプロンプトのクリップ画像埋め込みです。画像生成の条件付けに使用されます。
negative_image_embeds (`torch.Tensor` または `list[torch.Tensor]`) : 負のテキストプロンプトに対するクリップ画像埋め込み。画像生成の条件付けに使用されます。
negative_prompt (`str` または `list[str]`、*省略可能*) : 画像生成をガイドしないプロンプト、またはプロンプトのリスト。`guidance_scale` が `1` 未満の場合、無視されます（ガイドを使用していない場合、無視されます）。
height (`int`、*任意*、デフォルト値は 512) : 生成される画像のピクセル単位の縦幅。
width (`int`、*optional*、デフォルトは 512) : 生成される画像の幅（ピクセル単位）。
num_inference_steps (`int`、*optional*、デフォルト値は 100) : デノイジングのステップ数です。デノイジングのステップ数を増やすと、推論速度が遅くなる代わりに、通常はより高品質な画像が得られます。
strength (`float`, *optional*, デフォルト値は 0.3) : 概念的には、参照となる `image` をどの程度変換するかを示します。0 から 1 の間の値である必要があります。 `image` は開始点として使用され、 `strength` が大きいほど、それに加えられるノイズ量が増えます。デノイジングのステップ数は、最初に追加されるノイズ量に依存します。 `strength` が 1 の場合、追加されるノイズは最大となり、デノイジングプロセスは `num_inference_steps` で指定された全イテレーション数分実行されます。したがって、値が 1 である場合、 `image` は実質的に無視されます。
guidance_scale (`float`、*任意*、デフォルト値は 4.0) : [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598)で定義されているガイダンススケールです。`guidance_scale` は、[Imagen Paper](https://huggingface.co/papers/2205.11487)の式 2 の `w` として定義されています。`guidance_scale > 1` を設定することで、ガイダンススケールが有効になります。ガイダンススケールを高くすると、`prompt` のテキストと密接に関連した画像の生成が促されますが、通常は画像の品質が低下する傾向があります。
num_images_per_prompt (`int`、*任意*、デフォルトは 1) : プロンプトごとに生成する画像の数。
generator (`torch.Generator` または `list[torch.Generator]`、*任意*) : 生成を決定論的にするための [torch ジェネレーター](https://pytorch.org/docs/stable/generated/torch.Generator.html) 1 つまたはそのリスト。
output_type (`str`、*任意*、デフォルトは `"pil"`) : 生成画像の出力形式。以下のいずれかを選択します: `"pil"` (`PIL.Image.Image`)、`"np"` (`np.array`)、または `"pt"` (`torch.Tensor`)。
callback (`Callable`、*任意*) : 推論中に`callback_steps`ステップごとに呼び出される関数です。この関数は、以下の引数とともに呼び出されます: `callback(step: int, timestep: int, latents: torch.Tensor)`。
callback_steps (`int`、*optional*、デフォルトは 1) : `callback` 関数が呼び出される頻度です。指定しない場合、callback はすべてのステップで呼び出されます。
return_dict (`bool`、*任意*、デフォルトは`True`) : プレーンなタプルではなく、[ImagePipelineOutput](/docs/diffusers/main/ja/api/pipelines/consistency_models#diffusers.ImagePipelineOutput)を返すかどうか。
**戻り値:** [ImagePipelineOutput](/docs/diffusers/main/ja/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) または `tuple`
生成用のパイプラインを呼び出したときに実行される関数。
例:
```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)
```
[ソース](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_combined.py#L331)
**パラメータ:**
text_encoder (`MultilingualCLIP`) : 凍結されたテキストエンコーダー。
tokenizer (`XLMRobertaTokenizer`) : クラス
scheduler (`DDIMScheduler` | `DDPMScheduler`) : `unet` と組み合わせて使用し、画像の潜在変数を生成するためのスケジューラ。
unet ([UNet2DConditionModel](/docs/diffusers/main/ja/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : 画像埋め込みのノイズ除去を行う条件付き U-Net アーキテクチャ。
movq ([VQModel](/docs/diffusers/main/ja/api/models/vq#diffusers.VQModel)) : 潜在変数から画像を生成するための MoVQ デコーダー。
prior_prior ([PriorTransformer](/docs/diffusers/main/ja/api/models/prior_transformer#diffusers.PriorTransformer)) : テキスト埋め込みから画像埋め込みを近似するための、unCLIPの正規化された事前分布モデル。
prior_image_encoder (`CLIPVisionModelWithProjection`) : 凍結された画像エンコーダー。
prior_text_encoder (`CLIPTextModelWithProjection`) : 凍結されたテキストエンコーダー。
prior_tokenizer (`CLIPTokenizer`) : クラス [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer) の Tokenizer。
prior_scheduler (`UnCLIPScheduler`) : `prior` と組み合わせて使用し、画像埋め込みを生成するためのスケジューラ。
Kandinsky を用いた画像から画像への生成のための統合 Pipeline
このモデルは [DiffusionPipeline](/docs/diffusers/main/ja/api/pipelines/overview#diffusers.DiffusionPipeline) を継承しています。ライブラリがすべてのパイプラインに対して実装している汎用的なメソッド（ダウンロードや保存、特定のデバイスでの実行など）については、スーパークラスのドキュメントを参照してください。
#### __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)
```
[ソース](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_combined.py#L434)
**パラメータ:**
prompt (`str` または `list[str]`) : 画像生成をガイドするためのプロンプト、またはプロンプトのリスト。
image (`torch.Tensor`、`PIL.Image.Image`、`np.ndarray`、`list[torch.Tensor]`、`list[PIL.Image.Image]`、または `list[np.ndarray]`) : `Image`、または画像バッチを表すテンソル。プロセスの開始点として使用されます。`image` として画像の潜在変数（latents）を直接渡すことも可能で、その場合は再度エンコードされません。
negative_prompt (`str` または `list[str]`、*省略可能*) : 画像生成をガイドしないプロンプト、またはプロンプトのリスト。`guidance_scale` が `1` 未満の場合、無視されます（ガイドを使用していない場合、無視されます）。
num_images_per_prompt (`int`、*任意*、デフォルトは 1) : プロンプトごとに生成する画像の数。
num_inference_steps (`int`、*optional*、デフォルト値は 100) : デノイジングのステップ数です。デノイジングのステップ数を増やすと、推論速度が遅くなる代わりに、通常はより高品質な画像が得られます。
height (`int`、*任意*、デフォルト値は 512) : 生成される画像のピクセル単位の縦幅。
width (`int`、*optional*、デフォルトは 512) : 生成される画像の幅（ピクセル単位）。
strength (`float`, *optional*, デフォルト値は 0.3) : 概念的には、参照となる `image` をどの程度変換するかを示します。0 から 1 の間の値である必要があります。 `image` は開始点として使用され、 `strength` が大きいほど、それに加えられるノイズ量が増えます。デノイジングのステップ数は、最初に追加されるノイズ量に依存します。 `strength` が 1 の場合、追加されるノイズは最大となり、デノイジングプロセスは `num_inference_steps` で指定された全イテレーション数分実行されます。したがって、値が 1 である場合、 `image` は実質的に無視されます。
prior_guidance_scale (`float`、*任意*、デフォルト値は 4.0) : [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598)で定義されているガイダンススケールです。`guidance_scale` は、[Imagen Paper](https://huggingface.co/papers/2205.11487)の式 2 の `w` として定義されています。`guidance_scale > 1` を設定することで、ガイダンススケールが有効になります。ガイダンススケールを高くすると、`prompt` のテキストと密接に関連した画像の生成が促されますが、通常は画像の品質が低下する傾向があります。
prior_num_inference_steps (`int`、*optional*、デフォルト値は 100) : デノイジングのステップ数です。デノイジングのステップ数を増やすと、推論速度が遅くなる代わりに、通常はより高品質な画像が得られます。
guidance_scale (`float`、*任意*、デフォルト値は 4.0) : [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598)で定義されているガイダンススケールです。`guidance_scale` は、[Imagen Paper](https://huggingface.co/papers/2205.11487)の式 2 の `w` として定義されています。`guidance_scale > 1` を設定することで、ガイダンススケールが有効になります。ガイダンススケールを高くすると、`prompt` のテキストと密接に関連した画像の生成が促されますが、通常は画像の品質が低下する傾向があります。
generator (`torch.Generator` または `list[torch.Generator]`、*任意*) : 生成を決定論的にするための [torch ジェネレーター](https://pytorch.org/docs/stable/generated/torch.Generator.html) 1 つまたはそのリスト。
latents (`torch.Tensor`, *任意*) : イメージ生成の入力として使用される、ガウス分布からサンプリングされた事前生成されたノイジー・ラテンツ。異なるプロンプトで同じ生成を調整するために使用できます。指定されない場合、指定されたランダムな`generator`を使用してサンプリングを行い、ラテンツのテンソルが生成されます。
output_type (`str`、*任意*、デフォルトは `"pil"`) : 生成画像の出力形式。以下のいずれかを選択します: `"pil"` (`PIL.Image.Image`)、`"np"` (`np.array`)、または `"pt"` (`torch.Tensor`)。
callback (`Callable`、*任意*) : 推論中に`callback_steps`ステップごとに呼び出される関数です。この関数は、以下の引数とともに呼び出されます: `callback(step: int, timestep: int, latents: torch.Tensor)`。
callback_steps (`int`、*optional*、デフォルトは 1) : `callback` 関数が呼び出される頻度です。指定しない場合、callback はすべてのステップで呼び出されます。
return_dict (`bool`、*任意*、デフォルトは`True`) : プレーンなタプルではなく、[ImagePipelineOutput](/docs/diffusers/main/ja/api/pipelines/consistency_models#diffusers.ImagePipelineOutput)を返すかどうか。
**戻り値:** [ImagePipelineOutput](/docs/diffusers/main/ja/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) または `tuple`
生成用のパイプラインを呼び出したときに実行される関数。
例:
```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)
```
[ソース](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)
```
[ソース](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_inpaint.py#L244)
**パラメータ:**
text_encoder (`MultilingualCLIP`) : 凍結されたテキストエンコーダー。
tokenizer (`XLMRobertaTokenizer`) : クラス
scheduler ([DDIMScheduler](/docs/diffusers/main/ja/api/schedulers/ddim#diffusers.DDIMScheduler)) : `unet`と組み合わせて使用し、画像の潜在変数を生成するためのスケジューラ。
unet ([UNet2DConditionModel](/docs/diffusers/main/ja/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : 画像埋め込みのノイズ除去を行う条件付き U-Net アーキテクチャ。
movq ([VQModel](/docs/diffusers/main/ja/api/models/vq#diffusers.VQModel)) : MoVQ画像エンコーダーおよびデコーダー
Kandinsky2.1 を用いたテキストガイド型画像インペインティングのパイプライン
このモデルは [DiffusionPipeline](/docs/diffusers/main/ja/api/pipelines/overview#diffusers.DiffusionPipeline) を継承しています。ライブラリがすべてのパイプラインに対して実装している汎用的なメソッド（ダウンロードや保存、特定のデバイスでの実行など）については、スーパークラスのドキュメントを参照してください。
#### __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)
```
[ソース](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_inpaint.py#L400)
**パラメータ:**
prompt (`str` または `list[str]`) : 画像生成をガイドするためのプロンプト、またはプロンプトのリスト。
image (`torch.Tensor`、`PIL.Image.Image`、または `np.ndarray`) : `Image`、または画像バッチを表すテンソル。このプロセスの開始点として使用されます。
mask_image (`PIL.Image.Image`、`torch.Tensor`、または `np.ndarray`) : `image` をマスクするための `Image`、または画像バッチを表すテンソル。マスク内の白いピクセルは再描画され、黒いピクセルは保持されます。マスクとして PyTorch テンソルを渡すことができるのは、渡した画像が PyTorch テンソルの場合のみです。また、3 つのカラーチャネルではなく 1 つのカラーチャネル (L) を含める必要があるため、期待される形状は `(B, 1, H, W,)`、`(B, H, W)`、`(1, H, W)`、または `(H, W)` になります。画像が PIL イメージまたは NumPy 配列の場合、マスクも PIL イメージまたは NumPy 配列である必要があります。PIL イメージの場合、使用前に単一チャネル (輝度) に変換されます。NumPy 配列の場合、期待される形状は `(H, W)` です。
image_embeds (`torch.Tensor` または `list[torch.Tensor]`) : テキストプロンプトのクリップ画像埋め込みです。画像生成の条件付けに使用されます。
negative_image_embeds (`torch.Tensor` または `list[torch.Tensor]`) : 負のテキストプロンプトに対するクリップ画像埋め込み。画像生成の条件付けに使用されます。
negative_prompt (`str` または `list[str]`、*省略可能*) : 画像生成をガイドしないプロンプト、またはプロンプトのリスト。`guidance_scale` が `1` 未満の場合、無視されます（ガイドを使用していない場合、無視されます）。
height (`int`、*任意*、デフォルト値は 512) : 生成される画像のピクセル単位の縦幅。
width (`int`、*optional*、デフォルトは 512) : 生成される画像の幅（ピクセル単位）。
num_inference_steps (`int`、*optional*、デフォルト値は 100) : デノイジングのステップ数です。デノイジングのステップ数を増やすと、推論速度が遅くなる代わりに、通常はより高品質な画像が得られます。
guidance_scale (`float`、*任意*、デフォルト値は 4.0) : [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598)で定義されているガイダンススケールです。`guidance_scale` は、[Imagen Paper](https://huggingface.co/papers/2205.11487)の式 2 の `w` として定義されています。`guidance_scale > 1` を設定することで、ガイダンススケールが有効になります。ガイダンススケールを高くすると、`prompt` のテキストと密接に関連した画像の生成が促されますが、通常は画像の品質が低下する傾向があります。
num_images_per_prompt (`int`、*任意*、デフォルトは 1) : プロンプトごとに生成する画像の数。
generator (`torch.Generator` または `list[torch.Generator]`、*任意*) : 生成を決定論的にするための [torch ジェネレーター](https://pytorch.org/docs/stable/generated/torch.Generator.html) 1 つまたはそのリスト。
latents (`torch.Tensor`, *任意*) : イメージ生成の入力として使用される、ガウス分布からサンプリングされた事前生成されたノイジー・ラテンツ。異なるプロンプトで同じ生成を調整するために使用できます。指定されない場合、指定されたランダムな`generator`を使用してサンプリングを行い、ラテンツのテンソルが生成されます。
output_type (`str`、*任意*、デフォルトは `"pil"`) : 生成画像の出力形式。以下のいずれかを選択します: `"pil"` (`PIL.Image.Image`)、`"np"` (`np.array`)、または `"pt"` (`torch.Tensor`)。
callback (`Callable`、*任意*) : 推論中に`callback_steps`ステップごとに呼び出される関数です。この関数は、以下の引数とともに呼び出されます: `callback(step: int, timestep: int, latents: torch.Tensor)`。
callback_steps (`int`、*optional*、デフォルトは 1) : `callback` 関数が呼び出される頻度です。指定しない場合、callback はすべてのステップで呼び出されます。
return_dict (`bool`、*任意*、デフォルトは`True`) : プレーンなタプルではなく、[ImagePipelineOutput](/docs/diffusers/main/ja/api/pipelines/consistency_models#diffusers.ImagePipelineOutput)を返すかどうか。
**戻り値:** [ImagePipelineOutput](/docs/diffusers/main/ja/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) または `tuple`
生成用のパイプラインを呼び出したときに実行される関数。
例:
```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)
```
[ソース](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_combined.py#L572)
**パラメータ:**
text_encoder (`MultilingualCLIP`) : 凍結されたテキストエンコーダー。
tokenizer (`XLMRobertaTokenizer`) : クラス
scheduler (`DDIMScheduler` | `DDPMScheduler`) : `unet` と組み合わせて使用し、画像の潜在変数を生成するためのスケジューラ。
unet ([UNet2DConditionModel](/docs/diffusers/main/ja/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : 画像埋め込みのノイズ除去を行う条件付き U-Net アーキテクチャ。
movq ([VQModel](/docs/diffusers/main/ja/api/models/vq#diffusers.VQModel)) : 潜在変数から画像を生成するための MoVQ デコーダー。
prior_prior ([PriorTransformer](/docs/diffusers/main/ja/api/models/prior_transformer#diffusers.PriorTransformer)) : テキスト埋め込みから画像埋め込みを近似するための、unCLIPの正規化された事前分布モデル。
prior_image_encoder (`CLIPVisionModelWithProjection`) : 凍結された画像エンコーダー。
prior_text_encoder (`CLIPTextModelWithProjection`) : 凍結されたテキストエンコーダー。
prior_tokenizer (`CLIPTokenizer`) : クラス [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer) の Tokenizer。
prior_scheduler (`UnCLIPScheduler`) : `prior` と組み合わせて使用し、画像埋め込みを生成するためのスケジューラ。
Kandinsky を用いた生成のための統合 Pipeline
このモデルは [DiffusionPipeline](/docs/diffusers/main/ja/api/pipelines/overview#diffusers.DiffusionPipeline) を継承しています。ライブラリがすべてのパイプラインに対して実装している汎用的なメソッド（ダウンロードや保存、特定のデバイスでの実行など）については、スーパークラスのドキュメントを参照してください。
#### __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)
```
[ソース](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky/pipeline_kandinsky_combined.py#L675)
**パラメータ:**
prompt (`str` または `list[str]`) : 画像生成をガイドするためのプロンプト、またはプロンプトのリスト。
image (`torch.Tensor`、`PIL.Image.Image`、`np.ndarray`、`list[torch.Tensor]`、`list[PIL.Image.Image]`、または `list[np.ndarray]`) : `Image`、または画像バッチを表すテンソル。プロセスの開始点として使用されます。`image` として画像の潜在変数（latents）を直接渡すことも可能で、その場合は再度エンコードされません。
mask_image (`np.array`) : `image` をマスクするための、画像バッチを表す Tensor。マスク内の白いピクセルは再描画され、黒いピクセルは保持されます。`mask_image` が PIL 画像の場合、使用の前に単一チャネル（輝度）に変換されます。テンソルの場合は、3 つのチャネルではなく 1 つの色チャネル（L）を含む必要があるため、期待される形状は `(B, H, W, 1)` になります。
negative_prompt (`str` または `list[str]`、*省略可能*) : 画像生成をガイドしないプロンプト、またはプロンプトのリスト。`guidance_scale` が `1` 未満の場合、無視されます（ガイドを使用していない場合、無視されます）。
num_images_per_prompt (`int`、*任意*、デフォルトは 1) : プロンプトごとに生成する画像の数。
num_inference_steps (`int`、*optional*、デフォルト値は 100) : デノイジングのステップ数です。デノイジングのステップ数を増やすと、推論速度が遅くなる代わりに、通常はより高品質な画像が得られます。
height (`int`、*任意*、デフォルト値は 512) : 生成される画像のピクセル単位の縦幅。
width (`int`、*optional*、デフォルトは 512) : 生成される画像の幅（ピクセル単位）。
prior_guidance_scale (`float`、*任意*、デフォルト値は 4.0) : [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598)で定義されているガイダンススケールです。`guidance_scale` は、[Imagen Paper](https://huggingface.co/papers/2205.11487)の式 2 の `w` として定義されています。`guidance_scale > 1` を設定することで、ガイダンススケールが有効になります。ガイダンススケールを高くすると、`prompt` のテキストと密接に関連した画像の生成が促されますが、通常は画像の品質が低下する傾向があります。
prior_num_inference_steps (`int`、*optional*、デフォルト値は 100) : デノイジングのステップ数です。デノイジングのステップ数を増やすと、推論速度が遅くなる代わりに、通常はより高品質な画像が得られます。
guidance_scale (`float`、*任意*、デフォルト値は 4.0) : [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598)で定義されているガイダンススケールです。`guidance_scale` は、[Imagen Paper](https://huggingface.co/papers/2205.11487)の式 2 の `w` として定義されています。`guidance_scale > 1` を設定することで、ガイダンススケールが有効になります。ガイダンススケールを高くすると、`prompt` のテキストと密接に関連した画像の生成が促されますが、通常は画像の品質が低下する傾向があります。
generator (`torch.Generator` または `list[torch.Generator]`、*任意*) : 生成を決定論的にするための [torch ジェネレーター](https://pytorch.org/docs/stable/generated/torch.Generator.html) 1 つまたはそのリスト。
latents (`torch.Tensor`, *任意*) : イメージ生成の入力として使用される、ガウス分布からサンプリングされた事前生成されたノイジー・ラテンツ。異なるプロンプトで同じ生成を調整するために使用できます。指定されない場合、指定されたランダムな`generator`を使用してサンプリングを行い、ラテンツのテンソルが生成されます。
output_type (`str`、*任意*、デフォルトは `"pil"`) : 生成画像の出力形式。以下のいずれかを選択します: `"pil"` (`PIL.Image.Image`)、`"np"` (`np.array`)、または `"pt"` (`torch.Tensor`)。
callback (`Callable`、*任意*) : 推論中に`callback_steps`ステップごとに呼び出される関数です。この関数は、以下の引数とともに呼び出されます: `callback(step: int, timestep: int, latents: torch.Tensor)`。
callback_steps (`int`、*optional*、デフォルトは 1) : `callback` 関数が呼び出される頻度です。指定しない場合、callback はすべてのステップで呼び出されます。
return_dict (`bool`、*任意*、デフォルトは`True`) : プレーンなタプルではなく、[ImagePipelineOutput](/docs/diffusers/main/ja/api/pipelines/consistency_models#diffusers.ImagePipelineOutput)を返すかどうか。
**戻り値:** [ImagePipelineOutput](/docs/diffusers/main/ja/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) または `tuple`
生成用のパイプラインを呼び出したときに実行される関数。
例:
```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)
```
[ソース](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.
# 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)、[Denis Dimitrov](https://github.com/denndimitrov) によって作成されました。
そのGitHubページの説明は以下の通りです:
*Kandinsky 2.1 は、Dall-E 2 と Latent diffusion の優れたプラクティスを継承しつつ、いくつかの新しいアイデアを導入しています。テキストおよび画像エンコーダーとして CLIP モデルを使用し、CLIP のモダリティ間の潜在空間の間に拡散画像事前分布（マッピング）を適用します。このアプローチにより、モデルの視覚的なパフォーマンスが向上し、画像のブレンドやテキスト主導の画像操作において新たな可能性が広がります。*
元のコードベースは [ai-forever/Kandinsky-2](https://github.com/ai-forever/Kandinsky-2) で確認できます。
> [!TIP]
> Hub上の[Kandinsky Community](https://huggingface.co/kandinsky-community)組織では、テキストから画像への変換、画像から画像への変換、インペインティングなどのタスク向けの公式モデルチェックポイントを確認できます。
> [!TIP]
> スケジューラーのトレードオフ、すなわち速度と品質のバランスをどのように探求するかを学ぶには、[ガイド](../../using-diffusers/schedulers)を必ずご確認ください。また、同じコンポーネントを複数のパイプラインに効率的に読み込む方法については、[パイプライン間でコンポーネントを再利用する](../../using-diffusers/loading#reusing-models-in-multiple-pipelines)セクションを参照してください。
以下のライブラリがインストールされていることを確認してください。
```py
# uncomment to install the necessary libraries in Colab
#!pip install -q diffusers transformers accelerate
```
> [!WARNING]
> Kandinsky 2.1 と 2.2 の使い方は非常に似ています! 唯一の違いは、Kandinsky 2.2 は latents をデコードする際に `prompt` を入力として受け付けないことです。代わりに、Kandinsky 2.2 はデコード時に `image_embeds` のみを接受します。
>
>
>
> Kandinsky 3 はより簡潔なアーキテクチャを持ち、事前モデルを必要としません。そのため、[Stable Diffusion XL](./stable_diffusion/stable_diffusion_xl) などの他の拡散モデルと同様に使用できます。
## テキストから画像へ
Kandinsky モデルを任意のタスクに使用する場合、常にまず prior パイプラインを設定して、プロンプトをエンコードし、画像埋め込みを生成します。prior パイプラインは、ネガティブプロンプト `""` に対応する `negative_image_embeds` も生成します。より良い結果を得るには、実際の `negative_prompt` を prior パイプラインに渡すことができますが、これにより prior パイプラインの有効なバッチサイズが 2 倍になります。
```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()
```
次に、すべてのプロンプトと埋め込みを[KandinskyPipeline](/docs/diffusers/main/ja/api/pipelines/kandinsky#diffusers.KandinskyPipeline)に渡し、画像を生成します:
```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()
```
`image_embeds`と`negative_image_embeds`を[KandinskyV22Pipeline](/docs/diffusers/main/ja/api/pipelines/kandinsky_v22#diffusers.KandinskyV22Pipeline)に渡して画像を生成します:
```py
image = pipeline(image_embeds=image_embeds, negative_image_embeds=negative_image_embeds, height=768, width=768).images[0]
image
```
Kandinsky 3 は事前モデルを必要としないため、[Kandinsky3Pipeline](/docs/diffusers/main/ja/api/pipelines/kandinsky3#diffusers.Kandinsky3Pipeline) を直接読み込み、プロンプトを渡して画像を生成できます。
```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 は、[KandinskyCombinedPipeline](/docs/diffusers/main/ja/api/pipelines/kandinsky#diffusers.KandinskyCombinedPipeline) と [KandinskyV22CombinedPipeline](/docs/diffusers/main/ja/api/pipelines/kandinsky_v22#diffusers.KandinskyV22CombinedPipeline) を通じたエンドツーエンドの API も提供しています。これにより、prior と text-to-image のパイプラインを個別にロードする必要はありません。統合パイプラインは、prior モデルとデコーダーの両方を自動的にロードします。必要に応じて、`prior_guidance_scale` と `prior_num_inference_steps` パラメータを使用して、prior パイプラインに異なる値を設定することもできます。
[AutoPipelineForText2Image](/docs/diffusers/main/ja/api/pipelines/auto_pipeline#diffusers.AutoPipelineForText2Image) を使用すると、内部で統合されたパイプラインが自動的に呼び出されます。
```py
from diffusers import AutoPipelineForText2Image
import torch
pipeline = AutoPipelineForText2Image.from_pretrained("kandinsky-community/kandinsky-2-1", dtype=torch.float16)
pipeline.enable_model_cpu_offload()
Xet Storage Details
- Size:
- 96.2 kB
- Xet hash:
- d82c551ae5635788b8910666beea0a5bc6ed946e6c4c4d79005a04e7bcc9f780
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.