Spaces:
Running
on
A10G
Running
on
A10G
| from functools import partial | |
| from typing import List, Optional, Union | |
| from einops import rearrange | |
| import torch | |
| from ...modules.diffusionmodules.openaimodel import * | |
| from ...modules.video_attention import SpatialVideoTransformer | |
| from ...util import default | |
| from .util import AlphaBlender | |
| class VideoResBlock(ResBlock): | |
| def __init__( | |
| self, | |
| channels: int, | |
| emb_channels: int, | |
| dropout: float, | |
| video_kernel_size: Union[int, List[int]] = 3, | |
| merge_strategy: str = "fixed", | |
| merge_factor: float = 0.5, | |
| out_channels: Optional[int] = None, | |
| use_conv: bool = False, | |
| use_scale_shift_norm: bool = False, | |
| dims: int = 2, | |
| use_checkpoint: bool = False, | |
| up: bool = False, | |
| down: bool = False, | |
| ): | |
| super().__init__( | |
| channels, | |
| emb_channels, | |
| dropout, | |
| out_channels=out_channels, | |
| use_conv=use_conv, | |
| use_scale_shift_norm=use_scale_shift_norm, | |
| dims=dims, | |
| use_checkpoint=use_checkpoint, | |
| up=up, | |
| down=down, | |
| ) | |
| self.time_stack = ResBlock( | |
| default(out_channels, channels), | |
| emb_channels, | |
| dropout=dropout, | |
| dims=3, | |
| out_channels=default(out_channels, channels), | |
| use_scale_shift_norm=False, | |
| use_conv=False, | |
| up=False, | |
| down=False, | |
| kernel_size=video_kernel_size, | |
| use_checkpoint=use_checkpoint, | |
| exchange_temb_dims=True, | |
| ) | |
| self.time_mixer = AlphaBlender( | |
| alpha=merge_factor, | |
| merge_strategy=merge_strategy, | |
| rearrange_pattern="b t -> b 1 t 1 1", | |
| ) | |
| def forward( | |
| self, | |
| x: th.Tensor, | |
| emb: th.Tensor, | |
| num_video_frames: int, | |
| image_only_indicator: Optional[th.Tensor] = None, | |
| ) -> th.Tensor: | |
| x = super().forward(x, emb) | |
| x_mix = rearrange(x, "(b t) c h w -> b c t h w", t=num_video_frames) | |
| x = rearrange(x, "(b t) c h w -> b c t h w", t=num_video_frames) | |
| x = self.time_stack( | |
| x, rearrange(emb, "(b t) ... -> b t ...", t=num_video_frames) | |
| ) | |
| x = self.time_mixer( | |
| x_spatial=x_mix, x_temporal=x, image_only_indicator=image_only_indicator | |
| ) | |
| x = rearrange(x, "b c t h w -> (b t) c h w") | |
| return x | |
| class VideoUNet(nn.Module): | |
| def __init__( | |
| self, | |
| in_channels: int, | |
| model_channels: int, | |
| out_channels: int, | |
| num_frames: int, | |
| num_res_blocks: int, | |
| attention_resolutions: int, | |
| dropout: float = 0.0, | |
| channel_mult: List[int] = (1, 2, 4, 8), | |
| conv_resample: bool = True, | |
| dims: int = 2, | |
| num_classes: Optional[int] = None, | |
| use_checkpoint: bool = False, | |
| num_heads: int = -1, | |
| num_head_channels: int = -1, | |
| num_heads_upsample: int = -1, | |
| use_scale_shift_norm: bool = False, | |
| resblock_updown: bool = False, | |
| transformer_depth: Union[List[int], int] = 1, | |
| transformer_depth_middle: Optional[int] = None, | |
| context_dim: Optional[int] = None, | |
| time_downup: bool = False, | |
| time_context_dim: Optional[int] = None, | |
| extra_ff_mix_layer: bool = False, | |
| use_spatial_context: bool = False, | |
| merge_strategy: str = "fixed", | |
| merge_factor: float = 0.5, | |
| spatial_transformer_attn_type: str = "softmax", | |
| video_kernel_size: Union[int, List[int]] = 3, | |
| use_linear_in_transformer: bool = False, | |
| adm_in_channels: Optional[int] = None, | |
| disable_temporal_crossattention: bool = False, | |
| max_ddpm_temb_period: int = 10000, | |
| ): | |
| super(VideoUNet, self).__init__() | |
| assert context_dim is not None | |
| if num_heads_upsample == -1: | |
| num_heads_upsample = num_heads | |
| if num_heads == -1: | |
| assert num_head_channels != -1 | |
| if num_head_channels == -1: | |
| assert num_heads != -1 | |
| self.in_channels = in_channels | |
| self.model_channels = model_channels | |
| self.out_channels = out_channels | |
| self.num_frames = num_frames | |
| if isinstance(transformer_depth, int): | |
| transformer_depth = len(channel_mult) * [transformer_depth] | |
| transformer_depth_middle = default( | |
| transformer_depth_middle, transformer_depth[-1] | |
| ) | |
| self.num_res_blocks = num_res_blocks | |
| self.attention_resolutions = attention_resolutions | |
| self.dropout = dropout | |
| self.channel_mult = channel_mult | |
| self.conv_resample = conv_resample | |
| self.num_classes = num_classes | |
| self.use_checkpoint = use_checkpoint | |
| self.num_heads = num_heads | |
| self.num_head_channels = num_head_channels | |
| self.num_heads_upsample = num_heads_upsample | |
| time_embed_dim = model_channels * 4 | |
| self.time_embed = nn.Sequential( | |
| linear(model_channels, time_embed_dim), | |
| nn.SiLU(), | |
| linear(time_embed_dim, time_embed_dim), | |
| ) | |
| if self.num_classes is not None: | |
| if isinstance(self.num_classes, int): | |
| self.label_emb = nn.Embedding(num_classes, time_embed_dim) | |
| elif self.num_classes == "continuous": | |
| print("setting up linear c_adm embedding layer") | |
| self.label_emb = nn.Linear(1, time_embed_dim) | |
| elif self.num_classes == "timestep": | |
| self.label_emb = nn.Sequential( | |
| Timestep(model_channels), | |
| nn.Sequential( | |
| linear(model_channels, time_embed_dim), | |
| nn.SiLU(), | |
| linear(time_embed_dim, time_embed_dim), | |
| ), | |
| ) | |
| elif self.num_classes == "sequential": | |
| assert adm_in_channels is not None | |
| self.label_emb = nn.Sequential( | |
| nn.Sequential( | |
| linear(adm_in_channels, time_embed_dim), | |
| nn.SiLU(), | |
| linear(time_embed_dim, time_embed_dim), | |
| ) | |
| ) | |
| else: | |
| raise ValueError() | |
| self.input_blocks = nn.ModuleList( | |
| [ | |
| TimestepEmbedSequential( | |
| conv_nd(dims, in_channels, model_channels, 3, padding=1) | |
| ) | |
| ] | |
| ) | |
| self._feature_size = model_channels | |
| input_block_chans = [model_channels] | |
| ch = model_channels | |
| ds = 1 | |
| def get_attention_layer( | |
| ch, | |
| num_heads, | |
| dim_head, | |
| depth=1, | |
| context_dim=None, | |
| use_checkpoint=False, | |
| disabled_sa=False, | |
| ): | |
| return SpatialVideoTransformer( | |
| ch, | |
| num_heads, | |
| dim_head, | |
| depth=depth, | |
| context_dim=context_dim, | |
| time_context_dim=time_context_dim, | |
| dropout=dropout, | |
| ff_in=extra_ff_mix_layer, | |
| use_spatial_context=use_spatial_context, | |
| merge_strategy=merge_strategy, | |
| merge_factor=merge_factor, | |
| checkpoint=use_checkpoint, | |
| use_linear=use_linear_in_transformer, | |
| attn_mode=spatial_transformer_attn_type, | |
| disable_self_attn=disabled_sa, | |
| disable_temporal_crossattention=disable_temporal_crossattention, | |
| max_time_embed_period=max_ddpm_temb_period, | |
| ) | |
| def get_resblock( | |
| merge_factor, | |
| merge_strategy, | |
| video_kernel_size, | |
| ch, | |
| time_embed_dim, | |
| dropout, | |
| out_ch, | |
| dims, | |
| use_checkpoint, | |
| use_scale_shift_norm, | |
| down=False, | |
| up=False, | |
| ): | |
| return VideoResBlock( | |
| merge_factor=merge_factor, | |
| merge_strategy=merge_strategy, | |
| video_kernel_size=video_kernel_size, | |
| channels=ch, | |
| emb_channels=time_embed_dim, | |
| dropout=dropout, | |
| out_channels=out_ch, | |
| dims=dims, | |
| use_checkpoint=use_checkpoint, | |
| use_scale_shift_norm=use_scale_shift_norm, | |
| down=down, | |
| up=up, | |
| ) | |
| for level, mult in enumerate(channel_mult): | |
| for _ in range(num_res_blocks): | |
| layers = [ | |
| get_resblock( | |
| merge_factor=merge_factor, | |
| merge_strategy=merge_strategy, | |
| video_kernel_size=video_kernel_size, | |
| ch=ch, | |
| time_embed_dim=time_embed_dim, | |
| dropout=dropout, | |
| out_ch=mult * model_channels, | |
| dims=dims, | |
| use_checkpoint=use_checkpoint, | |
| use_scale_shift_norm=use_scale_shift_norm, | |
| ) | |
| ] | |
| ch = mult * model_channels | |
| if ds in attention_resolutions: | |
| if num_head_channels == -1: | |
| dim_head = ch // num_heads | |
| else: | |
| num_heads = ch // num_head_channels | |
| dim_head = num_head_channels | |
| layers.append( | |
| get_attention_layer( | |
| ch, | |
| num_heads, | |
| dim_head, | |
| depth=transformer_depth[level], | |
| context_dim=context_dim, | |
| use_checkpoint=use_checkpoint, | |
| disabled_sa=False, | |
| ) | |
| ) | |
| self.input_blocks.append(TimestepEmbedSequential(*layers)) | |
| self._feature_size += ch | |
| input_block_chans.append(ch) | |
| if level != len(channel_mult) - 1: | |
| ds *= 2 | |
| out_ch = ch | |
| self.input_blocks.append( | |
| TimestepEmbedSequential( | |
| get_resblock( | |
| merge_factor=merge_factor, | |
| merge_strategy=merge_strategy, | |
| video_kernel_size=video_kernel_size, | |
| ch=ch, | |
| time_embed_dim=time_embed_dim, | |
| dropout=dropout, | |
| out_ch=out_ch, | |
| dims=dims, | |
| use_checkpoint=use_checkpoint, | |
| use_scale_shift_norm=use_scale_shift_norm, | |
| down=True, | |
| ) | |
| if resblock_updown | |
| else Downsample( | |
| ch, | |
| conv_resample, | |
| dims=dims, | |
| out_channels=out_ch, | |
| third_down=time_downup, | |
| ) | |
| ) | |
| ) | |
| ch = out_ch | |
| input_block_chans.append(ch) | |
| self._feature_size += ch | |
| if num_head_channels == -1: | |
| dim_head = ch // num_heads | |
| else: | |
| num_heads = ch // num_head_channels | |
| dim_head = num_head_channels | |
| self.middle_block = TimestepEmbedSequential( | |
| get_resblock( | |
| merge_factor=merge_factor, | |
| merge_strategy=merge_strategy, | |
| video_kernel_size=video_kernel_size, | |
| ch=ch, | |
| time_embed_dim=time_embed_dim, | |
| out_ch=None, | |
| dropout=dropout, | |
| dims=dims, | |
| use_checkpoint=use_checkpoint, | |
| use_scale_shift_norm=use_scale_shift_norm, | |
| ), | |
| get_attention_layer( | |
| ch, | |
| num_heads, | |
| dim_head, | |
| depth=transformer_depth_middle, | |
| context_dim=context_dim, | |
| use_checkpoint=use_checkpoint, | |
| ), | |
| get_resblock( | |
| merge_factor=merge_factor, | |
| merge_strategy=merge_strategy, | |
| video_kernel_size=video_kernel_size, | |
| ch=ch, | |
| out_ch=None, | |
| time_embed_dim=time_embed_dim, | |
| dropout=dropout, | |
| dims=dims, | |
| use_checkpoint=use_checkpoint, | |
| use_scale_shift_norm=use_scale_shift_norm, | |
| ), | |
| ) | |
| self._feature_size += ch | |
| self.output_blocks = nn.ModuleList([]) | |
| for level, mult in list(enumerate(channel_mult))[::-1]: | |
| for i in range(num_res_blocks + 1): | |
| ich = input_block_chans.pop() | |
| layers = [ | |
| get_resblock( | |
| merge_factor=merge_factor, | |
| merge_strategy=merge_strategy, | |
| video_kernel_size=video_kernel_size, | |
| ch=ch + ich, | |
| time_embed_dim=time_embed_dim, | |
| dropout=dropout, | |
| out_ch=model_channels * mult, | |
| dims=dims, | |
| use_checkpoint=use_checkpoint, | |
| use_scale_shift_norm=use_scale_shift_norm, | |
| ) | |
| ] | |
| ch = model_channels * mult | |
| if ds in attention_resolutions: | |
| if num_head_channels == -1: | |
| dim_head = ch // num_heads | |
| else: | |
| num_heads = ch // num_head_channels | |
| dim_head = num_head_channels | |
| layers.append( | |
| get_attention_layer( | |
| ch, | |
| num_heads, | |
| dim_head, | |
| depth=transformer_depth[level], | |
| context_dim=context_dim, | |
| use_checkpoint=use_checkpoint, | |
| disabled_sa=False, | |
| ) | |
| ) | |
| if level and i == num_res_blocks: | |
| out_ch = ch | |
| ds //= 2 | |
| layers.append( | |
| get_resblock( | |
| merge_factor=merge_factor, | |
| merge_strategy=merge_strategy, | |
| video_kernel_size=video_kernel_size, | |
| ch=ch, | |
| time_embed_dim=time_embed_dim, | |
| dropout=dropout, | |
| out_ch=out_ch, | |
| dims=dims, | |
| use_checkpoint=use_checkpoint, | |
| use_scale_shift_norm=use_scale_shift_norm, | |
| up=True, | |
| ) | |
| if resblock_updown | |
| else Upsample( | |
| ch, | |
| conv_resample, | |
| dims=dims, | |
| out_channels=out_ch, | |
| third_up=time_downup, | |
| ) | |
| ) | |
| self.output_blocks.append(TimestepEmbedSequential(*layers)) | |
| self._feature_size += ch | |
| self.out = nn.Sequential( | |
| normalization(ch), | |
| nn.SiLU(), | |
| zero_module(conv_nd(dims, model_channels, out_channels, 3, padding=1)), | |
| ) | |
| def forward( | |
| self, | |
| x: th.Tensor, | |
| timesteps: th.Tensor, | |
| context: Optional[th.Tensor] = None, | |
| y: Optional[th.Tensor] = None, | |
| time_context: Optional[th.Tensor] = None, | |
| num_video_frames: Optional[int] = None, | |
| image_only_indicator: Optional[th.Tensor] = None, | |
| ): | |
| assert (y is not None) == ( | |
| self.num_classes is not None | |
| ), "must specify y if and only if the model is class-conditional -> no, relax this TODO" | |
| t_emb = timestep_embedding(timesteps, self.model_channels, repeat_only=False) | |
| emb = self.time_embed(t_emb) | |
| ## tbd: check the role of "image_only_indicator" | |
| num_video_frames = self.num_frames | |
| image_only_indicator = torch.zeros( | |
| x.shape[0]//num_video_frames, num_video_frames | |
| ).to(x.device) if image_only_indicator is None else image_only_indicator | |
| if self.num_classes is not None: | |
| assert y.shape[0] == x.shape[0] | |
| emb = emb + self.label_emb(y) | |
| ## x shape: [bt,c,h,w] | |
| h = x | |
| hs = [] | |
| for module in self.input_blocks: | |
| h = module( | |
| h, | |
| emb, | |
| context=context, | |
| image_only_indicator=image_only_indicator, | |
| time_context=time_context, | |
| num_video_frames=num_video_frames, | |
| ) | |
| hs.append(h) | |
| h = self.middle_block( | |
| h, | |
| emb, | |
| context=context, | |
| image_only_indicator=image_only_indicator, | |
| time_context=time_context, | |
| num_video_frames=num_video_frames, | |
| ) | |
| for module in self.output_blocks: | |
| h = th.cat([h, hs.pop()], dim=1) | |
| h = module( | |
| h, | |
| emb, | |
| context=context, | |
| image_only_indicator=image_only_indicator, | |
| time_context=time_context, | |
| num_video_frames=num_video_frames, | |
| ) | |
| h = h.type(x.dtype) | |
| return self.out(h) | |