pipeline_stable_diffusion.py 42.7 KB
Newer Older
Patrick von Platen's avatar
Patrick von Platen committed
1
# Copyright 2023 The HuggingFace Team. All rights reserved.
2
3
4
5
6
7
8
9
10
11
12
13
14
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

Suraj Patil's avatar
Suraj Patil committed
15
import inspect
16
from typing import Any, Callable, Dict, List, Optional, Union
Suraj Patil's avatar
Suraj Patil committed
17
18

import torch
19
from packaging import version
20
from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer
Suraj Patil's avatar
Suraj Patil committed
21

22
from ...configuration_utils import FrozenDict
23
from ...image_processor import VaeImageProcessor
Patrick von Platen's avatar
Patrick von Platen committed
24
from ...loaders import FromSingleFileMixin, LoraLoaderMixin, TextualInversionLoaderMixin
Suraj Patil's avatar
Suraj Patil committed
25
from ...models import AutoencoderKL, UNet2DConditionModel
26
from ...models.lora import adjust_lora_scale_text_encoder
Kashif Rasul's avatar
Kashif Rasul committed
27
from ...schedulers import KarrasDiffusionSchedulers
28
29
30
31
32
33
34
35
from ...utils import (
    USE_PEFT_BACKEND,
    deprecate,
    logging,
    replace_example_docstring,
    scale_lora_layers,
    unscale_lora_layers,
)
Dhruv Nair's avatar
Dhruv Nair committed
36
from ...utils.torch_utils import randn_tensor
37
from ..pipeline_utils import DiffusionPipeline
38
from .pipeline_output import StableDiffusionPipelineOutput
Suraj Patil's avatar
Suraj Patil committed
39
from .safety_checker import StableDiffusionSafetyChecker
Suraj Patil's avatar
Suraj Patil committed
40
41


42
43
logger = logging.get_logger(__name__)  # pylint: disable=invalid-name

44
45
46
47
48
49
50
51
52
53
54
55
56
57
EXAMPLE_DOC_STRING = """
    Examples:
        ```py
        >>> import torch
        >>> from diffusers import StableDiffusionPipeline

        >>> pipe = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5", torch_dtype=torch.float16)
        >>> pipe = pipe.to("cuda")

        >>> prompt = "a photo of an astronaut riding a horse on mars"
        >>> image = pipe(prompt).images[0]
        ```
"""

58

59
60
61
62
63
64
65
66
67
68
69
70
71
72
def rescale_noise_cfg(noise_cfg, noise_pred_text, guidance_rescale=0.0):
    """
    Rescale `noise_cfg` according to `guidance_rescale`. Based on findings of [Common Diffusion Noise Schedules and
    Sample Steps are Flawed](https://arxiv.org/pdf/2305.08891.pdf). See Section 3.4
    """
    std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True)
    std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True)
    # rescale the results from guidance (fixes overexposure)
    noise_pred_rescaled = noise_cfg * (std_text / std_cfg)
    # mix with the original results from guidance by factor guidance_rescale to avoid "plain looking" images
    noise_cfg = guidance_rescale * noise_pred_rescaled + (1 - guidance_rescale) * noise_cfg
    return noise_cfg


Patrick von Platen's avatar
Patrick von Platen committed
73
class StableDiffusionPipeline(DiffusionPipeline, TextualInversionLoaderMixin, LoraLoaderMixin, FromSingleFileMixin):
74
75
76
    r"""
    Pipeline for text-to-image generation using Stable Diffusion.

77
78
    This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods
    implemented for all pipelines (downloading, saving, running on a particular device, etc.).
79

80
81
82
83
84
    The pipeline also inherits the following loading methods:
        - [`~loaders.TextualInversionLoaderMixin.load_textual_inversion`] for loading textual inversion embeddings
        - [`~loaders.LoraLoaderMixin.load_lora_weights`] for loading LoRA weights
        - [`~loaders.LoraLoaderMixin.save_lora_weights`] for saving LoRA weights
        - [`~loaders.FromSingleFileMixin.from_single_file`] for loading `.ckpt` files
1lint's avatar
1lint committed
85

86
87
    Args:
        vae ([`AutoencoderKL`]):
88
89
90
91
92
93
94
            Variational Auto-Encoder (VAE) model to encode and decode images to and from latent representations.
        text_encoder ([`~transformers.CLIPTextModel`]):
            Frozen text-encoder ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)).
        tokenizer ([`~transformers.CLIPTokenizer`]):
            A `CLIPTokenizer` to tokenize text.
        unet ([`UNet2DConditionModel`]):
            A `UNet2DConditionModel` to denoise the encoded image latents.
95
        scheduler ([`SchedulerMixin`]):
96
            A scheduler to be used in combination with `unet` to denoise the encoded image latents. Can be one of
97
98
            [`DDIMScheduler`], [`LMSDiscreteScheduler`], or [`PNDMScheduler`].
        safety_checker ([`StableDiffusionSafetyChecker`]):
99
            Classification module that estimates whether generated images could be considered offensive or harmful.
100
101
102
103
            Please refer to the [model card](https://huggingface.co/runwayml/stable-diffusion-v1-5) for more details
            about a model's potential harms.
        feature_extractor ([`~transformers.CLIPImageProcessor`]):
            A `CLIPImageProcessor` to extract features from generated images; used as inputs to the `safety_checker`.
104
    """
105
    model_cpu_offload_seq = "text_encoder->unet->vae"
106
    _optional_components = ["safety_checker", "feature_extractor"]
107
    _exclude_from_cpu_offload = ["safety_checker"]
108
    _callback_tensor_inputs = ["latents", "prompt_embeds", "negative_prompt_embeds"]
109

Suraj Patil's avatar
Suraj Patil committed
110
111
112
113
114
115
    def __init__(
        self,
        vae: AutoencoderKL,
        text_encoder: CLIPTextModel,
        tokenizer: CLIPTokenizer,
        unet: UNet2DConditionModel,
Kashif Rasul's avatar
Kashif Rasul committed
116
        scheduler: KarrasDiffusionSchedulers,
Suraj Patil's avatar
Suraj Patil committed
117
        safety_checker: StableDiffusionSafetyChecker,
118
        feature_extractor: CLIPImageProcessor,
119
        requires_safety_checker: bool = True,
Suraj Patil's avatar
Suraj Patil committed
120
121
    ):
        super().__init__()
122
123

        if hasattr(scheduler.config, "steps_offset") and scheduler.config.steps_offset != 1:
124
            deprecation_message = (
125
                f"The configuration file of this scheduler: {scheduler} is outdated. `steps_offset`"
Yuta Hayashibe's avatar
Yuta Hayashibe committed
126
                f" should be set to 1 instead of {scheduler.config.steps_offset}. Please make sure "
127
128
129
                "to update the config accordingly as leaving `steps_offset` might led to incorrect results"
                " in future versions. If you have downloaded this checkpoint from the Hugging Face Hub,"
                " it would be very nice if you could open a Pull request for the `scheduler/scheduler_config.json`"
130
                " file"
131
            )
132
            deprecate("steps_offset!=1", "1.0.0", deprecation_message, standard_warn=False)
133
134
135
136
            new_config = dict(scheduler.config)
            new_config["steps_offset"] = 1
            scheduler._internal_dict = FrozenDict(new_config)

137
138
139
140
141
142
143
144
145
146
147
148
149
        if hasattr(scheduler.config, "clip_sample") and scheduler.config.clip_sample is True:
            deprecation_message = (
                f"The configuration file of this scheduler: {scheduler} has not set the configuration `clip_sample`."
                " `clip_sample` should be set to False in the configuration file. Please make sure to update the"
                " config accordingly as not setting `clip_sample` in the config might lead to incorrect results in"
                " future versions. If you have downloaded this checkpoint from the Hugging Face Hub, it would be very"
                " nice if you could open a Pull request for the `scheduler/scheduler_config.json` file"
            )
            deprecate("clip_sample not set", "1.0.0", deprecation_message, standard_warn=False)
            new_config = dict(scheduler.config)
            new_config["clip_sample"] = False
            scheduler._internal_dict = FrozenDict(new_config)

150
        if safety_checker is None and requires_safety_checker:
151
            logger.warning(
152
                f"You have disabled the safety checker for {self.__class__} by passing `safety_checker=None`. Ensure"
153
154
155
156
157
158
159
                " that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered"
                " results in services or applications open to the public. Both the diffusers team and Hugging Face"
                " strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling"
                " it only for use-cases that involve analyzing network behavior or auditing its results. For more"
                " information, please have a look at https://github.com/huggingface/diffusers/pull/254 ."
            )

160
161
162
163
164
165
        if safety_checker is not None and feature_extractor is None:
            raise ValueError(
                "Make sure to define a feature extractor when loading {self.__class__} if you want to use the safety"
                " checker. If you do not want to use the safety checker, you can pass `'safety_checker=None'` instead."
            )

166
167
168
169
170
171
172
        is_unet_version_less_0_9_0 = hasattr(unet.config, "_diffusers_version") and version.parse(
            version.parse(unet.config._diffusers_version).base_version
        ) < version.parse("0.9.0.dev0")
        is_unet_sample_size_less_64 = hasattr(unet.config, "sample_size") and unet.config.sample_size < 64
        if is_unet_version_less_0_9_0 and is_unet_sample_size_less_64:
            deprecation_message = (
                "The configuration file of the unet has set the default `sample_size` to smaller than"
Pedro Cuenca's avatar
Pedro Cuenca committed
173
                " 64 which seems highly unlikely. If your checkpoint is a fine-tuned version of any of the"
174
175
176
177
178
179
180
181
182
183
184
185
186
                " following: \n- CompVis/stable-diffusion-v1-4 \n- CompVis/stable-diffusion-v1-3 \n-"
                " CompVis/stable-diffusion-v1-2 \n- CompVis/stable-diffusion-v1-1 \n- runwayml/stable-diffusion-v1-5"
                " \n- runwayml/stable-diffusion-inpainting \n you should change 'sample_size' to 64 in the"
                " configuration file. Please make sure to update the config accordingly as leaving `sample_size=32`"
                " in the config might lead to incorrect results in future versions. If you have downloaded this"
                " checkpoint from the Hugging Face Hub, it would be very nice if you could open a Pull request for"
                " the `unet/config.json` file"
            )
            deprecate("sample_size<64", "1.0.0", deprecation_message, standard_warn=False)
            new_config = dict(unet.config)
            new_config["sample_size"] = 64
            unet._internal_dict = FrozenDict(new_config)

Suraj Patil's avatar
Suraj Patil committed
187
188
189
190
191
192
193
194
195
        self.register_modules(
            vae=vae,
            text_encoder=text_encoder,
            tokenizer=tokenizer,
            unet=unet,
            scheduler=scheduler,
            safety_checker=safety_checker,
            feature_extractor=feature_extractor,
        )
Patrick von Platen's avatar
Patrick von Platen committed
196
        self.vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1)
197
        self.image_processor = VaeImageProcessor(vae_scale_factor=self.vae_scale_factor)
198
        self.register_to_config(requires_safety_checker=requires_safety_checker)
Suraj Patil's avatar
Suraj Patil committed
199

200
201
    def enable_vae_slicing(self):
        r"""
202
203
        Enable sliced VAE decoding. When this option is enabled, the VAE will split the input tensor in slices to
        compute decoding in several steps. This is useful to save some memory and allow larger batch sizes.
204
205
206
207
208
        """
        self.vae.enable_slicing()

    def disable_vae_slicing(self):
        r"""
209
        Disable sliced VAE decoding. If `enable_vae_slicing` was previously enabled, this method will go back to
210
211
212
213
        computing decoding in one step.
        """
        self.vae.disable_slicing()

214
215
    def enable_vae_tiling(self):
        r"""
216
217
218
        Enable tiled VAE decoding. When this option is enabled, the VAE will split the input tensor into tiles to
        compute decoding and encoding in several steps. This is useful for saving a large amount of memory and to allow
        processing larger images.
219
220
221
222
223
        """
        self.vae.enable_tiling()

    def disable_vae_tiling(self):
        r"""
224
        Disable tiled VAE decoding. If `enable_vae_tiling` was previously enabled, this method will go back to
225
226
227
228
        computing decoding in one step.
        """
        self.vae.disable_tiling()

229
230
231
232
233
234
235
236
237
    def _encode_prompt(
        self,
        prompt,
        device,
        num_images_per_prompt,
        do_classifier_free_guidance,
        negative_prompt=None,
        prompt_embeds: Optional[torch.FloatTensor] = None,
        negative_prompt_embeds: Optional[torch.FloatTensor] = None,
238
        lora_scale: Optional[float] = None,
239
        **kwargs,
240
241
242
243
244
245
246
247
248
249
250
251
252
    ):
        deprecation_message = "`_encode_prompt()` is deprecated and it will be removed in a future version. Use `encode_prompt()` instead. Also, be aware that the output format changed from a concatenated tensor to a tuple."
        deprecate("_encode_prompt()", "1.0.0", deprecation_message, standard_warn=False)

        prompt_embeds_tuple = self.encode_prompt(
            prompt=prompt,
            device=device,
            num_images_per_prompt=num_images_per_prompt,
            do_classifier_free_guidance=do_classifier_free_guidance,
            negative_prompt=negative_prompt,
            prompt_embeds=prompt_embeds,
            negative_prompt_embeds=negative_prompt_embeds,
            lora_scale=lora_scale,
253
            **kwargs,
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
        )

        # concatenate for backwards comp
        prompt_embeds = torch.cat([prompt_embeds_tuple[1], prompt_embeds_tuple[0]])

        return prompt_embeds

    def encode_prompt(
        self,
        prompt,
        device,
        num_images_per_prompt,
        do_classifier_free_guidance,
        negative_prompt=None,
        prompt_embeds: Optional[torch.FloatTensor] = None,
        negative_prompt_embeds: Optional[torch.FloatTensor] = None,
        lora_scale: Optional[float] = None,
271
        clip_skip: Optional[int] = None,
272
    ):
273
274
275
276
        r"""
        Encodes the prompt into text encoder hidden states.

        Args:
277
            prompt (`str` or `List[str]`, *optional*):
278
279
280
281
282
283
284
                prompt to be encoded
            device: (`torch.device`):
                torch device
            num_images_per_prompt (`int`):
                number of images that should be generated per prompt
            do_classifier_free_guidance (`bool`):
                whether to use classifier free guidance or not
285
            negative_prompt (`str` or `List[str]`, *optional*):
286
                The prompt or prompts not to guide the image generation. If not defined, one has to pass
287
288
                `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is
                less than `1`).
289
290
291
292
293
294
295
            prompt_embeds (`torch.FloatTensor`, *optional*):
                Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not
                provided, text embeddings will be generated from `prompt` input argument.
            negative_prompt_embeds (`torch.FloatTensor`, *optional*):
                Pre-generated negative text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt
                weighting. If not provided, negative_prompt_embeds will be generated from `negative_prompt` input
                argument.
296
            lora_scale (`float`, *optional*):
297
298
299
300
                A LoRA scale that will be applied to all LoRA layers of the text encoder if LoRA layers are loaded.
            clip_skip (`int`, *optional*):
                Number of layers to be skipped from CLIP while computing the prompt embeddings. A value of 1 means that
                the output of the pre-final layer will be used for computing the prompt embeddings.
301
        """
302
303
304
305
306
        # set lora scale so that monkey patched LoRA
        # function of text encoder can correctly access it
        if lora_scale is not None and isinstance(self, LoraLoaderMixin):
            self._lora_scale = lora_scale

307
            # dynamically adjust the LoRA scale
308
            if not USE_PEFT_BACKEND:
309
310
311
                adjust_lora_scale_text_encoder(self.text_encoder, lora_scale)
            else:
                scale_lora_layers(self.text_encoder, lora_scale)
312

313
314
315
316
317
318
        if prompt is not None and isinstance(prompt, str):
            batch_size = 1
        elif prompt is not None and isinstance(prompt, list):
            batch_size = len(prompt)
        else:
            batch_size = prompt_embeds.shape[0]
319

320
        if prompt_embeds is None:
321
322
323
324
            # textual inversion: procecss multi-vector tokens if necessary
            if isinstance(self, TextualInversionLoaderMixin):
                prompt = self.maybe_convert_prompt(prompt, self.tokenizer)

325
326
327
328
329
330
            text_inputs = self.tokenizer(
                prompt,
                padding="max_length",
                max_length=self.tokenizer.model_max_length,
                truncation=True,
                return_tensors="pt",
331
            )
332
333
            text_input_ids = text_inputs.input_ids
            untruncated_ids = self.tokenizer(prompt, padding="longest", return_tensors="pt").input_ids
Patrick von Platen's avatar
Patrick von Platen committed
334

335
336
337
338
339
340
341
342
343
344
            if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(
                text_input_ids, untruncated_ids
            ):
                removed_text = self.tokenizer.batch_decode(
                    untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1]
                )
                logger.warning(
                    "The following part of your input was truncated because CLIP can only handle sequences up to"
                    f" {self.tokenizer.model_max_length} tokens: {removed_text}"
                )
Patrick von Platen's avatar
Patrick von Platen committed
345

346
347
348
349
            if hasattr(self.text_encoder.config, "use_attention_mask") and self.text_encoder.config.use_attention_mask:
                attention_mask = text_inputs.attention_mask.to(device)
            else:
                attention_mask = None
350

351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
            if clip_skip is None:
                prompt_embeds = self.text_encoder(text_input_ids.to(device), attention_mask=attention_mask)
                prompt_embeds = prompt_embeds[0]
            else:
                prompt_embeds = self.text_encoder(
                    text_input_ids.to(device), attention_mask=attention_mask, output_hidden_states=True
                )
                # Access the `hidden_states` first, that contains a tuple of
                # all the hidden states from the encoder layers. Then index into
                # the tuple to access the hidden states from the desired layer.
                prompt_embeds = prompt_embeds[-1][-(clip_skip + 1)]
                # We also need to apply the final LayerNorm here to not mess with the
                # representations. The `last_hidden_states` that we typically use for
                # obtaining the final prompt representations passes through the LayerNorm
                # layer.
                prompt_embeds = self.text_encoder.text_model.final_layer_norm(prompt_embeds)
367

368
369
370
371
372
373
374
375
        if self.text_encoder is not None:
            prompt_embeds_dtype = self.text_encoder.dtype
        elif self.unet is not None:
            prompt_embeds_dtype = self.unet.dtype
        else:
            prompt_embeds_dtype = prompt_embeds.dtype

        prompt_embeds = prompt_embeds.to(dtype=prompt_embeds_dtype, device=device)
376
377

        bs_embed, seq_len, _ = prompt_embeds.shape
378
        # duplicate text embeddings for each generation per prompt, using mps friendly method
379
380
        prompt_embeds = prompt_embeds.repeat(1, num_images_per_prompt, 1)
        prompt_embeds = prompt_embeds.view(bs_embed * num_images_per_prompt, seq_len, -1)
381
382

        # get unconditional embeddings for classifier free guidance
383
        if do_classifier_free_guidance and negative_prompt_embeds is None:
384
385
386
            uncond_tokens: List[str]
            if negative_prompt is None:
                uncond_tokens = [""] * batch_size
387
            elif prompt is not None and type(prompt) is not type(negative_prompt):
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
                raise TypeError(
                    f"`negative_prompt` should be the same type to `prompt`, but got {type(negative_prompt)} !="
                    f" {type(prompt)}."
                )
            elif isinstance(negative_prompt, str):
                uncond_tokens = [negative_prompt]
            elif batch_size != len(negative_prompt):
                raise ValueError(
                    f"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:"
                    f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"
                    " the batch size of `prompt`."
                )
            else:
                uncond_tokens = negative_prompt

403
404
405
406
            # textual inversion: procecss multi-vector tokens if necessary
            if isinstance(self, TextualInversionLoaderMixin):
                uncond_tokens = self.maybe_convert_prompt(uncond_tokens, self.tokenizer)

407
            max_length = prompt_embeds.shape[1]
408
409
410
411
412
413
414
            uncond_input = self.tokenizer(
                uncond_tokens,
                padding="max_length",
                max_length=max_length,
                truncation=True,
                return_tensors="pt",
            )
Patrick von Platen's avatar
Patrick von Platen committed
415
416
417
418
419
420

            if hasattr(self.text_encoder.config, "use_attention_mask") and self.text_encoder.config.use_attention_mask:
                attention_mask = uncond_input.attention_mask.to(device)
            else:
                attention_mask = None

421
            negative_prompt_embeds = self.text_encoder(
Patrick von Platen's avatar
Patrick von Platen committed
422
423
424
                uncond_input.input_ids.to(device),
                attention_mask=attention_mask,
            )
425
            negative_prompt_embeds = negative_prompt_embeds[0]
426

427
        if do_classifier_free_guidance:
428
            # duplicate unconditional embeddings for each generation per prompt, using mps friendly method
429
430
            seq_len = negative_prompt_embeds.shape[1]

431
            negative_prompt_embeds = negative_prompt_embeds.to(dtype=prompt_embeds_dtype, device=device)
432
433
434

            negative_prompt_embeds = negative_prompt_embeds.repeat(1, num_images_per_prompt, 1)
            negative_prompt_embeds = negative_prompt_embeds.view(batch_size * num_images_per_prompt, seq_len, -1)
435

436
        if isinstance(self, LoraLoaderMixin) and USE_PEFT_BACKEND:
437
            # Retrieve the original scale by scaling back the LoRA layers
438
            unscale_lora_layers(self.text_encoder, lora_scale)
439

440
        return prompt_embeds, negative_prompt_embeds
441

442
    def run_safety_checker(self, image, device, dtype):
443
444
445
446
447
448
449
450
        if self.safety_checker is None:
            has_nsfw_concept = None
        else:
            if torch.is_tensor(image):
                feature_extractor_input = self.image_processor.postprocess(image, output_type="pil")
            else:
                feature_extractor_input = self.image_processor.numpy_to_pil(image)
            safety_checker_input = self.feature_extractor(feature_extractor_input, return_tensors="pt").to(device)
451
452
453
454
455
456
            image, has_nsfw_concept = self.safety_checker(
                images=image, clip_input=safety_checker_input.pixel_values.to(dtype)
            )
        return image, has_nsfw_concept

    def decode_latents(self, latents):
457
458
459
        deprecation_message = "The decode_latents method is deprecated and will be removed in 1.0.0. Please use VaeImageProcessor.postprocess(...) instead"
        deprecate("decode_latents", "1.0.0", deprecation_message, standard_warn=False)

460
        latents = 1 / self.vae.config.scaling_factor * latents
461
        image = self.vae.decode(latents, return_dict=False)[0]
462
        image = (image / 2 + 0.5).clamp(0, 1)
463
        # we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
        image = image.cpu().permute(0, 2, 3, 1).float().numpy()
        return image

    def prepare_extra_step_kwargs(self, generator, eta):
        # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
        # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
        # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
        # and should be between [0, 1]

        accepts_eta = "eta" in set(inspect.signature(self.scheduler.step).parameters.keys())
        extra_step_kwargs = {}
        if accepts_eta:
            extra_step_kwargs["eta"] = eta

        # check if the scheduler accepts generator
        accepts_generator = "generator" in set(inspect.signature(self.scheduler.step).parameters.keys())
        if accepts_generator:
            extra_step_kwargs["generator"] = generator
        return extra_step_kwargs

484
485
486
487
488
489
490
491
492
    def check_inputs(
        self,
        prompt,
        height,
        width,
        callback_steps,
        negative_prompt=None,
        prompt_embeds=None,
        negative_prompt_embeds=None,
493
        callback_on_step_end_tensor_inputs=None,
494
    ):
495
496
497
        if height % 8 != 0 or width % 8 != 0:
            raise ValueError(f"`height` and `width` have to be divisible by 8 but are {height} and {width}.")

498
        if callback_steps is not None and (not isinstance(callback_steps, int) or callback_steps <= 0):
499
500
501
502
            raise ValueError(
                f"`callback_steps` has to be a positive integer but is {callback_steps} of type"
                f" {type(callback_steps)}."
            )
503
504
505
506
507
508
        if callback_on_step_end_tensor_inputs is not None and not all(
            k in self._callback_tensor_inputs for k in callback_on_step_end_tensor_inputs
        ):
            raise ValueError(
                f"`callback_on_step_end_tensor_inputs` has to be in {self._callback_tensor_inputs}, but found {[k for k in callback_on_step_end_tensor_inputs if k not in self._callback_tensor_inputs]}"
            )
509

510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
        if prompt is not None and prompt_embeds is not None:
            raise ValueError(
                f"Cannot forward both `prompt`: {prompt} and `prompt_embeds`: {prompt_embeds}. Please make sure to"
                " only forward one of the two."
            )
        elif prompt is None and prompt_embeds is None:
            raise ValueError(
                "Provide either `prompt` or `prompt_embeds`. Cannot leave both `prompt` and `prompt_embeds` undefined."
            )
        elif prompt is not None and (not isinstance(prompt, str) and not isinstance(prompt, list)):
            raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")

        if negative_prompt is not None and negative_prompt_embeds is not None:
            raise ValueError(
                f"Cannot forward both `negative_prompt`: {negative_prompt} and `negative_prompt_embeds`:"
                f" {negative_prompt_embeds}. Please make sure to only forward one of the two."
            )

        if prompt_embeds is not None and negative_prompt_embeds is not None:
            if prompt_embeds.shape != negative_prompt_embeds.shape:
                raise ValueError(
                    "`prompt_embeds` and `negative_prompt_embeds` must have the same shape when passed directly, but"
                    f" got: `prompt_embeds` {prompt_embeds.shape} != `negative_prompt_embeds`"
                    f" {negative_prompt_embeds.shape}."
                )

536
    def prepare_latents(self, batch_size, num_channels_latents, height, width, dtype, device, generator, latents=None):
Patrick von Platen's avatar
Patrick von Platen committed
537
        shape = (batch_size, num_channels_latents, height // self.vae_scale_factor, width // self.vae_scale_factor)
538
539
540
541
542
543
        if isinstance(generator, list) and len(generator) != batch_size:
            raise ValueError(
                f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
                f" size of {batch_size}. Make sure the batch size matches the length of the generators."
            )

544
        if latents is None:
545
            latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
546
547
548
549
550
551
552
        else:
            latents = latents.to(device)

        # scale the initial noise by the standard deviation required by the scheduler
        latents = latents * self.scheduler.init_noise_sigma
        return latents

553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
    def enable_freeu(self, s1: float, s2: float, b1: float, b2: float):
        r"""Enables the FreeU mechanism as in https://arxiv.org/abs/2309.11497.

        The suffixes after the scaling factors represent the stages where they are being applied.

        Please refer to the [official repository](https://github.com/ChenyangSi/FreeU) for combinations of the values
        that are known to work well for different pipelines such as Stable Diffusion v1, v2, and Stable Diffusion XL.

        Args:
            s1 (`float`):
                Scaling factor for stage 1 to attenuate the contributions of the skip features. This is done to
                mitigate "oversmoothing effect" in the enhanced denoising process.
            s2 (`float`):
                Scaling factor for stage 2 to attenuate the contributions of the skip features. This is done to
                mitigate "oversmoothing effect" in the enhanced denoising process.
            b1 (`float`): Scaling factor for stage 1 to amplify the contributions of backbone features.
            b2 (`float`): Scaling factor for stage 2 to amplify the contributions of backbone features.
        """
        if not hasattr(self, "unet"):
            raise ValueError("The pipeline must have `unet` for using FreeU.")
        self.unet.enable_freeu(s1=s1, s2=s2, b1=b1, b2=b2)

    def disable_freeu(self):
        """Disables the FreeU mechanism if enabled."""
        self.unet.disable_freeu()

579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
    @property
    def guidance_scale(self):
        return self._guidance_scale

    @property
    def guidance_rescale(self):
        return self._guidance_rescale

    @property
    def clip_skip(self):
        return self._clip_skip

    # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
    # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
    # corresponds to doing no classifier free guidance.
    @property
    def do_classifier_free_guidance(self):
        return self._guidance_scale > 1

    @property
    def cross_attention_kwargs(self):
        return self._cross_attention_kwargs

    @property
    def num_timesteps(self):
        return self._num_timesteps

Suraj Patil's avatar
Suraj Patil committed
606
    @torch.no_grad()
607
    @replace_example_docstring(EXAMPLE_DOC_STRING)
Suraj Patil's avatar
Suraj Patil committed
608
609
    def __call__(
        self,
610
        prompt: Union[str, List[str]] = None,
611
612
        height: Optional[int] = None,
        width: Optional[int] = None,
613
614
        num_inference_steps: int = 50,
        guidance_scale: float = 7.5,
615
        negative_prompt: Optional[Union[str, List[str]]] = None,
616
        num_images_per_prompt: Optional[int] = 1,
617
        eta: float = 0.0,
618
        generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
619
        latents: Optional[torch.FloatTensor] = None,
620
621
        prompt_embeds: Optional[torch.FloatTensor] = None,
        negative_prompt_embeds: Optional[torch.FloatTensor] = None,
Suraj Patil's avatar
Suraj Patil committed
622
        output_type: Optional[str] = "pil",
623
        return_dict: bool = True,
624
        cross_attention_kwargs: Optional[Dict[str, Any]] = None,
625
        guidance_rescale: float = 0.0,
626
        clip_skip: Optional[int] = None,
627
628
629
        callback_on_step_end: Optional[Callable[[int, int, Dict], None]] = None,
        callback_on_step_end_tensor_inputs: List[str] = ["latents"],
        **kwargs,
Suraj Patil's avatar
Suraj Patil committed
630
    ):
631
        r"""
632
        The call function to the pipeline for generation.
633
634

        Args:
635
            prompt (`str` or `List[str]`, *optional*):
636
637
                The prompt or prompts to guide image generation. If not defined, you need to pass `prompt_embeds`.
            height (`int`, *optional*, defaults to `self.unet.config.sample_size * self.vae_scale_factor`):
638
                The height in pixels of the generated image.
639
            width (`int`, *optional*, defaults to `self.unet.config.sample_size * self.vae_scale_factor`):
640
641
642
643
644
                The width in pixels of the generated image.
            num_inference_steps (`int`, *optional*, defaults to 50):
                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
                expense of slower inference.
            guidance_scale (`float`, *optional*, defaults to 7.5):
645
646
                A higher guidance scale value encourages the model to generate images closely linked to the text
                `prompt` at the expense of lower image quality. Guidance scale is enabled when `guidance_scale > 1`.
647
            negative_prompt (`str` or `List[str]`, *optional*):
648
649
                The prompt or prompts to guide what to not include in image generation. If not defined, you need to
                pass `negative_prompt_embeds` instead. Ignored when not using guidance (`guidance_scale < 1`).
650
651
            num_images_per_prompt (`int`, *optional*, defaults to 1):
                The number of images to generate per prompt.
652
            eta (`float`, *optional*, defaults to 0.0):
653
654
                Corresponds to parameter eta (η) from the [DDIM](https://arxiv.org/abs/2010.02502) paper. Only applies
                to the [`~schedulers.DDIMScheduler`], and is ignored in other schedulers.
655
            generator (`torch.Generator` or `List[torch.Generator]`, *optional*):
656
657
                A [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) to make
                generation deterministic.
658
            latents (`torch.FloatTensor`, *optional*):
659
                Pre-generated noisy latents sampled from a Gaussian distribution, to be used as inputs for image
660
                generation. Can be used to tweak the same generation with different prompts. If not provided, a latents
661
                tensor is generated by sampling using the supplied random `generator`.
662
            prompt_embeds (`torch.FloatTensor`, *optional*):
663
664
                Pre-generated text embeddings. Can be used to easily tweak text inputs (prompt weighting). If not
                provided, text embeddings are generated from the `prompt` input argument.
665
            negative_prompt_embeds (`torch.FloatTensor`, *optional*):
666
667
                Pre-generated negative text embeddings. Can be used to easily tweak text inputs (prompt weighting). If
                not provided, `negative_prompt_embeds` are generated from the `negative_prompt` input argument.
668
            output_type (`str`, *optional*, defaults to `"pil"`):
669
                The output format of the generated image. Choose between `PIL.Image` or `np.array`.
670
671
672
            return_dict (`bool`, *optional*, defaults to `True`):
                Whether or not to return a [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] instead of a
                plain tuple.
673
            cross_attention_kwargs (`dict`, *optional*):
674
                A kwargs dictionary that if specified is passed along to the [`AttentionProcessor`] as defined in
Patrick von Platen's avatar
Patrick von Platen committed
675
                [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
676
            guidance_rescale (`float`, *optional*, defaults to 0.0):
677
678
679
                Guidance rescale factor from [Common Diffusion Noise Schedules and Sample Steps are
                Flawed](https://arxiv.org/pdf/2305.08891.pdf). Guidance rescale factor should fix overexposure when
                using zero terminal SNR.
680
681
682
            clip_skip (`int`, *optional*):
                Number of layers to be skipped from CLIP while computing the prompt embeddings. A value of 1 means that
                the output of the pre-final layer will be used for computing the prompt embeddings.
683
684
685
686
687
688
689
690
691
            callback_on_step_end (`Callable`, *optional*):
                A function that calls at the end of each denoising steps during the inference. The function is called
                with the following arguments: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int,
                callback_kwargs: Dict)`. `callback_kwargs` will include a list of all tensors as specified by
                `callback_on_step_end_tensor_inputs`.
            callback_on_step_end_tensor_inputs (`List`, *optional*):
                The list of tensor inputs for the `callback_on_step_end` function. The tensors specified in the list
                will be passed as `callback_kwargs` argument. You will only be able to include variables listed in the
                `._callback_tensor_inputs` attribute of your pipeine class.
692

693
694
        Examples:

695
        Returns:
696
            [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] or `tuple`:
697
698
699
700
                If `return_dict` is `True`, [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] is returned,
                otherwise a `tuple` is returned where the first element is a list with the generated images and the
                second element is a list of `bool`s indicating whether the corresponding generated image contains
                "not-safe-for-work" (nsfw) content.
701
        """
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718

        callback = kwargs.pop("callback", None)
        callback_steps = kwargs.pop("callback_steps", None)

        if callback is not None:
            deprecate(
                "callback",
                "1.0.0",
                "Passing `callback` as an input argument to `__call__` is deprecated, consider using `callback_on_step_end`",
            )
        if callback_steps is not None:
            deprecate(
                "callback_steps",
                "1.0.0",
                "Passing `callback_steps` as an input argument to `__call__` is deprecated, consider using `callback_on_step_end`",
            )

719
        # 0. Default height and width to unet
Patrick von Platen's avatar
Patrick von Platen committed
720
721
        height = height or self.unet.config.sample_size * self.vae_scale_factor
        width = width or self.unet.config.sample_size * self.vae_scale_factor
722
        # to deal with lora scaling and other possible forward hooks
Suraj Patil's avatar
Suraj Patil committed
723

724
        # 1. Check inputs. Raise error if not correct
725
        self.check_inputs(
726
727
728
729
730
731
732
733
            prompt,
            height,
            width,
            callback_steps,
            negative_prompt,
            prompt_embeds,
            negative_prompt_embeds,
            callback_on_step_end_tensor_inputs,
734
        )
735

736
737
738
739
740
        self._guidance_scale = guidance_scale
        self._guidance_rescale = guidance_rescale
        self._clip_skip = clip_skip
        self._cross_attention_kwargs = cross_attention_kwargs

741
        # 2. Define call parameters
742
743
744
745
746
747
748
        if prompt is not None and isinstance(prompt, str):
            batch_size = 1
        elif prompt is not None and isinstance(prompt, list):
            batch_size = len(prompt)
        else:
            batch_size = prompt_embeds.shape[0]

Anton Lozhkov's avatar
Anton Lozhkov committed
749
        device = self._execution_device
Suraj Patil's avatar
Suraj Patil committed
750

751
        # 3. Encode input prompt
752
753
754
        lora_scale = (
            self.cross_attention_kwargs.get("scale", None) if self.cross_attention_kwargs is not None else None
        )
755

756
        prompt_embeds, negative_prompt_embeds = self.encode_prompt(
757
758
759
            prompt,
            device,
            num_images_per_prompt,
760
            self.do_classifier_free_guidance,
761
762
763
            negative_prompt,
            prompt_embeds=prompt_embeds,
            negative_prompt_embeds=negative_prompt_embeds,
764
            lora_scale=lora_scale,
765
            clip_skip=self.clip_skip,
766
        )
767
768
769
        # For classifier free guidance, we need to do two forward passes.
        # Here we concatenate the unconditional and text embeddings into a single batch
        # to avoid doing two forward passes
770
        if self.do_classifier_free_guidance:
771
            prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds])
772

773
        # 4. Prepare timesteps
Anton Lozhkov's avatar
Anton Lozhkov committed
774
        self.scheduler.set_timesteps(num_inference_steps, device=device)
775
776
777
        timesteps = self.scheduler.timesteps

        # 5. Prepare latent variables
778
        num_channels_latents = self.unet.config.in_channels
779
780
781
782
783
        latents = self.prepare_latents(
            batch_size * num_images_per_prompt,
            num_channels_latents,
            height,
            width,
784
            prompt_embeds.dtype,
785
786
787
788
            device,
            generator,
            latents,
        )
Suraj Patil's avatar
Suraj Patil committed
789

790
791
        # 6. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline
        extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)
hlky's avatar
hlky committed
792

793
        # 7. Denoising loop
794
        num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order
795
        self._num_timesteps = len(timesteps)
796
797
798
        with self.progress_bar(total=num_inference_steps) as progress_bar:
            for i, t in enumerate(timesteps):
                # expand the latents if we are doing classifier free guidance
799
                latent_model_input = torch.cat([latents] * 2) if self.do_classifier_free_guidance else latents
800
801
802
                latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)

                # predict the noise residual
803
804
805
806
                noise_pred = self.unet(
                    latent_model_input,
                    t,
                    encoder_hidden_states=prompt_embeds,
807
                    cross_attention_kwargs=self.cross_attention_kwargs,
808
809
                    return_dict=False,
                )[0]
810
811

                # perform guidance
812
                if self.do_classifier_free_guidance:
813
                    noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
814
                    noise_pred = noise_pred_uncond + self.guidance_scale * (noise_pred_text - noise_pred_uncond)
815

816
                if self.do_classifier_free_guidance and self.guidance_rescale > 0.0:
817
                    # Based on 3.4. in https://arxiv.org/pdf/2305.08891.pdf
818
                    noise_pred = rescale_noise_cfg(noise_pred, noise_pred_text, guidance_rescale=self.guidance_rescale)
819

820
                # compute the previous noisy sample x_t -> x_t-1
821
                latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs, return_dict=False)[0]
822

823
824
825
826
827
828
829
830
831
832
                if callback_on_step_end is not None:
                    callback_kwargs = {}
                    for k in callback_on_step_end_tensor_inputs:
                        callback_kwargs[k] = locals()[k]
                    callback_outputs = callback_on_step_end(self, i, t, callback_kwargs)

                    latents = callback_outputs.pop("latents", latents)
                    prompt_embeds = callback_outputs.pop("prompt_embeds", prompt_embeds)
                    negative_prompt_embeds = callback_outputs.pop("negative_prompt_embeds", negative_prompt_embeds)

833
                # call the callback, if provided
834
                if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):
835
836
                    progress_bar.update()
                    if callback is not None and i % callback_steps == 0:
837
838
                        step_idx = i // getattr(self.scheduler, "order", 1)
                        callback(step_idx, t, latents)
839

840
        if not output_type == "latent":
Will Berman's avatar
Will Berman committed
841
842
843
            image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False, generator=generator)[
                0
            ]
844
845
            image, has_nsfw_concept = self.run_safety_checker(image, device, prompt_embeds.dtype)
        else:
846
847
            image = latents
            has_nsfw_concept = None
Suraj Patil's avatar
Suraj Patil committed
848

849
850
        if has_nsfw_concept is None:
            do_denormalize = [True] * image.shape[0]
851
        else:
852
            do_denormalize = [not has_nsfw for has_nsfw in has_nsfw_concept]
853

854
        image = self.image_processor.postprocess(image, output_type=output_type, do_denormalize=do_denormalize)
Suraj Patil's avatar
Suraj Patil committed
855

856
857
        # Offload all models
        self.maybe_free_model_hooks()
858

859
860
861
862
        if not return_dict:
            return (image, has_nsfw_concept)

        return StableDiffusionPipelineOutput(images=image, nsfw_content_detected=has_nsfw_concept)