PyTorch weights as safetensors, with the architecture module

configs.json

@@ -0,0 +1,67 @@
+{
+  "ruq-0.7m": {
+    "vocab_size": 8192,
+    "d_model": 64,
+    "n_layers": 4,
+    "n_heads": 4,
+    "n_kv_heads": 4,
+    "ffn_hidden": 192,
+    "max_seq_len": 512,
+    "rope_theta": 10000.0,
+    "norm_eps": 1e-05,
+    "dropout": 0.0,
+    "tie_embeddings": true
+  },
+  "ruq-2m": {
+    "vocab_size": 8192,
+    "d_model": 128,
+    "n_layers": 4,
+    "n_heads": 4,
+    "n_kv_heads": 4,
+    "ffn_hidden": 384,
+    "max_seq_len": 512,
+    "rope_theta": 10000.0,
+    "norm_eps": 1e-05,
+    "dropout": 0.0,
+    "tie_embeddings": true
+  },
+  "ruq-5m": {
+    "vocab_size": 8192,
+    "d_model": 256,
+    "n_layers": 4,
+    "n_heads": 4,
+    "n_kv_heads": 4,
+    "ffn_hidden": 704,
+    "max_seq_len": 512,
+    "rope_theta": 10000.0,
+    "norm_eps": 1e-05,
+    "dropout": 0.0,
+    "tie_embeddings": true
+  },
+  "ruq-15m": {
+    "vocab_size": 8192,
+    "d_model": 384,
+    "n_layers": 6,
+    "n_heads": 6,
+    "n_kv_heads": 6,
+    "ffn_hidden": 1024,
+    "max_seq_len": 512,
+    "rope_theta": 10000.0,
+    "norm_eps": 1e-05,
+    "dropout": 0.0,
+    "tie_embeddings": true
+  },
+  "ruq-30m": {
+    "vocab_size": 8192,
+    "d_model": 512,
+    "n_layers": 8,
+    "n_heads": 8,
+    "n_kv_heads": 8,
+    "ffn_hidden": 1408,
+    "max_seq_len": 512,
+    "rope_theta": 10000.0,
+    "norm_eps": 1e-05,
+    "dropout": 0.0,
+    "tie_embeddings": true
+  }
+}

modeling_ruqlm.py

@@ -0,0 +1,238 @@
+"""
+معمارية Ruq-LM — محوّل صغير مُدرَّب من الصفر.
+
+هذا هو النموذج نفسه: أوزان مهيّأة عشوائياً، لا اشتقاق من أي نموذج جاهز.
+الوصفة حديثة وقياسية: pre-norm + RMSNorm + RoPE + SwiGLU + تضمينات مربوطة.
+
+لماذا هذه الخيارات عند 30M بارامتر تحديداً:
+  - RMSNorm بدل LayerNorm: أقل عمليات، ولا فرق يُذكر في الجودة.
+  - RoPE بدل تضمينات موضعية مُتعلَّمة: لا بارامترات إضافية، وتعميم أفضل
+    على أطوال لم تُرَ أثناء التدريب.
+  - SwiGLU: أفضل من ReLU/GELU عند ثبات عدد البارامترات.
+  - ربط تضمينات الدخل بالخرج: يوفّر 4.2M بارامتر — أي 14% من النموذج
+    عند مفردات 8192. عند هذا الحجم الصغير هذا فرق جوهري لا تحسين هامشي.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass, asdict
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+@dataclass
+class ModelArgs:
+    vocab_size: int = 8192
+    d_model: int = 512
+    n_layers: int = 8
+    n_heads: int = 8
+    n_kv_heads: int | None = None      # None = انتباه متعدد الرؤوس عادي؛ أقل = GQA
+    ffn_hidden: int | None = None      # None = يُحسب تلقائياً (~8/3 × d مقرّباً لمضاعف 64)
+    max_seq_len: int = 512
+    rope_theta: float = 10000.0
+    norm_eps: float = 1e-5
+    dropout: float = 0.0
+    tie_embeddings: bool = True
+
+    def __post_init__(self) -> None:
+        if self.d_model % self.n_heads:
+            raise ValueError("d_model يجب أن يقبل القسمة على n_heads")
+        if self.n_kv_heads is None:
+            self.n_kv_heads = self.n_heads
+        if self.n_heads % self.n_kv_heads:
+            raise ValueError("n_heads يجب أن يقبل القسمة على n_kv_heads")
+        if self.ffn_hidden is None:
+            # 8/3 × d بدل 4 × d: SwiGLU يستخدم ثلاث مصفوفات لا اثنتين،
+            # فنقلّص العرض للحفاظ على نفس ميزانية البارامترات.
+            self.ffn_hidden = 64 * math.ceil((8 * self.d_model / 3) / 64)
+
+    @property
+    def head_dim(self) -> int:
+        return self.d_model // self.n_heads
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+# --------------------------------------------------------------------- الطبقات
+class RMSNorm(nn.Module):
+    def __init__(self, dim: int, eps: float = 1e-5):
+        super().__init__()
+        self.eps = eps
+        self.weight = nn.Parameter(torch.ones(dim))
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        # يُحسب في float32 دائماً: التطبيع في bf16 يفقد دقة تُهم عند العمق
+        dtype = x.dtype
+        x = x.float()
+        x = x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps)
+        return (x * self.weight.float()).to(dtype)
+
+
+def build_rope_cache(seq_len: int, head_dim: int, theta: float, device, dtype):
+    """يعيد (cos, sin) بشكل (seq_len, head_dim/2)."""
+    inv_freq = 1.0 / (theta ** (torch.arange(0, head_dim, 2, device=device).float() / head_dim))
+    pos = torch.arange(seq_len, device=device).float()
+    freqs = torch.outer(pos, inv_freq)
+    return freqs.cos().to(dtype), freqs.sin().to(dtype)
+
+
+def apply_rope(x: torch.Tensor, cos: torch.Tensor, sin: torch.Tensor) -> torch.Tensor:
+    """x بشكل (B, H, S, D) — يدوّر كل زوج إحداثيات بزاوية تتناسب مع الموضع."""
+    x1, x2 = x.chunk(2, dim=-1)
+    cos = cos[None, None, : x.size(-2), :]
+    sin = sin[None, None, : x.size(-2), :]
+    return torch.cat([x1 * cos - x2 * sin, x2 * cos + x1 * sin], dim=-1)
+
+
+class Attention(nn.Module):
+    def __init__(self, args: ModelArgs):
+        super().__init__()
+        self.n_heads, self.n_kv_heads = args.n_heads, args.n_kv_heads
+        self.head_dim = args.head_dim
+        self.repeat = self.n_heads // self.n_kv_heads
+        self.dropout = args.dropout
+
+        self.wq = nn.Linear(args.d_model, self.n_heads * self.head_dim, bias=False)
+        self.wk = nn.Linear(args.d_model, self.n_kv_heads * self.head_dim, bias=False)
+        self.wv = nn.Linear(args.d_model, self.n_kv_heads * self.head_dim, bias=False)
+        self.wo = nn.Linear(self.n_heads * self.head_dim, args.d_model, bias=False)
+
+    def forward(self, x, cos, sin):
+        B, S, _ = x.shape
+        q = self.wq(x).view(B, S, self.n_heads, self.head_dim).transpose(1, 2)
+        k = self.wk(x).view(B, S, self.n_kv_heads, self.head_dim).transpose(1, 2)
+        v = self.wv(x).view(B, S, self.n_kv_heads, self.head_dim).transpose(1, 2)
+
+        q, k = apply_rope(q, cos, sin), apply_rope(k, cos, sin)
+
+        if self.repeat > 1:                                  # GQA
+            k = k.repeat_interleave(self.repeat, dim=1)
+            v = v.repeat_interleave(self.repeat, dim=1)
+
+        out = F.scaled_dot_product_attention(
+            q, k, v, is_causal=True,
+            dropout_p=self.dropout if self.training else 0.0,
+        )
+        return self.wo(out.transpose(1, 2).contiguous().view(B, S, -1))
+
+
+class SwiGLU(nn.Module):
+    def __init__(self, args: ModelArgs):
+        super().__init__()
+        h = args.ffn_hidden
+        self.w_gate = nn.Linear(args.d_model, h, bias=False)
+        self.w_up = nn.Linear(args.d_model, h, bias=False)
+        self.w_down = nn.Linear(h, args.d_model, bias=False)
+
+    def forward(self, x):
+        return self.w_down(F.silu(self.w_gate(x)) * self.w_up(x))
+
+
+class Block(nn.Module):
+    def __init__(self, args: ModelArgs):
+        super().__init__()
+        self.attn_norm = RMSNorm(args.d_model, args.norm_eps)
+        self.attn = Attention(args)
+        self.ffn_norm = RMSNorm(args.d_model, args.norm_eps)
+        self.ffn = SwiGLU(args)
+        self.drop = nn.Dropout(args.dropout)
+
+    def forward(self, x, cos, sin):
+        x = x + self.drop(self.attn(self.attn_norm(x), cos, sin))
+        return x + self.drop(self.ffn(self.ffn_norm(x)))
+
+
+# --------------------------------------------------------------------- النموذج
+class RuqLM(nn.Module):
+    def __init__(self, args: ModelArgs):
+        super().__init__()
+        self.args = args
+        self.tok_emb = nn.Embedding(args.vocab_size, args.d_model)
+        self.drop = nn.Dropout(args.dropout)
+        self.blocks = nn.ModuleList(Block(args) for _ in range(args.n_layers))
+        self.norm = RMSNorm(args.d_model, args.norm_eps)
+        self.lm_head = nn.Linear(args.d_model, args.vocab_size, bias=False)
+
+        if args.tie_embeddings:
+            self.lm_head.weight = self.tok_emb.weight
+
+        self.apply(self._init)
+        # تدرّج المسارات المتبقية ينمو مع العمق؛ نقلّص أوزان الإسقاط الأخير
+        # في كل كتلة بـ 1/sqrt(2L) للحفاظ على تباين ثابت عبر الطبقات (GPT-2).
+        std = 0.02 / math.sqrt(2 * args.n_layers)
+        for block in self.blocks:
+            nn.init.normal_(block.attn.wo.weight, mean=0.0, std=std)
+            nn.init.normal_(block.ffn.w_down.weight, mean=0.0, std=std)
+
+        self._cache_key = None
+
+    @staticmethod
+    def _init(module):
+        if isinstance(module, nn.Linear):
+            nn.init.normal_(module.weight, mean=0.0, std=0.02)
+            if module.bias is not None:
+                nn.init.zeros_(module.bias)
+        elif isinstance(module, nn.Embedding):
+            nn.init.normal_(module.weight, mean=0.0, std=0.02)
+
+    def _rope(self, seq_len: int, device, dtype):
+        key = (seq_len, device, dtype)
+        if self._cache_key != key:
+            self._cos, self._sin = build_rope_cache(
+                max(seq_len, self.args.max_seq_len), self.args.head_dim,
+                self.args.rope_theta, device, dtype,
+            )
+            self._cache_key = key
+        return self._cos[:seq_len], self._sin[:seq_len]
+
+    def forward(self, input_ids: torch.Tensor, labels: torch.Tensor | None = None):
+        x = self.drop(self.tok_emb(input_ids))
+        cos, sin = self._rope(input_ids.size(1), x.device, x.dtype)
+        for block in self.blocks:
+            x = block(x, cos, sin)
+        logits = self.lm_head(self.norm(x))
+
+        loss = None
+        if labels is not None:
+            # الإزاحة: الموضع i يتنبأ بالتوكن i+1
+            loss = F.cross_entropy(
+                logits[:, :-1].reshape(-1, logits.size(-1)).float(),
+                labels[:, 1:].reshape(-1),
+                ignore_index=-100,
+            )
+        return logits, loss
+
+    # ------------------------------------------------------------- الإحصاءات
+    def num_params(self, embeddings: bool = True) -> int:
+        """التضمينات المربوطة تُحسب مرة واحدة (lm_head.weight هو نفسه tok_emb.weight)."""
+        seen, total = set(), 0
+        for name, p in self.named_parameters():
+            if id(p) in seen:
+                continue
+            seen.add(id(p))
+            if not embeddings and "tok_emb" in name:
+                continue
+            total += p.numel()
+        return total
+
+    @torch.no_grad()
+    def generate(self, input_ids, max_new_tokens=128, temperature=0.8,
+                 top_k=50, eos_id=None):
+        """توليد بسيط بلا كاش KV — كافٍ للتقييم على تسلسلات قصيرة."""
+        self.eval()
+        for _ in range(max_new_tokens):
+            window = input_ids[:, -self.args.max_seq_len:]
+            logits, _ = self(window)
+            logits = logits[:, -1, :].float() / max(temperature, 1e-6)
+            if top_k:
+                kth = logits.topk(min(top_k, logits.size(-1)), dim=-1).values[:, -1:]
+                logits = logits.masked_fill(logits < kth, float("-inf"))
+            nxt = torch.multinomial(logits.softmax(-1), num_samples=1)
+            input_ids = torch.cat([input_ids, nxt], dim=1)
+            if eos_id is not None and (nxt == eos_id).all():
+                break
+        return input_ids

ruq-0.7m.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:27016d2f1bf1e55a76906f1be007806ee39d1199eeb26dc9f547959fd6db40a6
+size 2954888

ruq-15m.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a71400bfadc737d6826816e8eea2f714975f3976e52021935b05d5dcf67c8282
+size 55075584

ruq-2m.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d8329724a88ed97ad2c3979e7fb0eb388c04b757c6d99636e4776fe7d26a780
+size 7610360

ruq-30m.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e1e242c504b3ababa75154e6933d41d0f50c51635dd38322d9fa07dac8f0c90d
+size 119579600

ruq-5m.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9334bcca423b254b641892be0095680d2b7f5752d90baa5e3ced296f1f2550e8
+size 21246488