Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+*.pyc
+out/
+*.pt
+.git/

data/sample.txt

@@ -0,0 +1,50 @@
+Indigo adalah model bahasa kecil yang dibangun dari nol.
+Model ini dilatih dengan PyTorch murni tanpa pustaka tambahan.
+Arsitektur Indigo berupa transformer decoder sederhana.
+Setiap blok transformer memuat perhatian kausal dan jaringan saraf.
+Perhatian kausal membuat model hanya melihat token masa lalu.
+Token masa lalu dipakai untuk memprediksi token berikutnya.
+Prediksi token berikutnya adalah inti dari pemodelan bahasa.
+Pemodelan bahasa bisa dipakai untuk membuat teks baru.
+Teks baru dihasilkan token demi token secara berurutan.
+Urutan token ditentukan oleh distribusi probabilitas model.
+Probabilitas model dipelajari dari data latih.
+Data latih berupa kumpulan teks biasa dalam berkas txt.
+Berkas teks dibaca lalu diubah menjadi deret angka.
+Deret angka tersebut menjadi masukan bagi jaringan saraf.
+Jaringan saraf belajar dengan menurunkan fungsi kerugian.
+Fungsi kerugian dihitung menggunakan cross entropy.
+Cross entropy mengukur selisih prediksi dengan jawaban sebenarnya.
+Jawaban sebenarnya adalah token yang muncul pada data asli.
+Data asli dibagi menjadi data latih dan data validasi.
+Data validasi dipakai untuk memantau kemajuan pelatihan.
+Pelatihan berjalan selama ribuan langkah kecil.
+Setiap langkah memperbarui bobot model sedikit demi sedikit.
+Bobot model diperbarui oleh optimizer AdamW.
+Optimizer menurunkan kerugian dengan gradien turun.
+Gradien dihitung lewat propagasi balik otomatis dari PyTorch.
+Propagasi balik meneruskan kesalahan ke setiap lapisan.
+Lapisan pertama adalah lapisan penyematan token.
+Penyematan token mengubah angka menjadi vektor padat.
+Vektor padat digabung dengan penyematan posisi.
+Penyematan posisi memberi tahu urutan kata dalam kalimat.
+Kalimat panjang dipotong menjadi jendela tetap.
+Jendela tetap disebut block size atau konteks.
+Konteks dibatasi agar perhatian tetap efisien.
+Perhatian menghitung hubungan antar token dalam konteks.
+Hubungan antar token membentuk pemahaman sederhana.
+Pemahaman ini tumbuh seiring bertambahnya langkah latih.
+Langkah latih dicatat beserta nilai kerugiannya.
+Nilai kerugian yang menurun menandakan model belajar.
+Model yang sudah belajar bisa menyimpan checkpoint.
+Checkpoint berisi bobot, konfigurasi, dan kosakata.
+Kosakata Indigo berupa karakter unik dari data.
+Tokenizer karakter mengubah huruf menjadi angka sederhana.
+Angka sederhana mudah dipahami tanpa pustaka eksternal.
+Tanpa pustaka eksternal proyek tetap ringan dan jelas.
+Proyek ringan cocok untuk belajar dari dasar.
+Dasar yang kuat memudahkan eksperimen lanjutan.
+Eksperimen bisa berupa penambahan lapisan atau kepala perhatian.
+Kepala perhatian tambahan menangkap pola yang lebih beragam.
+Pola beragam menghasilkan teks yang lebih koheren.
+Teks koheren adalah tujuan akhir dari pelatihan ini.

developments.txt

@@ -0,0 +1,29 @@
+
+Sekarang smoke test training singkat untuk memastikan pipeline jalan:
+
+python train.py 
+--data data/sample.txt 
+--out out_smoke 
+--steps 80 
+--batch-size 16 
+--block-size 64 
+--n-layer 2 
+--n-head 2 
+--n-embd 64 
+--warmup 10 
+--eval-interval 40
+
+
+Loss turun (3.93 → 3.08) — pipeline bekerja. Tes generasi:
+
+python generate.py 
+--ckpt out_smoke/indigo.pt 
+--prompt "Indigo" 
+--max-new 80 
+--temperature 0.8 
+--top-k 20 
+--seed 42
+
+Generasi berfungsi (masih acak karena hanya 80 langkah). Sekarang latih versi asli dengan konfigurasi lebih besar:
+
+Remove-Item -Recurse -Force out_smoke

generate.py

@@ -0,0 +1,34 @@
+import argparse
+
+import torch
+
+from indigo.model import GPT, GPTConfig
+from indigo.tokenizer import CharTokenizer
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate teks dari checkpoint Indigo")
+    parser.add_argument("--ckpt", default="out/indigo.pt")
+    parser.add_argument("--prompt", default="")
+    parser.add_argument("--max-new", type=int, default=300)
+    parser.add_argument("--temperature", type=float, default=0.8)
+    parser.add_argument("--top-k", type=int, default=40)
+    parser.add_argument("--seed", type=int, default=None)
+    args = parser.parse_args()
+
+    if args.seed is not None:
+        torch.manual_seed(args.seed)
+
+    ckpt = torch.load(args.ckpt, map_location="cpu", weights_only=True)
+    model = GPT(GPTConfig(**ckpt["config"]))
+    model.load_state_dict(ckpt["model"])
+    tokenizer = CharTokenizer(ckpt["vocab"])
+
+    ids = tokenizer.encode(args.prompt) or [0]
+    idx = torch.tensor([ids], dtype=torch.long)
+    out = model.generate(idx, args.max_new, temperature=args.temperature, top_k=args.top_k)
+    print(tokenizer.decode(out[0].tolist()))
+
+
+if __name__ == "__main__":
+    main()

indigo/__init__.py

@@ -0,0 +1,4 @@
+from .model import GPT, GPTConfig
+from .tokenizer import CharTokenizer
+
+__all__ = ["GPT", "GPTConfig", "CharTokenizer"]

indigo/model.py

@@ -0,0 +1,121 @@
+import math
+from dataclasses import dataclass
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+@dataclass
+class GPTConfig:
+    vocab_size: int = 256
+    block_size: int = 128
+    n_layer: int = 4
+    n_head: int = 4
+    n_embd: int = 128
+    dropout: float = 0.1
+    bias: bool = False
+
+
+class CausalSelfAttention(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        assert config.n_embd % config.n_head == 0
+        self.n_head = config.n_head
+        self.n_embd = config.n_embd
+        self.qkv = nn.Linear(config.n_embd, 3 * config.n_embd, bias=config.bias)
+        self.proj = nn.Linear(config.n_embd, config.n_embd, bias=config.bias)
+        self.attn_dropout = nn.Dropout(config.dropout)
+        self.resid_dropout = nn.Dropout(config.dropout)
+        mask = torch.tril(torch.ones(config.block_size, config.block_size))
+        self.register_buffer("mask", mask.view(1, 1, config.block_size, config.block_size))
+
+    def forward(self, x):
+        B, T, C = x.shape
+        q, k, v = self.qkv(x).split(self.n_embd, dim=2)
+        q = q.view(B, T, self.n_head, C // self.n_head).transpose(1, 2)
+        k = k.view(B, T, self.n_head, C // self.n_head).transpose(1, 2)
+        v = v.view(B, T, self.n_head, C // self.n_head).transpose(1, 2)
+        att = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(k.size(-1)))
+        att = att.masked_fill(self.mask[:, :, :T, :T] == 0, float("-inf"))
+        att = F.softmax(att, dim=-1)
+        att = self.attn_dropout(att)
+        y = (att @ v).transpose(1, 2).contiguous().view(B, T, C)
+        return self.resid_dropout(self.proj(y))
+
+
+class MLP(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.fc = nn.Linear(config.n_embd, 4 * config.n_embd, bias=config.bias)
+        self.proj = nn.Linear(4 * config.n_embd, config.n_embd, bias=config.bias)
+        self.drop = nn.Dropout(config.dropout)
+
+    def forward(self, x):
+        return self.drop(self.proj(F.gelu(self.fc(x))))
+
+
+class Block(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.ln1 = nn.LayerNorm(config.n_embd, bias=config.bias)
+        self.attn = CausalSelfAttention(config)
+        self.ln2 = nn.LayerNorm(config.n_embd, bias=config.bias)
+        self.mlp = MLP(config)
+
+    def forward(self, x):
+        x = x + self.attn(self.ln1(x))
+        x = x + self.mlp(self.ln2(x))
+        return x
+
+
+class GPT(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        self.tok_emb = nn.Embedding(config.vocab_size, config.n_embd)
+        self.pos_emb = nn.Embedding(config.block_size, config.n_embd)
+        self.drop = nn.Dropout(config.dropout)
+        self.blocks = nn.ModuleList([Block(config) for _ in range(config.n_layer)])
+        self.ln_f = nn.LayerNorm(config.n_embd, bias=config.bias)
+        self.head = nn.Linear(config.n_embd, config.vocab_size, bias=False)
+        self.head.weight = self.tok_emb.weight
+        self.apply(self._init_weights)
+
+    def _init_weights(self, module):
+        if isinstance(module, nn.Linear):
+            nn.init.normal_(module.weight, mean=0.0, std=0.02)
+            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=0.02)
+
+    def forward(self, idx, targets=None):
+        B, T = idx.shape
+        pos = torch.arange(T, device=idx.device)
+        x = self.drop(self.tok_emb(idx) + self.pos_emb(pos))
+        for block in self.blocks:
+            x = block(x)
+        logits = self.head(self.ln_f(x))
+        loss = None
+        if targets is not None:
+            loss = F.cross_entropy(logits.reshape(-1, logits.size(-1)), targets.reshape(-1))
+        return logits, loss
+
+    @torch.no_grad()
+    def generate(self, idx, max_new_tokens, temperature=1.0, top_k=None):
+        self.eval()
+        for _ in range(max_new_tokens):
+            idx_cond = idx[:, -self.config.block_size:]
+            logits, _ = self(idx_cond)
+            logits = logits[:, -1, :] / max(temperature, 1e-8)
+            if top_k is not None:
+                v, _ = torch.topk(logits, min(top_k, logits.size(-1)))
+                logits[logits < v[:, [-1]]] = float("-inf")
+            probs = F.softmax(logits, dim=-1)
+            next_id = torch.multinomial(probs, num_samples=1)
+            idx = torch.cat((idx, next_id), dim=1)
+        return idx
+
+    def num_params(self):
+        return sum(p.numel() for p in self.parameters())

indigo/tokenizer.py

@@ -0,0 +1,33 @@
+import json
+
+
+class CharTokenizer:
+    def __init__(self, vocab=None):
+        if vocab is None:
+            self.itos = []
+        else:
+            self.itos = list(vocab)
+        self.stoi = {ch: i for i, ch in enumerate(self.itos)}
+
+    @classmethod
+    def from_text(cls, text):
+        return cls(sorted(set(text)))
+
+    @property
+    def vocab_size(self):
+        return len(self.itos)
+
+    def encode(self, text):
+        return [self.stoi[ch] for ch in text if ch in self.stoi]
+
+    def decode(self, ids):
+        return "".join(self.itos[i] for i in ids)
+
+    def save(self, path):
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(self.itos, f, ensure_ascii=False)
+
+    @classmethod
+    def load(cls, path):
+        with open(path, encoding="utf-8") as f:
+            return cls(json.load(f))

requirements.txt

@@ -0,0 +1 @@
+torch>=2.0

train.py

@@ -0,0 +1,125 @@
+import argparse
+import math
+import os
+import time
+
+import torch
+
+from indigo.model import GPT, GPTConfig
+from indigo.tokenizer import CharTokenizer
+
+
+def get_batch(data, block_size, batch_size, device):
+    ix = torch.randint(len(data) - block_size - 1, (batch_size,))
+    x = torch.stack([data[i : i + block_size] for i in ix])
+    y = torch.stack([data[i + 1 : i + block_size + 1] for i in ix])
+    return x.to(device, non_blocking=True), y.to(device, non_blocking=True)
+
+
+@torch.no_grad()
+def estimate_loss(model, data, args, device):
+    model.eval()
+    losses = []
+    for _ in range(args.eval_iters):
+        x, y = get_batch(data, args.block_size, args.batch_size, device)
+        _, loss = model(x, y)
+        losses.append(loss.item())
+    model.train()
+    return sum(losses) / len(losses)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Latih model Indigo dari scratch")
+    parser.add_argument("--data", default="data/sample.txt", help="path file teks untuk training")
+    parser.add_argument("--out", default="out", help="folder output checkpoint")
+    parser.add_argument("--steps", type=int, default=2000)
+    parser.add_argument("--batch-size", type=int, default=32)
+    parser.add_argument("--block-size", type=int, default=128)
+    parser.add_argument("--n-layer", type=int, default=4)
+    parser.add_argument("--n-head", type=int, default=4)
+    parser.add_argument("--n-embd", type=int, default=128)
+    parser.add_argument("--dropout", type=float, default=0.1)
+    parser.add_argument("--lr", type=float, default=3e-4)
+    parser.add_argument("--warmup", type=int, default=100)
+    parser.add_argument("--weight-decay", type=float, default=0.1)
+    parser.add_argument("--eval-interval", type=int, default=200)
+    parser.add_argument("--eval-iters", type=int, default=20)
+    parser.add_argument("--seed", type=int, default=1337)
+    args = parser.parse_args()
+
+    torch.manual_seed(args.seed)
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    os.makedirs(args.out, exist_ok=True)
+
+    with open(args.data, encoding="utf-8") as f:
+        text = f.read()
+
+    tokenizer = CharTokenizer.from_text(text)
+    data = torch.tensor(tokenizer.encode(text), dtype=torch.long)
+    if len(data) < args.block_size * 2:
+        raise SystemExit(f"data terlalu pendek ({len(data)} token), minimal {args.block_size * 2}")
+    n = int(0.9 * len(data))
+    train_data, val_data = data[:n], data[n:]
+
+    config = GPTConfig(
+        vocab_size=tokenizer.vocab_size,
+        block_size=args.block_size,
+        n_layer=args.n_layer,
+        n_head=args.n_head,
+        n_embd=args.n_embd,
+        dropout=args.dropout,
+    )
+    model = GPT(config).to(device)
+    print(
+        f"device={device} | params={model.num_params() / 1e6:.2f}M | "
+        f"vocab={tokenizer.vocab_size} | tokens={len(data):,}"
+    )
+
+    optimizer = torch.optim.AdamW(
+        model.parameters(), lr=args.lr, betas=(0.9, 0.95), weight_decay=args.weight_decay
+    )
+
+    def lr_at(step):
+        if step < args.warmup:
+            return args.lr * (step + 1) / args.warmup
+        progress = (step - args.warmup) / max(1, args.steps - args.warmup)
+        return 0.1 * args.lr + 0.45 * args.lr * (1 + math.cos(math.pi * progress))
+
+    model.train()
+    t0 = time.time()
+    for step in range(args.steps):
+        lr = lr_at(step)
+        for g in optimizer.param_groups:
+            g["lr"] = lr
+        x, y = get_batch(train_data, args.block_size, args.batch_size, device)
+        _, loss = model(x, y)
+        optimizer.zero_grad(set_to_none=True)
+        loss.backward()
+        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+        optimizer.step()
+
+        if step % args.eval_interval == 0 or step == args.steps - 1:
+            if len(val_data) > args.block_size + 1:
+                val_loss = estimate_loss(model, val_data, args, device)
+                val_str = f"{val_loss:.4f}"
+            else:
+                val_str = "n/a"
+            print(
+                f"step {step:5d}/{args.steps} | lr {lr:.2e} | "
+                f"loss {loss.item():.4f} | val {val_str} | {time.time() - t0:.1f}s"
+            )
+
+    ckpt_path = os.path.join(args.out, "indigo.pt")
+    torch.save(
+        {
+            "model": model.state_dict(),
+            "config": config.__dict__,
+            "vocab": tokenizer.itos,
+        },
+        ckpt_path,
+    )
+    print(f"checkpoint tersimpan di {ckpt_path}")
+
+
+if __name__ == "__main__":
+    main()