pipeline_ddim.py 6.3 KB
Newer Older
Patrick von Platen's avatar
Patrick von Platen committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# Copyright 2022 The HuggingFace Team. All rights reserved.
#
# 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.

15
from typing import List, Optional, Tuple, Union
Pedro Cuenca's avatar
Pedro Cuenca committed
16

Patrick von Platen's avatar
Patrick von Platen committed
17
18
import torch

19
from ...pipeline_utils import DiffusionPipeline, ImagePipelineOutput
20
from ...utils import deprecate
Patrick von Platen's avatar
Patrick von Platen committed
21
22


Patrick von Platen's avatar
Patrick von Platen committed
23
class DDIMPipeline(DiffusionPipeline):
Kashif Rasul's avatar
Kashif Rasul committed
24
25
26
27
28
29
30
31
32
33
34
    r"""
    This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods the
    library implements for all the pipelines (such as downloading or saving, running on a particular device, etc.)

    Parameters:
        unet ([`UNet2DModel`]): U-Net architecture to denoise the encoded image.
        scheduler ([`SchedulerMixin`]):
            A scheduler to be used in combination with `unet` to denoise the encoded image. Can be one of
            [`DDPMScheduler`], or [`DDIMScheduler`].
    """

35
    def __init__(self, unet, scheduler):
Patrick von Platen's avatar
Patrick von Platen committed
36
        super().__init__()
37
        self.register_modules(unet=unet, scheduler=scheduler)
Patrick von Platen's avatar
Patrick von Platen committed
38

Patrick von Platen's avatar
Patrick von Platen committed
39
    @torch.no_grad()
40
41
    def __call__(
        self,
Sid Sahai's avatar
Sid Sahai committed
42
        batch_size: int = 1,
43
        generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
Sid Sahai's avatar
Sid Sahai committed
44
45
        eta: float = 0.0,
        num_inference_steps: int = 50,
46
        use_clipped_model_output: Optional[bool] = None,
Sid Sahai's avatar
Sid Sahai committed
47
        output_type: Optional[str] = "pil",
48
49
        return_dict: bool = True,
    ) -> Union[ImagePipelineOutput, Tuple]:
Kashif Rasul's avatar
Kashif Rasul committed
50
51
        r"""
        Args:
52
            batch_size (`int`, *optional*, defaults to 1):
Kashif Rasul's avatar
Kashif Rasul committed
53
                The number of images to generate.
54
            generator (`torch.Generator`, *optional*):
55
56
                One or a list of [torch generator(s)](https://pytorch.org/docs/stable/generated/torch.Generator.html)
                to make generation deterministic.
57
            eta (`float`, *optional*, defaults to 0.0):
Kashif Rasul's avatar
Kashif Rasul committed
58
                The eta parameter which controls the scale of the variance (0 is DDIM and 1 is one type of DDPM).
59
            num_inference_steps (`int`, *optional*, defaults to 50):
Kashif Rasul's avatar
Kashif Rasul committed
60
61
                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
                expense of slower inference.
62
63
64
            use_clipped_model_output (`bool`, *optional*, defaults to `None`):
                if `True` or `False`, see documentation for `DDIMScheduler.step`. If `None`, nothing is passed
                downstream to the scheduler. So use `None` for schedulers which don't support this argument.
65
            output_type (`str`, *optional*, defaults to `"pil"`):
Kashif Rasul's avatar
Kashif Rasul committed
66
                The output format of the generate image. Choose between
67
                [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`.
68
            return_dict (`bool`, *optional*, defaults to `True`):
Kashif Rasul's avatar
Kashif Rasul committed
69
                Whether or not to return a [`~pipeline_utils.ImagePipelineOutput`] instead of a plain tuple.
70
71
72
73
74

        Returns:
            [`~pipeline_utils.ImagePipelineOutput`] or `tuple`: [`~pipelines.utils.ImagePipelineOutput`] if
            `return_dict` is True, otherwise a `tuple. When returning a tuple, the first element is a list with the
            generated images.
Kashif Rasul's avatar
Kashif Rasul committed
75
        """
Pedro Cuenca's avatar
Pedro Cuenca committed
76

77
78
79
80
81
82
        if (
            generator is not None
            and isinstance(generator, torch.Generator)
            and generator.device.type != self.device.type
            and self.device.type != "mps"
        ):
83
84
            message = (
                f"The `generator` device is `{generator.device}` and does not match the pipeline "
85
                f"device `{self.device}`, so the `generator` will be ignored. "
86
87
88
89
                f'Please use `generator=torch.Generator(device="{self.device}")` instead.'
            )
            deprecate(
                "generator.device == 'cpu'",
Anton Lozhkov's avatar
Anton Lozhkov committed
90
                "0.13.0",
91
92
93
94
                message,
            )
            generator = None

Patrick von Platen's avatar
Patrick von Platen committed
95
        # Sample gaussian noise to begin loop
96
97
98
99
100
        if isinstance(self.unet.sample_size, int):
            image_shape = (batch_size, self.unet.in_channels, self.unet.sample_size, self.unet.sample_size)
        else:
            image_shape = (batch_size, self.unet.in_channels, *self.unet.sample_size)

101
102
103
104
105
106
107
108
109
110
111
112
113
114
        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."
            )

        rand_device = "cpu" if self.device.type == "mps" else self.device
        if isinstance(generator, list):
            shape = (1,) + image_shape[1:]
            image = [
                torch.randn(shape, generator=generator[i], device=rand_device, dtype=self.unet.dtype)
                for i in range(batch_size)
            ]
            image = torch.cat(image, dim=0).to(self.device)
115
        else:
116
117
            image = torch.randn(image_shape, generator=generator, device=rand_device, dtype=self.unet.dtype)
            image = image.to(self.device)
Patrick von Platen's avatar
Patrick von Platen committed
118

119
120
        # set step values
        self.scheduler.set_timesteps(num_inference_steps)
Patrick von Platen's avatar
Patrick von Platen committed
121

hysts's avatar
hysts committed
122
        for t in self.progress_bar(self.scheduler.timesteps):
Patrick von Platen's avatar
Patrick von Platen committed
123
            # 1. predict noise model_output
124
            model_output = self.unet(image, t).sample
Patrick von Platen's avatar
Patrick von Platen committed
125

126
            # 2. predict previous mean of image x_t-1 and add variance depending on eta
127
            # eta corresponds to η in paper and should be between [0, 1]
128
            # do x_t -> x_t-1
129
130
131
            image = self.scheduler.step(
                model_output, t, image, eta=eta, use_clipped_model_output=use_clipped_model_output, generator=generator
            ).prev_sample
Patrick von Platen's avatar
Patrick von Platen committed
132

133
134
        image = (image / 2 + 0.5).clamp(0, 1)
        image = image.cpu().permute(0, 2, 3, 1).numpy()
anton-l's avatar
anton-l committed
135
136
        if output_type == "pil":
            image = self.numpy_to_pil(image)
137

138
139
140
141
        if not return_dict:
            return (image,)

        return ImagePipelineOutput(images=image)