model.py

import torch
import torch.nn as nn
import torch.nn.functional as F
from transformers import AutoModel

class AdaLNZero(nn.Module):
    def __init__(self, hidden_dim, cond_dim):
        super().__init__()
        self.norm = nn.LayerNorm(hidden_dim, elementwise_affine=False)
        self.proj = nn.Linear(cond_dim, 3 * hidden_dim)
        nn.init.zeros_(self.proj.weight)
        nn.init.zeros_(self.proj.bias)

    def forward(self, x, cond):
        params = self.proj(cond).unsqueeze(1)
        scale, shift, alpha = params.chunk(3, dim=-1)
        normalized = self.norm(x) * (1 + scale) + shift
        return normalized, alpha

class ModernBertLayerWithAdaLN(nn.Module):
    def __init__(self, pretrained_layer, hidden_dim, cond_dim):
        super().__init__()
        self.pretrained_layer = pretrained_layer
        self.cond_proj = nn.Linear(cond_dim, 6 * hidden_dim)
        nn.init.zeros_(self.cond_proj.weight)
        nn.init.zeros_(self.cond_proj.bias)
        
        # Tự động map đúng tên module của Qwen3
        self.attn_module = getattr(pretrained_layer, 'self_attn', getattr(pretrained_layer, 'attn', None))
        self.mlp_module = getattr(pretrained_layer, 'mlp', getattr(pretrained_layer, 'feed_forward', None))
        self.attn_norm = getattr(pretrained_layer, 'input_layernorm', getattr(pretrained_layer, 'attn_norm', nn.Identity()))
        self.mlp_norm = getattr(pretrained_layer, 'post_attention_layernorm', getattr(pretrained_layer, 'mlp_norm', nn.Identity()))

    def forward(self, hidden_states, cond, position_ids=None, attention_mask=None, position_embeddings=None):
        adaln_params = self.cond_proj(cond).unsqueeze(1)
        scale_attn, shift_attn, alpha_attn, scale_mlp, shift_mlp, alpha_mlp = adaln_params.chunk(6, dim=-1)
        
        # --- Attention Block ---
        normed_attn = self.attn_norm(hidden_states) * (1 + scale_attn) + shift_attn
        
        # Đóng gói kwargs an toàn để truyền cho Attention
        kwargs = {}
        if attention_mask is not None: kwargs['attention_mask'] = attention_mask
        if position_ids is not None: kwargs['position_ids'] = position_ids
        if position_embeddings is not None: kwargs['position_embeddings'] = position_embeddings
        
        attn_out = self.attn_module(normed_attn, **kwargs)
        attn_output = attn_out[0] if isinstance(attn_out, tuple) else attn_out
        hidden_states = hidden_states + (alpha_attn * attn_output)
        
        # --- MLP Block ---
        normed_mlp = self.mlp_norm(hidden_states) * (1 + scale_mlp) + shift_mlp
        mlp_out = self.mlp_module(normed_mlp)
        mlp_output = mlp_out[0] if isinstance(mlp_out, tuple) else mlp_out
        hidden_states = hidden_states + (alpha_mlp * mlp_output)
        
        return hidden_states

class ConditionalMDLM(nn.Module):
    def __init__(self, config):
        super().__init__()
        mc = config["model"]
        self.vocab_size = mc["vocab_size"]

        print(f"Loading pretrained backbone from {mc['pretrained_token_embeddings']}...")
        self.backbone = AutoModel.from_pretrained(mc["pretrained_token_embeddings"], trust_remote_code=True)
        
        # FIX CỐT LÕI: Tự động lấy kích thước chuẩn (1024) từ model gốc, bỏ qua khai báo sai trong yaml
        self.hidden_dim = self.backbone.config.hidden_size 
        self.cond_dim = mc["embedding_cond_dim"]
        print(f"Dynamically mapped: hidden_dim={self.hidden_dim}, cond_dim={self.cond_dim}")

        self.token_embed = self.backbone.get_input_embeddings()
        self.embed_norm = getattr(self.backbone, 'norm', nn.Identity())
        
        self.layers = nn.ModuleList([
            ModernBertLayerWithAdaLN(layer, self.hidden_dim, self.cond_dim)
            for layer in self.backbone.layers
        ])
        
        self.final_adaln = AdaLNZero(self.hidden_dim, self.cond_dim)
        self.output_proj = nn.Linear(self.hidden_dim, self.vocab_size, bias=False)
        
        if mc.get("tie_weights", True):
            self.output_proj.weight = self.token_embed.weight

    def _forward_impl(self, input_ids, cond_embedding, padding_mask, return_logits=False):
        device = input_ids.device
        batch_size, seq_len = input_ids.shape

        # 1. Chuẩn bị Attention Mask (Fix lõi SDPA dtype & Ép Bidirectional)
        if padding_mask is not None:
            # Chuyển sang bool: True = Attend (Giữ lại), False = PAD (Bỏ qua)
            attn_mask = (~padding_mask).bool() 
        else:
            attn_mask = torch.ones(batch_size, seq_len, dtype=torch.bool, device=device)
            
        # Mở rộng chiều thành [Batch, 1, 1, SeqLen] để broadcast với đa Head
        # Phải truyền mask này vào để tắt Causal Mask mặc định của Qwen3
        attn_mask = attn_mask.unsqueeze(1).unsqueeze(2)

        # 2. Chuẩn bị Position IDs
        pos_ids = torch.arange(seq_len, dtype=torch.long, device=device).unsqueeze(0).expand(batch_size, -1)

        # 3. Trích xuất RoPE đa năng
        pos_emb = None
        if hasattr(self.backbone, 'rotary_emb'):
            dummy_x = torch.empty(batch_size, seq_len, self.hidden_dim, device=device, dtype=torch.bfloat16)
            try:
                pos_emb = self.backbone.rotary_emb(dummy_x, pos_ids)
            except Exception:
                try:
                    pos_emb = self.backbone.rotary_emb(pos_ids)
                except Exception:
                    pass

        # 4. Forward Pass
        x = self.token_embed(input_ids)
        x = self.embed_norm(x)
        
        for layer in self.layers:
            # Đã truyền attn_mask chuẩn bool
            x = layer(x, cond_embedding, position_ids=pos_ids, attention_mask=attn_mask, position_embeddings=pos_emb)
            
        x, _ = self.final_adaln(x, cond_embedding)
        
        if return_logits:
            return self.output_proj(x)
        return x

    def forward(self, input_ids, cond_embedding, padding_mask=None):
        return self._forward_impl(input_ids, cond_embedding, padding_mask, return_logits=True)

    def forward_hidden(self, input_ids, cond_embedding, padding_mask=None):
        return self._forward_impl(input_ids, cond_embedding, padding_mask, return_logits=False)

    def count_params(self):
        total = sum(p.numel() for p in self.parameters())
        trainable = sum(p.numel() for p in self.parameters() if p.requires_grad)
        return total, trainable

def apply_mask(token_ids, mask_token_id, padding_mask=None):
    B, L = token_ids.shape
    device = token_ids.device
    u = torch.rand(B, 1, device=device)
    mask_ratio = (1 - (1 - 1e-3)**u).clamp(min=0.1, max=1.0)
    rand_scores = torch.rand(B, L, device=device)
    if padding_mask is not None:
        rand_scores[padding_mask] = 2.0
    target_mask = rand_scores < mask_ratio
    masked_ids = token_ids.clone()
    masked_ids[target_mask] = mask_token_id
    return masked_ids, target_mask, mask_ratio