Diffusers 文档

DeepFloyd IF

Diffusers

加入 Hugging Face 社区

并获得增强型文档体验

协作模型、数据集和空间

使用加速推理获得更快的示例

在文档主题之间切换

开始使用

DeepFloyd IF

概述

DeepFloyd IF 是一款新颖的、最先进的开源文本到图像模型，具有高度的真实感和语言理解能力。该模型采用模块化设计，由一个冻结的文本编码器和三个级联像素扩散模块组成。

阶段 1：一个基础模型，根据文本提示生成 64x64 像素的图像，
阶段 2：一个 64x64 像素 => 256x256 像素的超分辨率模型，以及
阶段 3：一个 256x256 像素 => 1024x1024 像素的超分辨率模型。阶段 1 和阶段 2 利用基于 T5 变压器的冻结文本编码器来提取文本嵌入，然后将其馈送到增强了交叉注意力和注意力池化的 UNet 架构中。阶段 3 是 Stability AI 的 x4 上采样模型。结果是一个高效的模型，其性能优于当前最先进的模型，在 COCO 数据集上实现了 6.66 的零样本 FID 分数。我们的工作强调了更大的 UNet 架构在级联扩散模型第一阶段的潜力，并描绘了文本到图像合成的光明未来。

使用

在使用 IF 之前，您需要接受其使用条款。为此

确保拥有一个 Hugging Face 帐户并登录。
在 DeepFloyd/IF-I-XL-v1.0 的模型卡片上接受许可证。接受阶段 I 模型卡片上的许可证将自动接受其他 IF 模型的许可证。
确保本地登录。安装 huggingface_hub

pip install huggingface_hub --upgrade

在 Python shell 中运行登录函数

from huggingface_hub import login

login()

并输入您的 Hugging Face Hub 访问令牌。

接下来，我们安装 diffusers 及其依赖项

pip install -q diffusers accelerate transformers

以下部分将更详细地介绍如何使用 IF。具体来说

文本到图像生成
图像到图像生成
修复
重用模型权重
速度优化
内存优化

可用检查点

阶段 1
阶段 2
- DeepFloyd/IF-II-L-v1.0
- DeepFloyd/IF-II-M-v1.0
阶段 3
- stabilityai/stable-diffusion-x4-upscaler

Google Colab

文本到图像生成

默认情况下，diffusers 利用模型 CPU 卸载来运行整个 IF 管道，只需 14 GB 的 VRAM。

from diffusers import DiffusionPipeline
from diffusers.utils import pt_to_pil, make_image_grid
import torch

# stage 1
stage_1 = DiffusionPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0", variant="fp16", torch_dtype=torch.float16)
stage_1.enable_model_cpu_offload()

# stage 2
stage_2 = DiffusionPipeline.from_pretrained(
    "DeepFloyd/IF-II-L-v1.0", text_encoder=None, variant="fp16", torch_dtype=torch.float16
)
stage_2.enable_model_cpu_offload()

# stage 3
safety_modules = {
    "feature_extractor": stage_1.feature_extractor,
    "safety_checker": stage_1.safety_checker,
    "watermarker": stage_1.watermarker,
}
stage_3 = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-x4-upscaler", **safety_modules, torch_dtype=torch.float16
)
stage_3.enable_model_cpu_offload()

prompt = 'a photo of a kangaroo wearing an orange hoodie and blue sunglasses standing in front of the eiffel tower holding a sign that says "very deep learning"'
generator = torch.manual_seed(1)

# text embeds
prompt_embeds, negative_embeds = stage_1.encode_prompt(prompt)

# stage 1
stage_1_output = stage_1(
    prompt_embeds=prompt_embeds, negative_prompt_embeds=negative_embeds, generator=generator, output_type="pt"
).images
#pt_to_pil(stage_1_output)[0].save("./if_stage_I.png")

# stage 2
stage_2_output = stage_2(
    image=stage_1_output,
    prompt_embeds=prompt_embeds,
    negative_prompt_embeds=negative_embeds,
    generator=generator,
    output_type="pt",
).images
#pt_to_pil(stage_2_output)[0].save("./if_stage_II.png")

# stage 3
stage_3_output = stage_3(prompt=prompt, image=stage_2_output, noise_level=100, generator=generator).images
#stage_3_output[0].save("./if_stage_III.png")
make_image_grid([pt_to_pil(stage_1_output)[0], pt_to_pil(stage_2_output)[0], stage_3_output[0]], rows=1, rows=3)

文本引导图像到图像生成

相同的 IF 模型权重可用于文本引导的图像到图像转换或图像变化。在这种情况下，只需确保使用 IFImg2ImgPipeline 和 IFImg2ImgSuperResolutionPipeline 管道加载权重。

注意：您还可以通过利用 components 参数（如此处所述）直接将文本到图像管道的权重移动到图像到图像管道，而无需加载两次。

from diffusers import IFImg2ImgPipeline, IFImg2ImgSuperResolutionPipeline, DiffusionPipeline
from diffusers.utils import pt_to_pil, load_image, make_image_grid
import torch

# 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))

# stage 1
stage_1 = IFImg2ImgPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0", variant="fp16", torch_dtype=torch.float16)
stage_1.enable_model_cpu_offload()

# stage 2
stage_2 = IFImg2ImgSuperResolutionPipeline.from_pretrained(
    "DeepFloyd/IF-II-L-v1.0", text_encoder=None, variant="fp16", torch_dtype=torch.float16
)
stage_2.enable_model_cpu_offload()

# stage 3
safety_modules = {
    "feature_extractor": stage_1.feature_extractor,
    "safety_checker": stage_1.safety_checker,
    "watermarker": stage_1.watermarker,
}
stage_3 = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-x4-upscaler", **safety_modules, torch_dtype=torch.float16
)
stage_3.enable_model_cpu_offload()

prompt = "A fantasy landscape in style minecraft"
generator = torch.manual_seed(1)

# text embeds
prompt_embeds, negative_embeds = stage_1.encode_prompt(prompt)

# stage 1
stage_1_output = stage_1(
    image=original_image,
    prompt_embeds=prompt_embeds,
    negative_prompt_embeds=negative_embeds,
    generator=generator,
    output_type="pt",
).images
#pt_to_pil(stage_1_output)[0].save("./if_stage_I.png")

# stage 2
stage_2_output = stage_2(
    image=stage_1_output,
    original_image=original_image,
    prompt_embeds=prompt_embeds,
    negative_prompt_embeds=negative_embeds,
    generator=generator,
    output_type="pt",
).images
#pt_to_pil(stage_2_output)[0].save("./if_stage_II.png")

# stage 3
stage_3_output = stage_3(prompt=prompt, image=stage_2_output, generator=generator, noise_level=100).images
#stage_3_output[0].save("./if_stage_III.png")
make_image_grid([original_image, pt_to_pil(stage_1_output)[0], pt_to_pil(stage_2_output)[0], stage_3_output[0]], rows=1, rows=4)

文本引导修复生成

相同的 IF 模型权重可用于文本引导的图像到图像转换或图像变化。在这种情况下，只需确保使用 IFInpaintingPipeline 和 IFInpaintingSuperResolutionPipeline 管道加载权重。

注意：您还可以通过利用 ~DiffusionPipeline.components() 函数（如此处所述）直接将文本到图像管道的权重移动到图像到图像管道，而无需加载两次。

from diffusers import IFInpaintingPipeline, IFInpaintingSuperResolutionPipeline, DiffusionPipeline
from diffusers.utils import pt_to_pil, load_image, make_image_grid
import torch

# download image
url = "https://huggingface.co/datasets/diffusers/docs-images/resolve/main/if/person.png"
original_image = load_image(url)

# download mask
url = "https://huggingface.co/datasets/diffusers/docs-images/resolve/main/if/glasses_mask.png"
mask_image = load_image(url)

# stage 1
stage_1 = IFInpaintingPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0", variant="fp16", torch_dtype=torch.float16)
stage_1.enable_model_cpu_offload()

# stage 2
stage_2 = IFInpaintingSuperResolutionPipeline.from_pretrained(
    "DeepFloyd/IF-II-L-v1.0", text_encoder=None, variant="fp16", torch_dtype=torch.float16
)
stage_2.enable_model_cpu_offload()

# stage 3
safety_modules = {
    "feature_extractor": stage_1.feature_extractor,
    "safety_checker": stage_1.safety_checker,
    "watermarker": stage_1.watermarker,
}
stage_3 = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-x4-upscaler", **safety_modules, torch_dtype=torch.float16
)
stage_3.enable_model_cpu_offload()

prompt = "blue sunglasses"
generator = torch.manual_seed(1)

# text embeds
prompt_embeds, negative_embeds = stage_1.encode_prompt(prompt)

# stage 1
stage_1_output = stage_1(
    image=original_image,
    mask_image=mask_image,
    prompt_embeds=prompt_embeds,
    negative_prompt_embeds=negative_embeds,
    generator=generator,
    output_type="pt",
).images
#pt_to_pil(stage_1_output)[0].save("./if_stage_I.png")

# stage 2
stage_2_output = stage_2(
    image=stage_1_output,
    original_image=original_image,
    mask_image=mask_image,
    prompt_embeds=prompt_embeds,
    negative_prompt_embeds=negative_embeds,
    generator=generator,
    output_type="pt",
).images
#pt_to_pil(stage_1_output)[0].save("./if_stage_II.png")

# stage 3
stage_3_output = stage_3(prompt=prompt, image=stage_2_output, generator=generator, noise_level=100).images
#stage_3_output[0].save("./if_stage_III.png")
make_image_grid([original_image, mask_image, pt_to_pil(stage_1_output)[0], pt_to_pil(stage_2_output)[0], stage_3_output[0]], rows=1, rows=5)

在不同管道之间转换

除了使用 from_pretrained 加载外，管道还可以直接从彼此加载。

from diffusers import IFPipeline, IFSuperResolutionPipeline

pipe_1 = IFPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0")
pipe_2 = IFSuperResolutionPipeline.from_pretrained("DeepFloyd/IF-II-L-v1.0")


from diffusers import IFImg2ImgPipeline, IFImg2ImgSuperResolutionPipeline

pipe_1 = IFImg2ImgPipeline(**pipe_1.components)
pipe_2 = IFImg2ImgSuperResolutionPipeline(**pipe_2.components)


from diffusers import IFInpaintingPipeline, IFInpaintingSuperResolutionPipeline

pipe_1 = IFInpaintingPipeline(**pipe_1.components)
pipe_2 = IFInpaintingSuperResolutionPipeline(**pipe_2.components)

优化速度

运行 IF 更快的最简单优化是将所有模型组件移动到 GPU。

pipe = DiffusionPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0", variant="fp16", torch_dtype=torch.float16)
pipe.to("cuda")

您还可以将扩散过程运行更少的步数。

这可以通过 num_inference_steps 参数完成

pipe("<prompt>", num_inference_steps=30)

或 timesteps 参数完成

from diffusers.pipelines.deepfloyd_if import fast27_timesteps

pipe("<prompt>", timesteps=fast27_timesteps)

在进行图像变化或修复时，您还可以使用 strength 参数减少步数。strength 参数是要添加到输入图像中的噪声量，它也决定了在去噪过程中运行的步数。较小的数字会使图像变化较小，但运行速度更快。

pipe = IFImg2ImgPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0", variant="fp16", torch_dtype=torch.float16)
pipe.to("cuda")

image = pipe(image=image, prompt="<prompt>", strength=0.3).images

您还可以使用 torch.compile。请注意，我们尚未对 IF 彻底测试 torch.compile，它可能无法提供预期的结果。

from diffusers import DiffusionPipeline
import torch

pipe = DiffusionPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0", variant="fp16", torch_dtype=torch.float16)
pipe.to("cuda")

pipe.text_encoder = torch.compile(pipe.text_encoder, mode="reduce-overhead", fullgraph=True)
pipe.unet = torch.compile(pipe.unet, mode="reduce-overhead", fullgraph=True)

优化内存

在优化 GPU 内存时，我们可以使用标准的 diffusers CPU 卸载 API。

无论是基于模型的 CPU 卸载，

pipe = DiffusionPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0", variant="fp16", torch_dtype=torch.float16)
pipe.enable_model_cpu_offload()

还是更激进的基于层的 CPU 卸载。

pipe = DiffusionPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0", variant="fp16", torch_dtype=torch.float16)
pipe.enable_sequential_cpu_offload()

此外，T5 可以以 8 位精度加载。

from transformers import T5EncoderModel

text_encoder = T5EncoderModel.from_pretrained(
    "DeepFloyd/IF-I-XL-v1.0", subfolder="text_encoder", device_map="auto", load_in_8bit=True, variant="8bit"
)

from diffusers import DiffusionPipeline

pipe = DiffusionPipeline.from_pretrained(
    "DeepFloyd/IF-I-XL-v1.0",
    text_encoder=text_encoder,  # pass the previously instantiated 8bit text encoder
    unet=None,
    device_map="auto",
)

prompt_embeds, negative_embeds = pipe.encode_prompt("<prompt>")

对于像 Google Colab 免费层这样的 CPU 内存受限的机器，我们无法一次将所有模型组件加载到 CPU 上，我们可以手动仅在需要相应模型组件时加载带有文本编码器或 UNet 的管道。

from diffusers import IFPipeline, IFSuperResolutionPipeline
import torch
import gc
from transformers import T5EncoderModel
from diffusers.utils import pt_to_pil, make_image_grid

text_encoder = T5EncoderModel.from_pretrained(
    "DeepFloyd/IF-I-XL-v1.0", subfolder="text_encoder", device_map="auto", load_in_8bit=True, variant="8bit"
)

# text to image
pipe = DiffusionPipeline.from_pretrained(
    "DeepFloyd/IF-I-XL-v1.0",
    text_encoder=text_encoder,  # pass the previously instantiated 8bit text encoder
    unet=None,
    device_map="auto",
)

prompt = 'a photo of a kangaroo wearing an orange hoodie and blue sunglasses standing in front of the eiffel tower holding a sign that says "very deep learning"'
prompt_embeds, negative_embeds = pipe.encode_prompt(prompt)

# Remove the pipeline so we can re-load the pipeline with the unet
del text_encoder
del pipe
gc.collect()
torch.cuda.empty_cache()

pipe = IFPipeline.from_pretrained(
    "DeepFloyd/IF-I-XL-v1.0", text_encoder=None, variant="fp16", torch_dtype=torch.float16, device_map="auto"
)

generator = torch.Generator().manual_seed(0)
stage_1_output = pipe(
    prompt_embeds=prompt_embeds,
    negative_prompt_embeds=negative_embeds,
    output_type="pt",
    generator=generator,
).images

#pt_to_pil(stage_1_output)[0].save("./if_stage_I.png")

# Remove the pipeline so we can load the super-resolution pipeline
del pipe
gc.collect()
torch.cuda.empty_cache()

# First super resolution

pipe = IFSuperResolutionPipeline.from_pretrained(
    "DeepFloyd/IF-II-L-v1.0", text_encoder=None, variant="fp16", torch_dtype=torch.float16, device_map="auto"
)

generator = torch.Generator().manual_seed(0)
stage_2_output = pipe(
    image=stage_1_output,
    prompt_embeds=prompt_embeds,
    negative_prompt_embeds=negative_embeds,
    output_type="pt",
    generator=generator,
).images

#pt_to_pil(stage_2_output)[0].save("./if_stage_II.png")
make_image_grid([pt_to_pil(stage_1_output)[0], pt_to_pil(stage_2_output)[0]], rows=1, rows=2)

可用管道：

管道	任务	Colab
pipeline_if.py	文本到图像生成	-
pipeline_if_superresolution.py	文本到图像生成	-
pipeline_if_img2img.py	图像到图像生成	-
pipeline_if_img2img_superresolution.py	图像到图像生成	-
pipeline_if_inpainting.py	图像到图像生成	-
pipeline_if_inpainting_superresolution.py	图像到图像生成	-

IFPipeline

类 diffusers.IFPipeline

< 源代码 >

( tokenizer: T5Tokenizer text_encoder: T5EncoderModel unet: UNet2DConditionModel scheduler: DDPMScheduler safety_checker: 可选 feature_extractor: 可选 watermarker: 可选 requires_safety_checker: bool = True )

call

< 源代码 >

( prompt: Union = None num_inference_steps: int = 100 timesteps: List = None guidance_scale: float = 7.0 negative_prompt: Union = None num_images_per_prompt: 可选 = 1 height: 可选 = None width: 可选 = None eta: float = 0.0 generator: Union = None prompt_embeds: 可选 = None negative_prompt_embeds: 可选 = None output_type: 可选 = 'pil' return_dict: bool = True callback: 可选 = None callback_steps: int = 1 clean_caption: bool = True cross_attention_kwargs: 可选 = None ) → ~pipelines.stable_diffusion.IFPipelineOutput 或 元组

参数

prompt (str 或 List[str], 可选) — 指导图像生成的提示或提示。如果未定义，则必须传递 prompt_embeds. 代替。
num_inference_steps (int, 可选，默认为 100) — 降噪步骤的数量。更多的降噪步骤通常会导致更高的图像质量，但推理速度会变慢。
timesteps (List[int], 可选) — 用于降噪过程的自定义时间步长。如果未定义，则使用等间距的 num_inference_steps 时间步长。必须按降序排列。
guidance_scale (float，可选，默认为 7.0) — 如 Classifier-Free Diffusion Guidance 中所定义的引导尺度。guidance_scale 定义为 Imagen 论文公式 2 中的 w。通过设置 guidance_scale > 1 来启用引导尺度。较高的引导尺度会鼓励生成与文本 prompt 密切相关的图像，通常以降低图像质量为代价。
negative_prompt (str 或 List[str]，可选) — 不引导图像生成的提示或提示。如果未定义，则必须传递 negative_prompt_embeds。在不使用引导时被忽略（即，如果 guidance_scale 小于 1 则被忽略）。
num_images_per_prompt (int，可选，默认为 1) — 每个提示生成图像的数量。
height (int，可选，默认为 self.unet.config.sample_size) — 生成图像的高度（以像素为单位）。
width (int，可选，默认为 self.unet.config.sample_size) — 生成图像的宽度（以像素为单位）。
eta (float，可选，默认为 0.0) — 对应于 DDIM 论文中的参数 eta (η)：https://arxiv.org/abs/2010.02502。仅适用于 schedulers.DDIMScheduler，其他情况将被忽略。
generator (torch.Generator 或 List[torch.Generator]，可选) — 一个或一列 torch 生成器，用于使生成确定性。
prompt_embeds (torch.Tensor，可选) — 预生成的文本嵌入。可用于轻松调整文本输入，例如提示加权。如果未提供，则将根据 prompt 输入参数生成文本嵌入。
negative_prompt_embeds (torch.Tensor，可选) — 预生成的负文本嵌入。可用于轻松调整文本输入，例如提示加权。如果未提供，则将根据 negative_prompt 输入参数生成 negative_prompt_embeds。
output_type (str，可选，默认为 "pil") — 生成图像的输出格式。在 PIL：PIL.Image.Image 或 np.array 之间选择。
callback (Callable，可选) — 推理过程中每隔 callback_steps 步调用一次的函数。该函数将使用以下参数调用：callback(step: int, timestep: int, latents: torch.Tensor)。
callback_steps (int，可选，默认为 1) — callback 函数的调用频率。如果未指定，则回调函数将在每个步骤中调用。
clean_caption (bool，可选，默认为 True) — 是否在创建嵌入之前清理标题。需要安装 beautifulsoup4 和 ftfy。如果未安装依赖项，则将根据原始提示创建嵌入。
cross_attention_kwargs (dict，可选) — 如果指定，则传递给 AttentionProcessor 的关键字参数字典，如 diffusers.models.attention_processor 中 self.processor 下定义的那样。

~pipelines.stable_diffusion.IFPipelineOutput 或 tuple

如果 return_dict 为 True，则返回 ~pipelines.stable_diffusion.IFPipelineOutput，否则返回 tuple。当返回元组时，第一个元素是包含生成图像的列表，第二个元素是 bool 值的列表，根据 safety_checker 表示相应的生成图像是否可能包含“不适合工作场所”（nsfw）或水印内容。

调用管道进行生成时调用的函数。

示例

>>> from diffusers import IFPipeline, IFSuperResolutionPipeline, DiffusionPipeline
>>> from diffusers.utils import pt_to_pil
>>> import torch

>>> pipe = IFPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0", variant="fp16", torch_dtype=torch.float16)
>>> pipe.enable_model_cpu_offload()

>>> prompt = 'a photo of a kangaroo wearing an orange hoodie and blue sunglasses standing in front of the eiffel tower holding a sign that says "very deep learning"'
>>> prompt_embeds, negative_embeds = pipe.encode_prompt(prompt)

>>> image = pipe(prompt_embeds=prompt_embeds, negative_prompt_embeds=negative_embeds, output_type="pt").images

>>> # save intermediate image
>>> pil_image = pt_to_pil(image)
>>> pil_image[0].save("./if_stage_I.png")

>>> super_res_1_pipe = IFSuperResolutionPipeline.from_pretrained(
...     "DeepFloyd/IF-II-L-v1.0", text_encoder=None, variant="fp16", torch_dtype=torch.float16
... )
>>> super_res_1_pipe.enable_model_cpu_offload()

>>> image = super_res_1_pipe(
...     image=image, prompt_embeds=prompt_embeds, negative_prompt_embeds=negative_embeds, output_type="pt"
... ).images

>>> # save intermediate image
>>> pil_image = pt_to_pil(image)
>>> pil_image[0].save("./if_stage_I.png")

>>> safety_modules = {
...     "feature_extractor": pipe.feature_extractor,
...     "safety_checker": pipe.safety_checker,
...     "watermarker": pipe.watermarker,
... }
>>> super_res_2_pipe = DiffusionPipeline.from_pretrained(
...     "stabilityai/stable-diffusion-x4-upscaler", **safety_modules, torch_dtype=torch.float16
... )
>>> super_res_2_pipe.enable_model_cpu_offload()

>>> image = super_res_2_pipe(
...     prompt=prompt,
...     image=image,
... ).images
>>> image[0].save("./if_stage_II.png")

encode_prompt

< source >

( prompt: Union do_classifier_free_guidance: bool = True num_images_per_prompt: int = 1 device: Optional = None negative_prompt: Union = None prompt_embeds: Optional = None negative_prompt_embeds: Optional = None clean_caption: bool = False )

参数

prompt (str 或 List[str]，可选) — 要编码的提示
do_classifier_free_guidance (bool，可选，默认为 True) — 是否使用分类器自由引导
num_images_per_prompt (int，可选，默认为 1) — 每个提示应生成的图像数量 device — (torch.device，可选)：将生成的嵌入放置到的 Torch 设备
negative_prompt (str 或 List[str]，可选) — 不用于引导图像生成的提示或提示。如果未定义，则必须传递 negative_prompt_embeds。如果未定义，则必须传递 negative_prompt_embeds。在不使用引导时被忽略（即，如果 guidance_scale 小于 1，则被忽略）。
negative_prompt_embeds (torch.Tensor, 可选) — 预生成的负面文本嵌入。可用于轻松调整文本输入，例如提示加权。如果未提供，则将从negative_prompt输入参数生成negative_prompt_embeds。
clean_caption (bool, 默认为 False) — 如果为 True，则函数将在编码前预处理并清理提供的标题。

将提示编码为文本编码器隐藏状态。

IFSuperResolutionPipeline

类 diffusers.IFSuperResolutionPipeline

< 源代码 >

( tokenizer: T5Tokenizer text_encoder: T5EncoderModel unet: UNet2DConditionModel scheduler: DDPMScheduler image_noising_scheduler: DDPMScheduler safety_checker: 可选 feature_extractor: 可选 watermarker: 可选 requires_safety_checker: bool = True )

call

< 源代码 >

( prompt: Union = None height: int = None width: int = None image: Union = None num_inference_steps: int = 50 timesteps: List = None guidance_scale: float = 4.0 negative_prompt: Union = None num_images_per_prompt: 可选 = 1 eta: float = 0.0 generator: Union = None prompt_embeds: 可选 = None negative_prompt_embeds: 可选 = None output_type: 可选 = 'pil' return_dict: bool = True callback: 可选 = None callback_steps: int = 1 cross_attention_kwargs: 可选 = None noise_level: int = 250 clean_caption: bool = True ) → ~pipelines.stable_diffusion.IFPipelineOutput 或 tuple

参数

prompt (str 或 List[str], 可选) — 指导图像生成的提示或提示。如果未定义，则必须传递prompt_embeds。代替。
height (int, 可选, 默认为 None) — 生成的图像的高度（以像素为单位）。
width (int, 可选, 默认为 None) — 生成的图像的宽度（以像素为单位）。
image (PIL.Image.Image, np.ndarray, torch.Tensor) — 需要进行超分辨率缩放的图像。
num_inference_steps (int, 可选, 默认为 50) — 降噪步骤的数量。更多的降噪步骤通常会导致更高的图像质量，但推理速度会变慢。
timesteps (List[int], 可选, 默认为 None) — 用于降噪过程的自定义时间步长。如果未定义，则使用等间距的 num_inference_steps 时间步长。必须按降序排列。
guidance_scale (float, 可选, 默认为 4.0) — 如 Classifier-Free Diffusion Guidance 中所定义的引导尺度。guidance_scale 定义为 Imagen 论文公式 2 中的 w。通过设置 guidance_scale > 1 来启用引导尺度。较高的引导尺度鼓励生成与文本 prompt 密切相关的图像，通常以降低图像质量为代价。
negative_prompt (str 或 List[str], 可选) — 不引导图像生成的提示或提示列表。如果未定义，则必须传递 negative_prompt_embeds。在不使用引导时被忽略（即，如果 guidance_scale 小于 1 则被忽略）。
num_images_per_prompt (int, 可选, 默认为 1) — 每个提示生成图像的数量。
eta (float, 可选, 默认为 0.0) — 对应于 DDIM 论文中的参数 eta (η)：https://arxiv.org/abs/2010.02502。仅适用于 schedulers.DDIMScheduler，对于其他调度器将被忽略。
generator (torch.Generator 或 List[torch.Generator], 可选) — 一个或一组 torch 生成器，用于使生成确定性。
prompt_embeds (torch.Tensor, 可选) — 预生成的文本嵌入。可用于轻松调整文本输入，例如提示加权。如果未提供，则将从 prompt 输入参数生成文本嵌入。
negative_prompt_embeds (torch.Tensor, 可选) — 预生成的负文本嵌入。可用于轻松调整文本输入，例如提示加权。如果未提供，则将从 negative_prompt 输入参数生成 negative_prompt_embeds。
return_dict (bool, 可选, 默认为 True) — 是否返回 ~pipelines.stable_diffusion.IFPipelineOutput 而不是普通元组。
callback (Callable, 可选) — 推理过程中每隔 callback_steps 步调用一次的函数。该函数将使用以下参数调用：callback(step: int, timestep: int, latents: torch.Tensor)。
callback_steps (int, 可选, 默认为 1) — callback 函数调用的频率。如果未指定，则回调将在每个步骤中调用。
cross_attention_kwargs (dict, 可选) — 如果指定，则将传递给 AttentionProcessor 的关键字参数字典，该字典在 diffusers.models.attention_processor 中的 self.processor 下定义。
noise_level (int, 可选, 默认为 250) — 添加到上采样图像中的噪声量。必须在 [0, 1000) 范围内
clean_caption (bool, 可选, 默认为 True) — 是否在创建嵌入之前清理标题。需要安装 beautifulsoup4 和 ftfy。如果未安装依赖项，则将从原始提示创建嵌入。

~pipelines.stable_diffusion.IFPipelineOutput 或 tuple

调用管道进行生成时调用的函数。

示例

>>> from diffusers import IFPipeline, IFSuperResolutionPipeline, DiffusionPipeline
>>> from diffusers.utils import pt_to_pil
>>> import torch

>>> pipe = IFPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0", variant="fp16", torch_dtype=torch.float16)
>>> pipe.enable_model_cpu_offload()

>>> prompt = 'a photo of a kangaroo wearing an orange hoodie and blue sunglasses standing in front of the eiffel tower holding a sign that says "very deep learning"'
>>> prompt_embeds, negative_embeds = pipe.encode_prompt(prompt)

>>> image = pipe(prompt_embeds=prompt_embeds, negative_prompt_embeds=negative_embeds, output_type="pt").images

>>> # save intermediate image
>>> pil_image = pt_to_pil(image)
>>> pil_image[0].save("./if_stage_I.png")

>>> super_res_1_pipe = IFSuperResolutionPipeline.from_pretrained(
...     "DeepFloyd/IF-II-L-v1.0", text_encoder=None, variant="fp16", torch_dtype=torch.float16
... )
>>> super_res_1_pipe.enable_model_cpu_offload()

>>> image = super_res_1_pipe(
...     image=image, prompt_embeds=prompt_embeds, negative_prompt_embeds=negative_embeds
... ).images
>>> image[0].save("./if_stage_II.png")

encode_prompt

< source >

参数

prompt (str 或 List[str], 可选) — 要编码的提示
do_classifier_free_guidance (bool, 可选, 默认为 True) — 是否使用分类器免费引导
num_images_per_prompt (int, 可选, 默认为 1) — 每个提示应生成的图像数量 device — (torch.device, 可选): 将生成的嵌入放置到的 torch 设备
negative_prompt (str 或 List[str], 可选) — 用于引导图像生成的提示或提示。如果未定义，则必须传递 negative_prompt_embeds。代替。如果未定义，则必须传递 negative_prompt_embeds。代替。在不使用引导时忽略（即，如果 guidance_scale 小于 1，则忽略）。
prompt_embeds (torch.Tensor, 可选) — 预生成的文本嵌入。可用于轻松调整文本输入，例如提示加权。如果未提供，则文本嵌入将从 prompt 输入参数生成。
negative_prompt_embeds (torch.Tensor, 可选) — 预生成的负文本嵌入。可用于轻松调整文本输入，例如提示加权。如果未提供，则 negative_prompt_embeds 将从 negative_prompt 输入参数生成。
clean_caption (bool，默认为 False) — 如果 True，则该函数将在编码之前预处理和清理提供的标题。

将提示编码为文本编码器隐藏状态。

IFImg2ImgPipeline

类 diffusers.IFImg2ImgPipeline

< 源代码 >

call

< 源代码 >

( prompt: Union = None image: Union = None strength: float = 0.7 num_inference_steps: int = 80 timesteps: List = None guidance_scale: float = 10.0 negative_prompt: Union = None num_images_per_prompt: Optional = 1 eta: float = 0.0 generator: Union = None prompt_embeds: Optional = None negative_prompt_embeds: Optional = None output_type: Optional = 'pil' return_dict: bool = True callback: Optional = None callback_steps: int = 1 clean_caption: bool = True cross_attention_kwargs: Optional = None ) → ~pipelines.stable_diffusion.IFPipelineOutput 或 tuple

参数

prompt (str 或 List[str], 可选) — 用于引导图像生成的提示或提示。如果未定义，则必须传递 prompt_embeds。代替。
强度 (float, 可选, 默认为 0.7) — 从概念上讲，表示要转换参考 image 的程度。必须介于 0 和 1 之间。image 将用作起点，随着 strength 的增大，会向其添加更多噪声。降噪步骤的数量取决于最初添加的噪声量。当 strength 为 1 时，添加的噪声将达到最大值，并且降噪过程将运行 num_inference_steps 中指定的完整迭代次数。因此，值为 1 实际上会忽略 image。
推理步骤数 (int, 可选, 默认为 80) — 降噪步骤的数量。更多的降噪步骤通常会导致更高的图像质量，但代价是推理速度较慢。
时间步长 (List[int], 可选) — 用于降噪过程的自定义时间步长。如果未定义，则使用等间距的 num_inference_steps 时间步长。必须按降序排列。
引导尺度 (float, 可选, 默认为 10.0) — 在 Classifier-Free Diffusion Guidance 中定义的引导尺度。guidance_scale 定义为 Imagen 论文的公式 2 中的 w。通过设置 guidance_scale > 1 来启用引导尺度。较高的引导尺度鼓励生成与文本 prompt 密切相关的图像，通常以降低图像质量为代价。
负面提示 (str 或 List[str], 可选) — 不引导图像生成的提示或提示。如果未定义，则必须改为传递 negative_prompt_embeds。在不使用引导时（即，如果 guidance_scale 小于 1）会被忽略。
每个提示的图像数量 (int, 可选, 默认为 1) — 每个提示要生成的图像数量。
eta (float, 可选, 默认为 0.0) — 对应于 DDIM 论文中的参数 eta (η)：https://arxiv.org/abs/2010.02502。仅适用于 schedulers.DDIMScheduler，对于其他调度器将被忽略。
生成器 (torch.Generator 或 List[torch.Generator], 可选) — 一个或多个 torch 生成器，用于使生成确定性。
提示嵌入 (torch.Tensor, 可选) — 预生成的文本嵌入。可用于轻松调整文本输入，例如提示加权。如果未提供，则将从 prompt 输入参数生成文本嵌入。
负面提示嵌入 (torch.Tensor, 可选) — 预生成的负面文本嵌入。可用于轻松调整文本输入，例如提示加权。如果未提供，则将从 negative_prompt 输入参数生成 negative_prompt_embeds。
return_dict (bool，可选，默认为 True) — 是否返回 ~pipelines.stable_diffusion.IFPipelineOutput 而不是普通元组。
callback (Callable，可选) — 推理过程中每隔 callback_steps 步调用一次的函数。该函数将使用以下参数调用：callback(step: int, timestep: int, latents: torch.Tensor)。
callback_steps (int，可选，默认为 1) — callback 函数的调用频率。如果未指定，则在每一步都调用回调函数。
clean_caption (bool，可选，默认为 True) — 是否在创建嵌入之前清理标题。需要安装 beautifulsoup4 和 ftfy。如果未安装依赖项，则将从原始提示创建嵌入。
cross_attention_kwargs (dict，可选) — 如果指定，则传递给 AttentionProcessor 的 kwargs 字典，如 diffusers.models.attention_processor 中的 self.processor 所定义。

~pipelines.stable_diffusion.IFPipelineOutput 或 tuple

调用管道进行生成时调用的函数。

示例

>>> from diffusers import IFImg2ImgPipeline, IFImg2ImgSuperResolutionPipeline, DiffusionPipeline
>>> from diffusers.utils import pt_to_pil
>>> import torch
>>> from PIL import Image
>>> import requests
>>> from io import BytesIO

>>> url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg"
>>> response = requests.get(url)
>>> original_image = Image.open(BytesIO(response.content)).convert("RGB")
>>> original_image = original_image.resize((768, 512))

>>> pipe = IFImg2ImgPipeline.from_pretrained(
...     "DeepFloyd/IF-I-XL-v1.0",
...     variant="fp16",
...     torch_dtype=torch.float16,
... )
>>> pipe.enable_model_cpu_offload()

>>> prompt = "A fantasy landscape in style minecraft"
>>> prompt_embeds, negative_embeds = pipe.encode_prompt(prompt)

>>> image = pipe(
...     image=original_image,
...     prompt_embeds=prompt_embeds,
...     negative_prompt_embeds=negative_embeds,
...     output_type="pt",
... ).images

>>> # save intermediate image
>>> pil_image = pt_to_pil(image)
>>> pil_image[0].save("./if_stage_I.png")

>>> super_res_1_pipe = IFImg2ImgSuperResolutionPipeline.from_pretrained(
...     "DeepFloyd/IF-II-L-v1.0",
...     text_encoder=None,
...     variant="fp16",
...     torch_dtype=torch.float16,
... )
>>> super_res_1_pipe.enable_model_cpu_offload()

>>> image = super_res_1_pipe(
...     image=image,
...     original_image=original_image,
...     prompt_embeds=prompt_embeds,
...     negative_prompt_embeds=negative_embeds,
... ).images
>>> image[0].save("./if_stage_II.png")

encode_prompt

< source >

参数

prompt (str 或 List[str]，可选) — 要编码的提示
do_classifier_free_guidance (bool，可选，默认为 True) — 是否使用分类器免费引导
num_images_per_prompt (int，可选，默认为 1) — 每个提示应生成的图像数量 device — (torch.device，可选)：将生成的嵌入放置到的 torch 设备
negative_prompt (str 或 List[str]，可选) — 不用于引导图像生成的提示或提示。如果未定义，则必须传递 negative_prompt_embeds。如果未定义，则必须传递 negative_prompt_embeds。在不使用引导时忽略（即，如果 guidance_scale 小于 1，则忽略）。
negative_prompt_embeds (torch.Tensor, 可选) — 预生成的负面文本嵌入。可用于轻松调整文本输入，例如提示权重。如果未提供，则将从negative_prompt输入参数生成negative_prompt_embeds。
clean_caption (bool，默认为False) — 如果为True，则该函数将在编码前预处理和清理提供的标题。

将提示编码为文本编码器隐藏状态。

IFImg2ImgSuperResolutionPipeline

类 diffusers.IFImg2ImgSuperResolutionPipeline

< 源代码 >

call

< 源代码 >

( image: Union original_image: Union = None strength: float = 0.8 prompt: Union = None num_inference_steps: int = 50 timesteps: List = None guidance_scale: float = 4.0 negative_prompt: Union = None num_images_per_prompt: Optional = 1 eta: float = 0.0 generator: Union = None prompt_embeds: Optional = None negative_prompt_embeds: Optional = None output_type: Optional = 'pil' return_dict: bool = True callback: Optional = None callback_steps: int = 1 cross_attention_kwargs: Optional = None noise_level: int = 250 clean_caption: bool = True ) → ~pipelines.stable_diffusion.IFPipelineOutput 或 tuple

参数

image (torch.Tensor 或 PIL.Image.Image) — 将用作过程起点的图像或表示图像批次的张量。
original_image (torch.Tensor 或 PIL.Image.Image) — image变化来源的原始图像。
strength (float, 可选，默认为 0.8) — 从概念上讲，指示要转换参考image的程度。必须介于 0 和 1 之间。image将用作起点，向其添加更多噪声，strength越大。降噪步骤的数量取决于最初添加的噪声量。当strength为 1 时，添加的噪声将达到最大值，并且降噪过程将运行num_inference_steps中指定的完整迭代次数。因此，值为 1 实际上会忽略image。
prompt (str 或 List[str], 可选) — 用于引导图像生成的提示或提示列表。如果未定义，则必须传递 prompt_embeds。代替。
num_inference_steps (int, 可选，默认为 50) — 降噪步骤的数量。更多的降噪步骤通常会导致更高的图像质量，但会以更慢的推理速度为代价。
timesteps (List[int], 可选) — 用于降噪过程的自定义时间步长。如果未定义，则使用等间距的 num_inference_steps 时间步长。必须按降序排列。
guidance_scale (float, 可选，默认为 4.0) — 在 Classifier-Free Diffusion Guidance 中定义的引导尺度。guidance_scale 定义为 Imagen 论文的公式 2 中的 w。通过设置 guidance_scale > 1 来启用引导尺度。较高的引导尺度鼓励生成与文本 prompt 密切相关的图像，通常会以较低的图像质量为代价。
negative_prompt (str 或 List[str], 可选) — 不用于引导图像生成的提示或提示列表。如果未定义，则必须传递 negative_prompt_embeds 代替。在不使用引导时（即，如果 guidance_scale 小于 1）将被忽略。
num_images_per_prompt (int, 可选，默认为 1) — 每个提示生成图像的数量。
eta (float, 可选，默认为 0.0) — 对应于 DDIM 论文中的参数 eta (η)：https://arxiv.org/abs/2010.02502。仅适用于 schedulers.DDIMScheduler，对于其他调度器将被忽略。
generator (torch.Generator 或 List[torch.Generator], 可选) — 一个或多个 torch 生成器，用于使生成确定性。
prompt_embeds (torch.Tensor, 可选) — 预生成的文本嵌入。可用于轻松调整文本输入，例如提示加权。如果未提供，则将从 prompt 输入参数生成文本嵌入。
negative_prompt_embeds (torch.Tensor, 可选) — 预生成的负文本嵌入。可用于轻松调整文本输入，例如提示加权。如果未提供，则将从 negative_prompt 输入参数生成 negative_prompt_embeds。
return_dict (bool，可选，默认为 True) — 是否返回 ~pipelines.stable_diffusion.IFPipelineOutput 而不是普通元组。
callback (Callable，可选) — 在推理过程中，每隔 callback_steps 步调用一次的函数。该函数将使用以下参数调用：callback(step: int, timestep: int, latents: torch.Tensor)。
callback_steps (int，可选，默认为 1) — callback 函数调用的频率。如果未指定，则在每个步骤都会调用回调函数。
cross_attention_kwargs (dict，可选) — 如果指定，则传递给 AttentionProcessor 的关键字参数字典，定义在 diffusers.models.attention_processor 中的 self.processor 下。
noise_level (int，可选，默认为 250) — 添加到上采样图像中的噪声量。必须在 [0, 1000) 范围内
clean_caption (bool，可选，默认为 True) — 是否在创建嵌入之前清理标题。需要安装 beautifulsoup4 和 ftfy。如果未安装依赖项，则将从原始提示创建嵌入。

~pipelines.stable_diffusion.IFPipelineOutput 或 tuple

调用管道进行生成时调用的函数。

示例

>>> from diffusers import IFImg2ImgPipeline, IFImg2ImgSuperResolutionPipeline, DiffusionPipeline
>>> from diffusers.utils import pt_to_pil
>>> import torch
>>> from PIL import Image
>>> import requests
>>> from io import BytesIO

>>> url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg"
>>> response = requests.get(url)
>>> original_image = Image.open(BytesIO(response.content)).convert("RGB")
>>> original_image = original_image.resize((768, 512))

>>> pipe = IFImg2ImgPipeline.from_pretrained(
...     "DeepFloyd/IF-I-XL-v1.0",
...     variant="fp16",
...     torch_dtype=torch.float16,
... )
>>> pipe.enable_model_cpu_offload()

>>> prompt = "A fantasy landscape in style minecraft"
>>> prompt_embeds, negative_embeds = pipe.encode_prompt(prompt)

>>> image = pipe(
...     image=original_image,
...     prompt_embeds=prompt_embeds,
...     negative_prompt_embeds=negative_embeds,
...     output_type="pt",
... ).images

>>> # save intermediate image
>>> pil_image = pt_to_pil(image)
>>> pil_image[0].save("./if_stage_I.png")

>>> super_res_1_pipe = IFImg2ImgSuperResolutionPipeline.from_pretrained(
...     "DeepFloyd/IF-II-L-v1.0",
...     text_encoder=None,
...     variant="fp16",
...     torch_dtype=torch.float16,
... )
>>> super_res_1_pipe.enable_model_cpu_offload()

>>> image = super_res_1_pipe(
...     image=image,
...     original_image=original_image,
...     prompt_embeds=prompt_embeds,
...     negative_prompt_embeds=negative_embeds,
... ).images
>>> image[0].save("./if_stage_II.png")

encode_prompt

< source >

参数

prompt (str 或 List[str]，可选) — 要编码的提示
do_classifier_free_guidance (bool，可选，默认为 True) — 是否使用分类器免费引导
num_images_per_prompt (int，可选，默认为 1) — 每个提示应生成的图像数量 device — (torch.device，可选)：将结果嵌入放置到的 Torch 设备
prompt_embeds (torch.Tensor，可选) — 预生成的文本嵌入。可用于轻松调整文本输入，例如提示权重。如果未提供，则将从prompt输入参数生成文本嵌入。
negative_prompt_embeds (torch.Tensor，可选) — 预生成的负面文本嵌入。可用于轻松调整文本输入，例如提示权重。如果未提供，则将从negative_prompt输入参数生成negative_prompt_embeds。
clean_caption (bool，默认为False) — 如果为True，则函数将在编码之前预处理和清理提供的标题。

将提示编码为文本编码器隐藏状态。

IFInpaintingPipeline

类 diffusers.IFInpaintingPipeline

< 源代码 >

call

< 源代码 >

( prompt: Union = None image: Union = None mask_image: Union = None strength: float = 1.0 num_inference_steps: int = 50 timesteps: List = None guidance_scale: float = 7.0 negative_prompt: Union = None num_images_per_prompt: Optional = 1 eta: float = 0.0 generator: Union = None prompt_embeds: Optional = None negative_prompt_embeds: Optional = None output_type: Optional = 'pil' return_dict: bool = True callback: Optional = None callback_steps: int = 1 clean_caption: bool = True cross_attention_kwargs: Optional = None ) → ~pipelines.stable_diffusion.IFPipelineOutput 或 tuple

参数

prompt (str 或 List[str]，可选) — 用于引导图像生成的提示或提示。如果未定义，则必须传递prompt_embeds。
image (torch.Tensor 或 PIL.Image.Image) — Image 或表示图像批次的张量，将用作过程的起点。
mask_image (PIL.Image.Image) — 用于遮蔽 image 的 Image 或表示图像批次的张量。掩码中的白色像素将被重新绘制，而黑色像素将被保留。如果 mask_image 是 PIL 图像，则在使用前将其转换为单通道（亮度）。如果它是张量，则应包含一个颜色通道 (L) 而不是 3，因此预期的形状为 (B, H, W, 1)。
strength (float, 可选，默认为 1.0) — 从概念上讲，表示要转换参考 image 的程度。必须在 0 和 1 之间。image 将用作起点，向其添加更多噪声，strength 越大。降噪步骤的数量取决于最初添加的噪声量。当 strength 为 1 时，添加的噪声将达到最大值，并且降噪过程将运行 num_inference_steps 中指定的完整迭代次数。因此，值为 1 实际上会忽略 image。
num_inference_steps (int, 可选，默认为 50) — 降噪步骤的数量。更多的降噪步骤通常会导致更高的图像质量，但推理速度会变慢。
timesteps (List[int], 可选) — 用于降噪过程的自定义时间步长。如果未定义，则使用等间距的 num_inference_steps 时间步长。必须按降序排列。
guidance_scale (float, 可选，默认为 7.0) — 在 Classifier-Free Diffusion Guidance 中定义的引导尺度。guidance_scale 定义为 Imagen 论文公式 2 的 w。通过设置 guidance_scale > 1 来启用引导尺度。更高的引导尺度鼓励生成与文本 prompt 密切相关的图像，通常以降低图像质量为代价。
negative_prompt (str 或 List[str], 可选) — 不引导图像生成的提示或提示。如果未定义，则必须传递 negative_prompt_embeds。在不使用引导时被忽略（即，如果 guidance_scale 小于 1 则被忽略）。
num_images_per_prompt (int, 可选，默认为 1) — 每个提示生成图像的数量。
eta (float, 可选，默认为 0.0) — 对应于 DDIM 论文中的参数 eta (η)：https://arxiv.org/abs/2010.02502。仅适用于 schedulers.DDIMScheduler，其他情况将被忽略。
generator (torch.Generator 或 List[torch.Generator], 可选) — 一个或多个 torch 生成器，用于使生成确定性。
prompt_embeds (torch.Tensor, 可选) — 预生成的文本嵌入。可用于轻松调整文本输入，例如提示加权。如果未提供，则将从 prompt 输入参数生成文本嵌入。
negative_prompt_embeds (torch.Tensor, 可选) — 预生成的负面文本嵌入。可用于轻松调整文本输入，例如提示权重。如果未提供，则将从negative_prompt输入参数生成negative_prompt_embeds。
output_type (str, 可选，默认为 "pil") — 生成的图像的输出格式。在PIL：PIL.Image.Image 或 np.array之间选择。
return_dict (bool, 可选，默认为 True) — 是否返回~pipelines.stable_diffusion.IFPipelineOutput而不是普通元组。
callback (Callable, 可选) — 在推理过程中，每隔callback_steps步将调用的函数。该函数将使用以下参数调用：callback(step: int, timestep: int, latents: torch.Tensor)。
callback_steps (int, 可选，默认为 1) — 将调用callback函数的频率。如果未指定，则将在每一步调用回调。
clean_caption (bool, 可选，默认为 True) — 是否在创建嵌入之前清理标题。需要安装beautifulsoup4 和 ftfy。如果未安装依赖项，则将从原始提示创建嵌入。
cross_attention_kwargs (dict, 可选) — 如果指定，则传递给AttentionProcessor的关键字参数字典，如diffusers.models.attention_processor中的self.processor定义。

~pipelines.stable_diffusion.IFPipelineOutput 或 tuple

调用管道进行生成时调用的函数。

示例

>>> from diffusers import IFInpaintingPipeline, IFInpaintingSuperResolutionPipeline, DiffusionPipeline
>>> from diffusers.utils import pt_to_pil
>>> import torch
>>> from PIL import Image
>>> import requests
>>> from io import BytesIO

>>> url = "https://huggingface.co/datasets/diffusers/docs-images/resolve/main/if/person.png"
>>> response = requests.get(url)
>>> original_image = Image.open(BytesIO(response.content)).convert("RGB")
>>> original_image = original_image

>>> url = "https://huggingface.co/datasets/diffusers/docs-images/resolve/main/if/glasses_mask.png"
>>> response = requests.get(url)
>>> mask_image = Image.open(BytesIO(response.content))
>>> mask_image = mask_image

>>> pipe = IFInpaintingPipeline.from_pretrained(
...     "DeepFloyd/IF-I-XL-v1.0", variant="fp16", torch_dtype=torch.float16
... )
>>> pipe.enable_model_cpu_offload()

>>> prompt = "blue sunglasses"
>>> prompt_embeds, negative_embeds = pipe.encode_prompt(prompt)

>>> image = pipe(
...     image=original_image,
...     mask_image=mask_image,
...     prompt_embeds=prompt_embeds,
...     negative_prompt_embeds=negative_embeds,
...     output_type="pt",
... ).images

>>> # save intermediate image
>>> pil_image = pt_to_pil(image)
>>> pil_image[0].save("./if_stage_I.png")

>>> super_res_1_pipe = IFInpaintingSuperResolutionPipeline.from_pretrained(
...     "DeepFloyd/IF-II-L-v1.0", text_encoder=None, variant="fp16", torch_dtype=torch.float16
... )
>>> super_res_1_pipe.enable_model_cpu_offload()

>>> image = super_res_1_pipe(
...     image=image,
...     mask_image=mask_image,
...     original_image=original_image,
...     prompt_embeds=prompt_embeds,
...     negative_prompt_embeds=negative_embeds,
... ).images
>>> image[0].save("./if_stage_II.png")

encode_prompt

< source >

参数

prompt (str 或 List[str], 可选) — 要编码的提示
do_classifier_free_guidance (bool, 可选，默认为 True) — 是否使用分类器自由引导
negative_prompt (str 或 List[str], 可选) — 用于引导图像生成的提示或提示。如果未定义，则必须传递 negative_prompt_embeds。如果未定义，则必须传递 negative_prompt_embeds。在不使用引导的情况下忽略（即，如果 guidance_scale 小于 1，则忽略）。
prompt_embeds (torch.Tensor, 可选) — 预生成的文本嵌入。可用于轻松调整文本输入，例如提示权重。如果未提供，则将从 prompt 输入参数生成文本嵌入。
negative_prompt_embeds (torch.Tensor, 可选) — 预生成的负文本嵌入。可用于轻松调整文本输入，例如提示权重。如果未提供，则将从 negative_prompt 输入参数生成 negative_prompt_embeds。
clean_caption (bool, 默认为 False) — 如果为 True，则该函数将在编码之前预处理和清理提供的标题。

将提示编码为文本编码器隐藏状态。

IFInpaintingSuperResolutionPipeline

类 diffusers.IFInpaintingSuperResolutionPipeline

< 源代码 >

call

< 源代码 >

( image: Union original_image: Union = None mask_image: Union = None strength: float = 0.8 prompt: Union = None num_inference_steps: int = 100 timesteps: List = None guidance_scale: float = 4.0 negative_prompt: Union = None num_images_per_prompt: Optional = 1 eta: float = 0.0 generator: Union = None prompt_embeds: Optional = None negative_prompt_embeds: Optional = None output_type: Optional = 'pil' return_dict: bool = True callback: Optional = None callback_steps: int = 1 cross_attention_kwargs: Optional = None noise_level: int = 0 clean_caption: bool = True ) → ~pipelines.stable_diffusion.IFPipelineOutput 或 tuple

参数

image (torch.Tensor 或 PIL.Image.Image) — Image 或表示图像批次的张量，将用作流程的起点。
原始图像 (torch.Tensor 或 PIL.Image.Image) — image 变异前的原始图像。
遮罩图像 (PIL.Image.Image) — 用于遮罩 image 的 Image 或表示图像批次的张量。遮罩中的白色像素将被重新绘制，而黑色像素将被保留。如果 mask_image 是 PIL 图像，它将在使用前转换为单通道（亮度）。如果它是张量，则应包含一个颜色通道 (L) 而不是 3，因此预期形状将为 (B, H, W, 1)。
强度 (float, 可选, 默认为 0.8) — 从概念上讲，指示要转换参考 image 的程度。必须介于 0 和 1 之间。image 将用作起点，在其上添加更多噪声，strength 越大。降噪步骤的数量取决于最初添加的噪声量。当 strength 为 1 时，添加的噪声将最大，并且降噪过程将运行 num_inference_steps 中指定的完整迭代次数。因此，值为 1 本质上会忽略 image。
提示 (str 或 List[str], 可选) — 指导图像生成的提示或提示。如果未定义，则必须传递 prompt_embeds 代替。
推理步数 (int, 可选, 默认为 100) — 降噪步骤的数量。更多的降噪步骤通常会导致更高的图像质量，但会以更慢的推理为代价。
时间步长 (List[int], 可选) — 用于降噪过程的自定义时间步长。如果未定义，则使用等间距的 num_inference_steps 时间步长。必须按降序排列。
引导尺度 (float, 可选, 默认为 4.0) — 在无分类器扩散引导中定义的引导尺度。guidance_scale 定义为 Imagen 论文公式 2 的 w。通过设置 guidance_scale > 1 来启用引导尺度。更高的引导尺度鼓励生成与文本 prompt 密切相关的图像，通常以降低图像质量为代价。
负面提示 (str 或 List[str], 可选) — 不用于指导图像生成的提示或提示。如果未定义，则必须传递 negative_prompt_embeds 代替。在不使用引导时被忽略（即，如果 guidance_scale 小于 1，则被忽略）。
每个提示的图像数量 (int, 可选, 默认为 1) — 每个提示生成图像的数量。
eta (float, 可选, 默认为 0.0) — 对应于 DDIM 论文中的参数 eta (η)：https://arxiv.org/abs/2010.02502。仅适用于 schedulers.DDIMScheduler，其他情况将被忽略。
生成器 (torch.Generator 或 List[torch.Generator], 可选) — 一个或多个 torch 生成器，用于使生成确定性。
提示嵌入 (torch.Tensor, 可选) — 预生成的文本嵌入。可用于轻松调整文本输入，例如提示加权。如果未提供，则将从 prompt 输入参数生成文本嵌入。
负面提示嵌入 (torch.Tensor, 可选) — 预生成的负面文本嵌入。可用于轻松调整文本输入，例如提示加权。如果未提供，则将从 negative_prompt 输入参数生成负面提示嵌入。
输出类型 (str, 可选, 默认为 "pil") — 生成图像的输出格式。在 PIL 之间选择：PIL.Image.Image 或 np.array。
返回字典 (bool, 可选, 默认为 True) — 是否返回 ~pipelines.stable_diffusion.IFPipelineOutput 而不是普通元组。
回调函数 (Callable, 可选) — 在推理过程中每隔 callback_steps 步调用一次的函数。该函数将使用以下参数调用：callback(step: int, timestep: int, latents: torch.Tensor)。
回调步数 (int, 可选, 默认为 1) — 调用 callback 函数的频率。如果未指定，则将在每个步骤调用回调函数。
交叉注意力关键字参数 (dict, 可选) — 如果指定，则传递给 diffusers.models.attention_processor 中 self.processor 下定义的 AttentionProcessor 的关键字参数字典。
噪声级别 (int, 可选, 默认为 0) — 添加到上采样图像的噪声量。必须在 [0, 1000) 范围内
清理标题 (bool, 可选, 默认为 True) — 是否在创建嵌入之前清理标题。需要安装 beautifulsoup4 和 ftfy。如果未安装依赖项，则将从原始提示创建嵌入。

~pipelines.stable_diffusion.IFPipelineOutput 或 tuple

调用管道进行生成时调用的函数。

示例

>>> from diffusers import IFInpaintingPipeline, IFInpaintingSuperResolutionPipeline, DiffusionPipeline
>>> from diffusers.utils import pt_to_pil
>>> import torch
>>> from PIL import Image
>>> import requests
>>> from io import BytesIO

>>> url = "https://huggingface.co/datasets/diffusers/docs-images/resolve/main/if/person.png"
>>> response = requests.get(url)
>>> original_image = Image.open(BytesIO(response.content)).convert("RGB")
>>> original_image = original_image

>>> url = "https://huggingface.co/datasets/diffusers/docs-images/resolve/main/if/glasses_mask.png"
>>> response = requests.get(url)
>>> mask_image = Image.open(BytesIO(response.content))
>>> mask_image = mask_image

>>> pipe = IFInpaintingPipeline.from_pretrained(
...     "DeepFloyd/IF-I-XL-v1.0", variant="fp16", torch_dtype=torch.float16
... )
>>> pipe.enable_model_cpu_offload()

>>> prompt = "blue sunglasses"

>>> prompt_embeds, negative_embeds = pipe.encode_prompt(prompt)
>>> image = pipe(
...     image=original_image,
...     mask_image=mask_image,
...     prompt_embeds=prompt_embeds,
...     negative_prompt_embeds=negative_embeds,
...     output_type="pt",
... ).images

>>> # save intermediate image
>>> pil_image = pt_to_pil(image)
>>> pil_image[0].save("./if_stage_I.png")

>>> super_res_1_pipe = IFInpaintingSuperResolutionPipeline.from_pretrained(
...     "DeepFloyd/IF-II-L-v1.0", text_encoder=None, variant="fp16", torch_dtype=torch.float16
... )
>>> super_res_1_pipe.enable_model_cpu_offload()

>>> image = super_res_1_pipe(
...     image=image,
...     mask_image=mask_image,
...     original_image=original_image,
...     prompt_embeds=prompt_embeds,
...     negative_prompt_embeds=negative_embeds,
... ).images
>>> image[0].save("./if_stage_II.png")

encode_prompt

< 源代码 >

参数

prompt (str 或 List[str], 可选) — 要编码的提示
do_classifier_free_guidance (bool, 可选, 默认为 True) — 是否使用分类器免费引导
num_images_per_prompt (int, 可选, 默认为 1) — 每个提示应生成的图像数量 device — (torch.device, 可选): 将生成的嵌入放置到的 Torch 设备
negative_prompt (str 或 List[str], 可选) — 不引导图像生成的提示或提示。如果未定义，则必须传递 negative_prompt_embeds。如果未定义，则必须传递 negative_prompt_embeds。在不使用引导时忽略（即，如果 guidance_scale 小于 1，则忽略）。
prompt_embeds (torch.Tensor, 可选) — 预生成的文本嵌入。可用于轻松调整文本输入，例如提示加权。如果未提供，则将从 prompt 输入参数生成文本嵌入。
negative_prompt_embeds (torch.Tensor, 可选) — 预生成的负文本嵌入。可用于轻松调整文本输入，例如提示加权。如果未提供，则将从 negative_prompt 输入参数生成 negative_prompt_embeds。
clean_caption (bool, 默认为 False) — 如果 True，则该函数将在编码之前预处理和清理提供的标题。

将提示编码为文本编码器隐藏状态。

< > 在 GitHub 上更新

←DDPM DiffEdit→

Diffusers

DeepFloyd IF

概述

使用

文本到图像生成

文本引导图像到图像生成

文本引导修复生成

在不同管道之间转换

优化速度

优化内存

可用管道：

IFPipeline

类 diffusers.IFPipeline

__call__

encode_prompt

IFSuperResolutionPipeline

类 diffusers.IFSuperResolutionPipeline

__call__

encode_prompt

IFImg2ImgPipeline

类 diffusers.IFImg2ImgPipeline

__call__

encode_prompt

IFImg2ImgSuperResolutionPipeline

类 diffusers.IFImg2ImgSuperResolutionPipeline

__call__

encode_prompt

IFInpaintingPipeline

类 diffusers.IFInpaintingPipeline

__call__

encode_prompt

IFInpaintingSuperResolutionPipeline

类 diffusers.IFInpaintingSuperResolutionPipeline

__call__

encode_prompt

call

call

call

call

call

call