prior_transformer.py 16.8 KB
Newer Older
Will Berman's avatar
Will Berman committed
1
from dataclasses import dataclass
2
from typing import Dict, Optional, Union
Will Berman's avatar
Will Berman committed
3
4
5
6
7
8
9
10

import torch
import torch.nn.functional as F
from torch import nn

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput
from .attention import BasicTransformerBlock
11
12
13
14
15
16
17
from .attention_processor import (
    ADDED_KV_ATTENTION_PROCESSORS,
    CROSS_ATTENTION_PROCESSORS,
    AttentionProcessor,
    AttnAddedKVProcessor,
    AttnProcessor,
)
Will Berman's avatar
Will Berman committed
18
from .embeddings import TimestepEmbedding, Timesteps
19
from .modeling_utils import ModelMixin
Will Berman's avatar
Will Berman committed
20
21
22
23
24


@dataclass
class PriorTransformerOutput(BaseOutput):
    """
Steven Liu's avatar
Steven Liu committed
25
26
    The output of [`PriorTransformer`].

Will Berman's avatar
Will Berman committed
27
28
29
30
31
32
33
34
35
36
    Args:
        predicted_image_embedding (`torch.FloatTensor` of shape `(batch_size, embedding_dim)`):
            The predicted CLIP image embedding conditioned on the CLIP text embedding input.
    """

    predicted_image_embedding: torch.FloatTensor


class PriorTransformer(ModelMixin, ConfigMixin):
    """
Steven Liu's avatar
Steven Liu committed
37
    A Prior Transformer model.
Will Berman's avatar
Will Berman committed
38
39
40
41
42

    Parameters:
        num_attention_heads (`int`, *optional*, defaults to 32): The number of heads to use for multi-head attention.
        attention_head_dim (`int`, *optional*, defaults to 64): The number of channels in each head.
        num_layers (`int`, *optional*, defaults to 20): The number of layers of Transformer blocks to use.
YiYi Xu's avatar
YiYi Xu committed
43
44
45
        embedding_dim (`int`, *optional*, defaults to 768): The dimension of the model input `hidden_states`
        num_embeddings (`int`, *optional*, defaults to 77):
            The number of embeddings of the model input `hidden_states`
Will Berman's avatar
Will Berman committed
46
        additional_embeddings (`int`, *optional*, defaults to 4): The number of additional tokens appended to the
Steven Liu's avatar
Steven Liu committed
47
            projected `hidden_states`. The actual length of the used `hidden_states` is `num_embeddings +
Will Berman's avatar
Will Berman committed
48
49
            additional_embeddings`.
        dropout (`float`, *optional*, defaults to 0.0): The dropout probability to use.
YiYi Xu's avatar
YiYi Xu committed
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
        time_embed_act_fn (`str`, *optional*, defaults to 'silu'):
            The activation function to use to create timestep embeddings.
        norm_in_type (`str`, *optional*, defaults to None): The normalization layer to apply on hidden states before
            passing to Transformer blocks. Set it to `None` if normalization is not needed.
        embedding_proj_norm_type (`str`, *optional*, defaults to None):
            The normalization layer to apply on the input `proj_embedding`. Set it to `None` if normalization is not
            needed.
        encoder_hid_proj_type (`str`, *optional*, defaults to `linear`):
            The projection layer to apply on the input `encoder_hidden_states`. Set it to `None` if
            `encoder_hidden_states` is `None`.
        added_emb_type (`str`, *optional*, defaults to `prd`): Additional embeddings to condition the model.
            Choose from `prd` or `None`. if choose `prd`, it will prepend a token indicating the (quantized) dot
            product between the text embedding and image embedding as proposed in the unclip paper
            https://arxiv.org/abs/2204.06125 If it is `None`, no additional embeddings will be prepended.
        time_embed_dim (`int, *optional*, defaults to None): The dimension of timestep embeddings.
            If None, will be set to `num_attention_heads * attention_head_dim`
        embedding_proj_dim (`int`, *optional*, default to None):
            The dimension of `proj_embedding`. If None, will be set to `embedding_dim`.
        clip_embed_dim (`int`, *optional*, default to None):
            The dimension of the output. If None, will be set to `embedding_dim`.
Will Berman's avatar
Will Berman committed
70
71
72
73
74
75
76
77
78
79
80
81
    """

    @register_to_config
    def __init__(
        self,
        num_attention_heads: int = 32,
        attention_head_dim: int = 64,
        num_layers: int = 20,
        embedding_dim: int = 768,
        num_embeddings=77,
        additional_embeddings=4,
        dropout: float = 0.0,
YiYi Xu's avatar
YiYi Xu committed
82
83
84
85
86
87
88
89
        time_embed_act_fn: str = "silu",
        norm_in_type: Optional[str] = None,  # layer
        embedding_proj_norm_type: Optional[str] = None,  # layer
        encoder_hid_proj_type: Optional[str] = "linear",  # linear
        added_emb_type: Optional[str] = "prd",  # prd
        time_embed_dim: Optional[int] = None,
        embedding_proj_dim: Optional[int] = None,
        clip_embed_dim: Optional[int] = None,
Will Berman's avatar
Will Berman committed
90
91
92
93
94
95
96
    ):
        super().__init__()
        self.num_attention_heads = num_attention_heads
        self.attention_head_dim = attention_head_dim
        inner_dim = num_attention_heads * attention_head_dim
        self.additional_embeddings = additional_embeddings

YiYi Xu's avatar
YiYi Xu committed
97
98
99
100
        time_embed_dim = time_embed_dim or inner_dim
        embedding_proj_dim = embedding_proj_dim or embedding_dim
        clip_embed_dim = clip_embed_dim or embedding_dim

Will Berman's avatar
Will Berman committed
101
        self.time_proj = Timesteps(inner_dim, True, 0)
YiYi Xu's avatar
YiYi Xu committed
102
        self.time_embedding = TimestepEmbedding(inner_dim, time_embed_dim, out_dim=inner_dim, act_fn=time_embed_act_fn)
Will Berman's avatar
Will Berman committed
103
104
105

        self.proj_in = nn.Linear(embedding_dim, inner_dim)

YiYi Xu's avatar
YiYi Xu committed
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
        if embedding_proj_norm_type is None:
            self.embedding_proj_norm = None
        elif embedding_proj_norm_type == "layer":
            self.embedding_proj_norm = nn.LayerNorm(embedding_proj_dim)
        else:
            raise ValueError(f"unsupported embedding_proj_norm_type: {embedding_proj_norm_type}")

        self.embedding_proj = nn.Linear(embedding_proj_dim, inner_dim)

        if encoder_hid_proj_type is None:
            self.encoder_hidden_states_proj = None
        elif encoder_hid_proj_type == "linear":
            self.encoder_hidden_states_proj = nn.Linear(embedding_dim, inner_dim)
        else:
            raise ValueError(f"unsupported encoder_hid_proj_type: {encoder_hid_proj_type}")
Will Berman's avatar
Will Berman committed
121
122
123

        self.positional_embedding = nn.Parameter(torch.zeros(1, num_embeddings + additional_embeddings, inner_dim))

YiYi Xu's avatar
YiYi Xu committed
124
125
126
127
128
129
130
131
        if added_emb_type == "prd":
            self.prd_embedding = nn.Parameter(torch.zeros(1, 1, inner_dim))
        elif added_emb_type is None:
            self.prd_embedding = None
        else:
            raise ValueError(
                f"`added_emb_type`: {added_emb_type} is not supported. Make sure to choose one of `'prd'` or `None`."
            )
Will Berman's avatar
Will Berman committed
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

        self.transformer_blocks = nn.ModuleList(
            [
                BasicTransformerBlock(
                    inner_dim,
                    num_attention_heads,
                    attention_head_dim,
                    dropout=dropout,
                    activation_fn="gelu",
                    attention_bias=True,
                )
                for d in range(num_layers)
            ]
        )

YiYi Xu's avatar
YiYi Xu committed
147
148
149
150
151
152
153
        if norm_in_type == "layer":
            self.norm_in = nn.LayerNorm(inner_dim)
        elif norm_in_type is None:
            self.norm_in = None
        else:
            raise ValueError(f"Unsupported norm_in_type: {norm_in_type}.")

Will Berman's avatar
Will Berman committed
154
        self.norm_out = nn.LayerNorm(inner_dim)
YiYi Xu's avatar
YiYi Xu committed
155
156

        self.proj_to_clip_embeddings = nn.Linear(inner_dim, clip_embed_dim)
Will Berman's avatar
Will Berman committed
157
158

        causal_attention_mask = torch.full(
159
            [num_embeddings + additional_embeddings, num_embeddings + additional_embeddings], -10000.0
Will Berman's avatar
Will Berman committed
160
161
162
163
164
        )
        causal_attention_mask.triu_(1)
        causal_attention_mask = causal_attention_mask[None, ...]
        self.register_buffer("causal_attention_mask", causal_attention_mask, persistent=False)

YiYi Xu's avatar
YiYi Xu committed
165
166
        self.clip_mean = nn.Parameter(torch.zeros(1, clip_embed_dim))
        self.clip_std = nn.Parameter(torch.zeros(1, clip_embed_dim))
Will Berman's avatar
Will Berman committed
167

168
169
170
171
172
173
174
175
176
177
178
179
    @property
    # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.attn_processors
    def attn_processors(self) -> Dict[str, AttentionProcessor]:
        r"""
        Returns:
            `dict` of attention processors: A dictionary containing all attention processors used in the model with
            indexed by its weight name.
        """
        # set recursively
        processors = {}

        def fn_recursive_add_processors(name: str, module: torch.nn.Module, processors: Dict[str, AttentionProcessor]):
180
181
            if hasattr(module, "get_processor"):
                processors[f"{name}.processor"] = module.get_processor(return_deprecated_lora=True)
182
183
184
185
186
187
188
189
190
191
192
193
194
195

            for sub_name, child in module.named_children():
                fn_recursive_add_processors(f"{name}.{sub_name}", child, processors)

            return processors

        for name, module in self.named_children():
            fn_recursive_add_processors(name, module, processors)

        return processors

    # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.set_attn_processor
    def set_attn_processor(self, processor: Union[AttentionProcessor, Dict[str, AttentionProcessor]]):
        r"""
Steven Liu's avatar
Steven Liu committed
196
197
        Sets the attention processor to use to compute attention.

198
        Parameters:
Steven Liu's avatar
Steven Liu committed
199
            processor (`dict` of `AttentionProcessor` or only `AttentionProcessor`):
200
                The instantiated processor class or a dictionary of processor classes that will be set as the processor
Steven Liu's avatar
Steven Liu committed
201
202
203
204
                for **all** `Attention` layers.

                If `processor` is a dict, the key needs to define the path to the corresponding cross attention
                processor. This is strongly recommended when setting trainable attention processors.
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232

        """
        count = len(self.attn_processors.keys())

        if isinstance(processor, dict) and len(processor) != count:
            raise ValueError(
                f"A dict of processors was passed, but the number of processors {len(processor)} does not match the"
                f" number of attention layers: {count}. Please make sure to pass {count} processor classes."
            )

        def fn_recursive_attn_processor(name: str, module: torch.nn.Module, processor):
            if hasattr(module, "set_processor"):
                if not isinstance(processor, dict):
                    module.set_processor(processor)
                else:
                    module.set_processor(processor.pop(f"{name}.processor"))

            for sub_name, child in module.named_children():
                fn_recursive_attn_processor(f"{name}.{sub_name}", child, processor)

        for name, module in self.named_children():
            fn_recursive_attn_processor(name, module, processor)

    # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.set_default_attn_processor
    def set_default_attn_processor(self):
        """
        Disables custom attention processors and sets the default attention implementation.
        """
233
234
235
236
237
238
239
240
241
242
        if all(proc.__class__ in ADDED_KV_ATTENTION_PROCESSORS for proc in self.attn_processors.values()):
            processor = AttnAddedKVProcessor()
        elif all(proc.__class__ in CROSS_ATTENTION_PROCESSORS for proc in self.attn_processors.values()):
            processor = AttnProcessor()
        else:
            raise ValueError(
                f"Cannot call `set_default_attn_processor` when attention processors are of type {next(iter(self.attn_processors.values()))}"
            )

        self.set_attn_processor(processor)
243

Will Berman's avatar
Will Berman committed
244
245
246
247
248
    def forward(
        self,
        hidden_states,
        timestep: Union[torch.Tensor, float, int],
        proj_embedding: torch.FloatTensor,
YiYi Xu's avatar
YiYi Xu committed
249
        encoder_hidden_states: Optional[torch.FloatTensor] = None,
Will Berman's avatar
Will Berman committed
250
251
252
253
        attention_mask: Optional[torch.BoolTensor] = None,
        return_dict: bool = True,
    ):
        """
Steven Liu's avatar
Steven Liu committed
254
255
        The [`PriorTransformer`] forward method.

Will Berman's avatar
Will Berman committed
256
257
        Args:
            hidden_states (`torch.FloatTensor` of shape `(batch_size, embedding_dim)`):
Steven Liu's avatar
Steven Liu committed
258
259
                The currently predicted image embeddings.
            timestep (`torch.LongTensor`):
Will Berman's avatar
Will Berman committed
260
261
262
263
264
265
266
267
                Current denoising step.
            proj_embedding (`torch.FloatTensor` of shape `(batch_size, embedding_dim)`):
                Projected embedding vector the denoising process is conditioned on.
            encoder_hidden_states (`torch.FloatTensor` of shape `(batch_size, num_embeddings, embedding_dim)`):
                Hidden states of the text embeddings the denoising process is conditioned on.
            attention_mask (`torch.BoolTensor` of shape `(batch_size, num_embeddings)`):
                Text mask for the text embeddings.
            return_dict (`bool`, *optional*, defaults to `True`):
Steven Liu's avatar
Steven Liu committed
268
                Whether or not to return a [`~models.prior_transformer.PriorTransformerOutput`] instead of a plain
Will Berman's avatar
Will Berman committed
269
270
271
272
                tuple.

        Returns:
            [`~models.prior_transformer.PriorTransformerOutput`] or `tuple`:
Steven Liu's avatar
Steven Liu committed
273
274
                If return_dict is True, a [`~models.prior_transformer.PriorTransformerOutput`] is returned, otherwise a
                tuple is returned where the first element is the sample tensor.
Will Berman's avatar
Will Berman committed
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
        """
        batch_size = hidden_states.shape[0]

        timesteps = timestep
        if not torch.is_tensor(timesteps):
            timesteps = torch.tensor([timesteps], dtype=torch.long, device=hidden_states.device)
        elif torch.is_tensor(timesteps) and len(timesteps.shape) == 0:
            timesteps = timesteps[None].to(hidden_states.device)

        # broadcast to batch dimension in a way that's compatible with ONNX/Core ML
        timesteps = timesteps * torch.ones(batch_size, dtype=timesteps.dtype, device=timesteps.device)

        timesteps_projected = self.time_proj(timesteps)

        # timesteps does not contain any weights and will always return f32 tensors
        # but time_embedding might be fp16, so we need to cast here.
        timesteps_projected = timesteps_projected.to(dtype=self.dtype)
        time_embeddings = self.time_embedding(timesteps_projected)

YiYi Xu's avatar
YiYi Xu committed
294
295
296
        if self.embedding_proj_norm is not None:
            proj_embedding = self.embedding_proj_norm(proj_embedding)

Will Berman's avatar
Will Berman committed
297
        proj_embeddings = self.embedding_proj(proj_embedding)
YiYi Xu's avatar
YiYi Xu committed
298
299
300
301
302
        if self.encoder_hidden_states_proj is not None and encoder_hidden_states is not None:
            encoder_hidden_states = self.encoder_hidden_states_proj(encoder_hidden_states)
        elif self.encoder_hidden_states_proj is not None and encoder_hidden_states is None:
            raise ValueError("`encoder_hidden_states_proj` requires `encoder_hidden_states` to be set")

Will Berman's avatar
Will Berman committed
303
        hidden_states = self.proj_in(hidden_states)
YiYi Xu's avatar
YiYi Xu committed
304

Will Berman's avatar
Will Berman committed
305
306
        positional_embeddings = self.positional_embedding.to(hidden_states.dtype)

YiYi Xu's avatar
YiYi Xu committed
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
        additional_embeds = []
        additional_embeddings_len = 0

        if encoder_hidden_states is not None:
            additional_embeds.append(encoder_hidden_states)
            additional_embeddings_len += encoder_hidden_states.shape[1]

        if len(proj_embeddings.shape) == 2:
            proj_embeddings = proj_embeddings[:, None, :]

        if len(hidden_states.shape) == 2:
            hidden_states = hidden_states[:, None, :]

        additional_embeds = additional_embeds + [
            proj_embeddings,
            time_embeddings[:, None, :],
            hidden_states,
        ]

        if self.prd_embedding is not None:
            prd_embedding = self.prd_embedding.to(hidden_states.dtype).expand(batch_size, -1, -1)
            additional_embeds.append(prd_embedding)

Will Berman's avatar
Will Berman committed
330
        hidden_states = torch.cat(
YiYi Xu's avatar
YiYi Xu committed
331
            additional_embeds,
Will Berman's avatar
Will Berman committed
332
333
334
            dim=1,
        )

YiYi Xu's avatar
YiYi Xu committed
335
336
337
338
339
340
341
342
343
344
345
346
347
348
        # Allow positional_embedding to not include the `addtional_embeddings` and instead pad it with zeros for these additional tokens
        additional_embeddings_len = additional_embeddings_len + proj_embeddings.shape[1] + 1
        if positional_embeddings.shape[1] < hidden_states.shape[1]:
            positional_embeddings = F.pad(
                positional_embeddings,
                (
                    0,
                    0,
                    additional_embeddings_len,
                    self.prd_embedding.shape[1] if self.prd_embedding is not None else 0,
                ),
                value=0.0,
            )

Will Berman's avatar
Will Berman committed
349
350
351
352
353
354
355
356
        hidden_states = hidden_states + positional_embeddings

        if attention_mask is not None:
            attention_mask = (1 - attention_mask.to(hidden_states.dtype)) * -10000.0
            attention_mask = F.pad(attention_mask, (0, self.additional_embeddings), value=0.0)
            attention_mask = (attention_mask[:, None, :] + self.causal_attention_mask).to(hidden_states.dtype)
            attention_mask = attention_mask.repeat_interleave(self.config.num_attention_heads, dim=0)

YiYi Xu's avatar
YiYi Xu committed
357
358
359
        if self.norm_in is not None:
            hidden_states = self.norm_in(hidden_states)

Will Berman's avatar
Will Berman committed
360
361
362
363
        for block in self.transformer_blocks:
            hidden_states = block(hidden_states, attention_mask=attention_mask)

        hidden_states = self.norm_out(hidden_states)
YiYi Xu's avatar
YiYi Xu committed
364
365
366
367
368
369

        if self.prd_embedding is not None:
            hidden_states = hidden_states[:, -1]
        else:
            hidden_states = hidden_states[:, additional_embeddings_len:]

Will Berman's avatar
Will Berman committed
370
371
372
373
374
375
376
377
378
379
        predicted_image_embedding = self.proj_to_clip_embeddings(hidden_states)

        if not return_dict:
            return (predicted_image_embedding,)

        return PriorTransformerOutput(predicted_image_embedding=predicted_image_embedding)

    def post_process_latents(self, prior_latents):
        prior_latents = (prior_latents * self.clip_std) + self.clip_mean
        return prior_latents