Kandinsky 2.1
Kandinsky 2.1 由 Arseniy Shakhmatov、Anton Razzhigaev、Aleksandr Nikolich、Vladimir Arkhipkin、Igor Pavlov、Andrey Kuznetsov和Denis Dimitrov 创建。
GitHub 页面的描述是
Kandinsky 2.1 继承了 Dall-E 2 和 Latent diffusion 的最佳实践，同时引入了一些新想法。作为文本和图像编码器，它使用 CLIP 模型和 CLIP 模态的潜在空间的扩散图像先验（映射）。这种方法提高了模型的可视性能，并揭示了图像和文本引导图像操作的新前景。
原始代码库可以在 ai-forever/Kandinsky-2 找到。
请查看 Hub 上的 Kandinsky Community 组织，获取文本到图像、图像到图像和补色的官方模型检查点。
确保查看 调度器指南，了解如何探索调度器速度和质量之间的权衡，并查看在管道之间重用组件部分，了解如何高效地将同一组件加载到多个管道中。
KandinskyPriorPipeline
类 diffusers.KandinskyPriorPipeline
< 源 >( 先验: PriorTransformer 图像编码器: CLIPVisionModelWithProjection 文本编码器: CLIPTextModelWithProjection 分词器: CLIPTokenizer 调度器: UnCLIPScheduler 图像处理器: CLIPImageProcessor )
参数
- prior （PriorTransformer） — 旨在近似从文本嵌入到图像嵌入的标准的 unCLIP 前置。
- image_encoder （
CLIPVisionModelWithProjection） — 冻结的图像编码器。 - text_encoder （
CLIPTextModelWithProjection） — 冻结的文本编码器。 - tokenizer （
CLIPTokenizer） — 属于类 CLIPTokenizer 的标记器。 - 调度器 (
UnCLIPScheduler) — 与prior结合使用以生成图像嵌入的调度器。
Kandinsky 的图像先验生成pipeline
此模型继承自 DiffusionPipeline。请检查超类文档，了解库为所有pipeline实现的通用方法（例如下载或保存、在特定设备上运行等）
__call__
< source >( 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 ) → KandinskyPriorPipelineOutput 或 tuple
参数
- prompt (
str或List[str]) — 指导图像生成的提示或提示列表。 - negative_prompt (
str或List[str], 可选) — 不指导图像生成的提示或提示列表。在不使用指导（即当guidance_scale小于1）时将被忽略。 - num_images_per_prompt (
int, 可选, 默认为 1) — 每个提示生成图像的数量。 - num_inference_steps (
int, 可选, 默认为 25) — 去噪步骤的数量。更多的去噪步骤通常会导致图像质量更高，但推理速度会变慢。 - 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, optional, 默认为"pt") — 生成图像的输出格式。可选择："np"(np.array) 或"pt"(torch.Tensor)。 - return_dict (
bool, optional, 默认为True) — 是否返回 ImagePipelineOutput 而不是普通元组。
返回值
KandinskyPriorPipelineOutput 或 tuple
调用生成过程时执行的函数。
示例
>>> 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
< source >( images_and_prompts: 列表 weights: 列表 num_images_per_prompt: int = 1 num_inference_steps: int = 25 generator: 合集 = None latents: 可选 = None negative_prior_prompt: 可选 = None negative_prompt: str = '' guidance_scale: float = 4.0 device = None ) → KandinskyPriorPipelineOutput 或 tuple
参数
- images_and_prompts (
List[Union[str, PIL.Image.Image, torch.Tensor]]) — 引导图像生成的提示和图像列表。 weights — (List[float]):images_and_prompts中每个条件的权重列表 - num_images_per_prompt (
int, 可选，默认为 1) — 每个提示生成的图像数量。 - num_inference_steps (
int, 可选，默认为25) — 噪声消除步骤的数量。更多的噪声消除步骤通常会导致图像质量更高，但推理速度会变慢。 - 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 论文 方程 2 中的w。当设置guidance_scale > 1时启用引导尺度。更高的引导尺度鼓励生成与文本prompt密切相关的图像，通常以牺牲图像质量为代价。
返回值
KandinskyPriorPipelineOutput 或 tuple
调用先验管道进行插值时调用的函数。
示例
>>> 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
< 来源 >( text_encoder: 多语言CLIP tokenizer: XLMRobertaTokenizer unet: UNet2DConditionModel scheduler: 联合 movq: VQModel )
参数
- text_encoder (
MultilingualCLIP) — 冻结文本编码器。 - tokenizer (
XLMRobertaTokenizer) — 类的标记化器 -
DDIMScheduler,DDPMScheduler]) — 用于与unet结合使用的调度器，以生成图像潜在的值。 - unet (UNet2DConditionModel) — 用于去除图像嵌入的图像 U-Net 建筑师。
- movq (VQModel) — 用于从潜在值生成图像的 MoVQ 解码器。
Kandinsky 图文生成流水线
此模型继承自 DiffusionPipeline。请检查超类文档，了解库为所有pipeline实现的通用方法（例如下载或保存、在特定设备上运行等）
__call__
< source >( prompt: Union image_embeds: Union negative_image_embeds: Union negative_prompt: Union = None height: int = 512 width: int = 512 num_inference_steps: int = 100 guidance_scale: float = 4.0 num_images_per_prompt: int = 1 generator: Union = None latents: Optional = None output_type: Optional = 'pil' callback: Optional = None callback_steps: int = 1 return_dict: bool = True ) → ImagePipelineOutput or tuple
参数
- prompt (
str或List[str]) — 用于指导图像生成的提示或提示列表。 - image_embeds (
torch.Tensor或List[torch.Tensor]) — 用于文本提示的clip图像嵌入，将用于指导图像生成。 - negative_image_embeds (
torch.Tensor或List[torch.Tensor]) — 用于负文本提示的clip图像嵌入，将用于指导图像生成。 - negative_prompt (
str或List[str]，可选) — 不用于指导图像生成的提示或提示列表。当未使用指导（即当guidance_scale小于1时）将被忽略。 - height (
int, 可选, 默认值 512) — 生成图像的像素高度。 - width (
int, 可选, 默认值 512) — 生成图像的像素宽度。 - num_inference_steps (
int, 可选, 默认值 100) — 降噪步数。更多的降噪步骤通常会导致图像质量更高，但推理速度会变慢。 - guidance_scale （
浮点数，可选，默认为4.0） — 引导比例，如无分类器扩散引导中定义。guidance_scale是ImageNet论文中方程2的w的定义。引导比例通过设置guidance_scale > 1启用。更高的引导比例会鼓励生成与文本prompt密切相关的图像，通常以牺牲图像质量为代价。 - num_images_per_prompt （
整数，可选，默认为1） — 每个提示生成图像的数量。 - generator （
torch.Generator或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 或 tuple
调用生成过程时执行的函数。
示例
>>> 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
< source >( text_encoder: MultilingualCLIP tokenizer: XLMRobertaTokenizer unet: UNet2DConditionModel scheduler: Union movq: VQModel prior_prior: PriorTransformer prior_image_encoder: CLIPVisionModelWithProjection prior_text_encoder: CLIPTextModelWithProjection prior_tokenizer: CLIPTokenizer prior_scheduler: UnCLIPScheduler prior_image_processor: CLIPImageProcessor )
参数
- text_encoder (
MultilingualCLIP) — 冷冻文本编码器。 - tokenizer (
XLMRobertaTokenizer) — 类的标记器 - 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 类别的标记化器。 CLIPTokenizer。 - prior_scheduler (
UnCLIPScheduler) — 一个用于与prior结合生成图像嵌入的调度器。
Kandinsky 文本到图像生成联合管道
此模型继承自 DiffusionPipeline。请检查超类文档，了解库为所有pipeline实现的通用方法（例如下载或保存、在特定设备上运行等）
__call__
< source >( 提示: 联合 负提示: 联合 = None 推断步数: int = 100 引导比例: float = 4.0 每个提示的图片数量: int = 1 高度: int = 512 宽度: int = 512 先验引导比例: float = 4.0 先验推断步数: int = 25 生成器: 联合 = None 潜在变量: Optional = None 输出类型: Optional = 'pil' 回调: Optional = None 回调步数: int = 1 返回字典: bool = True ) → ImagePipelineOutput 或 tuple
参数
- 提示 (
str或List[str]) — 引导图像生成的提示或提示列表。 - negative_prompt (
str或List[str], 可选) — 不要指导图像生成的提示或提示列表。如果不使用引导（即，如果guidance_scale小于1），则会被忽略。 - num_images_per_prompt (
int, 可选，默认为 1) — 每个提示生成的图像数量。 - num_inference_steps (
int, 可选，默认为 100) — 降噪步骤的数量。更多的降噪步骤通常会导致图像质量更高，但推理速度会更慢。 - 高度 (
int, 可选, 默认为512) — 生成图像像素的高度。 - 宽度 (
int, 可选, 默认为512) — 生成图像像素的宽度。 - 先验指导比例 (
float, 可选, 默认为4.0) — 如在无分类器扩散指导中定义的指导比例。guidance_scale定义为Imagen 论文中的方程 2 的w。当设置guidance_scale > 1时启用指导比例。较高的指导比例会鼓励生成与文本prompt紧密相关的图像，通常以牺牲图像质量为代价。 - prior_num_inference_steps （
int，可选，默认为100）— 噪声消除步骤的数量。更多的噪声消除步骤通常会获得更高质量的图像，但会以更慢的推理速度为代价。 - guidance_scale （
float，可选，默认为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， 可选）— 预生成的噪声潜变量，从高斯分布中采样，用作图像生成的输入。可用于使用不同的提示调整相同的生成。如果未提供，将通过使用提供的随机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 或 tuple
调用生成过程时执行的函数。
示例
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]使用 🤗 Accelerate 将所有模型 (unet、text_encoder、vae 和 安全检查器 的状态字典) 转移到 CPU，显著减少内存使用。当必需的子模块的 forward 方法被调用时，将模型移动到 torch.device('meta') 并在 GPU 上加载。转移基于子模块级别。内存节省高于使用 enable_model_cpu_offload，但性能较低。
KandinskyImg2ImgPipeline
类 diffusers.KandinskyImg2ImgPipeline
< source >( text_encoder: MultilingualCLIP movq: VQModel tokenizer: XLMRobertaTokenizer unet: UNet2DConditionModel scheduler: DDIMScheduler )
参数
- text_encoder (
MultilingualCLIP) — 冻结的文本编码器。 - tokenizer (
XLMRobertaTokenizer) — 类的Tokenizer - scheduler (DDIMScheduler) — 与
unet一起使用的调度器以生成图像隐式数据 - unet (UNet2DConditionModel) — 用于去噪图像嵌入的条件U-Net架构
- movq (VQModel) — MoVQ图像编码器和解码器
使用Kandinsky进行图像到图像生成的流水线
此模型继承自 DiffusionPipeline。请检查超类文档，了解库为所有pipeline实现的通用方法（例如下载或保存、在特定设备上运行等）
__call__
< source >( prompt(提示): Union image(图像): Union image_embeds(图像嵌入): Tensor negative_image_embeds(负图像嵌入): Tensor negative_prompt(负提示)Union = 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(生成器): Union = None output_type(输出类型): Optional = 'pil' callback(回调): Optional = None callback_steps(回调步骤): int = 1 return_dict(返回字典): bool = True ) → ImagePipelineOutput or tuple
参数
- prompt (
str或List[str]) — 指引图像生成的提示或提示列表。 - image (
torch.Tensor或PIL.Image.Image) — 作为处理起始点的图像或表示图像批次的张量。 - image_embeds (
torch.Tensor或List[torch.Tensor]) — 用于条件图像生成的文本提示的clip图像嵌入。 - negative_image_embeds (
torch.Tensor或List[torch.Tensor]) — 用于条件图像生成的否定文本提示的clip图像嵌入。 - negative_prompt (
str或List[str]，可选) — 不用于引导图像生成的提示或提示列表。在使用引导（即，如果guidance_scale小于1）时将被忽略。 - height (
int，可选，默认为 512) — 生成图像的像素高度。 - width (
int，可选，默认为 512) — 生成图像的像素宽度。 - num_inference_steps （
int，可选，默认为100）- 降噪步骤的数量。更多的降噪步骤通常会导致图像质量更高，但推理速度会变慢。 - strength （
float，可选，默认为0.3）- 从概念上讲，表示要多少地转换参考image。必须在0到1之间。以image作为起点，增加更多噪声，当strength增加时。降噪步骤的数量取决于最初添加的噪声量。当strength为1时，增加的噪声将最大化，降噪过程将以num_inference_steps中指定的完整迭代次数运行。因此，值为1实际上忽略了image。 - guidance_scale （
float，可选，默认为4.0）- 如文献Classifier-Free Diffusion Guidance中定义的指导尺度。guidance_scale是文献Imagen Paper中方程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 或 tuple
调用生成过程时执行的函数。
示例
>>> 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
< source >( text_encoder: MultilingualCLIP tokenizer: XLMRobertaTokenizer unet: UNet2DConditionModel scheduler: Union movq: VQModel prior_prior: PriorTransformer prior_image_encoder: CLIPVisionModelWithProjection prior_text_encoder: CLIPTextModelWithProjection prior_tokenizer: CLIPTokenizer prior_scheduler: UnCLIPScheduler prior_image_processor: CLIPImageProcessor )
参数
- text_encoder (
MultilingualCLIP) — 冻结的文本编码器。 - tokenizer (
XLMRobertaTokenizer) — 类 - scheduler (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类实现的标记化器。 - prior_scheduler (
UnCLIPScheduler) — 用于与结合以生成图像嵌入的调度器。
使用Kandinsky进行图像到图像生成的combined pipeline
此模型继承自 DiffusionPipeline。请检查超类文档，了解库为所有pipeline实现的通用方法（例如下载或保存、在特定设备上运行等）
__call__
< source >( prompt: Union image: Union negative_prompt: Union = 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: Union = None latents: Optional = None output_type: Optional = 'pil' callback: Optional = None callback_steps: int = 1 return_dict: bool = True ) → 导出const metadata = 'undefined';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）— 每个提示生成图像的数量。
- num_inference_steps（《int》，《可选》，默认为 100）— 降噪步骤的数量。更多的降噪步骤通常会导致图像质量更高，但同时推理速度会减慢。
- height（《int》，《可选》，默认为 512）— 生成图像的像素高度。
- width（《int》，《可选》，默认为 512）— 生成图像的像素宽度。
- strength (
float, 可选, 默认为 0.3) — 从概念上讲，表示要转换参考image的程度。必须在 0 和 1 之间。将作为起始点使用image，而strength值越大，添加的噪声越多。去噪步数取决于最初添加的噪声量。当strength为 1 时，添加的噪声最大，去噪过程将运行num_inference_steps中指定的迭代次数。因此，1 的值实际上忽略了image。 - prior_guidance_scale (
float, 可选, 默认为 4.0) — 根据 Classifier-Free Diffusion Guidance 中定义的指导缩放比例。指导缩放比例定义为 Imagen 论文 第 2 个方程中的w。通过设置guidance_scale > 1启用指导缩放比例。较高的指导缩放比例鼓励生成与文本prompt密切相关的图像，这通常以降低图像质量为代价。 - prior_num_inference_steps (
int, 可选, 默认为 100) — 去噪步数。更多的去噪步骤通常会导致图像质量更高，但这要以较慢的推理速度为代价。 - guidance_scale (
float, 可选, 默认为 4.0) — 指导缩放比例，如《无分类器扩散指导》中定义。指导缩放比例是源自《Imagen 论文》方程 2 中的W。通过设置guidance_scale > 1启用指导缩放比例。更高的指导缩放比例会鼓励生成与文本prompt关联更紧密的图像，通常以牺牲较低的图像质量为代价。 - generator (
torch.Generator或List[torch.Generator], 可选) — 一个或多个 torch generator 用于使生成过程确定。 - 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 或 tuple
调用生成过程时执行的函数。
示例
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]使用 accelerate 将所有模型卸载到 CPU，显著减少内存使用。当调用时，unet、text_encoder、vae和安全检查器的状态字典被保存到 CPU，然后在它们的特定子模块调用 forward 方法时才加载到 GPU。注意，卸载是在子模块基础上发生的。内存节省量比 `enable_model_cpu_offload` 更大，但性能更低。
KandinskyInpaintPipeline
类 diffusers.KandinskyInpaintPipeline
< 源码 >( text_encoder: MultilingualCLIP movq: VQModel tokenizer: XLMRobertaTokenizer unet: UNet2DConditionModel scheduler: DDIMScheduler )
参数
- text_encoder (
MultilingualCLIP) — 冻结的文本编码器。 - tokenizer (
XLMRobertaTokenizer) — 类 - scheduler (DDIMScheduler) — 与
unet结合使用的调度器，用于生成图像潜在空间。 - unet (UNet2DConditionModel) — 用于去除图像嵌入的条件的U-Net架构。
- movq (VQModel) — MoVQ图像编码器和解码器
使用Kandinsky2.1进行文本引导图像修复的管道
此模型继承自 DiffusionPipeline。请检查超类文档，了解库为所有pipeline实现的通用方法（例如下载或保存、在特定设备上运行等）
__call__
< source >( prompt: 并集 image: 并集 mask_image: 并集 image_embeds: 张量 negative_image_embeds: 张量 negative_prompt: 并集 = None 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]) — 引导图像生成的提示或提示列表。 - image (
torch.Tensor,PIL.Image.Image或np.ndarray) —Image或表示图像批次的张量，用作处理的起始点。 - mask_image (
PIL.Image.Image,torch.Tensor或np.ndarray) —Image或表示图像批次的张量，用于隐藏image。掩码中的白色像素将被重绘，而黑色像素将被保留。如果图像是 PyTorch 张量，则可以传递 pytorch 张量作为掩码，并且它应包含一个颜色通道（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]) — 用于条件图像生成的文本提示的 clip 图像嵌入。 - 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) — 指导比例，如无分类器扩散指导中定义。指导比例如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, optional, defaults toTrue) — 是否返回ImagePipelineOutput而不是简单的元组。
返回值
ImagePipelineOutput 或 tuple
调用生成过程时执行的函数。
示例
>>> 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
< 来源 >( text_encoder: MultilingualCLIP tokenizer: XLMRobertaTokenizer unet: UNet2DConditionModel scheduler: Union movq: VQModel prior_prior: PriorTransformer prior_image_encoder: CLIPVisionModelWithProjection prior_text_encoder: CLIPTextModelWithProjection prior_tokenizer: CLIPTokenizer prior_scheduler: UnCLIPScheduler prior_image_processor: CLIPImageProcessor )
参数
- text_encoder (
MultilingualCLIP) — 冻结文本编码器。 - tokenizer (
XLMRobertaTokenizer) — 类的划分器。 - scheduler (Union[
DDIMScheduler,DDPMScheduler]) — 结合unet生成图像潜在值的调度器。 - unet (UNet2DConditionModel) — 用于去噪图像嵌入的条件 U-Net 架构。
- movq (VQModel) — 用于从潜在变量生成图像的MoVQ解码器。
- prior_prior (PriorTransformer) — 用于近似文本嵌入到图像嵌入的规范unCLIP先验。
- prior_image_encoder (
CLIPVisionModelWithProjection) — 冻结的图像编码器。 - prior_text_encoder (
CLIPTextModelWithProjection) — 冻结的文本编码器。 - 先验_tokenizer (
CLIPTokenizer) — CLIPTokenizer 类的 Tokenizer。 - 先验_scheduler (
UnCLIPScheduler) — 一个与prior结合使用以生成图像嵌入的调度器。
Kandinsky 用于生成的联合流水线
此模型继承自 DiffusionPipeline。请检查超类文档，了解库为所有pipeline实现的通用方法（例如下载或保存、在特定设备上运行等）
__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: 可选 = None output_type: 可选 = 'pil' callback: 可选 = None callback_steps: int = 1 return_dict: bool = True ) → ImagePipelineOutput or tuple
参数
- prompt （
str或List[str]）— 引导图像生成的提示或提示列表。 - image (
torch.Tensor,PIL.Image.Image,np.ndarray,List[torch.Tensor],List[PIL.Image.Image], 或List[np.ndarray]) — 包含图像或图像批次的 Tensor，用作处理过程的起始点。也可以接受作为image的图像隐式，如果直接传递隐式，则不会再次编码。 - mask_image (
np.array) — 用以遮罩image的图像批次的 Tensor。遮罩中的白色像素将被重新绘制，而黑色像素将被保留。如果mask_image是 PIL 图像，则在使用之前将其转换为单通道（亮度）。如果它是一个 Tensor，则应包含一个颜色通道（L），而不是三个，因此期望的形状将为(B, H, W, 1)。 - 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中定义的引导比例。《Imagen Paper` 中的指引比例定义为方程2的w。引导比例通过设置guidance_scale > 1启用。更高的引导比例会鼓励生成与文本prompt紧密相关的图像，这通常以较低的图像质量为代价。 - prior_num_inference_steps （
int，可选，默认值100） — 降噪步骤的数量。更多的降噪步骤通常会导致图像质量更高，但推理速度会变慢。 - guidance_scale (
float, 可选, 默认值为 4.0) — 指导尺度，如《无分类器扩散引导》[Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598) 中定义。guidance_scale是《Imagen 论文》中方程 2 中的w。指导尺度通过设置guidance_scale > 1来启用。更高的指导尺度鼓励生成与文本prompt紧密相关的图像，通常以牺牲较低的图像质量为代价。 - generator (
torch.Generator或List[torch.Generator], 可选) — 一个或多个 torch 生成器，用于使生成过程确定。 - latents (
torch.Tensor, 可选) — 预生成的噪声先验，从高斯分布中采样，用于图像生成的输入。可用于使用不同的prompt来调整相同的生成。如果没有提供，将通过使用提供的随机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, optional, 默认为True) — 是否返回 ImagePipelineOutput 而不是纯元组。
返回值
ImagePipelineOutput 或 tuple
调用生成过程时执行的函数。
示例
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]使用 accelerate 将所有模型卸载到 CPU，显著减少内存使用。当调用时，unet、text_encoder、vae和安全检查器的状态字典被保存到 CPU，然后在它们的特定子模块调用 forward 方法时才加载到 GPU。注意，卸载是在子模块基础上发生的。内存节省量比 `enable_model_cpu_offload` 更大，但性能更低。