t5gemma-2-1b-1b-instruct-chat-indo-v2-exp

T5-Gemma-2-1B-Instruct-Chat-Indo-v2-exp

Model ini merupakan LoRA adapter berukuran 1B yang difine-tune dari model dasar google/t5gemma-2-1b-1b menggunakan metode Supervised Fine-Tuning (SFT) dengan konfigurasi eksperimental. Model ini dioptimalkan untuk tugas pemahaman instruksi dan kemampuan dialog multi-turn secara natural dalam Bahasa Indonesia serta Bahasa Inggris.

Karakteristik dan Evaluasi Model

• Optimasi Eksperimental (GrokAdEMAMix): Pelatihan diselesaikan secara penuh selama 1225 langkah menggunakan optimizer GrokAdEMAMix untuk mengoptimalkan konvergensi model dan kestabilan gradien.
• Peningkatan Metrik BLEU: Model dengan GrokAdEMAMix mencapai skor BLEU 26.16% (dengan nilai loss evaluasi 2.743), menunjukkan peningkatan akurasi generasi dibandingkan baseline model yang menggunakan optimizer standar.
• In-Task Learning & Cross-Attention: Menggunakan arsitektur Encoder-Decoder (Seq2Seq) untuk memetakan representasi encoder secara implisit sesuai kategori tugas (seperti ringkasan, penerjemahan, Q&A berbasis dokumen, dan parafrase) tanpa memerlukan rekayasa prompt statis.
• Logit Masking: Menerapkan logit masking untuk memblokir logits bagi token yang tidak digunakan (unused tokens) dan token visual di encoder guna meminimalkan kesalahan pembentukan token selama generasi teks.

Hasil Evaluasi Komparatif

Berikut adalah hasil perbandingan kinerja generasi teks antara model yang menggunakan optimizer standar (AdamW) dan model eksperimental (GrokAdEMAMix):

Cara Penggunaan

Berikut adalah contoh skrip Python untuk memuat model dasar beserta LoRA adapter ini menggunakan pustaka transformers dan peft:

import os
import torch
from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
from peft import PeftModel

base_model_name = "google/t5gemma-2-1b-1b"
adapter_id = "daruokta/t5gemma-2-1b-1b-instruct-chat-indo-v2-exp"

# 1. Memuat Tokenizer
tokenizer = AutoTokenizer.from_pretrained(base_model_name, trust_remote_code=True)

# 2. Memuat Base Model
base_model = AutoModelForSeq2SeqLM.from_pretrained(
    base_model_name,
    trust_remote_code=True,
    torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
    device_map="auto" if torch.cuda.is_available() else None
)

# 3. Menerapkan Logit Masking
vocab_size = base_model.config.vocab_size
suppress_block1 = list(range(6, 105))
suppress_block2 = list(range(256002, 262144))
suppress_vision = [255999, 256000, 256001]
suppress_ids = [i for i in (suppress_block1 + suppress_block2 + suppress_vision) if i < vocab_size]

mask = torch.zeros(vocab_size, dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32)
mask[suppress_ids] = -10000.0

def forward_hook(module, inputs, outputs):
    if hasattr(outputs, "logits"):
        outputs.logits.add_(mask.to(outputs.logits.device))
    elif isinstance(outputs, tuple):
        outputs[0].add_(mask.to(outputs[0].device))
    return outputs

base_model.register_forward_hook(forward_hook)

# 4. Memuat LoRA Adapter
model = PeftModel.from_pretrained(base_model, adapter_id, subfolder="final_adapter")
model.eval()

# 5. Inferensi Percakapan
messages = [
    {"role": "system", "content": "Kamu adalah asisten AI yang helpful, santai, dan ramah. Gunakan Bahasa Indonesia sebagai bahasa utama."},
    {"role": "user", "content": "Tolong jelaskan secara singkat apa itu fotosintesis."}
]

prompt = ""
is_first_user = True
for msg in messages:
    if msg["role"] == "system":
        continue
    if msg["role"] == "user":
        prompt += "<start_of_turn>user\n"
        if is_first_user:
            prompt += messages[0]["content"] + "\n\n"
            is_first_user = False
        prompt += msg["content"] + "<end_of_turn>\n"
    elif msg["role"] in ["assistant", "model"]:
        prompt += "<start_of_turn>model\n" + msg["content"] + "<end_of_turn>\n"

prompt += "<start_of_turn>model\n"

inputs = tokenizer(prompt, return_tensors="pt", add_special_tokens=False).to(model.device)

with torch.no_grad():
    outputs = model.generate(
        **inputs,
        max_new_tokens=256,
        temperature=0.7,
        repetition_penalty=1.0,
        do_sample=True,
        eos_token_id=[tokenizer.convert_tokens_to_ids("<end_of_turn>"), tokenizer.eos_token_id]
    )

response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(response.strip())

Spesifikasi dan Hyperparameter Pelatihan

• Dataset: daruokta/t5gemma2-indonesia-chat-formatted (31,299 sampel)
• Konfigurasi LoRA:
  • Rank (r): 128
  • Alpha ($\alpha$): 256
  • Target Modules: ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]
  • Dropout: 0.2
• Hyperparameter Pelatihan:
  • Epochs: 5 (Selesai penuh / langkah 1225)
  • Optimizer: Custom GrokAdEMAMix (grok_alpha = 2.0, grok_lamb = 0.98)
  • Learning Rate: 1e-5 (Cosine decay scheduler dengan 100 langkah pemanasan/warmup)
  • Batch Size: 4 per device (Gradient Accumulation Steps: 32)
  • Precision: Mixed Precision bfloat16
  • Panjang Konteks (Source / Target): 2048 / 512
  • Faktor Label Smoothing: 0.1
  • NEFTune Noise Alpha: 5.0
  • Weight Decay: 0.1

Batasan & Lisensi

• Lisensi: Mengikuti lisensi dasar model Gemma dari Google.
• Keterbatasan: Performa terbaik difokuskan pada pemahaman Bahasa Indonesia dan Bahasa Inggris. Respons terhadap bahasa daerah atau bahasa asing lainnya dapat menunjukkan variasi akurasi.

Library Versions

• PEFT: 0.19.1
• PyTorch: 2.12.0+cu130
• Transformers: 5.11.0
• Bitsandbytes: 0.49.2
• Accelerate: 1.14.0
• Datasets: 5.0.0

Referensi & Publikasi Ilmiah

Makalah Rujukan Utama

1. T5Gemma 2: Seeing, Reading, and Understanding Longer

   • Biao Zhang, et al. (Google DeepMind, 2025).
   • arXiv: arXiv:2512.14856
   • Relevansi: Menjelaskan detail arsitektural T5Gemma 2, termasuk teknik Tied Word Embeddings, Merged Attention, dan efisiensi model encoder-decoder dalam rentang konteks panjang.

2. Return of the Encoder: Maximizing Parameter Efficiency for SLMs

   • Mohamed Elfeki, et al. (Microsoft, 2025).
   • arXiv: arXiv:2501.16273
   • Relevansi: Menyediakan basis pembuktian empiris bahwa model dengan arsitektur encoder-decoder lebih hemat parameter dibandingkan decoder-only untuk tugas-tugas berbasis instruksi dan dialog terstruktur.

3. The AdEMAMix Optimizer: Better, Faster, Older

   • Matteo Pagliardini, Pierre Ablin, and David Grangier (2024).
   • arXiv: arXiv:2409.03137
   • Relevansi: Menyediakan basis metodologis dan teoritis untuk penggunaan optimizer GrokAdEMAMix yang memanfaatkan perpaduan dua tingkat Exponential Moving Average (EMA) gradien untuk mengoptimalkan konvergensi dan mengatasi pelupaan model (forgetting).

4. Layer-Aware Task Arithmetic: Disentangling Task-Specific and Instruction-Following Knowledge

   • Han Ren, et al. (2025).
   • arXiv: arXiv:2502.20186
   • Relevansi: Teori penyelarasan bobot model multi-tugas yang dinonaktifkan secara selektif per lapisan (layer-aware) untuk menghindari tabrakan fitur (feature collision).

5. Editing Models with Task Arithmetic

   • Gabriel Ilharco, et al. (2023).
   • arXiv: arXiv:2212.04089
   • Relevansi: Metode penyuntingan model (model surgery) melalui manipulasi aritmatika pada vektor parameter.

6. Gemma 3 Technical Report

   • Google DeepMind (2025).
   • arXiv: arXiv:2503.19786
   • Relevansi: Laporan teknis model dasar Gemma 3 yang menjadi tumpuan transfer bobot inisialisasi T5Gemma 2.

7. Cendol: Open Instruction-tuned Generative Large Language Models for Indonesian Languages

   • Fajri Koto, et al. (2024).
   • arXiv: arXiv:2404.06138
   • Relevansi: Kerangka kurasi data instruksi konversasional untuk lokalisasi performa model dalam rumpun bahasa Indonesia.

Sitasi BibTeX

@article{zhang2025t5gemma2,
  title={T5Gemma 2: Seeing, Reading, and Understanding Longer},
  author={Zhang, Biao and others},
  journal={arXiv preprint arXiv:2512.14856},
  year={2025}
}

@article{elfeki2025return,
  title={Return of the Encoder: Maximizing Parameter Efficiency for SLMs},
  author={Elfeki, Mohamed and others},
  journal={arXiv preprint arXiv:2501.16273},
  year={2025}
}

@article{pagliardini2024ademamix,
  title={The AdEMAMix Optimizer: Better, Faster, Older},
  author={Pagliardini, Matteo and Ablin, Pierre and Grangier, David},
  journal={arXiv preprint arXiv:2409.03137},
  year={2024}
}

@article{ren2025layer,
  title={Layer-Aware Task Arithmetic: Disentangling Task-Specific and Instruction-Following Knowledge},
  author={Ren, Han and others},
  journal={arXiv preprint arXiv:2502.20186},
  year={2025}
}

@article{ilharco2022editing,
  title={Editing models with task arithmetic},
  author={Ilharco, Gabriel and others},
  journal={arXiv preprint arXiv:2212.04089},
  year={2022}
}

@article{gemma3report,
  title={Gemma 3 Technical Report},
  author={DeepMind, Google},
  journal={arXiv preprint arXiv:2503.19786},
  year={2025}
}

@article{koto2024cendol,
  title={Cendol: Open Instruction-tuned Generative Large Language Models for Indonesian Languages},
  author={Koto, Fajri and others},
  journal={arXiv preprint arXiv:2404.06138},
  year={2024}
}