LLM: Fine Tuning

1. 1. Model Ollama yang Direkomendasikan untuk Fine-Tuning

Dengan spesifikasi RTX 4060 (8GB VRAM) di Ubuntu 24.04, saya merekomendasikan **Llama 3.1 8B** sebagai model yang paling mungkin di-fine-tune. Alasan: - Ukuran model (sekitar 4-5GB saat dikuantisasi 4-bit) muat di 8GB VRAM menggunakan teknik efisien seperti LoRA/QLoRA, yang hanya butuh ~6-8GB VRAM untuk training. - Model ini populer di Ollama, performa bagus untuk tugas umum, dan banyak tutorial mendukungnya. - Alternatif lebih kecil: Phi-3 Mini (3.8B) jika dataset sangat besar, tapi Llama 3.1 lebih fleksibel untuk fine-tuning mendalam.

Fine-tuning Ollama tidak sepenuhnya via CLI murni (karena butuh library seperti Unsloth untuk LoRA), tapi bisa dijalankan lewat script Python yang dieksekusi via CLI. Proses ini pakai Unsloth untuk efisiensi GPU NVIDIA. Estimasi waktu: 1-2 jam untuk dataset kecil (~1.000 sampel) pada RTX 4060.

1. 1. Persiapan Hardware (NVIDIA Drivers & CUDA)

Pastikan GPU terdeteksi. Jalankan perintah di terminal:

1. Update sistem:

  ```
  sudo apt update && sudo apt upgrade -y
  ```

2. Install NVIDIA drivers (versi 550 atau lebih baru untuk RTX 4060):

  ```
  sudo ubuntu-drivers autoinstall
  ```
  Atau manual:
  ```
  sudo apt install nvidia-driver-550 -y
  ```
  Reboot: `sudo reboot`. Verifikasi dengan `nvidia-smi` (harus tampil RTX 4060 dengan 8GB VRAM).

3. Install CUDA Toolkit (versi 12.1+ untuk kompatibilitas PyTorch/Unsloth):

  ```
  wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/x86_64/cuda-keyring_1.1-1_all.deb
  sudo dpkg -i cuda-keyring_1.1-1_all.deb
  sudo apt-get update
  sudo apt-get install cuda-toolkit-12-5 -y
  ```
  Tambahkan ke PATH: Edit `~/.bashrc` dengan `export PATH=/usr/local/cuda-12.5/bin${PATH:+:${PATH}}` dan `export LD_LIBRARY_PATH=/usr/local/cuda-12.5/lib64${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}`, lalu `source ~/.bashrc`.
  
  Verifikasi: `nvcc --version`.

1. 1. Install Ollama

1. Install via CLI:

  ```
  curl -fsSL https://ollama.com/install.sh | sh
  ```

2. Jalankan service:

  ```
  ollama serve
  ```
  (Jalankan di background dengan `nohup ollama serve &` atau via systemd.)

3. Download model base (untuk testing):

  ```
  ollama pull llama3.1:8b
  ```
  Verifikasi GPU usage: Jalankan `ollama run llama3.1:8b` dan monitor dengan `nvidia-smi`.

1. 1. Install Tool Fine-Tuning (Unsloth)

Unsloth dioptimalkan untuk NVIDIA dan mengurangi VRAM usage hingga 2x.

1. Install Python 3.10+ jika belum: `sudo apt install python3-pip python3-venv -y`.

2. Buat virtual env:

  ```
  python3 -m venv unsloth-env
  source unsloth-env/bin/activate
  ```

3. Install dependencies (fokus CUDA 11.8/12.x):

  ```
  pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
  pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121  # Sesuaikan cu121 untuk CUDA 12.1
  pip install datasets trl peft accelerate bitsandbytes xformers
  ```

1. 1. Siapkan Dataset

Gunakan dataset sederhana seperti Alpaca (untuk instruksi-following). Download via Hugging Face.

1. Buat file `dataset.jsonl` atau gunakan script untuk load:

  - Contoh dataset Alpaca: https://huggingface.co/datasets/vicgalle/alpaca-gpt4
  - Script Python sederhana untuk download (simpan sebagai `prepare_data.py`):
    ```python
    from datasets import load_dataset
    dataset = load_dataset("vicgalle/alpaca-gpt4", split="train")
    dataset.to_json("alpaca.json", lines=True)
    ```
    Jalankan: `python prepare_data.py`.

Asumsi dataset Anda dalam format JSONL: `{"instruction": "...", "input": "...", "output": "..."}`. Sesuaikan untuk task Anda (misal, Q&A atau chat).

1. 1. Fine-Tuning dengan LoRA (via Script CLI)

Buat file `train.py` berdasarkan tutorial Unsloth. Jalankan via CLI.

Isi `train.py`: ```python from unsloth import FastLanguageModel import torch from datasets import load_dataset from trl import SFTTrainer from peft import LoraConfig from transformers import TrainingArguments

Load model (quantized untuk 8GB VRAM)

max_seq_length = 2048 dtype = None # Auto-detect (bfloat16 untuk RTX 40-series) load_in_4bit = True # QLoRA untuk efisiensi

model, tokenizer = FastLanguageModel.from_pretrained(

   model_name="unsloth/Meta-Llama-3.1-8B-bnb-4bit",  # Base model quantized
   max_seq_length=max_seq_length,
   dtype=dtype,
   load_in_4bit=load_in_4bit,

)

LoRA config

model = FastLanguageModel.get_peft_model(

   model,
   r=16,  # Rank LoRA (16 cukup untuk 8GB)
   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",
   random_state=3407,
   use_rslora=False,

)

Load dataset

dataset = load_dataset("json", data_files="alpaca.json", split="train")

Trainer

trainer = SFTTrainer(

   model=model,
   tokenizer=tokenizer,
   train_dataset=dataset,
   dataset_text_field="text",  # Sesuaikan kolom (buat fungsi formatting jika perlu)
   max_seq_length=max_seq_length,
   args=TrainingArguments(
       per_device_train_batch_size=2,
       gradient_accumulation_steps=4,
       warmup_steps=5,
       max_steps=60,  # Atau num_train_epochs=1 untuk full dataset
       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",
   ),

)

Train

trainer.train()

Save LoRA adapter

model.save_pretrained("lora_model") ```

Jalankan: ``` python train.py ``` Monitor VRAM dengan `watch nvidia-smi`. Jika OOM, kurangi batch_size ke 1 atau r=8.

1. 1. Convert ke Format Ollama dan Import

1. Convert LoRA ke GGUF (gunakan Unsloth export atau llama.cpp).

  - Install llama.cpp: `git clone https://github.com/ggerganov/llama.cpp && cd llama.cpp && make -j`.
  - Merge LoRA ke base model dan convert (script `merge_and_convert.py`):
    ```python
    from unsloth import FastLanguageModel
    from peft import PeftModel
    import torch

    base_model, tokenizer = FastLanguageModel.from_pretrained("unsloth/Meta-Llama-3.1-8B-bnb-4bit")
    model = PeftModel.from_pretrained(base_model, "lora_model")
    model = model.merge_and_unload()
    model.save_pretrained("merged_model", safe_serialization=True)

    # Export ke GGUF via CLI llama.cpp
    # python convert_hf_to_gguf.py merged_model --outtype q4_k_m  # Q4 untuk 8GB
    ```
    Jalankan: `python convert_hf_to_gguf.py merged_model --outfile llama3.1-finetuned.gguf --outtype q4_k_m`.

2. Buat Modelfile untuk Ollama (`Modelfile`):

  ```
  FROM ./llama3.1-finetuned.gguf
  TEMPLATE """Template:.System<|start_header_id|>user<|end_header_id|>

  Template:.Prompt<|eot_id|><|start_header_id|>assistant<|end_header_id|>

  Template:.Response<|eot_id|>"""
  PARAMETER stop "<|start_header_id|>"
  PARAMETER stop "<|end_header_id|>"
  PARAMETER stop "<|eot_id|>"
  SYSTEM "You are a helpful assistant."
  ```

3. Import ke Ollama:

  ```
  ollama create my-finetuned-llama -f Modelfile
  ```

4. Test:

  ```
  ollama run my-finetuned-llama "Halo, apa kabar?"
  ```

1. 1. Tips Tambahan

- **VRAM Management**: Gunakan `load_in_4bit=True` dan Q4_K_M quantization untuk muat di 8GB. Jika error, coba di Google Colab gratis dulu untuk test. - **Dataset Ukuran**: Mulai dengan 500-1000 sampel untuk hindari overfit. - **Troubleshooting**: Jika GPU tidak terpakai, cek `OLLAMA_CUDA_VISIBLE_DEVICES=0` env var. Update Ollama ke versi terbaru. - Sumber: Berdasarkan tutorial Unsloth dan docs NVIDIA/Ubuntu.

Jika butuh dataset khusus atau error, beri tahu detailnya!

LLM: Fine Tuning

Navigation menu

Search