Delete model.py

model.py

@@ -1,67 +0,0 @@
-import torch
-import torch.nn as nn
-import math
-from torch.nn import functional as F
-
-class SelfAttention(nn.Module):
-    def __init__(self, n_embd=768, n_head=8):
-        super().__init__()
-        self.qkv = nn.Linear(n_embd, n_embd * 3, bias=False)
-        self.proj = nn.Linear(n_embd, n_embd)
-        self.n_head = n_head
-        
-        # إضافة القناع (Causal Mask) لمنع النموذج من رؤية المستقبل
-        # تم ضبطه على 256 ليتوافق مع حجم أوزانك
-        self.register_buffer("tril", torch.tril(torch.ones(256, 256))
-                                        .view(1, 1, 256, 256))
-
-    def forward(self, x):
-        B, T, C = x.shape
-        q, k, v = self.qkv(x).split(C, dim=2)
-        
-        q = q.view(B, T, self.n_head, C // self.n_head).transpose(1, 2)
-        k = k.view(B, T, self.n_head, C // self.n_head).transpose(1, 2)
-        v = v.view(B, T, self.n_head, C // self.n_head).transpose(1, 2)
-        
-        att = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(k.shape[-1]))
-        
-        # تطبيق القناع: إخفاء الحروف المستقبلية
-        att = att.masked_fill(self.tril[:,:,:T,:T] == 0, float('-inf'))
-        
-        att = torch.softmax(att, dim=-1)
-        y = att @ v
-        y = y.transpose(1, 2).contiguous().view(B, T, C)
-        return self.proj(y)
-
-class Block(nn.Module):
-    def __init__(self, n_embd=768, n_head=8):
-        super().__init__()
-        self.ln1 = nn.LayerNorm(n_embd)
-        self.attn = SelfAttention(n_embd, n_head)
-        self.ln2 = nn.LayerNorm(n_embd)
-        self.mlp = nn.Sequential(
-            nn.Linear(n_embd, 4 * n_embd),
-            nn.GELU(),
-            nn.Linear(4 * n_embd, n_embd),
-        )
-
-    def forward(self, x):
-        x = x + self.attn(self.ln1(x))
-        x = x + self.mlp(self.ln2(x))
-        return x
-
-class MedicalMasterAI(nn.Module):
-    def __init__(self, vocab_size=115, n_layer=48, n_head=8, n_embd=768):
-        super().__init__()
-        self.token_embedding = nn.Embedding(vocab_size, n_embd)
-        # تم التعديل إلى 256 بناءً على سجل الخطأ في أوزانك
-        self.position_embedding = nn.Parameter(torch.zeros(1, 256, n_embd))
-        self.blocks = nn.Sequential(*[Block(n_embd, n_head) for _ in range(n_layer)])
-        self.ln_f = nn.LayerNorm(n_embd)
-        self.lm_head = nn.Linear(n_embd, vocab_size)
-
-    def forward(self, idx):
-        b, t = idx.shape
-        x = self.token_embedding(idx) + self.position_embedding[:, :t, :]
-        x = self.blocks(x)
-        return self.lm_head(self.ln_f(x))