AWS Trainium 和 Inferentia 文档

在 AWS Inferentia 上使用 Stable Diffusion 模型生成图像

AWS Trainium 和 Inferentia

加入 Hugging Face 社区

并获得增强型文档体验

协作模型、数据集和 Spaces

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

在文档主题之间切换

开始使用

在 AWS Inferentia 上使用 Stable Diffusion 模型生成图像

Stable Diffusion

该教程的笔记本版本在此处.

🤗 Optimum 扩展了 Diffusers 以支持在第二代 Neuron 设备（为 Trainium 和 Inferentia 2 提供支持）上进行推理。它旨在继承 Diffusers 在 Neuron 上的易用性。

要开始使用，请确保您已配置您的 inf2/trn1 实例并安装了 optimum

pip install "optimum[neuronx, diffusers]"

编译 Stable Diffusion

要部署模型，您需要将其编译为针对 AWS Neuron 优化的 TorchScript。在 Stable Diffusion 的情况下，有四个组件需要导出为 .neuron 格式以提高性能

文本编码器
U-Net
VAE 编码器
VAE 解码器

您可以通过 CLI 或 NeuronStableDiffusionPipeline 类编译和导出 Stable Diffusion 检查点。

通过 CLI 导出

以下是如何使用 Optimum CLI 导出 Stable Diffusion 组件的示例

optimum-cli export neuron --model stabilityai/stable-diffusion-2-1-base \
  --batch_size 1 \
  --height 512 `# height in pixels of generated image, eg. 512, 768` \
  --width 512 `# width in pixels of generated image, eg. 512, 768` \
  --num_images_per_prompt 4 `# number of images to generate per prompt, defaults to 1` \
  --auto_cast matmul `# cast only matrix multiplication operations` \
  --auto_cast_type bf16 `# cast operations from FP32 to BF16` \
  sd_neuron/

我们建议使用 inf2.8xlarge 或更大的实例进行模型编译。您也可以在仅 CPU 的实例上使用 Optimum CLI 编译模型（需要约 35 GB 内存），然后在 inf2.xlarge 上运行预编译模型以降低成本。在这种情况下，请不要忘记通过添加 --disable-validation 参数禁用推理验证。

通过 Python API 导出

以下是如何使用 NeuronStableDiffusionPipeline 导出 Stable Diffusion 组件的示例

要应用 Unet 注意力分数的优化计算，请使用 export NEURON_FUSE_SOFTMAX=1 配置您的环境变量。

此外，请随时调整编译配置以在您的用例中找到性能与准确性之间的最佳权衡。默认情况下，我们建议将 FP32 矩阵乘法运算转换为 BF16，这可以提供良好的性能，同时适度牺牲准确性。查看来自AWS Neuron 文档的指南，以更好地了解编译选项。

>>> from optimum.neuron import NeuronStableDiffusionPipeline

>>> model_id = "runwayml/stable-diffusion-v1-5"
>>> compiler_args = {"auto_cast": "matmul", "auto_cast_type": "bf16"}
>>> input_shapes = {"batch_size": 1, "height": 512, "width": 512}

>>> stable_diffusion = NeuronStableDiffusionPipeline.from_pretrained(model_id, export=True, **compiler_args, **input_shapes)

# Save locally or upload to the HuggingFace Hub
>>> save_directory = "sd_neuron/"
>>> stable_diffusion.save_pretrained(save_directory)
>>> stable_diffusion.push_to_hub(
...     save_directory, repository_id="my-neuron-repo", use_auth_token=True
... )

文本到图像

NeuronStableDiffusionPipeline 类允许您在 Neuron 设备上根据文本提示生成图像，类似于使用 Diffusers 的体验。

使用预编译的 Stable Diffusion 模型，现在可以在 Neuron 上根据提示生成图像。

>>> from optimum.neuron import NeuronStableDiffusionPipeline

>>> stable_diffusion = NeuronStableDiffusionPipeline.from_pretrained("sd_neuron/")
>>> prompt = "a photo of an astronaut riding a horse on mars"
>>> image = stable_diffusion(prompt).images[0]

图像到图像

使用 NeuronStableDiffusionImg2ImgPipeline 类，您可以根据文本提示和初始图像生成新的图像。

import requests
from PIL import Image
from io import BytesIO
from optimum.neuron import NeuronStableDiffusionImg2ImgPipeline

# compile & save
model_id = "nitrosocke/Ghibli-Diffusion"
input_shapes = {"batch_size": 1, "height": 512, "width": 512}
pipeline = NeuronStableDiffusionImg2ImgPipeline.from_pretrained(model_id, export=True, **input_shapes)
pipeline.save_pretrained("sd_img2img/")

url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg"

response = requests.get(url)
init_image = Image.open(BytesIO(response.content)).convert("RGB")
init_image = init_image.resize((512, 512))

prompt = "ghibli style, a fantasy landscape with snowcapped mountains, trees, lake with detailed reflection. sunlight and cloud in the sky, warm colors, 8K"

image = pipeline(prompt=prompt, image=init_image, strength=0.75, guidance_scale=7.5).images[0]
image.save("fantasy_landscape.png")

`图像`	`提示`	输出
	*吉卜力风格，一个带有雪山、树木、湖泊（带有详细反射）的奇幻景观。暖色调，8K*

修复上色

使用 NeuronStableDiffusionInpaintPipeline 类，您可以通过提供掩码和文本提示来编辑图像的特定部分。

import requests
from PIL import Image
from io import BytesIO
from optimum.neuron import NeuronStableDiffusionInpaintPipeline

model_id = "runwayml/stable-diffusion-inpainting"
input_shapes = {"batch_size": 1, "height": 512, "width": 512}
pipeline = NeuronStableDiffusionInpaintPipeline.from_pretrained(model_id, export=True, **input_shapes)
pipeline.save_pretrained("sd_inpaint/")

def download_image(url):
    response = requests.get(url)
    return Image.open(BytesIO(response.content)).convert("RGB")

img_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo.png"
mask_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo_mask.png"

init_image = download_image(img_url).resize((512, 512))
mask_image = download_image(mask_url).resize((512, 512))

prompt = "Face of a yellow cat, high resolution, sitting on a park bench"
image = pipeline(prompt=prompt, image=init_image, mask_image=mask_image).images[0]
image.save("cat_on_bench.png")

`图像`	`掩码图像`	`提示`	输出
		*一只黄色猫咪的脸，高分辨率，坐在公园长椅上*

指令Pix2Pix

使用 NeuronStableDiffusionInstructPix2PixPipeline 类，您可以使用文本引导和图像引导来应用基于指令的图像编辑。

import requests
import PIL
from io import BytesIO
from optimum.neuron import NeuronStableDiffusionInstructPix2PixPipeline

def download_image(url):
    response = requests.get(url)
    return PIL.Image.open(BytesIO(response.content)).convert("RGB")

model_id = "timbrooks/instruct-pix2pix"
input_shapes = {"batch_size": 1, "height": 512, "width": 512}

pipe = NeuronStableDiffusionInstructPix2PixPipeline.from_pretrained(
  model_id, export=True, dynamic_batch_size=True, **input_shapes,
)
pipe.save_pretrained("sd_ip2p/")

img_url = "https://huggingface.co/datasets/diffusers/diffusers-images-docs/resolve/main/mountain.png"
init_image = download_image(img_url).resize((512, 512))

prompt = "Add a beautiful sunset"
image = pipe(prompt=prompt, image=init_image).images[0]
image.save("sunset_mountain.png")

`图像`	`提示`	输出
	*添加一个美丽的日落*

Stable Diffusion XL

此教程的 Notebook 版本在此处.

Stable Diffusion XL (SDXL) 是一种用于文本到图像的潜在扩散模型。与之前版本的 Stable Diffusion 模型相比，它使用更大的 UNet 提高了生成图像的质量。

编译 Stable Diffusion XL

要部署 SDXL 模型，我们也将首先编译模型。我们支持导出管道中的以下组件以提高速度

文本编码器
第二个文本编码器
U-Net（比 Stable Diffusion 管道中的 UNet 大三倍）
VAE 编码器
VAE 解码器

通过 CLI 导出

以下是用 Optimum CLI 导出 SDXL 组件的示例

optimum-cli export neuron --model stabilityai/stable-diffusion-xl-base-1.0 \
  --batch_size 1 \
  --height 1024 `# height in pixels of generated image, eg. 768, 1024` \
  --width 1024 `# width in pixels of generated image, eg. 768, 1024` \
  --num_images_per_prompt 4 `# number of images to generate per prompt, defaults to 1` \
  --auto_cast matmul `# cast only matrix multiplication operations` \
  --auto_cast_type bf16 `# cast operations from FP32 to BF16` \
  sd_neuron_xl/

我们建议使用 inf2.8xlarge 或更大实例进行模型编译。您也可以在仅 CPU 的实例上使用 Optimum CLI 编译模型（需要约 92 GB 内存），然后在 inf2.xlarge 上运行预编译的模型以减少开支。在这种情况下，请不要忘记通过添加 --disable-validation 参数来禁用推理验证。

通过 Python API 导出

以下是用 NeuronStableDiffusionXLPipeline 导出 Stable Diffusion 组件的示例

>>> from optimum.neuron import NeuronStableDiffusionXLPipeline

>>> model_id = "stabilityai/stable-diffusion-xl-base-1.0"
>>> compiler_args = {"auto_cast": "matmul", "auto_cast_type": "bf16"}
>>> input_shapes = {"batch_size": 1, "height": 1024, "width": 1024}

>>> stable_diffusion_xl = NeuronStableDiffusionXLPipeline.from_pretrained(model_id, export=True, **compiler_args, **input_shapes)

# Save locally or upload to the HuggingFace Hub
>>> save_directory = "sd_neuron_xl/"
>>> stable_diffusion_xl.save_pretrained(save_directory)
>>> stable_diffusion_xl.push_to_hub(
...     save_directory, repository_id="my-neuron-repo", use_auth_token=True
... )

文本到图像

使用预编译的 SDXL 模型，现在可以在 Neuron 上根据文本提示生成图像。

>>> from optimum.neuron import NeuronStableDiffusionXLPipeline

>>> stable_diffusion_xl = NeuronStableDiffusionXLPipeline.from_pretrained("sd_neuron_xl/")
>>> prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
>>> image = stable_diffusion_xl(prompt).images[0]

图像到图像

使用 NeuronStableDiffusionXLImg2ImgPipeline，您可以传递初始图像和文本提示来调节生成的图像。

from optimum.neuron import NeuronStableDiffusionXLImg2ImgPipeline
from diffusers.utils import load_image

prompt = "a dog running, lake, moat"
url = "https://huggingface.co/datasets/optimum/documentation-images/resolve/main/intel/openvino/sd_xl/castle_friedrich.png"
init_image = load_image(url).convert("RGB")

pipe = NeuronStableDiffusionXLImg2ImgPipeline.from_pretrained("sd_neuron_xl/")
image = pipe(prompt=prompt, image=init_image).images[0]

`图像`	`提示`	输出
	*一只狗在奔跑，湖泊，护城河*

修复上色

使用 NeuronStableDiffusionXLInpaintPipeline，传递原始图像和要替换的区域的掩码。然后用提示中描述的内容替换掩码区域。

from optimum.neuron import NeuronStableDiffusionXLInpaintPipeline
from diffusers.utils import load_image

img_url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/sdxl-text2img.png"
mask_url = (
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/sdxl-inpaint-mask.png"
)

init_image = load_image(img_url).convert("RGB")
mask_image = load_image(mask_url).convert("RGB")
prompt = "A deep sea diver floating"

pipe = NeuronStableDiffusionXLInpaintPipeline.from_pretrained("sd_neuron_xl/")
image = pipe(prompt=prompt, image=init_image, mask_image=mask_image, strength=0.85, guidance_scale=12.5).images[0]

`图像`	`掩码图像`	`提示`	输出
		*一个深海潜水员漂浮着*

优化图像质量

SDXL 包含一个细化模型，用于对从基础模型生成的低噪声阶段图像进行降噪。有两种方法可以使用细化器

将基础模型和细化模型一起使用以生成细化的图像。
使用基础模型生成图像，然后随后使用细化模型为图像添加更多细节。

基础 + 细化模型

from optimum.neuron import NeuronStableDiffusionXLPipeline, NeuronStableDiffusionXLImg2ImgPipeline

prompt = "A majestic lion jumping from a big stone at night"
base = NeuronStableDiffusionXLPipeline.from_pretrained("sd_neuron_xl/")
image = base(
    prompt=prompt,
    num_images_per_prompt=num_images_per_prompt,
    num_inference_steps=40,
    denoising_end=0.8,
    output_type="latent",
).images[0]
del base  # To avoid neuron device OOM

refiner = NeuronStableDiffusionXLImg2ImgPipeline.from_pretrained("sd_neuron_xl_refiner/")
image = refiner(
    prompt=prompt,
    num_inference_steps=40,
    denoising_start=0.8,
    image=image,
).images[0]

基础到细化模型

from optimum.neuron import NeuronStableDiffusionXLPipeline, NeuronStableDiffusionXLImg2ImgPipeline

prompt = "A majestic lion jumping from a big stone at night"
base = NeuronStableDiffusionXLPipeline.from_pretrained("sd_neuron_xl/")
image = base(prompt=prompt, output_type="latent").images[0]
del base  # To avoid neuron device OOM

refiner = NeuronStableDiffusionXLImg2ImgPipeline.from_pretrained("sd_neuron_xl_refiner/")
image = refiner(prompt=prompt, image=image[None, :]).images[0]

`基础图像`	细化图像

为了避免 Neuron 设备内存不足，建议在运行细化器之前完成所有基础推理并释放设备内存。

潜在一致模型

潜在一致模型 (LCM) 在潜在一致模型：通过少量步骤推理合成高分辨率图像，作者：Simian Luo、Yiqin Tan、Longbo Huang、Jian Li 和 Hang Zhao中提出。LCM 能够在任何预训练的 LDM 上使用更少的步骤进行推理，包括 Stable Diffusion 和 SDXL。

在 optimum-neuron 中，您可以

使用 NeuronLatentConsistencyModelPipeline 类编译和运行从 Stable Diffusion (SD) 模型中提取的 LCM 的推理。
并继续使用 NeuronStableDiffusionXLPipeline 类用于从 SDXL 模型中提取的 LCM。

以下是编译 Stable Diffusion 的 LCM（SimianLuo/LCM_Dreamshaper_v7）和 Stable Diffusion XL（latent-consistency/lcm-sdxl）的示例，然后在 AWS Inferentia 2 上运行推理

编译LCM

稳定扩散的LCM

from optimum.neuron import NeuronLatentConsistencyModelPipeline

model_id = "SimianLuo/LCM_Dreamshaper_v7"
num_images_per_prompt = 1
input_shapes = {"batch_size": 1, "height": 768, "width": 768, "num_images_per_prompt": num_images_per_prompt}
compiler_args = {"auto_cast": "matmul", "auto_cast_type": "bf16"}

stable_diffusion = NeuronLatentConsistencyModelPipeline.from_pretrained(
    model_id, export=True, **compiler_args, **input_shapes
)
save_directory = "lcm_sd_neuron/"
stable_diffusion.save_pretrained(save_directory)

# Push to hub
stable_diffusion.push_to_hub(save_directory, repository_id="my-neuron-repo", use_auth_token=True)  # Replace with your repo id, eg. "Jingya/LCM_Dreamshaper_v7_neuronx"

稳定扩散XL的LCM

from optimum.neuron import NeuronStableDiffusionXLPipeline

model_id = "stabilityai/stable-diffusion-xl-base-1.0"
unet_id = "latent-consistency/lcm-sdxl"
num_images_per_prompt = 1
input_shapes = {"batch_size": 1, "height": 1024, "width": 1024, "num_images_per_prompt": num_images_per_prompt}
compiler_args = {"auto_cast": "matmul", "auto_cast_type": "bf16"}

stable_diffusion = NeuronStableDiffusionXLPipeline.from_pretrained(
    model_id, unet_id=unet_id, export=True, **compiler_args, **input_shapes
)
save_directory = "lcm_sdxl_neuron/"
stable_diffusion.save_pretrained(save_directory)

# Push to hub
stable_diffusion.push_to_hub(save_directory, repository_id="my-neuron-repo", use_auth_token=True)   # Replace with your repo id, eg. "Jingya/lcm-sdxl-neuronx"

文本到图像

现在我们可以在Inf2上使用预编译模型从文本提示生成图像

稳定扩散的LCM

from optimum.neuron import NeuronLatentConsistencyModelPipeline

pipe = NeuronLatentConsistencyModelPipeline.from_pretrained("Jingya/LCM_Dreamshaper_v7_neuronx")
prompts = ["Self-portrait oil painting, a beautiful cyborg with golden hair, 8k"] * 2

images = pipe(prompt=prompts, num_inference_steps=4, guidance_scale=8.0).images

稳定扩散XL的LCM

from optimum.neuron import NeuronStableDiffusionXLPipeline

pipe = NeuronStableDiffusionXLPipeline.from_pretrained("Jingya/lcm-sdxl-neuronx")
prompts = ["a close-up picture of an old man standing in the rain"] * 2

images = pipe(prompt=prompts, num_inference_steps=4, guidance_scale=8.0).images

稳定扩散XL Turbo

SDXL Turbo是一个对抗性时间蒸馏的稳定扩散XL (SDXL) 模型，能够在尽可能少的1步内运行推理（查看🤗diffusers了解更多详情）。

在 optimum-neuron 中，您可以

使用类NeuronStableDiffusionXLPipeline编译并运行推理。

在这里，我们将使用Optimum CLI编译stabilityai/sdxl-turbo模型。

编译SDXL Turbo

optimum-cli export neuron --model stabilityai/sdxl-turbo --batch_size 1 --height 512 --width 512 --auto_cast matmul --auto_cast_type bf16 sdxl_turbo_neuron/

文本到图像

现在我们可以在Inf2上使用预编译模型从文本提示生成图像

from optimum.neuron import NeuronStableDiffusionXLPipeline

pipe = NeuronStableDiffusionXLPipeline.from_pretrained("sdxl_turbo_neuron/", data_parallel_mode="all")
prompt = ["Self-portrait oil painting, a beautiful cyborg with golden hair, 8k"] * 2

images = pipe(prompt=prompt, guidance_scale=0.0, num_inference_steps=1).images

Inf2实例包含一个或多个Neuron设备，每个Neuron设备包含2个NeuronCore-v2。默认情况下，我们将LCM的整个管道加载到两个Neuron核心上。这意味着当批次大小可以被2整除时，您可以充分利用两个核心的计算能力。

加载适配器

LoRA

低秩自适应是使稳定扩散快速适应生成图像风格的一种方法。在Optimum Neuron中，我们支持通过将其参数融合到文本编码器和UNet的原始参数中，在编译期间使用一个或多个LoRA适配器。下面是使用您选择的LoRA适配器编译稳定扩散模型并使用编译后的工件生成风格化图像的示例。


from diffusers import LCMScheduler
from optimum.neuron import NeuronStableDiffusionPipeline


model_id = "Lykon/dreamshaper-7"
adapter_id = "latent-consistency/lcm-lora-sdv1-5"
input_shapes = {"batch_size": 1, "height": 512, "width": 512, "num_images_per_prompt": 1}
compiler_args = {"auto_cast": "matmul", "auto_cast_type": "bf16"}

# Compile
pipe = NeuronStableDiffusionPipeline.from_pretrained(
    model_id,
    export=True,
    inline_weights_to_neff=True,  # caveat: performance drop if neff/weights separated, will be improved by a future Neuron sdk release.
    lora_model_ids=adapter_id,
    lora_weight_names="pytorch_lora_weights.safetensors",
    lora_adapter_names="lcm",
    **input_shapes,
    **compiler_args,
)
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)

# Save locally or upload to the HuggingFace Hub
pipe.save_pretrained("dreamshaper_7_lcm_lora_neuron/")


# Inference
prompt = "Self-portrait oil painting, a beautiful cyborg with golden hair, 8k"
image = pipe(prompt, num_inference_steps=4, guidance_scale=0).images[0]

stable diffusion generated image with LoRA adapter.

ControlNet

ControlNet使用额外的输入图像来调节稳定扩散模型。在Optimum Neuron中，我们支持与稳定扩散检查点一起编译一个或多个ControlNet。然后，您可以使用编译后的工件生成风格化图像。

编译ControlNet

我们可以通过Optimum CLI或通过NeuronStableDiffusionControlNetPipeline类以编程方式传递controlnet_ids来编译一个或多个ControlNet。

通过Optimum CLI导出

optimum-cli export neuron -m runwayml/stable-diffusion-v1-5 --batch_size 1 --height 512 --width 512 --controlnet_ids lllyasviel/sd-controlnet-canny --num_images_per_prompt 1 sd_neuron_controlnet/

通过 Python API 导出

from optimum.neuron import NeuronStableDiffusionControlNetPipeline

model_id = "runwayml/stable-diffusion-v1-5"
controlnet_id = "lllyasviel/sd-controlnet-canny"

# [Neuron] pipeline
input_shapes = {"batch_size": 1, "height": 512, "width": 512, "num_images_per_prompt": 1}
compiler_args = {"auto_cast": "matmul", "auto_cast_type": "bf16"}
pipe = NeuronStableDiffusionControlNetPipeline.from_pretrained(
    model_id,
    controlnet_ids=controlnet_id,
    export=True,
    **input_shapes,
    **compiler_args,
)
pipe.save_pretrained("sd_neuron_controlnet")

文本到图像

对于文本到图像，我们可以指定额外的条件输入。

这是一个使用Canny图像的示例，即黑色背景上图像的白色轮廓。ControlNet将使用Canny图像作为控制，引导模型生成具有相同轮廓的图像。

import cv2
import numpy as np
from diffusers import UniPCMultistepScheduler
from diffusers.utils import load_image, make_image_grid
from PIL import Image

from optimum.neuron import NeuronStableDiffusionControlNetPipeline


# prepare canny image
original_image = load_image(
    "https://hf.co/datasets/huggingface/documentation-images/resolve/main/diffusers/input_image_vermeer.png"
)

image = np.array(original_image)

low_threshold = 100
high_threshold = 200

image = cv2.Canny(image, low_threshold, high_threshold)
image = image[:, :, None]
image = np.concatenate([image, image, image], axis=2)
canny_image = Image.fromarray(image)

# load pre-compiled neuron model
pipe = NeuronStableDiffusionControlNetPipeline.from_pretrained("sd_neuron_controlnet")
pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config)

# inference
output = pipe("the mona lisa", image=canny_image).images[0]
compare = make_image_grid([original_image, canny_image, output], rows=1, cols=3)
compare.save("compare.png")

stable diffusion 1.5 generated image with controlnet.

多ControlNet

使用Optimum Neuron，您还可以从不同的图像输入组合多个ControlNet条件。

为SD1.5编译多个ControlNet

optimum-cli export neuron --inline-weights-neff --model jyoung105/stable-diffusion-v1-5 --task stable-diffusion --auto_cast matmul --auto_cast_type bf16 --batch_size 1 --num_images_per_prompt 1 --controlnet_ids lllyasviel/control_v11p_sd15_openpose lllyasviel/control_v11f1p_sd15_depth --height 512 --width 512 sd15-512x512-bf16-openpose-depth

使用OpenPose和深度条件运行SD1.5

import numpy as np
import torch
from PIL import Image

from controlnet_aux import OpenposeDetector
from transformers import pipeline
from diffusers import UniPCMultistepScheduler
from diffusers.utils import load_image
from optimum.neuron import NeuronStableDiffusionControlNetPipeline


# OpenPose+Depth ControlNet
model_id = "sd15-512x512-bf16-openpose-depth"

# Load ControlNet images

# 1. openpose
image = load_image("https://huggingface.co/lllyasviel/control_v11p_sd15_openpose/resolve/main/images/input.png")
processor = OpenposeDetector.from_pretrained('lllyasviel/ControlNet')
openpose_image = processor(image)

# 2. depth
image = load_image("https://huggingface.co/lllyasviel/control_v11p_sd15_depth/resolve/main/images/input.png")
depth_estimator = pipeline('depth-estimation')
image = depth_estimator(image)['depth']
image = np.array(image)
image = image[:, :, None]
image = np.concatenate([image, image, image], axis=2)
depth_image = Image.fromarray(image)

images = [openpose_image.resize((512, 512)), depth_image.resize((512, 512))]

# 3. inference
pipe = NeuronStableDiffusionControlNetPipeline.from_pretrained(model_id)
pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config)
prompt = "a giant in a fantasy landscape, best quality"
negative_prompt = "monochrome, lowres, bad anatomy, worst quality, low quality"

image = pipe(prompt=prompt, image=images).images[0]
image.save('out.png')

stable diffusion 1.5 generated image with OpenPose and Depth controlnet.

稳定扩散XL的ControlNet

编译

optimum-cli export neuron -m stabilityai/stable-diffusion-xl-base-1.0 --task stable-diffusion-xl --batch_size 1 --height 1024 --width 1024 --controlnet_ids diffusers/controlnet-canny-sdxl-1.0-small --num_images_per_prompt 1 sdxl_neuron_controlnet/

文本到图像

import cv2
import numpy as np
from diffusers.utils import load_image
from PIL import Image
from optimum.neuron import NeuronStableDiffusionXLControlNetPipeline

# Inputs
prompt = "aerial view, a futuristic research complex in a bright foggy jungle, hard lighting"
negative_prompt = "low quality, bad quality, sketches"

image = load_image(
    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/hf-logo.png"
)
image = np.array(image)
image = cv2.Canny(image, 100, 200)
image = image[:, :, None]
image = np.concatenate([image, image, image], axis=2)
image = Image.fromarray(image)

controlnet_conditioning_scale = 0.5  # recommended for good generalization

pipe = NeuronStableDiffusionXLControlNetPipeline.from_pretrained("sdxl_neuron_controlnet")

images = pipe(
    prompt,
    negative_prompt=negative_prompt,
    image=image,
    controlnet_conditioning_scale=controlnet_conditioning_scale,
).images
images[0].save("hug_lab.png")

stable diffusion xl generated image with controlnet.

您希望我们在🤗Optimum-neuron中支持任何其他稳定扩散功能吗？请在Optimum-neuron Github 仓库中提交问题，或在HuggingFace 的社区论坛上与我们讨论，欢呼🤗！

←AWS Inferentia上的句子转换器设置AWS Trainium实例→