Spaces:
Running
on
Zero
Running
on
Zero
| import math | |
| import torch | |
| import torch.nn as nn | |
| from einops import rearrange, repeat | |
| class ImageProjModel(nn.Module): | |
| """Projection Model""" | |
| def __init__( | |
| self, | |
| cross_attention_dim=1024, | |
| clip_embeddings_dim=1024, | |
| clip_extra_context_tokens=4, | |
| ): | |
| super().__init__() | |
| self.cross_attention_dim = cross_attention_dim | |
| self.clip_extra_context_tokens = clip_extra_context_tokens | |
| self.proj = nn.Linear( | |
| clip_embeddings_dim, self.clip_extra_context_tokens * cross_attention_dim | |
| ) | |
| self.norm = nn.LayerNorm(cross_attention_dim) | |
| def forward(self, image_embeds): | |
| # embeds = image_embeds | |
| embeds = image_embeds.type(list(self.proj.parameters())[0].dtype) | |
| clip_extra_context_tokens = self.proj(embeds).reshape( | |
| -1, self.clip_extra_context_tokens, self.cross_attention_dim | |
| ) | |
| clip_extra_context_tokens = self.norm(clip_extra_context_tokens) | |
| return clip_extra_context_tokens | |
| # FFN | |
| def FeedForward(dim, mult=4): | |
| inner_dim = int(dim * mult) | |
| return nn.Sequential( | |
| nn.LayerNorm(dim), | |
| nn.Linear(dim, inner_dim, bias=False), | |
| nn.GELU(), | |
| nn.Linear(inner_dim, dim, bias=False), | |
| ) | |
| def reshape_tensor(x, heads): | |
| bs, length, width = x.shape | |
| # (bs, length, width) --> (bs, length, n_heads, dim_per_head) | |
| x = x.view(bs, length, heads, -1) | |
| # (bs, length, n_heads, dim_per_head) --> (bs, n_heads, length, dim_per_head) | |
| x = x.transpose(1, 2) | |
| # (bs, n_heads, length, dim_per_head) --> (bs*n_heads, length, dim_per_head) | |
| x = x.reshape(bs, heads, length, -1) | |
| return x | |
| class PerceiverAttention(nn.Module): | |
| def __init__(self, *, dim, dim_head=64, heads=8): | |
| super().__init__() | |
| self.scale = dim_head**-0.5 | |
| self.dim_head = dim_head | |
| self.heads = heads | |
| inner_dim = dim_head * heads | |
| self.norm1 = nn.LayerNorm(dim) | |
| self.norm2 = nn.LayerNorm(dim) | |
| self.to_q = nn.Linear(dim, inner_dim, bias=False) | |
| self.to_kv = nn.Linear(dim, inner_dim * 2, bias=False) | |
| self.to_out = nn.Linear(inner_dim, dim, bias=False) | |
| def forward(self, x, latents): | |
| """ | |
| Args: | |
| x (torch.Tensor): image features | |
| shape (b, n1, D) | |
| latent (torch.Tensor): latent features | |
| shape (b, n2, D) | |
| """ | |
| x = self.norm1(x) | |
| latents = self.norm2(latents) | |
| b, l, _ = latents.shape | |
| q = self.to_q(latents) | |
| kv_input = torch.cat((x, latents), dim=-2) | |
| k, v = self.to_kv(kv_input).chunk(2, dim=-1) | |
| q = reshape_tensor(q, self.heads) | |
| k = reshape_tensor(k, self.heads) | |
| v = reshape_tensor(v, self.heads) | |
| # attention | |
| scale = 1 / math.sqrt(math.sqrt(self.dim_head)) | |
| # More stable with f16 than dividing afterwards | |
| weight = (q * scale) @ (k * scale).transpose(-2, -1) | |
| weight = torch.softmax(weight.float(), dim=-1).type(weight.dtype) | |
| out = weight @ v | |
| out = out.permute(0, 2, 1, 3).reshape(b, l, -1) | |
| return self.to_out(out) | |
| class Resampler(nn.Module): | |
| def __init__( | |
| self, | |
| dim=1024, | |
| depth=8, | |
| dim_head=64, | |
| heads=16, | |
| num_queries=8, | |
| embedding_dim=768, | |
| output_dim=1024, | |
| ff_mult=4, | |
| video_length=None, | |
| ): | |
| super().__init__() | |
| self.num_queries = num_queries | |
| self.video_length = video_length | |
| if video_length is not None: | |
| num_queries = num_queries * video_length | |
| self.latents = nn.Parameter(torch.randn(1, num_queries, dim) / dim**0.5) | |
| self.proj_in = nn.Linear(embedding_dim, dim) | |
| self.proj_out = nn.Linear(dim, output_dim) | |
| self.norm_out = nn.LayerNorm(output_dim) | |
| self.layers = nn.ModuleList([]) | |
| for _ in range(depth): | |
| self.layers.append( | |
| nn.ModuleList( | |
| [ | |
| PerceiverAttention(dim=dim, dim_head=dim_head, heads=heads), | |
| FeedForward(dim=dim, mult=ff_mult), | |
| ] | |
| ) | |
| ) | |
| def forward(self, x): | |
| latents = self.latents.repeat(x.size(0), 1, 1) # B (T L) C | |
| x = self.proj_in(x) | |
| for attn, ff in self.layers: | |
| latents = attn(x, latents) + latents | |
| latents = ff(latents) + latents | |
| latents = self.proj_out(latents) | |
| latents = self.norm_out(latents) # B L C or B (T L) C | |
| return latents | |
| class CameraPoseQueryTransformer(nn.Module): | |
| def __init__( | |
| self, | |
| dim=1024, | |
| depth=8, | |
| dim_head=64, | |
| heads=16, | |
| num_queries=8, | |
| embedding_dim=768, | |
| output_dim=1024, | |
| ff_mult=4, | |
| num_views=None, | |
| use_multi_view_attention=True, | |
| ): | |
| super().__init__() | |
| self.num_queries = num_queries | |
| self.num_views = num_views | |
| assert num_views is not None, "video_length must be given." | |
| self.use_multi_view_attention = use_multi_view_attention | |
| self.camera_pose_embedding_layers = nn.Sequential( | |
| nn.Linear(12, dim), | |
| nn.SiLU(), | |
| nn.Linear(dim, dim), | |
| nn.SiLU(), | |
| nn.Linear(dim, dim), | |
| ) | |
| nn.init.zeros_(self.camera_pose_embedding_layers[-1].weight) | |
| nn.init.zeros_(self.camera_pose_embedding_layers[-1].bias) | |
| self.latents = nn.Parameter( | |
| torch.randn(1, num_views * num_queries, dim) / dim**0.5 | |
| ) | |
| self.proj_in = nn.Linear(embedding_dim, dim) | |
| self.proj_out = nn.Linear(dim, output_dim) | |
| self.norm_out = nn.LayerNorm(output_dim) | |
| self.layers = nn.ModuleList([]) | |
| for _ in range(depth): | |
| self.layers.append( | |
| nn.ModuleList( | |
| [ | |
| PerceiverAttention(dim=dim, dim_head=dim_head, heads=heads), | |
| FeedForward(dim=dim, mult=ff_mult), | |
| ] | |
| ) | |
| ) | |
| def forward(self, x, camera_poses): | |
| # camera_poses: (b, t, 12) | |
| batch_size, num_views, _ = camera_poses.shape | |
| # latents: (1, t*q, d) -> (b, t*q, d) | |
| latents = self.latents.repeat(batch_size, 1, 1) | |
| x = self.proj_in(x) | |
| # camera_poses: (b*t, 12) | |
| camera_poses = rearrange(camera_poses, "b t d -> (b t) d", t=num_views) | |
| camera_poses = self.camera_pose_embedding_layers( | |
| camera_poses | |
| ) # camera_poses: (b*t, d) | |
| # camera_poses: (b, t, d) | |
| camera_poses = rearrange(camera_poses, "(b t) d -> b t d", t=num_views) | |
| # camera_poses: (b, t*q, d) | |
| camera_poses = repeat(camera_poses, "b t d -> b (t q) d", q=self.num_queries) | |
| latents = latents + camera_poses # b, t*q, d | |
| latents = rearrange( | |
| latents, | |
| "b (t q) d -> (b t) q d", | |
| b=batch_size, | |
| t=num_views, | |
| q=self.num_queries, | |
| ) # (b*t, q, d) | |
| _, x_seq_size, _ = x.shape | |
| for layer_idx, (attn, ff) in enumerate(self.layers): | |
| if self.use_multi_view_attention and layer_idx % 2 == 1: | |
| # latents: (b*t, q, d) | |
| latents = rearrange( | |
| latents, | |
| "(b t) q d -> b (t q) d", | |
| b=batch_size, | |
| t=num_views, | |
| q=self.num_queries, | |
| ) | |
| # x: (b*t, s, d) | |
| x = rearrange( | |
| x, "(b t) s d -> b (t s) d", b=batch_size, t=num_views, s=x_seq_size | |
| ) | |
| # print("After rearrange: latents.shape=", latents.shape) | |
| # print("After rearrange: x.shape=", camera_poses.shape) | |
| latents = attn(x, latents) + latents | |
| latents = ff(latents) + latents | |
| if self.use_multi_view_attention and layer_idx % 2 == 1: | |
| # latents: (b*q, t, d) | |
| latents = rearrange( | |
| latents, | |
| "b (t q) d -> (b t) q d", | |
| b=batch_size, | |
| t=num_views, | |
| q=self.num_queries, | |
| ) | |
| # x: (b*s, t, d) | |
| x = rearrange( | |
| x, "b (t s) d -> (b t) s d", b=batch_size, t=num_views, s=x_seq_size | |
| ) | |
| latents = self.proj_out(latents) | |
| latents = self.norm_out(latents) # B L C or B (T L) C | |
| return latents | |