Diffusers

( prior: PriorTransformer image_encoder: CLIPVisionModelWithProjection text_encoder: CLIPTextModelWithProjection tokenizer: CLIPTokenizer scheduler: UnCLIPScheduler image_processor: CLIPImageProcessor )

参数

prior (PriorTransformer) — 使用当前unCLIP先验来近似文本嵌入到图像嵌入。
image_encoder (CLIPVisionModelWithProjection) — 冻结的图像编码器。
text_encoder (CLIPTextModelWithProjection) — 冻结的文本编码器。
tokenizer (CLIPTokenizer) — 属于 CLIPTokenizer 类的分词器。
scheduler (UnCLIPScheduler) — 与 prior 结合使用的调度器，用于生成图像嵌入。
image_processor (CLIPImageProcessor) — 用于在 clip 中预处理图像的图像处理器。

为康定斯基生成图像先验的管道

此模型继承自 DiffusionPipeline。请查看超类文档，了解库为所有管道（例如下载或保存、在特定设备上运行等）实现的通用方法。

call

( prompt: 联合 negative_prompt: 联合 = None num_images_per_prompt: int = 1 num_inference_steps: int = 25 generator: 联合 = None latents: 选项 = None guidance_scale: float = 4.0 output_type: 选项 = 'pt' return_dict: bool = True callback_on_step_end: 选项 = None callback_on_step_end_tensor_inputs: 列表 = ['latents'] ) → KandinskyPriorPipelineOutput 或 tuple

参数

prompt (str 或 List[str]) — 指导图像生成的提示或提示列表。
negative_prompt (str or List[str], 可选) — 不要引导图像生成的提示或提示列表。当不使用引导时（例如，如果 guidance_scale 小于 1），则忽略。
num_images_per_prompt (int, 可选, 默认为1) — 每个提示生成的图像数量。
num_inference_steps (int, 可选, 默认为100) — 降噪步骤的数量。更多的降噪步骤通常会带来更高的图像质量，但以更慢的推理为代价。
generator (torch.Generator 或 List[torch.Generator]，可选) — 用于生成确定性输出的一个或多个 torch 生成器。
latents (torch.Tensor，可选) — 用于图像生成的预先生成的噪声潜在变量，从高斯分布中采样。可用于使用不同的提示调整相同的生成。如果未提供，将通过使用提供的随机 generator 来采样的方式生成潜在变量张量。
guidance_scale (float，可选，默认为 4.0) — 根据 Classifier-Free Diffusion Guidance 定义的指导缩放比例。`guidance_scale` 被定义为 Imagen 论文中方程 2 中的 `w`。当 `guidance_scale > 1` 时，启用指导缩放。较高的指导缩放比例鼓励生成与文本 prompt 非常紧密相关的图像，通常以牺牲较低图像质量为代价。
output_type (str, 可选, 默认为 "pt") — 生成的图像的输出格式。可选择："np" (np.array) 或 "pt" (torch.Tensor)。
return_dict (bool, 可选, 默认为 True) — 是否返回一个 ImagePipelineOutput 而不是普通的元组。
callback_on_step_end (Callable, 可选) — 在推理期间每个去噪步骤结束时调用的函数。函数以以下参数调用： callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)。callback_kwargs 将包含由 callback_on_step_end_tensor_inputs 指定的所有张量列表。
callback_on_step_end_tensor_inputs (列表，可选）—the callback_on_step_end 函数的 tensor 输入列表。列表中指定的张量将被作为 callback_kwargs 参数传递。您只能包含在您的 pipeline 类的 ._callback_tensor_inputs 属性中列出的变量。

KandinskyPriorPipelineOutput 或 元组

在调用 pipeline 进行生成时触发函数。

示例

>>> from diffusers import KandinskyV22Pipeline, KandinskyV22PriorPipeline
>>> import torch

>>> pipe_prior = KandinskyV22PriorPipeline.from_pretrained("kandinsky-community/kandinsky-2-2-prior")
>>> pipe_prior.to("cuda")
>>> prompt = "red cat, 4k photo"
>>> image_emb, negative_image_emb = pipe_prior(prompt).to_tuple()

>>> pipe = KandinskyV22Pipeline.from_pretrained("kandinsky-community/kandinsky-2-2-decoder")
>>> pipe.to("cuda")
>>> image = pipe(
...     image_embeds=image_emb,
...     negative_image_embeds=negative_image_emb,
...     height=768,
...     width=768,
...     num_inference_steps=50,
... ).images
>>> image[0].save("cat.png")

interpolate

< 源 >

( images_and_prompts: List weights: List num_images_per_prompt: int = 1 num_inference_steps: int = 25 generator: Union = None latents: Optional = None negative_prior_prompt: Optional = None negative_prompt: str = '' guidance_scale: float = 4.0 device = None ) → KandinskyPriorPipelineOutput or tuple

参数

images_and_prompts (List[Union[str, PIL.Image.Image, torch.Tensor]]) — 指导图像生成的提示和图像列表。weights — （List[float]）：图像和提示中每个条件对应的权重列表
num_images_per_prompt （int，可选，默认为1） — 每个提示生成的图像数量。
negative_prior_prompt (str, 可选) — 不引导先验扩散过程的提示。当不使用引导时（即，当 guidance_scale 小于 1 时）被忽略。
negative_prompt (str 或 List[str], 可选) — 不引导图像生成的提示。当不使用引导时（即，当 guidance_scale 小于 1 时）被忽略。
guidance_scale (float, 可选，默认 4.0) — 在无分类器扩散指导中定义的指导缩放。 guidance_scale 定义为 Imagen 论文第 2 个方程的 w。通过将 guidance_scale > 1 来启用指导缩放。更高的指导缩放会鼓励生成与文本 prompt 密切相关的图像，通常以牺牲较低的图像质量为代价。

KandinskyPriorPipelineOutput 或 元组

在用于插值的先验管道中调用的函数。

示例

>>> from diffusers import KandinskyV22PriorPipeline, KandinskyV22Pipeline
>>> from diffusers.utils import load_image
>>> import PIL
>>> import torch
>>> from torchvision import transforms

>>> pipe_prior = KandinskyV22PriorPipeline.from_pretrained(
...     "kandinsky-community/kandinsky-2-2-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]
>>> out = pipe_prior.interpolate(images_texts, weights)
>>> pipe = KandinskyV22Pipeline.from_pretrained(
...     "kandinsky-community/kandinsky-2-2-decoder", torch_dtype=torch.float16
... )
>>> pipe.to("cuda")
>>> image = pipe(
...     image_embeds=out.image_embeds,
...     negative_image_embeds=out.negative_image_embeds,
...     height=768,
...     width=768,
...     num_inference_steps=50,
... ).images[0]
>>> image.save("starry_cat.png")

KandinskyV22Pipeline

类 diffusers.KandinskyV22Pipeline

( unet: UNet2DConditionModel scheduler: DDPMScheduler movq: VQModel )

参数

调度器 (Union[DDIMScheduler,DDPMScheduler]) — 与 unet 结合使用以生成图像潜变量的调度器。
unet (UNet2DConditionModel) — 条件 U-Net 架构，用于去除图像嵌入的噪声。
movq (VQModel) — MoVQ 解码器，用于从潜在空间生成图像。

使用 Kandinsky 生成的文本到图像的管道。

此模型继承自 DiffusionPipeline。请查看超类文档，了解库为所有管道（例如下载或保存、在特定设备上运行等）实现的通用方法。

call

( image_embeds: 联合类型negative_image_embeds: 联合类型height: int = 512width: int = 512num_inference_steps: int = 100guidance_scale: float = 4.0num_images_per_prompt: int = 1generator: 联合类型 = Nonelatents: 可选类型 = Noneoutput_type: 可选类型 = 'pil'return_dict: bool = Truecallback_on_step_end: 可选类型 = Nonecallback_on_step_end_tensor_inputs: List = ['latents']**kwargs ) → ImagePipelineOutput 或 tuple

参数

image_embeds (torch.Tensor 或 List[torch.Tensor]) — 用于条件图像生成的文本提示的clip图像嵌入。
negative_image_embeds （torch.Tensor 或 List[torch.Tensor]）— 负文字提示的剪影图像嵌入，将用于条件化图像生成。
height （int，可选，默认值为512）— 生成的图像高度（像素）。
width （int，可选，默认值为512）— 生成的图像宽度（像素）。
num_inference_steps （int，可选，默认为 100）——去噪步数。更多的去噪步骤通常会导致图像质量更高，但推理速度减慢。
guidance_scale （float，可选，默认为 4.0）——如 Classifier-Free Diffusion Guidance 中定义的引导比例。引导比例为 Imagen 论文中方程 2 的 w。引导比例通过设置 guidance_scale > 1 启用。更高的引导比例鼓励生成与文本 prompt 密切相关的图像，通常以牺牲图像质量为代价。
num_images_per_prompt （int，可选，默认为 1）——每个提示生成的图像数量。
generator (torch.Generator 或 List[torch.Generator]，可选）—— 用于生成确定性输出的一个或多个 torch 生成器。
latents (torch.Tensor，可选）—— 预生成的噪声 latents，从高斯分布中采样，用于图像生成的输入。可用于使用不同提示调整相同的生成。如果未提供，将通过提供的随机 generator 生成 latents 张量。
output_type (str，可选，默认为 "pil"）—— 生成的图像的输出格式。可选择："pil"（《PIL.Image.Image》），"np"（《np.array》）或 "pt"（《torch.Tensor》）。
return_dict (bool, 可选, 默认为 True) — 是否返回 ImagePipelineOutput 而不是普通元组。
callback_on_step_end (Callable, 可选) — 在推理过程中每一步消除噪声时调用的函数。函数带有以下参数: callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)。 callback_kwargs 将包括由 callback_on_step_end_tensor_inputs 指定的一组所有张量。
callback_on_step_end_tensor_inputs (列表, 可选) — callback_on_step_end 函数的输入张量列表。列表中指定的张量将作为 callback_kwargs 参数传递。只能包含您的管道类中 ._callback_tensor_inputs 属性列出的变量。

ImagePipelineOutput 或 元组

在调用 pipeline 进行生成时触发函数。

示例

>>> from diffusers import KandinskyV22Pipeline, KandinskyV22PriorPipeline
>>> import torch

>>> pipe_prior = KandinskyV22PriorPipeline.from_pretrained("kandinsky-community/kandinsky-2-2-prior")
>>> pipe_prior.to("cuda")
>>> prompt = "red cat, 4k photo"
>>> out = pipe_prior(prompt)
>>> image_emb = out.image_embeds
>>> zero_image_emb = out.negative_image_embeds
>>> pipe = KandinskyV22Pipeline.from_pretrained("kandinsky-community/kandinsky-2-2-decoder")
>>> pipe.to("cuda")
>>> image = pipe(
...     image_embeds=image_emb,
...     negative_image_embeds=zero_image_emb,
...     height=768,
...     width=768,
...     num_inference_steps=50,
... ).images
>>> image[0].save("cat.png")

KandinskyV22CombinedPipeline

类 diffusers.KandinskyV22CombinedPipeline

( unet: UNet2DConditionModel scheduler: DDPMScheduler movq: VQModel prior_prior: PriorTransformer prior_image_encoder: CLIPVisionModelWithProjection prior_text_encoder: CLIPTextModelWithProjection prior_tokenizer: CLIPTokenizer prior_scheduler: UnCLIPScheduler prior_image_processor: CLIPImageProcessor )

参数

scheduler (Union[DDIMScheduler,DDPMScheduler]) — 一个用于与unet结合使用以生成图像潜的调度程序。
unet (UNet2DConditionModel) — 用于去噪图像嵌入的有条件U-Net架构。
movq (VQModel) — 用于从潜变量生成图像的MoVQ解码器。
prior_prior (PriorTransformer) — 该无CLIP先验用于近似的从文本嵌入到图像嵌入的规范先验。
prior_image_encoder (CLIPVisionModelWithProjection) — 冻结的图像编码器。
prior_text_encoder (CLIPTextModelWithProjection) — 冻结的文本编码器。
prior_tokenizer (CLIPTokenizer) — 类 CLIPTokenizer 的分词器。
prior_scheduler (UnCLIPScheduler) — 与 prior 结合使用以生成图像嵌入的调度器。
prior_image_processor (CLIPImageProcessor) — 用于从 clip 预处理的图像处理器。

使用 Kandinsky 的文本到图像生成的组合管道

此模型继承自 DiffusionPipeline。请查看超类文档，了解库为所有管道（例如下载或保存、在特定设备上运行等）实现的通用方法。

call

( 提示: 联合 negative_prompt: 联合 = None num_inference_steps: int = 100 guidance_scale: float = 4.0 num_images_per_prompt: int = 1 高度: int = 512 宽度: int = 512 prior_guidance_scale: float = 4.0 prior_num_inference_steps: int = 25 generator: 联合 = None latents: 可选 = None output_type: 可选 = 'pil' callback: 可选 = None callback_steps: int = 1 return_dict: bool = True prior_callback_on_step_end: 可选 = None prior_callback_on_step_end_tensor_inputs: List = ['latents'] callback_on_step_end: 可选 = None callback_on_step_end_tensor_inputs: List = ['latents'] ) → ImagePipelineOutput or tuple

参数

提示 (str or List[str]) — 指导图像生成的提示或提示列表。
negative_prompt (str 或 List[str]，可选）— 不用于引导图像生成的提示或提示词。当未使用引导（即，当 guidance_scale 小于 1 时）将被忽略。
num_images_per_prompt (int，可选，默认为1）— 每个提示词生成图像的数量。
num_inference_steps (int，可选，默认为100）— 降噪步骤的数量。更多的降噪步骤通常会导致图像质量更高，但推理速度会变慢。
height (int，可选，默认为512）— 生成图像的像素高度。
width (int, 可选, 默认为 512) — 生成图像的像素宽度。
prior_guidance_scale (float, 可选, 默认为 4.0) — 如在 Classifier-Free Diffusion Guidance 中定义的引导尺度。`guidance_scale` 是 Imagen 论文方程 2 中的 `w`。引导尺度通过设置 `guidance_scale > 1` 启用。更高的引导尺度鼓励生成与文本 prompt 密切相关的图像，通常以牺牲图像质量为代价。
prior_num_inference_steps (int, 可选, 默认为 100) — 推断步骤的数量。更多的去噪步骤通常会导致图像质量更高，但推理速度会变慢。
guidance_scale（《浮点数》可选，默认为4.0）— 根据在Classifier-Free Diffusion Guidance中定义的指导尺度。 guidance_scale是在Imagen Paper公式2中的w。指导尺度通过设置guidance_scale > 1启用。更高的指导尺度鼓励生成与文本prompt紧密相连的图像，通常以牺牲较低的图像质量为代价。
generator（《torch.Generator》或《List[torch.Generator]》）可选 — 一个或多个torch generator(s)用于使生成确定性的工具。
latents（《torch.Tensor》）可选 — 预生成的噪声latents，从高斯分布中抽取，用作图像生成的输入。可用于使用不同的提示调整相同的生成。如果没有提供，将通过提供的随机generator采样来生成latents张量。
output_type (str, 可选, 默认为 "pil") — 生成图像的输出格式。选择以下之一："pil" (PIL.Image.Image), "np" (np.array) 或 "pt" (torch.Tensor)。
return_dict (bool, 可选, 默认为 True) — 是否返回ImagePipelineOutput而非纯元组。
prior_callback_on_step_end (Callable, 可选) — 在先验管道推理过程中，每次去噪步骤结束时调用的函数。该函数用以下参数调用：prior_callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)。
prior_callback_on_step_end_tensor_inputs（《列表》, 可选）—用于 prior_callback_on_step_end 函数的张量输入列表。列表中指定的张量将作为 callback_kwargs 参数传递。您只能包含在管道类 ._callback_tensor_inputs 属性中列出的变量。
callback_on_step_end（《调用函数》,可选) —在每个解码推理步骤结束后调用的函数。该函数使用以下参数调用：callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)。 callback_kwargs 将包括所有根据 callback_on_step_end_tensor_inputs 指定的张量。
callback_on_step_end_tensor_inputs（《列表》,可选) —用于 callback_on_step_end 函数的张量输入列表。列表中指定的张量将作为 callback_kwargs 参数传递。您只能包含在管道类 ._callback_tensor_inputs 属性中列出的变量。

ImagePipelineOutput 或 元组

在调用 pipeline 进行生成时触发函数。

示例

from diffusers import AutoPipelineForText2Image
import torch

pipe = AutoPipelineForText2Image.from_pretrained(
    "kandinsky-community/kandinsky-2-2-decoder", 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]

启用_sequential_cpu_offload

( gpu_id: 可选 = None device: 联合 = 'cuda' )

使用 accelerate 将所有模型卸载到 CPU，显著减少内存使用。当调用时，unet、text_encoder、vae 和安全检查器将它们的状态字典保存到 CPU，然后在它们的特定子模块调用 forward 方法时才将其移动到 torch.device('meta') 并加载到 GPU。注意卸载是在子模块基础上发生的。内存节省大于使用 `enable_model_cpu_offload` 的情况，但性能较低。

KandinskyV22ControlnetPipeline

类 diffusers.KandinskyV22ControlnetPipeline

( unet: UNet2DConditionModel scheduler: DDPMScheduler movq: VQModel )

参数

调度器 (DDIM调度器) — 用于与unet结合以生成图像潜伏值的调度器。
unet (UNet2D条件模型) — 条件U-Net架构，用于去除图像嵌入的噪声。
movq (VQ模型) — MoVQ解码器，用于从潜伏值生成图像。

使用 Kandinsky 生成的文本到图像的管道。

此模型继承自 DiffusionPipeline。请查看超类文档，了解库为所有管道（例如下载或保存、在特定设备上运行等）实现的通用方法。

call

( image_embeds: 联合 negative_image_embeds: 联合 hint: 张量 height: int = 512 width: int = 512 num_inference_steps: int = 100 guidance_scale: float = 4.0 num_images_per_prompt: int = 1 generator: 联合 = None latents: 任意 = None output_type: 任意 = 'pil' callback: 任意 = None callback_steps: int = 1 return_dict: bool = True ) → ImagePipelineOutput 或 tuple

参数

prompt (str 或 List[str]) — 引导图像生成的指示或指示列表。
提示 (torch.Tensor) — 控制网条件。
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, 可选，默认为512) — 生成图像的像素宽度。
num_inference_steps (int, 可选，默认为100) — 消噪步骤的数量。更多的消噪步骤通常会导致图像质量更高，但推理速度会变慢。
guidance_scale (float, 可选，默认为4.0) — 指导比例，如无分类器扩散指导中定义。 guidance_scale 被定义为 Imagen 文章中的方程式2中的 w。通过设置 guidance_scale > 1 启用指导比例。更高的指导比例鼓励生成与文本 prompt 紧密相关的图像，通常是以牺牲图像质量为代价的。
num_images_per_prompt (int, 可选，默认为1) — 每个提示生成的图像数量。
generator (torch.Generator 或 List[torch.Generator], 可选) — 一个或多个torch 生成器，用于使生成过程具有确定性。
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, 可选，默认值为 1) — callback 函数被调用的频率。如果未指定，则在每个步骤上调用回调。
return_dict (bool, 可选，默认值为 True) — 是否返回一个 ImagePipelineOutput 而不是普通元组。

ImagePipelineOutput 或 元组

在调用 pipeline 进行生成时触发函数。

示例

KandinskyV22PriorEmb2EmbPipeline

类 diffusers.KandinskyV22PriorEmb2EmbPipeline

参数

prior (PriorTransformer) — 用于近似从文本嵌入到图像嵌入的标准的unCLIP先验。
image_encoder (CLIPVisionModelWithProjection) — 固定的图像编码器。
text_encoder (CLIPTextModelWithProjection) — 固定的文本编码器。
tokenizer (CLIPTokenizer) — 类 CLIPTokenizer 的分词器。
scheduler (UnCLIPScheduler) — 与 prior 一起生成图像嵌入的调度器。

为康定斯基生成图像先验的管道

此模型继承自 DiffusionPipeline。请查看超类文档，了解库为所有管道（例如下载或保存、在特定设备上运行等）实现的通用方法。

call

( prompt: 联合类型 image: 联合类型 strength: 浮点型 = 0.3 negative_prompt: 联合类型 = None num_images_per_prompt: 整型 = 1 num_inference_steps: 整型 = 25 generator: 联合类型 = None guidance_scale: 浮点型 = 4.0 output_type: 可选 = 'pt' return_dict: 布尔型 = True ) → KandinskyPriorPipelineOutput 或 tuple

参数

prompt (str 或 List[str]) — 引导图像生成的提示或提示列表。
strength (float，可选，默认为0.8) — 从概念上讲，表示调整参考 emb 的程度。必须在0到1之间。image 将用作起始点，增加更多的噪声，则 strength 越大。去噪步骤的数量取决于最初加入的噪声量。
emb (torch.Tensor) — 图像嵌入。
negative_prompt (str 或 List[str]，可选) — 不指导图像生成的提示或提示列表。当未使用指导（即当 guidance_scale 小于 1 时）将被忽略。
num_images_per_prompt (int，可选，默认为 1) — 每个提示生成图片的数量。
num_inference_steps (int, 可选, 默认为100) — 消噪步骤的数量。更多的消噪步骤通常会导致图像质量更高，但推理速度较慢。
generator (torch.Generator 或 List[torch.Generator], 可选) — 一个或多个用于使生成确定性化的 torch 生成器。
guidance_scale (float, 可选, 默认为4.0) — 在 Classifier-Free Diffusion Guidance 中定义的指导比例。 guidance_scale 定义为Imagen 论文中的方程 2 的 w。指导比例通过设置 guidance_scale > 1 启用。更高的指导比例鼓励生成与文本 prompt 密切相关的图像，通常以降低图像质量为代价。
output_type (str, 可选, 默认为 "pt") — 生成图像的输出格式。可以选择："np" (np.array) 或 "pt" (torch.Tensor)。
return_dict (bool, 可选, 默认为 True) — 是否返回一个 ImagePipelineOutput 而不是原始元组。

KandinskyPriorPipelineOutput 或 元组

在调用 pipeline 进行生成时触发函数。

示例

>>> from diffusers import KandinskyV22Pipeline, KandinskyV22PriorEmb2EmbPipeline
>>> import torch

>>> pipe_prior = KandinskyPriorPipeline.from_pretrained(
...     "kandinsky-community/kandinsky-2-2-prior", torch_dtype=torch.float16
... )
>>> pipe_prior.to("cuda")

>>> prompt = "red cat, 4k photo"
>>> img = load_image(
...     "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
...     "/kandinsky/cat.png"
... )
>>> image_emb, nagative_image_emb = pipe_prior(prompt, image=img, strength=0.2).to_tuple()

>>> pipe = KandinskyPipeline.from_pretrained(
...     "kandinsky-community/kandinsky-2-2-decoder, torch_dtype=torch.float16"
... )
>>> pipe.to("cuda")

>>> image = pipe(
...     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

参数

images_and_prompts (列表[Union[str, PIL.Image.Image, torch.Tensor]]) — 利用作图像生成的提示和图像列表。权重 — (列表[float])：用于 images_and_prompts 中每种条件的权重列表
num_images_per_prompt (int, 可选, 默认为 1) — 每个提示生成的图像数量。
num_inference_steps (int, 可选, 默认为 100) — 去噪步骤的数量。更多的去噪步骤通常会导致图像质量更高，但会牺牲推理速度。
generator (torch.Generator 或 List[torch.Generator]，可选) — 用于使生成过程确定性的一个或多个 torch 生成器。
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 中定义。 guidance_scale 被定义为 Imagen Paper 中公式 2 的 w。指导尺度通过设置 guidance_scale > 1 启用。更高的指导尺度会鼓励生成与文本 prompt 紧密相关的图像，通常以牺牲图像质量为代价。

KandinskyPriorPipelineOutput 或 元组

在用于插值的先验管道中调用的函数。

示例

>>> from diffusers import KandinskyV22PriorEmb2EmbPipeline, KandinskyV22Pipeline
>>> from diffusers.utils import load_image
>>> import PIL

>>> import torch
>>> from torchvision import transforms

>>> pipe_prior = KandinskyV22PriorPipeline.from_pretrained(
...     "kandinsky-community/kandinsky-2-2-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 = KandinskyV22Pipeline.from_pretrained(
...     "kandinsky-community/kandinsky-2-2-decoder", 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")

KandinskyV22Img2ImgPipeline

类 diffusers.KandinskyV22Img2ImgPipeline

( unet: UNet2DConditionModel scheduler: DDPMScheduler movq: VQModel )

参数

scheduler (DDIMScheduler) — 用于与unet结合以生成图像潜力的调度器。
unet (UNet2DConditionModel) — 用于去噪图像嵌入的条件U-Net架构。
movq (VQModel) — 用于从潜量生成图像的MoVQ解码器。

使用Kandinsky进行图像到图像生成的Pipeline

此模型继承自 DiffusionPipeline。请查看超类文档，了解库为所有管道（例如下载或保存、在特定设备上运行等）实现的通用方法。

call

( image_embeds: 联合类型 image: 联合类型 negative_image_embeds: 联合类型 height: int = 512 width: int = 512 num_inference_steps: int = 100 guidance_scale: float = 4.0 strength: float = 0.3 num_images_per_prompt: int = 1 generator: 联合类型 = None output_type: 可选 = 'pil' return_dict: bool = True callback_on_step_end: 可选 = None callback_on_step_end_tensor_inputs: 列表 = ['latents'] **kwargs ) → ImagePipelineOutput or tuple

参数

image_embeds (torch.Tensor 或 List[torch.Tensor]) — 用于文本提示的剪影图像嵌入，将用于条件化图像生成。
image (torch.Tensor, PIL.Image.Image, np.ndarray, List[torch.Tensor], List[PIL.Image.Image], 或 List[np.ndarray]) — Image，或代表图像批次的张量，用作生成过程的起点。也可以将图像潜量作为 image 接受，如果直接传递潜量，则不会再次编码。
strength (可选 float，默认 0.8) — 从概念上讲，表示有多大的程度要变换引用图像 image。必须在 0 和 1 之间。越大 strength 的值，image 上添加的噪声就越多。strength 的数量依赖于初始添加的噪声量。当 strength 为 1 时，添加的噪声将达到最大，去噪过程将运行到在 num_inference_steps 中指定的完整迭代次数。因此，值 1 实质上忽略了 image。
negative_image_embeds （torch.Tensor 或 List[torch.Tensor]）— 用于负文本提示的剪辑图像嵌入，将被用于限制图像生成。
height （int，可选，默认为512）— 生成图像的像素高度。
width （int，可选，默认为512）— 生成图像的像素宽度。
num_inference_steps （int，可选，默认为100）— 去噪步骤的数量。更多的去噪步骤通常会导致图像质量更高，但推理速度较慢。
guidance_scale（《浮点数》，可选，默认为4.0）— 指导尺度，如无分类扩散指导中定义。指导尺度定义为Imagen 论文中的方程2的w。guidance_scale通过设置guidance_scale > 1启用。较高的指导尺度会鼓励生成与文本prompt密切相关的图像，通常以牺牲较低的画面质量为代价。
num_images_per_prompt（《整型数字》，可选，默认为1）— 每个提示生成的图像数量。
generator（《torch.Generator 或 List[torch.Generator]），可选）— 一个或多个torch generator(s)以实现生成确定性的。
output_type (str, 可选，默认为 "pil") — 生成图像的输出格式。选择以下选项之一： "pil" （PIL.Image.Image）， "np"（np.array），或 "pt"（torch.Tensor）。
return_dict (bool, 可选，默认为 True) — 是否返回 ImagePipelineOutput 而不是纯元组。
callback_on_step_end (Callable, 可选) — 在推理过程中每个去噪步骤结束时调用的函数。该函数带有以下参数： callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)。 callback_kwargs 将包含由 callback_on_step_end_tensor_inputs 指定的所有张量。
callback_on_step_end_tensor_inputs (列表，可选）—— 为 callback_on_step_end 函数提供的张量输入列表。列表中指定的张量将作为 callback_kwargs 参数传递。您只能包含在您的管道类 ._callback_tensor_inputs 属性中列出的变量。

ImagePipelineOutput 或 元组

在调用 pipeline 进行生成时触发函数。

示例

（KandinskyV22Img2ImgCombinedPipeline）

类 diffusers.KandinskyV22Img2ImgCombinedPipeline

参数

调度器 (Union[DDIMScheduler,DDPMScheduler]) — 用于与 unet 结合以生成图像潜在值的调度器。
unet (UNet2DConditionModel) — 条件 U-Net 架构，用于去噪图像嵌入。
movq (VQModel) — MoVQ 解码器，用于从潜在值生成图像。
prior_prior (PriorTransformer) — 文本嵌入近似图像嵌入的标准 unCLIP 先验。
prior_image_encoder (CLIPVisionModelWithProjection) — 冻结的图像编码器。
prior_text_encoder (CLIPTextModelWithProjection) — 冻结的文本编码器。
prior_tokenizer (CLIPTokenizer) —— Tokenizer 类 CLIPTokenizer。
prior_scheduler (UnCLIPScheduler) —— 用于与 prior 结合以生成图像嵌入的调度器。
prior_image_processor (CLIPImageProcessor) —— 用于在 clip 中预处理图像的图像处理器。

Kandinsky 图像到图像生成组合流程

此模型继承自 DiffusionPipeline。请查看超类文档，了解库为所有管道（例如下载或保存、在特定设备上运行等）实现的通用方法。

call

( prompt: 联合 image: 联合 negative_prompt: 联合 = None num_inference_steps: int = 100 guidance_scale: float = 4.0 strength: float = 0.3 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: 联合 = None latents: Optional = None output_type: Optional = 'pil' callback: Optional = None callback_steps: int = 1 return_dict: bool = True prior_callback_on_step_end: Optional = None prior_callback_on_step_end_tensor_inputs: List = ['latents'] callback_on_step_end: Optional = None callback_on_step_end_tensor_inputs: List = ['latents'] ) → ImagePipelineOutput 或 tuple

参数

prompt (str 或 List[str]) — 指导图像生成的提示或提示列表。
image (torch.Tensor、PIL.Image.Image、np.ndarray、List[torch.Tensor]、List[PIL.Image.Image] 或 List[np.ndarray]) — 图像或表示图像批次的张量，用作过程的起始点。也可以接受作为图像的图像隐变量image，如果直接传递隐变量，则不会再次进行编码。
negative_prompt (str 或 List[str]，可选) — 不需要指导图像生成的提示或提示列表。当不使用指导（即当 guidance_scale 小于 1 时）将被忽略。
num_images_per_prompt (int, 可选, 默认值为1) — 每个提示生成的图像数量。
guidance_scale (float, 可选, 默认值为4.0) — 根据Classifier-Free Diffusion Guidance定义的指导比例。 guidance_scale 定义为Imagen Paper中方程2的 . 指导比例通过设置 guidance_scale > 1 启用。更高的指导比例鼓励生成与文本 prompt 紧密相关的图像，通常以牺牲较低的图像质量为代价。
strength (float, 可选, 默认值为0.3) — 从概念上讲，表示将参考 image 转换的程度。必须在0和1之间。 image 将用作起点，增加更多噪声的大小为 strength。去噪步数取决于最初添加的噪声量。当 strength 为1时，添加的噪声将最大，去噪过程将运行与 num_inference_steps 中指定的迭代次数完全相同的数量。因此，值为1实际上忽略了 image。
num_inference_steps （int，可选，默认为100）—— 降噪步骤的数量。更多的降噪步骤通常会导致图像质量更高，但推理速度会变慢。
height （int，可选，默认为512）—— 生成图像的像素高度。
width （int，可选，默认为512）—— 生成图像的像素宽度。
prior_guidance_scale (float, 可选，默认为 4.0) — 指导尺度，定义为无分类器扩散指导中的内容。《图片 paper》中的方程 2 定义了 guidance_scale 为 W。指导尺度通过设置 guidance_scale > 1 启用。较高的指导尺度鼓励生成的图像与文本 prompt 密切相关，通常会牺牲图像质量。
prior_num_inference_steps (int, 可选，默认为 100) — 降噪步数。更多的降噪步数通常会以降低推理速度为代价，得到质量更高的图像。
generator (torch.Generator 或 List[torch.Generator], 可选) — 一个或多个torch 生成器（们），用于生成确定性结果。
latents (torch.Tensor, 可选) — 预生成的噪音latents，从高斯分布中采样，用作图像生成的输入。可以用于使用不同的提示修改相同的生成。如果不提供，将使用提供的随机generator生成latents张量。
output_type (str, 可选，默认为"pil") — 生成的图像的输出格式。选择以下之一："pil" (PIL.Image.Image)，"np" (np.array) 或 "pt" (torch.Tensor)。
callback (Callable, 可选) — 在推理过程中的每callback_steps步调 utilisé une fonction. La fonction est appelée avec les arguments suivants: callback(step: int, timestep: int, latents: torch.Tensor).
callback_steps (int, 可选, 默认为 1) — 调用 callback 函数的频率。如果没有指定，则每一步都会调用回调。
return_dict (bool, 可选, 默认为 True) — 是否返回一个 ImagePipelineOutput 而不是一个普通的元组。

ImagePipelineOutput 或 元组

在调用 pipeline 进行生成时触发函数。

示例

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-2-decoder", 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_model_cpu_offload

( gpu_id: 可选 = None device: 联合 = 'cuda' )

使用 accelerate 将所有模型卸载到 CPU，通过低性能影响减少内存使用。相比 enable_sequential_cpu_offload，此方法在调用模型的 forward 方法时将整个模型一次移动到 GPU，直到下一个模型运行，此时模型保持 GPU。内存节省少于 enable_sequential_cpu_offload，但由于 unet 的迭代执行，性能要好得多。

启用_sequential_cpu_offload

( gpu_id: 可选 = None device: 联合 = 'cuda' )

KandinskyV22ControlnetImg2ImgPipeline

类 diffusers.KandinskyV22ControlnetImg2ImgPipeline

( unet: UNet2DConditionModel scheduler: DDPMScheduler movq: VQModel )

参数

scheduler (DDIMScheduler) — 与 unet 结合使用以生成图像潴留的调度器
unet (UNet2DConditionModel) — 用于降噪图像嵌入的条件U-Net架构。
movq (VQModel) — 用于生成图像的MoVQ解码器。

使用Kandinsky进行图像到图像生成的Pipeline

此模型继承自 DiffusionPipeline。请查看超类文档，了解库为所有管道（例如下载或保存、在特定设备上运行等）实现的通用方法。

call

( image_embeds: 联合类型 image: 联合类型 negative_image_embeds: 联合类型 hint: 矩阵 height: int = 512 width: int = 512 num_inference_steps: int = 100 guidance_scale: float = 4.0 strength: float = 0.3 num_images_per_prompt: int = 1 generator: Union = None output_type: Optional = 'pil' callback: Optional = None callback_steps: int = 1 return_dict: bool = True ) → ImagePipelineOutput 或 tuple

参数

image_embeds (torch.Tensor 或 List[torch.Tensor]) — 对文本提示的缩略图嵌入，用于约束图像生成。
image (torch.Tensor, PIL.Image.Image, np.ndarray, List[torch.Tensor], List[PIL.Image.Image], 或 List[np.ndarray]) — 图像，或表示图像批次的张量，将用作过程的起点。也可以接受作为 image 的图像潜变量，如果直接传递潜变量，则不会再次编码。
strength (float, 可选，默认为 0.8) — 从概念上讲，表示要变换参考 image 的程度。必须在 0 和 1 之间。更大的 strength 表示向 image 添加更多的噪声。去噪步骤的数量取决于最初添加的噪声量。当 strength 为 1 时，添加的噪声将达到最大，去噪过程将运行 num_inference_steps 中指定的完整迭代次数。因此，1 的值基本上忽略了 image。
hint (torch.Tensor) — 控制网条件。
negative_image_embeds (torch.Tensor 或 List[torch.Tensor]) — 用于负文本提示的剪图嵌入，将用于图像生成的条件。
height (int，可选，默认为 512) — 生成图像的像素高度。
width (int，可选，默认为 512) — 生成图像的像素宽度。
num_inference_steps (int，可选，默认为 100) — 反噪声步骤的数量。更多的反噪声步骤通常会以较慢的推理速度为代价来提高图像的质量。
guidance_scale (float, 可选，默认为4.0) — 与《无分类器扩散指导》中定义的引导尺度。 guidance_scale是Imagen论文中公式2的w所定义。引导尺度通过设置guidance_scale > 1被启用。更高的引导尺度会鼓励生成与文本prompt紧密相关的图像，通常以牺牲图像质量为代价。
num_images_per_prompt (int, 可选，默认为1) — 每个提示生成的图像数量。
generator (torch.Generator或List[torch.Generator]，可选) — 用于生成确定性的单个或多个torch生成器。
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，可选，默认为1）——callback函数调用的频率。如果不指定，则回调在每个步骤上调用地。
return_dict (bool, 可选，默认为 True) — 是否返回一个 ImagePipelineOutput 而不是原始元组。

ImagePipelineOutput 或 元组

在调用 pipeline 进行生成时触发函数。

示例

KandinskyV22InpaintPipeline

类 diffusers.KandinskyV22InpaintPipeline

< 源码 >

( unet: UNet2DConditionModel scheduler: DDPMScheduler movq: VQModel )

参数

scheduler (DDIMScheduler) — 与 unet 结合使用的调度程序，用于生成图像潜伏量。
unet (UNet2DConditionModel) —— 条件U-Net架构，用于去噪图像嵌套。
movq (VQModel) —— MoVQ解码器，用于从潜在空间生成图像。

基于Kandinsky2.1的文字引导图像修复管道

此模型继承自 DiffusionPipeline。请查看超类文档，了解库为所有管道（例如下载或保存、在特定设备上运行等）实现的通用方法。

call

( image_embeds: 联合 image: 联合 mask_image: 联合 negative_image_embeds: 联合 height: int = 512 width: int = 512 num_inference_steps: int = 100 guidance_scale: float = 4.0 num_images_per_prompt: int = 1 generator: 联合 = None latents: 可选 = None output_type: 可选 = 'pil' return_dict: bool = True callback_on_step_end: 可选 = None callback_on_step_end_tensor_inputs: 列表 = ['latents'] **kwargs ) → ImagePipelineOutput 或 tuple

参数

image_embeds (torch.Tensor 或 List[torch.Tensor]) — 用于图像生成的文本提示的clip图像嵌入，用于条件化图像生成。
image (PIL.Image.Image) — Image，或者表示将要修复的图像批次的张量，即图像的部分将使用mask_image进行遮罩并按照提示进行重新绘制。
mask_image (np.array) — 表示图像批次的张量，用于遮罩image。遮罩中的白色像素将被重新绘制，而黑色像素将被保留。如果mask_image是PIL图像，将在使用之前将其转换为单通道（亮度）。如果是张量，它应包含一个颜色通道（L），而不是3个，预期形状为(B, H, W, 1)。
negative_image_embeds (torch.Tensor 或 List[torch.Tensor]) — 用于逆向文本提示的clip图像嵌入，将用于图像生成条件。
height (int, 可选,默认为 512) — 生成图像的高度（像素）。
width (int, 可选,默认为 512) — 生成图像的宽度（像素）。
num_inference_steps (int, 可选,默认为 100) — 降噪步数。更多的降噪步数通常会导致图像质量更高，但推理速度较慢。
guidance_scale (float, 可选，默认为 4.0) — 指导尺度的定义为 Classifier-Free Diffusion Guidance 中。指导尺度是 Imagen 论文中的方程 2 的 w。当设置 guidance_scale > 1 时启用指导尺度。较高的指导尺度会鼓励生成与文本 prompt 紧密相关的图像，通常以图像质量较低为代价。
num_images_per_prompt (int, 可选，默认为 1) — 每个提示生成图像的数量。
generator (torch.Generator 或 List[torch.Generator], 可选) — 一或多个 torch 生成器用于使生成确定性。
latents (torch.Tensor, 可选) — 预生成的噪声潜变量，从高斯分布中采样，用于图像生成。可用于使用不同提示调整相同的生成。如果没有提供，将使用提供的随机 generator 生成一个潜变量张量。
output_type (str, 可选, 默认为 "pil") — 生成的图像的输出格式。选择项包括："pil" (PIL.Image.Image)，"np" (np.array) 或 "pt" (torch.Tensor)。
return_dict (bool, 可选, 默认为 True) — 是否返回一个 ImagePipelineOutput 而不是一个普通元组。
callback_on_step_end (Callable, 可选) — 在推理过程中每个去噪步骤结束时调用的函数。函数的参数为：callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)。 callback_kwargs 将包含由 callback_on_step_end_tensor_inputs 指定的所有张量。
callback_on_step_end_tensor_inputs (列表, 可选) — 用于 callback_on_step_end 函数的张量输入列表。列表中指定的张量将作为 callback_kwargs 参数传递。您只能包含管线上传类中 ._callback_tensor_inputs 属性列出的变量。

ImagePipelineOutput 或 元组

在调用 pipeline 进行生成时触发函数。

示例

KandinskyV22InpaintCombinedPipeline

类 diffusers.KandinskyV22InpaintCombinedPipeline

参数

调度器 (Union[DDIMScheduler,DDPMScheduler]) — 生成图像潜伏像时要与 unet 配合使用的调度器。
unet (UNet2DConditionModel) — 用于去噪图像嵌入的具有条件的 U-Net 架构。
movq (VQModel) — 用于从潜伏像生成图像的 MoVQ 解码器。
prior_prior (PriorTransformer) — 用于近似文本嵌入到图像嵌入的规范 unCLIP 前导。
prior_image_encoder (CLIPVisionModelWithProjection) — 冻结的图像编码器。
prior_text_encoder (CLIPTextModelWithProjection) — 冻结的文本编码器。
prior_tokenizer (CLIPTokenizer) — CLIPTokenizer 类的标记器。
优先调度器 (UnCLIPScheduler) — 一种调度器，用于与优先结合生成图像嵌入。
优先图像处理器 (CLIPImageProcessor) — 用于从CLIP预处理图像的处理器。

使用Kandinsky进行的修复生成组合流水线

此模型继承自 DiffusionPipeline。请查看超类文档，了解库为所有管道（例如下载或保存、在特定设备上运行等）实现的通用方法。

call

( prompt: 联合 image: 联合 mask_image: 联合 negative_prompt: 联合 = 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: 联合 = None latents: Optional = None output_type: Optional = 'pil' return_dict: bool = True prior_callback_on_step_end: Optional = None prior_callback_on_step_end_tensor_inputs: 列表 = ['latents'] callback_on_step_end: Optional = None callback_on_step_end_tensor_inputs: 列表 = ['latents'] **kwargs ) → ImagePipelineOutput or tuple

参数

prompt (str or List[str]) — 引导图像生成的提示或提示列表。
image (torch.Tensor, PIL.Image.Image, np.ndarray, List[torch.Tensor], List[PIL.Image.Image], 或 List[np.ndarray]) — Image，或表示图像批次的张量，用作处理过程的起始点。也可以接受作为 image 的图像潜变量，如果直接传递潜变量，则不会再次编码。
mask_image (np.array) — 表示图像批次的张量，用于遮罩 image。遮罩中的白色像素将被重绘，而黑色像素将被保留。如果 mask_image 是 PIL 图像，则在使用前将其转换为单通道（亮度）。如果它是张量，它应包含一个颜色通道（L），而不是3个，因此预期的形状应为(B, H, W, 1)。
negative_prompt (str 或 List[str]，可选) — 不指导图像生成的提示或提示词。当不使用引导（即当 guidance_scale 小于 1）时忽略。
num_images_per_prompt （int，可选，默认为1） — 每个提示生成图像的数量。
guidance_scale （float，可选，默认为4.0） — 指导尺度，如《Classifier-Free Diffusion Guidance》中定义。指导尺度被定义为Imagen Paper中的公式2中的w。启用指导尺度可以通过设置guidance_scale > 1来实现。较高的指导尺度可以鼓励生成与文本prompt紧密相关的图像，通常以降低图像质量为代价。
num_inference_steps （int，可选，默认为100） — 方程式的去噪步骤数量。更多的去噪步骤通常会导致图像质量更高，但推理速度会更慢。
高度 (int, 可选, 默认为 512) — 生成的图像的像素高度。
宽度 (int, 可选, 默认为 512) — 生成的图像的像素宽度。
先导指导比例 (float, 可选, 默认为 4.0) — 根据参考文献 Classifier-Free Diffusion Guidance 定义的指导比例。`guidance_scale` 作为方程 2 中的 `w` 在 Imagen 论文中定义。当 `guidance_scale > 1` 时启用指导比例。更高的指导比例会鼓励生成与文本 `提示` 紧密相关联的图像，通常以牺牲图像质量为代价。
prior_num_inference_steps （int，可选，默认为100） — 噪声去除步骤的数量。更多的噪声去除步骤通常会导致图像质量更高，但推理速度会变慢。
generator （torch.Generator 或 List[torch.Generator]，可选） — 一个或多个用于生成确定性结果的 torch 生成器。
latents （torch.Tensor，可选） — 预生成的噪声潜在值，从高斯分布中采样，用作图像生成的输入。可以用于使用不同的提示调节相同的生成。如果没有提供，将使用提供的随机 generator 生成 latents 张量。
output_type （str，可选项，默认为"pil"）—生成的图像的输出格式。可选择以下格式之一："pil"（PIL.Image.Image）、"np"（np.array）或"pt"（torch.Tensor）。
return_dict （bool，可选项，默认为True）—是否返回ImagePipelineOutput对象而不是普通元组。
prior_callback_on_step_end （Callable，可选项）—在推理每个去噪步骤结束时调用的函数。该函数接收以下参数：prior_callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)。
在步骤结束时传输张量的先验回调 (列表，可选) — prior_callback_on_step_end 函数的张量输入列表。列表中指定的张量将作为 callback_kwargs 参数传递。您只能在管道类的 ._callback_tensor_inputs 属性中列出变量。
在每个去噪步骤结束时调用的回调 (可调用，可选) — 在推理过程中每个去噪步骤结束时调用的函数。函数使用以下参数调用：callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)。《callback_kwargs》将包括由 callback_on_step_end_tensor_inputs 指定的所有张量列表。
在步骤结束时传输张量的回调 (列表，可选) — callback_on_step_end 函数的张量输入列表。列表中指定的张量将作为 callback_kwargs 参数传递。您只能在管道类的 ._callback_tensor_inputs 属性中列出变量。

ImagePipelineOutput 或 元组

在调用 pipeline 进行生成时触发函数。

示例

from diffusers import AutoPipelineForInpainting
from diffusers.utils import load_image
import torch
import numpy as np

pipe = AutoPipelineForInpainting.from_pretrained(
    "kandinsky-community/kandinsky-2-2-decoder-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]

启用_sequential_cpu_offload