import json import os from typing import List, Tuple, Union, Optional from functools import lru_cache import random import math import torch import numpy as np import torch.nn as nn import torch.nn.functional as F from einops import rearrange from diffusers import ConfigMixin, ModelMixin from diffusers.configuration_utils import register_to_config from diffusers.utils.torch_utils import maybe_allow_in_graph from diffusers.models.autoencoders.vae import ( DiagonalGaussianDistribution, ) from dataclasses import dataclass import numbers # from diffusers.models.modeling_outputs import AutoencoderKLOutput from diffusers.utils import BaseOutput from diffusers.models.attention import FeedForward from diffusers.models.attention_processor import Attention from torch.nn.attention.flex_attention import ( _DEFAULT_SPARSE_BLOCK_SIZE, create_block_mask, create_mask, flex_attention, ) @dataclass class EncoderOutput(BaseOutput): r""" Output of encoding method. Args: latent (`torch.Tensor` of shape `(batch_size, num_channels, latent_height, latent_width)`): The encoded latent. """ latent: torch.Tensor @dataclass class DecoderOutput(BaseOutput): r""" Output of decoding method. Args: sample (`torch.Tensor` of shape `(batch_size, num_channels, height, width)`): The decoded output sample from the last layer of the model. """ sample: torch.Tensor commit_loss: Optional[torch.FloatTensor] = None features: Optional = None @dataclass class AutoencoderKLOutput(BaseOutput): """ Output of AutoencoderKL encoding method. Args: latent_dist (`DiagonalGaussianDistribution`): Encoded outputs of `Encoder` represented as the mean and logvar of `DiagonalGaussianDistribution`. `DiagonalGaussianDistribution` allows for sampling latents from the distribution. """ latent_dist: "DiagonalGaussianDistribution" # noqa: F821 features: Optional = None def our_drop(z, p=0.5): b, c, t, h, w = z.shape mask = torch.arange(0, c, device=z.device).unsqueeze(0).repeat(b, 1) idx = torch.randint(c // 4, c, (b, 1), device=z.device).repeat(1, c) mask = (mask <= idx).float() return z * mask[:, :, None, None, None] def pad_at_dim(t, pad, dim=-1): dims_from_right = (-dim - 1) if dim < 0 else (t.ndim - dim - 1) zeros = (0, 0) * dims_from_right return F.pad(t, (*zeros, *pad), mode="constant") def cast_tuple(t, length=1): return t if isinstance(t, tuple) else ((t,) * length) # from ltx_video.models.transformers.attention import BasicTransformerBlock class FeatureFusion(nn.Module): def __init__(self, channels, conv_fn): super().__init__() # self.layer = conv_fn(channels * 2, channels, kernel_size=(3, 3, 3), bias=True) def forward(self, x: torch.FloatTensor, res_feature: torch.FloatTensor, feature_weight) -> torch.FloatTensor: # pad_feature = torch.cat((res_feature, res_feature.repeat(1, 1, x.shape[2] - 1, 1, 1) * 0.), dim=2) pad_feature = torch.cat((res_feature, x[:, :, 1:]), dim=2) return x * (1. - feature_weight) + pad_feature * feature_weight # return self.layer(torch.cat((x, pad_feature), dim=1)) + x class RMSNorm(nn.Module): r""" RMS Norm as introduced in https://arxiv.org/abs/1910.07467 by Zhang et al. Args: dim (`int`): Number of dimensions to use for `weights`. Only effective when `elementwise_affine` is True. eps (`float`): Small value to use when calculating the reciprocal of the square-root. elementwise_affine (`bool`, defaults to `True`): Boolean flag to denote if affine transformation should be applied. bias (`bool`, defaults to False): If also training the `bias` param. """ def __init__(self, dim, eps: float, elementwise_affine: bool = True, bias: bool = False): super().__init__() self.eps = eps self.elementwise_affine = elementwise_affine if isinstance(dim, numbers.Integral): dim = (dim,) self.dim = torch.Size(dim) self.weight = None self.bias = None if elementwise_affine: self.weight = nn.Parameter(torch.ones(dim)) if bias: self.bias = nn.Parameter(torch.zeros(dim)) def forward(self, hidden_states): # if is_torch_npu_available(): # import torch_npu # # if self.weight is not None: # # convert into half-precision if necessary # if self.weight.dtype in [torch.float16, torch.bfloat16]: # hidden_states = hidden_states.to(self.weight.dtype) # hidden_states = torch_npu.npu_rms_norm(hidden_states, self.weight, epsilon=self.eps)[0] # if self.bias is not None: # hidden_states = hidden_states + self.bias # else: input_dtype = hidden_states.dtype variance = hidden_states.to(torch.float32).pow(2).mean(-1, keepdim=True) hidden_states = hidden_states * torch.rsqrt(variance + self.eps) if self.weight is not None: # convert into half-precision if necessary if self.weight.dtype in [torch.float16, torch.bfloat16]: hidden_states = hidden_states.to(self.weight.dtype) hidden_states = hidden_states * self.weight if self.bias is not None: hidden_states = hidden_states + self.bias else: hidden_states = hidden_states.to(input_dtype) return hidden_states class PixelNorm(nn.Module): def __init__(self, channels=32, dim=1, eps=1e-8): super(PixelNorm, self).__init__() self.dim = dim self.eps = eps def forward(self, x): return x / torch.sqrt(torch.mean(x ** 2, dim=self.dim, keepdim=True) + self.eps) # class PixelNorm(nn.Module): # def __init__(self, channels=32, eps=1e-5): # super(PixelNorm, self).__init__() # self.eps = eps # # def forward(self, x): # return (x - x.mean(dim=1, keepdim=True)) / (x.std(dim=1, keepdim=True) + self.eps) class SpatialNorm(nn.Module): def __init__(self, channels=32, eps=1e-6): super(SpatialNorm, self).__init__() self.eps = eps def forward(self, x): return x / torch.sqrt(torch.mean(x ** 2, dim=(1, 3, 4), keepdim=True) + self.eps) class BatchNorm(nn.Module): def __init__(self, channels=32, eps=1e-5): super(BatchNorm, self).__init__() def forward(self, x): return x class GroupNorm(nn.Module): def __init__(self, channels=64, groups=32, ): super().__init__() self.norm = nn.GroupNorm(groups, channels) def forward(self, x: torch.FloatTensor) -> torch.FloatTensor: b, c, t, h, w = x.shape out = self.norm(x.transpose(1, 2).flatten(0, 1)) return out.reshape((b, t) + out.shape[1:]).transpose(1, 2) class LayerNorm(nn.Module): def __init__(self, channels=64, ): super().__init__() self.norm = nn.LayerNorm(channels) def forward(self, x: torch.FloatTensor) -> torch.FloatTensor: b, c, t, h, w = x.shape out = self.norm(x.flatten(2).transpose(1, 2)) return out.transpose(1, 2).reshape((b, c, t, h, w)) class DyTNorm(torch.nn.Module): def __init__(self, dim: int, alpha_init: float = 0.5, affine: bool = True): super().__init__() self.alpha = torch.nn.Parameter(torch.ones(1) * alpha_init) self.scale = torch.nn.Parameter(torch.ones(dim)) if affine else None self.shift = torch.nn.Parameter(torch.zeros(dim)) if affine else None def forward(self, x: torch.Tensor) -> torch.Tensor: x = (self.alpha * x).clamp(-1., 1.) # .tanh() if self.scale is not None: assert self.scale.shape[-1] == self.shift.shape[-1] == x.shape[ -1], f"Wrong shape: {self.scale.shape}, {self.shift.shape}, {x.shape}" return x * self.scale + self.shift else: return x class CausalConv3dRepeat(nn.Module): def __init__( self, in_channels, out_channels, kernel_size: Union[int, Tuple[int]] = 3, strides: Union[int, Tuple[int]] = 1, dilation: int = 1, groups: int = 1, **kwargs, ): super().__init__() self.in_channels = in_channels self.out_channels = out_channels kernel_size = cast_tuple(kernel_size, 3) self.time_kernel_size = kernel_size[0] dilation = (dilation, 1, 1) height_pad = kernel_size[1] // 2 width_pad = kernel_size[2] // 2 padding = (0, height_pad, width_pad) self.conv = nn.Conv3d( in_channels, out_channels, kernel_size, stride=strides, dilation=dilation, padding=padding, padding_mode="zeros", groups=groups, ) def forward(self, x, causal: bool = True): if causal: first_frame_pad = x[:, :, :1, :, :].repeat( (1, 1, self.time_kernel_size - 1, 1, 1) ) x = torch.cat((first_frame_pad, x), dim=2) else: first_frame_pad = x[:, :, :1, :, :].repeat( (1, 1, (self.time_kernel_size - 1) // 2, 1, 1) ) last_frame_pad = x[:, :, -1:, :, :].repeat( (1, 1, (self.time_kernel_size - 1) // 2, 1, 1) ) x = torch.cat((first_frame_pad, x, last_frame_pad), dim=2) x = self.conv(x) return x @property def weight(self): return self.conv.weight class CausalConv3d(nn.Module): def __init__( self, chan_in, chan_out, kernel_size: Union[int, Tuple[int, int, int]], pad_mode="constant", strides=None, # allow custom stride **kwargs, ): super().__init__() kernel_size = cast_tuple(kernel_size, 3) time_kernel_size, height_kernel_size, width_kernel_size = kernel_size dilation = kwargs.pop("dilation", 1) stride = strides[0] if strides is not None else kwargs.pop("stride", 1) self.pad_mode = pad_mode time_pad = dilation * (time_kernel_size - 1) + (1 - stride) height_pad = height_kernel_size // 2 width_pad = width_kernel_size // 2 self.time_pad = time_pad self.time_causal_padding = (width_pad, width_pad, height_pad, height_pad, time_pad, 0) stride = strides if strides is not None else (stride, 1, 1) dilation = (dilation, 1, 1) self.conv = nn.Conv3d(chan_in, chan_out, kernel_size, stride=stride, dilation=dilation, **kwargs) def forward(self, x): x = F.pad(x, self.time_causal_padding, mode=self.pad_mode) x = self.conv(x) return x class NormalConv3d(nn.Module): def __init__( self, chan_in, chan_out, kernel_size: Union[int, Tuple[int, int, int]], pad_mode="constant", strides=None, # allow custom stride **kwargs, ): super().__init__() kernel_size = cast_tuple(kernel_size, 3) time_kernel_size, height_kernel_size, width_kernel_size = kernel_size dilation = kwargs.pop("dilation", 1) stride = strides[0] if strides is not None else kwargs.pop("stride", 1) self.pad_mode = pad_mode # time_pad = dilation * (time_kernel_size - 1) + (1 - stride) time_pad = time_kernel_size // 2 height_pad = height_kernel_size // 2 width_pad = width_kernel_size // 2 # self.time_pad = time_pad # self.time_causal_padding = (width_pad, width_pad, height_pad, height_pad, time_pad, 0) stride = strides if strides is not None else (stride, 1, 1) dilation = (dilation, 1, 1) self.conv = nn.Conv3d(chan_in, chan_out, kernel_size, stride=stride, padding=(time_pad, height_pad, width_pad), dilation=dilation, **kwargs) def forward(self, x): # x = F.pad(x, self.time_causal_padding, mode=self.pad_mode) x = self.conv(x) return x # Based on SpectralConv1d from the official StyleGAN-T code # https://github.com/autonomousvision/stylegan-t/blob/36ab80ce76237fefe03e65e9b3161c040ae888e3/networks/discriminator.py#L29 class SpectralCausalConv3d(CausalConv3dRepeat): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) torch.nn.utils.parametrizations.spectral_norm(self.conv, name="weight", n_power_iterations=1, eps=1e-12, dim=0) class ResBlock3D(nn.Module): def __init__( self, in_channels, # SCH: added filters, conv_fn, activation_fn=nn.Hardswish, use_conv_shortcut=False, norm_type=PixelNorm, num_groups=32, ): super().__init__() self.in_channels = in_channels self.filters = filters self.activate = activation_fn() self.use_conv_shortcut = use_conv_shortcut # SCH: MAGVIT uses GroupNorm by default self.norm1 = norm_type(in_channels) self.conv1 = conv_fn(in_channels, self.filters, kernel_size=(3, 3, 3), bias=False) self.norm2 = norm_type(self.filters) self.conv2 = conv_fn(self.filters, self.filters, kernel_size=(3, 3, 3), bias=False) if in_channels != filters: if self.use_conv_shortcut: self.conv3 = conv_fn(in_channels, self.filters, kernel_size=(3, 3, 3), bias=False) else: self.conv3 = conv_fn(in_channels, self.filters, kernel_size=(1, 1, 1), bias=False) else: self.conv3 = None def forward(self, residual): x = residual x = self.norm1(x) x = self.activate(x) x = self.conv1(x) x = self.norm2(x) x = self.activate(x) x = self.conv2(x) if self.in_channels != self.filters and self.conv3 is not None: # SCH: ResBlock X->Y residual = self.conv3(residual) return x + residual class ResBlock3DBN(nn.Module): def __init__( self, in_channels, # SCH: added filters, conv_fn, activation_fn=nn.Hardswish, use_conv_shortcut=False, norm_type=PixelNorm, num_groups=32, ): super().__init__() self.in_channels = in_channels self.filters = filters self.activate = activation_fn() self.use_conv_shortcut = use_conv_shortcut # SCH: MAGVIT uses GroupNorm by default self.conv1 = conv_fn(in_channels, self.filters, kernel_size=(3, 3, 3), bias=False) self.norm1 = nn.BatchNorm3d(self.filters) self.conv2 = conv_fn(self.filters, self.filters, kernel_size=(3, 3, 3), bias=False) self.norm2 = nn.BatchNorm3d(self.filters) if in_channels != filters: if self.use_conv_shortcut: self.conv3 = conv_fn(in_channels, self.filters, kernel_size=(3, 3, 3), bias=False) else: self.conv3 = conv_fn(in_channels, self.filters, kernel_size=(1, 1, 1), bias=False) def forward(self, x): residual = x x = self.conv1(x) x = self.norm1(x) x = self.activate(x) x = self.conv2(x) x = self.norm2(x) x = self.activate(x) if self.in_channels != self.filters: # SCH: ResBlock X->Y residual = self.conv3(residual) return x + residual class SpatialBlock(nn.Module): def __init__(self, channels: int, activation_fn=nn.ReLU, channel_mul=1): super().__init__() act_fn = activation_fn() self.conv = nn.Sequential( nn.GroupNorm(32, channels), act_fn, nn.Conv2d(channels, channels * channel_mul, kernel_size=3, stride=1, padding=1, bias=False), nn.GroupNorm(32, channels * channel_mul), act_fn, nn.Conv2d(channels * channel_mul, channels, kernel_size=3, stride=1, padding=1, bias=False), ) def forward(self, x: torch.FloatTensor) -> torch.FloatTensor: return self.conv(x) + x class SpatialBlockBN(nn.Module): def __init__(self, channels: int, activation_fn=nn.ReLU, channel_mul=1): super().__init__() act_fn = activation_fn() self.conv = nn.Sequential( nn.Conv2d(channels, channels * channel_mul, kernel_size=3, stride=1, padding=1, bias=False), nn.BatchNorm2d(channels * channel_mul), act_fn, nn.Conv2d(channels * channel_mul, channels, kernel_size=3, stride=1, padding=1, bias=False), nn.BatchNorm2d(channels), act_fn, ) def forward(self, x: torch.FloatTensor) -> torch.FloatTensor: return self.conv(x) + x def patchify(x, patch_size_hw=4, patch_size_t=1): if patch_size_hw == 1 and patch_size_t == 1: return x if x.dim() == 4: x = rearrange( x, "b c (h q) (w r) -> b (c r q) h w", q=patch_size_hw, r=patch_size_hw ) elif x.dim() == 5: x = rearrange( x, "b c (f p) (h q) (w r) -> b (c p r q) f h w", p=patch_size_t, q=patch_size_hw, r=patch_size_hw, ) else: raise ValueError(f"Invalid input shape: {x.shape}") return x def unpatchify(x, patch_size_hw=4, patch_size_t=1): if patch_size_hw == 1 and patch_size_t == 1: return x if x.dim() == 4: x = rearrange( x, "b (c r q) h w -> b c (h q) (w r)", q=patch_size_hw, r=patch_size_hw ) elif x.dim() == 5: x = rearrange( x, "b (c p r q) f h w -> b c (f p) (h q) (w r)", p=patch_size_t, q=patch_size_hw, r=patch_size_hw, ) return x class Patchify2D(nn.Module): def __init__(self, channels=64, activation_fn=nn.Hardswish, channel_mul=2, block_type=SpatialBlock): super().__init__() self.layers = nn.Sequential( nn.Conv2d(3, 32, kernel_size=3, stride=2, padding=1), block_type(channels=32, activation_fn=activation_fn), nn.Conv2d(32, 64, kernel_size=3, stride=2, padding=1), block_type(channels=64, activation_fn=activation_fn), block_type(channels=64, activation_fn=activation_fn), ) def forward(self, x: torch.FloatTensor) -> torch.FloatTensor: b, c, t, h, w = x.shape out = self.layers(x.transpose(1, 2).flatten(0, 1)) return out.reshape((b, t) + out.shape[1:]).transpose(1, 2) class UnPatchify2D(nn.Module): def __init__(self, channels=64, activation_fn=nn.Hardswish, channel_mul=2, block_type=SpatialBlock): super().__init__() self.layers = nn.Sequential( block_type(channels=64, activation_fn=activation_fn), block_type(channels=64, activation_fn=activation_fn), nn.Conv2d(64, 32 * 4, kernel_size=3, stride=1, padding=1), nn.PixelShuffle(2), block_type(channels=32, activation_fn=activation_fn), nn.Conv2d(32, 16 * 4, kernel_size=3, stride=1, padding=1), nn.PixelShuffle(2), nn.Conv2d(16, 3, kernel_size=3, stride=1, padding=1), ) def forward(self, x: torch.FloatTensor) -> torch.FloatTensor: b, c, t, h, w = x.shape out = self.layers(x.transpose(1, 2).flatten(0, 1)) return out.reshape((b, t) + out.shape[1:]).transpose(1, 2) def apply_rotary_emb(x, freqs): cos, sin = freqs x_real, x_imag = x.unflatten(2, (-1, 2)).unbind(-1) # [B, S, H, D // 2] x_rotated = torch.stack([-x_imag, x_real], dim=-1).flatten(2) out = (x.float() * cos + x_rotated.float() * sin).to(x.dtype) return out @lru_cache def create_causal_block_mask_cached(block_size, B, H, Q_LEN, KV_LEN, device="cuda"): def causal_block_mask(b, h, q_idx, kv_idx): mask = q_idx // block_size >= kv_idx // block_size return mask return create_mask(causal_block_mask, B, None, Q_LEN, KV_LEN, device=device, # _compile=True ) class LTXVideoAttentionProcessor2_0: r""" Processor for implementing scaled dot-product attention (enabled by default if you're using PyTorch 2.0). This is used in the LTX model. It applies a normalization layer and rotary embedding on the query and key vector. """ def __init__(self): if not hasattr(F, "scaled_dot_product_attention"): raise ImportError( "LTXVideoAttentionProcessor2_0 requires PyTorch 2.0, to use it, please upgrade PyTorch to 2.0." ) def __call__( self, attn: Attention, hidden_states: torch.Tensor, encoder_hidden_states: Optional[torch.Tensor] = None, attention_mask: Optional[torch.Tensor] = None, image_rotary_emb: Optional[torch.Tensor] = None, frame_seq_len: Optional[int] = None, ) -> torch.Tensor: batch_size, sequence_length, _ = ( hidden_states.shape if encoder_hidden_states is None else encoder_hidden_states.shape ) if attention_mask is not None: attention_mask = attn.prepare_attention_mask(attention_mask, sequence_length, batch_size) attention_mask = attention_mask.view(batch_size, attn.heads, -1, attention_mask.shape[-1]) if encoder_hidden_states is None: encoder_hidden_states = hidden_states query = attn.to_q(hidden_states) key = attn.to_k(encoder_hidden_states) value = attn.to_v(encoder_hidden_states) query = attn.norm_q(query) key = attn.norm_k(key) if image_rotary_emb is not None: query = apply_rotary_emb(query, image_rotary_emb) key = apply_rotary_emb(key, image_rotary_emb) query = query.unflatten(2, (attn.heads, -1)).transpose(1, 2) key = key.unflatten(2, (attn.heads, -1)).transpose(1, 2) value = value.unflatten(2, (attn.heads, -1)).transpose(1, 2) assert frame_seq_len is not None B, H, q_len, _ = query.shape _, _, kv_len, _ = key.shape mask = create_causal_block_mask_cached( block_size=frame_seq_len, B=B, H=H, Q_LEN=q_len, KV_LEN=kv_len, device=query.device ) hidden_states = F.scaled_dot_product_attention( query, key, value, attn_mask=mask, dropout_p=0.0, ) hidden_states = hidden_states.transpose(1, 2).flatten(2, 3) hidden_states = hidden_states.to(query.dtype) hidden_states = attn.to_out[0](hidden_states) hidden_states = attn.to_out[1](hidden_states) return hidden_states class LTXVideoRotaryPosEmbed(nn.Module): def __init__( self, dim: int, base_num_frames: int = 20, base_height: int = 2048, base_width: int = 2048, patch_size: int = 1, patch_size_t: int = 1, theta: float = 10000.0, ) -> None: super().__init__() self.dim = dim self.base_num_frames = base_num_frames self.base_height = base_height self.base_width = base_width self.patch_size = patch_size self.patch_size_t = patch_size_t self.theta = theta def forward( self, hidden_states: torch.Tensor, num_frames: int, height: int, width: int, rope_interpolation_scale: Optional[Tuple[torch.Tensor, float, float]] = None, ) -> Tuple[torch.Tensor, torch.Tensor]: batch_size = hidden_states.size(0) # Always compute rope in fp32 grid_h = torch.arange(height, dtype=torch.float32, device=hidden_states.device) grid_w = torch.arange(width, dtype=torch.float32, device=hidden_states.device) grid_f = torch.arange(num_frames, dtype=torch.float32, device=hidden_states.device) grid = torch.meshgrid(grid_f, grid_h, grid_w, indexing="ij") grid = torch.stack(grid, dim=0) grid = grid.unsqueeze(0).repeat(batch_size, 1, 1, 1, 1) if rope_interpolation_scale is not None: grid[:, 0:1] = grid[:, 0:1] * rope_interpolation_scale[0] * self.patch_size_t / self.base_num_frames grid[:, 1:2] = grid[:, 1:2] * rope_interpolation_scale[1] * self.patch_size / self.base_height grid[:, 2:3] = grid[:, 2:3] * rope_interpolation_scale[2] * self.patch_size / self.base_width grid = grid.flatten(2, 4).transpose(1, 2) start = 1.0 end = self.theta freqs = self.theta ** torch.linspace( math.log(start, self.theta), math.log(end, self.theta), self.dim // 6, device=hidden_states.device, dtype=torch.float32, ) freqs = freqs * math.pi / 2.0 freqs = freqs * (grid.unsqueeze(-1) * 2 - 1) freqs = freqs.transpose(-1, -2).flatten(2) cos_freqs = freqs.cos().repeat_interleave(2, dim=-1) sin_freqs = freqs.sin().repeat_interleave(2, dim=-1) if self.dim % 6 != 0: cos_padding = torch.ones_like(cos_freqs[:, :, : self.dim % 6]) sin_padding = torch.zeros_like(cos_freqs[:, :, : self.dim % 6]) cos_freqs = torch.cat([cos_padding, cos_freqs], dim=-1) sin_freqs = torch.cat([sin_padding, sin_freqs], dim=-1) return cos_freqs, sin_freqs @maybe_allow_in_graph class LTXVideoTransformerBlock(nn.Module): r""" Transformer block used in [LTX](https://huggingface.co/Lightricks/LTX-Video). Args: dim (`int`): The number of channels in the input and output. num_attention_heads (`int`): The number of heads to use for multi-head attention. attention_head_dim (`int`): The number of channels in each head. qk_norm (`str`, defaults to `"rms_norm"`): The normalization layer to use. activation_fn (`str`, defaults to `"gelu-approximate"`): Activation function to use in feed-forward. eps (`float`, defaults to `1e-6`): Epsilon value for normalization layers. """ def __init__( self, dim: int, num_attention_heads: int, attention_head_dim: int, cross_attention_dim=None, qk_norm: str = "rms_norm_across_heads", activation_fn: str = "gelu-approximate", attention_bias: bool = True, attention_out_bias: bool = True, eps: float = 1e-6, elementwise_affine: bool = False, ): super().__init__() self.norm1 = nn.LayerNorm(dim, eps=eps, elementwise_affine=elementwise_affine) # self.norm1 = RMSNorm(dim, eps=eps, elementwise_affine=elementwise_affine) self.attn1 = Attention( query_dim=dim, heads=num_attention_heads, kv_heads=num_attention_heads, dim_head=attention_head_dim, bias=attention_bias, cross_attention_dim=None, out_bias=attention_out_bias, qk_norm=qk_norm, processor=LTXVideoAttentionProcessor2_0(), ) self.norm2 = nn.LayerNorm(dim, eps=eps, elementwise_affine=elementwise_affine) # self.norm2 = RMSNorm(dim, eps=eps, elementwise_affine=elementwise_affine) self.attn2 = Attention( query_dim=dim, cross_attention_dim=cross_attention_dim, heads=num_attention_heads, kv_heads=num_attention_heads, dim_head=attention_head_dim, bias=attention_bias, out_bias=attention_out_bias, qk_norm=qk_norm, processor=LTXVideoAttentionProcessor2_0(), ) self.ff = FeedForward(dim, activation_fn=activation_fn) self.scale_shift_table = nn.Parameter(torch.randn(6, dim) / dim ** 0.5) def forward( self, hidden_states: torch.Tensor, encoder_hidden_states: Optional[torch.Tensor] = None, temb: Optional[torch.Tensor] = None, image_rotary_emb: Optional[Tuple[torch.Tensor, torch.Tensor]] = None, encoder_attention_mask: Optional[torch.Tensor] = None, frame_seq_len=None, ) -> torch.Tensor: batch_size = hidden_states.size(0) norm_hidden_states = self.norm1(hidden_states) num_ada_params = self.scale_shift_table.shape[0] ada_values = self.scale_shift_table[None, None] # + temb.reshape(batch_size, temb.size(1), num_ada_params, -1) shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = ada_values.unbind(dim=2) norm_hidden_states = norm_hidden_states * (1 + scale_msa) + shift_msa attn_hidden_states = self.attn1( hidden_states=norm_hidden_states, encoder_hidden_states=None, image_rotary_emb=image_rotary_emb, frame_seq_len=frame_seq_len, ) hidden_states = hidden_states + attn_hidden_states * gate_msa attn_hidden_states = self.attn2( hidden_states, encoder_hidden_states=None, # encoder_hidden_states, image_rotary_emb=image_rotary_emb, # None, frame_seq_len=frame_seq_len, # attention_mask=encoder_attention_mask, ) hidden_states = hidden_states + attn_hidden_states norm_hidden_states = self.norm2(hidden_states) * (1 + scale_mlp) + shift_mlp ff_output = self.ff(norm_hidden_states) hidden_states = hidden_states + ff_output * gate_mlp return hidden_states class LinearAttention(torch.nn.Module): def __init__(self, query_dim, heads=16, dim_head=64, window_size=1, ): super().__init__() self.heads = heads self.dim_head = dim_head self.window_size = window_size self.scale = dim_head ** -0.5 self.to_q = torch.nn.Sequential( torch.nn.Conv3d(query_dim, heads * dim_head, kernel_size=1, stride=1, padding=0), torch.nn.BatchNorm3d(heads * dim_head), ) self.to_k = torch.nn.Sequential( torch.nn.Conv3d(query_dim, query_dim, kernel_size=3, stride=1, padding=1, groups=query_dim), torch.nn.BatchNorm3d(query_dim), torch.nn.Conv3d(query_dim, heads * dim_head * window_size, kernel_size=1, stride=1, padding=0), torch.nn.BatchNorm3d(heads * dim_head * window_size), ) self.to_v = torch.nn.Sequential( torch.nn.Conv3d(query_dim, query_dim, kernel_size=3, stride=1, padding=1, groups=query_dim), torch.nn.Conv3d(query_dim, heads * dim_head * window_size, kernel_size=1, stride=1, padding=0), ) self.to_out = torch.nn.Conv3d(heads * dim_head, query_dim, kernel_size=1, stride=1, padding=0) def forward(self, x): # ####### x: [B, C, T, H, W] ######## b, c, t, h, w = x.shape q = self.to_q(x).flatten(2).reshape(b, self.heads, self.dim_head, -1).unsqueeze(-2).permute(0, 1, 4, 3, 2) k = self.to_k(x).flatten(2).reshape(b, self.heads, self.dim_head, self.window_size, -1).permute(0, 1, 4, 2, 3) v = self.to_v(x).flatten(2).reshape(b, self.heads, self.dim_head, self.window_size, -1).permute(0, 1, 4, 3, 2) # q = self.to_q(x).flatten(2).reshape(b, self.heads, self.dim_head, -1).transpose(-1, -2) # k = self.to_k(x).flatten(2).reshape(b, self.heads, self.dim_head, -1) # v = self.to_v(x).flatten(2).reshape(b, self.heads, self.dim_head, -1).transpose(-1, -2) attn = torch.matmul(q, k) * self.scale attn = attn.softmax(dim=-1) out = torch.matmul(attn, v).squeeze( dim=-2).transpose(-1, -2).flatten(1, 2).reshape(b, self.heads * self.dim_head, t, h, w) # out = torch.matmul(attn, v).transpose(-1, -2).flatten(1, 2).reshape(b, self.heads * self.dim_head, t, h, w) out = self.to_out(out) return out class LocalFeedForward(torch.nn.Module): def __init__(self, dim, activation_fn=None, expansion=4, ): super().__init__() self.layers = torch.nn.Sequential( torch.nn.Conv2d(dim, dim * expansion, kernel_size=1, stride=1, padding=0), torch.nn.Hardswish(), torch.nn.Conv2d(dim * expansion, dim * expansion, kernel_size=3, stride=1, padding=1, groups=dim * expansion), torch.nn.Hardswish(), torch.nn.Conv2d(dim * expansion, dim, kernel_size=1, stride=1, padding=0), ) def forward(self, x): # ####### x: [B, C, T, H, W] ######## b, c, t, h, w = x.shape x = x.transpose(1, 2).flatten(0, 1) out = self.layers(x) return out.reshape(b, t, c, h, w).transpose(1, 2) @maybe_allow_in_graph class LinearTransformerBlock(nn.Module): r""" Transformer block used in [LTX](https://huggingface.co/Lightricks/LTX-Video). Args: dim (`int`): The number of channels in the input and output. num_attention_heads (`int`): The number of heads to use for multi-head attention. attention_head_dim (`int`): The number of channels in each head. qk_norm (`str`, defaults to `"rms_norm"`): The normalization layer to use. activation_fn (`str`, defaults to `"gelu-approximate"`): Activation function to use in feed-forward. eps (`float`, defaults to `1e-6`): Epsilon value for normalization layers. """ def __init__( self, dim: int, num_attention_heads: int, attention_head_dim: int, cross_attention_dim=None, qk_norm: str = "rms_norm_across_heads", activation_fn: str = "gelu-approximate", attention_bias: bool = True, attention_out_bias: bool = True, eps: float = 1e-6, elementwise_affine: bool = False, ): super().__init__() self.norm1 = LayerNorm(dim) self.attn1 = LinearAttention( query_dim=dim, # heads=num_attention_heads, # dim_head=attention_head_dim, # window_size=9, ) # self.norm2 = LayerNorm(dim) # # self.attn2 = LinearAttention( # # query_dim=dim, # # cross_attention_dim=cross_attention_dim, # # heads=num_attention_heads, # # kv_heads=num_attention_heads, # # dim_head=attention_head_dim, # # bias=attention_bias, # # out_bias=attention_out_bias, # # qk_norm=qk_norm, # # processor=LTXVideoAttentionProcessor2_0(), # # window_size=9, # # ) # self.ff = LocalFeedForward(dim) def forward( self, hidden_states: torch.Tensor, encoder_hidden_states: Optional[torch.Tensor] = None, temb: Optional[torch.Tensor] = None, image_rotary_emb: Optional[Tuple[torch.Tensor, torch.Tensor]] = None, encoder_attention_mask: Optional[torch.Tensor] = None, frame_seq_len=None, ) -> torch.Tensor: norm_hidden_states = self.norm1(hidden_states) attn_hidden_states = self.attn1(norm_hidden_states) hidden_states = hidden_states + attn_hidden_states # norm_hidden_states = self.norm2(hidden_states) # ff_output = self.ff(norm_hidden_states) # hidden_states = hidden_states + ff_output return hidden_states class Discriminator(ModelMixin, ConfigMixin): @register_to_config def __init__( self, in_out_channels=48, latent_channels=128, spatial_stride=(2, 2, 2, 2, 2), temporal_stride=(2, 2, 2, 1, 1), encoder_width=(32, 64, 128, 256, 256), decoder_width=(256, 256, 128, 64, 32), encoder_depth=(2, 4, 6, 8, 8), decoder_depth=(6, 6, 4, 4, 2), bottleneck_depth=4, num_groups=32, # for nn.GroupNorm activation_fn=nn.Hardswish, encoder_conv_type=CausalConv3dRepeat, decoder_conv_type=CausalConv3dRepeat, encoder_block_type=ResBlock3D, decoder_block_type=ResBlock3D, use_pixel_shuffle=True, patch_size=4, patch_type="default", use_attention=False, scaling_factor=0.3, symmetric_width=False, bypass_features=False, distill_features=False, use_2d_mix=False, use_ae=False, ): super().__init__() in_out_channels = in_out_channels * 2 latent_channels = 1 width = encoder_width depth = encoder_depth conv_type = encoder_conv_type block_type = encoder_block_type use_out_norm = False use_attention = False out_norm = PixelNorm return_features = False self.num_res_blocks = depth self.num_blocks = len(spatial_stride) self.num_groups = num_groups self.activate = activation_fn() self.use_out_norm = use_out_norm self.conv_fn = conv_type self.return_features = return_features self.block_args = dict( conv_fn=self.conv_fn, activation_fn=activation_fn, use_conv_shortcut=False, num_groups=self.num_groups, ) self.patch_size = patch_size self.patch_type = patch_type if self.patch_size > 1: if self.patch_type == "default": self.patchify = patchify elif self.patch_type == "2DUniform": self.patchify = Patchify2D(block_type=SpatialBlock) else: raise NotImplementedError self.use_attention = use_attention # first layer conv self.conv_in = self.conv_fn( in_out_channels, width[0], kernel_size=(3, 3, 3), ) self.bottleneck = nn.ModuleList([]) for _ in range(bottleneck_depth): self.bottleneck.append(block_type(width[0], width[0], **self.block_args)) # ResBlocks and conv downsample self.block_res_blocks = nn.ModuleList([]) self.conv_blocks = nn.ModuleList([]) prev_filters = width[0] # record for in_channels for idx, s_stride in enumerate(spatial_stride): filters = width[idx] self.conv_blocks.append( self.conv_fn( prev_filters, filters, kernel_size=(3, 3, 3), strides=(temporal_stride[idx], s_stride, s_stride) ) ) block_items = nn.ModuleList([]) if self.use_attention and idx == len(spatial_stride) - 1: self.rope = LTXVideoRotaryPosEmbed( dim=1024, base_num_frames=20, base_height=2048, base_width=2048, patch_size=1, patch_size_t=1, theta=10000.0, ) self.rope_interpolation_scale = ( 2 ** (sum(temporal_stride) - len(temporal_stride)) / 25, 2 ** (sum(spatial_stride) - len(spatial_stride)) * 4, 2 ** (sum(spatial_stride) - len(spatial_stride)) * 4, ) for _ in range(depth[idx]): block_items.append( LTXVideoTransformerBlock( dim=filters, num_attention_heads=16, attention_head_dim=64, cross_attention_dim=None, ) ) else: for _ in range(depth[idx]): block_items.append(block_type(filters, filters, **self.block_args)) self.block_res_blocks.append(block_items) prev_filters = filters # update in_channels # MAGVIT uses Group Normalization if self.use_out_norm: self.norm_out = out_norm(channels=prev_filters) # self.conv_out = self.conv_fn(prev_filters, latent_channels * 2, kernel_size=(1, 1, 1)) self.conv_out = nn.Sequential( SpectralCausalConv3d(prev_filters, prev_filters // 2, kernel_size=(1, 1, 1)), self.activate, SpectralCausalConv3d(prev_filters // 2, prev_filters // 4, kernel_size=(1, 1, 1)), self.activate, SpectralCausalConv3d(prev_filters // 4, prev_filters // 4, kernel_size=(1, 2, 2)), # self.activate, SpectralCausalConv3d(prev_filters // 4, prev_filters // 8, kernel_size=(1, 1, 1)), self.activate, SpectralCausalConv3d(prev_filters // 8, latent_channels * 2, kernel_size=(1, 1, 1)), ) def forward(self, x1, x2): if self.patch_size > 1: x1 = self.patchify(x1) x2 = self.patchify(x2) x = torch.cat((x1, x2), dim=1) x = self.conv_in(x) for block in self.bottleneck: x = block(x) for i in range(self.num_blocks): # if self.return_features and i > 0: # features.append(x) x = self.conv_blocks[i](x) if self.use_attention and i == self.num_blocks - 1: b, c, t, h, w = x.shape x = x.flatten(2).transpose(1, 2) image_rotary_emb = self.rope(x, t, h, w, self.rope_interpolation_scale) for j in range(self.num_res_blocks[i]): x = self.block_res_blocks[i][j](x, image_rotary_emb=image_rotary_emb) x = x.transpose(1, 2).reshape(b, c, t, h, w) else: for j in range(self.num_res_blocks[i]): x = self.block_res_blocks[i][j](x) if self.use_out_norm: x = self.norm_out(x) x = self.activate(x) x = self.conv_out(x) return x.chunk(2, dim=1) class Encoder(nn.Module): """Encoder Blocks.""" def __init__( self, in_out_channels=3, latent_channels=128, spatial_stride=(2, 2, 2, 2, 2), temporal_stride=(2, 2, 2, 1, 1), width=(32, 64, 128, 256, 256), depth=(2, 4, 6, 8, 8), bottleneck_depth=8, num_groups=32, # for nn.GroupNorm activation_fn=nn.Hardswish, conv_type=CausalConv3d, block_type=ResBlock3D, norm_type=PixelNorm, patch_size=1, patch_type="2DUniform", use_attention=False, bypass_features=False, distill_features=False, use_ae=False, attention_type="default", ): super().__init__() self.use_ae = use_ae if not self.use_ae: latent_channels = latent_channels * 2 self.num_res_blocks = depth self.num_blocks = len(spatial_stride) self.num_groups = num_groups self.activate = activation_fn() self.conv_fn = conv_type self.bypass_features = bypass_features self.distill_features = distill_features if norm_type == BatchNorm: block_type = ResBlock3DBN self.block_args = dict( conv_fn=self.conv_fn, activation_fn=activation_fn, use_conv_shortcut=False, norm_type=norm_type, num_groups=self.num_groups, ) self.patch_size = patch_size self.patch_type = patch_type if self.patch_size > 1: if self.patch_type == "default": self.patchify = torch.nn.functional.pixel_unshuffle in_out_channels = 3 * self.patch_size * self.patch_size elif self.patch_type == "2DUniform": self.patchify = Patchify2D(block_type=SpatialBlock, activation_fn=activation_fn) else: self.patchify = nn.Identity() self.use_attention = use_attention self.attention_type = attention_type if attention_type == "default": attention_layer = LTXVideoTransformerBlock elif attention_type == "linear": attention_layer = LinearTransformerBlock else: raise NotImplementedError # first layer conv self.conv_in = self.conv_fn( in_out_channels, width[0], kernel_size=(3, 3, 3), ) self.bottleneck = nn.ModuleList([]) for _ in range(bottleneck_depth): self.bottleneck.append(block_type(width[0], width[0], **self.block_args)) # ResBlocks and conv downsample self.block_res_blocks = nn.ModuleList([]) self.conv_blocks = nn.ModuleList([]) prev_filters = width[0] # record for in_channels for idx, s_stride in enumerate(spatial_stride): filters = width[idx] self.conv_blocks.append( self.conv_fn( prev_filters, filters, kernel_size=(3, 3, 3), strides=(temporal_stride[idx], s_stride, s_stride) ) ) block_items = nn.ModuleList([]) if self.use_attention and idx == len(spatial_stride) - 1: self.rope = LTXVideoRotaryPosEmbed( dim=1024, base_num_frames=20, base_height=2048, base_width=2048, patch_size=1, patch_size_t=1, theta=10000.0, ) self.rope_interpolation_scale = ( 2 ** (sum(temporal_stride) - len(temporal_stride)) / 25, 2 ** (sum(spatial_stride) - len(spatial_stride)) * 4, 2 ** (sum(spatial_stride) - len(spatial_stride)) * 4, ) for _ in range(depth[idx]): block_items.append( attention_layer( dim=filters, num_attention_heads=16, attention_head_dim=64, cross_attention_dim=None, ) ) else: for i in range(depth[idx]): block_items.append(block_type(filters, filters, **self.block_args)) self.rope = None self.block_res_blocks.append(block_items) prev_filters = filters # update in_channels # MAGVIT uses Group Normalization if norm_type == BatchNorm: self.norm_out = None else: self.norm_out = norm_type(prev_filters) self.conv_out = self.conv_fn(prev_filters, latent_channels, kernel_size=(1, 1, 1)) if self.use_ae: self.norm_ae = torch.nn.BatchNorm3d(latent_channels, affine=False) else: self.norm_ae = None def forward(self, x): if self.patch_size > 1: if self.patch_type == "default": x = self.patchify(x.transpose(1, 2), self.patch_size).transpose(1, 2) else: x = self.patchify(x) x = self.conv_in(x) if self.distill_features: features = [x, ] else: features = [] for block in self.bottleneck: x = block(x) if self.bypass_features: features = [x[:, :, 0:1], ] for i, (conv_block, block_res_block) in enumerate(zip(self.conv_blocks, self.block_res_blocks)): x = conv_block(x) if self.distill_features: features.append(x) if self.use_attention and i == self.num_blocks - 1: if self.attention_type == "default" and self.rope is not None: b, c, t, h, w = x.shape x = x.flatten(2).transpose(1, 2) image_rotary_emb = self.rope(x, t, h, w, self.rope_interpolation_scale) for j, res_block in enumerate(block_res_block): x = res_block(x, image_rotary_emb=image_rotary_emb, frame_seq_len=h * w, ) x = x.transpose(1, 2).reshape(b, c, t, h, w) elif self.attention_type == "linear": for j, res_block in enumerate(block_res_block): x = res_block(x) else: raise NotImplementedError else: for j, res_block in enumerate(block_res_block): x = res_block(x) if self.bypass_features: # and not (self.use_attention and i == self.num_blocks - 1) features.append(x[:, :, 0:1]) if self.norm_out is not None: x = self.norm_out(x) x = self.activate(x) x = self.conv_out(x) if self.use_ae: x = self.norm_ae(x) return x, features class Decoder(nn.Module): """Decoder Blocks.""" def __init__( self, in_out_channels=3, latent_channels=128, spatial_stride=(2, 2, 2, 2, 2), temporal_stride=(1, 1, 2, 2, 2), width=(256, 256, 128, 64, 32), depth=(6, 6, 4, 4, 2), bottleneck_depth=8, num_groups=32, # for nn.GroupNorm activation_fn=nn.Hardswish, conv_type=NormalConv3d, block_type=ResBlock3D, use_pixel_shuffle=False, norm_type=PixelNorm, patch_size=1, patch_type="2DUniform", use_attention=False, bypass_features=False, distill_features=False, attention_type="default", ): super().__init__() self.export = False self.image_rotary_emb = None self.num_res_blocks = depth self.num_blocks = len(spatial_stride) self.num_groups = num_groups self.use_pixel_shuffle = use_pixel_shuffle self.activate = activation_fn() self.conv_fn = conv_type self.bypass_features = bypass_features self.distill_features = distill_features if norm_type == BatchNorm: block_type = ResBlock3DBN spatial_block_type = SpatialBlockBN else: spatial_block_type = SpatialBlock self.block_args = dict( conv_fn=self.conv_fn, activation_fn=activation_fn, use_conv_shortcut=False, norm_type=norm_type, num_groups=self.num_groups, ) self.patch_size = patch_size self.patch_type = patch_type if self.patch_size > 1: if self.patch_type == "default": self.unpatchify = torch.nn.functional.pixel_shuffle in_out_channels = 3 * self.patch_size * self.patch_size elif self.patch_type == "2DUniform": self.unpatchify = UnPatchify2D(block_type=spatial_block_type, activation_fn=activation_fn) else: self.unpatchify = nn.Identity() self.use_attention = use_attention self.attention_type = attention_type if attention_type == "default": attention_layer = LTXVideoTransformerBlock elif attention_type == "linear": attention_layer = LinearTransformerBlock else: raise NotImplementedError # last conv self.conv1 = self.conv_fn(latent_channels, width[0], kernel_size=(3, 3, 3), bias=True) self.block_res_blocks = nn.ModuleList([]) self.conv_blocks = nn.ModuleList([]) self.spatial_conv_blocks = nn.ModuleList([]) self.spatial_res_blocks = nn.ModuleList([]) self.strides = [] self.feature_fusion = nn.ModuleList([]) # reverse to keep track of the in_channels, but append also in a reverse direction for idx, s_stride in enumerate(spatial_stride): if self.bypass_features: self.feature_fusion.append(FeatureFusion(width[idx], conv_fn=self.conv_fn), ) else: self.feature_fusion.append(nn.Identity()) filters = width[idx] next_filters = width[idx + 1] if idx < len(width) - 1 else width[idx] block_items = nn.ModuleList([]) if s_stride > 1: num_blocks = depth[idx] // 2 else: num_blocks = depth[idx] if self.use_attention and idx == 0: self.rope = LTXVideoRotaryPosEmbed( dim=1024, base_num_frames=20, base_height=2048, base_width=2048, patch_size=1, patch_size_t=1, theta=10000.0, ) self.rope_interpolation_scale = ( 2 ** (sum(temporal_stride) - len(temporal_stride)) / 25, 2 ** (sum(spatial_stride) - len(spatial_stride)) * 4, 2 ** (sum(spatial_stride) - len(spatial_stride)) * 4, ) for _ in range(num_blocks): block_items.append( attention_layer( dim=filters, num_attention_heads=16, attention_head_dim=64, cross_attention_dim=None, ) ) else: for i in range(num_blocks): block_items.append(block_type(filters, filters, **self.block_args)) self.block_res_blocks.append(block_items) # SCH: append in front self.strides.append((temporal_stride[idx], s_stride)) if self.use_pixel_shuffle: self.conv_blocks.append( self.conv_fn( filters, next_filters * temporal_stride[idx], kernel_size=(3, 3, 3) ), ) else: self.conv_blocks.append( self.conv_fn( filters, next_filters * temporal_stride[idx], kernel_size=(3, 3, 3) ), ) if s_stride > 1: spatial_block_items = nn.ModuleList([]) for i in range(num_blocks): spatial_block_items.append(spatial_block_type(next_filters, activation_fn=activation_fn)) if self.use_pixel_shuffle: self.spatial_conv_blocks.append( nn.Conv2d( next_filters, next_filters * s_stride * s_stride, kernel_size=3, stride=1, padding=1, ), ) else: self.spatial_conv_blocks.append( nn.Conv2d( next_filters, next_filters, kernel_size=3, stride=1, padding=1, ), ) else: spatial_block_items = nn.Identity() self.spatial_conv_blocks.append( nn.Identity(), ) self.spatial_res_blocks.append(spatial_block_items) if self.bypass_features: self.feature_fusion.append(FeatureFusion(next_filters, conv_fn=self.conv_fn), ) else: self.feature_fusion.append(nn.Identity()) # ResBlocks and conv upsample self.bottleneck = nn.ModuleList([]) for _ in range(bottleneck_depth): self.bottleneck.append(block_type(next_filters, next_filters, **self.block_args)) if norm_type == BatchNorm: self.norm_out = None else: self.norm_out = norm_type(next_filters) self.conv_out = self.conv_fn(next_filters, in_out_channels, kernel_size=(3, 3, 3), bias=True) if self.use_pixel_shuffle: self.up = nn.PixelShuffle(2) else: self.up = nn.Upsample(scale_factor=2, mode='bilinear') def forward(self, x, features=None): x = self.conv1(x) if self.bypass_features: assert features is not None if self.training: feature_weight = round(random.random()) / 2. else: feature_weight = 0.5 if self.distill_features: features = [] for i, (feature_fusion, block_res_block, conv_block, spatial_res_block, spatial_conv_block) in enumerate( zip(self.feature_fusion, self.block_res_blocks, self.conv_blocks, self.spatial_res_blocks, self.spatial_conv_blocks)): # i in range(self.num_blocks): if self.bypass_features: # and not (self.use_attention and i == 0) x = feature_fusion(x, features.pop(-1), feature_weight=feature_weight) if self.use_attention and i == 0: if self.attention_type == "default": b, c, t, h, w = x.shape x = x.flatten(2).transpose(1, 2) if self.image_rotary_emb is None or not self.export: self.image_rotary_emb = self.rope(x, t, h, w, self.rope_interpolation_scale) for block in block_res_block: x = block(x, image_rotary_emb=self.image_rotary_emb, frame_seq_len=h * w, ) x = x.transpose(1, 2).reshape(b, c, t, h, w) elif self.attention_type == "linear": for block in block_res_block: x = block(x) else: raise NotImplementedError else: for block in block_res_block: x = block(x) if self.distill_features: features.append(x) t_stride, s_stride = self.strides[i] x = conv_block(x) if t_stride > 1: x = rearrange( x, "B (C ts) T H W -> B C (T ts) H W", ts=t_stride, )[:, :, 1:] if s_stride > 1: b, c, t, h, w = x.shape x = x.transpose(1, 2).flatten(0, 1) for spatial_block in spatial_res_block: x = spatial_block(x) x = spatial_conv_block(x) x = self.up(x) x = x.reshape((b, t) + x.shape[1:]).transpose(1, 2) if self.bypass_features: x = self.feature_fusion[-1](x, features.pop(-1), feature_weight=feature_weight) for block in self.bottleneck: x = block(x) if self.distill_features: features.append(x) if self.norm_out is not None: x = self.norm_out(x) x = self.activate(x) x = self.conv_out(x) if self.patch_size > 1: if self.patch_type == "default": x = self.unpatchify(x.transpose(1, 2), self.patch_size).transpose(1, 2) else: x = self.unpatchify(x) if self.distill_features: return x, features else: return x class H3AE(ModelMixin, ConfigMixin): _supports_gradient_checkpointing = True @register_to_config def __init__( self, in_out_channels=48, latent_channels=128, spatial_stride=(2, 2, 2, 2, 2), temporal_stride=(2, 2, 2, 1, 1), encoder_width=(32, 64, 128, 256, 256), decoder_width=(256, 256, 128, 64, 32), encoder_depth=(2, 4, 6, 8, 8), decoder_depth=(6, 6, 4, 4, 2), bottleneck_depth=4, num_groups=32, # for nn.GroupNorm activation_fn="hardswish", norm_type="pn", encoder_conv_type="CausalConv3dRepeat", decoder_conv_type="CausalConv3dRepeat", encoder_block_type="ResBlock3D", decoder_block_type="ResBlock3D", use_pixel_shuffle=True, patch_size=4, patch_type="2DUniform", use_attention=False, mean=0., scaling_factor=0.1666, latents_mean: List[float] = [], latents_std: List[float] = [], symmetric_width=False, bypass_features=False, distill_features=False, use_ae=False, attention_type="default", ): super().__init__() if activation_fn == "hardswish": activation_fn = nn.Hardswish elif activation_fn == "relu": activation_fn = nn.ReLU else: raise ValueError(f"Unknown activation function: {activation_fn}") if norm_type == "pn": norm = PixelNorm elif norm_type == "gn": norm = GroupNorm elif norm_type == "ln": norm = LayerNorm elif norm_type == "sn": norm = SpatialNorm elif norm_type == "bn": norm = BatchNorm else: raise ValueError(f"Unknown norm type: {norm_type}") encoder_conv_type = eval(encoder_conv_type) encoder_block_type = eval(encoder_block_type) decoder_conv_type = eval(decoder_conv_type) decoder_block_type = eval(decoder_block_type) self.use_ae = use_ae self.bypass_features = bypass_features self.distill_features = distill_features self.scaling_factor = scaling_factor self.mean = mean self.latents_mean = latents_mean self.latents_std = latents_std self.micro_frame_size = 17 self.time_downsample_factor = 2 ** (sum(temporal_stride) - len(temporal_stride)) self.spatial_downscale_factor = 2 ** (sum(spatial_stride) - len(spatial_stride)) * patch_size self.temporal_downscale_factor = self.time_downsample_factor self.micro_frame_latent = 1 + (self.micro_frame_size - 1) // self.time_downsample_factor # self.time_padding = ( # 0 # if (self.micro_frame_size % self.time_downsample_factor == 0) # else self.time_downsample_factor - self.micro_frame_size % self.time_downsample_factor # ) self.time_padding = self.time_downsample_factor - 1 self.use_z_tiling = False self.use_hw_tiling = False self.z_sample_size = 1 self.gradient_checkpointing = True # NOTE: following MAGVIT, conv in bias=False in encoder first conv self.encoder = Encoder( in_out_channels=in_out_channels, latent_channels=latent_channels, spatial_stride=spatial_stride, temporal_stride=temporal_stride, width=encoder_width, depth=encoder_depth, bottleneck_depth=bottleneck_depth, num_groups=num_groups, # for nn.GroupNorm activation_fn=activation_fn, conv_type=encoder_conv_type, block_type=encoder_block_type, norm_type=norm, patch_size=patch_size, patch_type=patch_type, use_attention=use_attention, bypass_features=self.bypass_features, distill_features=self.distill_features, use_ae=self.use_ae, attention_type=attention_type, ) if symmetric_width: decoder_func = Decoder else: raise NotImplementedError self.decoder = decoder_func( in_out_channels=in_out_channels, latent_channels=latent_channels, spatial_stride=list(reversed(spatial_stride)), temporal_stride=list(reversed(temporal_stride)), width=decoder_width, depth=decoder_depth, bottleneck_depth=bottleneck_depth, num_groups=num_groups, # for nn.GroupNorm activation_fn=activation_fn, conv_type=decoder_conv_type, block_type=decoder_block_type, use_pixel_shuffle=use_pixel_shuffle, norm_type=norm, patch_size=patch_size, patch_type=patch_type, use_attention=use_attention, bypass_features=self.bypass_features, distill_features=self.distill_features, attention_type=attention_type, ) def set_tiling_params(self, sample_size: int = 512, overlap_factor: float = 0.25): self.tile_sample_min_size = sample_size num_blocks = len(self.encoder.down_blocks) self.tile_latent_min_size = int(sample_size / (2 ** (num_blocks - 1))) self.tile_overlap_factor = overlap_factor def enable_z_tiling(self, z_sample_size: int = 8): r""" Enable tiling during VAE decoding. When this option is enabled, the VAE will split the input tensor in tiles to compute decoding in several steps. This is useful to save some memory and allow larger batch sizes. """ self.use_z_tiling = z_sample_size > 1 self.z_sample_size = z_sample_size assert ( z_sample_size % 8 == 0 or z_sample_size == 1 ), f"z_sample_size must be a multiple of 8 or 1. Got {z_sample_size}." def disable_z_tiling(self): r""" Disable tiling during VAE decoding. If `use_tiling` was previously invoked, this method will go back to computing decoding in one step. """ self.use_z_tiling = False def enable_hw_tiling(self): r""" Enable tiling during VAE decoding along the height and width dimension. """ self.use_hw_tiling = True def disable_hw_tiling(self): r""" Disable tiling during VAE decoding along the height and width dimension. """ self.use_hw_tiling = False def _hw_tiled_encode(self, x: torch.FloatTensor, return_dict: bool = True): overlap_size = int(self.tile_sample_min_size * (1 - self.tile_overlap_factor)) blend_extent = int(self.tile_latent_min_size * self.tile_overlap_factor) row_limit = self.tile_latent_min_size - blend_extent # Split the image into 512x512 tiles and encode them separately. rows = [] for i in range(0, x.shape[3], overlap_size): row = [] for j in range(0, x.shape[4], overlap_size): tile = x[ :, :, :, i: i + self.tile_sample_min_size, j: j + self.tile_sample_min_size, ] tile = self.encoder(tile) tile = self.quant_conv(tile) row.append(tile) rows.append(row) result_rows = [] for i, row in enumerate(rows): result_row = [] for j, tile in enumerate(row): # blend the above tile and the left tile # to the current tile and add the current tile to the result row if i > 0: tile = self.blend_v(rows[i - 1][j], tile, blend_extent) if j > 0: tile = self.blend_h(row[j - 1], tile, blend_extent) result_row.append(tile[:, :, :, :row_limit, :row_limit]) result_rows.append(torch.cat(result_row, dim=4)) moments = torch.cat(result_rows, dim=3) return moments def blend_z( self, a: torch.Tensor, b: torch.Tensor, blend_extent: int ) -> torch.Tensor: blend_extent = min(a.shape[2], b.shape[2], blend_extent) for z in range(blend_extent): b[:, :, z, :, :] = a[:, :, -blend_extent + z, :, :] * ( 1 - z / blend_extent ) + b[:, :, z, :, :] * (z / blend_extent) return b def blend_v( self, a: torch.Tensor, b: torch.Tensor, blend_extent: int ) -> torch.Tensor: blend_extent = min(a.shape[3], b.shape[3], blend_extent) for y in range(blend_extent): b[:, :, :, y, :] = a[:, :, :, -blend_extent + y, :] * ( 1 - y / blend_extent ) + b[:, :, :, y, :] * (y / blend_extent) return b def blend_h( self, a: torch.Tensor, b: torch.Tensor, blend_extent: int ) -> torch.Tensor: blend_extent = min(a.shape[4], b.shape[4], blend_extent) for x in range(blend_extent): b[:, :, :, :, x] = a[:, :, :, :, -blend_extent + x] * ( 1 - x / blend_extent ) + b[:, :, :, :, x] * (x / blend_extent) return b def _hw_tiled_decode(self, z: torch.FloatTensor, target_shape): overlap_size = int(self.tile_latent_min_size * (1 - self.tile_overlap_factor)) blend_extent = int(self.tile_sample_min_size * self.tile_overlap_factor) row_limit = self.tile_sample_min_size - blend_extent tile_target_shape = ( *target_shape[:3], self.tile_sample_min_size, self.tile_sample_min_size, ) # Split z into overlapping 64x64 tiles and decode them separately. # The tiles have an overlap to avoid seams between tiles. rows = [] for i in range(0, z.shape[3], overlap_size): row = [] for j in range(0, z.shape[4], overlap_size): tile = z[ :, :, :, i: i + self.tile_latent_min_size, j: j + self.tile_latent_min_size, ] tile = self.post_quant_conv(tile) decoded = self.decoder(tile, target_shape=tile_target_shape) row.append(decoded) rows.append(row) result_rows = [] for i, row in enumerate(rows): result_row = [] for j, tile in enumerate(row): # blend the above tile and the left tile # to the current tile and add the current tile to the result row if i > 0: tile = self.blend_v(rows[i - 1][j], tile, blend_extent) if j > 0: tile = self.blend_h(row[j - 1], tile, blend_extent) result_row.append(tile[:, :, :, :row_limit, :row_limit]) result_rows.append(torch.cat(result_row, dim=4)) dec = torch.cat(result_rows, dim=3) return dec def encode( self, z: torch.FloatTensor, return_dict: bool = True ) -> Union[DecoderOutput, torch.FloatTensor]: if self.use_z_tiling and z.shape[2] > self.z_sample_size > 1: num_splits = z.shape[2] // self.z_sample_size sizes = [self.z_sample_size] * num_splits sizes = ( sizes + [z.shape[2] - sum(sizes)] if z.shape[2] - sum(sizes) > 0 else sizes ) tiles = z.split(sizes, dim=2) moments_tiles = [ ( self._hw_tiled_encode(z_tile, return_dict) if self.use_hw_tiling else self._encode(z_tile) ) for z_tile in tiles ] moments = torch.cat(moments_tiles, dim=2) else: moments = ( self._hw_tiled_encode(z, return_dict) if self.use_hw_tiling else self._encode(z) ) moments, features = moments if self.use_ae: return AutoencoderKLOutput(latent_dist=moments, features=features) posterior = DiagonalGaussianDistribution(moments) if not return_dict: return (posterior,) return AutoencoderKLOutput(latent_dist=posterior, features=features) def _encode(self, x: torch.FloatTensor) -> AutoencoderKLOutput: if torch.is_grad_enabled() and self.gradient_checkpointing: # moments = self._gradient_checkpointing_func(self.encoder, x) moments = self.encoder(x) # def create_custom_forward(module, return_dict=None): # def custom_forward(*inputs): # if return_dict is not None: # return module(*inputs, return_dict=return_dict) # else: # return module(*inputs) # # return custom_forward # # moments = torch.utils.checkpoint.checkpoint( # create_custom_forward(self.encoder), # x, # ) else: moments = self.encoder(x) # moments = self.quant_conv(h) return moments def _decode( self, z: torch.FloatTensor, target_shape=None, timesteps: Optional[torch.Tensor] = None, features: Optional[torch.Tensor] = None, ) -> Union[DecoderOutput, torch.FloatTensor]: # z = self.post_quant_conv(z) # if "timesteps" in self.decoder_params: # dec = self.decoder(z, target_shape=target_shape, timesteps=timesteps) # else: dec = self.decoder(z, features=features) # , target_shape=target_shape return dec def decode( self, z: torch.FloatTensor, return_dict: bool = True, target_shape=None, timesteps: Optional[torch.Tensor] = None, features: Optional[torch.Tensor] = None, ) -> Union[DecoderOutput, torch.FloatTensor]: assert target_shape is None, "target_shape not supported yet" if self.use_z_tiling and z.shape[2] > self.z_sample_size > 1: reduction_factor = int( self.encoder.patch_size_t * 2 ** ( len(self.encoder.down_blocks) - 1 - math.sqrt(self.encoder.patch_size) ) ) split_size = self.z_sample_size // reduction_factor num_splits = z.shape[2] // split_size # copy target shape, and divide frame dimension (=2) by the context size target_shape_split = list(target_shape) target_shape_split[2] = target_shape[2] // num_splits decoded_tiles = [ ( self._hw_tiled_decode(z_tile, target_shape_split) if self.use_hw_tiling else self._decode(z_tile, target_shape=target_shape_split, features=features) ) for z_tile in torch.tensor_split(z, num_splits, dim=2) ] decoded = torch.cat(decoded_tiles, dim=2) else: decoded = ( self._hw_tiled_decode(z, target_shape) if self.use_hw_tiling else self._decode(z, target_shape=target_shape, timesteps=timesteps, features=features) ) if self.distill_features: decoded, features = decoded else: features = None if not return_dict: return (decoded,) return DecoderOutput(sample=decoded, features=features) def forward( self, sample: torch.FloatTensor, sample_posterior: bool = True, return_dict: bool = True, generator: Optional[torch.Generator] = None, return_training: bool = True, return_posterior: bool = False, drop_type: Optional[str] = "", ) -> Union[DecoderOutput, torch.FloatTensor]: r""" Args: sample (`torch.FloatTensor`): Input sample. sample_posterior (`bool`, *optional*, defaults to `False`): Whether to sample from the posterior. return_dict (`bool`, *optional*, defaults to `True`): Whether to return a [`DecoderOutput`] instead of a plain tuple. generator (`torch.Generator`, *optional*): Generator used to sample from the posterior. """ x = sample output = self.encode(x) if self.use_ae: z = output.latent_dist posterior = None features = output.features else: posterior = output.latent_dist features = output.features if return_posterior: return posterior if sample_posterior: z = posterior.sample(generator=generator) else: z = posterior.mode() if drop_type and self.training: if drop_type == "dropout3d": z = torch.nn.functional.dropout3d(z, p=0.25, training=self.training, ) elif drop_type == "ours": z = our_drop(z) else: pass recon = self.decode(z, features=features) dec = recon.sample out_features = recon.features if return_training: return (dec, posterior, z, features, out_features) # return (dec, posterior, z) if not return_dict: return (dec,) return DecoderOutput(sample=dec, features=out_features) if __name__ == "__main__": pass