LLM: Fine Tuning Ollama gemma3:1b

From OnnoWiki
Jump to navigation Jump to search

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

---

  1. 0) Persiapan lingkungan (ringkas)

```bash

  1. Python env (opsional)

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

  1. 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. 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])

---

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

  1. 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. 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"

)

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

  1. 3) Dataset JSONL → prompt
  2. 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)

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

  1. 5) Data collator (LM)

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

  1. 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()

  1. 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])

---

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

Buat file bernama `Modelfile`:

```Dockerfile

  1. Modelfile: gemma3-1b-faq.modelfile

FROM gemma3:1b

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

ADAPTER ./lora_out/

  1. (opsional) Prompt sistem agar gaya konsisten

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

  1. (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 ..."

Retrieved from "https://onnocenter.or.id/wiki/index.php?title=LLM:_Fine_Tuning_Ollama_gemma3:1b&oldid=72940"