LLM: Fine Tuning Ollama gemma3:1b

Siap! Berikut **paket lengkap** untuk *fine-tuning* **Ollama `gemma3:1b`** dengan *open-source stack* (Python + Unsloth/PEFT) lalu **dipakai di Ollama** via LoRA *adapter*. Alurnya:

1. **Siapkan data** (JSON/JSONL). 2. **Fine-tune di Python** → hasilkan **LoRA adapter**. 3. **Bungkus ke Ollama** dengan **Modelfile** (`FROM gemma3:1b` + `ADAPTER …`). ([Ollama][1])

---

0) Persiapan lingkungan (ringkas)

```bash

Python env (opsional)

python -m venv .venv && source .venv/bin/activate

Lib open-source

pip install -U transformers datasets accelerate peft bitsandbytes unsloth ```

> Catatan: `gemma3:1b` tersedia di pustaka Ollama dan butuh Ollama ≥ 0.6. ([Ollama][1])

---

1) Contoh **dataset** (JSONL) untuk FAQ sekolah

Format **instruksi–jawaban** sederhana (tiap baris = 1 contoh). Simpan sebagai `data_faq.jsonl`.

```json {"instruction": "Kapan jadwal UKK tahun ini?", "input": "", "output": "UKK dilaksanakan pada minggu ke-3 bulan Mei. Cek papan informasi atau web sekolah untuk tanggal pasti."} {"instruction": "Bagaimana cara mendaftar ekstrakurikuler?", "input": "", "output": "Isi formulir di ruang BK atau lewat portal siswa. Pendaftaran buka tiap awal semester."} {"instruction": "Apa saja jurusan di SMK ini?", "input": "", "output": "RPL, TKJ, DKV, Akuntansi, dan Bisnis Daring. Lihat brosur atau situs sekolah untuk detail kurikulum."} ```

> Boleh juga pakai **JSON** (array) kalau nyaman, tapi **JSONL** umum dipakai untuk *fine-tuning*. ([Arsturn][2])

---

2) **Script Python**: *fine-tune* Gemma 3 1B (QLoRA via Unsloth/PEFT)

> Script ini: > – Membaca `data_faq.jsonl` > – Mengubah ke *prompt template* sederhana > – *Fine-tune* model 1B pakai **QLoRA** (hemat VRAM) > – Menyimpan **LoRA adapter** ke folder `lora_out/`

> Catatan: Nama model HF untuk Gemma 3 1B bisa bervariasi (contoh: `google/gemma-3-1b-it` / `google/gemma-3-1b`). Gantilah `BASE_MODEL_ID` sesuai model yang tersedia di HF Anda. (Tujuan kita: hasilkan **adapter** yang nanti dipakai di Ollama). Petunjuk penggunaan **ADAPTER** di Modelfile ada di dokumentasi resmi. ([Ollama][3])

```python

fine_tune_gemma3_1b_lora.py

import json, os from datasets import load_dataset from transformers import AutoTokenizer, AutoModelForCausalLM from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training from transformers import TrainingArguments, Trainer, DataCollatorForLanguageModeling

BASE_MODEL_ID = "google/gemma-3-1b-it" # ganti sesuai HF model yang tersedia OUTPUT_DIR = "lora_out" os.makedirs(OUTPUT_DIR, exist_ok=True)

1) Load tokenizer & model (8-bit/4-bit QLoRA hemat VRAM)

tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL_ID, use_fast=True) model = AutoModelForCausalLM.from_pretrained(

   BASE_MODEL_ID,
   load_in_4bit=True,
   device_map="auto"

)

2) Siapkan PEFT LoRA

lora_config = LoraConfig(

   r=16,
   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="CAUSAL_LM"

) model = prepare_model_for_kbit_training(model) model = get_peft_model(model, lora_config)

3) Dataset JSONL → prompt
Template simpel: "~~### Instruction:\n{instruction}\n### Response:\n{output}~~"

def format_example(ex):

   instruction = ex.get("instruction","").strip()
   user_input = ex.get("input","").strip()
   output = ex.get("output","").strip()
   if user_input:
       prompt = f"### Instruction:\n{instruction}\n### Input:\n{user_input}\n### Response:\n{output}"
   else:
       prompt = f"### Instruction:\n{instruction}\n### Response:\n{output}"
   return {"text": prompt}

dataset = load_dataset("json", data_files="data_faq.jsonl", split="train") dataset = dataset.map(format_example)

4) Tokenisasi

def tokenize_fn(batch):

   return tokenizer(batch["text"], truncation=True, max_length=1024)

tokenized = dataset.map(tokenize_fn, batched=True, remove_columns=dataset.column_names)

5) Data collator (LM)

collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm=False)

6) Training args (ringan; sesuaikan dengan GPU)

args = TrainingArguments(

   output_dir=OUTPUT_DIR,
   per_device_train_batch_size=2,
   gradient_accumulation_steps=8,
   learning_rate=2e-4,
   num_train_epochs=2,
   logging_steps=20,
   save_steps=200,
   save_total_limit=2,
   bf16=True,
   optim="paged_adamw_8bit",
   report_to="none"

)

trainer = Trainer(

   model=model,
   args=args,
   train_dataset=tokenized,
   data_collator=collator,

)

trainer.train()

7) Simpan LoRA adapter (PEFT)

model.save_pretrained(OUTPUT_DIR) tokenizer.save_pretrained(OUTPUT_DIR)

print(f"LoRA adapter saved to: {OUTPUT_DIR}") ```

- Hasil:** folder `lora_out/` berisi file **adapter** (mis. `adapter_config.json`, `adapter_model.safetensors`). Panduan menyimpan/menjalankan LoRA dan memakai di Ollama (Modelfile `ADAPTER`) banyak dibahas juga oleh Unsloth & komunitas. ([docs.unsloth.ai][4])

---

3) **Integrasi ke Ollama** lewat **Modelfile**

Buat file bernama `Modelfile`:

```Dockerfile

Modelfile: gemma3-1b-faq.modelfile

FROM gemma3:1b

Terapkan LoRA adapter hasil training (path relatif/absolut ke folder adapter)

ADAPTER ./lora_out/

(opsional) Prompt sistem agar gaya konsisten

SYSTEM """ Kamu adalah chatbot FAQ sekolah. Jawab singkat, jelas, dan sopan. """

(opsional) Atur parameter inferensi

PARAMETER temperature 0.2 PARAMETER top_p 0.9 ```

Lalu **buat model** kustom di Ollama dan jalankan:

```bash ollama create gemma3-1b-faq -f gemma3-1b-faq.modelfile ollama run gemma3-1b-faq ```

> **Kunci:** `FROM gemma3:1b` memastikan basis cocok, dan `ADAPTER …` menerapkan LoRA hasil *fine-tune*. Ini adalah cara resmi menerapkan **LoRA adapter** di Ollama via **Modelfile**. ([Ollama][3])

- Tes cepat di sesi Ollama:**

``` > Kapan UKK dilaksanakan? ```

(Seharusnya merujuk ke pola jawaban yang kamu latih dari dataset FAQ.)

---

1. Tips Praktik Baik (ringkas)

**Konsistensi format**: pastikan semua contoh punya `instruction` dan `output` yang jelas.
**Variasi pertanyaan**: untuk topik sama, latih beberapa cara tanya yang beda.
**Split data**: sisakan sebagian untuk **uji manual** di akhir (jangan semua dilatih).

---

1. FAQ singkat

**Bisa tanpa Unsloth?** Bisa, pakai *Transformers + PEFT* saja (script di atas sudah begitu). Unsloth membantu percepatan & hemat memori. ([docs.unsloth.ai][4])
**Harus konversi ke GGUF?** Tidak wajib. Dengan Modelfile `ADAPTER` banyak alur langsung memakai **folder safetensors**. Jika perlu *merge/export* tertentu (mis. via `llama.cpp` tools), ada panduan komunitas. ([GitHub][5])
**Nama model Ollama benar?** Ya, `gemma3:1b` tersedia di library Ollama. ([Ollama][1])

---

Kalau mau, saya bisa siapkan **template Colab** + **dataset CSV→JSONL converter** dan **ukur akurasi sederhana** (tes sebelum/ sesudah fine-tune) — tinggal bilang ya.

[1]: https://ollama.com/library/gemma3%3A1b?utm_source=chatgpt.com "gemma3:1b" [2]: https://www.arsturn.com/blog/deep-dive-fine-tuning-models-ollama?utm_source=chatgpt.com "Fine-Tuning Models with Ollama: A Comprehensive Guide - Arsturn" [3]: https://docs.ollama.com/modelfile?utm_source=chatgpt.com "Modelfile reference" [4]: https://docs.unsloth.ai/basics/running-and-saving-models/saving-to-ollama?utm_source=chatgpt.com "Saving to Ollama | Unsloth Documentation" [5]: https://github.com/dkarunakaran/deploy_to_ollama?utm_source=chatgpt.com "Deploying to Ollama - dkarunakaran ..."

LLM: Fine Tuning Ollama gemma3:1b

Navigation menu

Search