import typing as tp import torch from einops import rearrange from torch import nn from torch.nn import functional as F from x_transformers import ContinuousTransformerWrapper, Encoder from functools import reduce, partial from packaging import version from einops import rearrange, repeat from einops.layers.torch import Rearrange import torch import torch.nn.functional as F from torch import nn, einsum from torch.cuda.amp import autocast from typing import Callable, Literal try: from flash_attn import flash_attn_func, flash_attn_kvpacked_func except ImportError as e: print(e) print('flash_attn not installed, disabling Flash Attention') flash_attn_kvpacked_func = None flash_attn_func = None try: import natten except ImportError: natten = None from functools import reduce import math import numpy as np import torch from torch import nn from torch.nn import functional as F from torch.backends.cuda import sdp_kernel from packaging import version from dac.nn.layers import Snake1d class ResidualBlock(nn.Module): def __init__(self, main, skip=None): super().__init__() self.main = nn.Sequential(*main) self.skip = skip if skip else nn.Identity() def forward(self, input): return self.main(input) + self.skip(input) class ResConvBlock(ResidualBlock): def __init__(self, c_in, c_mid, c_out, is_last=False, kernel_size=5, conv_bias=True, use_snake=False): skip = None if c_in == c_out else nn.Conv1d(c_in, c_out, 1, bias=False) super().__init__([ nn.Conv1d(c_in, c_mid, kernel_size, padding=kernel_size // 2, bias=conv_bias), nn.GroupNorm(1, c_mid), Snake1d(c_mid) if use_snake else nn.GELU(), nn.Conv1d(c_mid, c_out, kernel_size, padding=kernel_size // 2, bias=conv_bias), nn.GroupNorm(1, c_out) if not is_last else nn.Identity(), (Snake1d(c_out) if use_snake else nn.GELU()) if not is_last else nn.Identity(), ], skip) class SelfAttention1d(nn.Module): def __init__(self, c_in, n_head=1, dropout_rate=0.): super().__init__() assert c_in % n_head == 0 self.norm = nn.GroupNorm(1, c_in) self.n_head = n_head self.qkv_proj = nn.Conv1d(c_in, c_in * 3, 1) self.out_proj = nn.Conv1d(c_in, c_in, 1) self.dropout = nn.Dropout(dropout_rate, inplace=True) self.use_flash = torch.cuda.is_available() and version.parse(torch.__version__) >= version.parse('2.0.0') if not self.use_flash: return device_properties = torch.cuda.get_device_properties(torch.device('cuda')) if device_properties.major == 8 and device_properties.minor == 0: # Use flash attention for A100 GPUs self.sdp_kernel_config = (True, False, False) else: # Don't use flash attention for other GPUs self.sdp_kernel_config = (False, True, True) def forward(self, input): n, c, s = input.shape qkv = self.qkv_proj(self.norm(input)) qkv = qkv.view( [n, self.n_head * 3, c // self.n_head, s]).transpose(2, 3) q, k, v = qkv.chunk(3, dim=1) scale = k.shape[3] ** -0.25 if self.use_flash: with sdp_kernel(*self.sdp_kernel_config): y = F.scaled_dot_product_attention(q, k, v, is_causal=False).contiguous().view([n, c, s]) else: att = ((q * scale) @ (k.transpose(2, 3) * scale)).softmax(3) y = (att @ v).transpose(2, 3).contiguous().view([n, c, s]) return input + self.dropout(self.out_proj(y)) class SkipBlock(nn.Module): def __init__(self, *main): super().__init__() self.main = nn.Sequential(*main) def forward(self, input): return torch.cat([self.main(input), input], dim=1) class FourierFeatures(nn.Module): def __init__(self, in_features, out_features, std=1.): super().__init__() assert out_features % 2 == 0 self.weight = nn.Parameter(torch.randn( [out_features // 2, in_features]) * std) def forward(self, input): f = 2 * math.pi * input @ self.weight.T return torch.cat([f.cos(), f.sin()], dim=-1) def expand_to_planes(input, shape): return input[..., None].repeat([1, 1, shape[2]]) _kernels = { 'linear': [1 / 8, 3 / 8, 3 / 8, 1 / 8], 'cubic': [-0.01171875, -0.03515625, 0.11328125, 0.43359375, 0.43359375, 0.11328125, -0.03515625, -0.01171875], 'lanczos3': [0.003689131001010537, 0.015056144446134567, -0.03399861603975296, -0.066637322306633, 0.13550527393817902, 0.44638532400131226, 0.44638532400131226, 0.13550527393817902, -0.066637322306633, -0.03399861603975296, 0.015056144446134567, 0.003689131001010537] } class Downsample1d(nn.Module): def __init__(self, kernel='linear', pad_mode='reflect', channels_last=False): super().__init__() self.pad_mode = pad_mode kernel_1d = torch.tensor(_kernels[kernel]) self.pad = kernel_1d.shape[0] // 2 - 1 self.register_buffer('kernel', kernel_1d) self.channels_last = channels_last def forward(self, x): if self.channels_last: x = x.permute(0, 2, 1) x = F.pad(x, (self.pad,) * 2, self.pad_mode) weight = x.new_zeros([x.shape[1], x.shape[1], self.kernel.shape[0]]) indices = torch.arange(x.shape[1], device=x.device) weight[indices, indices] = self.kernel.to(weight) x = F.conv1d(x, weight, stride=2) if self.channels_last: x = x.permute(0, 2, 1) return x class Upsample1d(nn.Module): def __init__(self, kernel='linear', pad_mode='reflect', channels_last=False): super().__init__() self.pad_mode = pad_mode kernel_1d = torch.tensor(_kernels[kernel]) * 2 self.pad = kernel_1d.shape[0] // 2 - 1 self.register_buffer('kernel', kernel_1d) self.channels_last = channels_last def forward(self, x): if self.channels_last: x = x.permute(0, 2, 1) x = F.pad(x, ((self.pad + 1) // 2,) * 2, self.pad_mode) weight = x.new_zeros([x.shape[1], x.shape[1], self.kernel.shape[0]]) indices = torch.arange(x.shape[1], device=x.device) weight[indices, indices] = self.kernel.to(weight) x = F.conv_transpose1d(x, weight, stride=2, padding=self.pad * 2 + 1) if self.channels_last: x = x.permute(0, 2, 1) return x def Downsample1d_2( in_channels: int, out_channels: int, factor: int, kernel_multiplier: int = 2 ) -> nn.Module: assert kernel_multiplier % 2 == 0, "Kernel multiplier must be even" return nn.Conv1d( in_channels=in_channels, out_channels=out_channels, kernel_size=factor * kernel_multiplier + 1, stride=factor, padding=factor * (kernel_multiplier // 2), ) def Upsample1d_2( in_channels: int, out_channels: int, factor: int, use_nearest: bool = False ) -> nn.Module: if factor == 1: return nn.Conv1d( in_channels=in_channels, out_channels=out_channels, kernel_size=3, padding=1 ) if use_nearest: return nn.Sequential( nn.Upsample(scale_factor=factor, mode="nearest"), nn.Conv1d( in_channels=in_channels, out_channels=out_channels, kernel_size=3, padding=1, ), ) else: return nn.ConvTranspose1d( in_channels=in_channels, out_channels=out_channels, kernel_size=factor * 2, stride=factor, padding=factor // 2 + factor % 2, output_padding=factor % 2, ) def zero_init(layer): nn.init.zeros_(layer.weight) if layer.bias is not None: nn.init.zeros_(layer.bias) return layer def rms_norm(x, scale, eps): dtype = reduce(torch.promote_types, (x.dtype, scale.dtype, torch.float32)) mean_sq = torch.mean(x.to(dtype) ** 2, dim=-1, keepdim=True) scale = scale.to(dtype) * torch.rsqrt(mean_sq + eps) return x * scale.to(x.dtype) # rms_norm = torch.compile(rms_norm) class AdaRMSNorm(nn.Module): def __init__(self, features, cond_features, eps=1e-6): super().__init__() self.eps = eps self.linear = zero_init(nn.Linear(cond_features, features, bias=False)) def extra_repr(self): return f"eps={self.eps}," def forward(self, x, cond): return rms_norm(x, self.linear(cond)[:, None, :] + 1, self.eps) def normalize(x, eps=1e-4): dim = list(range(1, x.ndim)) n = torch.linalg.vector_norm(x, dim=dim, keepdim=True) alpha = np.sqrt(n.numel() / x.numel()) return x / torch.add(eps, n, alpha=alpha) class ForcedWNConv1d(nn.Module): def __init__(self, in_channels, out_channels, kernel_size=1): super().__init__() self.weight = nn.Parameter(torch.randn([out_channels, in_channels, kernel_size])) def forward(self, x): if self.training: with torch.no_grad(): self.weight.copy_(normalize(self.weight)) fan_in = self.weight[0].numel() w = normalize(self.weight) / math.sqrt(fan_in) return F.conv1d(x, w, padding='same') # Kernels use_compile = True def compile(function, *args, **kwargs): if not use_compile: return function try: return torch.compile(function, *args, **kwargs) except RuntimeError: return function @compile def linear_geglu(x, weight, bias=None): x = x @ weight.mT if bias is not None: x = x + bias x, gate = x.chunk(2, dim=-1) return x * F.gelu(gate) @compile def rms_norm(x, scale, eps): dtype = reduce(torch.promote_types, (x.dtype, scale.dtype, torch.float32)) mean_sq = torch.mean(x.to(dtype) ** 2, dim=-1, keepdim=True) scale = scale.to(dtype) * torch.rsqrt(mean_sq + eps) return x * scale.to(x.dtype) # Layers class LinearGEGLU(nn.Linear): def __init__(self, in_features, out_features, bias=True): super().__init__(in_features, out_features * 2, bias=bias) self.out_features = out_features def forward(self, x): return linear_geglu(x, self.weight, self.bias) class RMSNorm(nn.Module): def __init__(self, shape, fix_scale=False, eps=1e-6): super().__init__() self.eps = eps if fix_scale: self.register_buffer("scale", torch.ones(shape)) else: self.scale = nn.Parameter(torch.ones(shape)) def extra_repr(self): return f"shape={tuple(self.scale.shape)}, eps={self.eps}" def forward(self, x): return rms_norm(x, self.scale, self.eps) def snake_beta(x, alpha, beta): return x + (1.0 / (beta + 0.000000001)) * pow(torch.sin(x * alpha), 2) # try: # snake_beta = torch.compile(snake_beta) # except RuntimeError: # pass # Adapted from https://github.com/NVIDIA/BigVGAN/blob/main/activations.py under MIT license # License available in LICENSES/LICENSE_NVIDIA.txt class SnakeBeta(nn.Module): def __init__(self, in_features, alpha=1.0, alpha_trainable=True, alpha_logscale=True): super(SnakeBeta, self).__init__() self.in_features = in_features # initialize alpha self.alpha_logscale = alpha_logscale if self.alpha_logscale: # log scale alphas initialized to zeros self.alpha = nn.Parameter(torch.zeros(in_features) * alpha) self.beta = nn.Parameter(torch.zeros(in_features) * alpha) else: # linear scale alphas initialized to ones self.alpha = nn.Parameter(torch.ones(in_features) * alpha) self.beta = nn.Parameter(torch.ones(in_features) * alpha) self.alpha.requires_grad = alpha_trainable self.beta.requires_grad = alpha_trainable self.no_div_by_zero = 0.000000001 def forward(self, x): alpha = self.alpha.unsqueeze(0).unsqueeze(-1) # line up with x to [B, C, T] beta = self.beta.unsqueeze(0).unsqueeze(-1) if self.alpha_logscale: alpha = torch.exp(alpha) beta = torch.exp(beta) x = snake_beta(x, alpha, beta) return x def checkpoint(function, *args, **kwargs): kwargs.setdefault("use_reentrant", False) return torch.utils.checkpoint.checkpoint(function, *args, **kwargs) # Copied and modified from https://github.com/lucidrains/x-transformers/blob/main/x_transformers/attend.py under MIT License # License can be found in LICENSES/LICENSE_XTRANSFORMERS.txt def create_causal_mask(i, j, device): return torch.ones((i, j), device=device, dtype=torch.bool).triu(j - i + 1) def or_reduce(masks): head, *body = masks for rest in body: head = head | rest return head # positional embeddings class AbsolutePositionalEmbedding(nn.Module): def __init__(self, dim, max_seq_len): super().__init__() self.scale = dim ** -0.5 self.max_seq_len = max_seq_len self.emb = nn.Embedding(max_seq_len, dim) def forward(self, x, pos=None, seq_start_pos=None): seq_len, device = x.shape[1], x.device assert seq_len <= self.max_seq_len, f'you are passing in a sequence length of {seq_len} but your absolute positional embedding has a max sequence length of {self.max_seq_len}' if pos is None: pos = torch.arange(seq_len, device=device) if seq_start_pos is not None: pos = (pos - seq_start_pos[..., None]).clamp(min=0) pos_emb = self.emb(pos) pos_emb = pos_emb * self.scale return pos_emb class ScaledSinusoidalEmbedding(nn.Module): def __init__(self, dim, theta=10000): super().__init__() assert (dim % 2) == 0, 'dimension must be divisible by 2' self.scale = nn.Parameter(torch.ones(1) * dim ** -0.5) half_dim = dim // 2 freq_seq = torch.arange(half_dim).float() / half_dim inv_freq = theta ** -freq_seq self.register_buffer('inv_freq', inv_freq, persistent=False) def forward(self, x, pos=None, seq_start_pos=None): seq_len, device = x.shape[1], x.device if pos is None: pos = torch.arange(seq_len, device=device) if seq_start_pos is not None: pos = pos - seq_start_pos[..., None] emb = einsum('i, j -> i j', pos, self.inv_freq) emb = torch.cat((emb.sin(), emb.cos()), dim=-1) return emb * self.scale class RotaryEmbedding(nn.Module): def __init__( self, dim, use_xpos=False, scale_base=512, interpolation_factor=1., base=10000, base_rescale_factor=1. ): super().__init__() # proposed by reddit user bloc97, to rescale rotary embeddings to longer sequence length without fine-tuning # has some connection to NTK literature # https://www.reddit.com/r/LocalLLaMA/comments/14lz7j5/ntkaware_scaled_rope_allows_llama_models_to_have/ base *= base_rescale_factor ** (dim / (dim - 2)) inv_freq = 1. / (base ** (torch.arange(0, dim, 2).float() / dim)) self.register_buffer('inv_freq', inv_freq) assert interpolation_factor >= 1. self.interpolation_factor = interpolation_factor if not use_xpos: self.register_buffer('scale', None) return scale = (torch.arange(0, dim, 2) + 0.4 * dim) / (1.4 * dim) self.scale_base = scale_base self.register_buffer('scale', scale) def forward_from_seq_len(self, seq_len): device = self.inv_freq.device t = torch.arange(seq_len, device=device) return self.forward(t) @autocast(enabled=False) def forward(self, t): device = self.inv_freq.device t = t.to(torch.float32) t = t / self.interpolation_factor freqs = torch.einsum('i , j -> i j', t, self.inv_freq) freqs = torch.cat((freqs, freqs), dim=-1) if self.scale is None: return freqs, 1. power = (torch.arange(seq_len, device=device) - (seq_len // 2)) / self.scale_base scale = self.scale ** rearrange(power, 'n -> n 1') scale = torch.cat((scale, scale), dim=-1) return freqs, scale def rotate_half(x): x = rearrange(x, '... (j d) -> ... j d', j=2) x1, x2 = x.unbind(dim=-2) return torch.cat((-x2, x1), dim=-1) @autocast(enabled=False) def apply_rotary_pos_emb(t, freqs, scale=1): out_dtype = t.dtype # cast to float32 if necessary for numerical stability dtype = reduce(torch.promote_types, (t.dtype, freqs.dtype, torch.float32)) rot_dim, seq_len = freqs.shape[-1], t.shape[-2] freqs, t = freqs.to(dtype), t.to(dtype) freqs = freqs[-seq_len:, :] if t.ndim == 4 and freqs.ndim == 3: freqs = rearrange(freqs, 'b n d -> b 1 n d') # partial rotary embeddings, Wang et al. GPT-J t, t_unrotated = t[..., :rot_dim], t[..., rot_dim:] t = (t * freqs.cos() * scale) + (rotate_half(t) * freqs.sin() * scale) t, t_unrotated = t.to(out_dtype), t_unrotated.to(out_dtype) return torch.cat((t, t_unrotated), dim=-1) # norms class LayerNorm(nn.Module): def __init__(self, dim, bias=False, fix_scale=False): """ bias-less layernorm has been shown to be more stable. most newer models have moved towards rmsnorm, also bias-less """ super().__init__() if fix_scale: self.register_buffer("gamma", torch.ones(dim)) else: self.gamma = nn.Parameter(torch.ones(dim)) if bias: self.beta = nn.Parameter(torch.zeros(dim)) else: self.register_buffer("beta", torch.zeros(dim)) def forward(self, x): return F.layer_norm(x, x.shape[-1:], weight=self.gamma, bias=self.beta) # feedforward class GLU(nn.Module): def __init__( self, dim_in, dim_out, activation: Callable, use_conv=False, conv_kernel_size=3, ): super().__init__() self.act = activation self.proj = nn.Linear(dim_in, dim_out * 2) if not use_conv else nn.Conv1d(dim_in, dim_out * 2, conv_kernel_size, padding=(conv_kernel_size // 2)) self.use_conv = use_conv def forward(self, x): if self.use_conv: x = rearrange(x, 'b n d -> b d n') x = self.proj(x) x = rearrange(x, 'b d n -> b n d') else: x = self.proj(x) x, gate = x.chunk(2, dim=-1) return x * self.act(gate) class FeedForward(nn.Module): def __init__( self, dim, dim_out=None, mult=4, no_bias=False, glu=True, use_conv=False, conv_kernel_size=3, zero_init_output=True, ): super().__init__() inner_dim = int(dim * mult) # Default to SwiGLU activation = nn.SiLU() dim_out = dim if dim_out is None else dim_out if glu: linear_in = GLU(dim, inner_dim, activation) else: linear_in = nn.Sequential( Rearrange('b n d -> b d n') if use_conv else nn.Identity(), nn.Linear(dim, inner_dim, bias=not no_bias) if not use_conv else nn.Conv1d(dim, inner_dim, conv_kernel_size, padding=( conv_kernel_size // 2), bias=not no_bias), Rearrange('b n d -> b d n') if use_conv else nn.Identity(), activation ) linear_out = nn.Linear(inner_dim, dim_out, bias=not no_bias) if not use_conv else nn.Conv1d(inner_dim, dim_out, conv_kernel_size, padding=( conv_kernel_size // 2), bias=not no_bias) # init last linear layer to 0 if zero_init_output: nn.init.zeros_(linear_out.weight) if not no_bias: nn.init.zeros_(linear_out.bias) self.ff = nn.Sequential( linear_in, Rearrange('b d n -> b n d') if use_conv else nn.Identity(), linear_out, Rearrange('b n d -> b d n') if use_conv else nn.Identity(), ) def forward(self, x): return self.ff(x) class Attention(nn.Module): def __init__( self, dim, dim_heads=64, dim_context=None, causal=False, zero_init_output=True, qk_norm: Literal['l2', 'ln', 'none'] = 'none', natten_kernel_size=None ): super().__init__() self.dim = dim self.dim_heads = dim_heads self.causal = causal dim_kv = dim_context if dim_context is not None else dim self.num_heads = dim // dim_heads self.kv_heads = dim_kv // dim_heads if dim_context is not None: self.to_q = nn.Linear(dim, dim, bias=False) self.to_kv = nn.Linear(dim_kv, dim_kv * 2, bias=False) else: self.to_qkv = nn.Linear(dim, dim * 3, bias=False) self.to_out = nn.Linear(dim, dim, bias=False) if zero_init_output: nn.init.zeros_(self.to_out.weight) self.qk_norm = qk_norm if self.qk_norm == "ln": self.q_norm = nn.LayerNorm(dim_heads, elementwise_affine=True, eps=1.0e-6) self.k_norm = nn.LayerNorm(dim_heads, elementwise_affine=True, eps=1.0e-6) # Using 1d neighborhood attention self.natten_kernel_size = natten_kernel_size if natten_kernel_size is not None: return self.use_pt_flash = torch.cuda.is_available() and version.parse(torch.__version__) >= version.parse('2.0.0') self.use_fa_flash = torch.cuda.is_available() and flash_attn_func is not None self.sdp_kwargs = dict( enable_flash=True, enable_math=True, enable_mem_efficient=True ) def flash_attn( self, q, k, v, mask=None, causal=None ): batch, heads, q_len, _, k_len, device = *q.shape, k.shape[-2], q.device kv_heads = k.shape[1] # Recommended for multi-query single-key-value attention by Tri Dao # kv shape torch.Size([1, 512, 64]) -> torch.Size([1, 8, 512, 64]) if heads != kv_heads: # Repeat interleave kv_heads to match q_heads heads_per_kv_head = heads // kv_heads k, v = map(lambda t: t.repeat_interleave(heads_per_kv_head, dim=1), (k, v)) if k.ndim == 3: k = rearrange(k, 'b ... -> b 1 ...').expand_as(q) if v.ndim == 3: v = rearrange(v, 'b ... -> b 1 ...').expand_as(q) causal = self.causal if causal is None else causal if q_len == 1 and causal: causal = False if mask is not None: assert mask.ndim == 4 mask = mask.expand(batch, heads, q_len, k_len) # handle kv cache - this should be bypassable in updated flash attention 2 if k_len > q_len and causal: causal_mask = self.create_causal_mask(q_len, k_len, device=device) if mask is None: mask = ~causal_mask else: mask = mask & ~causal_mask causal = False # manually handle causal mask, if another mask was given row_is_entirely_masked = None if mask is not None and causal: causal_mask = self.create_causal_mask(q_len, k_len, device=device) mask = mask & ~causal_mask # protect against an entire row being masked out row_is_entirely_masked = ~mask.any(dim=-1) mask[..., 0] = mask[..., 0] | row_is_entirely_masked causal = False with torch.backends.cuda.sdp_kernel(**self.sdp_kwargs): out = F.scaled_dot_product_attention( q, k, v, attn_mask=mask, is_causal=causal ) # for a row that is entirely masked out, should zero out the output of that row token if row_is_entirely_masked is not None: out = out.masked_fill(row_is_entirely_masked[..., None], 0.) return out def forward( self, x, context=None, mask=None, context_mask=None, rotary_pos_emb=None, causal=None ): h, kv_h, has_context = self.num_heads, self.kv_heads, context is not None kv_input = context if has_context else x if hasattr(self, 'to_q'): # Use separate linear projections for q and k/v q = self.to_q(x) q = rearrange(q, 'b n (h d) -> b h n d', h=h) k, v = self.to_kv(kv_input).chunk(2, dim=-1) k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h=kv_h), (k, v)) else: # Use fused linear projection q, k, v = self.to_qkv(x).chunk(3, dim=-1) q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h=h), (q, k, v)) # Normalize q and k for cosine sim attention if self.qk_norm == "l2": q = F.normalize(q, dim=-1) k = F.normalize(k, dim=-1) elif self.qk_norm == "ln": q = self.q_norm(q) k = self.k_norm(k) if rotary_pos_emb is not None and not has_context: freqs, _ = rotary_pos_emb q_dtype = q.dtype k_dtype = k.dtype q = q.to(torch.float32) k = k.to(torch.float32) freqs = freqs.to(torch.float32) q = apply_rotary_pos_emb(q, freqs) k = apply_rotary_pos_emb(k, freqs) q = q.to(q_dtype) k = k.to(k_dtype) input_mask = context_mask if input_mask is None and not has_context: input_mask = mask # determine masking masks = [] final_attn_mask = None # The mask that will be applied to the attention matrix, taking all masks into account if input_mask is not None: input_mask = rearrange(input_mask, 'b j -> b 1 1 j') masks.append(~input_mask) # Other masks will be added here later if len(masks) > 0: final_attn_mask = ~or_reduce(masks) n, device = q.shape[-2], q.device causal = self.causal if causal is None else causal if n == 1 and causal: causal = False if self.natten_kernel_size is not None: if natten is None: raise ImportError('natten not installed, please install natten to use neighborhood attention') dtype_in = q.dtype q, k, v = map(lambda t: t.to(torch.float32), (q, k, v)) attn = natten.functional.natten1dqk(q, k, kernel_size=self.natten_kernel_size, dilation=1) if final_attn_mask is not None: attn = attn.masked_fill(final_attn_mask, -torch.finfo(attn.dtype).max) attn = F.softmax(attn, dim=-1, dtype=torch.float32) out = natten.functional.natten1dav(attn, v, kernel_size=self.natten_kernel_size, dilation=1).to(dtype_in) # Prioritize Flash Attention 2 elif self.use_fa_flash: assert final_attn_mask is None, 'masking not yet supported for Flash Attention 2' # Flash Attention 2 requires FP16 inputs fa_dtype_in = q.dtype q, k, v = map(lambda t: rearrange(t, 'b h n d -> b n h d').to(torch.float16), (q, k, v)) out = flash_attn_func(q, k, v, causal=causal) out = rearrange(out.to(fa_dtype_in), 'b n h d -> b h n d') # Fall back to PyTorch implementation elif self.use_pt_flash: out = self.flash_attn(q, k, v, causal=causal, mask=final_attn_mask) else: # Fall back to custom implementation if h != kv_h: # Repeat interleave kv_heads to match q_heads heads_per_kv_head = h // kv_h k, v = map(lambda t: t.repeat_interleave(heads_per_kv_head, dim=1), (k, v)) scale = 1. / (q.shape[-1] ** 0.5) kv_einsum_eq = 'b j d' if k.ndim == 3 else 'b h j d' dots = einsum(f'b h i d, {kv_einsum_eq} -> b h i j', q, k) * scale i, j, dtype = *dots.shape[-2:], dots.dtype mask_value = -torch.finfo(dots.dtype).max if final_attn_mask is not None: dots = dots.masked_fill(~final_attn_mask, mask_value) if causal: causal_mask = self.create_causal_mask(i, j, device=device) dots = dots.masked_fill(causal_mask, mask_value) attn = F.softmax(dots, dim=-1, dtype=torch.float32) attn = attn.type(dtype) out = einsum(f'b h i j, {kv_einsum_eq} -> b h i d', attn, v) # merge heads out = rearrange(out, ' b h n d -> b n (h d)') # Communicate between heads # with autocast(enabled = False): # out_dtype = out.dtype # out = out.to(torch.float32) # out = self.to_out(out).to(out_dtype) out = self.to_out(out) if mask is not None: mask = rearrange(mask, 'b n -> b n 1') out = out.masked_fill(~mask, 0.) return out class ConformerModule(nn.Module): def __init__( self, dim, norm_kwargs={}, ): super().__init__() self.dim = dim self.in_norm = LayerNorm(dim, **norm_kwargs) self.pointwise_conv = nn.Conv1d(dim, dim, kernel_size=1, bias=False) self.glu = GLU(dim, dim, nn.SiLU()) self.depthwise_conv = nn.Conv1d(dim, dim, kernel_size=17, groups=dim, padding=8, bias=False) self.mid_norm = LayerNorm(dim, **norm_kwargs) # This is a batch norm in the original but I don't like batch norm self.swish = nn.SiLU() self.pointwise_conv_2 = nn.Conv1d(dim, dim, kernel_size=1, bias=False) def forward(self, x): x = self.in_norm(x) x = rearrange(x, 'b n d -> b d n') x = self.pointwise_conv(x) x = rearrange(x, 'b d n -> b n d') x = self.glu(x) x = rearrange(x, 'b n d -> b d n') x = self.depthwise_conv(x) x = rearrange(x, 'b d n -> b n d') x = self.mid_norm(x) x = self.swish(x) x = rearrange(x, 'b n d -> b d n') x = self.pointwise_conv_2(x) x = rearrange(x, 'b d n -> b n d') return x class TransformerBlock(nn.Module): def __init__( self, dim, dim_heads=64, cross_attend=False, dim_context=None, global_cond_dim=None, causal=False, zero_init_branch_outputs=True, conformer=False, layer_ix=-1, remove_norms=False, attn_kwargs={}, ff_kwargs={}, norm_kwargs={} ): super().__init__() self.dim = dim self.dim_heads = dim_heads self.cross_attend = cross_attend self.dim_context = dim_context self.causal = causal self.pre_norm = LayerNorm(dim, **norm_kwargs) if not remove_norms else nn.Identity() self.self_attn = Attention( dim, dim_heads=dim_heads, causal=causal, zero_init_output=zero_init_branch_outputs, **attn_kwargs ) if cross_attend: self.cross_attend_norm = LayerNorm(dim, **norm_kwargs) if not remove_norms else nn.Identity() self.cross_attn = Attention( dim, dim_heads=dim_heads, dim_context=dim_context, causal=causal, zero_init_output=zero_init_branch_outputs, **attn_kwargs ) self.ff_norm = LayerNorm(dim, **norm_kwargs) if not remove_norms else nn.Identity() self.ff = FeedForward(dim, zero_init_output=zero_init_branch_outputs, **ff_kwargs) self.layer_ix = layer_ix self.conformer = ConformerModule(dim, norm_kwargs=norm_kwargs) if conformer else None self.global_cond_dim = global_cond_dim if global_cond_dim is not None: self.to_scale_shift_gate = nn.Sequential( nn.SiLU(), nn.Linear(global_cond_dim, dim * 6, bias=False) ) nn.init.zeros_(self.to_scale_shift_gate[1].weight) # nn.init.zeros_(self.to_scale_shift_gate_self[1].bias) def forward( self, x, context=None, global_cond=None, mask=None, context_mask=None, rotary_pos_emb=None ): if self.global_cond_dim is not None and self.global_cond_dim > 0 and global_cond is not None: scale_self, shift_self, gate_self, scale_ff, shift_ff, gate_ff = self.to_scale_shift_gate( global_cond).unsqueeze(1).chunk(6, dim=-1) # self-attention with adaLN residual = x x = self.pre_norm(x) x = x * (1 + scale_self) + shift_self x = self.self_attn(x, mask=mask, rotary_pos_emb=rotary_pos_emb) x = x * torch.sigmoid(1 - gate_self) x = x + residual if context is not None: x = x + self.cross_attn(self.cross_attend_norm(x), context=context, context_mask=context_mask) if self.conformer is not None: x = x + self.conformer(x) # feedforward with adaLN residual = x x = self.ff_norm(x) x = x * (1 + scale_ff) + shift_ff x = self.ff(x) x = x * torch.sigmoid(1 - gate_ff) x = x + residual else: x = x + self.self_attn(self.pre_norm(x), mask=mask, rotary_pos_emb=rotary_pos_emb) if context is not None: x = x + self.cross_attn(self.cross_attend_norm(x), context=context, context_mask=context_mask) if self.conformer is not None: x = x + self.conformer(x) x = x + self.ff(self.ff_norm(x)) return x class ContinuousTransformer(nn.Module): def __init__( self, dim, depth, *, dim_in=None, dim_out=None, dim_heads=64, cross_attend=False, cond_token_dim=None, global_cond_dim=None, causal=False, rotary_pos_emb=True, zero_init_branch_outputs=True, conformer=False, use_sinusoidal_emb=False, use_abs_pos_emb=False, abs_pos_emb_max_length=10000, **kwargs ): super().__init__() self.dim = dim self.depth = depth self.causal = causal self.layers = nn.ModuleList([]) self.project_in = nn.Linear(dim_in, dim, bias=False) if dim_in is not None else nn.Identity() self.project_out = nn.Linear(dim, dim_out, bias=False) if dim_out is not None else nn.Identity() if rotary_pos_emb: self.rotary_pos_emb = RotaryEmbedding(max(dim_heads // 2, 32)) else: self.rotary_pos_emb = None self.use_sinusoidal_emb = use_sinusoidal_emb if use_sinusoidal_emb: self.pos_emb = ScaledSinusoidalEmbedding(dim) self.use_abs_pos_emb = use_abs_pos_emb if use_abs_pos_emb: self.pos_emb = AbsolutePositionalEmbedding(dim, abs_pos_emb_max_length) for i in range(depth): self.layers.append( TransformerBlock( dim, dim_heads=dim_heads, cross_attend=cross_attend, dim_context=cond_token_dim, global_cond_dim=global_cond_dim, causal=causal, zero_init_branch_outputs=zero_init_branch_outputs, conformer=conformer, layer_ix=i, **kwargs ) ) def forward( self, x, mask=None, prepend_embeds=None, prepend_mask=None, global_cond=None, return_info=False, **kwargs ): batch, seq, device = *x.shape[:2], x.device info = { "hidden_states": [], } x = self.project_in(x) if prepend_embeds is not None: prepend_length, prepend_dim = prepend_embeds.shape[1:] assert prepend_dim == x.shape[-1], 'prepend dimension must match sequence dimension' x = torch.cat((prepend_embeds, x), dim=-2) if prepend_mask is not None or mask is not None: mask = mask if mask is not None else torch.ones((batch, seq), device=device, dtype=torch.bool) prepend_mask = prepend_mask if prepend_mask is not None else torch.ones((batch, prepend_length), device=device, dtype=torch.bool) mask = torch.cat((prepend_mask, mask), dim=-1) # Attention layers if self.rotary_pos_emb is not None: rotary_pos_emb = self.rotary_pos_emb.forward_from_seq_len(x.shape[1]) else: rotary_pos_emb = None if self.use_sinusoidal_emb or self.use_abs_pos_emb: x = x + self.pos_emb(x) # Iterate over the transformer layers for layer in self.layers: # x = layer(x, rotary_pos_emb = rotary_pos_emb, global_cond=global_cond, **kwargs) x = checkpoint(layer, x, rotary_pos_emb=rotary_pos_emb, global_cond=global_cond, **kwargs) if return_info: info["hidden_states"].append(x) x = self.project_out(x) if return_info: return x, info return x class DiffusionTransformer(nn.Module): def __init__(self, io_channels=32, patch_size=1, embed_dim=768, cond_token_dim=0, project_cond_tokens=True, global_cond_dim=0, project_global_cond=True, input_concat_dim=0, prepend_cond_dim=0, depth=12, num_heads=8, transformer_type: tp.Literal["x-transformers", "continuous_transformer"] = "x-transformers", global_cond_type: tp.Literal["prepend", "adaLN"] = "prepend", **kwargs): super().__init__() self.cond_token_dim = cond_token_dim # Timestep embeddings timestep_features_dim = 256 self.timestep_features = FourierFeatures(1, timestep_features_dim) self.to_timestep_embed = nn.Sequential( nn.Linear(timestep_features_dim, embed_dim, bias=True), nn.SiLU(), nn.Linear(embed_dim, embed_dim, bias=True), ) if cond_token_dim > 0: # Conditioning tokens cond_embed_dim = cond_token_dim if not project_cond_tokens else embed_dim self.to_cond_embed = nn.Sequential( nn.Linear(cond_token_dim, cond_embed_dim, bias=False), nn.SiLU(), nn.Linear(cond_embed_dim, cond_embed_dim, bias=False) ) else: cond_embed_dim = 0 if global_cond_dim > 0: # Global conditioning global_embed_dim = global_cond_dim if not project_global_cond else embed_dim self.to_global_embed = nn.Sequential( nn.Linear(global_cond_dim, global_embed_dim, bias=False), nn.SiLU(), nn.Linear(global_embed_dim, global_embed_dim, bias=False) ) if prepend_cond_dim > 0: # Prepend conditioning self.to_prepend_embed = nn.Sequential( nn.Linear(prepend_cond_dim, embed_dim, bias=False), nn.SiLU(), nn.Linear(embed_dim, embed_dim, bias=False) ) self.input_concat_dim = input_concat_dim dim_in = io_channels + self.input_concat_dim self.patch_size = patch_size # Transformer self.transformer_type = transformer_type self.global_cond_type = global_cond_type if self.transformer_type == "x-transformers": self.transformer = ContinuousTransformerWrapper( dim_in=dim_in * patch_size, dim_out=io_channels * patch_size, max_seq_len=0, # Not relevant without absolute positional embeds attn_layers=Encoder( dim=embed_dim, depth=depth, heads=num_heads, attn_flash=True, cross_attend=cond_token_dim > 0, dim_context=None if cond_embed_dim == 0 else cond_embed_dim, zero_init_branch_output=True, use_abs_pos_emb=False, rotary_pos_emb=True, ff_swish=True, ff_glu=True, **kwargs ) ) elif self.transformer_type == "continuous_transformer": global_dim = None if self.global_cond_type == "adaLN": # The global conditioning is projected to the embed_dim already at this point global_dim = embed_dim self.transformer = ContinuousTransformer( dim=embed_dim, depth=depth, dim_heads=embed_dim // num_heads, dim_in=dim_in * patch_size, dim_out=io_channels * patch_size, cross_attend=cond_token_dim > 0, cond_token_dim=cond_embed_dim, global_cond_dim=global_dim, **kwargs ) else: raise ValueError(f"Unknown transformer type: {self.transformer_type}") self.preprocess_conv = nn.Conv1d(dim_in, dim_in, 1, bias=False) nn.init.zeros_(self.preprocess_conv.weight) self.postprocess_conv = nn.Conv1d(io_channels, io_channels, 1, bias=False) nn.init.zeros_(self.postprocess_conv.weight) def _forward( self, x, t, mask=None, cross_attn_cond=None, cross_attn_cond_mask=None, input_concat_cond=None, global_embed=None, prepend_cond=None, prepend_cond_mask=None, return_info=False, **kwargs): if cross_attn_cond is not None: cross_attn_cond = self.to_cond_embed(cross_attn_cond) if global_embed is not None: # Project the global conditioning to the embedding dimension global_embed = self.to_global_embed(global_embed) prepend_inputs = None prepend_mask = None prepend_length = 0 if prepend_cond is not None: # Project the prepend conditioning to the embedding dimension prepend_cond = self.to_prepend_embed(prepend_cond) prepend_inputs = prepend_cond if prepend_cond_mask is not None: prepend_mask = prepend_cond_mask if input_concat_cond is not None: # Interpolate input_concat_cond to the same length as x if input_concat_cond.shape[2] != x.shape[2]: input_concat_cond = F.interpolate(input_concat_cond, (x.shape[2],), mode='nearest') x = torch.cat([x, input_concat_cond], dim=1) # Get the batch of timestep embeddings timestep_embed = self.to_timestep_embed(self.timestep_features(t[:, None])) # (b, embed_dim) # Timestep embedding is considered a global embedding. Add to the global conditioning if it exists if global_embed is not None: global_embed = global_embed + timestep_embed else: global_embed = timestep_embed # Add the global_embed to the prepend inputs if there is no global conditioning support in the transformer if self.global_cond_type == "prepend": if prepend_inputs is None: # Prepend inputs are just the global embed, and the mask is all ones prepend_inputs = global_embed.unsqueeze(1) prepend_mask = torch.ones((x.shape[0], 1), device=x.device, dtype=torch.bool) else: # Prepend inputs are the prepend conditioning + the global embed prepend_inputs = torch.cat([prepend_inputs, global_embed.unsqueeze(1)], dim=1) prepend_mask = torch.cat([prepend_mask, torch.ones((x.shape[0], 1), device=x.device, dtype=torch.bool)], dim=1) prepend_length = prepend_inputs.shape[1] x = self.preprocess_conv(x) + x x = rearrange(x, "b c t -> b t c") extra_args = {} if self.global_cond_type == "adaLN": extra_args["global_cond"] = global_embed if self.patch_size > 1: x = rearrange(x, "b (t p) c -> b t (c p)", p=self.patch_size) if self.transformer_type == "x-transformers": output = self.transformer(x, prepend_embeds=prepend_inputs, context=cross_attn_cond, context_mask=cross_attn_cond_mask, mask=mask, prepend_mask=prepend_mask, **extra_args, **kwargs) elif self.transformer_type == "continuous_transformer": output = self.transformer(x, prepend_embeds=prepend_inputs, context=cross_attn_cond, context_mask=cross_attn_cond_mask, mask=mask, prepend_mask=prepend_mask, return_info=return_info, **extra_args, **kwargs) if return_info: output, info = output elif self.transformer_type == "mm_transformer": output = self.transformer(x, context=cross_attn_cond, mask=mask, context_mask=cross_attn_cond_mask, **extra_args, **kwargs) output = rearrange(output, "b t c -> b c t")[:, :, prepend_length:] if self.patch_size > 1: output = rearrange(output, "b (c p) t -> b c (t p)", p=self.patch_size) output = self.postprocess_conv(output) + output if return_info: return output, info return output def forward( self, x, t, cross_attn_cond=None, cross_attn_cond_mask=None, negative_cross_attn_cond=None, negative_cross_attn_mask=None, input_concat_cond=None, global_embed=None, negative_global_embed=None, prepend_cond=None, prepend_cond_mask=None, cfg_scale=1.0, cfg_dropout_prob=0.0, causal=False, scale_phi=0.0, mask=None, return_info=False, **kwargs): assert causal == False, "Causal mode is not supported for DiffusionTransformer" if cross_attn_cond_mask is not None: cross_attn_cond_mask = cross_attn_cond_mask.bool() cross_attn_cond_mask = None # Temporarily disabling conditioning masks due to kernel issue for flash attention if prepend_cond_mask is not None: prepend_cond_mask = prepend_cond_mask.bool() # CFG dropout if cfg_dropout_prob > 0.0: if cross_attn_cond is not None: null_embed = torch.zeros_like(cross_attn_cond, device=cross_attn_cond.device) dropout_mask = torch.bernoulli( torch.full((cross_attn_cond.shape[0], 1, 1), cfg_dropout_prob, device=cross_attn_cond.device)).to( torch.bool) cross_attn_cond = torch.where(dropout_mask, null_embed, cross_attn_cond) if prepend_cond is not None: null_embed = torch.zeros_like(prepend_cond, device=prepend_cond.device) dropout_mask = torch.bernoulli( torch.full((prepend_cond.shape[0], 1, 1), cfg_dropout_prob, device=prepend_cond.device)).to( torch.bool) prepend_cond = torch.where(dropout_mask, null_embed, prepend_cond) if cfg_scale != 1.0 and (cross_attn_cond is not None or prepend_cond is not None): # Classifier-free guidance # Concatenate conditioned and unconditioned inputs on the batch dimension batch_inputs = torch.cat([x, x], dim=0) batch_timestep = torch.cat([t, t], dim=0) if global_embed is not None: batch_global_cond = torch.cat([global_embed, global_embed], dim=0) else: batch_global_cond = None if input_concat_cond is not None: batch_input_concat_cond = torch.cat([input_concat_cond, input_concat_cond], dim=0) else: batch_input_concat_cond = None batch_cond = None batch_cond_masks = None # Handle CFG for cross-attention conditioning if cross_attn_cond is not None: null_embed = torch.zeros_like(cross_attn_cond, device=cross_attn_cond.device) # For negative cross-attention conditioning, replace the null embed with the negative cross-attention conditioning if negative_cross_attn_cond is not None: # If there's a negative cross-attention mask, set the masked tokens to the null embed if negative_cross_attn_mask is not None: negative_cross_attn_mask = negative_cross_attn_mask.to(torch.bool).unsqueeze(2) negative_cross_attn_cond = torch.where(negative_cross_attn_mask, negative_cross_attn_cond, null_embed) batch_cond = torch.cat([cross_attn_cond, negative_cross_attn_cond], dim=0) else: batch_cond = torch.cat([cross_attn_cond, null_embed], dim=0) if cross_attn_cond_mask is not None: batch_cond_masks = torch.cat([cross_attn_cond_mask, cross_attn_cond_mask], dim=0) batch_prepend_cond = None batch_prepend_cond_mask = None if prepend_cond is not None: null_embed = torch.zeros_like(prepend_cond, device=prepend_cond.device) batch_prepend_cond = torch.cat([prepend_cond, null_embed], dim=0) if prepend_cond_mask is not None: batch_prepend_cond_mask = torch.cat([prepend_cond_mask, prepend_cond_mask], dim=0) if mask is not None: batch_masks = torch.cat([mask, mask], dim=0) else: batch_masks = None batch_output = self._forward( batch_inputs, batch_timestep, cross_attn_cond=batch_cond, cross_attn_cond_mask=batch_cond_masks, mask=batch_masks, input_concat_cond=batch_input_concat_cond, global_embed=batch_global_cond, prepend_cond=batch_prepend_cond, prepend_cond_mask=batch_prepend_cond_mask, return_info=return_info, **kwargs) if return_info: batch_output, info = batch_output cond_output, uncond_output = torch.chunk(batch_output, 2, dim=0) cfg_output = uncond_output + (cond_output - uncond_output) * cfg_scale # CFG Rescale if scale_phi != 0.0: cond_out_std = cond_output.std(dim=1, keepdim=True) out_cfg_std = cfg_output.std(dim=1, keepdim=True) output = scale_phi * (cfg_output * (cond_out_std / out_cfg_std)) + (1 - scale_phi) * cfg_output else: output = cfg_output if return_info: return output, info return output else: return self._forward( x, t, cross_attn_cond=cross_attn_cond, cross_attn_cond_mask=cross_attn_cond_mask, input_concat_cond=input_concat_cond, global_embed=global_embed, prepend_cond=prepend_cond, prepend_cond_mask=prepend_cond_mask, mask=mask, return_info=return_info, **kwargs ) 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 DiT1D(nn.Module): def __init__(self, io_channels, cond_channels): super(DiT1D, self).__init__() self.model = DiffusionTransformer( io_channels=1, embed_dim=768, depth=12, num_heads=16, cond_token_dim=0, input_concat_dim=192+cond_channels, transformer_type="continuous_transformer", patch_size=1 ) self.context_dim = cond_channels self.band_emb = nn.Embedding(8, 96) self.l_position = SinePositionalEmbedding(96, dropout=0.1, scale=False, alpha=True) def forward(self, x, t, cond=None,**kwargs): x = x.transpose(1,2).unsqueeze(1) # cond = F.interpolate(cond, size=cond.shape[-1]//2, mode='linear') # cond = F.interpolate(cond, size=cond.shape[-1]*2, mode='linear') # cond_shape [N, L, 384] bs, ch, l, n_band = x.shape x_new = torch.zeros(bs, ch, l* n_band).to(x.device) cond_new = torch.zeros(bs, self.context_dim, l* n_band).to(x.device) for i in range(n_band): x_new[..., i::n_band] = x[..., :, :, i] cond_new[..., i::n_band] = cond pos = torch.zeros(bs, n_band).to(x.device) for i in range(n_band): pos[..., i] = i pos = self.band_emb(pos.long()) # pos [N, n_band, 96] pos = pos.unsqueeze(2).expand(-1, -1, l, -1) # pos [N, n_band, L, 96] pos_l =torch.zeros(bs, l).to(x.device) pos_l = self.l_position(pos_l) # pos [N, L, 96] pos_l = pos_l.unsqueeze(1).expand(-1, n_band, -1, -1) # pos [N, n_band, L, 96] pos = torch.cat([pos, pos_l], dim=-1) # pos [N, n_band, L, 192] pos_new = torch.zeros(bs, 192, l * n_band).to(x.device) for i in range(n_band): pos_new[..., i::n_band] = pos[:, i, :, :].transpose(1, 2) pos_new = torch.cat([pos_new, cond_new], dim=1) out= self.model(x_new, t, input_concat_cond=pos_new, **kwargs) out_new = torch.zeros(bs, ch, l, n_band).to(x.device) for i in range(n_band): out_new[..., :, :, i] = out[..., i::n_band] out_new = out_new.squeeze(1).transpose(1,2) return out_new if __name__ == '__main__': model = DiT1D(8,192).cuda() print(model) print('n parameters:', sum(p.numel() for p in model.parameters())/1e6, 'M') x = torch.randn(2, 8, 111).cuda() t = torch.rand(2).cuda() cond = torch.randn(2, 192, 111).cuda() out = model(x, t, cond) print(out.shape) # [2, 64, 111]