Tutorial Torchtune: Fine-Tuning LLM dengan PyTorch Native

Pendahuluan

Torchtune adalah library resmi dari PyTorch untuk melakukan fine-tuning Large Language Models (LLM). Library ini dirancang sebagai solusi native PyTorch yang ringan, modular, dan mudah dikustomisasi. Berbeda dengan framework fine-tuning lainnya yang sering kali kompleks dan memiliki banyak abstraksi tersembunyi, Torchtune memberikan kontrol penuh kepada developer sambil tetap menyediakan komponen-komponen siap pakai.

Torchtune mendukung berbagai model populer seperti Llama 3, Mistral, Gemma, Phi, dan Qwen. Library ini menyediakan berbagai teknik fine-tuning mulai dari full fine-tuning hingga parameter-efficient methods seperti LoRA dan QLoRA. Dengan integrasi langsung ke ekosistem PyTorch, Torchtune menjadi pilihan ideal bagi praktisi yang sudah familiar dengan PyTorch dan ingin melakukan fine-tuning LLM tanpa bergantung pada framework pihak ketiga yang berat.

Dalam tutorial ini, kita akan mempelajari cara menggunakan Torchtune dari instalasi hingga fine-tuning model dengan berbagai teknik, termasuk konfigurasi dataset kustom dan deployment model hasil fine-tuning.

Mengapa Torchtune?

Sebelum masuk ke implementasi, ada beberapa alasan mengapa Torchtune layak dipertimbangkan:

Native PyTorch: Dibangun sepenuhnya di atas PyTorch tanpa layer abstraksi tambahan

Modular: Setiap komponen (model, dataset, optimizer, loss) bisa diganti dan dikustomisasi

Memory Efficient: Mendukung teknik hemat memori seperti QLoRA, gradient checkpointing, dan mixed precision

Config-Driven: Workflow diatur melalui file YAML yang mudah dibaca dan dimodifikasi

Multi-GPU: Mendukung distributed training melalui FSDP2 (Fully Sharded Data Parallel)

Ekosistem: Integrasi langsung dengan Hugging Face Hub, Weights & Biases, dan format GGUF

Instalasi

Prasyarat

Pastikan Anda memiliki Python 3.10+ dan PyTorch 2.4+ terinstal.

# Cek versi Python
python --version

Cek versi PyTorch
python -c "import torch; print(torch.version)"

Instalasi Torchtune

# Instalasi via pip (stable release) pip install torchtune Atau instalasi dari source untuk versi terbaru pip install git+https://github.com/pytorch/torchtune.git Instalasi dengan dukungan semua fitur pip install torchtune[all]

Verifikasi Instalasi

# Cek versi torchtune tune --version Lihat daftar recipe yang tersedia tune ls

Output dari tune ls akan menampilkan semua recipe fine-tuning yang tersedia:

RECIPE CONFIG fullfinetunesingledevice llama32/1Bfullsingledevice fullfinetunedistributed llama32/3Bfull lorafinetunesingledevice llama32/1Blorasingledevice lorafinetunedistributed llama32/3Blora qlorafinetunesingledevice llama32/1Bqlorasingledevice knowledgedistillation llama32/1Bkdsingledevice ...

Download Model

Sebelum melakukan fine-tuning, kita perlu mengunduh model dasar. Torchtune menyediakan command tune download untuk mengunduh model dari Hugging Face Hub.

# Download Llama 3.2 1B (model kecil, cocok untuk eksperimen) tune download meta-llama/Llama-3.2-1B-Instruct \ --output-dir ./models/Llama-3.2-1B-Instruct \ --hf-token YOURHFTOKEN Download Mistral 7B tune download mistralai/Mistral-7B-Instruct-v0.3 \ --output-dir ./models/Mistral-7B-Instruct \ --hf-token YOURHFTOKEN Download Qwen 2.5 0.5B (sangat ringan) tune download Qwen/Qwen2.5-0.5B-Instruct \ --output-dir ./models/Qwen2.5-0.5B-Instruct

Anda memerlukan Hugging Face token untuk model yang memerlukan akses khusus seperti Llama. Dapatkan token di huggingface.co/settings/tokens.

Basic Usage: LoRA Fine-Tuning

LoRA (Low-Rank Adaptation) adalah teknik fine-tuning yang paling populer karena hemat memori dan cepat. Mari kita mulai dengan fine-tuning Llama 3.2 1B menggunakan LoRA.

Melihat Konfigurasi Default

# Lihat konfigurasi default untuk LoRA single device tune cp llama32/1Blorasingledevice ./myloraconfig.yaml

Memahami File Konfigurasi

# myloraconfig.yaml Model model: component: torchtune.models.llama32.lorallama321b loraattnmodules: ['qproj', 'vproj', 'kproj', 'outputproj'] applyloratomlp: True applyloratooutput: False lorarank: 8 loraalpha: 16 Tokenizer tokenizer: component: torchtune.models.llama3.llama3tokenizer path: ./models/Llama-3.2-1B-Instruct/original/tokenizer.model maxseqlen: 2048 Checkpoint checkpointer: component: torchtune.training.FullModelHFCheckpointer checkpointdir: ./models/Llama-3.2-1B-Instruct checkpointfiles: [model.safetensors] outputdir: ./output/lora-llama3.2-1b modeltype: LLAMA32 Dataset dataset: component: torchtune.datasets.alpacacleaneddataset seed: 42 shuffle: True Training epochs: 1 maxstepsperepoch: null batchsize: 4 gradientaccumulationsteps: 4 optimizer: component: torch.optim.AdamW fused: True lr: 2e-5 weightdecay: 0.01 lrscheduler: component: torchtune.training.lrschedulers.getcosineschedulewithwarmup numwarmupsteps: 100 Hardware device: cuda dtype: bf16 enableactivationcheckpointing: True Logging metriclogger: component: torchtune.training.metriclogging.WandBLogger project: torchtune-tutorial logeverynsteps: 10

Menjalankan Fine-Tuning

# Jalankan LoRA fine-tuning dengan konfigurasi default
tune run lorafinetunesingledevice \

    --config myloraconfig.yaml


Atau override parameter langsung dari command line
tune run lorafinetunesingledevice \
    --config myloraconfig.yaml \
    batchsize=2 \

    epochs=3 \
    optimizer.lr=1e-5

Monitoring Training

Torchtune mendukung berbagai logger untuk monitoring:

# Menggunakan Weights & Biasesmetriclogger: component: torchtune.training.metriclogging.WandBLogger project: my-finetune-project Menggunakan TensorBoard metriclogger: component: torchtune.training.metriclogging.TensorBoardLogger logdir: ./logs Menggunakan stdout (tanpa external logger) metriclogger: component: torchtune.training.metriclogging.StdoutLogger

Dataset Kustom

Salah satu kekuatan Torchtune adalah fleksibilitas dalam menggunakan dataset kustom.

Format Instruksi (Instruct)

Buat file JSON dengan format berikut:

[ { "instruction": "Jelaskan apa itu machine learning dalam satu paragraf.", "input": "", "output": "Machine learning adalah cabang dari kecerdasan buatan yang memungkinkan komputer belajar dari data tanpa diprogram secara eksplisit. Sistem ML menggunakan algoritma statistik untuk menemukan pola dalam data, membuat prediksi, dan meningkatkan performanya seiring bertambahnya data yang diproses." }, { "instruction": "Terjemahkan teks berikut ke bahasa Inggris.", "input": "Saya sedang belajar pemrograman Python.", "output": "I am learning Python programming." } ]

Konfigurasi Dataset Kustom

# Menggunakan dataset lokal dengan format instruct
dataset:
  component: torchtune.datasets.instructdataset

  source: json
  datafiles: ./data/mydataset.json

  split: train
  columnmap:
    instruction: instruction
    input: input
    output: output
  trainoninput: False

Menggunakan dataset dari Hugging Face
dataset:
  component: torchtune.datasets.instructdataset

  source: tatsu-lab/alpaca
  split: train
  trainoninput: False

Format Chat (Multi-turn)

Untuk dataset percakapan multi-turn:

[ { "messages": [ {"role": "system", "content": "Kamu adalah asisten AI yang membantu."}, {"role": "user", "content": "Apa itu Python?"}, {"role": "assistant", "content": "Python adalah bahasa pemrograman tingkat tinggi yang dirancang untuk kemudahan pembacaan kode."}, {"role": "user", "content": "Apa kelebihannya?"}, {"role": "assistant", "content": "Python memiliki sintaks yang bersih, library yang luas, komunitas besar, dan mendukung berbagai paradigma pemrograman."} ] } ]

# Konfigurasi untuk dataset chat dataset:component: torchtune.datasets.chatdataset source: json datafiles: ./data/chatdata.json split: train conversationcolumn: messages conversationstyle: openai trainoninput: False

Membuat Dataset Builder Kustom

Untuk kebutuhan yang lebih spesifik, Anda bisa membuat dataset builder sendiri:

# mydataset.py
from torchtune.data import Message
from torchtune.datasets import SFTDataset
from torchtune.modules.tokenizers import ModelTokenizer

def mycustomdataset(

    tokenizer: ModelTokenizer,
    source: str = "json",
    datafiles: str = "./data/custom.json",
    maxseqlen: int = 2048,
    kwargs,

) -> SFTDataset:

    def transform(sample):
        messages = [
            Message(
                role="user",
                content=sample["question"],
            ),
            Message(
                role="assistant",
                content=sample["answer"],
            ),
        ]
        return {"messages": messages}

    return SFTDataset(
        source=source,
        datafiles=datafiles,
        messagetransform=transform,

        modeltransform=tokenizer,
        maxseqlen=maxseqlen,
        kwargs,
    )

Gunakan dalam konfigurasi:

dataset: component: mydataset.mycustomdataset datafiles: ./data/custom.json maxseqlen: 2048

Advanced Usage

QLoRA Fine-Tuning

QLoRA menggabungkan quantization 4-bit dengan LoRA, memungkinkan fine-tuning model besar pada GPU dengan VRAM terbatas.

# Copy konfigurasi QLoRA tune cp llama32/1Bqlorasingledevice ./myqloraconfig.yaml

# myqloraconfig.yaml (bagian yang berbeda dari LoRA) model: component: torchtune.models.llama32.qlorallama321b loraattnmodules: ['qproj', 'vproj', 'kproj', 'outputproj'] applyloratomlp: True lorarank: 8 loraalpha: 16 QLoRA menggunakan optimizer khusus optimizer: component: torch.optim.AdamW fused: True lr: 2e-4 weightdecay: 0.01 Quantization otomatis dihandle oleh model component

# Jalankan QLoRA fine-tuning
tune run lorafinetunesingledevice \

    --config myqloraconfig.yaml

Full Fine-Tuning

Untuk hasil terbaik (memerlukan GPU lebih besar):

# fullfinetuneconfig.yaml model: component: torchtune.models.llama32.llama321b checkpointer: component: torchtune.training.FullModelHFCheckpointer checkpointdir: ./models/Llama-3.2-1B-Instruct checkpointfiles: [model.safetensors] outputdir: ./output/full-llama3.2-1b modeltype: LLAMA32 optimizer: component: torch.optim.AdamW fused: True lr: 5e-6 weightdecay: 0.01 enableactivationcheckpointing: True compile: True # Gunakan torch.compile untuk speedup

# Full fine-tuning single GPU
tune run fullfinetunesingledevice \

    --config fullfinetuneconfig.yaml

Distributed Training (Multi-GPU)

Untuk training pada multiple GPU menggunakan FSDP2:

# distributedconfig.yaml model: component: torchtune.models.llama32.lorallama323b loraattnmodules: ['qproj', 'vproj'] lorarank: 16 loraalpha: 32 Distributed-specific settings enableactivationcheckpointing: True fsdpcpuoffload: False # Set True jika VRAM terbatas

# Jalankan distributed training pada 4 GPU
tune run --nprocpernode 4 lorafinetunedistributed \
    --config distributedconfig.yaml

Knowledge Distillation

Torchtune mendukung knowledge distillation untuk mentransfer pengetahuan dari model besar ke model kecil:

# kdconfig.yaml teachermodel: component: torchtune.models.llama32.llama323b studentmodel: component: torchtune.models.llama32.lorallama321b loraattnmodules: ['qproj', 'vproj'] lorarank: 8 kdloss: component: torchtune.modules.loss.ForwardKLWithChunkedOutputLoss kdratio: 0.5 # Balance antara task loss dan KD loss

tune run knowledgedistillationsingledevice \ --config kdconfig.yaml

Evaluasi Model

Torchtune terintegrasi dengan EleutherAI's lm-evaluation-harness untuk evaluasi:

# Instalasi evaluation harness
pip install lm-eval

Evaluasi model hasil fine-tuning
tune run eleuthereval \

    --config eleutherevaluation \
    checkpointer.checkpointdir=./output/lora-llama3.2-1b \

    tasks=["hellaswag", "arceasy", "truthfulqamc2"] \

    limit=100

Menggunakan Model Programmatically

import torch
from torchtune.models.llama32 import llama321b
from torchtune.models.llama3 import llama3tokenizer

from torchtune.training import FullModelHFCheckpointer

Load tokenizer
tokenizer = llama3tokenizer(
    path="./models/Llama-3.2-1B-Instruct/original/tokenizer.model"
)

Load model dari checkpoint hasil fine-tuning
checkpointer = FullModelHFCheckpointer(
    checkpointdir="./output/lora-llama3.2-1b",

    checkpointfiles=["model-00001-of-00001.safetensors"],
    outputdir="./output/merged",

    modeltype="LLAMA32",

)

model = llama321b()

statedict = checkpointer.loadcheckpoint()

model.loadstatedict(statedict["model"])
model.eval()

Generate teks
prompt = "Jelaskan konsep machine learning:"
tokens = tokenizer.encode(prompt, addbos=True)

inputids = torch.tensor([tokens], dtype=torch.long)

with torch.nograd():

    output = model.generate(inputids, maxnewtokens=256)

response = tokenizer.decode(output[0].tolist())
print(response)

Export ke Format GGUF

Untuk deployment menggunakan llama.cpp:

# Export model ke format GGUF
tune run quantize \
    --config quantization \
    checkpointer.checkpointdir=./output/lora-llama3.2-1b \

    quantizer.component=torchtune.training.quantization.Int8DynActInt4WeightQuantizer

Best Practices

1. Pemilihan Hyperparameter

# Rekomendasi hyperparameter berdasarkan ukuran model Model kecil (1B-3B) LoRA rank: 8-16, lr: 2e-5 sampai 5e-5 Batch size efektif: 16-32 Model menengah (7B-13B) LoRA rank: 16-32, lr: 1e-5 sampai 3e-5 Batch size efektif: 8-16 Model besar (70B+) LoRA rank: 32-64, lr: 5e-6 sampai 1e-5 Batch size efektif: 4-8

2. Manajemen Memori

# Strategi hemat memori (urutkan dari paling hemat) 1. Gunakan QLoRA (4-bit quantization + LoRA) model:component: torchtune.models.llama32.qlorallama321b 2. Aktifkan activation checkpointing enableactivationcheckpointing: True 3. Kurangi batch size, tingkatkan gradient accumulation batchsize: 1 gradientaccumulationsteps: 16 4. Kurangi maxseqlen tokenizer: maxseqlen: 1024 # Default biasanya 2048 atau 4096 5. Gunakan FSDP CPU offload (multi-GPU) fsdpcpuoffload: True

3. Kualitas Dataset

Pastikan dataset bersih dan konsisten formatnya
Gunakan trainoninput: False untuk instruksi agar model hanya belajar menghasilkan output
Minimal 1000 sampel berkualitas lebih baik dari 100000 sampel noisy
Diversifikasi instruksi untuk menghindari overfitting pada pola tertentu

4. Monitoring dan Evaluasi

# Logging setiap N steps
logeverynsteps: 10


Simpan checkpoint secara berkala
saveeverynsteps: 500

Gunakan WandB untuk monitoring visual
metriclogger:

  component: torchtune.training.metriclogging.WandBLogger
  project: my-project
  logdir: ./logs

5. Reproducibility

# Selalu set seed untuk reproducibility seed: 42 shuffle: True Gunakan deterministic algorithmstorchdeterministic: True

6. Optimasi Kecepatan

# Aktifkan torch.compile untuk speedup compile: True Gunakan fused optimizer optimizer: component: torch.optim.AdamW fused: True Gunakan bf16 untuk training (lebih cepat dari fp16) dtype: bf16

Troubleshooting

Error CUDA Out of Memory

# Solusi bertahap:
1. Kurangi batchsize

2. Aktifkan activation checkpointing
3. Kurangi maxseqlen

4. Gunakan QLoRA instead of LoRA
5. Gunakan gradient accumulation

Model Tidak Converge

# Checklist:
1. Cek learning rate (terlalu tinggi = diverge, terlalu rendah = lambat)
2. Pastikan dataset format benar (inspect beberapa sampel)
3. Tingkatkan jumlah epoch
4. Cek apakah trainoninput sesuai kebutuhan

Error saat Load Checkpoint

# Pastikan modeltype sesuai dengan model yang digunakan Pastikan checkpointfiles mencakup semua file shard Contoh untuk model multi-shard: checkpointfiles: [ model-00001-of-00003.safetensors, model-00002-of-00003.safetensors, model-00003-of-00003.safetensors, ]

Perbandingan dengan Framework Lain

|-------|-----------|---------------|---------|---------|

Kesimpulan

Torchtune adalah pilihan yang tepat untuk praktisi yang menginginkan kontrol penuh atas proses fine-tuning LLM sambil tetap menggunakan ekosistem PyTorch yang sudah familiar. Dengan arsitektur modular dan config-driven workflow, Torchtune memudahkan eksperimen dengan berbagai teknik fine-tuning tanpa harus menulis boilerplate code yang berlebihan.

Beberapa poin penting yang perlu diingat:

Mulai dengan LoRA atau QLoRA untuk eksperimen awal, baru beralih ke full fine-tuning jika diperlukan
Investasikan waktu dalam menyiapkan dataset berkualitas daripada menambah jumlah data secara membabi buta
Gunakan config YAML untuk menjaga reproducibility dan dokumentasi eksperimen
Manfaatkan integrasi dengan WandB atau TensorBoard untuk monitoring training secara visual
Untuk deployment, export model ke format GGUF agar bisa dijalankan dengan llama.cpp pada hardware consumer

Dengan pemahaman yang baik tentang Torchtune, Anda bisa melakukan fine-tuning LLM secara efisien dan menghasilkan model yang sesuai dengan kebutuhan spesifik proyek Anda.