Custom_GPT_NN_ysnrfd/My_own_NN_GPT.py

"""
LICENSE:

Copyright 2025 ysnrfd

Timestamp: 2025-08-12

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to use,
copy, modify, and distribute the Software, subject to the following conditions:

1. The copyright notice, this permission notice, and all attribution information
   regarding the original author (ysnrfd) must be preserved in their entirety
   and must not be removed, altered, or obscured in any copies or derivative works.

2. Any modifications or derivative works must be clearly documented in a "CHANGELOG" or
   "NOTICE" file included with the Software. This documentation must include a detailed
   description of the changes made, the date of the modification, and the identity of
   the modifier.

3. The Software is provided "as is", without warranty of any kind, express or implied.
   The author shall not be liable for any damages arising from use of the Software.

4. Any attempt to remove or alter the original attribution or copyright information
   constitutes a violation of this license and may result in legal action.

"""

import math
import numpy as np
import pickle
import os
import time
from typing import List, Tuple, Dict, Any, Optional, Union
import warnings
DEFAULT_DTYPE = np.float32
EPS = 1e-6

def softmax(x: np.ndarray, axis: int = -1, eps: float = EPS) -> np.ndarray:
    x = x - np.max(x, axis=axis, keepdims=True)
    e = np.exp(x)
    return e / (np.sum(e, axis=axis, keepdims=True) + eps)

def gelu(x: np.ndarray) -> np.ndarray:
    return 0.5 * x * (1.0 + np.tanh(np.sqrt(2.0 / np.pi) * (x + 0.044715 * x**3)))

def gelu_exact(x: np.ndarray) -> np.ndarray:
    return 0.5 * x * (1.0 + math.erf(x / np.sqrt(2.0)))

def gelu_grad(x: np.ndarray) -> np.ndarray:
    tanh_term = np.tanh(np.sqrt(2.0 / np.pi) * (x + 0.044715 * x**3))
    sech2 = 1.0 - tanh_term**2
    return 0.5 * (1.0 + tanh_term) + 0.5 * x * sech2 * np.sqrt(2.0 / np.pi) * (1.0 + 3.0 * 0.044715 * x**2)

def rms_norm(x: np.ndarray, weight: np.ndarray, eps: float = EPS) -> np.ndarray:
    rms = np.sqrt(np.mean(x**2, axis=-1, keepdims=True) + eps)
    return weight * (x / rms)

class BPETokenizer:
    def __init__(self):
        self.vocab: List[str] = []
        self.w2i: Dict[str, int] = {}
        self.i2w: Dict[int, str] = {}
        self.merges: List[Tuple[str, str]] = []
        self.cache: Dict[str, List[str]] = {}
        self.special_tokens: List[str] = ['<pad>', '<unk>', '<bos>', '<eos>']

    @staticmethod
    def get_pairs(word: Tuple[str, ...]) -> Set[Tuple[str, str]]:
        return set(zip(word, word[1:]))

    @staticmethod
    def bytes_to_unicode() -> Dict[int, str]:
        bs = list(range(ord("!"), ord("~") + 1)) + \
             list(range(ord("¡"), ord("¬") + 1)) + \
             list(range(ord("®"), ord("ÿ") + 1))
        cs = bs[:]
        n = 0
        for b in range(2**8):
            if b not in bs:
                bs.append(b)
                cs.append(2**8 + n)
                n += 1
        cs = [chr(n) for n in cs]
        return dict(zip(bs, cs))

    def preprocess(self, text: str) -> str:
        byte_encoder = self.bytes_to_unicode()
        text_bytes = text.encode("utf-8")
        return "".join([byte_encoder[b] for b in text_bytes])

    def build_from_text(self, texts: List[str], vocab_size: int = 500, min_freq: int = 2):
        preprocessed = [self.preprocess(text) for text in texts]
        char_freq = {}
        for text in preprocessed:
            for char in text:
                char_freq[char] = char_freq.get(char, 0) + 1
        self.vocab = self.special_tokens + sorted(char_freq.keys(), key=lambda x: -char_freq[x])
        self.w2i = {w: i for i, w in enumerate(self.vocab)}
        self.i2w = {i: w for w, i in self.w2i.items()}
        if len(self.vocab) < vocab_size:
            words = []
            for text in preprocessed:
                words.extend([' '.join(text)])
            word_freq = {}
            for word in words:
                word_freq[word] = word_freq.get(word, 0) + 1
            num_merges = vocab_size - len(self.vocab)
            for i in range(num_merges):
                pairs = {}
                for word, freq in word_freq.items():
                    chars = word.split()
                    for j in range(len(chars) - 1):
                        pair = (chars[j], chars[j+1])
                        pairs[pair] = pairs.get(pair, 0) + freq
                if not pairs:
                    break
                best_pair = max(pairs, key=pairs.get)
                new_token = ''.join(best_pair)
                if new_token not in self.w2i:
                    self.vocab.append(new_token)
                    self.w2i[new_token] = len(self.vocab) - 1
                    self.i2w[len(self.vocab) - 1] = new_token
                    self.merges.append(best_pair)
                new_word_freq = {}
                for word, freq in word_freq.items():
                    new_word = word.replace(' '.join(best_pair), new_token)
                    new_word_freq[new_word] = freq
                word_freq = new_word_freq

    def encode(self, text: str, max_len: int = None, add_bos: bool = False, add_eos: bool = False) -> np.ndarray:
        text = self.preprocess(text)
        if add_bos:
            text = self.special_tokens[2] + text
        if add_eos:
            text = text + self.special_tokens[3]
        if text in self.cache:
            tokens = self.cache[text]
        else:
            tokens = list(text)
            for pair in self.merges:
                new_tokens = []
                i = 0
                while i < len(tokens):
                    if i < len(tokens) - 1 and tokens[i] == pair[0] and tokens[i+1] == pair[1]:
                        new_tokens.append(pair[0] + pair[1])
                        i += 2
                    else:
                        new_tokens.append(tokens[i])
                        i += 1
                tokens = new_tokens
            self.cache[text] = tokens
        ids = [self.w2i.get(t, self.w2i['<unk>']) for t in tokens]
        if max_len is not None and len(ids) > max_len:
            ids = ids[:max_len]
        if max_len is not None and len(ids) < max_len:
            ids = ids + [self.w2i['<pad>']] * (max_len - len(ids))
        return np.array(ids, dtype=np.int32)

    def decode(self, ids: Union[np.ndarray, List[int]]) -> str:
        tokens = [self.i2w.get(int(i), '<unk>') for i in ids]
        text = ''.join(tokens)
        for token in self.special_tokens:
            text = text.replace(token, '')
        byte_decoder = {v: k for k, v in self.bytes_to_unicode().items()}
        text_bytes = bytearray([byte_decoder[c] for c in text])
        return text_bytes.decode('utf-8', errors='replace')

class Embedding:
    def __init__(self, vocab_size: int, d_model: int, dtype=DEFAULT_DTYPE):
        self.vocab_size = vocab_size
        self.d_model = d_model
        self.dtype = dtype
        scale = 1.0 / np.sqrt(d_model)
        self.W = np.random.normal(0, scale, (vocab_size, d_model)).astype(dtype)
        self.grad_W = np.zeros_like(self.W)

    def forward(self, idx: np.ndarray) -> np.ndarray:
        return self.W[idx]

    def backward(self, idx: np.ndarray, grad: np.ndarray):
        np.add.at(self.grad_W, idx, grad)

class PositionalEmbedding:
    def __init__(self, max_len: int, d_model: int, use_rotary: bool = False, dtype=DEFAULT_DTYPE):
        self.max_len = max_len
        self.d_model = d_model
        self.use_rotary = use_rotary
        self.dtype = dtype
        if not use_rotary:
            self.W = np.zeros((max_len, d_model), dtype=dtype)
            for pos in range(max_len):
                for i in range(0, d_model, 2):
                    self.W[pos, i] = math.sin(pos / (10000 ** (i / d_model)))
                    if i + 1 < d_model:
                        self.W[pos, i + 1] = math.cos(pos / (10000 ** (i / d_model)))
            self.grad_W = np.zeros_like(self.W)
        else:
            self.rotary_freqs = self._create_rotary_frequencies()

    def _create_rotary_frequencies(self) -> np.ndarray:
        inv_freq = 1.0 / (10000 ** (np.arange(0, self.d_model, 2, dtype=self.dtype) / self.d_model))
        return inv_freq

    def apply_rotary_pos_emb(self, x: np.ndarray, seq_dim: int = -2) -> np.ndarray:
        seq_len = x.shape[seq_dim]
        t = np.arange(seq_len, dtype=self.dtype)
        freqs = np.outer(t, self.rotary_freqs)
        cos = np.cos(freqs)
        sin = np.sin(freqs)
        x1 = x[..., 0::2]
        x2 = x[..., 1::2]
        x_rotated1 = x1 * cos - x2 * sin
        x_rotated2 = x1 * sin + x2 * cos
        x_rotated = np.zeros_like(x)
        x_rotated[..., 0::2] = x_rotated1
        x_rotated[..., 1::2] = x_rotated2
        return x_rotated

    def forward(self, seq_len: int) -> np.ndarray:
        if not self.use_rotary:
            return self.W[:seq_len][np.newaxis, :, :]
        return None

    def backward(self, seq_len: int, grad: np.ndarray):
        if not self.use_rotary:
            np.add.at(self.grad_W, np.arange(seq_len), np.sum(grad, axis=0))

class LayerNorm:
    def __init__(self, d_model: int, eps: float = EPS, rms_norm: bool = False, dtype=DEFAULT_DTYPE):
        self.d_model = d_model
        self.eps = eps
        self.rms_norm = rms_norm
        self.dtype = dtype
        if not rms_norm:
            self.gamma = np.ones((1, 1, d_model), dtype=dtype)
            self.beta = np.zeros((1, 1, d_model), dtype=dtype)
            self.grad_gamma = np.zeros_like(self.gamma)
            self.grad_beta = np.zeros_like(self.beta)
        else:
            self.weight = np.ones((1, 1, d_model), dtype=dtype)
            self.grad_weight = np.zeros_like(self.weight)
        self.x = None
        self.mean = None
        self.var = None
        self.x_norm = None

    def forward(self, x: np.ndarray) -> np.ndarray:
        self.x = x
        if self.rms_norm:
            rms = np.sqrt(np.mean(x**2, axis=-1, keepdims=True) + self.eps)
            self.x_norm = x / rms
            return self.weight * self.x_norm
        else:
            self.mean = np.mean(x, axis=-1, keepdims=True)
            self.var = np.var(x, axis=-1, keepdims=True)
            self.x_norm = (x - self.mean) / np.sqrt(self.var + self.eps)
            return self.gamma * self.x_norm + self.beta

    def backward(self, grad: np.ndarray) -> np.ndarray:
        if self.rms_norm:
            grad_x_norm = grad * self.weight
            x_norm2 = self.x_norm ** 2
            d_rms = -np.sum(grad_x_norm * self.x_norm, axis=-1, keepdims=True) / np.sqrt(np.mean(x_norm2, axis=-1, keepdims=True) + self.eps)
            d_x = (grad_x_norm - self.x_norm * d_rms) / self.x_norm.shape[-1]
            self.grad_weight = np.sum(grad * self.x_norm, axis=(0, 1), keepdims=True)
            return d_x
        else:
            b, s, d = grad.shape
            self.grad_gamma = np.sum(grad * self.x_norm, axis=(0, 1), keepdims=True)
            self.grad_beta = np.sum(grad, axis=(0, 1), keepdims=True)
            dx_norm = grad * self.gamma
            var_eps = self.var + self.eps
            dx = (1. / np.sqrt(var_eps)) * (dx_norm - np.mean(dx_norm, axis=-1, keepdims=True) - 
                        self.x_norm * np.mean(dx_norm * self.x_norm, axis=-1, keepdims=True))
            return dx

class FeedForward:
    def __init__(self, d_model: int, d_ff: int, dropout: float = 0.1, dtype=DEFAULT_DTYPE):
        self.d_model = d_model
        self.d_ff = d_ff
        self.dropout = dropout
        self.dtype = dtype
        scale_in = 1.0 / np.sqrt(d_model)
        scale_out = 1.0 / np.sqrt(d_ff)
        self.W1 = np.random.normal(0, scale_in, (d_model, d_ff)).astype(dtype)
        self.b1 = np.zeros((1, 1, d_ff), dtype=dtype)
        self.W2 = np.random.normal(0, scale_out, (d_ff, d_model)).astype(dtype)
        self.b2 = np.zeros((1, 1, d_model), dtype=dtype)
        self.grad_W1 = np.zeros_like(self.W1)
        self.grad_b1 = np.zeros_like(self.b1)
        self.grad_W2 = np.zeros_like(self.W2)
        self.grad_b2 = np.zeros_like(self.b2)
        self.x = None
        self.hidden = None
        self.hidden_act = None
        self.dropout_mask1 = None
        self.dropout_mask2 = None

    def forward(self, x: np.ndarray, training: bool = True) -> np.ndarray:
        self.x = x
        b, s, d = x.shape
        self.hidden = x @ self.W1 + self.b1
        self.hidden_act = gelu(self.hidden)
        if training and self.dropout > 0:
            self.dropout_mask1 = (np.random.rand(*self.hidden_act.shape) > self.dropout)
            self.hidden_act = self.hidden_act * self.dropout_mask1 / (1 - self.dropout)
        else:
            self.dropout_mask1 = None
        out = self.hidden_act @ self.W2 + self.b2
        if training and self.dropout > 0:
            self.dropout_mask2 = (np.random.rand(*out.shape) > self.dropout)
            out = out * self.dropout_mask2 / (1 - self.dropout)
        else:
            self.dropout_mask2 = None
        return out

    def backward(self, grad: np.ndarray) -> np.ndarray:
        b, s, d = grad.shape
        if self.dropout_mask2 is not None:
            grad = grad * self.dropout_mask2
        self.grad_W2 = (self.hidden_act.reshape(-1, self.d_ff).T @ grad.reshape(-1, d)).reshape(self.d_ff, d)
        self.grad_b2 = np.sum(grad, axis=(0, 1), keepdims=True)
        dhidden_act = grad @ self.W2.T
        if self.dropout_mask1 is not None:
            dhidden_act = dhidden_act * self.dropout_mask1
        dhidden = dhidden_act * gelu_grad(self.hidden)
        self.grad_W1 = (self.x.reshape(-1, self.d_model).T @ dhidden.reshape(-1, self.d_ff)).reshape(self.d_model, self.d_ff)
        self.grad_b1 = np.sum(dhidden, axis=(0, 1), keepdims=True)
        dx = dhidden @ self.W1.T
        return dx

class MultiHeadSelfAttention:
    def __init__(self, d_model: int, num_heads: int, dropout: float = 0.1, use_rotary: bool = False, dtype=DEFAULT_DTYPE):
        assert d_model % num_heads == 0, "d_model must be divisible by num_heads"
        self.d_model = d_model
        self.num_heads = num_heads
        self.head_dim = d_model // num_heads
        self.dropout = dropout
        self.use_rotary = use_rotary
        self.dtype = dtype
        scale = 1.0 / np.sqrt(d_model)
        self.W_q = np.random.normal(0, scale, (d_model, d_model)).astype(dtype)
        self.W_k = np.random.normal(0, scale, (d_model, d_model)).astype(dtype)
        self.W_v = np.random.normal(0, scale, (d_model, d_model)).astype(dtype)
        self.W_o = np.random.normal(0, scale, (d_model, d_model)).astype(dtype)
        self.grad_W_q = np.zeros_like(self.W_q)
        self.grad_W_k = np.zeros_like(self.W_k)
        self.grad_W_v = np.zeros_like(self.W_v)
        self.grad_W_o = np.zeros_like(self.W_o)
        self.cache = {}
        self.dropout_mask = None

    def split_heads(self, x: np.ndarray) -> np.ndarray:
        b, s, d = x.shape
        x = x.reshape(b, s, self.num_heads, self.head_dim)
        return np.transpose(x, (0, 2, 1, 3))

    def combine_heads(self, x: np.ndarray) -> np.ndarray:
        x = np.transpose(x, (0, 2, 1, 3))
        b, s, h, hd = x.shape
        return x.reshape(b, s, h * hd)

    def causal_mask(self, seq_len: int) -> np.ndarray:
        return np.tril(np.ones((seq_len, seq_len), dtype=bool))

    def apply_rotary_embeddings(self, q: np.ndarray, k: np.ndarray, seq_dim: int = -2) -> Tuple[np.ndarray, np.ndarray]:
        q_rotated = PositionalEmbedding.apply_rotary_pos_emb(q, seq_dim=seq_dim)
        k_rotated = PositionalEmbedding.apply_rotary_pos_emb(k, seq_dim=seq_dim)
        return q_rotated, k_rotated

    def forward(self, x: np.ndarray, training: bool = True) -> np.ndarray:
        b, s, d = x.shape
        Q = x @ self.W_q
        K = x @ self.W_k
        V = x @ self.W_v
        Qh = self.split_heads(Q)
        Kh = self.split_heads(K)
        Vh = self.split_heads(V)
        if self.use_rotary:
            Qh, Kh = self.apply_rotary_embeddings(Qh, Kh)
        dk = self.head_dim
        scores = Qh @ np.swapaxes(Kh, -1, -2) / np.sqrt(dk)
        mask = self.causal_mask(s)[np.newaxis, np.newaxis, :, :]
        scores = np.where(mask, scores, -np.inf)
        attn = softmax(scores, axis=-1)
        if training and self.dropout > 0:
            self.dropout_mask = (np.random.rand(*attn.shape) > self.dropout)
            attn = attn * self.dropout_mask / (1 - self.dropout)
        else:
            self.dropout_mask = None
        attn_out = attn @ Vh
        out = self.combine_heads(attn_out) @ self.W_o
        self.cache = {
            'x': x, 'Q': Q, 'K': K, 'V': V,
            'Qh': Qh, 'Kh': Kh, 'Vh': Vh,
            'scores': scores, 'attn': attn, 'attn_out': attn_out,
            'mask': mask
        }
        return out

    def backward(self, grad_out: np.ndarray) -> np.ndarray:
        x = self.cache['x']
        Qh = self.cache['Qh']
        Kh = self.cache['Kh']
        Vh = self.cache['Vh']
        attn = self.cache['attn']
        attn_out = self.cache['attn_out']
        mask = self.cache['mask']
        b, s, d = grad_out.shape
        dk = self.head_dim
        if self.dropout_mask is not None:
            attn = attn * self.dropout_mask
        out_concat = self.combine_heads(attn_out)
        self.grad_W_o = out_concat.reshape(-1, d).T @ grad_out.reshape(-1, d)
        d_out_concat = grad_out @ self.W_o.T
        d_attn_out = d_out_concat.reshape(b, s, self.num_heads, self.head_dim)
        d_attn_out = np.transpose(d_attn_out, (0, 2, 1, 3))
        dVh = np.matmul(np.swapaxes(attn, -1, -2), d_attn_out)
        dattn = np.matmul(d_attn_out, np.swapaxes(Vh, -1, -2))
        sft = attn
        sum_d = np.sum(dattn * sft, axis=-1, keepdims=True)
        dscores = sft * (dattn - sum_d)
        dscores = np.where(mask, dscores, 0.0)
        dQh = np.matmul(dscores, Kh) / np.sqrt(dk)
        dKh = np.matmul(np.swapaxes(dscores, -1, -2), Qh) / np.sqrt(dk)
        dQ = np.transpose(dQh, (0, 2, 1, 3)).reshape(b, s, d)
        dK = np.transpose(dKh, (0, 2, 1, 3)).reshape(b, s, d)
        dV = np.transpose(dVh, (0, 2, 1, 3)).reshape(b, s, d)
        self.grad_W_q = x.reshape(-1, d).T @ dQ.reshape(-1, d)
        self.grad_W_k = x.reshape(-1, d).T @ dK.reshape(-1, d)
        self.grad_W_v = x.reshape(-1, d).T @ dV.reshape(-1, d)
        dx_q = dQ @ self.W_q.T
        dx_k = dK @ self.W_k.T
        dx_v = dV @ self.W_v.T
        dx = dx_q + dx_k + dx_v
        return dx

class DecoderBlock:
    def __init__(self, d_model: int, num_heads: int, d_ff: int, dropout: float = 0.1, 
                 layer_scale: bool = False, layer_scale_init: float = 1e-4, use_rotary: bool = False):
        self.mha = MultiHeadSelfAttention(d_model, num_heads, dropout, use_rotary)
        self.ln1 = LayerNorm(d_model, rms_norm=False)
        self.ff = FeedForward(d_model, d_ff, dropout)
        self.ln2 = LayerNorm(d_model, rms_norm=False)
        self.dropout = dropout
        self.layer_scale = layer_scale
        self.layer_scale_init = layer_scale_init
        if layer_scale:
            self.gamma1 = np.ones((1, 1, d_model)) * layer_scale_init
            self.gamma2 = np.ones((1, 1, d_model)) * layer_scale_init

    def forward(self, x: np.ndarray, training: bool = True) -> np.ndarray:
        attn_out = self.mha.forward(x, training)
        if self.layer_scale:
            attn_out = attn_out * self.gamma1
        x = x + attn_out
        x = self.ln1.forward(x)
        ff_out = self.ff.forward(x, training)
        if self.layer_scale:
            ff_out = ff_out * self.gamma2
        x = x + ff_out
        x = self.ln2.forward(x)
        return x

    def backward(self, grad: np.ndarray) -> np.ndarray:
        d_ln2 = self.ln2.backward(grad)
        d_ff = self.ff.backward(d_ln2)
        if self.layer_scale:
            d_ff = d_ff * self.gamma2
        d_res = d_ln2 + d_ff
        d_ln1 = self.ln1.backward(d_res)
        d_mha = self.mha.backward(d_ln1)
        if self.layer_scale:
            d_mha = d_mha * self.gamma1
        dx = d_mha + d_ln1
        return dx

class GPT:
    def __init__(self, vocab_size: int, max_len: int = 512, d_model: int = 768, num_heads: int = 12, 
                 d_ff: int = 3072, num_layers: int = 12, dropout: float = 0.1, 
                 use_rotary: bool = False, rms_norm: bool = False, layer_scale: bool = False,
                 dtype=DEFAULT_DTYPE):
        self.vocab_size = vocab_size
        self.max_len = max_len
        self.d_model = d_model
        self.dtype = dtype
        self.embed = Embedding(vocab_size, d_model, dtype)
        self.pos_embed = PositionalEmbedding(max_len, d_model, use_rotary, dtype)
        self.layers = [
            DecoderBlock(d_model, num_heads, d_ff, dropout, layer_scale, use_rotary=use_rotary)
            for _ in range(num_layers)
        ]
        self.ln_f = LayerNorm(d_model, rms_norm=rms_norm, dtype=dtype)
        self.dropout = dropout
        self.W_out = np.random.normal(0, 1.0 / np.sqrt(d_model), (d_model, vocab_size)).astype(dtype)
        self.grad_W_out = np.zeros_like(self.W_out)
        self.opt_states = {}
        self.lr = 0.0
        self.beta1 = 0.0
        self.beta2 = 0.0
        self.eps = 0.0
        self.opt_step = 0
        self.training = True

    def parameters(self) -> List[Tuple[str, np.ndarray]]:
        params = []
        params.append(('embed.W', self.embed.W))
        if not self.pos_embed.use_rotary:
            params.append(('pos.W', self.pos_embed.W))
        for i, layer in enumerate(self.layers):
            params.append((f'layer{i}.mha.W_q', layer.mha.W_q))
            params.append((f'layer{i}.mha.W_k', layer.mha.W_k))
            params.append((f'layer{i}.mha.W_v', layer.mha.W_v))
            params.append((f'layer{i}.mha.W_o', layer.mha.W_o))
            params.append((f'layer{i}.ln1.gamma', layer.ln1.gamma))
            params.append((f'layer{i}.ln1.beta', layer.ln1.beta))
            params.append((f'layer{i}.ff.W1', layer.ff.W1))
            params.append((f'layer{i}.ff.b1', layer.ff.b1))
            params.append((f'layer{i}.ff.W2', layer.ff.W2))
            params.append((f'layer{i}.ff.b2', layer.ff.b2))
            params.append((f'layer{i}.ln2.gamma', layer.ln2.gamma))
            params.append((f'layer{i}.ln2.beta', layer.ln2.beta))
            if layer.layer_scale:
                params.append((f'layer{i}.gamma1', layer.gamma1))
                params.append((f'layer{i}.gamma2', layer.gamma2))
        if not self.ln_f.rms_norm:
            params.append(('ln_f.gamma', self.ln_f.gamma))
            params.append(('ln_f.beta', self.ln_f.beta))
        else:
            params.append(('ln_f.weight', self.ln_f.weight))
        params.append(('W_out', self.W_out))
        return params

    def zero_grads(self):
        self.embed.grad_W.fill(0.0)
        if not self.pos_embed.use_rotary:
            self.pos_embed.grad_W.fill(0.0)
        for layer in self.layers:
            layer.mha.grad_W_q.fill(0.0)
            layer.mha.grad_W_k.fill(0.0)
            layer.mha.grad_W_v.fill(0.0)
            layer.mha.grad_W_o.fill(0.0)
            layer.ln1.grad_gamma.fill(0.0)
            layer.ln1.grad_beta.fill(0.0)
            layer.ff.grad_W1.fill(0.0)
            layer.ff.grad_b1.fill(0.0)
            layer.ff.grad_W2.fill(0.0)
            layer.ff.grad_b2.fill(0.0)
            layer.ln2.grad_gamma.fill(0.0)
            layer.ln2.grad_beta.fill(0.0)
        if not self.ln_f.rms_norm:
            self.ln_f.grad_gamma.fill(0.0)
            self.ln_f.grad_beta.fill(0.0)
        else:
            self.ln_f.grad_weight.fill(0.0)
        self.grad_W_out.fill(0.0)

    def forward(self, idx: np.ndarray, training: bool = True) -> np.ndarray:
        self.training = training
        b, s = idx.shape
        x = self.embed.forward(idx)
        if not self.pos_embed.use_rotary:
            x = x + self.pos_embed.forward(s)
        for layer in self.layers:
            x = layer.forward(x, training)
        x = self.ln_f.forward(x)
        if training and self.dropout > 0:
            dropout_mask = (np.random.rand(*x.shape) > self.dropout)
            x = x * dropout_mask / (1 - self.dropout)
        logits = x.reshape(-1, self.d_model) @ self.W_out
        logits = logits.reshape(b, s, -1)
        self._cache = {'x': x, 'idx': idx}
        return logits

    def loss_and_backward(self, idx_in: np.ndarray, idx_target: np.ndarray, 
                          grad_clip: float = 1.0) -> float:
        b, s = idx_in.shape
        logits = self.forward(idx_in, training=True)
        vocab = logits.shape[-1]
        logits_flat = logits.reshape(-1, vocab)
        targets_flat = idx_target.reshape(-1)
        probs = softmax(logits_flat, axis=1)
        log_probs = np.log(np.clip(probs, 1e-12, 1.0))
        loss = -np.mean(log_probs[np.arange(len(targets_flat)), targets_flat])
        grad_logits = probs.copy()
        grad_logits[np.arange(grad_logits.shape[0]), targets_flat] -= 1
        grad_logits = grad_logits.reshape(b, s, vocab) / (b * s)
        x = self._cache['x']
        self.grad_W_out = x.reshape(-1, self.d_model).T @ grad_logits.reshape(-1, vocab)
        dx = grad_logits.reshape(-1, vocab) @ self.W_out.T
        dx = dx.reshape(b, s, self.d_model)
        d_ln = self.ln_f.backward(dx)
        grad = d_ln
        for layer in reversed(self.layers):
            grad = layer.backward(grad)
        idx = self._cache['idx']
        self.embed.backward(idx, grad)
        if not self.pos_embed.use_rotary:
            self.pos_embed.backward(s, grad)
        if grad_clip > 0:
            total_norm = 0.0
            for _, param in self.parameters():
                if param.grad is not None:
                    param_norm = np.linalg.norm(param.grad)
                    total_norm += param_norm ** 2
            total_norm = np.sqrt(total_norm)
            clip_coef = min(grad_clip / (total_norm + EPS), 1.0)
            if clip_coef < 1:
                for _, param in self.parameters():
                    if param.grad is not None:
                        param.grad *= clip_coef
        return loss

    def init_optimizer(self, lr: float = 6e-4, betas=(0.9, 0.95), eps=1e-8, 
                       weight_decay: float = 0.1, warmup_steps: int = 2000):
        self.lr = lr
        self.beta1 = betas[0]
        self.beta2 = betas[1]
        self.eps = eps
        self.weight_decay = weight_decay
        self.warmup_steps = warmup_steps
        self.opt_step = 0
        self.opt_states = {}
        for name, param in self.parameters():
            self.opt_states[name] = {
                'm': np.zeros_like(param),
                'v': np.zeros_like(param)
            }

    def step_optimizer(self, current_step: Optional[int] = None):
        if current_step is not None:
            self.opt_step = current_step
        self.opt_step += 1
        if self.warmup_steps > 0:
            lr = self.lr * min(self.opt_step ** -0.5, self.opt_step * self.warmup_steps ** -1.5)
        else:
            lr = self.lr
        def update(name: str, param: np.ndarray, grad: np.ndarray):
            if 'W_' in name and self.weight_decay > 0:
                grad = grad + self.weight_decay * param
            state = self.opt_states[name]
            state['m'] = self.beta1 * state['m'] + (1 - self.beta1) * grad
            state['v'] = self.beta2 * state['v'] + (1 - self.beta2) * (grad ** 2)
            m_hat = state['m'] / (1 - self.beta1 ** self.opt_step)
            v_hat = state['v'] / (1 - self.beta2 ** self.opt_step)
            param -= lr * m_hat / (np.sqrt(v_hat) + self.eps)
        for name, param in self.parameters():
            if name in ['embed.W', 'pos.W', 'W_out'] or 'W_' in name:
                grad = getattr(self, f"grad_{name.split('.')[0]}")
            else:
                grad = getattr(self, f"grad_{name.replace('.', '_')}")
            update(name, param, grad)

    def enable_gradient_checkpointing(self):
        warnings.warn("Gradient checkpointing is not implemented in this NumPy version", RuntimeWarning)

    def convert_to_rms_norm(self):
        self.ln_f = LayerNorm(self.d_model, rms_norm=True, dtype=self.dtype)
        for layer in self.layers:
            layer.ln1 = LayerNorm(self.d_model, rms_norm=True, dtype=self.dtype)
            layer.ln2 = LayerNorm(self.d_model, rms_norm=True, dtype=self.dtype)

    def save(self, path: str, include_optimizer: bool = False):
        data = {
            'config': {
                'vocab_size': self.vocab_size,
                'max_len': self.max_len,
                'd_model': self.d_model,
                'num_heads': self.layers[0].mha.num_heads,
                'd_ff': self.layers[0].ff.d_ff,
                'num_layers': len(self.layers),
                'dropout': self.dropout,
                'use_rotary': self.pos_embed.use_rotary,
                'rms_norm': self.ln_f.rms_norm,
                'layer_scale': any(layer.layer_scale for layer in self.layers)
            },
            'embed.W': self.embed.W,
            'pos.W': self.pos_embed.W if not self.pos_embed.use_rotary else None,
            'layers': [],
            'ln_f.gamma': self.ln_f.gamma if not self.ln_f.rms_norm else None,
            'ln_f.beta': self.ln_f.beta if not self.ln_f.rms_norm else None,
            'ln_f.weight': self.ln_f.weight if self.ln_f.rms_norm else None,
            'W_out': self.W_out
        }
        for layer in self.layers:
            layer_data = {
                'mha.W_q': layer.mha.W_q,
                'mha.W_k': layer.mha.W_k,
                'mha.W_v': layer.mha.W_v,
                'mha.W_o': layer.mha.W_o,
                'ff.W1': layer.ff.W1,
                'ff.b1': layer.ff.b1,
                'ff.W2': layer.ff.W2,
                'ff.b2': layer.ff.b2,
                'ln1.gamma': layer.ln1.gamma,
                'ln1.beta': layer.ln1.beta,
                'ln2.gamma': layer.ln2.gamma,
                'ln2.beta': layer.ln2.beta
            }
            if layer.layer_scale:
                layer_data['gamma1'] = layer.gamma1
                layer_data['gamma2'] = layer.gamma2
            data['layers'].append(layer_data)
        if include_optimizer and self.opt_states:
            data['optimizer'] = {
                'lr': self.lr,
                'beta1': self.beta1,
                'beta2': self.beta2,
                'eps': self.eps,
                'weight_decay': self.weight_decay,
                'warmup_steps': self.warmup_steps,
                'opt_step': self.opt_step,
                'states': {k: {'m': v['m'], 'v': v['v']} for k, v in self.opt_states.items()}
            }
        os.makedirs(os.path.dirname(os.path.abspath(path)), exist_ok=True)
        with open(path, 'wb') as f:
            pickle.dump(data, f)

    def load(self, path: str, strict: bool = True):
        with open(path, 'rb') as f:
            data = pickle.load(f)
        self.embed.W = data['embed.W']
        if not self.pos_embed.use_rotary and data['pos.W'] is not None:
            self.pos_embed.W = data['pos.W']
        for layer, ld in zip(self.layers, data['layers']):
            layer.mha.W_q = ld['mha.W_q']
            layer.mha.W_k = ld['mha.W_k']
            layer.mha.W_v = ld['mha.W_v']
            layer.mha.W_o = ld['mha.W_o']
            layer.ff.W1 = ld['ff.W1']
            layer.ff.b1 = ld['ff.b1']
            layer.ff.W2 = ld['ff.W2']
            layer.ff.b2 = ld['ff.b2']
            layer.ln1.gamma = ld['ln1.gamma']
            layer.ln1.beta = ld['ln1.beta']
            layer.ln2.gamma = ld['ln2.gamma']
            layer.ln2.beta = ld['ln2.beta']
            if hasattr(layer, 'gamma1') and 'gamma1' in ld:
                layer.gamma1 = ld['gamma1']
            if hasattr(layer, 'gamma2') and 'gamma2' in ld:
                layer.gamma2 = ld['gamma2']
        if not self.ln_f.rms_norm:
            self.ln_f.gamma = data['ln_f.gamma']
            self.ln_f.beta = data['ln_f.beta']
        else:
            self.ln_f.weight = data['ln_f.weight']
        self.W_out = data['W_out']
        if 'optimizer' in data and self.opt_states:
            opt_data = data['optimizer']
            self.lr = opt_data['lr']
            self.beta1 = opt_data['beta1']
            self.beta2 = opt_data['beta2']
            self.eps = opt_data['eps']
            self.weight_decay = opt_data.get('weight_decay', 0.1)
            self.warmup_steps = opt_data.get('warmup_steps', 2000)
            self.opt_step = opt_data['opt_step']
            for name, state in opt_data['states'].items():
                if name in self.opt_states:
                    self.opt_states[name]['m'] = state['m']
                    self.opt_states[name]['v'] = state['v']

    def generate(self, idx_start: List[int], max_new_tokens: int = 50, 
                 temperature: float = 1.0, top_k: Optional[int] = None, 
                 top_p: Optional[float] = None, do_sample: bool = True) -> List[int]:
        idx = list(idx_start)
        for _ in range(max_new_tokens):
            input_ids = np.array([idx[-self.max_len:]], dtype=np.int32)
            logits = self.forward(input_ids, training=False)
            next_logits = logits[0, -1] / max(temperature, 1e-8)
            if top_k is not None and top_k > 0:
                top_k = min(top_k, len(next_logits))
                top_k_idx = np.argpartition(next_logits, -top_k)[-top_k:]
                top_k_logits = next_logits[top_k_idx]
                if top_p is not None and top_p < 1.0:
                    sorted_idx = np.argsort(top_k_logits)[::-1]
                    sorted_logits = top_k_logits[sorted_idx]
                    cumulative_probs = np.cumsum(softmax(sorted_logits))
                    cutoff_idx = np.where(cumulative_probs > top_p)[0][0]
                    top_p_idx = top_k_idx[sorted_idx[:cutoff_idx + 1]]
                    top_p_logits = next_logits[top_p_idx]
                    probs = softmax(top_p_logits)
                    next_id = np.random.choice(top_p_idx, p=probs) if do_sample else top_p_idx[np.argmax(top_p_logits)]
                else:
                    probs = softmax(top_k_logits)
                    next_id = np.random.choice(top_k_idx, p=probs) if do_sample else top_k_idx[np.argmax(top_k_logits)]
            else:
                if top_p is not None and top_p < 1.0:
                    sorted_idx = np.argsort(next_logits)[::-1]
                    sorted_logits = next_logits[sorted_idx]
                    cumulative_probs = np.cumsum(softmax(sorted_logits))
                    cutoff_idx = np.where(cumulative_probs > top_p)[0][0]
                    top_p_idx = sorted_idx[:cutoff_idx + 1]
                    top_p_logits = next_logits[top_p_idx]
                    probs = softmax(top_p_logits)
                    next_id = np.random.choice(top_p_idx, p=probs) if do_sample else top_p_idx[np.argmax(top_p_logits)]
                else:
                    probs = softmax(next_logits)
                    next_id = np.random.choice(len(probs), p=probs) if do_sample else np.argmax(probs)
            idx.append(int(next_id))
        return idx

    def evaluate(self, val_data: np.ndarray, seq_len: int, batch_size: int, 
                 tokenizer: Any) -> Tuple[float, float]:
        total_loss = 0.0
        total_tokens = 0
        n_batches = 0
        for xb, yb in get_batches_from_text(val_data, seq_len, batch_size, tokenizer):
            original_dropout = self.dropout
            self.dropout = 0.0
            b, s = xb.shape
            logits = self.forward(xb, training=False)
            vocab = logits.shape[-1]
            logits_flat = logits.reshape(-1, vocab)
            targets_flat = yb.reshape(-1)
            probs = softmax(logits_flat, axis=1)
            log_probs = np.log(np.clip(probs, 1e-12, 1.0))
            loss = -np.mean(log_probs[np.arange(len(targets_flat)), targets_flat])
            total_loss += loss * len(targets_flat)
            total_tokens += len(targets_flat)
            n_batches += 1
            self.dropout = original_dropout
        avg_loss = total_loss / total_tokens
        perplexity = np.exp(avg_loss)
        return avg_loss, perplexity

class Trainer:
    def __init__(self, model: GPT, tokenizer: Any, train_data: str, 
                 val_data: Optional[str] = None, seq_len: int = 1024, 
                 batch_size: int = 8, grad_accum_steps: int = 1):
        self.model = model
        self.tokenizer = tokenizer
        self.train_data = train_data
        self.val_data = val_data
        self.seq_len = seq_len
        self.batch_size = batch_size
        self.grad_accum_steps = grad_accum_steps
        self.history = {'train_loss': [], 'val_loss': [], 'perplexity': [], 'lr': []}
        self.best_val_loss = float('inf')
        self.patience_counter = 0

    def train(self, epochs: int = 10, lr: float = 3e-4, weight_decay: float = 0.1,
              warmup_steps: int = 2000, grad_clip: float = 1.0, 
              val_interval: int = 1, early_stopping_patience: int = 5,
              checkpoint_dir: str = 'checkpoints', save_best: bool = True):
        os.makedirs(checkpoint_dir, exist_ok=True)
        self.model.init_optimizer(
            lr=lr,
            weight_decay=weight_decay,
            warmup_steps=warmup_steps
        )
        total_steps = 0
        start_time = time.time()
        for epoch in range(1, epochs + 1):
            print(f"\nEpoch {epoch}/{epochs}")
            epoch_start = time.time()
            total_loss = 0.0
            n_batches = 0
            total_steps += len(self.train_data) // (self.seq_len * self.batch_size)
            for i, (xb, yb) in enumerate(get_batches_from_text(
                    self.train_data, self.seq_len, self.batch_size, self.tokenizer)):
                loss = self.model.loss_and_backward(xb, yb, grad_clip)
                total_loss += loss
                n_batches += 1
                if (i + 1) % self.grad_accum_steps == 0 or (i + 1) == n_batches:
                    self.model.step_optimizer(total_steps)
                    self.model.zero_grads()
                if i % 10 == 0:
                    current_lr = lr * min(total_steps ** -0.5, total_steps * warmup_steps ** -1.5) if warmup_steps > 0 else lr
                    print(f'Step {i+1}/{n_batches}, Loss: {loss:.4f}, LR: {current_lr:.2e}', end='\r')
            avg_loss = total_loss / max(1, n_batches)
            self.history['train_loss'].append(avg_loss)
            val_loss = float('inf')
            perplexity = float('inf')
            if self.val_data and epoch % val_interval == 0:
                val_loss, perplexity = self.model.evaluate(
                    self.val_data, self.seq_len, self.batch_size, self.tokenizer
                )
                self.history['val_loss'].append(val_loss)
                self.history['perplexity'].append(perplexity)
                if save_best and val_loss < self.best_val_loss:
                    self.best_val_loss = val_loss
                    best_path = os.path.join(checkpoint_dir, 'best_model.pkl')
                    self.model.save(best_path, include_optimizer=True)
                    print(f"\n[INFO] Best model saved with validation loss: {val_loss:.4f}")
                    self.patience_counter = 0
                else:
                    self.patience_counter += 1
            epoch_time = time.time() - epoch_start
            print(f"\nEpoch {epoch} completed in {epoch_time:.2f}s | "
                  f"Train Loss: {avg_loss:.4f} | "
                  f"Val Loss: {val_loss:.4f} | "
                  f"Perplexity: {perplexity:.2f}")
            start_prompt = 'دوست '
            start_ids = [self.tokenizer.w2i.get(c, self.tokenizer.w2i['<unk>']) for c in start_prompt]
            gen = self.model.generate(start_ids, max_new_tokens=100, temperature=0.8, top_k=50, top_p=0.9)
            print('Sample:', self.tokenizer.decode(np.array(gen)))
            if epoch % 5 == 0:
                ckpt_path = os.path.join(checkpoint_dir, f'model_epoch_{epoch}.pkl')
                self.model.save(ckpt_path)
                print(f"[INFO] Checkpoint saved to {ckpt_path}")
            if early_stopping_patience > 0 and self.patience_counter >= early_stopping_patience:
                print(f"\n[INFO] Early stopping triggered after {epoch} epochs")
                break
        total_time = time.time() - start_time
        print(f"\nTraining completed in {total_time/60:.2f} minutes")
        return self.history

if __name__ == '__main__':
    seq_len = 128
    batch_size = 8
    epochs = 50
    lr = 6e-4
    try:
        with open('sample_text.txt', 'r', encoding='utf-8') as f:
            sample_text = f.read()
    except:
        sample_text = """
        دوست دارم برنامه‌نویسی کنم. این یک متن نمونه است برای آموزش مدل GPT کوچک.
        مدل می‌تواند کاراکترها را یاد بگیرد و متن تولید کند.
        هوش مصنوعی یکی از حوزه‌های پررونق در دنیای امروز است.
        مدل‌های زبانی بزرگ قادر به انجام کارهای شگفت‌انگیزی هستند.
        در این مثال ساده، ما یک مدل GPT کوچک را پیاده‌سازی می‌کنیم.
        """
    train_ratio = 0.9
    split_idx = int(len(sample_text) * train_ratio)
    train_text = sample_text[:split_idx]
    val_text = sample_text[split_idx:]
    print("Building tokenizer...")
    tok = BPETokenizer()
    tok.build_from_text([train_text], vocab_size=500)
    vocab_size = len(tok.vocab)
    print(f'Vocabulary size: {vocab_size}')
    print("Building model...")
    model = GPT(
        vocab_size=vocab_size,
        max_len=seq_len,
        d_model=256,
        num_heads=8,
        d_ff=1024,
        num_layers=6,
        dropout=0.1,
        use_rotary=False,
        rms_norm=True,
        layer_scale=True
    )
    print("\nStarting training...")
    trainer = Trainer(
        model=model,
        tokenizer=tok,
        train_data=train_text,
        val_data=val_text,
        seq_len=seq_len,
        batch_size=batch_size
    )
    history = trainer.train(
        epochs=epochs,
        lr=lr,
        weight_decay=0.1,
        warmup_steps=1000,
        grad_clip=1.0,
        val_interval=1,
        early_stopping_patience=10,
        checkpoint_dir='checkpoints'
    )
    model.save('gpt_final.pkl')
    print('Final model saved -> gpt_final.pkl')







"""
LICENSE:

Copyright 2025 ysnrfd

Timestamp: 2025-08-12

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to use,
copy, modify, and distribute the Software, subject to the following conditions:

1. The copyright notice, this permission notice, and all attribution information
   regarding the original author (ysnrfd) must be preserved in their entirety
   and must not be removed, altered, or obscured in any copies or derivative works.

2. Any modifications or derivative works must be clearly documented in a "CHANGELOG" or
   "NOTICE" file included with the Software. This documentation must include a detailed
   description of the changes made, the date of the modification, and the identity of
   the modifier.

3. The Software is provided "as is", without warranty of any kind, express or implied.
   The author shall not be liable for any damages arising from use of the Software.

4. Any attempt to remove or alter the original attribution or copyright information
   constitutes a violation of this license and may result in legal action.

"""