Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,3 @@
+model.json
+veri.txt
+.*.*

CONTRIBUTING.md

@@ -0,0 +1,48 @@
+# Projeye Katkıda Bulunma
+Öncelikle bu projeye zaman ayırdığınız ve katkıda bulunmak istediğiniz için teşekkür ederiz!
+
+Bu belge, projeye sorunsuz bir şekilde katkıda bulunabilmeniz için izlemeniz gereken adımları ve proje standartlarını içermektedir.
+
+## Geliştirme Süreci
+Bu projenin temel odak noktası, dış kütüphanelere ve hazır paketlere olan bağımlılığı en aza indirerek yapay zeka çekirdek mimarilerini sıfırdan inşa etmektir.
+* Yeni bir özellik eklerken ağır dış bağımlılıklar getirmekten kaçının.
+* Yorum satırlarını yalnızca gerekli yerlerde kullanmaya özen gösterin.
+* Yeni modüllerin test edilmiş ve sorunsuz çalışır olduğundan emin olun.
+
+## Hata Bildirimi ve Çözülmesi
+Karşılaştığınız bir hatayı düzeltmek veya bildirmek için şu adımları izleyin:
+1. **Hata Kontrolü:** Karşılaştığınız sorunla ilgili daha önce bir Issue açılıp açılmadığını kontrol edin.
+2. **Issue Açma:** Hata daha önce bildirilmediyse yeni bir Issue açın. Hata ile ilgili beklenen sonucu, karşılaştığınız sonucu ve hatayı gidermek için izlenebilecek adımları detaylıca yazın.
+3. **Çözüm Önerisi:** Hata ile ilgili çözüm önerilerinizi veya hata üzerinde kendiniz çalışıyorsanız ilgili Issue altına yorum olarak bildirin. Ardından aşağıdaki katkı sürecini izleyerek bir Pull Request açın.
+
+## Yeni Özellik Ekleme ve Kod Katkısı Süreci
+Yeni bir özellik eklemek veya kodda bir iyileştirme yapmak için doğrudan ana depoya kod gönderemezsiniz. Lütfen aşağıdaki **Fork > Test > Pull Request** iş akışını takip edin:
+
+1. Projeyi Forklayın
+Ana projeyi kendi GitHub hesabınıza Forklayın
+
+2. Klonlayın ve Dal Oluşturun
+Forkladığınız projeyi çalışma ortamınızda klonlayın ve ardından üzerinde çalışacağınız yeni bir dal oluşturun. main ve master dalları üzerinde çalışmaktan kaçının.
+
+3. Geliştirme ve Test
+* Gerekli geliştirme ve eklemeleri yapın.
+* Yaptığınız geliştirme ve eklemelerin mevcut depoyu bozmadığından emin olmak için yerel çalışma ortamınızda **mutlaka test edin.**
+
+4. Değişiklikleri Gönderin
+Yaptığınız değişiklikleri anlaşılır commit mesajlarıyla kaydedin ve kendi forkladığınız deponuza gönderin.
+
+5. Pull Request Açın
+* Orijinal projenin GitHub sayfasına gidin ve kendi deponuzdaki dalı, orijinal projenin ana dalı ile karşılaştırarak Pull Request oluşturun.
+* Pull Request açıklamasında nelerin değiştirdiğinizi, hangi problemi çözdüğünüzü (eğer bir Issue çözüyorsa Fixes #IssueNumarası şeklinde) ve yerel ortamınızda hangi testleri uyguladığınızı detaylıca yazın.
+
+## Pull Request Değerlendirme Standartları
+Açılan PR'lar proje yöneticileri tarafından incelenir. Pull Request'inizin şu şartları sağlaması beklenir:
+* **Test Edilmiş Olmalı:** Çalışmama veya mevcut mimariyi bozma potansiyeli içeren değişiklikler kabul edilmez.
+* **Temiz Kod:** Geliştirme standartlarına ve dosya yapısına uygun olmalıdır.
+* **Açıklayıcı Olmalı:** Ne yapıldığı PR metninde net bir şekilde ifade edilmelidir.
+
+İnceleme sonucunda sizden Review Changes olarak bazı düzeltmeler veya değişiklikler istenebilir.
+
+---
+
+Katkılarınız için **Teşekkürler**

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mert Cahit Yiğit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,136 @@
+# Transformer Tabanlı Türkçe Dil Modeli
+
+Bu proje, Transformer mimarisine dayalı, saf Python ile yazılmış bir yapay sinir ağı kullanan Türkçe metin üreticisidir. PyTorch veya NumPy dahil hiçbir kütüphane kullanılmamıştır. Model, verilen başlangıç kelimesinden başlayarak yeni metinler üretebilir. Sürekli güncellenecek ve geliştirilecektir.
+
+## Proje Özellikleri
+
+- **Transformer Mimarisi**: Multi-head attention mekanizması ile gelişmiş metin işleme
+- **Pozisyonel Kodlama**: Token pozisyonlarını modellemek için positional encoding
+- **Layer Normalization**: Ağ katmanlarında normalizasyon
+- **Geri Yayılım Algoritması**: Backpropagation ile eğitim
+- **Model Kaydı/Yükleme**: Eğitilmiş modeli kaydetme ve yükleme özelliği
+- **Metin Üretimi**: Eğitilmiş model ile dinamik metin üretme
+
+## Dosya Yapısı
+
+```
+├── app.py                   # Ana uygulama - model eğitimi ve metin üretimi
+├── sinir_agi.py             # Sinir ağı mimarisi ve yapı tanımları
+├── model.py                 # İleri geçiş (forward pass) işlemleri
+├── egitim.py                # Eğitim algoritmaları ve loss fonksiyonları
+├── egitim_dongusu.py        # Eğitim döngüsü ve metin üretim fonksiyonları
+├── islemler.py              # Matematiksel işlemler (çarpım, softmax, vb.)
+├── kaydet.py                # Model kaydı ve yükleme işlemleri
+├── rastgele.py              # Rastgele sayı üretimi ve matematiksel fonksiyonlar
+├── veri.txt                 # Eğitim verisi (Türkçe metinler)
+├── model.json               # Kaydedilmiş model ağırlıkları
+├── teste.py                 # Test kodları
+└── README.md                # Bu dosya
+```
+
+## Nasıl Kullanılır
+
+### Gereksinimleri
+Python 3.7 veya daha yüksek bir sürüm gereklidir. Harici kütüphane bağımlılığı yoktur.
+
+### Eğitim ve Metin Üretimi
+
+Ana programı çalıştırın:
+
+```bash
+python app.py
+```
+
+`app.py` şunları yapar:
+1. Mevcut bir model varsa (`model.json`) yükler
+2. Model yoksa yeni bir model eğitir
+3. Eğitilmiş model ile metin üretimi yapar
+
+### Örnek Kullanım
+
+```python
+from egitim_dongusu import egit, uret
+from kaydet import modeli_kaydet, modeli_yukle
+
+# Yeni model eğitimi
+ag, kelime_sayi, sayi_kelime = egit(
+    dosya_adi="veri.txt",
+    epochs=100,
+    ogrenme_hizi=0.001,
+    pencere=4
+)
+
+# Model kaydı
+modeli_kaydet(ag, kelime_sayi, sayi_kelime, "model.json")
+
+# Metin üretimi
+uret(ag, kelime_sayi, sayi_kelime, 
+     baslangic_kelime="merhaba", 
+     uzunluk=10)
+```
+
+## Ana Bileşenler
+
+### `SinirAgi` Sınıfı
+Transformer modelinin ana yapısını tanımlar:
+- Embedding tablosu
+- Pozisyonel encoding
+- Transformer katmanları
+- Çıkış doğrusal katmanı
+
+### Transformer Bloğu
+- **Multi-Head Attention**: Birden fazla dikkat başı ile gelişmiş ilişki modelleme
+- **Feed-Forward Network**: Non-lineer dönüşümler
+- **Layer Normalization**: Katman çıktılarının normalizasyonu
+
+### Eğitim
+- **Cross-Entropy Loss**: Sınıflandırma kaybı hesaplaması
+- **Backpropagation**: Gradyan hesaplaması ve parametre güncelleme
+- **Softmax**: Çıkış olasılıkları
+
+## Eğitim Parametreleri
+
+Default parametreler:
+- **Epochs**: 100 - Eğitim iterasyonu sayısı
+- **Learning Rate**: 0.001 - Öğrenme hızı
+- **Window Size**: 4 - Giriş token sayısı
+- **Hidden Dimension**: 64 - Gizli katman boyutu
+- **Feedforward Dimension**: 256 - Feedforward katman boyutu
+- **Number of Heads**: 4 - Attention başlarının sayısı
+- **Number of Layers**: 2 - Transformer katman sayısı
+
+Bu parametreler `app.py` dosyasında değiştirilebilir.
+
+## Veri Formatı
+
+`veri.txt` dosyası, her satırın bir cümle olduğu Türkçe metinler içerir:
+
+```
+merhaba bugün nasılsın umarım iyisindir
+merhaba bugün hava çok güzel
+selam bugün neler yapacaksın
+...
+```
+
+## Metin Üretimi
+
+Eğitilmiş model, verilen başlangıç kelimesinden başlayarak ardışık tokenlar predikt eder:
+
+```python
+uret(ag, kelime_sayi, sayi_kelime, 
+     baslangic_kelime="merhaba", 
+     uzunluk=20)
+```
+
+Bu, "merhaba" ile başlayan ve 20 kelime uzunluğunda bir metin üretir.
+
+## Notlar
+
+- Model tamamıyla sıfırdan geliştirilmiştir (harici ML kütüphaneleri kullanılmamıştır)
+- Tüm matematiksel işlemler NumPy veya benzeri kütüphaneler olmadan uygulanmıştır
+- Model yapısı ve eğitim algoritması tamamen Python ile kodlanmıştır
+- Proje eğitsel amaçlı geliştirilmiştir ve aktif geliştirme aşamasındadır
+
+## Lisans
+
+MIT

app.py

@@ -0,0 +1,20 @@
+from egitim_dongusu import egit, uret
+from kaydet import modeli_kaydet, modeli_yukle
+import os
+
+MODEL_DOSYASI = "model.json"
+
+if os.path.exists(MODEL_DOSYASI):
+    print("Model bulundu, yükleniyor...")
+    ag, kelime_sayi, sayi_kelime = modeli_yukle(MODEL_DOSYASI)
+else:
+    print("Yeni model egitiliyor...")
+    ag, kelime_sayi, sayi_kelime = egit(
+        dosya_adi="veri.txt",
+        epochs=100,
+        ogrenme_hizi=0.001,
+        pencere=4
+    )
+    modeli_kaydet(ag, kelime_sayi, sayi_kelime, MODEL_DOSYASI)
+
+uret(ag, kelime_sayi, sayi_kelime, baslangic_kelime="merhaba", uzunluk=10)

egitim.py

@@ -0,0 +1,170 @@
+# file name 'egitim.py'
+from model import ileri_gecis
+from islemler import carpim, transpoze, embed, pozisyonel_encoding, transformer_blok, dogrusal, topla, katman_norm, cok_baslikli_attention
+
+def cross_entropy_kayip(olasiliklar, hedef_index):
+    p = max(olasiliklar[hedef_index], 1e-10)
+    y = (p - 1) / (p + 1)
+    y2 = y * y
+    sonuc = 0.0
+    for i in range(100):
+        n = 2 * i + 1
+        sonuc += (y ** n) / n
+    return -2 * sonuc
+
+def softmax_cross_entropy_gradyan(olasiliklar, hedef_index):
+    grad = olasiliklar[:]
+    grad[hedef_index] -= 1.0
+    return grad
+
+def dogrusal_gradyan(grad_cikti, x, W):
+    grad_x = carpim(grad_cikti, transpoze(W))
+    grad_W = carpim(transpoze(x), grad_cikti)
+    grad_b = [sum(grad_cikti[i][j] for i in range(len(grad_cikti)))
+              for j in range(len(grad_cikti[0]))]
+    return grad_x, grad_W, grad_b
+
+def guncelle(agirlik, grad, ogrenme_hizi):
+    return [
+        [agirlik[i][j] - ogrenme_hizi * grad[i][j] for j in range(len(agirlik[0]))]
+        for i in range(len(agirlik))
+    ]
+
+def vektor_guncelle(vektor, grad, ogrenme_hizi):
+    return [vektor[i] - ogrenme_hizi * grad[i] for i in range(len(vektor))]
+
+def egitim_adimi(ag, token_indexleri, hedef_index, ogrenme_hizi=0.001):
+    from islemler import embed, pozisyonel_encoding, topla, transformer_blok
+
+    olasiliklar = ileri_gecis(ag, token_indexleri)
+    kayip = cross_entropy_kayip(olasiliklar, hedef_index)
+
+    grad = softmax_cross_entropy_gradyan(olasiliklar, hedef_index)
+    grad_matris = [grad]
+
+    vektorler = embed(token_indexleri, ag.embedding)
+    pe = pozisyonel_encoding(len(token_indexleri), ag.model_boyutu)
+    x = topla(vektorler, pe)
+
+    ara_x = [x]
+    for katman in ag.katmanlar:
+        x = transformer_blok(x, katman)
+        ara_x.append(x)
+
+    son_token = [ara_x[-1][-1]]
+    grad_x, grad_W, grad_b = dogrusal_gradyan(grad_matris, son_token, ag.cikti_W)
+    ag.cikti_W = guncelle(ag.cikti_W, grad_W, ogrenme_hizi)
+    ag.cikti_b = vektor_guncelle(ag.cikti_b, grad_b, ogrenme_hizi)
+    son_token_grad = grad_x[0]
+    grad_katman = [son_token_grad for _ in range(len(token_indexleri))]
+
+    for i in reversed(range(len(ag.katmanlar))):
+        grad_katman = transformer_blok_gradyan(
+            grad_katman,
+            ara_x[i],
+            ag.katmanlar[i]
+        )
+
+    return kayip
+
+def gelu_gradyan(x):
+    PI = 3.141592653589793
+    k = (2 / PI) ** 0.5
+    ic = k * (x + 0.044715 * x**3)
+    ic = max(-20.0, min(20.0, ic))
+    e = 2.718281828459
+    exp2 = e ** (2 * ic)
+    tanh_ic = (exp2 - 1) / (exp2 + 1)
+    
+    dtanh = 1 - tanh_ic ** 2
+    dic = k * (1 + 3 * 0.044715 * x**2)
+    return 0.5 * (1 + tanh_ic) + 0.5 * x * dtanh * dic
+
+def ileri_besleme_gradyan(grad_cikti, x, ff_agirliklar):
+    ara = [[0.0] * len(ff_agirliklar.b1) for _ in range(len(x))]
+    ara_aktif = dogrusal(x, ff_agirliklar.W1, ff_agirliklar.b1)
+    aktivasyon = [[max(0.0, v) for v in satir] for satir in ara_aktif]  
+
+    grad_x2, grad_W2, grad_b2 = dogrusal_gradyan(grad_cikti, aktivasyon, ff_agirliklar.W2)
+
+    grad_aktif = [
+        [grad_x2[i][j] * gelu_gradyan(ara_aktif[i][j]) for j in range(len(ara_aktif[0]))]
+        for i in range(len(ara_aktif))
+    ]
+
+    grad_x1, grad_W1, grad_b1 = dogrusal_gradyan(grad_aktif, x, ff_agirliklar.W1)
+
+    return grad_x1, grad_W1, grad_b1, grad_W2, grad_b2
+
+def transformer_blok_gradyan(grad_cikti, x, katman_agirliklar):
+    if isinstance(grad_cikti[0], (int, float)):
+        grad_cikti = [grad_cikti]
+
+    att_cikti = cok_baslikli_attention(x, katman_agirliklar.attention)
+    x_att = katman_norm(topla(x, att_cikti), katman_agirliklar.gamma1, katman_agirliklar.beta1)
+
+    grad_ln2 = []
+    grad_gamma2_toplam = [0.0] * len(katman_agirliklar.gamma2)
+    grad_beta2_toplam  = [0.0] * len(katman_agirliklar.beta2)
+
+    for i in range(len(grad_cikti)):
+        gx, gg, gb = katman_norm_gradyan(grad_cikti[i], x_att[i], katman_agirliklar.gamma2)
+        grad_ln2.append(gx)
+        for j in range(len(gg)):
+            grad_gamma2_toplam[j] += gg[j]
+            grad_beta2_toplam[j]  += gb[j]
+
+    katman_agirliklar.gamma2 = vektor_guncelle(katman_agirliklar.gamma2, grad_gamma2_toplam, 0.001)
+    katman_agirliklar.beta2  = vektor_guncelle(katman_agirliklar.beta2,  grad_beta2_toplam,  0.001)
+
+    grad_ff_x, gW1, gb1, gW2, gb2 = ileri_besleme_gradyan(grad_ln2, x_att, katman_agirliklar.ff)
+    katman_agirliklar.ff.W1 = guncelle(katman_agirliklar.ff.W1, gW1, 0.001)
+    katman_agirliklar.ff.b1 = vektor_guncelle(katman_agirliklar.ff.b1, gb1, 0.001)
+    katman_agirliklar.ff.W2 = guncelle(katman_agirliklar.ff.W2, gW2, 0.001)
+    katman_agirliklar.ff.b2 = vektor_guncelle(katman_agirliklar.ff.b2, gb2, 0.001)
+
+    grad_x_att = [
+        [grad_ff_x[i][j] + grad_ln2[i][j] for j in range(len(grad_ff_x[0]))]
+        for i in range(len(grad_ff_x))
+    ]
+
+    grad_ln1 = []
+    grad_gamma1_toplam = [0.0] * len(katman_agirliklar.gamma1)
+    grad_beta1_toplam  = [0.0] * len(katman_agirliklar.beta1)
+
+    for i in range(len(grad_x_att)):
+        gx, gg, gb = katman_norm_gradyan(grad_x_att[i], x[i], katman_agirliklar.gamma1)
+        grad_ln1.append(gx)
+        for j in range(len(gg)):
+            grad_gamma1_toplam[j] += gg[j]
+            grad_beta1_toplam[j]  += gb[j]
+
+    katman_agirliklar.gamma1 = vektor_guncelle(katman_agirliklar.gamma1, grad_gamma1_toplam, 0.001)
+    katman_agirliklar.beta1  = vektor_guncelle(katman_agirliklar.beta1,  grad_beta1_toplam,  0.001)
+
+    return grad_ln1
+
+def katman_norm_gradyan(grad_cikti, x, gamma, eps=1e-5):
+    n = len(x)
+    ortalama = sum(x) / n
+    varyans = sum((v - ortalama) ** 2 for v in x) / n
+    std = (varyans + eps) ** 0.5
+
+    x_norm = [(v - ortalama) / std for v in x]
+
+    grad_gamma = [grad_cikti[i] * x_norm[i] for i in range(n)]
+    grad_beta  = grad_cikti[:]
+
+    grad_x_norm = [grad_cikti[i] * gamma[i] for i in range(n)]
+
+    grad_varyans  = sum(grad_x_norm[i] * (x[i] - ortalama) for i in range(n)) * (-0.5) * (varyans + eps) ** (-1.5)
+    grad_ortalama = sum(-grad_x_norm[i] / std for i in range(n)) + grad_varyans * sum(-2 * (x[i] - ortalama) for i in range(n)) / n
+
+    grad_x = [
+        grad_x_norm[i] / std +
+        grad_varyans * 2 * (x[i] - ortalama) / n +
+        grad_ortalama / n
+        for i in range(n)
+    ]
+
+    return grad_x, grad_gamma, grad_beta

egitim_dongusu.py

@@ -0,0 +1,67 @@
+# file name 'egitim_dongusu.py'
+from sinir_agi import SinirAgi
+from egitim import egitim_adimi
+from veri import dosyadan_yukle, sozluk_olustur, egitim_ornekleri_olustur
+from model import ileri_gecis
+
+def egit(dosya_adi="veri.txt", epochs=10, ogrenme_hizi=0.001, pencere=4):
+    cumleler = dosyadan_yukle(dosya_adi)
+    kelime_sayi, sayi_kelime = sozluk_olustur(cumleler)
+    ornekler = egitim_ornekleri_olustur(cumleler, kelime_sayi, pencere)
+
+    sozluk_boyutu = len(kelime_sayi)
+    print(f"Sozcuk sayisi: {sozluk_boyutu}")
+    print(f"Egitim ornegi: {len(ornekler)}")
+
+    ag = SinirAgi(
+        sozluk_boyutu=sozluk_boyutu,
+        model_boyutu=64,
+        ff_boyutu=256,
+        kafa_sayisi=4,
+        katman_sayisi=2
+    )
+
+    for epoch in range(epochs):
+        toplam_kayip = 0.0
+        for i, (girdi, hedef) in enumerate(ornekler):
+            if len(girdi) == 0:
+                continue
+            kayip = egitim_adimi(ag, girdi, hedef, ogrenme_hizi)
+            toplam_kayip += kayip
+
+            if i % 100 == 0:
+                print(f"Adim {epoch+1} | Ornek {i}/{len(ornekler)} | Kayip: {kayip:.4f}")
+
+        ort_kayip = toplam_kayip / len(ornekler)
+        print(f"\nAdim {epoch+1} tamamlandi | Ortalama Kayip: {ort_kayip:.4f}\n")
+
+    return ag, kelime_sayi, sayi_kelime
+
+def uret(ag, kelime_sayi, sayi_kelime, baslangic_kelime, uzunluk=10, pencere=4, temperature=0.8):
+    if baslangic_kelime not in kelime_sayi:
+        print("Kelime bulunamadı.")
+        return
+
+    from rastgele import rastgele, tohum_uret
+
+    indexler = [kelime_sayi[baslangic_kelime]]
+    for _ in range(uzunluk):
+        girdi = indexler[-pencere:]
+        olasiliklar = ileri_gecis(ag, girdi)
+
+        olasiliklar = [p ** (1 / temperature) for p in olasiliklar]
+        toplam = sum(olasiliklar)
+        olasiliklar = [p / toplam for p in olasiliklar]
+
+        r = rastgele(tohum_uret(), 1)[0]
+        kumulatif = 0.0
+        tahmin = 0
+        for j, p in enumerate(olasiliklar):
+            kumulatif += p
+            if r < kumulatif:
+                tahmin = j
+                break
+
+        indexler.append(tahmin)
+
+    print(" ".join(sayi_kelime[i] for i in indexler))

islemler.py

@@ -0,0 +1,114 @@
+# file name 'islemler.py'
+from rastgele import cos, PI
+
+def carpim(A, B):
+    satir_A = len(A)
+    sutun_A = len(A[0])
+    satir_B = len(B)
+    sutun_B = len(B[0])
+
+    if sutun_A != satir_B:
+        raise ValueError("A'nin sutun sayisi B'nin satir sayisina esit olmali!")
+    
+    sonuc = [[0 for _ in range(sutun_B)] for _ in range(satir_A)]
+
+    for i in range(satir_A):
+        for j in range(sutun_B):
+            for k in range(sutun_A):
+                sonuc[i][j] += A[i][k] * B[k][j]
+    
+    return sonuc
+
+def softmax(vektor):
+    e = 2.718281828459
+    maks = max(vektor)
+    ustel_degerler = [e ** (x - maks) for x in vektor]
+    toplam = sum(ustel_degerler)
+    return [deger / toplam for deger in ustel_degerler]
+
+def transpoze(matris):
+    satir_sayisi = len(matris)
+    sutun_sayisi = len(matris[0])
+    yeni_matris = [[0 for _ in range(satir_sayisi)] for _ in range(sutun_sayisi)]
+    for i in range(satir_sayisi):
+        for j in range(sutun_sayisi):
+            yeni_matris[j][i] = matris[i][j]
+    return yeni_matris
+
+def sin(x):
+    return cos(x - PI / 2)
+
+def topla(A, B):
+    return [[A[i][j] + B[i][j] for j in range(len(A[0]))] for i in range(len(A))]
+
+def embed(token_indexleri, embedding_tablosu):
+    return [embedding_tablosu[i] for i in token_indexleri]
+
+def pozisyonel_encoding(uzunluk, boyut):
+    pe = [[0.0] * boyut for _ in range(uzunluk)]
+    for pos in range(uzunluk):
+        for i in range(0, boyut, 2):
+            pe[pos][i] = sin(pos / (10000 ** (i / boyut)))
+            if i + 1 < boyut:
+                pe[pos][i+1] = cos(pos / (10000 ** (i / boyut)))
+    return pe
+
+def dogrusal(x, W, b):
+    sonuc = carpim(x, W)
+    return [[sonuc[i][j] + b[j] for j in range(len(b))] for i in range(len(sonuc))]
+
+def gelu(x):
+    PI = 3.141592653589793
+    k = (2 / PI) ** 0.5
+    ic = k * (x + 0.044715 * x**3)
+    ic = max(-20.0, min(20.0, ic))
+    e = 2.718281828459
+    exp2 = e ** (2 * ic)
+    tanh_ic = (exp2 - 1) / (exp2 + 1)
+    return 0.5 * x * (1 + tanh_ic)
+
+def katman_norm(x, gamma, beta, eps=1e-5):
+    sonuc = []
+    for satir in x:
+        ortalama = sum(satir) / len(satir)
+        varyans = sum((v - ortalama) ** 2 for v in satir) / len(satir)
+        normalize = [(v - ortalama) / ((varyans + eps) ** 0.5) for v in satir]
+        sonuc.append([gamma[i] * normalize[i] + beta[i] for i in range(len(satir))])
+    return sonuc
+
+def attention(Q, K, V):
+    d = len(K[0])
+    olcek = d ** 0.5
+    kt = transpoze(K)
+    skorlar = carpim(Q, kt)
+    olceklenmis = [[s / olcek for s in satir] for satir in skorlar]
+    agirliklar = [softmax(satir) for satir in olceklenmis]
+    return carpim(agirliklar, V)
+
+def cok_baslikli_attention(x, att_agirliklar):
+    kafalar = []
+    for kafa in att_agirliklar.kafalar:
+        Q = carpim(x, kafa.WQ)
+        K = carpim(x, kafa.WK)
+        V = carpim(x, kafa.WV)
+        kafalar.append(attention(Q, K, V))
+
+    birlesmis = [[] for _ in range(len(x))]
+    for kafa in kafalar:
+        for i in range(len(x)):
+            birlesmis[i].extend(kafa[i])
+
+    return dogrusal(birlesmis, att_agirliklar.WO, att_agirliklar.bO)
+
+def ileri_besleme(x, ff_agirliklar):
+    ara = dogrusal(x, ff_agirliklar.W1, ff_agirliklar.b1)
+    aktivasyon = [[gelu(d) for d in satir] for satir in ara]
+    return dogrusal(aktivasyon, ff_agirliklar.W2, ff_agirliklar.b2)
+
+def transformer_blok(x, katman_agirliklar):
+    att_cikti = cok_baslikli_attention(x, katman_agirliklar.attention)
+    x = katman_norm(topla(x, att_cikti), katman_agirliklar.gamma1, katman_agirliklar.beta1)
+
+    ff_cikti = ileri_besleme(x, katman_agirliklar.ff)
+    x = katman_norm(topla(x, ff_cikti), katman_agirliklar.gamma2, katman_agirliklar.beta2)
+    return x

kaydet.py

@@ -0,0 +1,94 @@
+# file name 'kaydet.py'
+def modeli_kaydet(ag, kelime_sayi, sayi_kelime, dosya_adi="model.json"):
+    import json
+    
+    veri = {
+        "sozluk_boyutu": ag.sozluk_boyutu,
+        "model_boyutu": ag.model_boyutu,
+        "ff_boyutu": ag.ff_boyutu,
+        "kafa_sayisi": ag.kafa_sayisi,
+        "katman_sayisi": ag.katman_sayisi,
+        "kelime_sayi": kelime_sayi,
+        "sayi_kelime": {str(k): v for k, v in sayi_kelime.items()},
+        "embedding": ag.embedding,
+        "cikti_W": ag.cikti_W,
+        "cikti_b": ag.cikti_b,
+        "katmanlar": []
+    }
+
+    for katman in ag.katmanlar:
+        katman_veri = {
+            "gamma1": katman.gamma1,
+            "beta1": katman.beta1,
+            "gamma2": katman.gamma2,
+            "beta2": katman.beta2,
+            "ff": {
+                "W1": katman.ff.W1,
+                "b1": katman.ff.b1,
+                "W2": katman.ff.W2,
+                "b2": katman.ff.b2,
+            },
+            "attention": {
+                "WO": katman.attention.WO,
+                "bO": katman.attention.bO,
+                "kafalar": [
+                    {
+                        "WQ": kafa.WQ,
+                        "WK": kafa.WK,
+                        "WV": kafa.WV,
+                    }
+                    for kafa in katman.attention.kafalar
+                ]
+            }
+        }
+        veri["katmanlar"].append(katman_veri)
+
+    with open(dosya_adi, "w", encoding="utf-8") as f:
+        json.dump(veri, f, ensure_ascii=False)
+
+    print(f"Model kaydedildi: {dosya_adi}")
+
+
+def modeli_yukle(dosya_adi="model.json"):
+    import json
+    from sinir_agi import SinirAgi, KatmanAgirliklari, FFAgirliklari, AttentionAgirliklari, KafaAgirliklari
+
+    with open(dosya_adi, "r", encoding="utf-8") as f:
+        veri = json.load(f)
+
+    ag = SinirAgi(
+        sozluk_boyutu=veri["sozluk_boyutu"],
+        model_boyutu=veri["model_boyutu"],
+        ff_boyutu=veri["ff_boyutu"],
+        kafa_sayisi=veri["kafa_sayisi"],
+        katman_sayisi=veri["katman_sayisi"]
+    )
+
+    ag.embedding = veri["embedding"]
+    ag.cikti_W   = veri["cikti_W"]
+    ag.cikti_b   = veri["cikti_b"]
+
+    for i, katman_veri in enumerate(veri["katmanlar"]):
+        ag.katmanlar[i].gamma1 = katman_veri["gamma1"]
+        ag.katmanlar[i].beta1  = katman_veri["beta1"]
+        ag.katmanlar[i].gamma2 = katman_veri["gamma2"]
+        ag.katmanlar[i].beta2  = katman_veri["beta2"]
+
+        ag.katmanlar[i].ff.W1 = katman_veri["ff"]["W1"]
+        ag.katmanlar[i].ff.b1 = katman_veri["ff"]["b1"]
+        ag.katmanlar[i].ff.W2 = katman_veri["ff"]["W2"]
+        ag.katmanlar[i].ff.b2 = katman_veri["ff"]["b2"]
+
+        for j, kafa_veri in enumerate(katman_veri["attention"]["kafalar"]):
+            ag.katmanlar[i].attention.kafalar[j].WQ = kafa_veri["WQ"]
+            ag.katmanlar[i].attention.kafalar[j].WK = kafa_veri["WK"]
+            ag.katmanlar[i].attention.kafalar[j].WV = kafa_veri["WV"]
+
+        ag.katmanlar[i].attention.WO = katman_veri["attention"]["WO"]
+        ag.katmanlar[i].attention.bO = katman_veri["attention"]["bO"]
+
+    kelime_sayi  = veri["kelime_sayi"]
+    sayi_kelime  = {int(k): v for k, v in veri["sayi_kelime"].items()}
+
+    print(f"Model yüklendi: {dosya_adi}")
+    return ag, kelime_sayi, sayi_kelime

model.py

@@ -0,0 +1,20 @@
+# file name 'model.py'
+from islemler import embed, pozisyonel_encoding, topla, transformer_blok, dogrusal, softmax
+from sinir_agi import SinirAgi
+
+def ileri_gecis(ag, token_indexleri):
+    vektorler = embed(token_indexleri, ag.embedding)
+    pe = pozisyonel_encoding(len(token_indexleri), ag.model_boyutu)
+    x = topla(vektorler, pe)
+
+    for katman in ag.katmanlar:
+        x = transformer_blok(x, katman)
+
+    son_token = [x[-1]]
+    logitler = dogrusal(son_token, ag.cikti_W, ag.cikti_b)
+    olasiliklar = softmax(logitler[0])
+    return olasiliklar
+
+def tahmin_et(ag, token_indexleri):
+    olasiliklar = ileri_gecis(ag, token_indexleri)
+    return olasiliklar.index(max(olasiliklar))

rastgele.py

@@ -0,0 +1,64 @@
+# file name 'rastgele.py'
+import time
+
+PI = 3.141592653589793
+COS_TABLOSU = []
+HASSASIYET = 2000
+
+def log(x, iterasyon=100):
+    if x <= 0:
+        raise ValueError("log tanimsiz")
+    y = (x - 1) / (x + 1)
+    y2 = y * y
+    sonuc = 0.0
+    for i in range(iterasyon):
+        n = 2 * i + 1
+        sonuc += (y ** n) / n
+    return 2 * sonuc
+
+def cos(x):
+    x = x % (2 * PI)
+    if x > PI:
+        x -= 2 * PI
+    
+    sonuc = 0.0
+    terim = 1.0
+    for i in range(1, 20):
+        sonuc += terim
+        terim *= -x * x / ((2 * i - 1) * (2 * i))
+    return sonuc
+
+def tohum_uret():
+    t = time.time()
+    mikrosaniye = int(t * 1_000_000)
+    
+    a = mikrosaniye & 0xFFFF
+    b = (mikrosaniye >> 16) & 0xFFFF
+    c = (mikrosaniye >> 32) & 0xFFFF
+    
+    karisik = (a * b * c) ^ (a << 3) ^ (b >> 2) ^ c
+    return karisik
+
+def rastgele(tohum, n):
+    A = 1664525
+    C = 1013904223
+    M = 2**32
+    
+    sonuclar = []
+    durum = tohum
+    for _ in range(n):
+        durum = (A * durum + C) % M
+        sonuclar.append(durum / M)
+    return sonuclar
+
+def gauss_rastgele(tohum, n):
+    tekil = rastgele(tohum, n * 2 + 2)
+    sonuclar = []
+    for i in range(0, n * 2, 2):
+        u1 = max(tekil[i], 1e-10)
+        u2 = tekil[i+1]
+        ln = -2 * log(u1)
+        kok = ln ** 0.5
+        cos_deg = cos(2 * PI * u2)
+        sonuclar.append(kok * cos_deg)
+    return sonuclar[:n]

sinir_agi.py

@@ -0,0 +1,60 @@
+# file name 'sinir_agi.py'
+from rastgele import gauss_rastgele, tohum_uret
+
+def agirlik_olustur(satirlar, sutunlar):
+    degerler = gauss_rastgele(tohum_uret(), satirlar * sutunlar)
+    return [
+        [degerler[i * sutunlar + j] * 0.02 for j in range(sutunlar)]
+        for i in range(satirlar)
+    ]
+
+def sifir_vektor(boyut):
+    return [0.0] * boyut
+
+def bir_vektor(boyut):
+    return [1.0] * boyut
+
+class KafaAgirliklari:
+    def __init__(self, model_boyutu, kafa_boyutu):
+        self.WQ = agirlik_olustur(model_boyutu, kafa_boyutu)
+        self.WK = agirlik_olustur(model_boyutu, kafa_boyutu)
+        self.WV = agirlik_olustur(model_boyutu, kafa_boyutu)
+
+class AttentionAgirliklari:
+    def __init__(self, kafa_sayisi, model_boyutu):
+        kafa_boyutu = model_boyutu // kafa_sayisi
+        self.kafalar = [KafaAgirliklari(model_boyutu, kafa_boyutu) for _ in range(kafa_sayisi)]
+        self.WO = agirlik_olustur(model_boyutu, model_boyutu)
+        self.bO = sifir_vektor(model_boyutu)
+
+class FFAgirliklari:
+    def __init__(self, model_boyutu, ff_boyutu):
+        self.W1 = agirlik_olustur(model_boyutu, ff_boyutu)
+        self.b1 = sifir_vektor(ff_boyutu)
+        self.W2 = agirlik_olustur(ff_boyutu, model_boyutu)
+        self.b2 = sifir_vektor(model_boyutu)
+
+class KatmanAgirliklari:
+    def __init__(self, kafa_sayisi, model_boyutu, ff_boyutu):
+        self.attention = AttentionAgirliklari(kafa_sayisi, model_boyutu)
+        self.ff        = FFAgirliklari(model_boyutu, ff_boyutu)
+        self.gamma1    = bir_vektor(model_boyutu)
+        self.beta1     = sifir_vektor(model_boyutu)
+        self.gamma2    = bir_vektor(model_boyutu)
+        self.beta2     = sifir_vektor(model_boyutu)
+
+class SinirAgi:
+    def __init__(self, sozluk_boyutu, model_boyutu, ff_boyutu, kafa_sayisi, katman_sayisi):
+        self.sozluk_boyutu = sozluk_boyutu
+        self.model_boyutu  = model_boyutu
+        self.ff_boyutu     = ff_boyutu
+        self.kafa_sayisi   = kafa_sayisi
+        self.katman_sayisi = katman_sayisi
+
+        self.embedding = agirlik_olustur(sozluk_boyutu, model_boyutu)
+        self.katmanlar = [
+            KatmanAgirliklari(kafa_sayisi, model_boyutu, ff_boyutu)
+            for _ in range(katman_sayisi)
+        ]
+        self.cikti_W = agirlik_olustur(model_boyutu, sozluk_boyutu)
+        self.cikti_b = sifir_vektor(sozluk_boyutu)

teste.py

@@ -0,0 +1,41 @@
+from sinir_agi import SinirAgi
+from islemler import embed, dogrusal, softmax
+from egitim import dogrusal_gradyan, guncelle, vektor_guncelle, cross_entropy_kayip
+
+def basit_ileri(ag, token_idx):
+    x = [ag.embedding[token_idx]]  # [1 x model_boyutu]
+    logitler = dogrusal(x, ag.cikti_W, ag.cikti_b)
+    return softmax(logitler[0])
+
+def basit_egitim(ag, girdi_idx, hedef_idx, ogrenme_hizi=0.01):
+    olasiliklar = basit_ileri(ag, girdi_idx)
+    kayip = cross_entropy_kayip(olasiliklar, hedef_idx)
+
+    grad = olasiliklar[:]
+    grad[hedef_idx] -= 1.0
+    grad_matris = [grad]
+
+    x = [ag.embedding[girdi_idx]]
+    grad_x, grad_W, grad_b = dogrusal_gradyan(grad_matris, x, ag.cikti_W)
+
+    ag.cikti_W = guncelle(ag.cikti_W, grad_W, ogrenme_hizi)
+    ag.cikti_b = vektor_guncelle(ag.cikti_b, grad_b, ogrenme_hizi)
+
+    # Embedding güncelle
+    for j in range(len(ag.embedding[girdi_idx])):
+        ag.embedding[girdi_idx][j] -= ogrenme_hizi * grad_x[0][j]
+
+    return kayip
+
+# Test
+ag = SinirAgi(sozluk_boyutu=10, model_boyutu=16, ff_boyutu=32, kafa_sayisi=2, katman_sayisi=1)
+
+MERHABA = 0
+BUGÜN = 1
+
+print("Egitim başlıyor: 'merhaba → bugün'")
+for epoch in range(200):
+    kayip = basit_egitim(ag, MERHABA, BUGÜN)
+    if epoch % 20 == 0:
+        olasiliklar = basit_ileri(ag, MERHABA)
+        print(f"Epoch {epoch:3d} | Kayıp: {kayip:.4f} | P(bugün|merhaba): {olasiliklar[BUGÜN]:.4f}")

veri.py

@@ -0,0 +1,41 @@
+# file name 'veri.py'
+def dosyadan_yukle(dosya_adi="veri.txt"):
+    bitis = ".!?\n"
+    noktalamalar = ",;:\"'()[]{}-_/#*"
+
+    with open(dosya_adi, "r", encoding="utf-8") as f:
+        metin = f.read()
+
+    metin = metin.replace("İ", "i").replace("I", "ı").replace("Ş", "ş") \
+                 .replace("Ğ", "ğ").replace("Ü", "ü").replace("Ö", "ö") \
+                 .replace("Ç", "ç").lower()
+
+    for isaret in bitis:
+        metin = metin.replace(isaret, "|")
+    for isaret in noktalamalar:
+        metin = metin.replace(isaret, " ")
+
+    cumleler = [c.split() for c in metin.split("|") if c.split()]
+    return cumleler
+
+def sozluk_olustur(cumleler):
+    kelime_sayi = {}
+    sayi_kelime = {}
+    sayac = 0
+    for cumle in cumleler:
+        for kelime in cumle:
+            if kelime not in kelime_sayi:
+                kelime_sayi[kelime] = sayac
+                sayi_kelime[sayac] = kelime
+                sayac += 1
+    return kelime_sayi, sayi_kelime
+
+def egitim_ornekleri_olustur(cumleler, kelime_sayi, pencere=4):
+    ornekler = []
+    for cumle in cumleler:
+        indexler = [kelime_sayi[k] for k in cumle if k in kelime_sayi]
+        for i in range(1, len(indexler)):
+            girdi = indexler[max(0, i - pencere):i]
+            hedef = indexler[i]
+            ornekler.append((girdi, hedef))
+    return ornekler