|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
import gc |
|
import random |
|
import tempfile |
|
import unittest |
|
|
|
import numpy as np |
|
import torch |
|
from PIL import Image |
|
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer |
|
|
|
from diffusers import ( |
|
AutoencoderKL, |
|
ControlNetModel, |
|
DDIMScheduler, |
|
StableDiffusionControlNetImg2ImgPipeline, |
|
UNet2DConditionModel, |
|
) |
|
from diffusers.pipelines.controlnet.pipeline_controlnet import MultiControlNetModel |
|
from diffusers.utils import load_image |
|
from diffusers.utils.import_utils import is_xformers_available |
|
from diffusers.utils.testing_utils import ( |
|
enable_full_determinism, |
|
floats_tensor, |
|
load_numpy, |
|
require_torch_gpu, |
|
slow, |
|
torch_device, |
|
) |
|
from diffusers.utils.torch_utils import randn_tensor |
|
|
|
from ..pipeline_params import ( |
|
IMAGE_TO_IMAGE_IMAGE_PARAMS, |
|
TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, |
|
TEXT_GUIDED_IMAGE_VARIATION_PARAMS, |
|
) |
|
from ..test_pipelines_common import ( |
|
IPAdapterTesterMixin, |
|
PipelineKarrasSchedulerTesterMixin, |
|
PipelineLatentTesterMixin, |
|
PipelineTesterMixin, |
|
) |
|
|
|
|
|
enable_full_determinism() |
|
|
|
|
|
class ControlNetImg2ImgPipelineFastTests( |
|
IPAdapterTesterMixin, |
|
PipelineLatentTesterMixin, |
|
PipelineKarrasSchedulerTesterMixin, |
|
PipelineTesterMixin, |
|
unittest.TestCase, |
|
): |
|
pipeline_class = StableDiffusionControlNetImg2ImgPipeline |
|
params = TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"height", "width"} |
|
batch_params = TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS |
|
image_params = IMAGE_TO_IMAGE_IMAGE_PARAMS.union({"control_image"}) |
|
image_latents_params = IMAGE_TO_IMAGE_IMAGE_PARAMS |
|
|
|
def get_dummy_components(self): |
|
torch.manual_seed(0) |
|
unet = UNet2DConditionModel( |
|
block_out_channels=(4, 8), |
|
layers_per_block=2, |
|
sample_size=32, |
|
in_channels=4, |
|
out_channels=4, |
|
down_block_types=("DownBlock2D", "CrossAttnDownBlock2D"), |
|
up_block_types=("CrossAttnUpBlock2D", "UpBlock2D"), |
|
cross_attention_dim=32, |
|
norm_num_groups=1, |
|
) |
|
torch.manual_seed(0) |
|
controlnet = ControlNetModel( |
|
block_out_channels=(4, 8), |
|
layers_per_block=2, |
|
in_channels=4, |
|
down_block_types=("DownBlock2D", "CrossAttnDownBlock2D"), |
|
cross_attention_dim=32, |
|
conditioning_embedding_out_channels=(16, 32), |
|
norm_num_groups=1, |
|
) |
|
torch.manual_seed(0) |
|
scheduler = DDIMScheduler( |
|
beta_start=0.00085, |
|
beta_end=0.012, |
|
beta_schedule="scaled_linear", |
|
clip_sample=False, |
|
set_alpha_to_one=False, |
|
) |
|
torch.manual_seed(0) |
|
vae = AutoencoderKL( |
|
block_out_channels=[4, 8], |
|
in_channels=3, |
|
out_channels=3, |
|
down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"], |
|
up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"], |
|
latent_channels=4, |
|
norm_num_groups=2, |
|
) |
|
torch.manual_seed(0) |
|
text_encoder_config = CLIPTextConfig( |
|
bos_token_id=0, |
|
eos_token_id=2, |
|
hidden_size=32, |
|
intermediate_size=37, |
|
layer_norm_eps=1e-05, |
|
num_attention_heads=4, |
|
num_hidden_layers=5, |
|
pad_token_id=1, |
|
vocab_size=1000, |
|
) |
|
text_encoder = CLIPTextModel(text_encoder_config) |
|
tokenizer = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip") |
|
|
|
components = { |
|
"unet": unet, |
|
"controlnet": controlnet, |
|
"scheduler": scheduler, |
|
"vae": vae, |
|
"text_encoder": text_encoder, |
|
"tokenizer": tokenizer, |
|
"safety_checker": None, |
|
"feature_extractor": None, |
|
"image_encoder": None, |
|
} |
|
return components |
|
|
|
def get_dummy_inputs(self, device, seed=0): |
|
if str(device).startswith("mps"): |
|
generator = torch.manual_seed(seed) |
|
else: |
|
generator = torch.Generator(device=device).manual_seed(seed) |
|
|
|
controlnet_embedder_scale_factor = 2 |
|
control_image = randn_tensor( |
|
(1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor), |
|
generator=generator, |
|
device=torch.device(device), |
|
) |
|
image = floats_tensor(control_image.shape, rng=random.Random(seed)).to(device) |
|
image = image.cpu().permute(0, 2, 3, 1)[0] |
|
image = Image.fromarray(np.uint8(image)).convert("RGB").resize((64, 64)) |
|
inputs = { |
|
"prompt": "A painting of a squirrel eating a burger", |
|
"generator": generator, |
|
"num_inference_steps": 2, |
|
"guidance_scale": 6.0, |
|
"output_type": "np", |
|
"image": image, |
|
"control_image": control_image, |
|
} |
|
|
|
return inputs |
|
|
|
def test_attention_slicing_forward_pass(self): |
|
return self._test_attention_slicing_forward_pass(expected_max_diff=2e-3) |
|
|
|
def test_ip_adapter_single(self): |
|
expected_pipe_slice = None |
|
if torch_device == "cpu": |
|
expected_pipe_slice = np.array([0.7096, 0.5149, 0.3571, 0.5897, 0.4715, 0.4052, 0.6098, 0.6886, 0.4213]) |
|
return super().test_ip_adapter_single(expected_pipe_slice=expected_pipe_slice) |
|
|
|
@unittest.skipIf( |
|
torch_device != "cuda" or not is_xformers_available(), |
|
reason="XFormers attention is only available with CUDA and `xformers` installed", |
|
) |
|
def test_xformers_attention_forwardGenerator_pass(self): |
|
self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3) |
|
|
|
def test_inference_batch_single_identical(self): |
|
self._test_inference_batch_single_identical(expected_max_diff=2e-3) |
|
|
|
|
|
class StableDiffusionMultiControlNetPipelineFastTests( |
|
IPAdapterTesterMixin, PipelineTesterMixin, PipelineKarrasSchedulerTesterMixin, unittest.TestCase |
|
): |
|
pipeline_class = StableDiffusionControlNetImg2ImgPipeline |
|
params = TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"height", "width"} |
|
batch_params = TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS |
|
image_params = frozenset([]) |
|
|
|
def get_dummy_components(self): |
|
torch.manual_seed(0) |
|
unet = UNet2DConditionModel( |
|
block_out_channels=(4, 8), |
|
layers_per_block=2, |
|
sample_size=32, |
|
in_channels=4, |
|
out_channels=4, |
|
down_block_types=("DownBlock2D", "CrossAttnDownBlock2D"), |
|
up_block_types=("CrossAttnUpBlock2D", "UpBlock2D"), |
|
cross_attention_dim=32, |
|
norm_num_groups=1, |
|
) |
|
torch.manual_seed(0) |
|
|
|
def init_weights(m): |
|
if isinstance(m, torch.nn.Conv2d): |
|
torch.nn.init.normal_(m.weight) |
|
m.bias.data.fill_(1.0) |
|
|
|
controlnet1 = ControlNetModel( |
|
block_out_channels=(4, 8), |
|
layers_per_block=2, |
|
in_channels=4, |
|
down_block_types=("DownBlock2D", "CrossAttnDownBlock2D"), |
|
cross_attention_dim=32, |
|
conditioning_embedding_out_channels=(16, 32), |
|
norm_num_groups=1, |
|
) |
|
controlnet1.controlnet_down_blocks.apply(init_weights) |
|
|
|
torch.manual_seed(0) |
|
controlnet2 = ControlNetModel( |
|
block_out_channels=(4, 8), |
|
layers_per_block=2, |
|
in_channels=4, |
|
down_block_types=("DownBlock2D", "CrossAttnDownBlock2D"), |
|
cross_attention_dim=32, |
|
conditioning_embedding_out_channels=(16, 32), |
|
norm_num_groups=1, |
|
) |
|
controlnet2.controlnet_down_blocks.apply(init_weights) |
|
|
|
torch.manual_seed(0) |
|
scheduler = DDIMScheduler( |
|
beta_start=0.00085, |
|
beta_end=0.012, |
|
beta_schedule="scaled_linear", |
|
clip_sample=False, |
|
set_alpha_to_one=False, |
|
) |
|
torch.manual_seed(0) |
|
vae = AutoencoderKL( |
|
block_out_channels=[4, 8], |
|
in_channels=3, |
|
out_channels=3, |
|
down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"], |
|
up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"], |
|
latent_channels=4, |
|
norm_num_groups=2, |
|
) |
|
torch.manual_seed(0) |
|
text_encoder_config = CLIPTextConfig( |
|
bos_token_id=0, |
|
eos_token_id=2, |
|
hidden_size=32, |
|
intermediate_size=37, |
|
layer_norm_eps=1e-05, |
|
num_attention_heads=4, |
|
num_hidden_layers=5, |
|
pad_token_id=1, |
|
vocab_size=1000, |
|
) |
|
text_encoder = CLIPTextModel(text_encoder_config) |
|
tokenizer = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip") |
|
|
|
controlnet = MultiControlNetModel([controlnet1, controlnet2]) |
|
|
|
components = { |
|
"unet": unet, |
|
"controlnet": controlnet, |
|
"scheduler": scheduler, |
|
"vae": vae, |
|
"text_encoder": text_encoder, |
|
"tokenizer": tokenizer, |
|
"safety_checker": None, |
|
"feature_extractor": None, |
|
"image_encoder": None, |
|
} |
|
return components |
|
|
|
def get_dummy_inputs(self, device, seed=0): |
|
if str(device).startswith("mps"): |
|
generator = torch.manual_seed(seed) |
|
else: |
|
generator = torch.Generator(device=device).manual_seed(seed) |
|
|
|
controlnet_embedder_scale_factor = 2 |
|
|
|
control_image = [ |
|
randn_tensor( |
|
(1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor), |
|
generator=generator, |
|
device=torch.device(device), |
|
), |
|
randn_tensor( |
|
(1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor), |
|
generator=generator, |
|
device=torch.device(device), |
|
), |
|
] |
|
|
|
image = floats_tensor(control_image[0].shape, rng=random.Random(seed)).to(device) |
|
image = image.cpu().permute(0, 2, 3, 1)[0] |
|
image = Image.fromarray(np.uint8(image)).convert("RGB").resize((64, 64)) |
|
inputs = { |
|
"prompt": "A painting of a squirrel eating a burger", |
|
"generator": generator, |
|
"num_inference_steps": 2, |
|
"guidance_scale": 6.0, |
|
"output_type": "np", |
|
"image": image, |
|
"control_image": control_image, |
|
} |
|
|
|
return inputs |
|
|
|
def test_control_guidance_switch(self): |
|
components = self.get_dummy_components() |
|
pipe = self.pipeline_class(**components) |
|
pipe.to(torch_device) |
|
|
|
scale = 10.0 |
|
steps = 4 |
|
|
|
inputs = self.get_dummy_inputs(torch_device) |
|
inputs["num_inference_steps"] = steps |
|
inputs["controlnet_conditioning_scale"] = scale |
|
output_1 = pipe(**inputs)[0] |
|
|
|
inputs = self.get_dummy_inputs(torch_device) |
|
inputs["num_inference_steps"] = steps |
|
inputs["controlnet_conditioning_scale"] = scale |
|
output_2 = pipe(**inputs, control_guidance_start=0.1, control_guidance_end=0.2)[0] |
|
|
|
inputs = self.get_dummy_inputs(torch_device) |
|
inputs["num_inference_steps"] = steps |
|
inputs["controlnet_conditioning_scale"] = scale |
|
output_3 = pipe(**inputs, control_guidance_start=[0.1, 0.3], control_guidance_end=[0.2, 0.7])[0] |
|
|
|
inputs = self.get_dummy_inputs(torch_device) |
|
inputs["num_inference_steps"] = steps |
|
inputs["controlnet_conditioning_scale"] = scale |
|
output_4 = pipe(**inputs, control_guidance_start=0.4, control_guidance_end=[0.5, 0.8])[0] |
|
|
|
|
|
assert np.sum(np.abs(output_1 - output_2)) > 1e-3 |
|
assert np.sum(np.abs(output_1 - output_3)) > 1e-3 |
|
assert np.sum(np.abs(output_1 - output_4)) > 1e-3 |
|
|
|
def test_attention_slicing_forward_pass(self): |
|
return self._test_attention_slicing_forward_pass(expected_max_diff=2e-3) |
|
|
|
@unittest.skipIf( |
|
torch_device != "cuda" or not is_xformers_available(), |
|
reason="XFormers attention is only available with CUDA and `xformers` installed", |
|
) |
|
def test_xformers_attention_forwardGenerator_pass(self): |
|
self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3) |
|
|
|
def test_inference_batch_single_identical(self): |
|
self._test_inference_batch_single_identical(expected_max_diff=2e-3) |
|
|
|
def test_ip_adapter_single(self): |
|
expected_pipe_slice = None |
|
if torch_device == "cpu": |
|
expected_pipe_slice = np.array([0.5293, 0.7339, 0.6642, 0.3950, 0.5212, 0.5175, 0.7002, 0.5907, 0.5182]) |
|
return super().test_ip_adapter_single(expected_pipe_slice=expected_pipe_slice) |
|
|
|
def test_save_pretrained_raise_not_implemented_exception(self): |
|
components = self.get_dummy_components() |
|
pipe = self.pipeline_class(**components) |
|
pipe.to(torch_device) |
|
pipe.set_progress_bar_config(disable=None) |
|
with tempfile.TemporaryDirectory() as tmpdir: |
|
try: |
|
|
|
pipe.save_pretrained(tmpdir) |
|
except NotImplementedError: |
|
pass |
|
|
|
|
|
@slow |
|
@require_torch_gpu |
|
class ControlNetImg2ImgPipelineSlowTests(unittest.TestCase): |
|
def setUp(self): |
|
super().setUp() |
|
gc.collect() |
|
torch.cuda.empty_cache() |
|
|
|
def tearDown(self): |
|
super().tearDown() |
|
gc.collect() |
|
torch.cuda.empty_cache() |
|
|
|
def test_canny(self): |
|
controlnet = ControlNetModel.from_pretrained("lllyasviel/sd-controlnet-canny") |
|
|
|
pipe = StableDiffusionControlNetImg2ImgPipeline.from_pretrained( |
|
"runwayml/stable-diffusion-v1-5", safety_checker=None, controlnet=controlnet |
|
) |
|
pipe.enable_model_cpu_offload() |
|
pipe.set_progress_bar_config(disable=None) |
|
|
|
generator = torch.Generator(device="cpu").manual_seed(0) |
|
prompt = "evil space-punk bird" |
|
control_image = load_image( |
|
"https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png" |
|
).resize((512, 512)) |
|
image = load_image( |
|
"https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png" |
|
).resize((512, 512)) |
|
|
|
output = pipe( |
|
prompt, |
|
image, |
|
control_image=control_image, |
|
generator=generator, |
|
output_type="np", |
|
num_inference_steps=50, |
|
strength=0.6, |
|
) |
|
|
|
image = output.images[0] |
|
|
|
assert image.shape == (512, 512, 3) |
|
|
|
expected_image = load_numpy( |
|
"https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/img2img.npy" |
|
) |
|
|
|
assert np.abs(expected_image - image).max() < 9e-2 |
|
|