Upload 11 files

LICENSE.md

@@ -0,0 +1,129 @@
+# Yedikule Model Lisansı
+
+Sürüm 2.0
+
+Telif hakkı sahibi: **Ahmet Karakuş** (Marul AI)
+
+## Kısaca
+
+Modeli özgürce kullanabilir, üzerine kendi modelinizi eğitebilir ve paylaşabilirsiniz. Üç şartla: ticari kullanım için izin alın, Yedikule'ye atıf yapın, türev modelinizin adında Yedikule geçsin.
+
+## 1. Kapsam
+
+Bu lisans Yedikule modelinin şu bileşenlerini kapsar:
+
+- Model ağırlıkları ve bunlardan türetilen her biçim (GGUF, ONNX, nicelenmiş sürümler, ince ayar sonucu ağırlıklar, birleştirilmiş modeller)
+- Tokenizer ve sözlüğü
+- Model mimarisi kodu (`model.py`, `config.py`)
+- Yapılandırma dosyaları ve dokümantasyon
+
+Bunların tamamı bundan sonra "Model" olarak anılır. Model üzerindeki fikri mülkiyet hakları Ahmet Karakuş'a aittir.
+
+## 2. İzin verilen kullanım
+
+Aşağıdakiler için ayrıca izin almanıza gerek yoktur. Hepsi ticari olmayan kullanımla sınırlıdır ve 3. bölümdeki şartlara tabidir.
+
+**2.1 Kullanım.** Modeli kendi cihazınızda veya sunucunuzda çalıştırabilirsiniz.
+
+**2.2 Eğitim ve araştırma.** Ders, atölye, tez, akademik araştırma ve ölçüt çalışmalarında kullanabilirsiniz.
+
+**2.3 Yeniden eğitim ve türev model.** Model üzerinde ince ayar (fine-tuning) yapabilir, sürekli eğitimle geliştirebilir, LoRA veya benzeri adaptör ekleyebilir, damıtabilir, başka modellerle birleştirebilirsiniz. Ortaya çıkan modeli yayımlayabilirsiniz.
+
+**2.4 Biçim dönüştürme.** Modeli GGUF, ONNX ve benzeri biçimlere çevirebilir, niceleyebilir (Q4, Q8 ve diğerleri) ve bu dosyaları paylaşabilirsiniz.
+
+**2.5 Yeniden dağıtım.** Modeli olduğu gibi veya değiştirilmiş halde başka platformlarda yayımlayabilirsiniz.
+
+## 3. Şartlar
+
+İzin verilen kullanımların tamamı aşağıdaki şartlara bağlıdır.
+
+**3.1 Atıf.** Modeli kullandığınız veya ondan türettiğiniz her yerde Yedikule'ye ve geliştiricisine atıf yapmalısınız. Yayımladığınız model kartında, dokümantasyonda veya akademik yayında şu bilgi bulunmalıdır:
+
+```
+Bu çalışma Yedikule modeline dayanmaktadır.
+Yedikule, 202M parametreli Türkçe dil modeli.
+Ahmet Karakuş, Marul AI, 2026.
+```
+
+**3.2 İsim.** Yedikule'den türettiğiniz bir modeli yayımlarsanız, modelin adında **Yedikule** geçmelidir. Örnek: `Yedikule-Tip`, `Yedikule-Kod`, `Firma-Yedikule-Asistan`. Modelin Yedikule'den türediğini gizleyemez, kendi sıfırdan eğitiminiz gibi sunamazsınız.
+
+**3.3 Türevler de bu lisansa tabidir.** Bu modelden türetilen her çalışma (ince ayar, sürekli eğitim, adaptör, damıtma, birleştirme, niceleme, biçim dönüşümü ve benzeri) bu lisansın kapsamındadır ve aynı koşullara bağlıdır. Türev modelinizi dağıtırken bu lisans dosyasını da birlikte vermeniz zorunludur. Türev modelinize daha gevşek bir lisans veremez, kendi lisansınızla yeniden lisanslayamazsınız. Bu yükümlülük türevin türevi için de sürer.
+
+**3.4 Telif bilgisinin korunması.** Telif hakkı beyanını ve geliştirici bilgisini kaldıramaz veya değiştiremezsiniz.
+
+## 4. Ticari kullanım
+
+Ticari kullanım, telif hakkı sahibinin yazılı izni olmadan yasaktır. Ticari kullanım şunları kapsar:
+
+- Modeli doğrudan veya dolaylı gelir getiren bir ürüne veya hizmete gömmek
+- API olarak ücretli sunmak, abonelik veya reklam geliri elde etmek
+- Kurum içi ticari süreçlerde çalıştırmak
+- Modelden türetilmiş bir modeli ticari amaçla kullanmak veya satmak
+- Danışmanlık hizmetinde kullanmak
+
+Ticari kullanım için telif hakkı sahibinden izin alın. Talebinizi şu adrese gönderin:
+
+**marulai.resmi@gmail.com**
+
+Talepler ayrıca değerlendirilir ve yazılı sözleşmeye bağlanır. Bu, modelden türetilmiş modellerin ticari kullanımı için de geçerlidir; türev modeli siz eğitmiş olsanız bile ticari kullanım izne bağlıdır.
+
+Akademik araştırma, kişisel projeler, öğrenme ve açık kaynak topluluk çalışmaları ticari kullanım sayılmaz.
+
+## 5. Eğitim verisi
+
+Bu model iki aşamada eğitildi. Ön eğitim corpus'u kısmen `uonlp/CulturaX` Türkçe alt kümesinden, kısmen telif hakkı sahibinin kendi web taramasından derlendi; CulturaX'in koşulları `mC4` ve `OSCAR` kümelerini takip eder ve her ikisi de Common Crawl üzerinden üretilmiştir.
+
+Talimat ayarı aşamasında telif hakkı sahibinin hazırladığı `MarulAI/Marul-SFT-TR` veri seti kullanıldı. Bu veri seti Apache 2.0 lisansıyla ayrıca yayımlanmıştır.
+
+Kaynak veri kümelerinin lisansları bu lisanstan bağımsız olarak yürürlüktedir. Modeli ticari amaçla kullanmak isteyen taraf, telif hakkı sahibinden izin almanın yanında ön eğitim verisinin kaynak koşullarının (mC4, OSCAR ve Common Crawl) kendi kullanım biçimine uygunluğunu da ayrıca değerlendirmelidir. Telif hakkı sahibinin verdiği ticari izin, kaynak veri koşullarından doğan yükümlülükleri ortadan kaldırmaz.
+
+## 6. Yasaklar
+
+**6.1** İzinsiz ticari kullanım.
+
+**6.2** Modeli veya türevini, Yedikule kaynaklı olduğunu gizleyerek sunmak.
+
+**6.3** Telif hakkı beyanını, lisans dosyasını veya geliştirici bilgisini kaldırmak.
+
+**6.4** Modeli yasa dışı içerik üretmek, kişileri hedef almak, yanıltıcı bilgi yaymak veya zarar verecek biçimde kullanmak.
+
+## 7. Garanti reddi
+
+Model olduğu gibi sunulur. Telif hakkı sahibi, Modelin belirli bir amaca uygunluğu, kesintisiz çalışması veya ürettiği bilginin doğruluğu konusunda garanti vermez.
+
+Model istatistiksel bir dil modelidir; yanlış, eksik veya yanıltıcı bilgi üretebilir. Tıbbi, hukuki, finansal veya güvenlik açısından kritik kararlarda tek başına kullanılmamalıdır. Çıktıların doğrulanması kullanıcının sorumluluğundadır.
+
+## 8. Sorumluluğun sınırlandırılması
+
+Telif hakkı sahibi, Modelin kullanımından doğan doğrudan veya dolaylı hiçbir zarardan sorumlu tutulamaz. Modeli kullanan taraf, kullanımdan doğacak tüm hukuki ve mali sorumluluğu kabul eder.
+
+## 9. Lisansın feshi
+
+Bu lisansın şartlarını ihlal etmeniz durumunda kullanım izniniz kendiliğinden sona erer. İhlali öğrendikten sonra otuz gün içinde düzeltirseniz izniniz geri kazanılır. Fesih, ihlal nedeniyle doğan hukuki sorumluluğu ortadan kaldırmaz.
+
+## 10. Uygulanacak hukuk
+
+Bu lisans Türkiye Cumhuriyeti hukukuna tabidir. Uyuşmazlıklarda İstanbul mahkemeleri ve icra daireleri yetkilidir.
+
+## 11. İletişim
+
+Ticari lisans, izin talepleri ve ihlal bildirimleri için:
+
+Ahmet Karakuş, Marul AI
+marulai.resmi@gmail.com
+
+---
+
+## English summary
+
+This is a non-binding summary. The Turkish text above is the governing license.
+
+Copyright Ahmet Karakuş (Marul AI).
+
+**You may**, without asking: run the model, use it for education and research, fine-tune it, distill it, merge it, quantize it, convert it to other formats, and publish the result. All of this is limited to non-commercial use.
+
+**You must**: give attribution to Yedikule and its developer; include the name **Yedikule** in the name of any derivative model you publish; ship this license with the model or any derivative; keep the copyright notice intact. Any derivative work remains subject to this same license and cannot be relicensed under different terms.
+
+**You may not**, without written permission: use the model or any derivative commercially; present the model as your own work or hide that it derives from Yedikule; remove the license or copyright notice; or use it for illegal, harmful or deceptive purposes.
+
+Provided as is, without warranty. Contact the copyright holder for commercial licensing: Ahmet Karakuş, Marul AI, marulai.resmi@gmail.com

README.md

@@ -0,0 +1,396 @@
+---
+license: other
+license_name: yedikule-model-lisansi-v2
+license_link: LICENSE.md
+base_model: MarulAI/Yedikule-202M-Base
+datasets:
+- MarulAI/Marul-SFT-TR
+language:
+- tr
+pipeline_tag: text-generation
+tags:
+- turkish
+- turkce
+- marul-ai
+- yedikule
+- instruct
+- conversational
+- reasoning
+- tool-calling
+---
+
+# Yedikule 1.4
+
+Yedikule 1.4, Marul AI'ın Türkçe için sıfırdan eğittiği 202 milyon parametreli dil modelinin en yeni talimat ayarlı sürümüdür. Cevap vermeden önce kısa bir düşünme yapar, sistem mesajındaki kurallara uyar, kendisine verilen araçları açıklamalarına bakarak seçip çağırır ve çok turlu sohbetlerde bağlamı korur.
+
+Bu sürüm, tamamen yeni ve bu model için hazırlanmış [Marul-SFT-TR](https://huggingface.co/datasets/MarulAI/Marul-SFT-TR) veri setiyle eğitildi. Önceki sürüme göre en büyük ilerleme düşünme, talimat takibi ve araç kullanımındadır: model artık eğitimde hiç görmediği araçlarla da çalışabiliyor. Ölçütlerde de yedi testin ortalamasında önceki sürümün ve temel modelin önüne geçti; okuduğunu anlamada ve zor fen sorularında açık farkla en iyi sonucu verdi. Üstelik modelin Türkçe dil bilgisi ve genel metin anlama yeteneği eksiksiz korundu.
+
+| | |
+|---|---|
+| Geliştirici | Ahmet Karakuş, Marul AI |
+| Model türü | Decoder-only Transformer, talimat ayarlı |
+| Dil | Türkçe |
+| Parametre | 202.1M |
+| Bağlam | 2048 token |
+| Ağırlık biçimi | bf16, safetensors |
+| Temel model | [Yedikule 202M Base](https://huggingface.co/MarulAI/Yedikule-202M-Base) |
+| Eğitim verisi | [Marul-SFT-TR](https://huggingface.co/datasets/MarulAI/Marul-SFT-TR) |
+| Lisans | Yedikule Model Lisansı 2.0 |
+| Sürüm | 1.4 (Ekim 2026) |
+
+GGUF sürümü llama.cpp, Ollama ve LM Studio ile doğrudan çalışır: [MarulAI/Yedikule-1.4-GGUF](https://huggingface.co/MarulAI/Yedikule-1.4-GGUF). Depoda ana modelle bit düzeyinde aynı BF16 dosyasının yanında, bu model için ölçülerek hazırlanmış Q8_0, Q6_K, Q5_K_M ve Q4_K_M sürümleri de vardır; en küçüğü 140 MB'tır.
+
+## Öne çıkanlar
+
+- **Düşünerek cevap verme.** Her cevaptan önce kullanıcının ne istediğini ve nasıl cevap vereceğini kısaca planlar. Düşünme ayrı bir bölümdür; arayüzde gizlenebilir.
+- **Araç çağırma.** Araç tanımları sistem turunda verilir. Model doğru aracı adına değil açıklamasına bakarak seçer, parametreleri kullanıcının söylediklerinden çıkarır, gerektiğinde art arda veya aynı anda birden fazla araç çağırır ve sonucu doğal bir dille aktarır. Araç gerekmeyen sorularda araç çağırmaz.
+- **Esnek sistem mesajı.** Tek bir sabit sistem mesajına bağlı değildir. Persona, kural, biçim ve uzunluk kısıtlarını, kurumsal asistan senaryolarını ve sohbet ortasında değişen talimatları izler.
+- **Çok turlu sohbet.** Önceki turlarda söylenenleri hatırlar, kullanıcı fikir değiştirdiğinde ya da yeni bir kısıt eklediğinde cevabını buna göre günceller.
+- **Doğal Türkçe.** Resmî yazan kullanıcıyı da, Türkçe karakter kullanmadan, yazım hatasıyla ya da argoyla yazanı da anlar; her zaman açık ve düzgün bir Türkçeyle cevap verir.
+
+## Örnek
+
+Aşağıdaki çıktılar, bu kartın Kullanım bölümündeki kodla ve önerilen üretim ayarlarıyla üretildi.
+
+```
+Kullanıcı : Fotosentezi kısaca anlatır mısın?
+Düşünme   : Kullanıcı fotosentezi tek cümleyle istiyor. Işığa bağlı tepkimeler ve Calvin döngüsü olarak
+            iki adımı, kısa ve net vermeliyim.
+Yedikule  : Fotosentez, bitkilerin güneş ışığını kullanarak besin üretmesi sürecidir.
+```
+
+Araç çağırma (sistem turunda `hava_durumu` aracı tanımlı):
+
+```
+Kullanıcı    : Yarın İzmir'de hava nasıl olacak?
+Araç çağrısı : {"name":"hava_durumu","arguments":{"sehir":"İzmir"}}
+Araç sonucu  : {"sehir":"İzmir","durum":"parçalı bulutlu","en_yuksek":27,"en_dusuk":19}
+Düşünme      : Sonuç yarın İzmir'de parçalı bulutlu, en yüksek 27, en düşük 19 derece. Kullanıcıya bunu
+               sade biçimde aktarmalıyım; sonuçta olmayan bilgi eklemeden.
+Yedikule     : Yarın İzmir'de hava parçalı bulutlu olacak. En yüksek 27, en düşük 19 derece.
+```
+
+## Değerlendirme
+
+Bütün modeller aynı kodla, aynı veriyle ve aynı koşullarda ölçüldü. Çoktan seçmeli görevlerde her seçeneğin bağlama göre olasılığı hesaplanır ve en olası seçenek modelin cevabı sayılır (0-shot, lm-evaluation-harness yöntemi). Üretim yapılmadığı için sonuçlar örnekleme ayarlarından bağımsızdır ve birebir tekrarlanabilir.
+
+| Ölçüt | Rastgele | Yedikule 202M Base | Yedikule 202M Instruct | Yedikule 1.4 |
+|---|---:|---:|---:|---:|
+| Belebele, okuduğunu anlama | 25,0 | 28,8 | 29,1 | **31,1** |
+| XCOPA, neden sonuç çıkarımı | 50,0 | 60,2 | **60,6** | 59,2 |
+| TurkishMMLU, lise düzeyi bilgi | 20,0 | **23,0** | 20,6 | 21,7 |
+| ARC-TR kolay, fen soruları | 25,0 | 37,3 | **39,8** | 38,8 |
+| ARC-TR zor, fen soruları | 25,0 | 24,1 | 26,5 | **28,5** |
+| HellaSwag-TR, sağduyu | 25,0 | 35,0 | **35,4** | **35,4** |
+| TurBLiMP, dil bilgisi | 50,0 | 92,8 | **93,1** | 92,6 |
+| **Ortalama** | | 43,0 | 43,6 | **43,9** |
+
+Belebele, TurkishMMLU, ARC ve HellaSwag'de uzunluğa göre normalleştirilmiş doğruluk (acc_norm), XCOPA ve TurBLiMP'te doğruluk (acc) verilmiştir. Yedikule 202M Instruct, bir önceki talimat ayarlı sürümdür.
+
+Yedikule 1.4 yedi ölçütün ortalamasında üç modelin en yükseğidir. En belirgin ilerleme okuduğunu anlamada (Belebele: temel modele göre 2,3, önceki sürüme göre 2,0 puan) ve zor fen sorularındadır (ARC zor: temel modele göre 4,4, önceki sürüme göre 2,0 puan); her ikisi de modelin metni okuyup soruya göre akıl yürütmesini gerektirir. Dil bilgisi (TurBLiMP yüzde 92,6) ve sağduyu (HellaSwag) korunmuştur: talimat ayarı modele yeni beceriler kazandırırken Türkçesine zarar vermemiştir. XCOPA, TurkishMMLU ve ARC kolaydaki farklar ölçüm belirsizliği sınırındadır. Bu tür bilgi ölçütlerinin sonucunu esas olarak ön eğitim belirler; 202 milyon parametrelik bir modelin geniş dünya bilgisi isteyen TurkishMMLU gibi ölçütlerde rastgele düzeye yakın kalması beklenen bir durumdur.
+
+Talimat ayarının asıl kazancı bu ölçütlerin ölçmediği yerdedir: düşünme, talimat takibi ve araç kullanımı. Aşağıdaki sonuçlar, Marul-SFT-TR'nin eğitimde hiç kullanılmayan doğrulama sohbetlerinde, modelin ilk cevabı en olası tokenler seçilerek üretilip ölçüldü.
+
+| Araç kullanımı | Sonuç |
+|---|---:|
+| Araç gereken durumlarda geçerli bir çağrı üretme (282 sohbet) | yüzde 89,7 |
+| Doğru aracı seçme | yüzde 75,9 |
+| Zorunlu parametreleri eksiksiz doldurma | yüzde 87,9 |
+| Eğitimde hiç görülmemiş araç adlarında doğru aracı seçme (30 sohbet) | yüzde 73,3 |
+| Araç gerekmeyen durumlarda araç çağırmama (159 sohbet) | yüzde 73,0 |
+
+Önceki sürüm yalnızca eğitimde gördüğü 15 araçla güvenilir biçimde çalışabiliyordu. Yedikule 1.4 ise araçları adlarından değil açıklamalarından tanımayı öğrendi; eğitimde hiç görmediği araçlarla da çalışabiliyor.
+
+Ölçütler: [Belebele](https://huggingface.co/datasets/facebook/belebele) (tur_Latn, okuduğunu anlama), [XCOPA](https://huggingface.co/datasets/cambridgeltl/xcopa) (tr, neden sonuç çıkarımı), [TurkishMMLU](https://huggingface.co/datasets/AYueksel/TurkishMMLU) (lise düzeyi bilgi), [ARC-TR](https://huggingface.co/datasets/malhajar/arc-tr) (fen soruları, kolay ve zor), [HellaSwag-TR](https://huggingface.co/datasets/malhajar/hellaswag_tr-v0.2) (sağduyu ile cümle tamamlama), [TurBLiMP](https://huggingface.co/datasets/juletxara/turblimp) (Türkçe dil bilgisi, 16 olguda 15.980 cümle çifti).
+
+## Eğitim verisi: Marul-SFT-TR
+
+Yedikule 1.4'ün sohbet yeteneklerinin kaynağı, bu model için baştan Türkçe olarak tasarlanan [Marul-SFT-TR](https://huggingface.co/datasets/MarulAI/Marul-SFT-TR) veri setidir. Çeviri değildir; Türk kültürü, günlük hayat, kurumlar ve konuşma alışkanlıkları gözetilerek hazırlandı.
+
+| | |
+|---|---|
+| Sohbet | 99.847 |
+| Kategori ve görev türü | 18 kategori, 244 görev türü |
+| Çok turlu sohbet | yüzde 85,7 |
+| Farklı sistem mesajı | 55.208 |
+| Araç tanımı içeren sohbet | 16.724 (9.571 farklı araç adı) |
+| Araç çağrısı | 24.510 (ardışık ve paralel çağrılar dahil) |
+| Düşünme metni olan asistan cevabı | yüzde 100 |
+
+Her sohbet ayrıntılı bir tariften üretildi: görev türü, kategori, sistem mesajı, kullanıcı profili ve yazım tarzı, hedef uzunluk, tur sayısı ve araç görevlerinde o senaryoya özel araç tanımları. Ardından çok katmanlı bir kalite kontrolünden geçti: biçim, dil ve araç çağrısı kontrolleri, birbirine benzeyen sohbetlerin ayıklanması ve her sohbetin bağımsız bir hakem model tarafından olgusal doğruluk, hesap doğruluğu, talimata uyum, araç kullanımı ve Türkçenin doğallığı açısından tek tek incelenmesi. 231.718 üretim denemesinin yalnızca yaklaşık yüzde 43'ü bütün kontrolleri geçti. Veri setinin kendisi Apache 2.0 lisansıyla ayrıca yayımlanmıştır.
+
+## Eğitim
+
+Model, [Yedikule 202M Base](https://huggingface.co/MarulAI/Yedikule-202M-Base) ağırlıklarından başlatılarak Marul-SFT-TR ile tam parametre ince ayarla eğitildi.
+
+| | |
+|---|---|
+| Eğitim / doğrulama | 97.261 / 2.586 sohbet |
+| Epoch | 2 (2.353 optimizer adımı) |
+| Optimizer | AdamW, tepe öğrenme hızı 1,5e-4, kosinüs azalma |
+| Kayıp | yalnızca asistan turları: düşünme, cevap, araç çağrısı ve `<\|im_end\|>` |
+| Doğrulama kaybı | 3,577'den 1,672'ye |
+| Biçim tokeni isabeti | yüzde 95 |
+
+Talimat ayarı sırasında modelin genel Türkçe bilgisini kaybetmemesi için eğitime bir miktar düz Türkçe metin karıştırıldı. Eğitimden sonra, eğitimde hiç görülmeyen genel web metinlerinde ölçülen perplexity değişimi yalnızca yüzde 1,2 oldu; model yeni beceriler kazanırken dil bilgisini korudu.
+
+## Sohbet şablonu
+
+Şablon eğitimde görülen biçimin birebir aynısıdır.
+
+```
+<|bos|><|im_start|><|system|>
+{sistem mesajı}<|im_end|>
+<|im_start|><|user|>
+{kullanıcı mesajı}<|im_end|>
+<|im_start|><|assistant|>
+<think>{düşünme}</think>
+{cevap}<|im_end|>
+```
+
+Standart ChatML değildir: rol adları düz metin değil, ayrı özel tokenlerdir. Sistem turu isteğe bağlıdır.
+
+| Kimlik | Token | Anlamı |
+|---:|---|---|
+| 3 | `<\|bos\|>` | dizinin başı |
+| 4 | `<\|im_start\|>` | tur başlangıcı |
+| 5 | `<\|im_end\|>` | tur sonu, üretim burada durur |
+| 6, 7, 8 | `<\|system\|>`, `<\|user\|>`, `<\|assistant\|>` | roller |
+| 9 | `<think>` | düşünme başlangıcı |
+| 10 | `</think>` | düşünme sonu |
+| 11 | `<tool_call>` | araç çağrısı başlangıcı |
+| 12 | `</tool_call>` | araç çağrısı sonu |
+| 13 | `<\|tool\|>` | araç sonucu rolü |
+| 14 | `<tools>` | araç tanımları başlangıcı |
+| 15 | `</tools>` | araç tanımları sonu |
+
+Token adları ve kimlikleri GGUF dosyasında da aynıdır. Taban modelin tokenizer'ında 9-15 kimlikleri `<|reserved_0|>` ile `<|reserved_6|>` arasındaki adlarla durur. Kimlikler aynı olduğu için iki tokenizer metni aynı token dizisine çevirir: talimat verisinin tamamında (99.847 sohbet, 83,4 milyon token) ve düz Türkçe metinde sonuç birebir aynıdır. Taban modelden ince ayar yaparken bu tokenizer'ı doğrudan kullanabilirsiniz.
+
+Üretimi `<|im_end|>` (5) tokeninde durdurun. İstemi her zaman `<|im_start|><|assistant|>\n` ile bitirin; model cevabına kendiliğinden düşünme bloğuyla başlar. Çok turlu sohbetlerde önceki asistan turlarını düşünmeleriyle birlikte geçmişe ekleyin; model eğitimde bu biçimi gördü. Aynı bilgiler `chat_format.json` dosyasında da bulunur.
+
+### Araç çağırma biçimi
+
+Araç tanımları sistem turunun sonuna, her biri tek satırlık ve boşluksuz bir JSON olarak eklenir:
+
+```
+<|im_start|><|system|>
+{sistem mesajı}
+
+<tools>
+{"name":"hava_durumu","description":"Bir şehrin hava tahminini getirir.","parameters":{"sehir":{"type":"string","description":"Şehir adı"},"gun":{"type":"integer","description":"Kaç gün sonrası (0 = bugün, 1 = yarın)"}},"required":["sehir"]}
+</tools><|im_end|>
+```
+
+`parameters` alanı yalnızca özellikleri içerir; zorunlu alanlar `required` listesinde verilir, liste boşsa yazılmaz. Model bir araç çağırmak istediğinde cevabının sonuna şunu yazar:
+
+```
+<tool_call>{"name":"hava_durumu","arguments":{"sehir":"İzmir","gun":1}}</tool_call><|im_end|>
+```
+
+Aracı çalıştırıp sonucunu ayrı bir turda verin, ardından modelden devam etmesini isteyin:
+
+```
+<|im_start|><|tool|>
+{"sehir":"İzmir","durum":"parçalı bulutlu","en_yuksek":27,"en_dusuk":19}<|im_end|>
+<|im_start|><|assistant|>
+```
+
+Bir turda birden fazla çağrı art arda yazılabilir; sonuçlar çağrılarla aynı sırada, her biri ayrı bir araç turunda verilir.
+
+## Kullanım
+
+```bash
+pip install torch tokenizers safetensors
+```
+
+Dosyaları indirdiğiniz klasörde çalıştırın; `model.py` ve `config.py` modelin kendi mimari dosyalarıdır.
+
+```python
+import json
+import re
+
+import torch
+from safetensors.torch import load_file
+from tokenizers import Tokenizer
+
+from config import ModelConfig
+from model import MarulLLM
+
+cfg = ModelConfig.load("model_config.json")
+model = MarulLLM(cfg)
+model.load_state_dict({k: v.float() for k, v in load_file("model.safetensors").items()})
+device = "cuda" if torch.cuda.is_available() else "cpu"
+model.eval().to(device)
+tok = Tokenizer.from_file("tokenizer.json")
+
+THINK, THINK_END = "<think>", "</think>"
+CALL, CALL_END = "<tool_call>", "</tool_call>"
+TOOL, TOOLS, TOOLS_END = "<|tool|>", "<tools>", "</tools>"
+
+
+def compact(obj):
+    return json.dumps(obj, ensure_ascii=False, separators=(",", ":"))
+
+
+def tool_line(tool):
+    """OpenAI biçimindeki araç tanımını modelin eğitimde gördüğü tek satırlık biçime çevirir."""
+    f = tool.get("function", tool)
+    p = f.get("parameters") or {}
+    d = {"name": f["name"], "description": f.get("description", ""), "parameters": p.get("properties", {})}
+    if p.get("required"):
+        d["required"] = p["required"]
+    return compact(d)
+
+
+def build_prompt(messages, tools=None):
+    system = None
+    if messages and messages[0]["role"] == "system":
+        system, messages = messages[0]["content"].strip(), messages[1:]
+    parts = [system] if system else []
+    if tools:
+        parts.append(TOOLS + "\n" + "\n".join(tool_line(t) for t in tools) + "\n" + TOOLS_END)
+    s = "<|bos|>"
+    if parts:
+        s += "<|im_start|><|system|>\n" + "\n\n".join(parts) + "<|im_end|>\n"
+    for m in messages:
+        if m["role"] == "assistant":
+            calls = "".join(CALL + compact({"name": c["name"], "arguments": c["arguments"]}) + CALL_END
+                            for c in m.get("tool_calls", []))
+            s += ("<|im_start|><|assistant|>\n" + THINK + m.get("reasoning", "").strip() + THINK_END + "\n"
+                  + m.get("content", "").strip() + calls + "<|im_end|>\n")
+        elif m["role"] == "tool":
+            s += "<|im_start|>" + TOOL + "\n" + m["content"].strip() + "<|im_end|>\n"
+        else:
+            s += "<|im_start|><|user|>\n" + m["content"].strip() + "<|im_end|>\n"
+    return s + "<|im_start|><|assistant|>\n"
+
+
+def chat(messages, tools=None, max_new_tokens=600):
+    ids = tok.encode(build_prompt(messages, tools), add_special_tokens=False).ids
+    out = model.generate(torch.tensor([ids], device=device), max_new_tokens=max_new_tokens,
+                         temperature=0.4, top_k=50, top_p=0.9, min_p=0.05,
+                         repetition_penalty=1.12, no_repeat_ngram_size=0, eos_token_id=5)
+    text = tok.decode(out[0, len(ids):].tolist(), skip_special_tokens=False).split("<|im_end|>")[0]
+    reasoning, _, rest = text.partition(THINK_END)
+    calls = [json.loads(c) for c in re.findall(re.escape(CALL) + "(.*?)" + re.escape(CALL_END), rest, re.S)]
+    content = re.sub(re.escape(CALL) + ".*?" + re.escape(CALL_END), "", rest, flags=re.S).strip()
+    return {"role": "assistant", "reasoning": reasoning.replace(THINK, "").strip(), "content": content,
+            "tool_calls": calls}
+
+
+torch.manual_seed(0)
+messages = [
+    {"role": "system", "content": "Adın Yedikule. Marul AI tarafından Türkçe için geliştirilmiş bir yapay zeka "
+                                  "asistanısın. Kullanıcılara yardım ederken açık, doğru ve nazik ol."},
+    {"role": "user", "content": "Fotosentezi kısaca anlatır mısın?"},
+]
+reply = chat(messages)
+print(reply["reasoning"])   # düşünme
+print(reply["content"])     # cevap
+
+# Araç çağırma
+tools = [{"type": "function", "function": {
+    "name": "hava_durumu",
+    "description": "Bir şehrin hava tahminini getirir.",
+    "parameters": {"type": "object",
+                   "properties": {"sehir": {"type": "string", "description": "Şehir adı"},
+                                  "gun": {"type": "integer", "description": "Kaç gün sonrası (0 = bugün, 1 = yarın)"}},
+                   "required": ["sehir"]}}}]
+messages = [{"role": "user", "content": "Yarın İzmir'de hava nasıl olacak?"}]
+reply = chat(messages, tools)
+print(reply["tool_calls"])
+
+result = {"sehir": "İzmir", "durum": "parçalı bulutlu", "en_yuksek": 27, "en_dusuk": 19}
+messages += [reply, {"role": "tool", "content": compact(result)}]
+print(chat(messages, tools)["content"])
+```
+
+`build_prompt` eğitimdeki sohbet biçimini birebir üretir; `chat` cevabı düşünme, metin ve araç çağrıları olarak ayırır. Araç sonucunu `{"role": "tool", ...}` mesajıyla geçmişe ekleyip `chat`'i yeniden çağırdığınızda model sonucu kullanarak cevabını yazar. `model.generate` önbelleksiz çalışır; daha hızlı ve hafif kullanım için [GGUF sürümünü](https://huggingface.co/MarulAI/Yedikule-1.4-GGUF) llama.cpp veya Ollama ile çalıştırabilirsiniz.
+
+## Önerilen üretim ayarları
+
+Önerilen değerler `generation_config.json` dosyasındadır:
+
+| Ayar | Değer |
+|---|---|
+| temperature | 0,4 |
+| top_k | 50 |
+| top_p | 0,9 |
+| min_p | 0,05 |
+| repetition_penalty | 1,12 |
+| no_repeat_ngram_size | 0 |
+| max_new_tokens | 1024 |
+
+Bu değerler; şablon metinler (e-posta, dilekçe, liste gibi), genel sorular ve araç çağırma görevlerinden oluşan bir ölçümle, altı farklı ayar karşılaştırılarak seçildi. Önceki sürümün ayarlarına (temperature 0,3, repetition_penalty 1,08) göre tekrar döngüsüne girme oranı yüzde 6,2'den yüzde 2,5'e indi; araç çağırma doğruluğu korundu.
+
+Daha olgusal ve tutarlı cevaplar için sıcaklığı 0,3'e indirebilir, daha yaratıcı metinler için 0,6'ya kadar çıkarabilirsiniz. Tekrar cezasını 1,15'in üzerine çıkarmayın: Türkçe ekleri bozmaya başlar ve gereksiz araç çağrılarını artırır. `no_repeat_ngram_size` kapalı kalmalıdır; açık olduğunda model araç adlarını ve JSON yapılarını istemden kopyalayamaz.
+
+## Sistem mesajı
+
+Model 55 binden fazla farklı sistem mesajıyla eğitildi; kendi sistem mesajınızı rahatlıkla yazabilirsiniz. Genel bir asistan için şu metin iyi bir başlangıçtır:
+
+```
+Adın Yedikule. Marul AI tarafından Türkçe için geliştirilmiş bir yapay zeka asistanısın. Kullanıcılara yardım ederken açık, doğru ve nazik ol.
+```
+
+Sistem mesajı vermeden de kullanılabilir; eğitim sohbetlerinin yaklaşık beşte biri sistem mesajı içermiyordu.
+
+## Mimari
+
+- 24 katman, 768 gizli boyut, 2304 ara boyut
+- Grouped Query Attention: 12 sorgu başlığı, 4 anahtar/değer başlığı, başlık boyutu 64
+- Pre-norm RMSNorm, RoPE (theta 10000), SwiGLU
+- Başlık boyutunda QK-Norm, RoPE'den önce uygulanır
+- Bağlı giriş ve çıkış gömmeleri, hiçbir katmanda bias yok
+- Tokenizer: Türkçe için eğitilmiş 48 bin tokenlik Byte-Level BPE
+
+Mimari `model.py` içinde tanımlıdır; torch dışında bağımlılığı yoktur.
+
+## Sınırlar
+
+Yedikule 1.4 202 milyon parametrelik küç��k bir modeldir. Günlük sohbet, açıklama, özetleme, metin düzeltme, yazım ve araçlarla çalışma gibi işlerde iyi sonuç verir; geniş dünya bilgisi isteyen sorularda ve çok adımlı aritmetikte hata yapabilir. Hesap gerektiren işlerde ona bir hesap makinesi aracı vermek doğruluğu belirgin biçimde artırır. Çok kurallı ve uzun sistem mesajlarındaki her ayrıntıyı (örneğin bir fiyat listesinin tamamını) her zaman doğru kullanamayabilir; kritik bilgileri kısa ve açık yazın. Bilgisi 2026 yılına kadardır ve internete erişimi yoktur.
+
+Model yanlış veya eksik bilgi üretebilir. Ürettiği bilgiyi doğrulamadan kullanmayın; tıbbi, hukuki, finansal veya güvenlik açısından kritik kararlarda tek başına kullanmayın.
+
+## Dosyalar
+
+| Dosya | İçerik |
+|---|---|
+| `model.safetensors` | bf16 ağırlıklar, 404 MB |
+| `model.py` | model mimarisi |
+| `config.py` | `ModelConfig` veri sınıfı |
+| `model_config.json` | mimari parametreleri |
+| `tokenizer.json` | 48 bin tokenlik Byte-Level BPE |
+| `tokenizer_config.json` | tokenizer meta bilgisi |
+| `tokenizer_info.json` | özel tokenler ve tokenizasyon örnekleri |
+| `chat_format.json` | sohbet şablonu ve özel tokenlerin anlamları |
+| `generation_config.json` | önerilen üretim ayarları |
+| `LICENSE.md` | lisans tam metni |
+
+## Lisans
+
+Yedikule Model Lisansı 2.0. Telif hakkı sahibi Ahmet Karakuş (Marul AI). Bağlayıcı metin `LICENSE.md` dosyasındadır.
+
+İzin almadan yapabilecekleriniz: modeli çalıştırmak, eğitim ve araştırmada kullanmak, üzerine ince ayar yapmak, damıtmak, birleştirmek, nicelemek, başka biçimlere çevirmek ve sonucu yayımlamak. Hepsi ticari olmayan kullanımla sınırlıdır.
+
+Uymanız gerekenler: Yedikule'ye atıf yapmak, türev modelinizin adında **Yedikule** geçirmek, lisansı model ile birlikte dağıtmak ve telif bilgisini korumak.
+
+**Türevler de bu lisansa tabidir.** Modelden türettiğiniz her çalışma aynı koşullara bağlı kalır; kendi lisansınızla yeniden lisanslayamazsınız. Türev modeli siz eğitmiş olsanız bile ticari kullanımı izne bağlıdır.
+
+Ticari kullanım yazılı izne bağlıdır. Ticari lisans ve izin talepleri: **marulai.resmi@gmail.com** (Ahmet Karakuş, Marul AI)
+
+## Atıf
+
+```
+Bu çalışma Yedikule modeline dayanmaktadır.
+Yedikule, 202M parametreli Türkçe dil modeli.
+Ahmet Karakuş, Marul AI, 2026.
+https://huggingface.co/MarulAI/Yedikule-1.4
+```
+
+Eğitim verisi:
+
+```
+Marul-SFT-TR, Ahmet Karakuş (Marul AI), 2026.
+https://huggingface.co/datasets/MarulAI/Marul-SFT-TR
+```

chat_format.json

@@ -0,0 +1,91 @@
+{
+  "aciklama": "Yedikule 1.4 sohbet biçimi. Kimlikler ve adlar tokenizer.json ve GGUF dosyasıyla aynıdır. 9-15 kimlikli tokenler taban modelin (Yedikule-202M-Base) tokenizer'ında <|reserved_0|> ile <|reserved_6|> arasındaki adlarla durur; kimlikler aynıdır.",
+  "ozel_tokenler": {
+    "<|endoftext|>": {
+      "kimlik": 0,
+      "anlam": "metin sonu"
+    },
+    "<|pad|>": {
+      "kimlik": 1,
+      "anlam": "dolgu"
+    },
+    "<|unk|>": {
+      "kimlik": 2,
+      "anlam": "bilinmeyen"
+    },
+    "<|bos|>": {
+      "kimlik": 3,
+      "anlam": "dizinin başı, her istemin ilk tokeni"
+    },
+    "<|im_start|>": {
+      "kimlik": 4,
+      "anlam": "tur başlangıcı"
+    },
+    "<|im_end|>": {
+      "kimlik": 5,
+      "anlam": "tur sonu, üretim burada durdurulur"
+    },
+    "<|system|>": {
+      "kimlik": 6,
+      "anlam": "sistem rolü"
+    },
+    "<|user|>": {
+      "kimlik": 7,
+      "anlam": "kullanıcı rolü"
+    },
+    "<|assistant|>": {
+      "kimlik": 8,
+      "anlam": "asistan rolü"
+    },
+    "<think>": {
+      "kimlik": 9,
+      "anlam": "düşünme başlangıcı"
+    },
+    "</think>": {
+      "kimlik": 10,
+      "anlam": "düşünme sonu"
+    },
+    "<tool_call>": {
+      "kimlik": 11,
+      "anlam": "araç çağrısı başlangıcı"
+    },
+    "</tool_call>": {
+      "kimlik": 12,
+      "anlam": "araç çağrısı sonu"
+    },
+    "<|tool|>": {
+      "kimlik": 13,
+      "anlam": "araç sonucu rolü"
+    },
+    "<tools>": {
+      "kimlik": 14,
+      "anlam": "araç tanımları başlangıcı"
+    },
+    "</tools>": {
+      "kimlik": 15,
+      "anlam": "araç tanımları sonu"
+    }
+  },
+  "sablon": {
+    "sistem": "<|im_start|><|system|>\n{sistem mesajı}\n\n<tools>\n{araç tanımı, satır başına bir}\n</tools><|im_end|>\n",
+    "kullanici": "<|im_start|><|user|>\n{mesaj}<|im_end|>\n",
+    "asistan": "<|im_start|><|assistant|>\n<think>{düşünme}</think>\n{cevap}<tool_call>{araç çağrısı JSON}</tool_call><|im_end|>\n",
+    "arac_sonucu": "<|im_start|><|tool|>\n{araç sonucu}<|im_end|>\n",
+    "uretim_istemi": "<|im_start|><|assistant|>\n"
+  },
+  "kurallar": [
+    "İstem <|bos|> ile başlar.",
+    "Sistem turu isteğe bağlıdır. Araç verilmişse ve sistem mesajı yoksa, sistem turu yalnızca araç tanımlarını içerir.",
+    "Araç tanımı tek satırlık, boşluksuz JSON'dur: {\"name\":...,\"description\":...,\"parameters\":{özellikler},\"required\":[...]}. required boşsa yazılmaz.",
+    "Araç çağrısı boşluksuz JSON'dur: {\"name\":...,\"arguments\":{...}}. Bir turda birden fazla çağrı art arda yazılabilir.",
+    "Asistan her turda önce düşünür. Çok turlu sohbetlerde önceki asistan turlarının düşünmelerini de geçmişe ekleyin.",
+    "Üretimi <|im_end|> (5) tokeninde durdurun."
+  ],
+  "stop_token_id": 5,
+  "prompt_suffix": "<|im_start|><|assistant|>\n",
+  "prompt_suffix_ids": [
+    4,
+    8,
+    214
+  ]
+}

config.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+import json
+
+
+@dataclass
+class ModelConfig:
+    vocab_size: int = 48000
+    max_seq_len: int = 2048
+
+    hidden_size: int = 768
+    intermediate_size: int = 2304
+    num_layers: int = 24
+    num_heads: int = 12
+    num_kv_heads: int = 4
+
+    rope_theta: float = 10_000.0
+
+    rms_norm_eps: float = 1.0e-5
+    qk_norm: bool = True
+
+    initializer_range: float = 0.02
+
+    eos_token_id: int = 0
+    pad_token_id: int = 1
+    bos_token_id: int = 3
+
+    tie_word_embeddings: bool = True
+
+    z_loss_coef: float = 1.0e-4
+    attn_dropout: float = 0.0
+    resid_dropout: float = 0.0
+
+    @property
+    def head_dim(self) -> int:
+        assert self.hidden_size % self.num_heads == 0
+        return self.hidden_size // self.num_heads
+
+    @property
+    def kv_groups(self) -> int:
+        assert self.num_heads % self.num_kv_heads == 0
+        return self.num_heads // self.num_kv_heads
+
+    @classmethod
+    def load(cls, path: str | Path) -> "ModelConfig":
+        d = json.loads(Path(path).read_text(encoding="utf-8"))
+        valid = {f for f in cls.__dataclass_fields__}
+        return cls(**{k: v for k, v in d.items() if k in valid})

generation_config.json

@@ -0,0 +1,13 @@
+{
+  "bos_token_id": 3,
+  "eos_token_id": 5,
+  "pad_token_id": 1,
+  "do_sample": true,
+  "temperature": 0.4,
+  "top_k": 50,
+  "top_p": 0.9,
+  "min_p": 0.05,
+  "repetition_penalty": 1.12,
+  "no_repeat_ngram_size": 0,
+  "max_new_tokens": 1024
+}

model.py

@@ -0,0 +1,307 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch import Tensor
+
+from config import ModelConfig
+
+
+class RMSNorm(nn.Module):
+    def __init__(self, dim: int, eps: float = 1.0e-5):
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(dim))
+        self.eps = eps
+
+    def forward(self, x: Tensor) -> Tensor:
+        dtype = x.dtype
+        x32 = x.float()
+        rms = x32.pow(2).mean(dim=-1, keepdim=True).add_(self.eps).rsqrt_()
+        out = (x32 * rms).to(dtype)
+        return out * self.weight.to(dtype)
+
+
+class RotaryEmbedding(nn.Module):
+    def __init__(self, head_dim: int, max_seq_len: int, theta: float = 10_000.0):
+        super().__init__()
+        self.head_dim = head_dim
+        self.max_seq_len = max_seq_len
+        self.theta = theta
+        self._cached_len: int = 0
+        self._cos_cache: Optional[Tensor] = None
+        self._sin_cache: Optional[Tensor] = None
+
+    def _build_cache(self, seq_len: int, device, dtype):
+        inv_freq = 1.0 / (
+            self.theta ** (torch.arange(0, self.head_dim, 2, dtype=torch.float32, device=device) / self.head_dim)
+        )
+        t = torch.arange(seq_len, dtype=torch.float32, device=device)
+        freqs = torch.outer(t, inv_freq)
+        emb = torch.cat([freqs, freqs], dim=-1)
+        self._cos_cache = emb.cos().to(dtype)
+        self._sin_cache = emb.sin().to(dtype)
+        self._cached_len = seq_len
+
+    def forward(self, seq_len: int, device, dtype) -> tuple[Tensor, Tensor]:
+        if (
+            self._cos_cache is None
+            or seq_len > self._cached_len
+            or self._cos_cache.device != device
+            or self._cos_cache.dtype != dtype
+        ):
+            self._build_cache(max(seq_len, self.max_seq_len), device, dtype)
+        return self._cos_cache[:seq_len], self._sin_cache[:seq_len]
+
+
+def _rotate_half(x: Tensor) -> Tensor:
+    x1, x2 = x.chunk(2, dim=-1)
+    return torch.cat([-x2, x1], dim=-1)
+
+
+def apply_rope(q: Tensor, k: Tensor, cos: Tensor, sin: Tensor) -> tuple[Tensor, Tensor]:
+    cos = cos.unsqueeze(0).unsqueeze(0)
+    sin = sin.unsqueeze(0).unsqueeze(0)
+    q_rot = (q * cos) + (_rotate_half(q) * sin)
+    k_rot = (k * cos) + (_rotate_half(k) * sin)
+    return q_rot, k_rot
+
+
+class Attention(nn.Module):
+    def __init__(self, cfg: ModelConfig, layer_idx: int):
+        super().__init__()
+        self.cfg = cfg
+        self.layer_idx = layer_idx
+        self.num_heads = cfg.num_heads
+        self.num_kv_heads = cfg.num_kv_heads
+        self.head_dim = cfg.head_dim
+        self.kv_groups = cfg.kv_groups
+        self.scale = self.head_dim ** -0.5
+
+        h, hd = cfg.hidden_size, self.head_dim
+        self.q_proj = nn.Linear(h, self.num_heads * hd, bias=False)
+        self.k_proj = nn.Linear(h, self.num_kv_heads * hd, bias=False)
+        self.v_proj = nn.Linear(h, self.num_kv_heads * hd, bias=False)
+        self.o_proj = nn.Linear(self.num_heads * hd, h, bias=False)
+
+        if cfg.qk_norm:
+            self.q_norm = RMSNorm(hd, eps=cfg.rms_norm_eps)
+            self.k_norm = RMSNorm(hd, eps=cfg.rms_norm_eps)
+        else:
+            self.q_norm = nn.Identity()
+            self.k_norm = nn.Identity()
+
+        self.attn_dropout = cfg.attn_dropout
+
+    def forward(self, x: Tensor, cos: Tensor, sin: Tensor) -> Tensor:
+        B, S, _ = x.shape
+        q = self.q_proj(x).view(B, S, self.num_heads, self.head_dim)
+        k = self.k_proj(x).view(B, S, self.num_kv_heads, self.head_dim)
+        v = self.v_proj(x).view(B, S, self.num_kv_heads, self.head_dim)
+
+        q = self.q_norm(q)
+        k = self.k_norm(k)
+
+        q = q.transpose(1, 2)
+        k = k.transpose(1, 2)
+        v = v.transpose(1, 2)
+
+        q, k = apply_rope(q, k, cos, sin)
+
+        if self.kv_groups > 1:
+            k = k.repeat_interleave(self.kv_groups, dim=1)
+            v = v.repeat_interleave(self.kv_groups, dim=1)
+
+        out = F.scaled_dot_product_attention(
+            q, k, v,
+            attn_mask=None,
+            dropout_p=self.attn_dropout if self.training else 0.0,
+            is_causal=True,
+        )
+        out = out.transpose(1, 2).contiguous().view(B, S, self.num_heads * self.head_dim)
+        return self.o_proj(out)
+
+
+class SwiGLU(nn.Module):
+    def __init__(self, cfg: ModelConfig):
+        super().__init__()
+        h, i = cfg.hidden_size, cfg.intermediate_size
+        self.gate_proj = nn.Linear(h, i, bias=False)
+        self.up_proj = nn.Linear(h, i, bias=False)
+        self.down_proj = nn.Linear(i, h, bias=False)
+
+    def forward(self, x: Tensor) -> Tensor:
+        return self.down_proj(F.silu(self.gate_proj(x)) * self.up_proj(x))
+
+
+class Block(nn.Module):
+    def __init__(self, cfg: ModelConfig, layer_idx: int):
+        super().__init__()
+        self.input_norm = RMSNorm(cfg.hidden_size, cfg.rms_norm_eps)
+        self.attn = Attention(cfg, layer_idx)
+        self.post_attn_norm = RMSNorm(cfg.hidden_size, cfg.rms_norm_eps)
+        self.mlp = SwiGLU(cfg)
+        self.resid_drop = nn.Dropout(cfg.resid_dropout) if cfg.resid_dropout > 0 else nn.Identity()
+
+    def forward(self, x: Tensor, cos: Tensor, sin: Tensor) -> Tensor:
+        x = x + self.resid_drop(self.attn(self.input_norm(x), cos, sin))
+        x = x + self.resid_drop(self.mlp(self.post_attn_norm(x)))
+        return x
+
+
+class MarulLLM(nn.Module):
+    def __init__(self, cfg: ModelConfig):
+        super().__init__()
+        self.cfg = cfg
+
+        self.embed_tokens = nn.Embedding(cfg.vocab_size, cfg.hidden_size)
+        self.rotary = RotaryEmbedding(cfg.head_dim, cfg.max_seq_len, cfg.rope_theta)
+        self.layers = nn.ModuleList(Block(cfg, i) for i in range(cfg.num_layers))
+        self.final_norm = RMSNorm(cfg.hidden_size, cfg.rms_norm_eps)
+
+        if cfg.tie_word_embeddings:
+            self.lm_head = None
+        else:
+            self.lm_head = nn.Linear(cfg.hidden_size, cfg.vocab_size, bias=False)
+
+        self.apply(self._init_weights)
+        self._scale_residual_inits()
+
+        self.num_params = sum(p.numel() for p in self.parameters())
+        self.num_params_trainable = sum(p.numel() for p in self.parameters() if p.requires_grad)
+        embed_params = cfg.vocab_size * cfg.hidden_size
+        self.num_params_non_embed = self.num_params - embed_params
+
+    def _init_weights(self, module: nn.Module) -> None:
+        std = self.cfg.initializer_range
+        if isinstance(module, nn.Linear):
+            nn.init.normal_(module.weight, mean=0.0, std=std)
+            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=std)
+
+    def _scale_residual_inits(self) -> None:
+        scale = (2 * self.cfg.num_layers) ** -0.5
+        with torch.no_grad():
+            for block in self.layers:
+                block.attn.o_proj.weight.mul_(scale)
+                block.mlp.down_proj.weight.mul_(scale)
+
+    def forward(
+        self,
+        input_ids: Tensor,
+        targets: Optional[Tensor] = None,
+        return_logits: bool = True,
+    ) -> tuple[Optional[Tensor], Optional[Tensor]]:
+        B, S = input_ids.shape
+        assert S <= self.cfg.max_seq_len, (
+            f"dizi uzunluğu {S}, modelin bağlam sınırı {self.cfg.max_seq_len}")
+
+        x = self.embed_tokens(input_ids)
+        cos, sin = self.rotary(S, x.device, x.dtype)
+
+        for block in self.layers:
+            x = block(x, cos, sin)
+        x = self.final_norm(x)
+
+        if self.cfg.tie_word_embeddings:
+            logits = F.linear(x, self.embed_tokens.weight)
+        else:
+            logits = self.lm_head(x)
+
+        loss: Optional[Tensor] = None
+        if targets is not None:
+            flat_logits = logits.view(-1, logits.size(-1))
+            flat_targets = targets.view(-1)
+            ce = F.cross_entropy(
+                flat_logits, flat_targets, ignore_index=-100, reduction="mean"
+            )
+            loss = ce
+            if self.cfg.z_loss_coef > 0:
+                mask = flat_targets != -100
+                lse = torch.logsumexp(flat_logits, dim=-1)
+                if mask.any():
+                    z = (lse[mask].float().pow(2)).mean()
+                    loss = loss + self.cfg.z_loss_coef * z
+
+        if not return_logits and targets is not None:
+            logits = None
+        return logits, loss
+
+    @torch.no_grad()
+    def generate(
+        self,
+        input_ids: Tensor,
+        max_new_tokens: int = 128,
+        temperature: float = 0.6,
+        top_k: int = 40,
+        top_p: float = 0.88,
+        repetition_penalty: float = 1.20,
+        no_repeat_ngram_size: int = 4,
+        min_p: float = 0.05,
+        eos_token_id: Optional[int] = None,
+    ) -> Tensor:
+        self.eval()
+        eos = eos_token_id if eos_token_id is not None else self.cfg.eos_token_id
+        out = input_ids.clone()
+        device = out.device
+
+        for _ in range(max_new_tokens):
+            ctx = out[:, -self.cfg.max_seq_len:]
+            logits, _ = self.forward(ctx)
+            logits = logits[:, -1, :].float()
+
+            if repetition_penalty is not None and repetition_penalty != 1.0:
+                for b in range(out.size(0)):
+                    seen = torch.unique(out[b])
+                    vals = logits[b, seen]
+                    logits[b, seen] = torch.where(
+                        vals > 0, vals / repetition_penalty, vals * repetition_penalty
+                    )
+
+            if no_repeat_ngram_size and no_repeat_ngram_size > 0:
+                n = no_repeat_ngram_size
+                if out.size(1) >= n - 1:
+                    for b in range(out.size(0)):
+                        seq = out[b].tolist()
+                        ngrams: dict = {}
+                        for i in range(len(seq) - n + 1):
+                            prefix = tuple(seq[i : i + n - 1])
+                            ngrams.setdefault(prefix, set()).add(seq[i + n - 1])
+                        curr = tuple(seq[-(n - 1):])
+                        if curr in ngrams:
+                            banned = torch.tensor(list(ngrams[curr]), device=device, dtype=torch.long)
+                            logits[b, banned] = float("-inf")
+
+            if temperature is not None and temperature != 1.0:
+                logits = logits / max(temperature, 1.0e-6)
+
+            if top_k is not None and top_k > 0:
+                v, _ = torch.topk(logits, k=min(top_k, logits.size(-1)))
+                logits[logits < v[:, -1:]] = float("-inf")
+
+            if min_p is not None and min_p > 0.0:
+                probs_tmp = F.softmax(logits, dim=-1)
+                max_probs, _ = probs_tmp.max(dim=-1, keepdim=True)
+                logits = logits.masked_fill(probs_tmp < (max_probs * min_p), float("-inf"))
+
+            if top_p is not None and 0.0 < top_p < 1.0:
+                sorted_logits, sorted_idx = torch.sort(logits, descending=True, dim=-1)
+                probs = F.softmax(sorted_logits, dim=-1)
+                cumprobs = probs.cumsum(dim=-1)
+                mask = cumprobs > top_p
+                mask[..., 1:] = mask[..., :-1].clone()
+                mask[..., 0] = False
+                sorted_logits = sorted_logits.masked_fill(mask, float("-inf"))
+                logits = torch.full_like(logits, float("-inf")).scatter(-1, sorted_idx, sorted_logits)
+
+            probs = F.softmax(logits, dim=-1)
+            next_token = torch.multinomial(probs, num_samples=1)
+            out = torch.cat([out, next_token], dim=1)
+
+            if eos is not None and (next_token == eos).all():
+                break
+        return out

model.safetensors

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

model_config.json

@@ -0,0 +1,16 @@
+{
+  "vocab_size": 48000,
+  "max_seq_len": 2048,
+  "hidden_size": 768,
+  "intermediate_size": 2304,
+  "num_layers": 24,
+  "num_heads": 12,
+  "num_kv_heads": 4,
+  "rope_theta": 10000.0,
+  "rms_norm_eps": 1e-05,
+  "qk_norm": true,
+  "tie_word_embeddings": true,
+  "bos_token_id": 3,
+  "eos_token_id": 5,
+  "pad_token_id": 1
+}

tokenizer_config.json

@@ -0,0 +1,16 @@
+{
+  "backend": "tokenizers",
+  "bos_token": "<|bos|>",
+  "eos_token": "<|endoftext|>",
+  "extra_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|system|>",
+    "<|user|>",
+    "<|assistant|>"
+  ],
+  "model_max_length": 2048,
+  "pad_token": "<|pad|>",
+  "tokenizer_class": "TokenizersBackend",
+  "unk_token": "<|unk|>"
+}

tokenizer_info.json

@@ -0,0 +1,60 @@
+{
+  "tur": "Byte-Level BPE",
+  "sozluk_boyutu": 48000,
+  "dil": "tr",
+  "kucuk_harfe_cevirir_mi": false,
+  "normalizasyon": "NFC",
+  "on_bolumleyici": "ByteLevel(add_prefix_space=False, use_regex=True)",
+  "cozucu": "ByteLevel",
+  "son_islemci": "ByteLevel(trim_offsets=False)",
+  "ozel_tokenler": {
+    "<|endoftext|>": 0,
+    "<|pad|>": 1,
+    "<|unk|>": 2,
+    "<|bos|>": 3,
+    "<|im_start|>": 4,
+    "<|im_end|>": 5,
+    "<|system|>": 6,
+    "<|user|>": 7,
+    "<|assistant|>": 8,
+    "<think>": 9,
+    "</think>": 10,
+    "<tool_call>": 11,
+    "</tool_call>": 12,
+    "<|tool|>": 13,
+    "<tools>": 14,
+    "</tools>": 15
+  },
+  "ornekler": [
+    {
+      "metin": "Türkiye'nin başkenti Ankara'dır.",
+      "token_sayisi": 8,
+      "parcalar": ["Türkiye", "'", "nin", " başkenti", " Ankara", "'d", "ır", "."]
+    },
+    {
+      "metin": "İstanbul'da yaşıyorum, çalışıyorum, eğleniyorum.",
+      "token_sayisi": 10,
+      "parcalar": ["İstanbul", "'d", "a", " yaşıyorum", ",", " çalışıyorum", ",", " eğlen", "iyorum", "."]
+    },
+    {
+      "metin": "Evlerimizdeydiniz galiba.",
+      "token_sayisi": 6,
+      "parcalar": ["Ev", "lerimizde", "y", "diniz", " galiba", "."]
+    },
+    {
+      "metin": "15 Temmuz 2026 tarihinde saat 09.30'da toplantımız var.",
+      "token_sayisi": 15,
+      "parcalar": ["15", " Temmuz", " 20", "26", " tarihinde", " saat", " 09", ".", "30", "'d", "a", " toplant", "ımız", " var", "."]
+    },
+    {
+      "metin": "Yapay zeka modelleri Türkçenin sondan eklemeli yapısıyla başa çıkmalı.",
+      "token_sayisi": 14,
+      "parcalar": ["Yapay", " zeka", " modelleri", " Türkç", "enin", " son", "dan", " eklem", "eli", " yapısıyla", " başa", " çık", "malı", "."]
+    },
+    {
+      "metin": "Muvaffakiyetsizleştiricileştiremeyebileceklerimizdenmişsinizcesine.",
+      "token_sayisi": 17,
+      "parcalar": ["M", "uv", "af", "fak", "iyet", "siz", "leştir", "ic", "ileştir", "em", "ey", "ebilecek", "lerimizden", "miş", "siniz", "cesine", "."]
+    }
+  ]
+}