View source for LLM: Fine Tune Ollama qwen3:1.7b

### Panduan Fine-Tuning Model Qwen2-1.5B dengan Dataset JSONL dan Deployment ke Ollama

Halo! Saya asumsikan "qwen3:1.7b" merujuk pada model Qwen2-1.5B atau Qwen2.5-1.5B (versi terbaru dari Alibaba, karena Qwen3 belum dirilis secara luas per Oktober 2025). Model ini bisa di-fine-tune menggunakan dataset dalam format JSONL (misalnya, format Alpaca: `{"instruction": "...", "input": "...", "output": "..."}` per baris). Proses ini melibatkan fine-tuning dengan LoRA (via Hugging Face dan Unsloth untuk efisiensi), konversi ke format GGUF (untuk Ollama), dan pembuatan Modelfile.

**Prasyarat:**
- GPU dengan minimal 8GB VRAM (untuk model 1.5B dengan 4-bit quantization).
- Python 3.10+, Git.
- Dataset JSONL siap (contoh: `train.jsonl`).
- Jalankan di Google Colab atau lokal dengan CUDA.

Proses ini bisa selesai dalam 1-2 jam tergantung dataset size. Saya akan jelaskan step-by-step dengan contoh kode. Gunakan Unsloth untuk mempercepat fine-tuning (hingga 2x lebih cepat).

#### Step 1: Persiapan Lingkungan dan Instalasi
Jalankan di terminal atau Colab:

```bash
pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps xformers "trl<0.9.0" peft accelerate bitsandbytes datasets transformers
```

#### Step 2: Load Model dan Tokenizer
Gunakan versi quantized dari Unsloth untuk efisiensi. Ganti `Qwen/Qwen2.5-1.5B` jika model spesifikmu berbeda.

```python
from unsloth import FastLanguageModel
import torch
from datasets import load_dataset

max_seq_length = 2048  # Sesuaikan dengan kebutuhan
dtype = None  # Auto-detect (bfloat16 jika GPU support)
load_in_4bit = True

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Qwen2.5-1.5B-bnb-4bit",  # Atau "Qwen/Qwen2-1.5B-Instruct"
    max_seq_length=max_seq_length,
    dtype=dtype,
    load_in_4bit=load_in_4bit,
    # token="hf_..." jika private model
)
```

#### Step 3: Konfigurasi LoRA (PEFT)
Terapkan LoRA untuk fine-tuning efisien (hanya train ~1% parameter).

```python
model = FastLanguageModel.get_peft_model(
    model,
    r=16,  # Rank LoRA, mulai dari 16
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
    lora_alpha=16,
    lora_dropout=0,
    bias="none",
    use_gradient_checkpointing="unsloth",  # Hemat memori
    random_state=3407,
    use_rslora=False,
    loftq_config=None,
)
```

#### Step 4: Load dan Preprocessing Dataset JSONL
Load dari file JSONL, format ke prompt Qwen2 (mirip Alpaca).

```python
# Definisikan prompt template untuk Qwen2 Instruct
alpaca_prompt = """<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
{}<|im_end|>
<|im_start|>assistant
{}<|im_end|>"""  # Sesuaikan dengan formatmu; tambah EOS jika perlu

EOS_TOKEN = tokenizer.eos_token

def formatting_prompts_func(examples):
    instructions = examples["instruction"]
    inputs = examples["input"] if "input" in examples else [""] * len(instructions)
    outputs = examples["output"]
    texts = []
    for instruction, input_, output in zip(instructions, inputs, outputs):
        # Gabung input jika ada
        user_input = f"{instruction}\n{input_}" if input_ else instruction
        text = alpaca_prompt.format(user_input, output) + EOS_TOKEN
        texts.append(text)
    return {"text": texts}

# Load dataset JSONL
dataset = load_dataset("json", data_files={"train": "path/to/your/file.jsonl"}, split="train")
dataset = dataset.map(formatting_prompts_func, batched=True)

# Split jika perlu (80% train, 20% eval)
dataset = dataset.train_test_split(test_size=0.2)
```

#### Step 5: Training dengan SFTTrainer
Konfigurasi dan jalankan training.

```python
from trl import SFTTrainer
from transformers import TrainingArguments

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset["train"],
    eval_dataset=dataset["test"],
    dataset_text_field="text",
    max_seq_length=max_seq_length,
    dataset_num_proc=2,
    packing=False,  # Untuk sequence panjang
    args=TrainingArguments(
        per_device_train_batch_size=2,  # Sesuaikan VRAM
        gradient_accumulation_steps=4,
        warmup_steps=5,
        max_steps=60,  # Atau num_epochs=1
        learning_rate=2e-4,
        fp16=not torch.cuda.is_bf16_supported(),
        bf16=torch.cuda.is_bf16_supported(),
        logging_steps=1,
        optim="adamw_8bit",
        weight_decay=0.01,
        lr_scheduler_type="linear",
        seed=3407,
        output_dir="outputs",
    ),
)

trainer_stats = trainer.train()
```

Simpan model setelah training:
```python
model.save_pretrained("fine_tuned_qwen2_1.5b")
tokenizer.save_pretrained("fine_tuned_qwen2_1.5b")
```

#### Step 6: Konversi ke Format GGUF untuk Ollama
Gunakan llama.cpp untuk convert. Ini memerlukan CPU/GPU, tapi bisa di-Colab.

1. Clone repo:
   ```bash:disable-run
   git clone https://github.com/ggerganov/llama.cpp
   cd llama.cpp
   pip install -r requirements.txt
   ```

2. Convert model Hugging Face ke GGUF (FP16 dulu):
   ```bash
   python convert.py /path/to/fine_tuned_qwen2_1.5b --outfile fine_tuned_qwen2.gguf --outtype f16
   ```

3. Quantize (opsional, untuk hemat memori; Q4_K_M bagus untuk 1.5B):
   ```bash
   ./llama-quantize fine_tuned_qwen2.gguf fine_tuned_qwen2_q4.gguf Q4_K_M
   ```

#### Step 7: Deployment ke Ollama
Install Ollama jika belum (https://ollama.com/download).

1. Buat file `Modelfile` (tanpa ekstensi) di folder yang sama dengan GGUF:
   ```
   FROM ./fine_tuned_qwen2_q4.gguf

   TEMPLATE """<|im_start|>system
   You are a helpful assistant.<|im_end|>
   <|im_start|>user
   {{ .Prompt }}<|im_end|>
   <|im_start|>assistant
   """

   PARAMETER stop "<|im_end|>"
   PARAMETER stop "<|im_start|>"
   PARAMETER num_ctx 2048  # Sesuaikan dengan max_seq_length
   PARAMETER temperature 0.7
   PARAMETER top_p 0.9
   ```

   - Template ini untuk Qwen2 Instruct; sesuaikan jika custom.

2. Create dan run model:
   ```bash
   ollama create my_fine_tuned_qwen -f Modelfile
   ollama run my_fine_tuned_qwen
   ```

Sekarang model siap digunakan di Ollama! Test dengan prompt sederhana.

**Tips Tambahan:**
- Jika looping infinite (masalah umum), tambah `PARAMETER num_predict -1` di Modelfile atau cek rope_freq_base di metadata HF.
- Dataset besar? Gunakan `num_epochs=1` dan monitor loss.
- Error VRAM? Turunkan batch_size atau gunakan 8-bit optimizer.
- Sumber: Berdasarkan tutorial Unsloth untuk Qwen2, konversi llama.cpp, dan Ollama docs untuk Qwen.

Jika butuh bantuan debug kode atau contoh JSONL, beri tahu!
```