| import torch |
| from torch import nn |
| from torch.nn import functional as F |
| from functools import partial |
| import typing as tp |
|
|
| from einops import rearrange |
| from diffusers import ( |
| AutoencoderKL, |
| FlowMatchEulerDiscreteScheduler, |
| SD3Transformer2DModel, |
| StableDiffusion3Pipeline, |
| ) |
| import math |
|
|
| class SinePositionalEmbedding(nn.Module): |
| def __init__( |
| self, |
| embedding_dim: int, |
| dropout: float=0.0, |
| scale: bool=False, |
| alpha: bool=False, ): |
| super().__init__() |
| self.embedding_dim = embedding_dim |
| self.x_scale = math.sqrt(embedding_dim) if scale else 1.0 |
| self.alpha = nn.Parameter(torch.ones(1), requires_grad=alpha) |
| self.dropout = torch.nn.Dropout(p=dropout) |
|
|
| self.reverse = False |
| self.pe = None |
| self.extend_pe(torch.tensor(0.0).expand(1, 4000)) |
|
|
| def extend_pe(self, x): |
| """Reset the positional encodings.""" |
| if self.pe is not None: |
| if self.pe.size(1) >= x.size(1): |
| if self.pe.dtype != x.dtype or self.pe.device != x.device: |
| self.pe = self.pe.to(dtype=x.dtype, device=x.device) |
| return |
| pe = torch.zeros(x.size(1), self.embedding_dim) |
| if self.reverse: |
| position = torch.arange( |
| x.size(1) - 1, -1, -1.0, dtype=torch.float32).unsqueeze(1) |
| else: |
| position = torch.arange( |
| 0, x.size(1), dtype=torch.float32).unsqueeze(1) |
| div_term = torch.exp( |
| torch.arange(0, self.embedding_dim, 2, dtype=torch.float32) * |
| -(math.log(10000.0) / self.embedding_dim)) |
| pe[:, 0::2] = torch.sin(position * div_term) |
| pe[:, 1::2] = torch.cos(position * div_term) |
| pe = pe.unsqueeze(0) |
| self.pe = pe.to(device=x.device, dtype=x.dtype).detach() |
|
|
| def forward(self, x: torch.Tensor) -> torch.Tensor: |
| self.extend_pe(x) |
| output = x.unsqueeze(-1) if x.ndim == 2 else x |
| output = output * self.x_scale + self.alpha * self.pe[:, :x.size(1)] |
| return self.dropout(output) |
|
|
|
|
|
|
| class SD3DiffusionModelWrapper(nn.Module): |
| def __init__( |
| self, |
| ): |
| super().__init__() |
| self.model = SD3Transformer2DModel( |
| attention_head_dim=64, |
| caption_projection_dim=1024, |
| in_channels=16, |
| joint_attention_dim=384, |
| num_attention_heads=16, |
| num_layers=6, |
| out_channels=16, |
| patch_size=1, |
| pooled_projection_dim=2048, |
| pos_embed_max_size=512, |
| sample_size=512 |
| ) |
| context_dim = 1024 |
| self.cond_map_disc = nn.Embedding(32768, 192) |
| self.cond_map_cont = nn.Conv1d(context_dim, 192, 3, padding=1) |
| self.ssl_position = SinePositionalEmbedding(192*2, dropout=0.1, scale=False, alpha=True) |
|
|
|
|
|
|
| def forward(self, x, t, cond=None, cfg=False, **kwargs): |
| """ |
| Forward pass of DiT. |
| x: (N, C, H, W) tensor of spatial inputs (images or latent representations of images) |
| t: (N,) tensor of diffusion timesteps |
| cond: [(N, L, D) tensor of SSL embeddings, (N, L) tensor of SSL tokens] |
| """ |
| ssl_q, toks = cond |
| cond_disc = self.cond_map_disc(toks).transpose(1, 2) |
| cond_cont = self.cond_map_cont(ssl_q.to(x.dtype).transpose(1, 2)) |
| cond = torch.cat([cond_disc, cond_cont], dim=1) |
| cond = self.ssl_position(cond.transpose(1, 2)) |
|
|
| if cfg: |
| cond = cond*0 |
|
|
| |
| |
| |
| pooled_projections = torch.randn(x.shape[0], 2048).to(x.device) |
| noise_pred = self.model( |
| hidden_states=x, |
| timestep=t, |
| encoder_hidden_states=cond, |
| pooled_projections=pooled_projections, |
| return_dict=False, |
| )[0] |
| return noise_pred |
|
|
| if __name__ == "__main__": |
| model = SD3DiffusionModelWrapper().cuda() |
| print('n params', sum(param.numel() for param in model.parameters())/1e6,"m") |
| x = torch.randn(2, 16, 512, 32).cuda() |
| t = torch.tensor([0.5, 0.5]).cuda() |
| cond = [torch.randn(2, 1189, 1024).cuda(), torch.randint(0, 32768, (2, 1189)).cuda()] |
| out = model(x, t, cond) |
| print(out.shape) |
