Unknown user: Created page with "### 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 u..."

2025-10-04T21:55:14Z

Created page with "### 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 u..."

New page

### 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).

#### 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")
```

#### 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

# Load dataset JSONL (ganti path sesuai file Anda)
dataset = load_dataset("json", data_files={"train": "train.jsonl"}, split="train")

# 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)
```

#### 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

# 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,
)

# Load model
model = AutoModelForCausalLM.from_pretrained(
model_id,
quantization_config=bnb_config,
device_map="auto",
torch_dtype=torch.bfloat16,
)

# 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)

# 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,
)

# 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.

#### 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")
```

#### 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
```

#### Langkah 6: Deploy ke Ollama
Buat Modelfile untuk Ollama (simpan sebagai `Modelfile`):

```
FROM ./gemma3-270m-finetuned-q4.gguf
TEMPLATE """{{ if .System }}<|im_start|>system
{{ .System }}<|im_end|>
{{ end }}{{ if .Prompt }}<|im_start|>user
{{ .Prompt }}<|im_end|>
{{ 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.

LLM: Fine Tune Ollama gemma3:270m - Revision history

Unknown user: Created page with "### 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 u..."