LLM: Fine Tune Ollama gemma3:270m

1. 1. 1. Panduan Fine-Tuning Model Gemma 3:270M dengan Dataset JSONL untuk Ollama

Model Gemma 3 270M (dari `google/gemma-3-270m` di Hugging Face) adalah varian ringan yang cocok untuk fine-tuning efisien, terutama pada perangkat dengan sumber daya terbatas. Proses fine-tuning menggunakan Parameter-Efficient Fine-Tuning (PEFT) seperti QLoRA untuk menghemat memori, dengan dataset dalam format JSONL (misalnya, format chat dengan role "user" dan "assistant"). Setelah fine-tuning, model akan di-merge, dikonversi ke format GGUF (untuk kompatibilitas lokal), dan di-deploy langsung ke Ollama.

• • Prasyarat:**

- Python 3.10+ dan GPU (minimal NVIDIA dengan CUDA 11.8+ untuk QLoRA). - Akun Hugging Face dengan token (setujui lisensi Gemma di HF). - Install Git dan clone repo llama.cpp untuk konversi GGUF. - Dataset JSONL Anda harus berformat seperti ini (satu baris per contoh):

 ```
 {"messages": [{"role": "user", "content": "Pertanyaan pengguna"}, {"role": "assistant", "content": "Jawaban yang diinginkan"}]}
 ```
 Simpan sebagai `train.jsonl` (minimal 100-1000 contoh untuk hasil baik).

1. 1. 1. 1. Langkah 1: Setup Environment

Install dependensi utama menggunakan pip. Jalankan di terminal atau Jupyter/Colab:

```bash pip install torch>=2.4.0 transformers>=4.51.3 datasets==3.3.2 accelerate==1.4.0 evaluate==0.4.3 bitsandbytes==0.45.3 trl==0.21.0 peft==0.14.0 protobuf sentencepiece ```

Login ke Hugging Face (ganti `YOUR_HF_TOKEN` dengan token Anda):

```python from huggingface_hub import login login(token="YOUR_HF_TOKEN") ```

1. 1. 1. 1. Langkah 2: Persiapan Dataset JSONL

Load dan format dataset Anda menggunakan Hugging Face Datasets. Asumsikan file `train.jsonl` Anda sudah siap.

```python from datasets import load_dataset

1. Load dataset JSONL (ganti path sesuai file Anda)

dataset = load_dataset("json", data_files={"train": "train.jsonl"}, split="train")

1. Format untuk chat (jika belum, tambahkan system prompt opsional)

def format_chat(example):

   messages = example["messages"]
   # Tambahkan system prompt jika perlu, e.g., {"role": "system", "content": "You are a helpful assistant."}
   return {"text": tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=False)}

dataset = dataset.map(format_chat) dataset = dataset.train_test_split(test_size=0.1) # Split 90% train, 10% eval ```

Tokenize dataset:

```python from transformers import AutoTokenizer

model_id = "google/gemma-3-270m" tokenizer = AutoTokenizer.from_pretrained(model_id) tokenizer.pad_token = tokenizer.eos_token # Penting untuk Gemma

def tokenize(example):

   return tokenizer(example["text"], truncation=True, max_length=512)

tokenized_dataset = dataset.map(tokenize, batched=True) ```

1. 1. 1. 1. Langkah 3: Fine-Tuning dengan QLoRA

Load model dengan 4-bit quantization untuk efisiensi (cocok untuk 270M params).

```python import torch from transformers import AutoModelForCausalLM, BitsAndBytesConfig, TrainingArguments from peft import LoraConfig, get_peft_model, TaskType from trl import SFTTrainer

1. Config quantization

bnb_config = BitsAndBytesConfig(

   load_in_4bit=True,
   bnb_4bit_quant_type="nf4",
   bnb_4bit_compute_dtype=torch.bfloat16,
   bnb_4bit_use_double_quant=True,

)

1. Load model

model = AutoModelForCausalLM.from_pretrained(

   model_id,
   quantization_config=bnb_config,
   device_map="auto",
   torch_dtype=torch.bfloat16,

)

1. Config LoRA (target modules untuk Gemma: q_proj, k_proj, v_proj, o_proj, gate_proj, up_proj, down_proj)

lora_config = LoraConfig(

   r=16,  # Rank LoRA
   lora_alpha=32,
   target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
   lora_dropout=0.05,
   bias="none",
   task_type=TaskType.CAUSAL_LM,

)

model = get_peft_model(model, lora_config)

1. Training args

training_args = TrainingArguments(

   output_dir="./gemma3-270m-finetuned",
   num_train_epochs=3,
   per_device_train_batch_size=4,
   gradient_accumulation_steps=4,
   learning_rate=2e-4,
   fp16=True,  # Atau bfloat16 jika GPU support
   save_steps=500,
   logging_steps=100,
   evaluation_strategy="steps",
   eval_steps=500,
   load_best_model_at_end=True,

)

1. Trainer

trainer = SFTTrainer(

   model=model,
   args=training_args,
   train_dataset=tokenized_dataset["train"],
   eval_dataset=tokenized_dataset["test"],
   tokenizer=tokenizer,
   peft_config=lora_config,
   dataset_text_field="text",  # Field yang berisi prompt + response

)

trainer.train() trainer.save_model("./gemma3-270m-finetuned") # Simpan adapter LoRA ```

Proses ini memakan waktu 30-60 menit tergantung dataset dan hardware.

1. 1. 1. 1. Langkah 4: Merge Adapter dan Simpan Model Penuh

Merge LoRA adapter ke base model untuk inference.

```python from peft import PeftModel

base_model = AutoModelForCausalLM.from_pretrained(

   model_id,
   device_map="auto",
   torch_dtype=torch.bfloat16,

)

peft_model = PeftModel.from_pretrained(base_model, "./gemma3-270m-finetuned") merged_model = peft_model.merge_and_unload()

merged_model.save_pretrained("./gemma3-270m-merged") tokenizer.save_pretrained("./gemma3-270m-merged") ```

1. 1. 1. 1. Langkah 5: Konversi ke Format GGUF

Clone llama.cpp dan konversi model HF ke GGUF.

```bash git clone https://github.com/ggerganov/llama.cpp cd llama.cpp pip install -r requirements.txt python convert_hf_to_gguf.py ../gemma3-270m-merged --outfile gemma3-270m-finetuned.gguf ```

Quantize untuk ukuran lebih kecil (misalnya Q4_K_M untuk keseimbangan kualitas/ukuran):

```bash ./llama-quantize gemma3-270m-finetuned.gguf gemma3-270m-finetuned-q4.gguf Q4_K_M ```

1. 1. 1. 1. Langkah 6: Deploy ke Ollama

Buat Modelfile untuk Ollama (simpan sebagai `Modelfile`):

``` FROM ./gemma3-270m-finetuned-q4.gguf TEMPLATE """Template:If .System<|im_start|>system Template:.System<|im_end|> Template:EndTemplate:If .Prompt<|im_start|>user Template:.Prompt<|im_end|> Template:End<|im_start|>assistant """ PARAMETER stop "<|im_end|>" PARAMETER stop "<|im_start|>" SYSTEM "You are a helpful assistant." ```

Jalankan:

```bash ollama create gemma3-270m-custom -f Modelfile ollama run gemma3-270m-custom ```

Sekarang model siap digunakan di Ollama! Test dengan prompt sederhana. Jika ada error, pastikan template chat sesuai dengan tokenizer Gemma (gunakan `apply_chat_template` untuk verifikasi). Untuk dataset lebih besar atau hyperparameter tuning, gunakan tools seperti Unsloth untuk percepatan 2x. Jika butuh bantuan debug, bagikan detail error Anda.