ninmeni 0.1.0__tar.gz

ninmeni-0.1.0/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

ninmeni-0.1.0/MANIFEST.in

@@ -0,0 +1,8 @@
+include LICENSE README.md requirements.txt
+recursive-include docs *.md
+recursive-include configs *.yaml
+recursive-include examples *.jsonl
+recursive-include registry *.json
+recursive-include training *.py
+recursive-include pipeline *.py
+recursive-include model *.py

ninmeni-0.1.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: ninmeni
+Version: 0.1.0
+Summary: NINMENI - framework model bahasa native Indonesia. Paradigma NMU: 1 karakter = 1 ID, ruang karakter statis universal, tanpa UNK.
+Author-email: Emylton Leunufna <emylleons8@gmail.com>
+License: Apache-2.0
+Project-URL: Homepage, https://ninmeni.net
+Keywords: nlp,bahasa-indonesia,character-level,language-model,tokenizer-free
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Natural Language :: Indonesian
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Development Status :: 3 - Alpha
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Provides-Extra: train
+Requires-Dist: torch>=2.4; extra == "train"
+Requires-Dist: pyyaml; extra == "train"
+Dynamic: license-file
+
+# NINMENI — Framework Model Bahasa Native Indonesia
+
+**NINMENI** adalah kerangka riset dan rekayasa untuk membangun model bahasa yang
+native terhadap bahasa Indonesia, dari lapisan paling dasar.
+
+Hierarki: **framework NINMENI → paradigma NMU → model (contoh: Veyra)**.
+
+- **NMU (Native Meaning Unit)** — paradigma representasi: satu karakter = satu
+  identitas tetap, di ruang karakter statis universal. Tanpa segmentasi sub-kata,
+  tanpa UNK. Bahasa Indonesia hidup dari imbuhan; dengan membaca per karakter, akar
+  kata selalu tampak utuh di setiap turunannya — model menemukan pola imbuhan sendiri.
+- **Veyra** — model pertama yang lahir dari kerangka ini (beta).
+
+## Isi repo
+```
+nmu/         codec NMU (paket paradigma) (encode/decode 1 karakter = 1 ID, registry-driven)
+registry/    ruang karakter statis (nmu_v1.json)
+model/       model REFERENSI (decoder polos) — titik colok arsitektur Anda; BUKAN arsitektur Veyra
+training/    loop pelatihan unified (pretraining + SFT satu loop) + sampler shard
+pipeline/    build_shards.py — teks JSONL -> shard ids (mmap-able)
+configs/     contoh konfigurasi
+docs/        panduan kurikulum data
+examples/    contoh format kurikulum (pretraining & SFT)
+```
+
+## Mulai cepat
+1. Siapkan korpus JSONL `{"teks": "..."}` (lihat `examples/curriculum/`).
+2. Shardize: `python pipeline/build_shards.py --inputs korpus.jsonl --out data/shards`
+3. Latih: `python -m training.train_unified_native --config configs/contoh_75m.yaml \
+   --shards data/shards/train --sft data/sft_train.jsonl --registry registry/nmu_v1.json`
+
+## Status & batas yang jujur
+Proyek ini dibuka bertahap. Kode di sini adalah pipeline yang benar-benar dipakai
+membangun Veyra 75M (beta) — bukan kode demonstrasi. Yang TIDAK ada di repo ini:
+bobot model, arsitektur internal Veyra (model/ berisi referensi polos sebagai titik
+colok — lihat docs/antarmuka-model.md), korpus pelatihan, dan catatan riset internal. Evaluasi menyeluruh
+menunggu dokumentasi teknis rilis penuh.
+
+## Kontribusi & lisensi
+Kode di repo ini dilisensikan di bawah **Apache License 2.0** (lihat `LICENSE`).
+Kontribusi dipersilakan melalui issue / pull request.
+
+## Kontak
+Emylton Leunufna — pencipta framework NINMENI & paradigma NMU — `emylleons8@gmail.com`

ninmeni-0.1.0/README.md

@@ -0,0 +1,44 @@
+# NINMENI — Framework Model Bahasa Native Indonesia
+
+**NINMENI** adalah kerangka riset dan rekayasa untuk membangun model bahasa yang
+native terhadap bahasa Indonesia, dari lapisan paling dasar.
+
+Hierarki: **framework NINMENI → paradigma NMU → model (contoh: Veyra)**.
+
+- **NMU (Native Meaning Unit)** — paradigma representasi: satu karakter = satu
+  identitas tetap, di ruang karakter statis universal. Tanpa segmentasi sub-kata,
+  tanpa UNK. Bahasa Indonesia hidup dari imbuhan; dengan membaca per karakter, akar
+  kata selalu tampak utuh di setiap turunannya — model menemukan pola imbuhan sendiri.
+- **Veyra** — model pertama yang lahir dari kerangka ini (beta).
+
+## Isi repo
+```
+nmu/         codec NMU (paket paradigma) (encode/decode 1 karakter = 1 ID, registry-driven)
+registry/    ruang karakter statis (nmu_v1.json)
+model/       model REFERENSI (decoder polos) — titik colok arsitektur Anda; BUKAN arsitektur Veyra
+training/    loop pelatihan unified (pretraining + SFT satu loop) + sampler shard
+pipeline/    build_shards.py — teks JSONL -> shard ids (mmap-able)
+configs/     contoh konfigurasi
+docs/        panduan kurikulum data
+examples/    contoh format kurikulum (pretraining & SFT)
+```
+
+## Mulai cepat
+1. Siapkan korpus JSONL `{"teks": "..."}` (lihat `examples/curriculum/`).
+2. Shardize: `python pipeline/build_shards.py --inputs korpus.jsonl --out data/shards`
+3. Latih: `python -m training.train_unified_native --config configs/contoh_75m.yaml \
+   --shards data/shards/train --sft data/sft_train.jsonl --registry registry/nmu_v1.json`
+
+## Status & batas yang jujur
+Proyek ini dibuka bertahap. Kode di sini adalah pipeline yang benar-benar dipakai
+membangun Veyra 75M (beta) — bukan kode demonstrasi. Yang TIDAK ada di repo ini:
+bobot model, arsitektur internal Veyra (model/ berisi referensi polos sebagai titik
+colok — lihat docs/antarmuka-model.md), korpus pelatihan, dan catatan riset internal. Evaluasi menyeluruh
+menunggu dokumentasi teknis rilis penuh.
+
+## Kontribusi & lisensi
+Kode di repo ini dilisensikan di bawah **Apache License 2.0** (lihat `LICENSE`).
+Kontribusi dipersilakan melalui issue / pull request.
+
+## Kontak
+Emylton Leunufna — pencipta framework NINMENI & paradigma NMU — `emylleons8@gmail.com`

ninmeni-0.1.0/configs/contoh_75m.yaml

@@ -0,0 +1,35 @@
+# Contoh konfigurasi ~75M — pretrain + SFT satu loop (muat di GPU konsumen ~8GB).
+#
+# Per step: ratio r ramp ratio0->ratio1, pilih SFT vs pretrain batch.
+#   - pretrain batch: seq=1024 (sampling acak shards), loss = model.loss(x) SHIFTED
+#   - SFT batch: max_len=2048 (build_example), loss = sft_loss SHIFTED + IGNORE mask
+#
+# Microbatch terpisah per tipe batch (SFT lebih kecil karena sekuens 2x lebih panjang).
+
+run_name: veyra-native
+
+model:
+  d_model: 768
+  n_layers: 12
+  n_heads: 12
+  n_kv_heads: 4
+  mlp_ratio: 4.0
+  rope_theta: 10000.0
+  grad_checkpoint: true
+
+train:
+  pretrain_seq_len: 1024     # window pretrain
+  sft_max_len: 2048          # cap panjang SFT
+  # Throughput: sesuaikan microbatch dgn memori GPU Anda;
+  # nilai di bawah = titik awal yang wajar utk ~8GB.
+  microbatch_pretrain: 4     # T=1024 
+  microbatch_sft: 2          # T=2048 
+  grad_accum: 16             
+  ratio0: 0.15               # awal: 15% SFT, 85% pretrain
+  ratio1: 0.35               # akhir: 35% SFT, 65% pretrain
+  lr: 3.0e-4
+  warmup: 300
+  optimizer: adam8bit
+  precision: bf16
+  ckpt_every: 200
+  time_budget_sec: 86400     # budget waktu run (detik)

ninmeni-0.1.0/docs/antarmuka-model.md

@@ -0,0 +1,67 @@
+# Antarmuka Model — Kontrak yang Dituntut Pipeline
+
+Repo ini menyertakan `model/reference_model.py` — decoder karakter-level yang
+sengaja polos. Ia BUKAN arsitektur Veyra; ia titik colok. Arsitektur Anda sendiri
+bisa langsung dipakai trainer selama memenuhi kontrak berikut.
+
+## 1. Config (dataclass)
+
+```python
+@dataclass
+class MyConfig:
+    ukuran_ruang: int # ukuran ruang karakter — diisi trainer dari registry (codec.ukuran_ruang)
+    pad_id: int       # diisi trainer dari registry (codec.pad_id)
+    # ... field lain = kunci di blok `model:` pada configs/*.yaml
+    grad_checkpoint: bool = False   # dibaca trainer untuk log
+```
+
+Trainer memvalidasi kunci yaml terhadap `fields(Config)` — kunci yang tidak
+dikenal dibuang dengan peringatan. Jadi: field config Anda = kunci yaml Anda.
+
+## 2. Model
+
+```python
+class MyModel(nn.Module):
+    def __init__(self, cfg: MyConfig): ...
+    # WAJIB: simpan config di atribut ini (dipakai sft_loss & checkpointing)
+    self.cfg = cfg
+
+    def forward(self, x):        # x: LongTensor [B, T] berisi ID karakter
+        return logits            # FloatTensor [B, T, ukuran_ruang]
+
+    def loss(self, x):           # objective pretraining
+        # WAJIB SHIFTED: logits[:, :-1] vs x[:, 1:]
+        # Loss tanpa shift = model belajar MENYALIN, bukan memprediksi —
+        # ini kelas bug yang diam dan mahal. Uji: loss awal harus ~ln(ukuran ruang).
+        ...
+```
+
+## 3. Aturan native yang tidak boleh dilanggar
+
+- **Input = deretan ID karakter mentah** dari codec (1 karakter = 1 ID).
+  Jangan menambahkan segmentasi/penggabungan apa pun sebelum pemetaan ID→vektor
+  di dalam model — kalau Anda ingin kompresi, letakkan DI DALAM model sebagai
+  bagian arsitektur.
+- **Tanpa UNK**: ukuran_ruang datang dari registry; semua ID valid.
+- **PAD**: tidak dilatih (ignore_index) dan tidak dilihat attention.
+- **Checkpoint**: trainer menyimpan `model.state_dict()` + config dict —
+  pastikan arsitektur Anda dapat direkonstruksi dari config-nya saja.
+
+## 4. Menghubungkan ke trainer
+
+Satu baris di `training/train_unified_native.py`:
+
+```python
+from model.reference_model import VeyraNativeModel, VeyraNativeConfig, count_params
+# ganti menjadi:
+from model.arsitektur_anda import VeyraNativeModel, VeyraNativeConfig, count_params
+```
+
+(Ekspor alias dengan nama yang sama, atau ubah ketiga nama di trainer.)
+
+## 5. Cara menilai model native (kacamata yang benar)
+
+Model karakter-level punya ritme belajarnya sendiri. Metrik yang wajar dipantau:
+bits/char (BPC) pada validasi — bukan membandingkan kurva Anda dengan kurva model
+ber-segmentasi sub-kata; keduanya mengukur unit yang berbeda. Perilaku awal seperti
+pengulangan pada teks yang digenerasi adalah fase belajar substrat, bukan bug decoding.

ninmeni-0.1.0/docs/kurikulum.md

@@ -0,0 +1,28 @@
+# Kurikulum Data NINMENI — Panduan Ringkas
+
+Dua jalur data, dua peran yang berbeda dan tidak boleh dicampur:
+
+## 1. Pretraining — membentuk PEMAHAMAN
+- Isi: teks aktual (prosa komunikasi nyata) berbahasa Indonesia — artikel, dokumentasi,
+  narasi, kode dengan penjelasan. Format: JSONL `{"teks": "..."}` (lihat
+  `examples/curriculum/pretraining_contoh.jsonl`).
+- Prinsip: substrat belajar dari BAHASA HIDUP. Format meta-linguistik (tabel kamus,
+  daftar lema, anotasi kelas kata) bukan corpus — kamus adalah alat kurasi, bukan data.
+- Setiap sumber wajib berlisensi jelas dan tercatat (URL + lisensi + hash) di manifest
+  Anda sendiri. Jangan gunakan data yang tidak boleh Anda gunakan.
+- Konten pengetahuan dunia (fakta, statistik, budaya) masuk ke jalur INI — bukan ke SFT.
+
+## 2. SFT — membentuk PROTOKOL DIALOG ("mulut")
+- Isi: contoh percakapan/tugas dalam format turns (lihat `examples/curriculum/sft_contoh.jsonl`).
+- Peran: mengajarkan BENTUK berinteraksi (format jawaban, protokol tool, gaya) — bukan
+  menjejalkan fakta. Fakta yang hanya ada di SFT cenderung rapuh.
+- Penalaran bertahap diajarkan sebagai LINTASAN: enumerasi langkah searah penulisan,
+  jawaban = kelanjutan alami dari langkahnya (lihat contoh `reason`).
+
+## Prinsip lintas-jalur
+- 1 karakter = 1 ID: registry karakter statis (`registry/nmu_v1.json`) berlaku untuk
+  SEMUA data. Teks yang memuat karakter di luar registry tidak dipaksa masuk — catat
+  dan putuskan secara sadar (normalisasi terdokumentasi, atau buang utuh).
+- Tanpa UNK: kegagalan encode = masalah validasi data, bukan sesuatu yang ditambal.
+- Evaluasi model native dibaca dengan kacamata native: model karakter-level punya
+  ritme belajar sendiri; jangan menilai dengan ekspektasi paradigma lain.

ninmeni-0.1.0/examples/curriculum/pretraining_contoh.jsonl

@@ -0,0 +1,4 @@
+{"teks": "Danau Toba terletak di Provinsi Sumatera Utara. Danau vulkanik ini terbentuk dari letusan purba dan menjadi rumah bagi Pulau Samosir di tengahnya."}
+{"teks": "Fotosintesis adalah proses tumbuhan mengubah cahaya matahari, air, dan karbon dioksida menjadi energi. Prosesnya berlangsung di daun, tepatnya di dalam kloroplas."}
+{"teks": "def hitung_keliling_lingkaran(jari_jari):\n    import math\n    return 2 * math.pi * jari_jari\n\n# Keliling lingkaran dihitung dari jari-jarinya."}
+{"teks": "Harga beras di pasar tradisional pekan ini berkisar antara Rp13.000 sampai Rp15.000 per kilogram, bergantung pada kualitas dan daerah."}

ninmeni-0.1.0/examples/curriculum/sft_contoh.jsonl

@@ -0,0 +1,4 @@
+{"cat": "qa", "turns": [{"role": "user", "content": "Apa ibukota Provinsi Jawa Tengah?"}, {"role": "assistant", "content": "Semarang."}]}
+{"cat": "multi_qa", "turns": [{"role": "user", "content": "Sungai terpanjang di Indonesia apa?"}, {"role": "assistant", "content": "Sungai Kapuas di Kalimantan Barat."}, {"role": "user", "content": "Berapa kira-kira panjangnya?"}, {"role": "assistant", "content": "Sekitar 1.143 kilometer."}]}
+{"cat": "reason", "turns": [{"role": "user", "content": "Jika hari ini Senin, tiga hari lagi hari apa?"}, {"role": "assistant", "content": "Langkah: Senin + 3 hari. Urut: Selasa, Rabu, Kamis. Jadi Kamis."}]}
+{"cat": "task", "turns": [{"role": "user", "content": "Sebutkan 3 pulau besar di Indonesia."}, {"role": "assistant", "content": "1. Sumatera 2. Kalimantan 3. Papua"}]}

ninmeni-0.1.0/model/reference_model.py

@@ -0,0 +1,144 @@
+"""reference_model.py — MODEL REFERENSI untuk pipeline NINMENI.
+
+PENTING: ini BUKAN arsitektur Veyra. Ini decoder-only transformer karakter-level
+yang sengaja dibuat polos dan mudah dibaca, dengan satu tujuan: pipeline di repo
+ini bisa dijalankan ujung-ke-ujung, dan Anda punya titik colok yang jelas untuk
+arsitektur Anda sendiri.
+
+Kontrak antarmuka yang dituntut trainer (lihat docs/antarmuka-model.md):
+  - Config  : dataclass; field mencakup kunci `model:` di configs/*.yaml
+              + ukuran_ruang + pad_id (diisi trainer dari registry).
+  - Model   : __init__(cfg); menyimpan `self.cfg`;
+              forward(x[B,T] long) -> logits [B, T, ukuran_ruang];
+              loss(x[B,T]) -> scalar CE SHIFTED (predict karakter berikutnya).
+  - count_params(model) -> int.
+
+Prinsip native yang dijaga di sini:
+  - Input = deretan ID karakter (1 karakter = 1 ID, registry-driven). Tidak ada
+    segmentasi apa pun sebelum model.
+  - Loss WAJIB shifted: logits[:, :-1] vs target x[:, 1:]. Loss tanpa shift =
+    model belajar menyalin, bukan memprediksi.
+  - PAD tidak dilatih dan tidak dilihat attention.
+"""
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.checkpoint import checkpoint
+
+
+@dataclass
+class ReferenceConfig:
+    ukuran_ruang: int = 4450     # ukuran ruang karakter registry (jumlah ID)
+    pad_id: int = 0
+    d_model: int = 768
+    n_layers: int = 12
+    n_heads: int = 12
+    n_kv_heads: int = 4          # diterima demi kompatibilitas config; referensi memakai MHA penuh
+    mlp_ratio: float = 4.0
+    rope_theta: float = 10000.0
+    grad_checkpoint: bool = False
+
+
+def _rope(q, k, theta):
+    # Penyandian posisi rotari (RoPE) sederhana (separuh-dimensi berpasangan).
+    B, H, T, D = q.shape
+    half = D // 2
+    freqs = theta ** (-torch.arange(0, half, device=q.device, dtype=torch.float32) / half)
+    pos = torch.arange(T, device=q.device, dtype=torch.float32)
+    ang = torch.outer(pos, freqs)                      # [T, half]
+    cos, sin = ang.cos()[None, None], ang.sin()[None, None]
+
+    def rot(x):
+        x1, x2 = x[..., :half], x[..., half:]
+        return torch.cat([x1 * cos - x2 * sin, x1 * sin + x2 * cos], dim=-1)
+
+    return rot(q), rot(k)
+
+
+class _Block(nn.Module):
+    def __init__(self, cfg: ReferenceConfig):
+        super().__init__()
+        self.cfg = cfg
+        self.norm1 = nn.RMSNorm(cfg.d_model)
+        self.norm2 = nn.RMSNorm(cfg.d_model)
+        self.qkv = nn.Linear(cfg.d_model, 3 * cfg.d_model, bias=False)
+        self.proj = nn.Linear(cfg.d_model, cfg.d_model, bias=False)
+        hidden = int(cfg.d_model * cfg.mlp_ratio)
+        self.mlp = nn.Sequential(
+            nn.Linear(cfg.d_model, hidden, bias=False),
+            nn.GELU(),
+            nn.Linear(hidden, cfg.d_model, bias=False),
+        )
+
+    def forward(self, x, pad_mask=None):
+        B, T, C = x.shape
+        H = self.cfg.n_heads
+        q, k, v = self.qkv(self.norm1(x)).chunk(3, dim=-1)
+        q = q.view(B, T, H, C // H).transpose(1, 2)
+        k = k.view(B, T, H, C // H).transpose(1, 2)
+        v = v.view(B, T, H, C // H).transpose(1, 2)
+        q, k = _rope(q, k, self.cfg.rope_theta)
+        attn_mask = None
+        if pad_mask is not None:
+            # PAD tidak boleh dilihat sebagai key oleh posisi mana pun.
+            attn_mask = pad_mask[:, None, None, :].expand(B, 1, T, T)
+        out = F.scaled_dot_product_attention(q, k, v, attn_mask=attn_mask, is_causal=True)
+        x = x + self.proj(out.transpose(1, 2).reshape(B, T, C))
+        x = x + self.mlp(self.norm2(x))
+        return x
+
+
+class ReferenceNativeModel(nn.Module):
+    def __init__(self, cfg: ReferenceConfig):
+        super().__init__()
+        self.cfg = cfg
+        self.emb = nn.Embedding(cfg.ukuran_ruang, cfg.d_model, padding_idx=cfg.pad_id)
+        self.blocks = nn.ModuleList(_Block(cfg) for _ in range(cfg.n_layers))
+        self.norm_f = nn.RMSNorm(cfg.d_model)
+        self.head = nn.Linear(cfg.d_model, cfg.ukuran_ruang, bias=False)
+        self.head.weight = self.emb.weight  # tied
+        # Init kecil (std 0.02) — tanpa ini logits awal membesar dan CE awal
+        # jauh di atas ln(ukuran ruang). Uji waras: loss step-0 harus ~ ln(ukuran_ruang).
+        self.apply(self._init)
+
+    @staticmethod
+    def _init(m):
+        if isinstance(m, (nn.Linear, nn.Embedding)):
+            nn.init.normal_(m.weight, mean=0.0, std=0.02)
+
+    def forward(self, x):
+        pad_mask = None
+        if (x == self.cfg.pad_id).any():
+            pad_mask = x != self.cfg.pad_id  # True = boleh dilihat
+        h = self.emb(x)
+        for blk in self.blocks:
+            if self.cfg.grad_checkpoint and self.training:
+                h = checkpoint(blk, h, pad_mask, use_reentrant=False)
+            else:
+                h = blk(h, pad_mask)
+        return self.head(self.norm_f(h))
+
+    def loss(self, x):
+        """CE SHIFTED — objective pretraining native (predict karakter berikutnya)."""
+        logits = self.forward(x)
+        return F.cross_entropy(
+            logits[:, :-1, :].reshape(-1, self.cfg.ukuran_ruang),
+            x[:, 1:].reshape(-1),
+            ignore_index=self.cfg.pad_id,
+        )
+
+
+def count_params(model) -> int:
+    return sum(p.numel() for p in model.parameters())
+
+
+# Alias kompatibilitas — trainer mengimpor nama-nama ini. Saat Anda menulis
+# arsitektur sendiri, ekspor nama yang sama dari modul Anda dan arahkan import
+# di training/train_unified_native.py ke sana.
+VeyraNativeConfig = ReferenceConfig
+VeyraNativeModel = ReferenceNativeModel