Upload layers_diffusion_4.py with huggingface_hub

layers_diffusion_4.py

@@ -0,0 +1,1490 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from huggingface_hub import PyTorchModelHubMixin
+from torch import Tensor
+from torch.nn import RMSNorm
+import numpy as np 
+#from .config import DiaConfig
+from state import DecoderInferenceState, EncoderInferenceState, KVCache
+from transformers.modeling_outputs import CausalLMOutput,CausalLMOutputWithCrossAttentions
+from safetensors.torch import load_file
+from config import Config 
+import os 
+import math 
+from typing import Optional
+from dataclasses import dataclass 
+from transformers.modeling_outputs import ModelOutput
+from typing import Optional, Tuple 
+from transformers import T5EncoderModel
+import math
+from einops import rearrange
+from convnext.convnext import ConvNeXtV2, IdentityConvNeXtV2
+from text_encoder.model import T5Encoder
+from scipy import stats
+from diffloss import DiffLoss
+
+@dataclass
+class QuoteTTSOutput(ModelOutput):
+    """
+    Base class for masked language models outputs.
+
+    Args:
+        loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` is provided):
+            Masked language modeling (MLM) loss.
+        logits (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.vocab_size)`):
+            Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).
+        hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+            Tuple of `torch.FloatTensor` (one for the output of the embeddings, if the model has an embedding layer, +
+            one for the output of each layer) of shape `(batch_size, sequence_length, hidden_size)`.
+
+            Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.
+        attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
+            Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length,
+            sequence_length)`.
+
+            Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
+            heads.
+    """
+
+    loss: Optional[torch.FloatTensor] = None
+    mask_loss: Optional[torch.FloatTensor] = None
+    logits: Optional[torch.FloatTensor] = None
+    labels: Optional[torch.FloatTensor] = None
+    expressive_latents: Optional[torch.FloatTensor] = None
+    labels_latents: Optional[torch.FloatTensor] = None
+    hidden_states: Optional[Tuple[torch.FloatTensor, ...]] = None
+    attentions: Optional[Tuple[torch.FloatTensor, ...]] = None
+    cross_attentions: Optional[Tuple[torch.FloatTensor, ...]] = None
+    target_mask: Optional[Tuple[torch.FloatTensor, ...]] = None
+    mu: Optional[torch.FloatTensor] = None
+    logvar: Optional[torch.FloatTensor] = None
+
+
+class SinusoidalPosEmb(nn.Module):
+    def __init__(self, dim):
+        super().__init__()
+        self.dim = dim
+
+    def forward(self, x):
+        device = x.device
+        half_dim = self.dim // 2
+        emb = math.log(10000) / (half_dim - 1)
+        emb = torch.exp(torch.arange(half_dim, device=device) * -emb)
+        emb = x[:, None] * emb[None, :] * 1.0
+        emb = torch.cat((emb.sin(), emb.cos()), dim=-1)
+        return emb
+
+
+
+def _normalize_axes(axes: tuple[int, ...], ndim: int) -> tuple[int, ...]:
+    return tuple(ax if ax >= 0 else ndim + ax for ax in axes)
+
+class DenseGeneral(nn.Module):
+    """
+    PyTorch equivalent of flax.linen.DenseGeneral with shapes defined at init.
+
+    Stores weights (`kernel`) in the same layout as Jax and uses torch.tensordot
+    for the generalized matrix multiplication. Weight/bias shapes are calculated
+    and parameters created during initialization based on config.
+    `load_weights` validates shapes and copies data.
+
+    Attributes:
+        axis (Tuple[int, ...]): Input axis or axes to contract.
+        in_shapes (Tuple[int, ...]): Sizes of the input dimensions specified by `axis`.
+        out_features (Tuple[int, ...]): Shape of the output features (non-contracted dims).
+        use_bias (bool): Whether to add a bias term.
+        weight (nn.Parameter): The kernel parameter.
+        bias (Optional[nn.Parameter]): The bias parameter (if use_bias=True).
+    """
+
+    def __init__(
+        self,
+        in_shapes: tuple[int, ...],
+        out_features: tuple[int, ...],
+        axis: tuple[int, ...] = (-1,),
+        #weight_dtype: torch.dtype = None,
+        #device: torch.device = None,
+    ):
+        super().__init__()
+        self.in_shapes = in_shapes
+        self.out_features = out_features
+        self.axis = axis
+        self.kernel_shape = self.in_shapes + self.out_features
+
+        # factory_kwargs = {"device": device, "dtype": weight_dtype}
+        self.weight = nn.Parameter(torch.empty(self.kernel_shape))
+        torch.nn.init.kaiming_uniform_(self.weight, a=math.sqrt(5))
+        # torch.nn.init.normal_(self.weight, std=.02)
+        
+    def forward(self, inputs: Tensor) -> Tensor:
+        norm_axis = _normalize_axes(self.axis, inputs.ndim)
+        kernel_contract_axes = tuple(range(len(norm_axis)))
+
+        output = torch.tensordot(
+            inputs.to(self.weight.dtype),
+            self.weight,
+            dims=(norm_axis, kernel_contract_axes),
+        ).to(inputs.dtype)
+        return output
+
+
+class MlpBlock(nn.Module):
+    """MLP block using DenseGeneral."""
+
+    def __init__(self, embed_dim: int, intermediate_dim: int, out_dim:int=None):
+        super().__init__()
+
+        self.wi_fused = DenseGeneral(
+            in_shapes=(embed_dim,),
+            out_features=(2, intermediate_dim),
+            axis=(-1,),
+        )
+        if out_dim is None : 
+            out_dim = embed_dim
+            
+        self.wo = DenseGeneral(
+            in_shapes=(intermediate_dim,),
+            out_features=(out_dim,),
+            axis=(-1,),
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """Forward pass."""
+        fused_x = self.wi_fused(x)
+
+        gate = fused_x[..., 0, :]
+        up = fused_x[..., 1, :]
+
+        hidden = torch.mul(F.silu(gate), up)
+
+        output = self.wo(hidden)
+        return output
+
+
+class LlamaAdaptiveRMSNorm(nn.Module):
+    def __init__(self, hidden_size=1024, eps=1e-6, dim_cond=1024):
+        super().__init__()
+        self.to_weight = nn.Linear(dim_cond, hidden_size)
+        nn.init.zeros_(self.to_weight.weight)
+        nn.init.ones_(self.to_weight.bias)
+        self.variance_epsilon = eps
+        self._is_hf_initialized = True  # disable automatic init
+
+    def forward(self, hidden_states, cond_embedding):
+        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.variance_epsilon)
+
+        weight = self.to_weight(cond_embedding)
+        if len(weight.shape) == 2:
+            weight = weight.unsqueeze(1)
+
+        return (weight * hidden_states).to(input_dtype)
+
+
+class RotaryEmbedding(nn.Module):
+    """Rotary Position Embedding (RoPE) implementation in PyTorch."""
+
+    def __init__(
+        self,
+        embedding_dims: int,
+        min_timescale: int = 1,
+        max_timescale: int = 10000,
+    ):
+        super().__init__()
+        if embedding_dims % 2 != 0:
+            raise ValueError("Embedding dim must be even for RoPE.")
+        self.embedding_dims = embedding_dims
+        self.min_timescale = min_timescale
+        self.max_timescale = max_timescale
+
+        half_embedding_dim = embedding_dims // 2
+        fraction = (2.0 * torch.arange(0, half_embedding_dim)) / embedding_dims
+        timescale = (self.min_timescale * (self.max_timescale / self.min_timescale) ** fraction).to(torch.float32)
+        self.register_buffer("timescale", timescale, persistent=False)
+
+    def forward(self, inputs: torch.Tensor, position: torch.Tensor):
+        """Applies RoPE."""
+        position = position.unsqueeze(-1).unsqueeze(-1)
+        sinusoid_inp = position / self.timescale
+        sin = torch.sin(sinusoid_inp)
+        cos = torch.cos(sinusoid_inp)
+        first_half, second_half = torch.chunk(inputs.to(torch.float32), 2, dim=-1)
+        first_part = first_half * cos - second_half * sin
+        second_part = second_half * cos + first_half * sin
+        return torch.cat((first_part, second_part), dim=-1)
+
+    def apply_rope(self, inputs: torch.Tensor, sin: torch.Tensor, cos: torch.Tensor):
+        first_half, second_half = torch.chunk(inputs.to(torch.float32), 2, dim=-1)
+        first_part = first_half * cos - second_half * sin
+        second_part = second_half * cos + first_half * sin
+        return torch.cat((first_part, second_part), dim=-1)
+        
+class selfAttention(nn.Module):
+    """Attention using DenseGeneral."""
+
+    def __init__(
+        self,
+        config,
+        q_embed_dim: int,
+        kv_embed_dim: int,
+        num_query_heads: int,
+        num_kv_heads: int,
+        head_dim: int,
+        is_cross_attn: bool = False,
+        out_embed_dim: int = None,
+        output_attentions=False,
+    ):
+        super().__init__()
+        self.num_query_heads = num_query_heads
+        self.num_kv_heads = num_kv_heads
+        self.head_dim = head_dim
+        self.is_cross_attn = is_cross_attn
+        self.output_dim = out_embed_dim if out_embed_dim is not None else q_embed_dim
+        self.projected_query_dim = num_query_heads * head_dim
+        if num_query_heads % num_kv_heads != 0:
+            raise ValueError(f"num_query_heads ({num_query_heads}) must be divisible by num_kv_heads ({num_kv_heads})")
+        self.num_gqa_groups = num_query_heads // num_kv_heads
+        self.kv_embed_dim = kv_embed_dim
+        self.q_embed_dim = q_embed_dim
+        self.output_attentions = output_attentions
+        self.dropout_rate = config.model.dropout_rate
+        # self.dropout = nn.Dropout(config.dropout_rate)
+        
+        # --- Projection Layers using DenseGeneral ---
+        self.q_proj = DenseGeneral(
+            in_shapes=(q_embed_dim,),
+            out_features=(num_query_heads, head_dim),
+            axis=(-1,),
+        )
+        self.k_proj = DenseGeneral(
+            in_shapes=(kv_embed_dim,),
+            out_features=(num_kv_heads, head_dim),
+            axis=(-1,),
+        )
+        self.v_proj = DenseGeneral(
+            in_shapes=(kv_embed_dim,),
+            out_features=(num_kv_heads, head_dim),
+            axis=(-1,),
+        )
+        self.o_proj = DenseGeneral(
+            in_shapes=(num_query_heads, head_dim),
+            out_features=(self.output_dim,),
+            axis=(-2, -1),
+        )
+
+        # --- Rotary Embedding ---
+        self.rotary_emb = RotaryEmbedding(
+            embedding_dims=self.head_dim,
+            min_timescale=config.model.rope_min_timescale,
+            max_timescale=config.model.rope_max_timescale,
+        )
+
+        self.is_fused_qkv = False
+
+    def forward(
+        self,
+        X: torch.Tensor,  # (B, T, D) T = 1 in AR generation
+        q_positions: torch.Tensor,  # (B, T)
+        kv_positions: torch.Tensor = None,  # (B, S)
+        attn_mask: torch.Tensor = None,  # None in Decoder self Attention, Valid mask in Others
+        cache: KVCache = None,  # None in Encoder, KVCache in Decoder
+        prefill: bool = False,
+        is_causal: bool = False,
+    ) :
+        """
+        Performs attention calculation with optional KV caching.
+
+        Args:
+            Xq: Query tensor (B, T, D). T=1 during single-step decoding.
+            Xkv: Key/Value source tensor (B, S, E). S=1 during single-step decoding for self-attn.
+            q_positions: Positions for queries (B, T).
+            kv_positions: Positions for keys/values (B, S). If None, uses q_positions.
+            attn_mask: Attention mask.
+            cache: KVCache.
+            prefill: If True, use prefill mode.
+
+        Returns:
+            A tuple containing:
+            - output: The attention output tensor (B, T, output_dim).
+            - present_kv: The K/V state to be cached for the next step ((B, N, S_new, H), (B, N, S_new, H)). For self-attn, S_new = S_past + S. For cross-attn, S_new = S_kv.
+        """
+        if kv_positions is None:
+            kv_positions = q_positions
+
+        original_dtype = X.dtype
+
+
+        Xq_BxTxNxH = self.q_proj(X)
+        Xk_BxSxKxH = self.k_proj(X)
+        Xv_BxSxKxH = self.v_proj(X)
+
+        position = q_positions.unsqueeze(-1).unsqueeze(-1)
+        sinusoid_inp = position / self.rotary_emb.timescale
+        sin = torch.sin(sinusoid_inp)
+        cos = torch.cos(sinusoid_inp)
+
+        Xq_BxTxNxH = self.rotary_emb.apply_rope(Xq_BxTxNxH, sin, cos)
+        Xk_BxSxKxH = self.rotary_emb.apply_rope(Xk_BxSxKxH, sin, cos)
+
+        Xq_BxNxTxH = Xq_BxTxNxH.transpose(1, 2)
+
+        attn_k = None
+        attn_v = None
+
+        Xk_BxKxSxH = Xk_BxSxKxH.transpose(1, 2)  # (B, K, S, H)
+        Xv_BxKxSxH = Xv_BxSxKxH.transpose(1, 2)  # (B, K, S, H)
+
+        if cache is None:
+            attn_k = Xk_BxKxSxH
+            attn_v = Xv_BxKxSxH
+        else:
+            attn_k, attn_v = cache.update(Xk_BxKxSxH, Xv_BxKxSxH, current_idx)
+
+        # print(Xq_BxNxTxH.size(), attn_k.size(), attn_v.size())
+
+        # print(attn_mask)
+        attn_output = F.scaled_dot_product_attention(
+            Xq_BxNxTxH,
+            attn_k,
+            attn_v,
+            attn_mask=attn_mask if not is_causal else None,
+            scale=None,
+            enable_gqa=self.num_gqa_groups > 1,
+            is_causal=is_causal,
+            dropout_p=self.dropout_rate if self.training else 0.0
+        )
+
+        attn_output = attn_output.transpose(1, 2).contiguous()  # (B, T, N, H)
+        output = self.o_proj(attn_output)
+
+        return output.to(original_dtype)
+        
+class CrossAttention(nn.Module):
+    """Cross-Attention using DenseGeneral."""
+
+    def __init__(
+        self,
+        config,
+        q_embed_dim: int,
+        kv_embed_dim: int,
+        num_query_heads: int,
+        num_kv_heads: int,
+        head_dim: int,
+        out_embed_dim: int = None,
+        output_attentions=False
+    ):
+        super().__init__()
+        self.num_query_heads = num_query_heads
+        self.num_kv_heads = num_kv_heads
+        self.head_dim = head_dim
+        self.output_dim = out_embed_dim if out_embed_dim is not None else q_embed_dim
+        self.projected_query_dim = num_query_heads * head_dim
+        if num_query_heads % num_kv_heads != 0:
+            raise ValueError(f"num_query_heads ({num_query_heads}) must be divisible by num_kv_heads ({num_kv_heads})")
+        self.num_gqa_groups = num_query_heads // num_kv_heads
+        self.output_attentions=output_attentions
+        self.dropout_rate = config.model.dropout_rate
+        # --- Projection Layers using DenseGeneral ---
+        self.q_proj = DenseGeneral(
+            in_shapes=(q_embed_dim,),
+            out_features=(num_query_heads, head_dim),
+            axis=(-1,),
+        )
+        self.k_proj = DenseGeneral(
+            in_shapes=(kv_embed_dim,),
+            out_features=(num_kv_heads, head_dim),
+            axis=(-1,),
+        )
+        self.v_proj = DenseGeneral(
+            in_shapes=(kv_embed_dim,),
+            out_features=(num_kv_heads, head_dim),
+            axis=(-1,),
+        )
+        self.o_proj = DenseGeneral(
+            in_shapes=(num_query_heads, head_dim),
+            out_features=(self.output_dim,),
+            axis=(-2, -1),
+        )
+
+        # --- Rotary Embedding ---
+        self.rotary_emb = RotaryEmbedding(
+            embedding_dims=self.head_dim,
+            min_timescale=config.model.rope_min_timescale,
+            max_timescale=config.model.rope_max_timescale,
+        )
+
+    def forward(
+        self,
+        Xq: torch.Tensor,  # (B, T, D) T = 1 in AR generation
+        q_positions: torch.Tensor,  # (B, T),
+        Xkv: torch.Tensor = None,  # (B, S)
+        kv_positions: torch.Tensor = None,  # (B, S)
+        attn_mask: torch.Tensor = None,  # None in Decoder self Attention, Valid mask in Others
+        cache: KVCache = None,  # None in Encoder, KVCache in Decoder
+        is_causal: bool = False,
+    ):
+        """
+        Performs attention calculation with optional KV caching.
+
+        Args:
+            Xq: Query tensor (B, T, D). T=1 during single-step decoding.
+            Xkv: Key/Value source tensor (B, S, E). S=1 during single-step decoding for self-attn.
+            q_positions: Positions for queries (B, T).
+            kv_positions: Positions for keys/values (B, S). If None, uses q_positions.
+            attn_mask: Attention mask.
+            cache: KVCache.
+
+        Returns:
+            A tuple containing:
+            - output: The attention output tensor (B, T, output_dim).
+            - present_kv: The K/V state to be cached for the next step ((B, N, S_new, H), (B, N, S_new, H)). For self-attn, S_new = S_past + S. For cross-attn, S_new = S_kv.
+        """
+        if kv_positions is None:
+            kv_positions = q_positions
+        original_dtype = Xq.dtype
+
+        Xq_BxTxNxH = self.q_proj(Xq)
+        Xq_BxTxNxH = self.rotary_emb(Xq_BxTxNxH, position=q_positions)
+        Xq_BxNxTxH = Xq_BxTxNxH.transpose(1, 2)
+
+        attn_k = None
+        attn_v = None
+        if cache is not None : 
+            attn_k, attn_v = cache.k, cache.v
+        else : 
+            attn_k = self.k_proj(Xkv)
+            attn_v = self.v_proj(Xkv)
+            attn_k = self.rotary_emb(attn_k, position=kv_positions)
+            attn_k = attn_k.transpose(1, 2)
+            attn_v = attn_v.transpose(1, 2)
+
+        attn_output = F.scaled_dot_product_attention(
+            Xq_BxNxTxH,
+            attn_k,
+            attn_v,
+            attn_mask=attn_mask if not is_causal else None,
+            scale=None,
+            enable_gqa=self.num_gqa_groups > 1,
+            is_causal=is_causal,
+            dropout_p=self.dropout_rate if self.training else 0.0
+        )
+        if self.output_attentions : 
+            attn_weight = attn_output @ torch.linalg.pinv(attn_v)
+            
+        attn_output = attn_output.transpose(1, 2).contiguous()  # (B, T, N, H)
+        output = self.o_proj(attn_output)
+        
+        if self.output_attentions : 
+            return output, attn_weight
+        return output.to(original_dtype)
+
+
+class EncoderLayer(nn.Module):
+    """Transformer Encoder Layer using DenseGeneral."""
+
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        model_config = config.model
+        enc_config = config.model.encoder
+        embed_dim = enc_config.n_embd
+
+        # self.pre_sa_norm = RMSNorm(
+        #     embed_dim,
+        #     eps=model_config.normalization_layer_epsilon,
+        #     dtype=torch.float32,
+        # )
+        self.pre_sa_norm = LlamaAdaptiveRMSNorm(
+            hidden_size=embed_dim, dim_cond=embed_dim
+        )
+        self.self_attention = selfAttention(
+            config,
+            q_embed_dim=embed_dim,
+            kv_embed_dim=embed_dim,
+            num_query_heads=enc_config.n_head,
+            num_kv_heads=enc_config.n_head,
+            head_dim=enc_config.head_dim,
+            is_cross_attn=False,
+            out_embed_dim=embed_dim,
+        )
+        # self.post_sa_norm = RMSNorm(
+        #     embed_dim,
+        #     eps=model_config.normalization_layer_epsilon,
+        #     dtype=torch.float32,
+        # )
+        self.post_sa_norm = LlamaAdaptiveRMSNorm(
+            hidden_size=embed_dim, dim_cond=embed_dim
+        )
+        self.mlp = MlpBlock(embed_dim=embed_dim, intermediate_dim=enc_config.n_hidden)
+        self.dropout = nn.Dropout(config.model.dropout_rate)
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        state: EncoderInferenceState,
+        cond_emb: torch.Tensor = None
+    ) -> torch.Tensor:
+        
+        residual = x
+        x_norm = self.pre_sa_norm(x, cond_embedding=cond_emb)
+
+        sa_out = self.self_attention(
+            X=x_norm,
+            q_positions=state.positions,
+            kv_positions=state.positions,
+            attn_mask=state.attn_mask,
+        )
+        x = residual + self.dropout(sa_out)
+
+        residual = x
+        x_norm = self.post_sa_norm(x, cond_embedding=cond_emb)
+        mlp_out = self.mlp(x_norm)
+        x = residual + self.dropout(mlp_out)
+
+        return x
+
+
+class Decoder(nn.Module):
+    """Transformer Decoder Stack using DenseGeneral."""
+
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        model_config = config.model
+        dec_config = config.model.decoder
+        data_config = config.data
+        self.num_layers = dec_config.n_layer
+        
+        # self.embeddings =  nn.Embedding(model_config.tgt_vocab_size, dec_config.n_embd)
+        self.mask_ratio_generator =  stats.truncnorm((config.model.mask_ratio_min - 1.0) / 0.25, 0, loc=1.0, scale=0.25)
+
+        self.sep_emb =  nn.Parameter(torch.zeros(1, 1, dec_config.n_embd))# nn.Embedding(1, dec_config.n_embd)
+        torch.nn.init.normal_(self.sep_emb, std=.02)
+        
+        self.mask_emb = nn.Parameter(torch.zeros(1, config.model.inp_dim))# nn.Embedding(1, config.model.inp_dim)
+        torch.nn.init.normal_(self.mask_emb, std=.02)
+
+        self.embedding_dense = DenseGeneral(
+            in_shapes=(dec_config.inp_dim,),
+            out_features=(1, dec_config.n_embd),
+            axis=(-1,),
+        )
+
+        self.layers = nn.ModuleList(
+            [DecoderLayer(config=config) for _ in range(self.num_layers)]
+        )
+
+        # self.norm = RMSNorm(
+        #     dec_config.n_embd,
+        #     eps=model_config.normalization_layer_epsilon,
+        #     dtype=torch.float32,
+        # )
+        self.norm = LlamaAdaptiveRMSNorm(
+            hidden_size=embed_dim, dim_cond=embed_dim
+        )
+        self.dropout = nn.Dropout(config.model.dropout_rate)
+
+        self.reconstructor = MlpBlock(
+            embed_dim=dec_config.n_embd,
+            intermediate_dim=dec_config.n_hidden,
+            out_dim = dec_config.inp_dim
+        )
+        
+        
+    def get_ids(self, text_input_ids, max_len, pad_value=1): 
+        bs, seq_len = text_input_ids.size()
+        padding_size = max_len - seq_len
+        
+        padding_tensor = torch.empty(bs, padding_size, device=text_input_ids.device).fill_(pad_value).long() 
+        return torch.cat((text_input_ids, padding_tensor), dim=1)
+        
+    def mask_prob(self, t):
+        return torch.sin(t * np.pi / 2).to(t.device)
+    
+    def get_t(self, x0) :  
+        t = torch.rand(x0.shape[0], device=x0.device, requires_grad=False)
+        t = torch.clamp(t, 1e-5, 1.0)
+        return t 
+        
+    def mask_tgt_embeddings(self, x0):
+        # x0: semantic tokens (B, T)
+        t = self.get_t(x0)
+        new_t = t
+        mask_prob = self.mask_prob(new_t)  # (B,)
+        # if mask_prob[i] < 0.2, mask_prob[i] = 0.2
+        mask_prob = torch.where(
+            mask_prob < 0.2, torch.ones_like(mask_prob) * 0.2, mask_prob
+        )
+        # Add mask
+        target_mask = torch.bernoulli(torch.ones_like(x0[:, :, 0]) * mask_prob[..., None])
+        # mask = torch.cat((torch.zeros_like(prefix), target_mask), dim=1)
+        
+        # mask 
+        xt = x0.clone()
+
+        # replace by pad embedding
+        # pad_emb = self.mask_emb.repeat(x0.shape[0], x0.shape[1], 1).to(x0.dtype) #self.pad_emb(torch.zeros(1, dtype=torch.int32, device=x0.device)).squeeze(0) # torch.zeros(1, device=x0.device)
+        xt[(target_mask==1)] = self.mask_emb.to(xt.dtype)
+
+        return xt, target_mask
+        
+    def random_masking(self, x, orders):
+        # generate token mask
+        bsz, seq_len, embed_dim = x.shape
+        mask_rate = self.mask_ratio_generator.rvs(1)[0]
+        num_masked_tokens = int(np.ceil(seq_len * mask_rate))
+        mask = torch.zeros(bsz, seq_len, device=x.device)
+        mask = torch.scatter(mask, dim=-1, index=orders[:, :num_masked_tokens].to(x.device),
+                             src=torch.ones(bsz, seq_len, device=x.device))
+        return mask.long()
+    def sample_orders(self, bsz, seq_len =32 ):
+        # generate a batch of random generation orders
+        orders = []
+        for _ in range(bsz):
+            order = np.array(list(range(seq_len)))
+            np.random.shuffle(order)
+            orders.append(order)
+        orders = torch.Tensor(np.array(orders)).long()
+        return orders
+
+    def mask_input(self, x) : 
+        bs, seq_len, _ = x.size()
+        orders = self.sample_orders(bs,seq_len)
+        mask = self.random_masking(x, orders)
+        xt = x.clone()
+        xt[(mask==1)] =  self.mask_emb.to(xt.dtype)
+        return xt, mask 
+        
+    def forward(
+        self,
+        enc_state: EncoderInferenceState,
+        enc_out: torch.Tensor,
+        quote_embs: torch.Tensor,
+        dec_in : torch.Tensor,
+        text_input_ids: torch.Tensor,
+        labels:torch.Tensor = None) -> torch.Tensor:
+        
+        if self.training : 
+            # x_orig = dec_in
+            # x, target_mask = self.mask_tgt_embeddings(dec_in)
+            x, target_mask = self.mask_input(dec_in)
+            # x = self.embedding_dense(x).squeeze(2)
+            
+        else : 
+            # x_orig = self.embedding_dense(dec_in).squeeze(2) 
+            # full of pad tokens
+            # bs, seq_len, _ = dec_in.size()
+            # x = self.mask_emb.unsqueeze(1).repeat(bs, seq_len,1)
+
+            # x = 
+            # x = self.embedding_dense(x.unsqueeze(1))#.squeeze(2)
+            # x = pad_emb.unsqueeze(1).expand(dec_in.size(0),dec_in.size(1),1)
+            target_mask=None
+            x = dec_in
+            
+        x = self.embedding_dense(x).squeeze(2)
+            
+        # sep_emb = self.sep_emb(torch.zeros(1, dtype=torch.int32, device=dec_in.device)).expand(dec_in.size(0), 1,  -1)
+
+        x = torch.cat((quote_embs, self.sep_emb.repeat(x.size(0), 1,1).to(x.dtype), x), dim = 1)
+
+        dec_in_dummy = self.get_ids(text_input_ids, max_len = x.size(1))
+        # print(dec_in_dummy)
+        state = DecoderInferenceState.new(
+            self.config, enc_state, enc_out, dec_in_dummy
+        )
+        # print(state.attn_mask[1,0, 8:, 8:])
+        cross_attentions = ()
+        for i, layer in enumerate(self.layers):
+            x, cattns = layer(x, state)
+            cross_attentions += (cattns,)
+            
+        # Final Norm
+        x = self.norm(x)
+        # print(x[:,-32:].size())
+
+        # reconstructed_input = self.reconstructor(self.dropout(x[:,-32:]).unsqueeze(1))
+        reconstructed_input = self.reconstructor(self.dropout(x[:,-32:])).squeeze(2)
+
+        if self.training : 
+            loss1 = F.mse_loss(
+                    reconstructed_input[:,-32:][(target_mask==1)],
+                    dec_in[(target_mask==1)],
+                    reduction="mean",
+                )
+            loss2 = F.l1_loss(
+                    reconstructed_input[:,-32:][(target_mask==1)],
+                    dec_in[(target_mask==1)],
+                    reduction="mean",
+                )
+            mask_loss = loss1 + loss2 
+        else :
+            if labels is not None : 
+                loss1 = F.mse_loss(
+                        reconstructed_input[:,-32:],
+                        labels,
+                        reduction="mean",
+                    )
+                loss2 = F.l1_loss(
+                        reconstructed_input[:,-32:],
+                        labels,
+                        reduction="mean",
+                    )
+                mask_loss = loss1 + loss2 
+            else : 
+                mask_loss = None
+        
+        
+
+        out = QuoteTTSOutput(
+            logits=x,
+            mask_loss=mask_loss,
+            cross_attentions=cross_attentions,
+            expressive_latents=reconstructed_input,
+            target_mask=target_mask)#, kl_div_loss=loss_kl, mu=mu, logvar=logvar)
+        return out
+
+
+class Encoder(nn.Module):
+    """Transformer Decoder Stack using DenseGeneral."""
+
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        model_config = config.model
+        dec_config = config.model.decoder
+        data_config = config.data
+        self.num_layers = dec_config.n_layer
+        
+        # self.embeddings =  nn.Embedding(model_config.tgt_vocab_size, dec_config.n_embd)
+
+        # self.embedding_dense = DenseGeneral(
+        #     in_shapes=(dec_config.inp_dim,),
+        #     out_features=(1, dec_config.n_embd),
+        #     axis=(-1,),
+        # )
+        self.embedding_dense = nn.Linear(dec_config.inp_dim, dec_config.n_embd, bias=True)
+        torch.nn.init.xavier_uniform_(self.embedding_dense.weight)
+        torch.nn.init.constant_(self.embedding_dense.bias, 0)
+        
+        self.sep_emb =  nn.Parameter(torch.zeros(1, 1, dec_config.n_embd))# nn.Embedding(1, dec_config.n_embd)
+        torch.nn.init.normal_(self.sep_emb, std=.02)
+
+        # self.z_proj_ln = nn.LayerNorm(dec_config.n_embd, eps=1e-6)
+        # self.encoder_pos_embed_learned = nn.Embedding(1024, dec_config.n_embd)
+        # torch.nn.init.normal_(self.encoder_pos_embed_learned.weight.data, std=.02)
+
+        # self.ref_dense = DenseGeneral(
+        #     in_shapes=(dec_config.inp_dim  * 32,),
+        #     out_features=(1, dec_config.n_embd),
+        #     axis=(-1,),
+        # )
+        # self.embedding_dense = IdentityConvNeXtV2(in_chans=1, depths=[3, 3, 9, 3], dims=[96, 192, 384, 768], num_classes=1024)
+
+        self.layers = nn.ModuleList(
+            [EncoderLayer(config=config) for _ in range(self.num_layers)]
+        )
+
+        # self.norm = RMSNorm(
+        #     dec_config.n_embd,
+        #     eps=model_config.normalization_layer_epsilon,
+        #     dtype=torch.float32,
+        # )
+        self.norm = LlamaAdaptiveRMSNorm(
+            hidden_size=embed_dim, dim_cond=embed_dim
+        )
+        self.dropout = nn.Dropout(config.model.dropout_rate)
+
+    def get_ids(self, text_input_ids, max_len, pad_value=1): 
+        bs, seq_len = text_input_ids.size()
+        padding_size = max_len - seq_len
+        
+        padding_tensor = torch.empty(bs, padding_size, device=text_input_ids.device).fill_(pad_value).long() 
+        return torch.cat((text_input_ids, padding_tensor), dim=1)
+        
+    def forward(
+        self,
+        context_embs: torch.Tensor,
+        audio_in : torch.Tensor,
+        ref_in : torch.Tensor,
+        text_input_ids: torch.Tensor,
+        mask: torch.Tensor) -> torch.Tensor:
+        
+
+        bsz, seq_len, embed_dim = context_embs.shape
+        
+        x = self.embedding_dense(audio_in).squeeze(2)
+        # ref_x = self.ref_dense(ref_in.view(x.size(0), -1)).squeeze(2)
+        # print(context_embs.size(), x.size())
+        x = torch.cat((context_embs, self.sep_emb.repeat(bsz, 1,1).to(x.dtype), x), dim = 1)
+        # x = x + ref_x
+        
+        mask_with_buffer =  torch.cat([torch.zeros(bsz, seq_len + 1, device=x.device), mask], dim=1)
+
+        # positional embeddings to let the model know the initial positions
+        # positions = torch.arange(x.size(1), device=x.device).unsqueeze(0).repeat(bsz,1).long()
+        # x = x + self.encoder_pos_embed_learned(positions)
+        # x = self.z_proj_ln(x)
+        
+        # dropping 
+        x = x[(1-mask_with_buffer).nonzero(as_tuple=True)].reshape(bsz, -1, embed_dim)
+
+        # state
+        enc_in_dummy = self.get_ids(text_input_ids, max_len = x.size(1))
+        state = EncoderInferenceState.new(
+            self.config, enc_in_dummy
+        )
+        # print(state.attn_mask[1,0, 8:, 8:])
+        # cross_attentions = ()
+        for i, layer in enumerate(self.layers):
+            x = layer(x, state)
+            # cross_attentions += (cattns,)
+            
+        # Final Norm
+        x = self.norm(x)
+        # reconstructed_input = self.reconstructor(self.dropout(x[:,-32:])).squeeze(2)
+        
+        # gt_latents = audio_in.clone().detach()
+        # x = x[:,-32:] + self.diffusion_pos_embed_learned
+        
+        # loss = self.forward_loss(x, gt_latents, target_mask)
+                
+        # out = QuoteTTSOutput(
+        #     logits=x,
+        #     mask_loss=None,
+        #     expressive_latents=None)
+            #, kl_div_loss=loss_kl, mu=mu, logvar=logvar)
+        return x
+
+
+class MaskedEncoder(nn.Module):
+    """Transformer Decoder Stack using DenseGeneral."""
+
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        model_config = config.model
+        dec_config = config.model.decoder
+        data_config = config.data
+        self.num_layers = dec_config.n_layer
+        
+        # self.embeddings =  nn.Embedding(model_config.tgt_vocab_size, dec_config.n_embd)
+        self.mask_token = nn.Parameter(torch.zeros(1, 1, dec_config.n_embd))# nn.Embedding(1, config.model.inp_dim)
+        torch.nn.init.normal_(self.mask_token, std=.02)
+        
+        # self.embedding_dense = DenseGeneral(
+        #     in_shapes=(dec_config.n_embd,),
+        #     out_features=(1, dec_config.n_embd),
+        #     axis=(-1,),
+        # )
+        self.embedding_dense = nn.Linear(dec_config.inp_dim, dec_config.n_embd, bias=True)
+        torch.nn.init.xavier_uniform_(self.embedding_dense.weight)
+        torch.nn.init.constant_(self.embedding_dense.bias, 0)
+        
+        self.layers = nn.ModuleList(
+            [EncoderLayer(config=config) for _ in range(self.num_layers)]
+        )
+
+        # self.norm = RMSNorm(
+        #     dec_config.n_embd,
+        #     eps=model_config.normalization_layer_epsilon,
+        #     dtype=torch.float32,
+        # )
+        self.norm = LlamaAdaptiveRMSNorm(
+            hidden_size=dec_config.n_embd, dim_cond=dec_config.n_embd
+        )
+        # self.decoder_pos_embed_learned = nn.Embedding(1024, dec_config.n_embd)
+        # torch.nn.init.normal_(self.decoder_pos_embed_learned.weight.data, std=.02)
+
+        # self.diffusion_pos_embed_learned =  nn.Parameter(torch.zeros(1, 32, config.model.decoder.n_embd))
+        # torch.nn.init.normal_(self.diffusion_pos_embed_learned, std=.02)
+        
+    def get_ids(self, text_input_ids, max_len, pad_value=1): 
+        bs, seq_len = text_input_ids.size()
+        padding_size = max_len - seq_len
+        
+        padding_tensor = torch.empty(bs, padding_size, device=text_input_ids.device).fill_(pad_value).long() 
+        return torch.cat((text_input_ids, padding_tensor), dim=1)
+        
+    def forward(
+        self,
+        audio_in: torch.Tensor,
+        context_embs: torch.Tensor,
+        mask: torch.Tensor,
+        text_input_ids : torch.Tensor,
+        cond_emb: torch.Tensor) -> torch.Tensor:
+        
+        bsz, seq_len = text_input_ids.shape
+
+        x = self.embedding_dense(audio_in).squeeze(2)
+        
+        mask_with_buffer =  torch.cat([torch.zeros(bsz, seq_len, device=x.device), mask], dim=1)
+
+        # mask tokens
+        x = torch.cat((context_embs, x), dim = 1)
+        # mask target tokens
+        x[(mask_with_buffer).nonzero(as_tuple=True)] = self.mask_token.to(x.dtype)
+
+        # positions = torch.arange(x_after_pad.size(1), device=x_after_pad.device).unsqueeze(0).repeat(bsz,1).long()
+        # x = x_after_pad + self.decoder_pos_embed_learned(positions)
+        
+        # avoid attending to pad tokens
+        enc_in_dummy = self.get_ids(text_input_ids, max_len = x.size(1))
+        state = EncoderInferenceState.new(
+            self.config, enc_in_dummy
+        )
+        # print(state.attn_mask[1,0, 8:, 8:])
+        # cross_attentions = ()
+        for i, layer in enumerate(self.layers):
+            x = layer(x, state,  cond_emb=cond_emb)
+            # cross_attentions += (cattns,)
+            
+        # Final Norm
+        x = self.norm(x, cond_embedding=cond_emb)
+        # reconstructed_input = self.reconstructor(self.dropout(x[:,-32:])).squeeze(2)
+        
+        x = x[:,-32:]
+        # x = x + self.diffusion_pos_embed_learned
+        
+        # loss = self.forward_loss(x, gt_latents, target_mask)
+                
+        # out = QuoteTTSOutput(
+        #     logits=x,
+        #     mask_loss=loss,
+        #     expressive_latents=None)
+            #, kl_div_loss=loss_kl, mu=mu, logvar=logvar)
+        return x
+        
+class EncoderDecoder(
+    nn.Module,
+):
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        self.mask_ratio_generator =  stats.truncnorm((config.model.mask_ratio_min - 1.0) / 0.25, 0, loc=1.0, scale=0.25)
+
+        # self.encoder = T5Encoder.from_pretrained(config.model.base_encoder_path, config.model.ft_encoder_path).encoder
+        self.context_encoder = T5EncoderModel.from_pretrained(config.model.base_encoder_path)
+        for p in self.context_encoder.parameters():
+            p.requires_grad = False
+        self.context_encoder = self.context_encoder.eval()
+        
+        # self.encoder = Encoder(config)
+        self.decoder = MaskedEncoder(config)
+        
+        self.diffloss = DiffLoss(
+            target_channels=config.model.inp_dim,
+            z_channels=1024,
+            width=1024,
+            depth=8,
+            num_sampling_steps='100',
+            grad_checkpointing=False
+        )
+        
+        self.mask_step_embedding = SinusoidalPosEmb(config.model.decoder.n_embd)
+        self.mask_step_mlp = nn.Sequential(
+            nn.Linear(config.model.decoder.n_embd, config.model.decoder.n_embd * 4),
+            nn.SiLU(),
+            nn.Linear(config.model.decoder.n_embd * 4, config.model.decoder.n_embd),
+        )
+        
+        # self.post_ln = nn.LayerNorm(config.model.decoder.n_embd)
+        
+        # self.ref_dense = nn.Linear(config.model.inp_dim, config.model.decoder.n_embd, bias=True)
+        # torch.nn.init.xavier_uniform_(self.ref_dense.weight)
+        # torch.nn.init.constant_(self.ref_dense.bias, 0)
+                
+    def random_masking(self, x, orders):
+        # generate token mask
+        bsz, seq_len, embed_dim = x.shape
+        mask_rate = self.mask_ratio_generator.rvs(1)[0]
+        num_masked_tokens = int(np.ceil(seq_len * mask_rate))
+        mask = torch.zeros(bsz, seq_len, device=x.device)
+        mask = torch.scatter(mask, dim=-1, index=orders[:, :num_masked_tokens].to(x.device),
+                             src=torch.ones(bsz, seq_len, device=x.device))
+        return mask.long()
+        
+    def sample_orders(self, bsz, seq_len =32 ):
+        # generate a batch of random generation orders
+        orders = []
+        for _ in range(bsz):
+            order = np.array(list(range(seq_len)))
+            np.random.shuffle(order)
+            orders.append(order)
+        orders = torch.Tensor(np.array(orders)).long()
+        return orders
+        
+    # def mask_input(self, x) : 
+    #     bs, seq_len, _ = x.size()
+    #     orders = self.sample_orders(bs,seq_len)
+    #     mask = self.random_masking(x, orders)
+    #     # xt = x.clone()
+    #     # xt[(mask==1)] =  self.mask_emb.to(xt.dtype)
+    #     return mask 
+    
+    # def sample_orders(self, bsz, seq_len =32 ):
+    #     # generate a batch of random generation orders
+    #     orders = torch.arange(seq_len).unsqueeze(0).repeat(bsz,1)
+    #     return orders
+        
+    def mask_prob(self, t):
+        return torch.sin(t * np.pi / 2).to(t.device)
+
+    def get_mask(self, bsz, device, seq_len=32) : 
+        t = torch.rand(bsz, device=device, requires_grad=False)
+        t = torch.clamp(t, 1e-5, 1.0)
+        mask_prob = self.mask_prob(t)
+        mask_prob = torch.where(
+            mask_prob < 0.2, torch.ones_like(mask_prob) * 0.2, mask_prob
+        )
+        mask = torch.bernoulli(torch.ones(bsz, seq_len, device=device) * mask_prob[..., None]).long()
+        
+        # bs, seq_len, _ = x.size()
+        # orders = self.sample_orders(bs,seq_len)
+        # mask = self.random_masking(x, orders)
+        # xt = x.clone()
+        # xt[(mask==1)] =  self.mask_emb.to(xt.dtype)
+        return t, mask 
+
+    def forward_loss(self, z, target, mask, diffusion_batch_mul=4):
+        bsz, seq_len, _ = target.shape
+        target = target.reshape(bsz * seq_len, -1).repeat(diffusion_batch_mul, 1)
+        z = z.reshape(bsz*seq_len, -1).repeat(diffusion_batch_mul, 1)
+        mask = mask.reshape(bsz*seq_len).repeat(diffusion_batch_mul)
+        loss = self.diffloss(z=z, target=target, mask=mask)
+        return loss
+
+    def get_diff_t(self, x) :
+        # 32 is sequence length here
+        return torch.randint(0, self.diffloss.train_diffusion.num_timesteps, (x.shape[0] * 32, ), device=x.device)
+
+    def _forward(
+        self,
+        context: torch.Tensor,
+        quote: torch.Tensor,
+        dec_in_ref: torch.Tensor,
+        transformer_in : torch.Tensor,
+        dec_in_tgt: torch.Tensor,
+        labels: torch.Tensor = None
+    ) : 
+
+        bsz, _ = context.size()
+        
+        # diffusion step embedding
+        # diff_t = self.get_diff_t(context)
+        # diffusion_step_emb = self.diff_step_embedding(diff_t)
+        # diffusion_step_emb = self.diff_step_mlp(diffusion_step_emb).reshape(bsz, 32, -1)
+
+        # mask step embedding
+        mask_t, mask = self.get_mask(bsz, device=context.device)
+        mask_perc_emb = self.mask_step_embedding(mask_t)
+        mask_perc_emb = self.mask_step_mlp(mask_perc_emb)
+
+        
+        enc_state = EncoderInferenceState.new(self.context_encoder.config, context)
+        enc_out = self.context_encoder(input_ids=context,attention_mask=enc_state.padding_mask).last_hidden_state
+        
+        # quote_embs = self.get_quote_embs(quote)
+
+        # mask = self.mask_input(transformer_in)
+        # x = self.encoder(enc_out, transformer_in, dec_in_ref, context, mask) 
+        z = self.decoder(
+            transformer_in,
+            enc_out,
+            mask,
+            context,
+            cond_emb=mask_perc_emb)
+
+        # Reference latents
+        # z_ref = self.post_ln(self.ref_dense(dec_in_ref) + quote_embs)
+        
+        # z = torch.cat((z, z_ref), dim = -1)
+        # print(t.size())
+        gt_latents = transformer_in.clone().detach()
+        loss = self.forward_loss(z, gt_latents, mask)
+                
+        out = QuoteTTSOutput(
+            logits=z,
+            loss=loss,
+            expressive_latents=None)
+        return out
+        
+
+    def forward(
+        self,
+        context: torch.Tensor,
+        quote: torch.Tensor,
+        dec_in_ref: torch.Tensor,
+        transformer_in: torch.Tensor = None,
+        dec_in_tgt: torch.Tensor = None,
+        labels: torch.Tensor = None): 
+        # if self.training : 
+        # if self.eval : 
+            # print(labels[0])
+        if self.training : 
+            return self._forward(
+                    context=context,
+                    quote=quote,
+                    dec_in_ref=dec_in_ref,
+                    dec_in_tgt=dec_in_tgt,
+                    transformer_in=transformer_in,
+                    labels=labels)
+        else : 
+            samples, z = self.sample_tokens(context, quote, dec_in_ref, num_iter=1)
+            # print(samples)
+            mask = torch.ones(z.size(0), z.size(1), device=context.device).long()
+            # print(z.size())
+            loss = self.forward_loss(z, transformer_in, mask, diffusion_batch_mul=1)
+            
+            out = QuoteTTSOutput(
+            logits=samples,
+            loss=loss,
+            labels=transformer_in)
+            return out
+            
+    @classmethod
+    def from_pretrained(cls, path: str, config_path: str= None):
+        if config_path:
+            with open(config_path) as f : 
+                config = yaml.safe_load(f)
+        else : 
+            config = Config()
+            
+        model = cls(config)
+        model.load_state_dict(torch.load(os.path.join(path, "pytorch_model.bin"), map_location="cpu"))
+        return model
+
+    # @torch.no_grad()
+    # def sample_all(self, context, quote,num_iter=10, seq_len=32):
+    #     expressive_latents = self.sample_tokens(context,quote,num_iter,seq_len)
+    #     out = self.decoder()
+
+    @torch.no_grad()
+    def sample_tokens(self, context, quote, dec_in_ref, num_iter=10, seq_len=32, temperature=1.0):
+
+        bsz = context.size(0)
+        enc_state = EncoderInferenceState.new(self.context_encoder.config, context)
+        enc_out = self.context_encoder(input_ids=context,attention_mask=enc_state.padding_mask).last_hidden_state
+        
+        # enc_state_ = EncoderInferenceState.new(self.context_encoder.config, quote)
+        # quote_embs = self.context_encoder(input_ids=quote, attention_mask=enc_state_.padding_mask).last_hidden_state
+        # quote_embs = quote_embs.mean(1, keepdims=True) 
+        # quote_embs = self.get_quote_embs(quote)
+        
+        # ref latents
+        # z_ref = self.post_ln(self.ref_dense(dec_in_ref) + quote_embs)
+        
+        # init and sample generation orders
+        tokens = torch.zeros(bsz, seq_len, dec_in_ref.size(2), device=context.device)#.repeat(bsz, seq_len, 1)
+        # dec_in = torch.zeros(bsz, seq_len, self.config.model.decoder.n_embed).cuda()
+        mask = torch.ones(bsz, seq_len, device=context.device)
+        orders = self.sample_orders(bsz)
+
+        # indices = list(range(num_iter))
+        h = 1.0/num_iter
+        t_list = [1.0 - i * h for i in range(num_iter)]
+        t_list.append(0.0)
+        
+        # generate latents
+        for step in range(num_iter):
+            cur_tokens = tokens.clone()
+            t = t_list[step] * torch.ones(bsz).to(mask.device)
+            mask_perc_emb = self.mask_step_embedding(t)
+            mask_perc_emb = self.mask_step_mlp(mask_perc_emb)
+            # print(tokens[0])
+            # print(curr_t
+            # x = self.encoder(enc_out, cur_tokens, dec_in_ref, context, mask) 
+            z = self.decoder(cur_tokens, enc_out, mask, context, cond_emb=mask_perc_emb)
+            
+            # mask ratio for the next round, following MaskGIT and MAGE.
+            mask_ratio = torch.Tensor([t_list[step+1]]).to(context.device) #* torch.ones(bsz).to(mask.device)#np.cos(math.pi / 2. * (step + 1) / num_iter)
+            # print(mask_ratio)
+            # mask_len = torch.Tensor([np.floor(seq_len * mask_ratio)]).to(cur_tokens.device)
+            mask_len = (self.mask_prob(mask_ratio) * seq_len).long()
+            
+            # masks out at least one for the next iteration
+            mask_len = torch.maximum(torch.Tensor([1]).to(context.device),
+                                     torch.minimum(torch.sum(mask, dim=-1, keepdims=True) - 1, mask_len))
+
+            # get masking for next iteration and locations to be predicted in this iteration
+            mask_next = mask_by_order(mask_len[0], orders, bsz, seq_len).to(cur_tokens.device)
+            if step >= num_iter - 1:
+                mask_to_pred = mask[:bsz].bool()
+            else:
+                mask_to_pred = torch.logical_xor(mask[:bsz].bool(), mask_next.bool())
+            mask = mask_next
+            # z = torch.cat((z, z_ref), dim = -1)
+            full_z = z.clone()
+            z = z[mask_to_pred.nonzero(as_tuple=True)]
+            # sample token latents for this step
+            # samples = out.expressive_latents[mask_to_pred.nonzero(as_tuple=True)]
+            sampled_token_latent = self.diffloss.sample(z, temperature, cfg=1.0)
+            cur_tokens[mask_to_pred.nonzero(as_tuple=True)] = sampled_token_latent
+            tokens = cur_tokens.clone()
+            # print(tokens[0,0])
+        return tokens, full_z
+
+def mask_by_order(mask_len, order, bsz, seq_len):
+    masking = torch.zeros(bsz, seq_len)
+    masking = torch.scatter(masking, dim=-1, index=order[:, :mask_len.long()], src=torch.ones(bsz, seq_len)).bool()
+    return masking
+
+
+def top_p_sample(logits, thres=0.9):
+    k = math.ceil((1 - thres) * logits.shape[-1])
+    val, ind = logits.topk(k, dim=-1)
+    probs = torch.full_like(logits, float("-inf"))
+    probs.scatter_(2, ind, val)
+    return probs
+
+
+def log(t, eps=1e-10):
+    return torch.log(t + eps)
+
+
+def gumbel_noise(t):
+    noise = torch.zeros_like(t).uniform_(0, 1)
+    return -log(-log(noise))
+
+
+def gumbel_sample(t, temperature=1.0, dim=-1):
+    return ((t / max(temperature, 1e-10)) + gumbel_noise(t)).argmax(dim=dim)
+
+    
+def apply_top_k_only(
+    logits: torch.Tensor,
+    k: torch.Tensor,
+) -> torch.Tensor:
+    """
+    Apply top-k mask to the logits.
+
+    This implementation doesn't involve sorting the entire vocab.
+
+    The logits tensor may be updated in-place.
+    """
+    no_top_k_mask = k == logits.shape[1]
+    # Set non-top-k rows to 1 so that we can gather.
+    k = k.masked_fill(no_top_k_mask, 1)
+    max_top_k = k.max()
+    # topk.values tensor has shape [batch_size, max_top_k].
+    # Convert top k to 0-based index in range [0, max_top_k).
+    k_index = k.sub_(1).unsqueeze(1)
+    top_k_mask = logits.topk(max_top_k, dim=1).values.gather(1, k_index.long())
+    # Handle non-topk rows.
+    top_k_mask.masked_fill_(no_top_k_mask.unsqueeze(1), -float("inf"))
+    logits.masked_fill_(logits < top_k_mask, -float("inf"))
+    return logits
+    
+def apply_top_k_top_p(
+    logits: torch.Tensor,
+    k: Optional[torch.Tensor],
+    p: Optional[torch.Tensor],
+) -> torch.Tensor:
+    """Apply top-k and top-p masks to the logits.
+
+    If a top-p is used, this function will sort the logits tensor,
+    which can be slow for large batches.
+
+    The logits tensor may be updated in-place.
+    """
+    if p is None:
+        if k is None:
+            return logits
+
+        # Avoid sorting vocab for top-k only case.
+        return apply_top_k_only(logits, k)
+
+    logits_sort, logits_idx = logits.sort(dim=-1, descending=False)
+
+    if k is not None:
+        # Apply top-k.
+        top_k_mask = logits_sort.size(1) - k.to(torch.long)  # shape: B
+        # Get all the top_k values.
+        top_k_mask = logits_sort.gather(1, top_k_mask.unsqueeze(dim=1))
+        top_k_mask = logits_sort < top_k_mask
+        logits_sort.masked_fill_(top_k_mask, -float("inf"))
+
+    if p is not None:
+        # Apply top-p.
+        probs_sort = logits_sort.softmax(dim=-1)
+        probs_sum = torch.cumsum(probs_sort, dim=-1, out=probs_sort)
+        top_p_mask = probs_sum <= 1 - p.unsqueeze(dim=1)
+        # at least one
+        top_p_mask[:, -1] = False
+        logits_sort.masked_fill_(top_p_mask, -float("inf"))
+
+    # Re-sort the probabilities.
+    logits = logits_sort.scatter(dim=-1, index=logits_idx, src=logits_sort)
+    return logits
+
+def _sample_next_token(
+    logits_BCxV: torch.Tensor,
+    temperature: float,
+    top_p: float,
+    top_k: int
+): 
+    if temperature in [0, None]:
+        return torch.argmax(logits_BCxV, dim=-1)
+    
+    logits_BCxV = logits_BCxV / temperature
+    logits = apply_top_k_top_p(logits_BCxV, torch.tensor([top_k]), torch.tensor([top_p]))
+    
+    final_probs_BCxV = torch.softmax(logits, dim=-1)
+
+    sampled_indices_BC = torch.multinomial(final_probs_BCxV, num_samples=1)
+    sampled_indices_C = sampled_indices_BC.squeeze(-1)
+    return sampled_indices_C
+    
+# def _sample_next_token(
+#     logits_BCxV: torch.Tensor,
+#     temperature: float,
+#     top_p: float,
+#     top_k: int,
+#     audio_eos_value: int,
+# ) -> torch.Tensor:
+#     if temperature == 0.0:
+#         return torch.argmax(logits_BCxV, dim=-1)
+
+#     logits_BCxV = logits_BCxV / temperature
+
+#     if audio_eos_value is not None and audio_eos_value >= 0:
+#         top_logit_indices_BC = torch.argmax(logits_BCxV, dim=-1)
+#         eos_not_highest_mask_BC = top_logit_indices_BC != audio_eos_value
+#         mask_eos_unless_highest_BCxV = torch.zeros_like(logits_BCxV, dtype=torch.bool)
+#         mask_eos_unless_highest_BCxV[eos_not_highest_mask_BC, audio_eos_value] = True
+#         logits_BCxV = logits_BCxV.masked_fill(mask_eos_unless_highest_BCxV, -torch.inf)
+
+#     if top_k is not None:
+#         _, top_k_indices_BCxV = torch.topk(logits_BCxV, k=top_k, dim=-1)
+#         mask = torch.ones_like(logits_BCxV, dtype=torch.bool)
+#         mask = mask.scatter(dim=-1, index=top_k_indices_BCxV, value=False)
+#         logits_BCxV = logits_BCxV.masked_fill(mask, -torch.inf)
+
+#     if top_p < 1.0:
+#         probs_BCxV = torch.softmax(logits_BCxV, dim=-1)
+#         sorted_probs_BCxV, sorted_indices_BCxV = torch.sort(probs_BCxV, dim=-1, descending=True)
+#         cumulative_probs_BCxV = torch.cumsum(sorted_probs_BCxV, dim=-1)
+
+#         sorted_indices_to_remove_BCxV = cumulative_probs_BCxV > top_p
+#         sorted_indices_to_remove_BCxV = torch.roll(sorted_indices_to_remove_BCxV, shifts=1, dims=-1)
+#         sorted_indices_to_remove_BCxV[..., 0] = torch.zeros_like(sorted_indices_to_remove_BCxV[..., 0])
+
+#         indices_to_remove_BCxV = torch.zeros_like(sorted_indices_to_remove_BCxV)
+#         indices_to_remove_BCxV = indices_to_remove_BCxV.scatter(
+#             dim=-1, index=sorted_indices_BCxV, src=sorted_indices_to_remove_BCxV
+#         )
+#         logits_BCxV = logits_BCxV.masked_fill(indices_to_remove_BCxV, -torch.inf)
+
+#     final_probs_BCxV = torch.softmax(logits_BCxV, dim=-1)
+
+#     sampled_indices_BC = torch.multinomial(final_probs_BCxV, num_samples=1)
+#     sampled_indices_C = sampled_indices_BC.squeeze(-1)
+#     return sampled_indices_C
+
+    
+    # @torch.no_grad()
+#     def generate(
+#         self,
+#         enc_in: torch.Tensor,
+#         temperature: float,
+#         top_p: float,
+#         top_k: int,
+#         output_attentions=False) : 
+
+#         enc_in_uncond = torch.zeros_like(enc_in)
+#         enc_in = torch.cat((enc_in, enc_in_uncond), dim=0) # [B, T]
+#         enc_state = EncoderInferenceState.new(self.config, enc_in)
+#         enc_out = self.encoder(enc_in, enc_state)
+        
+#         dec_in = torch.tensor([4096], device=enc_in.device).long().unsqueeze(0)
+#         dec_in_uncond = torch.tensor([4096], device=enc_in.device).long().unsqueeze(0)
+#         dec_in = torch.cat((dec_in, dec_in_uncond), dim=0)
+        
+#         dec_state = DecoderInferenceState.new(
+#             self.config, enc_state, enc_out, dec_in
+#         )
+#         dec_state.cross_attn_mask = dec_state.cross_attn_mask[:,:,[0], :]
+#         # Masking CA for CFG
+#         dec_state.cross_attn_mask[-1,:,:, :] = False
+
+#         cnt = 0
+#         cross_attns = ()
+#         all_logits = ()
+#         while cnt < 34 : 
+#             dec_state.prepare_step(0, cnt+1)
+#             # Masking CA for CFG
+#             dec_state.cross_attn_mask[-1,:,:, :] = False
+#             out = self.decoder(dec_in, dec_state)
+#             cross_attns += (out.cross_attentions, )
+#             logits = out['logits']
+#             # print(logits.size())
+#             # print(logits[0])
+#             # print(logits[1])
+#             logits = logits[0] + self.config.model.cfg_val * (logits[0] - logits[1])
+#             # logits = logits[0]
+#             # print(logits.size())
+#             all_logits += (logits,)
+
+#             ntp = _sample_next_token(
+#                 logits.squeeze(1)[-1],
+#                 temperature=temperature,
+#                 top_k=top_k,
+#                 top_p=top_p,
+#                 audio_eos_value=4097)
+#             # print(dec_in.size(), ntp.size(), ntp)
+#             # dec_in = torch.cat((dec_in, ntp.unsqueeze(0).view(-1,1)), dim=1)
+
+#             dec_in = torch.cat((dec_in, torch.stack((ntp.unsqueeze(0), ntp.unsqueeze(0)))), dim=1)
+            
+#             if ntp.item() == 4097 : 
+#                 break
+#             cnt += 1
+#         return dec_in, all_logits, cross_attns
+        
+# def _sample_next_token(
+#     logits_BCxV: torch.Tensor,
+#     temperature: float,
+#     top_p: float,
+#     top_k: int,
+#     audio_eos_value: int,
+# ) -> torch.Tensor:
+#     if temperature == 0.0:
+#         return torch.argmax(logits_BCxV, dim=-1)
+
+#     logits_BCxV = logits_BCxV / temperature
+
+#     if audio_eos_value is not None and audio_eos_value >= 0:
+#         top_logit_indices_BC = torch.argmax(logits_BCxV, dim=-1)
+#         eos_not_highest_mask_BC = top_logit_indices_BC != audio_eos_value
+#         mask_eos_unless_highest_BCxV = torch.zeros_like(logits_BCxV, dtype=torch.bool)
+#         mask_eos_unless_highest_BCxV[eos_not_highest_mask_BC, audio_eos_value] = True
+#         logits_BCxV = logits_BCxV.masked_fill(mask_eos_unless_highest_BCxV, -torch.inf)
+
+#     if top_k is not None:
+#         _, top_k_indices_BCxV = torch.topk(logits_BCxV, k=top_k, dim=-1)
+#         mask = torch.ones_like(logits_BCxV, dtype=torch.bool)
+#         mask = mask.scatter(dim=-1, index=top_k_indices_BCxV, value=False)
+#         logits_BCxV = logits_BCxV.masked_fill(mask, -torch.inf)
+
+#     if top_p < 1.0:
+#         probs_BCxV = torch.softmax(logits_BCxV, dim=-1)
+#         sorted_probs_BCxV, sorted_indices_BCxV = torch.sort(probs_BCxV, dim=-1, descending=True)
+#         cumulative_probs_BCxV = torch.cumsum(sorted_probs_BCxV, dim=-1)
+
+#         sorted_indices_to_remove_BCxV = cumulative_probs_BCxV > top_p
+#         sorted_indices_to_remove_BCxV = torch.roll(sorted_indices_to_remove_BCxV, shifts=1, dims=-1)
+#         sorted_indices_to_remove_BCxV[..., 0] = torch.zeros_like(sorted_indices_to_remove_BCxV[..., 0])
+
+#         indices_to_remove_BCxV = torch.zeros_like(sorted_indices_to_remove_BCxV)
+#         indices_to_remove_BCxV = indices_to_remove_BCxV.scatter(
+#             dim=-1, index=sorted_indices_BCxV, src=sorted_indices_to_remove_BCxV
+#         )
+#         logits_BCxV = logits_BCxV.masked_fill(indices_to_remove_BCxV, -torch.inf)
+
+#     final_probs_BCxV = torch.softmax(logits_BCxV, dim=-1)
+
+#     sampled_indices_BC = torch.multinomial(final_probs_BCxV, num_samples=1)
+#     sampled_indices_C = sampled_indices_BC.squeeze(-1)
+#     return sampled_indices_C