Update app.py

app.py

@@ -16,10 +16,9 @@ class ModelConfig:
     dropout = 0.1
 
 config = ModelConfig()
-device = "cpu"  # Spaces CPU
+device = "cpu"  # Spaces için CPU zorunlu
 
-# ---------------- MODEL ARCHITECTURE ----------------
-# (Model mimarisi, ağırlıkların doğru yüklenmesi için değiştirilmemelidir)
+# ---------------- MODEL ----------------
 class Head(nn.Module):
     def __init__(self, head_size):
         super().__init__()
@@ -27,6 +26,7 @@ class Head(nn.Module):
         self.query = nn.Linear(config.n_embd, head_size, bias=False)
         self.value = nn.Linear(config.n_embd, head_size, bias=False)
         self.register_buffer("tril", torch.tril(torch.ones(config.block_size, config.block_size)))
+        self.dropout = nn.Dropout(config.dropout)
 
     def forward(self, x):
         B, T, C = x.shape
@@ -34,66 +34,76 @@ class Head(nn.Module):
         wei = q @ k.transpose(-2, -1) * (C ** -0.5)
         wei = wei.masked_fill(self.tril[:T, :T] == 0, float("-inf"))
         wei = F.softmax(wei, dim=-1)
+        wei = self.dropout(wei)
         return wei @ v
 
+
 class MultiHeadAttention(nn.Module):
     def __init__(self, num_heads, head_size):
         super().__init__()
         self.heads = nn.ModuleList([Head(head_size) for _ in range(num_heads)])
         self.proj = nn.Linear(config.n_embd, config.n_embd)
+        self.dropout = nn.Dropout(config.dropout)
 
     def forward(self, x):
-        return self.proj(torch.cat([h(x) for h in self.heads], dim=-1))
+        out = torch.cat([h(x) for h in self.heads], dim=-1)
+        return self.dropout(self.proj(out))
+
 
 class FeedForward(nn.Module):
-    def __init__(self):
+    def __init__(self, n_embd):
         super().__init__()
         self.net = nn.Sequential(
-            nn.Linear(config.n_embd, 4 * config.n_embd),
+            nn.Linear(n_embd, 4 * n_embd),
             nn.ReLU(),
             nn.Dropout(config.dropout),
-            nn.Linear(4 * config.n_embd, config.n_embd),
+            nn.Linear(4 * n_embd, n_embd),
             nn.Dropout(config.dropout),
         )
 
     def forward(self, x):
         return self.net(x)
 
+
 class Block(nn.Module):
-    def __init__(self):
+    def __init__(self, n_embd, n_head):
         super().__init__()
-        self.sa = MultiHeadAttention(config.n_head, config.n_embd // config.n_head)
-        self.ffwd = FeedForward()
-        self.ln1 = nn.LayerNorm(config.n_embd)
-        self.ln2 = nn.LayerNorm(config.n_embd)
+        head_size = n_embd // n_head
+        self.sa = MultiHeadAttention(n_head, head_size)
+        self.ffwd = FeedForward(n_embd)
+        self.ln1 = nn.LayerNorm(n_embd)
+        self.ln2 = nn.LayerNorm(n_embd)
 
     def forward(self, x):
         x = x + self.sa(self.ln1(x))
         x = x + self.ffwd(self.ln2(x))
         return x
 
+
 class MyLanguageModel(nn.Module):
     def __init__(self):
         super().__init__()
         self.token_embedding_table = nn.Embedding(config.vocab_size, config.n_embd)
         self.position_embedding_table = nn.Embedding(config.block_size, config.n_embd)
-        self.blocks = nn.Sequential(*[Block() for _ in range(config.n_layer)])
+        self.blocks = nn.Sequential(*[Block(config.n_embd, n_head=config.n_head) for _ in range(config.n_layer)])
         self.ln_f = nn.LayerNorm(config.n_embd)
         self.lm_head = nn.Linear(config.n_embd, config.vocab_size)
+        self.dropout = nn.Dropout(config.dropout)
 
     def forward(self, idx):
         B, T = idx.shape
         tok_emb = self.token_embedding_table(idx)
         pos_emb = self.position_embedding_table(torch.arange(T, device=idx.device))
-        x = tok_emb + pos_emb
+        x = self.dropout(tok_emb + pos_emb)
         x = self.blocks(x)
         x = self.ln_f(x)
         return self.lm_head(x)
 
+
 # ---------------- LOAD MODEL ----------------
-print("Model yükleniyor...")
 REPO_ID = "jetbabareal/Sabir-20M"
 
+print("Model yükleniyor... / Loading model...")
 model = MyLanguageModel().to(device)
 weights = hf_hub_download(REPO_ID, "model.safetensors")
 model.load_state_dict(load_file(weights))
@@ -101,88 +111,133 @@ model.eval()
 
 tokenizer_path = hf_hub_download(REPO_ID, "tokenizer.model")
 tokenizer = spm.SentencePieceProcessor(model_file=tokenizer_path)
-print("Model hazır!")
-
-# ---------------- GENERATION LOGIC ----------------
-def generate_response(message, history):
-    """
-    Bu fonksiyon Gradio ChatInterface ile çalışacak şekilde ayarlandı.
-    message: Kullanıcının yeni mesajı
-    history: Önceki konuşma geçmişi (Model küçük olduğu için şimdilik geçmişi göz ardı ediyoruz)
-    """
-    
-    # 1. Prompt Hazırlığı
-    # Model sadece son mesajı cevaplayacak şekilde tasarlandı (Context window küçük olduğu için)
-    prompt = f"Kullanıcı: {message}\nModel:"
-    idx = torch.tensor(tokenizer.encode(prompt), dtype=torch.long).unsqueeze(0)
-    
-    # Ayarlar
-    max_new_tokens = 100
-    temperature = 0.6
-    top_k = 30
+print("Model başarıyla yüklendi! / Model loaded successfully!")
+
+# ---------------- GENERATION ----------------
+def generate(prompt, max_new_tokens=100, temperature=0.2, top_k=30):
+    if not prompt.strip():
+        return "Lütfen bir şeyler yazın! / Please write something!"
     
-    generated_tokens = []
+    full_prompt = f"Kullanıcı: {prompt}\nModel:"
+    input_ids = tokenizer.encode(full_prompt)
+    idx = torch.tensor(input_ids, dtype=torch.long, device=device).unsqueeze(0)
     
-    # 2. Üretim Döngüsü
+    generated_ids = []
+
     for _ in range(max_new_tokens):
-        # Context window taşarsa son kısmı al
         idx_cond = idx[:, -config.block_size:]
-        
         with torch.no_grad():
             logits = model(idx_cond)
-        
+
         logits = logits[:, -1, :] / temperature
-        
+
         if top_k:
-            v, _ = torch.topk(logits, top_k)
+            v, _ = torch.topk(logits, min(top_k, logits.size(-1)))
             logits[logits < v[:, [-1]]] = -float("inf")
-            
+
         probs = F.softmax(logits, dim=-1)
-        idx_next = torch.multinomial(probs, 1)
-        
+        idx_next = torch.multinomial(probs, num_samples=1)
+
         token_id = idx_next.item()
+        generated_ids.append(token_id)
         
-        # EOS kontrolü
-        if token_id == tokenizer.eos_id():
+        # Stop conditions
+        decoded_so_far = tokenizer.decode(generated_ids)
+        if "Kullanıcı:" in decoded_so_far or "Model:" in decoded_so_far:
+            generated_ids = generated_ids[:-1]
             break
             
-        generated_tokens.append(token_id)
+        if token_id == tokenizer.eos_id():
+            break
+
         idx = torch.cat([idx, idx_next], dim=1)
+
+    response = tokenizer.decode(generated_ids)
+    return response.strip()
+
+
+# ---------------- GRADIO UI ----------------
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        """
+        # 🤖 Sabir-20M - Türkçe Mini LLM
+        20 milyon parametreli deneysel Türkçe dil modeli (eğitim ve araştırma amaçlı)
         
-        # --- KRİTİK DÜZELTME: STOP WORD KONTROLÜ ---
-        # Şu ana kadar üretilen metni kontrol et
-        current_text = tokenizer.decode(generated_tokens)
-        
-        # Eğer model kendi kendine "Kullanıcı:" veya "Model:" yazmaya başlarsa DUR.
-        if "Kullanıcı:" in current_text:
-            current_text = current_text.split("Kullanıcı:")[0] # Fazlalığı at
-            return current_text.strip()
+        **Not:** Bu model eğitim amaçlı geliştirilmiştir ve küçük bir veri seti üzerinde eğitilmiştir. 
+        Üretilen metinler her zaman tutarlı olmayabilir.
+        """
+    )
+    
+    with gr.Row():
+        with gr.Column():
+            prompt_input = gr.Textbox(
+                label="Promptunuzu yazın / Write your prompt",
+                placeholder="Merhaba, nasılsın?",
+                lines=3
+            )
+            
+            with gr.Row():
+                max_tokens = gr.Slider(
+                    minimum=20,
+                    maximum=200,
+                    value=100,
+                    step=10,
+                    label="Maksimum Token Sayısı / Max Tokens"
+                )
+                temperature = gr.Slider(
+                    minimum=0.1,
+                    maximum=1.5,
+                    value=0.2,
+                    step=0.1,
+                    label="Temperature (Yaratıcılık)"
+                )
+            
+            top_k = gr.Slider(
+                minimum=5,
+                maximum=50,
+                value=30,
+                step=5,
+                label="Top-K Sampling"
+            )
             
-        if "Model:" in current_text: # Nadiren olabilir
-            current_text = current_text.split("Model:")[0]
-            return current_text.strip()
-
-    return tokenizer.decode(generated_tokens).strip()
-
-# ---------------- PROFESSIONAL UI ----------------
-# Modern Chat Arayüzü
-demo = gr.ChatInterface(
-    fn=generate_response,
-    title="🤖 Sabir-20M Türkçe AI",
-    description="20 Milyon parametreli, deneysel bir Türkçe dil modeli.",
-    theme=gr.themes.Soft(),  # Yumuşak ve modern bir tema
-    examples=[
-        "Merhaba nasılsın?",
-        "Bana bir şaka yap.",
-        "Bugün hava nasıl?",
-        "En sevdiğin renk ne?",
-        "Hayatın anlamı nedir?"
-    ],
-    cache_examples=False,
-    retry_btn="Yeniden Dene",
-    undo_btn="Geri Al",
-    clear_btn="Temizle",
-)
-
-if __name__ == "__main__":
-    demo.launch()
+            generate_btn = gr.Button("🚀 Üret / Generate", variant="primary")
+        
+        with gr.Column():
+            output = gr.Textbox(
+                label="Model Çıktısı / Model Output",
+                lines=10
+            )
+    
+    gr.Markdown(
+        """
+        ### 💡 İpuçları:
+        - **Temperature**: Düşük değerler (0.3-0.5) daha tutarlı, yüksek değerler (0.8-1.2) daha yaratıcı çıktılar üretir
+        - **Top-K**: Düşük değerler daha deterministik, yüksek değerler daha çeşitli sonuçlar verir
+        - **Max Tokens**: Daha uzun yanıtlar için artırın (ancak tutarsızlık riski artar)
+        
+        ### 📊 Model Bilgileri:
+        - Parametre Sayısı: ~20M
+        - Mimari: Transformer (8 katman, 384 gizli boyut)
+        - Vocabulary: 8000 token (SentencePiece)
+        """
+    )
+    
+    # Örnek promptlar
+    gr.Examples(
+        examples=[
+            ["Merhaba, nasılsın?"],
+            ["Türkiye'nin başkenti neresidir?"],
+            ["Yapay zeka nedir?"],
+            ["En sevdiğin renk nedir?"],
+            ["Bugün hava nasıl?"],
+        ],
+        inputs=prompt_input,
+    )
+    
+    generate_btn.click(
+        fn=generate,
+        inputs=[prompt_input, max_tokens, temperature, top_k],
+        outputs=output
+    )
+
+demo.launch()