pipeline_stable_diffusion.py 38.3 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
from ...utils import deprecate, logging, replace_example_docstring, scale_lora_layers, unscale_lora_layers
Dhruv Nair's avatar
Dhruv Nair committed
29
from ...utils.torch_utils import randn_tensor
30
from ..pipeline_utils import DiffusionPipeline
31
from .pipeline_output import StableDiffusionPipelineOutput
Suraj Patil's avatar
Suraj Patil committed
32
from .safety_checker import StableDiffusionSafetyChecker
Suraj Patil's avatar
Suraj Patil committed
33
34


35
36
logger = logging.get_logger(__name__)  # pylint: disable=invalid-name

37
38
39
40
41
42
43
44
45
46
47
48
49
50
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]
        ```
"""

51

52
53
54
55
56
57
58
59
60
61
62
63
64
65
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
66
class StableDiffusionPipeline(DiffusionPipeline, TextualInversionLoaderMixin, LoraLoaderMixin, FromSingleFileMixin):
67
68
69
    r"""
    Pipeline for text-to-image generation using Stable Diffusion.

70
71
    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.).
72

73
74
75
76
77
    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
78

79
80
    Args:
        vae ([`AutoencoderKL`]):
81
82
83
84
85
86
87
            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.
88
        scheduler ([`SchedulerMixin`]):
89
            A scheduler to be used in combination with `unet` to denoise the encoded image latents. Can be one of
90
91
            [`DDIMScheduler`], [`LMSDiscreteScheduler`], or [`PNDMScheduler`].
        safety_checker ([`StableDiffusionSafetyChecker`]):
92
            Classification module that estimates whether generated images could be considered offensive or harmful.
93
94
95
96
            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`.
97
    """
98
    model_cpu_offload_seq = "text_encoder->unet->vae"
99
    _optional_components = ["safety_checker", "feature_extractor"]
100
    _exclude_from_cpu_offload = ["safety_checker"]
101

Suraj Patil's avatar
Suraj Patil committed
102
103
104
105
106
107
    def __init__(
        self,
        vae: AutoencoderKL,
        text_encoder: CLIPTextModel,
        tokenizer: CLIPTokenizer,
        unet: UNet2DConditionModel,
Kashif Rasul's avatar
Kashif Rasul committed
108
        scheduler: KarrasDiffusionSchedulers,
Suraj Patil's avatar
Suraj Patil committed
109
        safety_checker: StableDiffusionSafetyChecker,
110
        feature_extractor: CLIPImageProcessor,
111
        requires_safety_checker: bool = True,
Suraj Patil's avatar
Suraj Patil committed
112
113
    ):
        super().__init__()
114
115

        if hasattr(scheduler.config, "steps_offset") and scheduler.config.steps_offset != 1:
116
            deprecation_message = (
117
                f"The configuration file of this scheduler: {scheduler} is outdated. `steps_offset`"
Yuta Hayashibe's avatar
Yuta Hayashibe committed
118
                f" should be set to 1 instead of {scheduler.config.steps_offset}. Please make sure "
119
120
121
                "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`"
122
                " file"
123
            )
124
            deprecate("steps_offset!=1", "1.0.0", deprecation_message, standard_warn=False)
125
126
127
128
            new_config = dict(scheduler.config)
            new_config["steps_offset"] = 1
            scheduler._internal_dict = FrozenDict(new_config)

129
130
131
132
133
134
135
136
137
138
139
140
141
        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)

142
        if safety_checker is None and requires_safety_checker:
143
            logger.warning(
144
                f"You have disabled the safety checker for {self.__class__} by passing `safety_checker=None`. Ensure"
145
146
147
148
149
150
151
                " 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 ."
            )

152
153
154
155
156
157
        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."
            )

158
159
160
161
162
163
164
        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
165
                " 64 which seems highly unlikely. If your checkpoint is a fine-tuned version of any of the"
166
167
168
169
170
171
172
173
174
175
176
177
178
                " 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
179
180
181
182
183
184
185
186
187
        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
188
        self.vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1)
189
        self.image_processor = VaeImageProcessor(vae_scale_factor=self.vae_scale_factor)
190
        self.register_to_config(requires_safety_checker=requires_safety_checker)
Suraj Patil's avatar
Suraj Patil committed
191

192
193
    def enable_vae_slicing(self):
        r"""
194
195
        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.
196
197
198
199
200
        """
        self.vae.enable_slicing()

    def disable_vae_slicing(self):
        r"""
201
        Disable sliced VAE decoding. If `enable_vae_slicing` was previously enabled, this method will go back to
202
203
204
205
        computing decoding in one step.
        """
        self.vae.disable_slicing()

206
207
    def enable_vae_tiling(self):
        r"""
208
209
210
        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.
211
212
213
214
215
        """
        self.vae.enable_tiling()

    def disable_vae_tiling(self):
        r"""
216
        Disable tiled VAE decoding. If `enable_vae_tiling` was previously enabled, this method will go back to
217
218
219
220
        computing decoding in one step.
        """
        self.vae.disable_tiling()

221
222
223
224
225
226
227
228
229
    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,
230
        lora_scale: Optional[float] = None,
231
        **kwargs,
232
233
234
235
236
237
238
239
240
241
242
243
244
    ):
        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,
245
            **kwargs,
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
        )

        # 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,
263
        clip_skip: Optional[int] = None,
264
    ):
265
266
267
268
        r"""
        Encodes the prompt into text encoder hidden states.

        Args:
269
            prompt (`str` or `List[str]`, *optional*):
270
271
272
273
274
275
276
                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
277
            negative_prompt (`str` or `List[str]`, *optional*):
278
                The prompt or prompts not to guide the image generation. If not defined, one has to pass
279
280
                `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is
                less than `1`).
281
282
283
284
285
286
287
            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.
288
            lora_scale (`float`, *optional*):
289
290
291
292
                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.
293
        """
294
295
296
297
298
        # 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

299
            # dynamically adjust the LoRA scale
300
301
302
303
            if not self.use_peft_backend:
                adjust_lora_scale_text_encoder(self.text_encoder, lora_scale)
            else:
                scale_lora_layers(self.text_encoder, lora_scale)
304

305
306
307
308
309
310
        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]
311

312
        if prompt_embeds is None:
313
314
315
316
            # textual inversion: procecss multi-vector tokens if necessary
            if isinstance(self, TextualInversionLoaderMixin):
                prompt = self.maybe_convert_prompt(prompt, self.tokenizer)

317
318
319
320
321
322
            text_inputs = self.tokenizer(
                prompt,
                padding="max_length",
                max_length=self.tokenizer.model_max_length,
                truncation=True,
                return_tensors="pt",
323
            )
324
325
            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
326

327
328
329
330
331
332
333
334
335
336
            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
337

338
339
340
341
            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
342

343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
            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)
359

360
361
362
363
364
365
366
367
        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)
368
369

        bs_embed, seq_len, _ = prompt_embeds.shape
370
        # duplicate text embeddings for each generation per prompt, using mps friendly method
371
372
        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)
373
374

        # get unconditional embeddings for classifier free guidance
375
        if do_classifier_free_guidance and negative_prompt_embeds is None:
376
377
378
            uncond_tokens: List[str]
            if negative_prompt is None:
                uncond_tokens = [""] * batch_size
379
            elif prompt is not None and type(prompt) is not type(negative_prompt):
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
                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

395
396
397
398
            # textual inversion: procecss multi-vector tokens if necessary
            if isinstance(self, TextualInversionLoaderMixin):
                uncond_tokens = self.maybe_convert_prompt(uncond_tokens, self.tokenizer)

399
            max_length = prompt_embeds.shape[1]
400
401
402
403
404
405
406
            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
407
408
409
410
411
412

            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

413
            negative_prompt_embeds = self.text_encoder(
Patrick von Platen's avatar
Patrick von Platen committed
414
415
416
                uncond_input.input_ids.to(device),
                attention_mask=attention_mask,
            )
417
            negative_prompt_embeds = negative_prompt_embeds[0]
418

419
        if do_classifier_free_guidance:
420
            # duplicate unconditional embeddings for each generation per prompt, using mps friendly method
421
422
            seq_len = negative_prompt_embeds.shape[1]

423
            negative_prompt_embeds = negative_prompt_embeds.to(dtype=prompt_embeds_dtype, device=device)
424
425
426

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

428
429
430
431
        if isinstance(self, LoraLoaderMixin) and self.use_peft_backend:
            # Retrieve the original scale by scaling back the LoRA layers
            unscale_lora_layers(self.text_encoder)

432
        return prompt_embeds, negative_prompt_embeds
433

434
    def run_safety_checker(self, image, device, dtype):
435
436
437
438
439
440
441
442
        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)
443
444
445
446
447
448
            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):
449
450
451
        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)

452
        latents = 1 / self.vae.config.scaling_factor * latents
453
        image = self.vae.decode(latents, return_dict=False)[0]
454
        image = (image / 2 + 0.5).clamp(0, 1)
455
        # we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
        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

476
477
478
479
480
481
482
483
484
485
    def check_inputs(
        self,
        prompt,
        height,
        width,
        callback_steps,
        negative_prompt=None,
        prompt_embeds=None,
        negative_prompt_embeds=None,
    ):
486
487
488
489
490
491
492
493
494
495
496
        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}.")

        if (callback_steps is None) or (
            callback_steps is not None and (not isinstance(callback_steps, int) or callback_steps <= 0)
        ):
            raise ValueError(
                f"`callback_steps` has to be a positive integer but is {callback_steps} of type"
                f" {type(callback_steps)}."
            )

497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
        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}."
                )

523
    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
524
        shape = (batch_size, num_channels_latents, height // self.vae_scale_factor, width // self.vae_scale_factor)
525
526
527
528
529
530
        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."
            )

531
        if latents is None:
532
            latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
533
534
535
536
537
538
539
        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

Suraj Patil's avatar
Suraj Patil committed
540
    @torch.no_grad()
541
    @replace_example_docstring(EXAMPLE_DOC_STRING)
Suraj Patil's avatar
Suraj Patil committed
542
543
    def __call__(
        self,
544
        prompt: Union[str, List[str]] = None,
545
546
        height: Optional[int] = None,
        width: Optional[int] = None,
547
548
        num_inference_steps: int = 50,
        guidance_scale: float = 7.5,
549
        negative_prompt: Optional[Union[str, List[str]]] = None,
550
        num_images_per_prompt: Optional[int] = 1,
551
        eta: float = 0.0,
552
        generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
553
        latents: Optional[torch.FloatTensor] = None,
554
555
        prompt_embeds: Optional[torch.FloatTensor] = None,
        negative_prompt_embeds: Optional[torch.FloatTensor] = None,
Suraj Patil's avatar
Suraj Patil committed
556
        output_type: Optional[str] = "pil",
557
        return_dict: bool = True,
558
        callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,
559
        callback_steps: int = 1,
560
        cross_attention_kwargs: Optional[Dict[str, Any]] = None,
561
        guidance_rescale: float = 0.0,
562
        clip_skip: Optional[int] = None,
Suraj Patil's avatar
Suraj Patil committed
563
    ):
564
        r"""
565
        The call function to the pipeline for generation.
566
567

        Args:
568
            prompt (`str` or `List[str]`, *optional*):
569
570
                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`):
571
                The height in pixels of the generated image.
572
            width (`int`, *optional*, defaults to `self.unet.config.sample_size * self.vae_scale_factor`):
573
574
575
576
577
                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):
578
579
                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`.
580
            negative_prompt (`str` or `List[str]`, *optional*):
581
582
                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`).
583
584
            num_images_per_prompt (`int`, *optional*, defaults to 1):
                The number of images to generate per prompt.
585
            eta (`float`, *optional*, defaults to 0.0):
586
587
                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.
588
            generator (`torch.Generator` or `List[torch.Generator]`, *optional*):
589
590
                A [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) to make
                generation deterministic.
591
            latents (`torch.FloatTensor`, *optional*):
592
                Pre-generated noisy latents sampled from a Gaussian distribution, to be used as inputs for image
593
                generation. Can be used to tweak the same generation with different prompts. If not provided, a latents
594
                tensor is generated by sampling using the supplied random `generator`.
595
            prompt_embeds (`torch.FloatTensor`, *optional*):
596
597
                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.
598
            negative_prompt_embeds (`torch.FloatTensor`, *optional*):
599
600
                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.
601
            output_type (`str`, *optional*, defaults to `"pil"`):
602
                The output format of the generated image. Choose between `PIL.Image` or `np.array`.
603
604
605
            return_dict (`bool`, *optional*, defaults to `True`):
                Whether or not to return a [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] instead of a
                plain tuple.
606
            callback (`Callable`, *optional*):
607
608
                A function that calls every `callback_steps` steps during inference. The function is called with the
                following arguments: `callback(step: int, timestep: int, latents: torch.FloatTensor)`.
609
            callback_steps (`int`, *optional*, defaults to 1):
610
611
                The frequency at which the `callback` function is called. If not specified, the callback is called at
                every step.
612
            cross_attention_kwargs (`dict`, *optional*):
613
                A kwargs dictionary that if specified is passed along to the [`AttentionProcessor`] as defined in
Patrick von Platen's avatar
Patrick von Platen committed
614
                [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
615
            guidance_rescale (`float`, *optional*, defaults to 0.0):
616
617
618
                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.
619
620
621
            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.
622

623
624
        Examples:

625
        Returns:
626
            [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] or `tuple`:
627
628
629
630
                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.
631
        """
632
        # 0. Default height and width to unet
Patrick von Platen's avatar
Patrick von Platen committed
633
634
        height = height or self.unet.config.sample_size * self.vae_scale_factor
        width = width or self.unet.config.sample_size * self.vae_scale_factor
Suraj Patil's avatar
Suraj Patil committed
635

636
        # 1. Check inputs. Raise error if not correct
637
638
639
        self.check_inputs(
            prompt, height, width, callback_steps, negative_prompt, prompt_embeds, negative_prompt_embeds
        )
640

641
        # 2. Define call parameters
642
643
644
645
646
647
648
        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
649
        device = self._execution_device
Suraj Patil's avatar
Suraj Patil committed
650
651
652
653
654
        # 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.
        do_classifier_free_guidance = guidance_scale > 1.0

655
        # 3. Encode input prompt
656
657
658
        text_encoder_lora_scale = (
            cross_attention_kwargs.get("scale", None) if cross_attention_kwargs is not None else None
        )
659
        prompt_embeds, negative_prompt_embeds = self.encode_prompt(
660
661
662
663
664
665
666
            prompt,
            device,
            num_images_per_prompt,
            do_classifier_free_guidance,
            negative_prompt,
            prompt_embeds=prompt_embeds,
            negative_prompt_embeds=negative_prompt_embeds,
667
            lora_scale=text_encoder_lora_scale,
668
            clip_skip=clip_skip,
669
        )
670
671
672
673
674
        # 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
        if do_classifier_free_guidance:
            prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds])
675

676
        # 4. Prepare timesteps
Anton Lozhkov's avatar
Anton Lozhkov committed
677
        self.scheduler.set_timesteps(num_inference_steps, device=device)
678
679
680
        timesteps = self.scheduler.timesteps

        # 5. Prepare latent variables
681
        num_channels_latents = self.unet.config.in_channels
682
683
684
685
686
        latents = self.prepare_latents(
            batch_size * num_images_per_prompt,
            num_channels_latents,
            height,
            width,
687
            prompt_embeds.dtype,
688
689
690
691
            device,
            generator,
            latents,
        )
Suraj Patil's avatar
Suraj Patil committed
692

693
694
        # 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
695

696
        # 7. Denoising loop
697
698
699
700
701
702
703
704
        num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order
        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
                latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents
                latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)

                # predict the noise residual
705
706
707
708
709
                noise_pred = self.unet(
                    latent_model_input,
                    t,
                    encoder_hidden_states=prompt_embeds,
                    cross_attention_kwargs=cross_attention_kwargs,
710
711
                    return_dict=False,
                )[0]
712
713
714
715
716
717

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

718
719
720
721
                if do_classifier_free_guidance and guidance_rescale > 0.0:
                    # Based on 3.4. in https://arxiv.org/pdf/2305.08891.pdf
                    noise_pred = rescale_noise_cfg(noise_pred, noise_pred_text, guidance_rescale=guidance_rescale)

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

                # call the callback, if provided
726
                if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):
727
728
                    progress_bar.update()
                    if callback is not None and i % callback_steps == 0:
729
730
                        step_idx = i // getattr(self.scheduler, "order", 1)
                        callback(step_idx, t, latents)
731

732
733
734
735
        if not output_type == "latent":
            image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False)[0]
            image, has_nsfw_concept = self.run_safety_checker(image, device, prompt_embeds.dtype)
        else:
736
737
            image = latents
            has_nsfw_concept = None
Suraj Patil's avatar
Suraj Patil committed
738

739
740
        if has_nsfw_concept is None:
            do_denormalize = [True] * image.shape[0]
741
        else:
742
            do_denormalize = [not has_nsfw for has_nsfw in has_nsfw_concept]
743

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

746
747
        # Offload all models
        self.maybe_free_model_hooks()
748

749
750
751
752
        if not return_dict:
            return (image, has_nsfw_concept)

        return StableDiffusionPipelineOutput(images=image, nsfw_content_detected=has_nsfw_concept)