Tutorial LitGPT: Framework untuk Melatih dan Fine-Tuning Large Language Models

LitGPT adalah framework open-source dari Lightning AI yang dirancang khusus untuk pretraining, fine-tuning, dan deployment Large Language Models (LLM). Dibangun di atas PyTorch Lightning, LitGPT menyediakan implementasi referensi yang bersih dan modular untuk berbagai arsitektur LLM populer seperti Llama, Mistral, Phi, Gemma, dan lainnya. Framework ini menjadi pilihan utama bagi praktisi yang ingin melatih atau menyesuaikan model bahasa tanpa harus menulis boilerplate code dari nol.

Dalam tutorial ini, kita akan membahas cara menggunakan LitGPT mulai dari instalasi, download model, fine-tuning dengan dataset custom, hingga deployment untuk inference. Semua langkah disertai code examples yang bisa langsung dipraktikkan.

Mengapa LitGPT?

Sebelum masuk ke implementasi, penting untuk memahami keunggulan LitGPT dibandingkan pendekatan lain:

• Multi-arsitektur: Mendukung 20+ arsitektur LLM termasuk Llama 3, Mistral, Phi-3, Gemma 2, Falcon, dan lainnya dalam satu framework yang konsisten
• Optimasi built-in: Flash Attention 2, quantization (QLoRA, GPTQ), gradient checkpointing, dan FSDP tersedia tanpa konfigurasi rumit
• CLI yang intuitif: Operasi umum seperti download, finetune, dan chat tersedia sebagai perintah CLI sederhana
• Modular dan hackable: Kode sumber bersih dan terdokumentasi, memudahkan modifikasi sesuai kebutuhan riset atau produksi
• Konversi checkpoint: Mendukung konversi dari/ke format Hugging Face, memudahkan integrasi dengan ekosistem yang ada

Instalasi

Prasyarat

Pastikan sistem Anda memenuhi persyaratan berikut:

• Python 3.10 atau lebih baru
• CUDA 12.1+ (untuk GPU NVIDIA) atau dukungan MPS (untuk Apple Silicon)
• Minimal 16GB RAM (disarankan 32GB+)
• GPU dengan VRAM minimal 8GB untuk fine-tuning (disarankan 24GB+ untuk model 7B)

Instalasi via pip

pip install 'litgpt[all]'

Opsi [all] akan menginstal semua dependensi termasuk tokenizer, datasets, dan utilitas tambahan. Jika Anda hanya membutuhkan fitur tertentu:

# Instalasi minimal
pip install litgpt

Dengan dukungan quantization
pip install 'litgpt[quantize]'

Instalasi dari Source

Untuk pengembangan atau akses fitur terbaru:

git clone https://github.com/Lightning-AI/litgpt.git
cd litgpt
pip install -e '.[all]'

Verifikasi Instalasi

import litgpt
print(litgpt.version)

Cek model yang tersedia
import subprocess
result = subprocess.run(['litgpt', 'download', 'list'], captureoutput=True, text=True)

print(result.stdout[:500])

# Download Llama 3.1 8B
litgpt download meta-llama/Meta-Llama-3.1-8B-Instruct

Download Mistral 7B
litgpt download mistralai/Mistral-7B-Instruct-v0.3

Download model kecil untuk testing
litgpt download microsoft/phi-2

Model akan disimpan di direktori checkpoints/ secara default. Anda bisa mengubah lokasi dengan flag --checkpointdir:

litgpt download meta-llama/Meta-Llama-3.1-8B-Instruct \
    --checkpointdir ./mymodels/

Chat Interaktif

Setelah model terdownload, Anda bisa langsung melakukan chat:

litgpt chat meta-llama/Meta-Llama-3.1-8B-Instruct

Atau dengan opsi tambahan:

litgpt chat meta-llama/Meta-Llama-3.1-8B-Instruct \
    --maxnewtokens 512 \
    --temperature 0.7 \
    --topp 0.9 \

    --quantize bnb.nf4  # Quantize untuk hemat VRAM

from litgpt import LLM

Load model
llm = LLM.load("meta-llama/Meta-Llama-3.1-8B-Instruct")

Generate teks
response = llm.generate("Jelaskan apa itu machine learning dalam 3 kalimat.")
print(response)

Generate dengan parameter custom
response = llm.generate(
    prompt="Tulis fungsi Python untuk menghitung fibonacci:",
    maxnewtokens=256,

    temperature=0.3,
    topk=50
)
print(response)

Untuk penggunaan dengan quantization agar hemat memori:

from litgpt import LLM

Load dengan 4-bit quantization
llm = LLM.load(
    "meta-llama/Meta-Llama-3.1-8B-Instruct",
    quantize="bnb.nf4"
)

response = llm.generate("Apa keuntungan menggunakan Docker?")
print(response)

Fine-Tuning dengan Dataset Custom

Persiapan Dataset

LitGPT mendukung beberapa format dataset. Format yang paling umum adalah JSON dengan struktur instruction-response:

[
    {
        "instruction": "Jelaskan apa itu API REST",
        "input": "",
        "output": "REST API (Representational State Transfer Application Programming Interface) adalah arsitektur komunikasi yang menggunakan protokol HTTP untuk pertukaran data antar sistem. REST API menggunakan metode HTTP standar seperti GET, POST, PUT, dan DELETE untuk operasi CRUD. Data biasanya dikirim dalam format JSON atau XML."
    },
    {
        "instruction": "Konversi kode berikut ke Python 3",
        "input": "print 'Hello World'",
        "output": "print('Hello World')"
    }
]

Simpan file ini sebagai mydataset.json. Kemudian buat script untuk mempersiapkan data:

import json
from pathlib import Path

def preparedataset(inputfile, outputdir):
    """Mempersiapkan dataset untuk LitGPT fine-tuning."""
    outputdir = Path(outputdir)
    outputdir.mkdir(parents=True, existok=True)

    with open(inputfile, 'r', encoding='utf-8') as f:

        data = json.load(f)

    # Split 90% train, 10% validation
    splitidx = int(len(data)  0.9)

    traindata = data[:splitidx]
    valdata = data[splitidx:]

    with open(outputdir / "train.json", 'w', encoding='utf-8') as f:

        json.dump(traindata, f, ensureascii=False, indent=2)


    with open(outputdir / "val.json", 'w', encoding='utf-8') as f:
        json.dump(valdata, f, ensureascii=False, indent=2)

    print(f"Train samples: {len(traindata)}")

    print(f"Validation samples: {len(valdata)}")

preparedataset("mydataset.json", "data/mycustomdata")

litgpt finetune lora \
    --checkpointdir checkpoints/meta-llama/Meta-Llama-3.1-8B-Instruct \

    --data JSON \
    --data.jsonpath data/mycustomdata/ \
    --train.epochs 3 \
    --train.lrwarmupsteps 100 \
    --train.learningrate 3e-4 \

    --train.microbatchsize 4 \

    --train.maxseqlength 1024 \

    --lorar 16 \
    --loraalpha 32 \

    --loradropout 0.05 \
    --outdir out/my-finetuned-model

litgpt finetune lora \
    --checkpointdir checkpoints/meta-llama/Meta-Llama-3.1-8B-Instruct \

    --data JSON \
    --data.jsonpath data/mycustomdata/ \
    --quantize bnb.nf4 \
    --train.epochs 3 \
    --train.learningrate 2e-4 \

    --train.microbatchsize 2 \

    --lorar 8 \
    --loraalpha 16 \

    --precision bf16-true \
    --outdir out/my-qlora-model

litgpt finetune full \
    --checkpointdir checkpoints/microsoft/phi-2 \

    --data JSON \
    --data.jsonpath data/mycustomdata/ \
    --train.epochs 2 \
    --train.learningrate 2e-5 \

    --train.microbatchsize 1 \

    --train.maxseqlength 1024 \

    --outdir out/phi2-full-finetune

# Jalankan TensorBoard
tensorboard --logdir out/my-finetuned-model/logs

Akses di browser: http://localhost:6006

litgpt finetune lora \
    --checkpointdir checkpoints/meta-llama/Meta-Llama-3.1-8B-Instruct \

    --data JSON \
    --data.jsonpath data/mycustomdata/ \
    --devices 4 \
    --train.epochs 3 \
    --train.learningrate 3e-4 \

    --lorar 16 \
    --loraalpha 32 \

    --outdir out/multi-gpu-model

litgpt pretrain \
    --modelname tiny-llama-1.1b \

    --data TextFiles \
    --data.path data/mycorpus/ \
    --train.maxsteps 50000 \

    --train.learningrate 4e-4 \
    --train.microbatchsize 8 \
    --train.maxseqlength 2048 \
    --devices 4 \
    --outdir out/my-pretrained-model

# LitGPT ke Hugging Face
from litgpt.scripts.convertlitcheckpoint import convertlitcheckpoint


convertlitcheckpoint(

    checkpointdir="out/my-finetuned-model/final",
    outputdir="out/my-finetuned-model/hfformat"
)

# LitGPT -> Hugging Face format
litgpt convertfromlitgpt \
    --checkpointdir out/my-finetuned-model/final \

    --outputdir out/hfmodel


Hugging Face -> LitGPT format
litgpt converttolitgpt \

    --checkpointdir path/to/hfmodel \

    --outputdir checkpoints/myconvertedmodel

import litserve as ls
from litgpt import LLM

class LitGPTAPI(ls.LitAPI):
    def setup(self, device):
        self.llm = LLM.load(
            "out/my-finetuned-model/final",
            quantize="bnb.nf4"
        )

    def decoderequest(self, request):

        return request["prompt"]

    def predict(self, prompt):
        return self.llm.generate(
            prompt,
            maxnewtokens=512,

            temperature=0.7
        )

    def encoderesponse(self, output):
        return {"response": output}

if name == "main":
    api = LitGPTAPI()
    server = ls.LitServer(api, accelerator="gpu", devices=1)
    server.run(port=8000)

curl -X POST http://localhost:8000/predict \
    -H "Content-Type: application/json" \
    -d '{"prompt": "Jelaskan konsep microservices:"}'

# Install evaluation harness
pip install lm-eval

Konversi ke format HF terlebih dahulu
litgpt convertfromlitgpt \
    --checkpointdir out/my-finetuned-model/final \

    --outputdir out/hfevalmodel

Jalankan evaluasi
lmeval --model hf \

    --modelargs pretrained=out/hfevalmodel \
    --tasks hellaswag,arceasy,mmlu \

    --batchsize 4

# Estimasi kebutuhan VRAM
def estimatevram(modelparamsbillion, method="qlora"):

    if method == "full":
        return modelparamsbillion  6  # ~6GB per 1B params (mixed precision)
    elif method == "lora":
        return modelparamsbillion  2  # ~2GB per 1B params

    elif method == "qlora":
        return modelparamsbillion  1.2  # ~1.2GB per 1B params

print(f"Llama 8B LoRA: ~{estimatevram(8, 'lora')}GB VRAM")
print(f"Llama 8B QLoRA: ~{estimatevram(8, 'qlora')}GB VRAM")

print(f"Llama 8B Full: ~{estimatevram(8, 'full')}GB VRAM")

3. Kualitas Dataset

• Pastikan dataset bersih dan konsisten dalam format
• Minimum 100-500 sampel untuk task spesifik dengan LoRA
• Gunakan deduplication untuk menghindari overfitting
• Validasi format JSON sebelum training

4. Hyperparameter Tuning

Mulai dengan konfigurasi konservatif lalu sesuaikan:

# Konfigurasi awal yang aman
learningrate: 2e-4

epochs: 3
microbatchsize: 4

lorar: 8
loraalpha: 16

warmupsteps: 100
weight_decay: 0.01

5. Checkpoint Management

# LitGPT otomatis menyimpan checkpoint
Struktur output:
out/my-model/
├── final/           # Checkpoint akhir
├── step-1000/       # Checkpoint intermediate
├── step-2000/
├── logs/            # TensorBoard logs
└── hyperparameters.yaml

Kesimpulan

LitGPT menyederhanakan workflow LLM dari download hingga deployment. Keunggulan utamanya terletak pada dukungan multi-arsitektur yang luas, CLI yang intuitif, dan implementasi teknik optimasi seperti LoRA/QLoRA yang terintegrasi. Framework ini cocok untuk praktisi yang ingin fokus pada eksperimen dan hasil tanpa terjebak dalam detail implementasi low-level.

Langkah selanjutnya yang bisa Anda eksplorasi:

Dokumentasi lengkap dan contoh tambahan tersedia di repositori resmi LitGPT di GitHub.