Tutorial Lengkap Liger Kernel: Efisiensi Training LLM dengan Triton Kernels

Pendahuluan

Training dan fine-tuning Large Language Models (LLM) adalah proses yang membutuhkan resource komputasi sangat besar, terutama dari sisi VRAM GPU. Bagi banyak praktisi machine learning, keterbatasan VRAM menjadi hambatan utama — baik saat melakukan full fine-tuning maupun parameter-efficient fine-tuning seperti LoRA. Di sinilah Liger Kernel hadir sebagai solusi yang sangat praktis.

Liger Kernel adalah koleksi kernel Triton yang dikembangkan oleh tim LinkedIn, dirancang khusus untuk mempercepat training LLM sekaligus mengurangi konsumsi VRAM secara signifikan. Nama "Liger" sendiri merupakan singkatan dari LinkedIn GPU Efficient Runtimes. Dengan menggantikan operasi-operasi bawaan PyTorch menggunakan kernel Triton yang dioptimasi, Liger Kernel mampu memberikan penghematan memori hingga 60% dan peningkatan throughput hingga 20% pada berbagai arsitektur model populer seperti LLaMA, Mistral, Gemma, dan Qwen.

Dalam tutorial ini, kita akan membahas secara mendalam bagaimana menggunakan Liger Kernel dalam berbagai skenario — mulai dari integrasi sederhana satu baris kode dengan HuggingFace Transformers, hingga penggunaan kernel individual dalam custom training loop. Tutorial ini ditujukan untuk ML practitioners yang ingin memaksimalkan efisiensi hardware mereka tanpa mengorbankan kualitas training.

Mengapa Liger Kernel?

Ada beberapa alasan kuat mengapa Anda harus mempertimbangkan Liger Kernel:

Kernel yang Tersedia

Liger Kernel menyediakan implementasi Triton yang dioptimasi untuk operasi-operasi berikut:

• RMSNorm: Root Mean Square Layer Normalization
• RoPE (Rotary Positional Embedding): Encoding posisi rotary
• SwiGLU: Aktivasi fungsi SwiGLU yang digunakan di LLaMA dan model sejenis
• CrossEntropyLoss: Loss function cross-entropy yang efisien
• FusedLinearCrossEntropy: Fusi dari layer linear terakhir dengan cross-entropy loss
• GeGLU dan ReGLU: Varian lain dari gated linear units
• Layer Norm: Layer normalization standar
• GroupNorm: Group normalization

Instalasi

Prasyarat

Sebelum menginstal Liger Kernel, pastikan environment Anda memenuhi persyaratan berikut:

• Python 3.8 atau lebih baru
• PyTorch 2.1.2 atau lebih baru
• CUDA toolkit yang kompatibel dengan versi PyTorch Anda
• GPU NVIDIA dengan compute capability 7.0 atau lebih tinggi (Volta, Turing, Ampere, Hopper, atau Ada Lovelace)

Instalasi via pip

Cara paling mudah untuk menginstal Liger Kernel adalah menggunakan pip:

pip install liger-kernel

Instalasi dari Source

Jika Anda ingin menggunakan versi terbaru langsung dari repository:

git clone https://github.com/linkedin/Liger-Kernel.git
cd Liger-Kernel
pip install -e .

Instalasi dengan Dependencies Tambahan

Untuk development dan testing:

pip install liger-kernel[dev]

Verifikasi Instalasi

Setelah instalasi selesai, verifikasi bahwa Liger Kernel terinstal dengan benar:

import ligerkernel
print(f"Liger Kernel version: {ligerkernel.version}")

Verifikasi Triton tersedia
import triton
print(f"Triton version: {triton.version}")

Test singkat
from ligerkernel.transformers import LigerRMSNorm

import torch

norm = LigerRMSNorm(hiddensize=4096).cuda()
x = torch.randn(2, 128, 4096, device="cuda")
output = norm(x)
print(f"RMSNorm output shape: {output.shape}")
print("Liger Kernel berhasil diinstal dan berfungsi!")

Basic Usage

Integrasi dengan HuggingFace Transformers (Satu Baris Kode)

Cara paling mudah menggunakan Liger Kernel adalah melalui metode monkey-patching otomatis. Dengan pendekatan ini, Anda hanya perlu menambahkan satu baris kode sebelum memuat model, dan Liger Kernel akan secara otomatis mengganti operasi-operasi bawaan model dengan implementasi Triton yang dioptimasi.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
from trl import SFTTrainer
from datasets import loaddataset


Satu baris ini yang mengaktifkan Liger Kernel!
from ligerkernel.transformers import applyligerkerneltollama
applyligerkerneltollama()

Sekarang muat model seperti biasa — kernel sudah di-patch otomatis
modelname = "meta-llama/Llama-3.1-8B"

model = AutoModelForCausalLM.frompretrained(
    modelname,

    torchdtype=torch.bfloat16,
    devicemap="auto",

)
tokenizer = AutoTokenizer.frompretrained(modelname)

tokenizer.padtoken = tokenizer.eostoken


Siapkan dataset
dataset = loaddataset("tatsu-lab/alpaca", split="train[:1000]")

def formatprompt(example):

    if example["input"]:
        return f"### Instruction:\n{example['instruction']}\n\n### Input:\n{example['input']}\n\n### Response:\n{example['output']}"
    return f"### Instruction:\n{example['instruction']}\n\n### Response:\n{example['output']}"

dataset = dataset.map(lambda x: {"text": formatprompt(x)})

Training arguments
trainingargs = TrainingArguments(

    outputdir="./output",
    numtrainepochs=1,
    perdevicetrainbatchsize=4,
    gradientaccumulationsteps=4,
    learningrate=2e-5,

    bf16=True,
    loggingsteps=10,
    savestrategy="epoch",

    reportto="none",
)

Buat trainer dan mulai training
trainer = SFTTrainer(
    model=model,
    args=trainingargs,

    traindataset=dataset,
    tokenizer=tokenizer,
    datasettextfield="text",
    maxseqlength=2048,
)

trainer.train()

Fungsi Monkey-Patch untuk Berbagai Arsitektur

Liger Kernel menyediakan fungsi monkey-patch khusus untuk setiap arsitektur model yang didukung:

# Untuk model LLaMA (LLaMA 2, LLaMA 3, LLaMA 3.1, dsb)
from ligerkernel.transformers import applyligerkerneltollama

applyligerkerneltollama()


Untuk model Mistral
from ligerkernel.transformers import applyligerkerneltomistral
applyligerkerneltomistral()

Untuk model Gemma dan Gemma 2
from ligerkernel.transformers import applyligerkerneltogemma

applyligerkerneltogemma()


from ligerkernel.transformers import applyligerkerneltogemma2
applyligerkerneltogemma2()

Untuk model Qwen 2 dan Qwen 2.5
from ligerkernel.transformers import applyligerkerneltoqwen2

applyligerkerneltoqwen2()


Untuk model Phi-3
from ligerkernel.transformers import applyligerkerneltophi3
applyligerkerneltophi3()

Parameter Kontrol Monkey-Patch

Setiap fungsi monkey-patch menerima parameter opsional untuk mengontrol kernel mana yang diaktifkan:

from ligerkernel.transformers import applyligerkerneltollama

applyligerkerneltollama(

    rope=True,           # Aktifkan Triton RoPE (default: True)
    crossentropy=True,  # Aktifkan Triton CrossEntropy (default: True)
    fusedlinearcrossentropy=True,  # Aktifkan FusedLinearCrossEntropy (default: True)

    rmsnorm=True,       # Aktifkan Triton RMSNorm (default: True)
    swiglu=True,         # Aktifkan Triton SwiGLU (default: True)
)

Contoh: hanya aktifkan RMSNorm dan SwiGLU saja
applyligerkerneltollama(
    rope=False,
    crossentropy=False,

    fusedlinearcrossentropy=False,
    rmsnorm=True,

    swiglu=True,
)

from transformers import TrainingArguments

trainingargs = TrainingArguments(
    outputdir="./output",

    useligerkernel=True,  # Otomatis aktifkan Liger Kernel

    # ... parameter lainnya
)

import torch
from ligerkernel.transformers import LigerRMSNorm

Gantikan nn.RMSNorm atau implementasi custom RMSNorm
rmsnorm = LigerRMSNorm(hiddensize=4096, eps=1e-6).cuda()

Forward pass
hiddenstates = torch.randn(2, 512, 4096, device="cuda", dtype=torch.bfloat16)

output = rmsnorm(hiddenstates)

print(f"Input shape: {hiddenstates.shape}, Output shape: {output.shape}")

LigerSwiGLUMLP

SwiGLU adalah fungsi aktivasi yang menggabungkan Swish dan Gated Linear Unit, digunakan di LLaMA, Mistral, dan model sejenis. Implementasi Liger memfusikan operasi gate dan up projection untuk efisiensi.

import torch
from ligerkernel.transformers import LigerSwiGLUMLP


Buat SwiGLU MLP layer
swiglumlp = LigerSwiGLUMLP(
    hiddensize=4096,

    intermediatesize=11008,
).cuda().to(torch.bfloat16)

Forward pass
hiddenstates = torch.randn(2, 512, 4096, device="cuda", dtype=torch.bfloat16)

output = swiglumlp(hiddenstates)

print(f"SwiGLU MLP output shape: {output.shape}")

import torch
from ligerkernel.transformers.rope import ligerrotaryposemb


Simulasi query dan key tensors
batchsize, numheads, seqlen, headdim = 2, 32, 512, 128

q = torch.randn(batchsize, numheads, seqlen, headdim, device="cuda", dtype=torch.bfloat16)

k = torch.randn(batchsize, numheads, seqlen, headdim, device="cuda", dtype=torch.bfloat16)


Buat cos dan sin embeddings
positionids = torch.arange(seqlen, device="cuda").unsqueeze(0)

cos = torch.randn(1, 1, seqlen, headdim, device="cuda", dtype=torch.bfloat16)

sin = torch.randn(1, 1, seqlen, headdim, device="cuda", dtype=torch.bfloat16)


Terapkan rotary embedding menggunakan Liger
qembed, kembed = ligerrotaryposemb(q, k, cos, sin)
print(f"Q embedded shape: {qembed.shape}")

print(f"K embedded shape: {kembed.shape}")

LigerCrossEntropyLoss

Cross-entropy loss yang dioptimasi oleh Liger menggunakan teknik chunked computation untuk mengurangi memory footprint secara drastis, terutama untuk vocabulary yang besar.

import torch
from ligerkernel.transformers import LigerCrossEntropyLoss


Buat loss function
lossfn = LigerCrossEntropyLoss()

Simulasi logits dan labels
vocabsize = 128256  # LLaMA 3 vocabulary size

batchsize, seqlen = 2, 512


logits = torch.randn(batchsize  seqlen, vocabsize, device="cuda", dtype=torch.bfloat16)

labels = torch.randint(0, vocabsize, (batchsize  seqlen,), device="cuda")


Hitung loss
loss = lossfn(logits, labels)
print(f"Cross-entropy loss: {loss.item():.4f}")

LigerFusedLinearCrossEntropyLoss

Ini adalah kernel paling powerful dari Liger Kernel. Ia memfusikan layer linear terakhir (lmhead) dengan cross-entropy loss, sehingga tidak perlu menyimpan full logits tensor di memori. Untuk model dengan vocabulary besar (misalnya 128K token), ini memberikan penghematan memori yang sangat besar.

import torch
from ligerkernel.transformers import LigerFusedLinearCrossEntropyLoss

Buat fused loss function
fusedlossfn = LigerFusedLinearCrossEntropyLoss()

Simulasi hidden states dan weight matrix
hiddensize = 4096

vocabsize = 128256
batchseqlen = 1024  # batchsize  seqlen


hiddenstates = torch.randn(batchseqlen, hiddensize, device="cuda", dtype=torch.bfloat16)
weight = torch.randn(vocabsize, hiddensize, device="cuda", dtype=torch.bfloat16)
labels = torch.randint(0, vocabsize, (batchseqlen,), device="cuda")


Hitung loss tanpa perlu materialisasi full logits tensor!
loss = fusedlossfn(hiddenstates, weight, labels)
print(f"Fused linear cross-entropy loss: {loss.item():.4f}")

import torch
from torch.utils.data import DataLoader
from transformers import AutoModelForCausalLM, AutoTokenizer
from ligerkernel.transformers import applyligerkerneltollama


Aktifkan Liger Kernel sebelum memuat model
applyligerkerneltollama()


Muat model dan tokenizer
modelname = "meta-llama/Llama-3.1-8B"
model = AutoModelForCausalLM.frompretrained(

    modelname,
    torchdtype=torch.bfloat16,

    devicemap="auto",
)
tokenizer = AutoTokenizer.frompretrained(modelname)
tokenizer.padtoken = tokenizer.eostoken

Setup optimizer
optimizer = torch.optim.AdamW(model.parameters(), lr=2e-5, weightdecay=0.01)


Simulasi training loop
model.train()
numepochs = 3
gradientaccumulationsteps = 4

for epoch in range(numepochs):

    totalloss = 0
    optimizer.zerograd()


    # Dalam praktik nyata, gunakan DataLoader dengan dataset Anda
    for step in range(100):
        # Simulasi input batch
        inputids = torch.randint(0, 32000, (2, 512), device="cuda")
        attentionmask = torch.oneslike(inputids)

        labels = inputids.clone()

        # Forward pass - Liger Kernel otomatis digunakan
        outputs = model(
            inputids=inputids,
            attentionmask=attentionmask,
            labels=labels,
        )
        loss = outputs.loss / gradientaccumulationsteps
        totalloss += loss.item()


        # Backward pass
        loss.backward()

        # Update weights setiap N steps
        if (step + 1) % gradientaccumulationsteps == 0:

            torch.nn.utils.clipgradnorm(model.parameters(), maxnorm=1.0)

            optimizer.step()
            optimizer.zerograd()

            if (step + 1) % 20 == 0:
                avgloss = totalloss / (step + 1)
                print(f"Epoch {epoch+1}, Step {step+1}, Loss: {avgloss:.4f}")


    print(f"Epoch {epoch+1} selesai. Average loss: {totalloss / 100:.4f}")

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
from peft import LoraConfig, getpeftmodel, TaskType
from trl import SFTTrainer
from datasets import loaddataset

from ligerkernel.transformers import applyligerkerneltollama

Aktifkan Liger Kernel
applyligerkerneltollama()

Muat base model
model = AutoModelForCausalLM.frompretrained(

    "meta-llama/Llama-3.1-8B",
    torchdtype=torch.bfloat16,
    devicemap="auto",

)
tokenizer = AutoTokenizer.frompretrained("meta-llama/Llama-3.1-8B")
tokenizer.padtoken = tokenizer.eostoken

Konfigurasi LoRA
loraconfig = LoraConfig(

    tasktype=TaskType.CAUSALLM,

    r=16,
    loraalpha=32,
    loradropout=0.05,

    targetmodules=["qproj", "kproj", "vproj", "oproj",
                     "gateproj", "upproj", "downproj"],

)

Terapkan LoRA
model = getpeftmodel(model, loraconfig)
model.printtrainableparameters()

Training arguments dengan Liger Kernel aktif
trainingargs = TrainingArguments(

    outputdir="./lora-output",
    numtrainepochs=1,
    perdevicetrainbatchsize=8,  # Batch size lebih besar berkat Liger!
    gradientaccumulationsteps=2,
    learningrate=2e-4,

    bf16=True,
    loggingsteps=10,
    savestrategy="epoch",

    reportto="none",
)

Siapkan dataset
dataset = loaddataset("tatsu-lab/alpaca", split="train[:5000]")

dataset = dataset.map(lambda x: {
    "text": f"### Instruction:\n{x['instruction']}\n\n### Response:\n{x['output']}"
})

trainer = SFTTrainer(
    model=model,
    args=trainingargs,
    traindataset=dataset,

    tokenizer=tokenizer,
    datasettextfield="text",

    maxseqlength=2048,

)

trainer.train()

# axolotlconfig.yml
basemodel: meta-llama/Llama-3.1-8B

modeltype: LlamaForCausalLM

Aktifkan Liger Kernel - cukup satu baris ini!
plugins:
ligerkernel


loadin8bit: false

loadin4bit: true


adapter: qlora
lorar: 16
loraalpha: 32

loradropout: 0.05
loratargetmodules:
qproj

kproj
vproj

oproj
gateproj

upproj
downproj


datasetpreparedpath: lastrunprepared

datasets:
path: tatsu-lab/alpaca
    type: alpaca


sequencelen: 4096
microbatchsize: 4
gradientaccumulationsteps: 4
numepochs: 3

learningrate: 2e-4
bf16: true

accelerate launch -m axolotl.cli.train axolotlconfig.yml

llamafactory-cli train \
    --modelnameorpath meta-llama/Llama-3.1-8B \
    --stage sft \
    --dotrain \

    --finetuningtype lora \
    --lorarank 16 \

    --loraalpha 32 \
    --loratarget qproj,kproj,vproj,oproj,gateproj,upproj,downproj \
    --dataset alpacaen \

    --template llama3 \
    --outputdir ./output \
    --perdevicetrainbatchsize 4 \
    --gradientaccumulationsteps 4 \
    --learningrate 2e-4 \

    --numtrainepochs 3 \

    --bf16 \
    --enableligerkernel true

# trainingconfig.yaml
modelnameorpath: meta-llama/Llama-3.1-8B

stage: sft
dotrain: true
finetuningtype: lora

lorarank: 16
loraalpha: 32

dataset: alpacaen
template: llama3
outputdir: ./output

perdevicetrainbatchsize: 4

gradientaccumulationsteps: 4

learningrate: 2.0e-4
numtrainepochs: 3
bf16: true
enableligerkernel: true

from trl import SFTTrainer, SFTConfig

sftconfig = SFTConfig(

    outputdir="./output",
    useligerkernel=True,
    perdevicetrainbatchsize=4,
    numtrainepochs=3,
    learningrate=2e-5,

    bf16=True,
)

import torch
import time
from transformers import AutoModelForCausalLM, AutoTokenizer

def benchmarktraining(modelname, useliger=False, numsteps=50):

    """Benchmark training throughput dan VRAM usage."""
    torch.cuda.resetpeakmemorystats()
    torch.cuda.emptycache()


    if useliger:
        from ligerkernel.transformers import applyligerkerneltollama

        applyligerkerneltollama()


    model = AutoModelForCausalLM.frompretrained(
        modelname,

        torchdtype=torch.bfloat16,
        devicemap="cuda",

    )
    tokenizer = AutoTokenizer.frompretrained(modelname)


    optimizer = torch.optim.AdamW(model.parameters(), lr=2e-5)
    model.train()

    # Warmup
    for  in range(3):
        inputids = torch.randint(0, 32000, (2, 512), device="cuda")

        outputs = model(inputids=inputids, labels=inputids)
        outputs.loss.backward()
        optimizer.step()
        optimizer.zerograd()


    torch.cuda.resetpeakmemorystats()

    # Benchmark
    starttime = time.time()

    totaltokens = 0

    for step in range(numsteps):

        inputids = torch.randint(0, 32000, (2, 512), device="cuda")
        outputs = model(inputids=inputids, labels=inputids)

        outputs.loss.backward()
        optimizer.step()
        optimizer.zerograd()
        totaltokens += 2  512

    elapsed = time.time() - starttime
    peakvram = torch.cuda.maxmemoryallocated() / 10243


    print(f"{'Dengan Liger' if useliger else 'Tanpa Liger'}:")
    print(f"  Peak VRAM: {peakvram:.2f} GB")

    print(f"  Throughput: {totaltokens / elapsed:.0f} tokens/sec")
    print(f"  Total time: {elapsed:.1f} sec")
    print()

    del model, optimizer
    torch.cuda.emptycache()


Jalankan benchmark
modelname = "meta-llama/Llama-3.1-8B"
benchmarktraining(modelname, useliger=False)

benchmarktraining(modelname, useliger=True)

applyligerkerneltollama(
    fusedlinearcrossentropy=True,  # Ini yang paling penting!

    rmsnorm=True,
    swiglu=True,
    rope=True,
)

• Meningkatkan batch size: Batch size lebih besar biasanya menghasilkan training yang lebih stabil dan konvergensi lebih cepat.
• Menambah sequence length: Konteks lebih panjang membantu model belajar dependensi jarak jauh.
• Menghindari gradient checkpointing: Jika VRAM cukup, matikan gradient checkpointing untuk throughput maksimal.

# Contoh: manfaatkan VRAM hemat untuk batch size lebih besar
trainingargs = TrainingArguments(

    perdevicetrainbatchsize=8,    # Naik dari 4

    gradientcheckpointing=False,      # Matikan jika VRAM cukup
    maxseqlength=4096,               # Sequence length lebih panjang
)

from transformers import TrainingArguments, BitsAndBytesConfig

Kombinasi: Liger Kernel + QLoRA + Flash Attention
bnbconfig = BitsAndBytesConfig(

    loadin4bit=True,

    bnb4bitquanttype="nf4",
    bnb4bitcomputedtype=torch.bfloat16,

    bnb4bitusedoublequant=True,

)

model = AutoModelForCausalLM.frompretrained(
    modelname,

    quantizationconfig=bnbconfig,

    attnimplementation="flashattention2",  # Flash Attention
    devicemap="auto",

)

trainingargs = TrainingArguments(
    useligerkernel=True,            # Liger Kernel
    perdevicetrainbatchsize=16,   # Batch size besar!
    bf16=True,
    gradientcheckpointing=True,      # Untuk model sangat besar

    gradientcheckpointingkwargs={"usereentrant": False},
)

import torch
from transformers import AutoModelForCausalLM

Muat model TANPA Liger
modelvanilla = AutoModelForCausalLM.frompretrained(
    modelname, torchdtype=torch.float32, devicemap="cuda"

)

Muat model DENGAN Liger
from ligerkernel.transformers import applyligerkerneltollama
applyligerkerneltollama()
modelliger = AutoModelForCausalLM.frompretrained(
    modelname, torchdtype=torch.float32, devicemap="cuda"

)

Bandingkan output
inputids = torch.randint(0, 32000, (1, 128), device="cuda")
with torch.nograd():

    outvanilla = modelvanilla(inputids).logits
    outliger = modelliger(inputids).logits


diff = (outvanilla - outliger).abs().max()

print(f"Max absolute difference: {diff.item()}")
Seharusnya sangat kecil (< 1e-5 untuk float32)

import torch

def printgpumemory():

    """Cetak penggunaan GPU memory saat ini."""
    allocated = torch.cuda.memoryallocated() / 10243
    reserved = torch.cuda.memoryreserved() / 10243

    peak = torch.cuda.maxmemoryallocated() / 10243

    print(f"GPU Memory - Allocated: {allocated:.2f} GB, "
          f"Reserved: {reserved:.2f} GB, Peak: {peak:.2f} GB")

Panggil di berbagai titik dalam training loop
printgpumemory()

# Cek versi yang terinstal
pip show liger-kernel torch transformers triton

Update jika perlu
pip install --upgrade liger-kernel

# Jika menggunakan torch.compile, uji kompatibilitas
model = torch.compile(model)
Jika error, coba nonaktifkan kernel tertentu
applyligerkerneltollama(

    fusedlinearcrossentropy=False,  # Kadang bermasalah dengan compile
)

Troubleshooting Umum

Error: Triton Not Found

# Instal Triton secara eksplisit
pip install triton>=2.1.0

Error: CUDA Version Mismatch

Pastikan CUDA toolkit Anda kompatibel:

# Cek versi CUDA
nvcc --version
python -c "import torch; print(torch.version.cuda)"

Kernel Crash atau NaN Loss

Jika Anda mengalami NaN loss setelah mengaktifkan Liger Kernel:

# Debug: aktifkan kernel satu per satu
applyligerkerneltollama(
    rope=False,
    crossentropy=False,

    fusedlinearcrossentropy=False,
    rmsnorm=True,   # Coba satu dulu

    swiglu=False,
)

Dengan mengadopsi Liger Kernel dalam workflow training Anda, Anda bisa fokus pada aspek yang lebih penting — yaitu data, arsitektur model, dan hyperparameter tuning — tanpa perlu khawatir tentang keterbatasan hardware. Selamat mencoba dan semoga tutorial ini bermanfaat untuk proyek AI Anda!

Untuk pertanyaan lebih lanjut seputar optimasi training LLM, jangan ragu untuk menghubungi kami di ruby@rubythalib.ai.