Upload folder using huggingface_hub

.gitignore

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

README.md

@@ -1,3 +1,31 @@
 ---
+language:
+- id
 license: mit
+tags:
+- text-generation
+- from-scratch
+- gpt
+- transformer
+- tensorflow
+- keras
 ---
+
+# Indigo-TF
+
+Versi **TensorFlow/Keras** dari proyek [Indigo](https://huggingface.co/adyoi/indigo) — model bahasa GPT kecil dari nol. Repo utama (PyTorch): `D:\Documents\GitHub\Indigo`.
+
+Format checkpoint identik (`.safetensors` + `_meta.json`, penanda `backend: tensorflow`), sehingga tidak bisa tertukar dengan checkpoint PyTorch.
+
+## Pakai
+
+```bash
+pip install -r requirements.txt
+
+python train.py --data data/sample.txt --steps 2000
+python generate.py --prompt "Indigo"
+```
+
+Fitur setara repo utama: pembersihan teks, split validasi per-file, best-checkpoint, resume (`--init-from`), tokenizer `char`/`bpe`, cosine LR + warmup, pilihan `--device`.
+
+Catatan: GPU TensorFlow di Windows native tidak didukung sejak TF 2.11 — gunakan WSL2/Colab/Linux.

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.

generate.py

@@ -0,0 +1,67 @@
+import sys
+import random
+import argparse
+import numpy as np
+import tensorflow as tf
+
+from indigotf.common import build_tokenizer, load_meta
+from indigotf.model import build_gpt, generate
+
+CONFIG_KEYS = ("vocab_size", "block_size", "n_layer", "n_head", "n_embd", "dropout")
+
+
+def load_model(path):
+    from safetensors.numpy import load_file
+
+    meta = load_meta(path)
+    if meta.get("backend") != "tensorflow":
+        raise SystemExit(
+            f"{path} berasal dari backend {meta.get('backend')}, gunakan repo indigo (PyTorch)"
+        )
+    state = load_file(path)
+    by_path = {k.replace("/", "_"): v for k, v in state.items()}
+    model = build_gpt(**{k: meta["config"][k] for k in CONFIG_KEYS})
+    missing = [v.path for v in model.weights if v.path.replace("/", "_") not in by_path]
+    if missing:
+        raise SystemExit(f"bobot tidak cocok dengan checkpoint: {missing[:5]}")
+    model.set_weights([by_path[v.path.replace("/", "_")] for v in model.weights])
+    tokenizer = build_tokenizer(meta.get("tokenizer") or {"type": "char"}, meta.get("vocab"))
+    return model, meta, tokenizer
+
+
+def main():
+    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+    parser = argparse.ArgumentParser(description="Generate teks dari checkpoint Indigo-TF")
+    parser.add_argument("--ckpt", default="out/indigo_best.safetensors")
+    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)
+    parser.add_argument("--device", default="auto", choices=["auto", "cpu", "gpu"])
+    args = parser.parse_args()
+
+    if args.device == "cpu":
+        tf.config.set_visible_devices([], "GPU")
+    if args.seed is not None:
+        random.seed(args.seed)
+        np.random.seed(args.seed)
+        tf.random.set_seed(args.seed)
+
+    model, meta, tokenizer = load_model(args.ckpt)
+
+    ids = tokenizer.encode(args.prompt) or [0]
+    idx = tf.constant([ids], dtype=tf.int64)
+    out = generate(
+        model,
+        idx,
+        args.max_new,
+        block_size=meta["config"]["block_size"],
+        temperature=args.temperature,
+        top_k=args.top_k,
+    )
+    print(tokenizer.decode(out.numpy()[0].tolist()))
+
+
+if __name__ == "__main__":
+    main()

indigotf/__init__.py

@@ -0,0 +1,5 @@
+from .bpe import BPETokenizer
+from .tokenizer import CharTokenizer
+from .model import build_gpt, generate
+
+__all__ = ["build_gpt", "generate", "BPETokenizer", "CharTokenizer"]

indigotf/bpe.py

@@ -0,0 +1,75 @@
+def _get_stats(ids):
+    stats = {}
+    for pair in zip(ids, ids[1:]):
+        stats[pair] = stats.get(pair, 0) + 1
+    return stats
+
+
+def _merge(ids, pair, idx):
+    out = []
+    i = 0
+    while i < len(ids):
+        if i < len(ids) - 1 and ids[i] == pair[0] and ids[i + 1] == pair[1]:
+            out.append(idx)
+            i += 2
+        else:
+            out.append(ids[i])
+            i += 1
+    return out
+
+
+class BPETokenizer:
+    def __init__(self, merges=None):
+        self.merges = [tuple(p) for p in (merges or [])]
+        self.ranks = {pair: i for i, pair in enumerate(self.merges)}
+        self.vocab = [bytes([i]) for i in range(256)]
+        for a, b in self.merges:
+            self.vocab.append(self.vocab[a] + self.vocab[b])
+
+    @classmethod
+    def train(cls, text, vocab_size):
+        tok = cls()
+        ids = list(text.encode("utf-8"))
+        next_id = 256
+        while next_id < vocab_size and len(ids) > 1:
+            stats = _get_stats(ids)
+            pair = max(stats, key=stats.get)
+            if stats[pair] < 2:
+                break
+            ids = _merge(ids, pair, next_id)
+            tok.ranks[pair] = len(tok.merges)
+            tok.merges.append(pair)
+            tok.vocab.append(tok.vocab[pair[0]] + tok.vocab[pair[1]])
+            next_id += 1
+        return tok
+
+    @property
+    def vocab_size(self):
+        return 256 + len(self.merges)
+
+    def _encode_chunk(self, ids):
+        while len(ids) >= 2:
+            best = None
+            best_rank = None
+            for pair in zip(ids, ids[1:]):
+                rank = self.ranks.get(pair)
+                if rank is not None and (best_rank is None or rank < best_rank):
+                    best = pair
+                    best_rank = rank
+            if best is None:
+                break
+            ids = _merge(ids, best, 256 + best_rank)
+        return ids
+
+    def encode(self, text):
+        return self._encode_chunk(list(text.encode("utf-8")))
+
+    def decode(self, ids):
+        return b"".join(self.vocab[i] for i in ids).decode("utf-8", errors="replace")
+
+    def state(self):
+        return {"type": "bpe", "merges": [list(p) for p in self.merges]}
+
+    @classmethod
+    def from_state(cls, state):
+        return cls(state["merges"])

indigotf/common.py

@@ -0,0 +1,56 @@
+import os
+import re
+import json
+
+DECOR_LINE = re.compile(r"^[\s=\-_~*#.]{4,}$")
+
+
+def clean_text(text):
+    lines = [ln for ln in text.splitlines() if not DECOR_LINE.match(ln)]
+    text = "\n".join(lines)
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    return text.strip() + "\n"
+
+
+def collect_text_files(paths):
+    files = []
+    for p in paths:
+        if os.path.isdir(p):
+            for root, _, names in os.walk(p):
+                files.extend(os.path.join(root, n) for n in sorted(names) if n.lower().endswith(".txt"))
+        else:
+            files.append(p)
+    return sorted(files)
+
+
+def read_clean(path):
+    with open(path, encoding="utf-8") as f:
+        return clean_text(f.read())
+
+
+def save_meta(base_path, config, vocab, step, val_loss, backend, tokenizer=None):
+    meta = {
+        "config": config,
+        "vocab": vocab,
+        "step": step,
+        "val_loss": val_loss,
+        "backend": backend,
+        "tokenizer": tokenizer or {"type": "char"},
+    }
+    with open(os.path.splitext(base_path)[0] + "_meta.json", "w", encoding="utf-8") as f:
+        json.dump(meta, f, ensure_ascii=False)
+
+
+def load_meta(path):
+    with open(os.path.splitext(path)[0] + "_meta.json", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def build_tokenizer(tokenizer_info, vocab):
+    if tokenizer_info.get("type") == "bpe":
+        from indigotf.bpe import BPETokenizer
+
+        return BPETokenizer.from_state(tokenizer_info)
+    from indigotf.tokenizer import CharTokenizer
+
+    return CharTokenizer(vocab)

indigotf/model.py

@@ -0,0 +1,61 @@
+import tensorflow as tf
+from keras import layers
+
+
+class PositionEmbedding(layers.Layer):
+    def __init__(self, block_size, **kwargs):
+        super().__init__(**kwargs)
+        self.block_size = block_size
+
+    def build(self, input_shape):
+        self.pos_emb = self.add_weight(
+            name="pos_emb", shape=(self.block_size, input_shape[-1]), initializer="random_normal"
+        )
+
+    def call(self, x):
+        T = tf.shape(x)[1]
+        return x + self.pos_emb[tf.newaxis, :T, :]
+
+    def get_config(self):
+        config = super().get_config()
+        config["block_size"] = self.block_size
+        return config
+
+
+def build_gpt(vocab_size, block_size, n_layer=4, n_head=4, n_embd=128, dropout=0.1, name="indigo"):
+    tokens = tf.keras.Input(shape=(None,), dtype="int64", name="tokens")
+    x = layers.Embedding(vocab_size, n_embd, name="tok_emb")(tokens)
+    x = PositionEmbedding(block_size, name="pos_emb")(x)
+    x = layers.Dropout(dropout)(x)
+    for i in range(n_layer):
+        xn = layers.LayerNormalization(epsilon=1e-5, name=f"ln1_{i}")(x)
+        attn = layers.MultiHeadAttention(
+            num_heads=n_head, key_dim=n_embd // n_head, dropout=dropout, name=f"attn_{i}"
+        )
+        x = x + attn(xn, xn, use_causal_mask=True)
+        xn = layers.LayerNormalization(epsilon=1e-5, name=f"ln2_{i}")(x)
+        h = layers.Dense(4 * n_embd, activation="gelu", name=f"fc_{i}")(xn)
+        h = layers.Dense(n_embd, name=f"proj_{i}")(h)
+        h = layers.Dropout(dropout)(h)
+        x = x + h
+    x = layers.LayerNormalization(epsilon=1e-5, name="ln_f")(x)
+    logits = layers.Dense(vocab_size, use_bias=False, name="head")(x)
+    return tf.keras.Model(tokens, logits, name=name)
+
+
+def generate(model, idx, max_new_tokens, block_size, temperature=1.0, top_k=None):
+    for _ in range(max_new_tokens):
+        idx_cond = idx[:, -block_size:]
+        logits = model(idx_cond, training=False)[:, -1, :]
+        logits = logits / max(temperature, 1e-8)
+        if top_k is not None:
+            k = min(top_k, int(logits.shape[-1]))
+            vals, _ = tf.math.top_k(logits, k=k)
+            logits = tf.where(
+                logits < vals[:, -1:],
+                tf.fill(tf.shape(logits), tf.float32.min),
+                logits,
+            )
+        next_id = tf.random.categorical(logits, num_samples=1, dtype=tf.int64)
+        idx = tf.concat([idx, next_id], axis=1)
+    return idx

indigotf/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,2 @@
+tensorflow>=2.16
+safetensors>=0.4

train.py

@@ -0,0 +1,224 @@
+import os
+import time
+import math
+import random
+import argparse
+import numpy as np
+import tensorflow as tf
+
+from safetensors.numpy import load_file, save_file
+
+from indigotf.bpe import BPETokenizer
+from indigotf.common import (
+    build_tokenizer,
+    collect_text_files,
+    load_meta,
+    read_clean,
+    save_meta,
+)
+from indigotf.model import build_gpt
+from indigotf.tokenizer import CharTokenizer
+
+CONFIG_KEYS = ("vocab_size", "block_size", "n_layer", "n_head", "n_embd", "dropout")
+
+
+def get_batch(np_data, block_size, batch_size):
+    ix = np.random.randint(0, len(np_data) - block_size - 1, size=batch_size)
+    x = np.stack([np_data[i : i + block_size] for i in ix])
+    y = np.stack([np_data[i + 1 : i + block_size + 1] for i in ix])
+    return tf.constant(x), tf.constant(y)
+
+
+@tf.function(reduce_retracing=True)
+def train_step(model, optimizer, loss_fn, x, y):
+    with tf.GradientTape() as tape:
+        logits = model(x, training=True)
+        loss = loss_fn(y, logits)
+    grads = tape.gradient(loss, model.trainable_variables)
+    optimizer.apply_gradients(zip(grads, model.trainable_variables))
+    return loss
+
+
+@tf.function(reduce_retracing=True)
+def eval_step(model, loss_fn, x, y):
+    logits = model(x, training=False)
+    return loss_fn(y, logits)
+
+
+def save_weights_tf(model, base_path, config, vocab, step, val_loss, tinfo):
+    tensors = {v.path: np.asarray(v) for v in model.weights}
+    save_file(tensors, base_path)
+    save_meta(base_path, config, vocab, step, val_loss, backend="tensorflow", tokenizer=tinfo)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Latih model Indigo-TF (backend TensorFlow/Keras)")
+    parser.add_argument("--data", nargs="+", default=["data/sample.txt"])
+    parser.add_argument("--out", default="out")
+    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)
+    parser.add_argument("--init-from", default=None, help="checkpoint safetensors sebelumnya")
+    parser.add_argument("--tokenizer", default="char", choices=["char", "bpe"])
+    parser.add_argument("--vocab-size", type=int, default=512)
+    parser.add_argument("--device", default="auto", choices=["auto", "cpu", "gpu"])
+    args = parser.parse_args()
+
+    if args.device == "cpu":
+        tf.config.set_visible_devices([], "GPU")
+    gpus = tf.config.list_physical_devices("GPU")
+    device_label = f"gpu({len(gpus)})" if gpus and args.device != "cpu" else "cpu"
+
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    tf.random.set_seed(args.seed)
+    os.makedirs(args.out, exist_ok=True)
+
+    files = sorted(collect_text_files(args.data))
+    if not files:
+        raise SystemExit("tidak ada file teks ditemukan")
+    rng = random.Random(args.seed)
+    rng.shuffle(files)
+    n_val = max(1, round(len(files) * 0.1)) if len(files) > 1 else 0
+    print(f"file latih={len(files) - n_val} | file validasi={n_val}")
+
+    train_text = "".join(read_clean(p) for p in files[n_val:])
+    val_text = "".join(read_clean(p) for p in files[:n_val])
+    all_text = train_text + val_text
+
+    start_step = 0
+    init_state = None
+    if args.init_from:
+        meta = load_meta(args.init_from)
+        if meta.get("backend") != "tensorflow":
+            raise SystemExit(f"{args.init_from} bukan checkpoint backend TensorFlow")
+        config_d = meta["config"]
+        start_step = meta.get("step", 0)
+        init_state = {k.replace("/", "_"): v for k, v in load_file(args.init_from).items()}
+        print(f"melanjutkan dari {args.init_from} (step {start_step})")
+        tokenizer = build_tokenizer(meta.get("tokenizer") or {"type": "char"}, meta.get("vocab"))
+        tinfo = meta.get("tokenizer") or {"type": "char"}
+    else:
+        if args.tokenizer == "bpe":
+            tokenizer = BPETokenizer.train(all_text, args.vocab_size)
+            tinfo = tokenizer.state()
+        else:
+            tokenizer = CharTokenizer.from_text(all_text)
+            tinfo = {"type": "char"}
+        config_d = {
+            "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,
+            "bias": False,
+        }
+    if config_d["vocab_size"] != tokenizer.vocab_size:
+        raise SystemExit(
+            f"vocab tidak cocok: checkpoint={config_d['vocab_size']}, tokenizer={tokenizer.vocab_size}"
+        )
+
+    train_np = np.array(tokenizer.encode(train_text), dtype=np.int64)
+    val_np = np.array(tokenizer.encode(val_text), dtype=np.int64)
+    if len(train_np) < config_d["block_size"] * 2:
+        raise SystemExit(f"data latih terlalu pendek ({len(train_np)} token)")
+    print(
+        f"tokenizer={tinfo['type']} | tokens latih={len(train_np):,} | "
+        f"tokens validasi={len(val_np):,} | vocab={tokenizer.vocab_size}"
+    )
+    total_steps = start_step + args.steps
+
+    model = build_gpt(
+        vocab_size=config_d["vocab_size"],
+        block_size=config_d["block_size"],
+        n_layer=config_d["n_layer"],
+        n_head=config_d["n_head"],
+        n_embd=config_d["n_embd"],
+        dropout=config_d["dropout"],
+    )
+    if init_state is not None:
+        by_path = {v.path.replace("/", "_"): v for v in model.weights}
+        missing = [p for p in by_path if p not in init_state]
+        if missing:
+            raise SystemExit(f"bobot tidak cocok dengan checkpoint: {missing[:5]}")
+        model.set_weights([init_state[v.path.replace("/", "_")] for v in model.weights])
+
+    n_params = int(sum(int(np.prod(v.shape)) for v in model.weights))
+    print(
+        f"device={device_label} | params={n_params / 1e6:.2f}M | "
+        f"vocab={config_d['vocab_size']} | total_steps={total_steps}"
+    )
+
+    optimizer = tf.keras.optimizers.AdamW(
+        learning_rate=args.lr, beta_1=0.9, beta_2=0.95, weight_decay=args.weight_decay, clipnorm=1.0
+    )
+    loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
+
+    def lr_at(step):
+        if step < args.warmup:
+            return args.lr * (step + 1) / args.warmup
+        progress = (step - args.warmup) / max(1, total_steps - args.warmup)
+        return 0.1 * args.lr + 0.45 * args.lr * (1 + math.cos(math.pi * progress))
+
+    best_val = float("inf")
+    last_val = None
+    t0 = time.time()
+    for step in range(start_step, total_steps):
+        optimizer.learning_rate.assign(lr_at(step))
+        x, y = get_batch(train_np, config_d["block_size"], args.batch_size)
+        loss = train_step(model, optimizer, loss_fn, x, y)
+        if step % args.eval_interval == 0 or step == total_steps - 1:
+            if len(val_np) > config_d["block_size"] + 1:
+                losses = []
+                for _ in range(args.eval_iters):
+                    vx, vy = get_batch(val_np, config_d["block_size"], args.batch_size)
+                    losses.append(float(eval_step(model, loss_fn, vx, vy)))
+                val_loss = sum(losses) / len(losses)
+                marker = ""
+                if val_loss < best_val:
+                    best_val = val_loss
+                    save_weights_tf(
+                        model,
+                        os.path.join(args.out, "indigo_best.safetensors"),
+                        config_d,
+                        tokenizer.itos if hasattr(tokenizer, "itos") else None,
+                        total_steps,
+                        val_loss,
+                        tinfo,
+                    )
+                    marker = " <- best"
+                last_val = val_loss
+                val_str = f"{val_loss:.4f}{marker}"
+            else:
+                val_str = "n/a"
+            print(
+                f"step {step + 1:5d}/{total_steps} | "
+                f"loss {float(loss):.4f} | val {val_str} | {time.time() - t0:.1f}s"
+            )
+
+    final_path = os.path.join(args.out, "indigo.safetensors")
+    save_weights_tf(
+        model,
+        final_path,
+        config_d,
+        tokenizer.itos if hasattr(tokenizer, "itos") else None,
+        total_steps,
+        last_val,
+        tinfo,
+    )
+    print(f"model tersimpan di {final_path} (+_meta.json)")
+
+
+if __name__ == "__main__":
+    main()