GROMAIVN / model.py
GRIMIAI-VNAnhdev's picture
Upload 101 files
ea19761 verified
Raw History Blame
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