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

2025-10-04T22:04:46Z

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

New page

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

LLM: Fine Tune Ollama qwen3:1.7b - Revision history

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