Download trainer_source/model.py from GRIMIAI-VNAnhdev/GROMAIVN: direct link, hf CLI and curl.
- Browser
- Download file 9.9 kB
-
https://huggingface.co/datasets/GRIMIAI-VNAnhdev/GROMAIVN/resolve/main/trainer_source/model.py
- Command line
-
hf download hf://datasets/GRIMIAI-VNAnhdev/GROMAIVN/trainer_source/model.py
-
curl -L -o model.py https://huggingface.co/datasets/GRIMIAI-VNAnhdev/GROMAIVN/resolve/main/trainer_source/model.py
9.9 kB
| """ | |
| model.py - GromGPT, kien truc kieu LLaMA de ho tro NGU CANH DAI. | |
| So voi ban cu (learned absolute position + nn.TransformerEncoder): | |
| - RoPE thay cho pos_emb hoc duoc -> khong con tran cung theo block_size, | |
| co the train/fine-tune o do dai lon hon ma khong doi tham so. | |
| - Attention dung F.scaled_dot_product_attention (Flash/mem-efficient) voi | |
| is_causal=True -> khong tao mask LxL, bo nho tang tuyen tinh theo L thay vi | |
| binh phuong. Day la dieu kien de train block 4096-32768 tren H100. | |
| - RMSNorm + SwiGLU, khong bias (giong LLaMA; llama.cpp ho tro san kien truc nay). | |
| - KV-cache cho sinh van ban: moi token moi chi tinh 1 vi tri thay vi ca chuoi. | |
| - Gradient checkpointing tuy chon (cat bo nho activation ~ n_layer lan). | |
| - Loss trung binh tren target hop le: batch bi mask hoan toan cho loss=0, khong NaN. | |
| API giu nguyen: GromGPT(vocab, block_size, n_embd, n_head, n_layer, dropout, vision) | |
| forward(idx, targets=None, images=None) -> (logits, loss). | |
| """ | |
| import math | |
| import torch | |
| import torch.nn as nn | |
| import torch.nn.functional as F | |
| from torch.utils.checkpoint import checkpoint | |
| from vision import ImageEncoder | |
| ARCH = "llama_rope_v2" | |
| class RMSNorm(nn.Module): | |
| def __init__(self, dim, eps=1e-6): | |
| super().__init__() | |
| self.eps = eps | |
| self.weight = nn.Parameter(torch.ones(dim)) | |
| def forward(self, x): | |
| xf = x.float() | |
| out = xf * torch.rsqrt(xf.pow(2).mean(-1, keepdim=True) + self.eps) | |
| return out.to(x.dtype) * self.weight | |
| def rope_cos_sin(head_dim, offset, length, theta, device): | |
| """cos/sin [length, head_dim/2] cho cac vi tri offset..offset+length-1 (tinh fp32).""" | |
| inv = 1.0 / (theta ** (torch.arange(0, head_dim, 2, device=device, dtype=torch.float32) / head_dim)) | |
| pos = torch.arange(offset, offset + length, device=device, dtype=torch.float32) | |
| freqs = torch.outer(pos, inv) | |
| return freqs.cos(), freqs.sin() | |
| def apply_rope(x, cos, sin): | |
| """x [B,H,T,hd]. Xoay trong fp32 roi tra ve dtype cu (bf16 o vi tri lon se mat do chinh xac).""" | |
| half = x.size(-1) // 2 | |
| xf = x.float() | |
| x1, x2 = xf[..., :half], xf[..., half:] | |
| out = torch.cat((x1 * cos - x2 * sin, x1 * sin + x2 * cos), dim=-1) | |
| return out.to(x.dtype) | |
| class Attention(nn.Module): | |
| def __init__(self, n_embd, n_head, dropout): | |
| super().__init__() | |
| assert n_embd % n_head == 0, "n_embd phai chia het cho n_head" | |
| self.n_head = n_head | |
| self.head_dim = n_embd // n_head | |
| assert self.head_dim % 2 == 0, "head_dim phai chan de dung RoPE" | |
| self.qkv = nn.Linear(n_embd, 3 * n_embd, bias=False) | |
| self.proj = nn.Linear(n_embd, n_embd, bias=False) | |
| self.dropout = dropout | |
| def forward(self, x, cos, sin, attn_mask=None, is_causal=False, past=None, use_cache=False): | |
| B, T, C = x.shape | |
| q, k, v = self.qkv(x).view(B, T, 3, self.n_head, self.head_dim).unbind(2) | |
| q, k, v = q.transpose(1, 2), k.transpose(1, 2), v.transpose(1, 2) # [B,H,T,hd] | |
| q = apply_rope(q, cos, sin) | |
| k = apply_rope(k, cos, sin) | |
| if past is not None: | |
| k = torch.cat([past[0], k], dim=2) | |
| v = torch.cat([past[1], v], dim=2) | |
| present = (k, v) if use_cache else None | |
| y = F.scaled_dot_product_attention( | |
| q, k, v, attn_mask=attn_mask, | |
| dropout_p=self.dropout if self.training else 0.0, | |
| is_causal=is_causal, | |
| ) | |
| y = y.transpose(1, 2).reshape(B, T, C) | |
| return self.proj(y), present | |
| class SwiGLU(nn.Module): | |
| def __init__(self, dim, hidden): | |
| super().__init__() | |
| self.w1 = nn.Linear(dim, hidden, bias=False) | |
| self.w3 = nn.Linear(dim, hidden, bias=False) | |
| self.w2 = nn.Linear(hidden, dim, bias=False) | |
| def forward(self, x): | |
| return self.w2(F.silu(self.w1(x)) * self.w3(x)) | |
| class Block(nn.Module): | |
| def __init__(self, n_embd, n_head, dropout): | |
| super().__init__() | |
| hidden = ((int(8 * n_embd / 3) + 63) // 64) * 64 | |
| self.attn_norm = RMSNorm(n_embd) | |
| self.attn = Attention(n_embd, n_head, dropout) | |
| self.ffn_norm = RMSNorm(n_embd) | |
| self.ffn = SwiGLU(n_embd, hidden) | |
| self.drop = nn.Dropout(dropout) | |
| def forward(self, x, cos, sin, attn_mask=None, is_causal=False, past=None, use_cache=False): | |
| a, present = self.attn(self.attn_norm(x), cos, sin, attn_mask, is_causal, past, use_cache) | |
| x = x + self.drop(a) | |
| x = x + self.drop(self.ffn(self.ffn_norm(x))) | |
| return x, present | |
| def _block_fwd(blk, x, cos, sin, attn_mask, is_causal): | |
| return blk(x, cos, sin, attn_mask, is_causal)[0] | |
| class GromGPT(nn.Module): | |
| arch = ARCH | |
| def __init__( | |
| self, | |
| vocab_size, | |
| block_size=192, | |
| n_embd=192, | |
| n_head=6, | |
| n_layer=5, | |
| dropout=0.05, | |
| vision=None, | |
| rope_theta=10000.0, | |
| gradient_checkpointing=False, | |
| ): | |
| super().__init__() | |
| self.block_size = block_size | |
| self.n_embd = n_embd | |
| self.n_head = n_head | |
| self.n_layer = n_layer | |
| self.head_dim = n_embd // n_head | |
| self.rope_theta = float(rope_theta) | |
| self.grad_ckpt = bool(gradient_checkpointing) | |
| self.token_emb = nn.Embedding(vocab_size, n_embd) | |
| self.drop = nn.Dropout(dropout) | |
| self.blocks = nn.ModuleList([Block(n_embd, n_head, dropout) for _ in range(n_layer)]) | |
| self.norm = RMSNorm(n_embd) | |
| self.head = nn.Linear(n_embd, vocab_size, bias=False) | |
| self.head.weight = self.token_emb.weight | |
| # Nhanh anh (tuy chon). vision=None -> model chi xu ly van ban. | |
| self.vision_cfg = dict(vision) if vision else None | |
| self.n_img_tokens = int(vision.get("n_img_tokens", 16)) if vision else 0 | |
| self.image_encoder = ImageEncoder(n_embd, dropout=dropout, **vision) if vision else None | |
| self.apply(self._init_weights) | |
| # Khoi tao residual-projection nho hon (GPT-2/LLaMA) de on dinh khi sau 24+ lop. | |
| res_std = 0.02 / math.sqrt(2 * n_layer) | |
| for blk in self.blocks: | |
| nn.init.normal_(blk.attn.proj.weight, mean=0.0, std=res_std) | |
| nn.init.normal_(blk.ffn.w2.weight, mean=0.0, std=res_std) | |
| def _init_weights(self, module): | |
| if isinstance(module, (nn.Linear, nn.Embedding)): | |
| nn.init.normal_(module.weight, mean=0.0, std=0.02) | |
| if isinstance(module, nn.Linear) and module.bias is not None: | |
| nn.init.zeros_(module.bias) | |
| def encode_image(self, images): | |
| """[B,3,S,S] -> [B, n_img_tokens, n_embd].""" | |
| if self.image_encoder is None: | |
| raise RuntimeError("Model nay duoc tao khong co nhanh anh (vision=None).") | |
| return self.image_encoder(images) | |
| def forward(self, idx, targets=None, images=None, past_kv=None, use_cache=False): | |
| """idx [B,T]. images [B,3,S,S] hoac None. | |
| Train / prefill: past_kv=None. Co images -> chuoi la [token anh | token van ban], | |
| token anh nhin nhau (khong nhan qua), van ban nhin moi anh. Loss chi tren van ban, | |
| logits tra ve chi gom vi tri van ban. | |
| Decode: truyen past_kv (tu lan goi truoc voi use_cache=True) va idx [B,1]. | |
| use_cache=True tra ve (logits, loss, present_kv). | |
| """ | |
| B, T = idx.shape | |
| n_img = 0 | |
| img_tok = None | |
| if past_kv is not None: | |
| if images is not None: | |
| raise ValueError("images chi dung o buoc prefill (past_kv=None).") | |
| if T != 1: | |
| raise ValueError("Co past_kv thi moi lan chi nap dung 1 token.") | |
| past_len = past_kv[0][0].size(2) | |
| else: | |
| past_len = 0 | |
| if images is not None: | |
| img_tok = self.encode_image(images) | |
| n_img = img_tok.size(1) | |
| text_max = self.block_size - n_img | |
| if text_max < 1: | |
| raise ValueError(f"n_img_tokens={n_img} >= block_size={self.block_size}") | |
| if T > text_max: | |
| idx = idx[:, -text_max:] | |
| T = text_max | |
| if targets is not None: | |
| targets = targets[:, -text_max:] | |
| tok = self.token_emb(idx) | |
| if img_tok is not None: | |
| tok = torch.cat([img_tok.to(tok.dtype), tok], dim=1) | |
| x = self.drop(tok) | |
| L = n_img + T | |
| cos, sin = rope_cos_sin(self.head_dim, past_len, L, self.rope_theta, idx.device) | |
| attn_mask, is_causal = None, False | |
| if past_kv is None: | |
| if n_img: | |
| attn_mask = torch.ones(L, L, dtype=torch.bool, device=idx.device).tril() | |
| attn_mask[:n_img, :n_img] = True | |
| else: | |
| is_causal = True | |
| presents = [] if use_cache else None | |
| use_ckpt = self.grad_ckpt and self.training and not use_cache and torch.is_grad_enabled() | |
| for i, blk in enumerate(self.blocks): | |
| if use_ckpt: | |
| x = checkpoint(_block_fwd, blk, x, cos, sin, attn_mask, is_causal, use_reentrant=False) | |
| else: | |
| x, pres = blk(x, cos, sin, attn_mask, is_causal, | |
| past_kv[i] if past_kv is not None else None, use_cache) | |
| if use_cache: | |
| presents.append(pres) | |
| x = self.norm(x) | |
| if n_img: | |
| x = x[:, n_img:, :] | |
| logits = self.head(x) | |
| loss = None | |
| if targets is not None: | |
| # Trung binh tren target hop le (!= -100). Batch bi mask het -> loss=0, khong NaN. | |
| flat_t = targets.reshape(-1) | |
| n_valid = (flat_t != -100).sum().clamp(min=1) | |
| loss = F.cross_entropy( | |
| logits.reshape(-1, logits.size(-1)), flat_t, | |
| ignore_index=-100, reduction="sum", | |
| ) / n_valid | |
| if use_cache: | |
| return logits, loss, presents | |
| return logits, loss | |