LLM: Fine Tune Ollama qwen3:0.6b

1. 1. 1. Panduan Fine-Tuning Model Qwen2-0.5B dengan Dataset JSONL untuk Ollama

Saya asumsikan "qwen3:0.6b" merujuk pada model Qwen2-0.5B (atau varian serupa seperti Qwen2.5-0.5B-Instruct, karena Qwen3 belum dirilis secara luas per Oktober 2025). Model ini ringan dan cocok untuk fine-tuning lokal. Proses ini menggunakan **LLaMA-Factory** untuk fine-tuning (mudah dan efisien), dataset dalam format JSONL (standar chat format), lalu konversi ke GGUF agar langsung bisa dijalankan di **Ollama**.

• • Prasyarat:**

- Python 3.10+ dengan CUDA (jika GPU) atau CPU. - Install LLaMA-Factory: `pip install -U "llama-factory[torch,metrics]"` (lihat [GitHub LLaMA-Factory](https://github.com/hiyouga/LLaMA-Factory)). - Install llama.cpp: Clone repo `git clone https://github.com/ggerganov/llama.cpp` dan build dengan `make`. - Ollama terinstall (download dari [ollama.com](https://ollama.com)). - Dataset JSONL: Setiap baris adalah JSON object, format ShareGPT untuk Qwen (contoh di bawah).

1. 1. 1. 1. 1. Siapkan Dataset JSONL

Dataset harus dalam format chat (multi-turn conversation). Contoh `train.jsonl` (simpan sebagai file teks):

``` {"conversations": [{"from": "human", "value": "Apa itu AI?"}, {"from": "gpt", "value": "AI adalah kecerdasan buatan yang mensimulasikan proses berpikir manusia."}]} {"conversations": [{"from": "human", "value": "Jelaskan machine learning."}, {"from": "gpt", "value": "Machine learning adalah subset AI di mana model belajar dari data tanpa diprogram eksplisit."}]} ```

- `from: "human"` = input user. - `from: "gpt"` = output assistant (ganti dengan "assistant" jika format chatml). - Taruh file di folder dataset, misal `./data/train.jsonl`. - Split jika perlu: 80% train, 20% eval.

1. 1. 1. 1. 2. Fine-Tuning dengan LLaMA-Factory

LLaMA-Factory mendukung Qwen secara native. Gunakan script SFT (Supervised Fine-Tuning).

- Buat file config YAML (`sft.yaml`) atau gunakan CLI. Contoh CLI command untuk Qwen2-0.5B:

``` llamafactory-cli train \

 --stage sft \
 --model_name_or_path Qwen/Qwen2-0.5B \
 --dataset your_dataset_name \  # Daftarkan dataset di examples/dataset_info.json jika custom
 --dataset_dir ./data \
 --template qwen \  # Template chat untuk Qwen
 --finetuning_type lora \  # Efisien, gunakan LoRA untuk model kecil
 --lora_target q_proj,v_proj  # Target LoRA untuk Qwen
 --output_dir ./output/qwen-finetuned \
 --overwrite_output_dir \
 --cutoff_len 1024 \
 --max_samples 1000 \  # Jumlah sample dari JSONL
 --per_device_train_batch_size 4 \
 --gradient_accumulation_steps 4 \
 --lr_scheduler_type cosine \
 --logging_steps 10 \
 --save_steps 100 \
 --learning_rate 5e-5 \
 --num_train_epochs 3 \
 --plot_loss \
 --fp16  # Gunakan FP16 untuk hemat memori

```

- **Penjelasan:**

 - `--model_name_or_path`: Ambil base model dari Hugging Face.
 - `--dataset`: Jika custom JSONL, tambahkan ke `src/llamafactory/data/dataset_info.json` seperti: `"your_dataset": {"file_name": "train.jsonl", "columns": {"messages": "conversations"}}`.
 - Jalankan di GPU jika ada (minimal 4GB VRAM untuk 0.5B).
 - Output: Model fine-tuned di `./output/qwen-finetuned` (dengan adapter LoRA).

- Jika ingin notebook: Lihat [Unsloth notebook untuk Qwen](https://huggingface.co/unsloth/Qwen2.5-0.5B-Instruct) – gratis di Colab, 2x lebih cepat.

- Waktu estimasi: 10-30 menit untuk 1000 sample di GPU.

1. 1. 1. 1. 3. Merge LoRA dan Export ke Hugging Face Format

Setelah fine-tuning, merge adapter ke base model:

``` llamafactory-cli export \

 --model_name_or_path Qwen/Qwen2-0.5B \
 --adapter_name_or_path ./output/qwen-finetuned \
 --template qwen \
 --export_dir ./merged_model \
 --export_size 2 \  # Export ke FP16
 --export_legacy_format False

```

Ini hasilkan model lengkap di `./merged_model` siap untuk konversi.

1. 1. 1. 1. 4. Konversi ke GGUF untuk Ollama

Gunakan llama.cpp converter:

- Di folder llama.cpp, jalankan:

``` python convert_hf_to_gguf.py ../merged_model --outfile qwen-finetuned.gguf --outtype f16 ```

- Quantize jika perlu (hemat ruang, misal Q4_K_M):

``` ./llama-quantize qwen-finetuned.gguf qwen-finetuned-q4.gguf Q4_K_M ```

- Hasil: File `.gguf` (ukuran ~300MB untuk 0.5B quantized).

1. 1. 1. 1. 5. Deploy ke Ollama

- Buat `Modelfile` (file teks):

``` FROM ./qwen-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 Template:.Response<|im_end|> """

PARAMETER stop "<|im_end|>" PARAMETER temperature 0.7 PARAMETER top_p 0.9 ```

- (Sesuaikan TEMPLATE dengan format Qwen: Gunakan `<|im_start|>` dan `<|im_end|>` untuk chat.)

- Import ke Ollama:

``` ollama create qwen-custom -f Modelfile ollama run qwen-custom ```

- Test: `ollama run qwen-custom "Apa itu AI?"` – output harus mengikuti pola fine-tuning dari JSONL.

1. 1. 1. 1. Tips Tambahan

- **Evaluasi:** Gunakan `--do_eval` di CLI untuk metric seperti perplexity. - **Masalah Umum:**

 - Memori: Gunakan LoRA + gradient checkpointing.
 - Format JSONL salah: Pastikan valid JSON per baris (cek dengan `jq . train.jsonl`).
 - Ollama error: Pastikan GGUF kompatibel (test dengan `llama-cli` dari llama.cpp).

- **Sumber Lanjutan:**

 - LLaMA-Factory docs untuk Qwen: [qwen.readthedocs.io](https://qwen.readthedocs.io/en/latest/training/llama_factory.html).
 - Konversi GGUF: [llama.cpp tutorial](https://github.com/ggerganov/llama.cpp/discussions/2948).

Proses ini end-to-end dan output langsung usable di Ollama. Jika butuh contoh kode spesifik atau error, beri detail lebih lanjut!