Tutorial bitsandbytes: Kuantisasi 4-bit dan 8-bit untuk Large Language Models

Menjalankan Large Language Model (LLM) seperti Llama, Mistral, atau Falcon membutuhkan GPU dengan VRAM besar. Model dengan 7 miliar parameter saja bisa memakan 14 GB VRAM dalam presisi float16. Bagaimana jika Anda hanya punya GPU consumer-grade dengan 8 GB VRAM? Di sinilah bitsandbytes berperan.

bitsandbytes adalah library Python yang memungkinkan Anda menjalankan model deep learning dalam presisi 4-bit atau 8-bit, secara drastis mengurangi kebutuhan memori tanpa mengorbankan kualitas output secara signifikan. Library ini menjadi fondasi dari teknik QLoRA (Quantized Low-Rank Adaptation), yang memungkinkan fine-tuning model miliaran parameter di GPU consumer.

Dalam tutorial ini, Anda akan belajar cara menggunakan bitsandbytes untuk:

• Memuat model LLM dalam presisi 8-bit dan 4-bit
• Mengonfigurasi parameter kuantisasi untuk hasil optimal
• Melakukan fine-tuning dengan QLoRA
• Mengoptimasi penggunaan memori GPU

Instalasi

Prasyarat

bitsandbytes membutuhkan GPU NVIDIA dengan dukungan CUDA. Pastikan Anda sudah memiliki:

• Python 3.8 atau lebih baru
• PyTorch 2.0 atau lebih baru
• CUDA Toolkit 11.8 atau 12.x
• GPU NVIDIA (compute capability 7.0+, yaitu Volta atau lebih baru)

Instalasi Library

pip install bitsandbytes
pip install transformers accelerate
pip install peft datasets  # untuk QLoRA fine-tuning

Untuk memverifikasi instalasi berhasil:

import bitsandbytes as bnb
import torch

print(f"bitsandbytes version: {bnb.version}")
print(f"PyTorch version: {torch.version}")
print(f"CUDA available: {torch.cuda.isavailable()}")

print(f"GPU: {torch.cuda.getdevicename(0)}")

from transformers import AutoModelForCausalLM, AutoTokenizer

modelname = "mistralai/Mistral-7B-Instruct-v0.3"

tokenizer = AutoTokenizer.frompretrained(modelname)

model = AutoModelForCausalLM.frompretrained(

    modelname,
    loadin8bit=True,
    devicemap="auto"

)

prompt = "Jelaskan apa itu machine learning dalam 3 kalimat:"
inputs = tokenizer(prompt, returntensors="pt").to(model.device)

outputs = model.generate(
    inputs,

    maxnewtokens=150,
    temperature=0.7,
    dosample=True

)

response = tokenizer.decode(outputs[0], skipspecialtokens=True)

print(response)

import torch

def printgpumemory():
    if torch.cuda.isavailable():

        allocated = torch.cuda.memoryallocated() / 10243
        reserved = torch.cuda.memoryreserved() / 10243

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

printgpumemory()

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
import torch

quantizationconfig = BitsAndBytesConfig(
    loadin4bit=True,
    bnb4bitquanttype="nf4",

    bnb4bitcomputedtype=torch.bfloat16,
    bnb4bitusedoublequant=True
)

modelname = "mistralai/Mistral-7B-Instruct-v0.3"


tokenizer = AutoTokenizer.frompretrained(modelname)


model = AutoModelForCausalLM.frompretrained(
    modelname,

    quantizationconfig=quantizationconfig,

    devicemap="auto"
)

printgpumemory()

# Perbandingan NF4 vs FP4
confignf4 = BitsAndBytesConfig(
    loadin4bit=True,
    bnb4bitquanttype="nf4",

    bnb4bitcomputedtype=torch.bfloat16
)

configfp4 = BitsAndBytesConfig(

    loadin4bit=True,

    bnb4bitquanttype="fp4",
    bnb4bitcomputedtype=torch.bfloat16

)

# Dengan double quant: ~3.5 GB untuk model 7B
configdouble = BitsAndBytesConfig(

    loadin4bit=True,

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

    bnb4bitusedoublequant=True

)

Tanpa double quant: ~3.9 GB untuk model 7B
configsingle = BitsAndBytesConfig(
    loadin4bit=True,
    bnb4bitquanttype="nf4",

    bnb4bitcomputedtype=torch.bfloat16,
    bnb4bitusedoublequant=False
)

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
import torch

quantizationconfig = BitsAndBytesConfig(

    loadin4bit=True,

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

    bnb4bitusedoublequant=True

)

modelname = "mistralai/Mistral-7B-Instruct-v0.3"
tokenizer = AutoTokenizer.frompretrained(modelname)
model = AutoModelForCausalLM.frompretrained(

    modelname,
    quantizationconfig=quantizationconfig,
    devicemap="auto"

)

def generateresponse(prompt, maxtokens=256):

    messages = [
        {"role": "user", "content": prompt}
    ]

    inputids = tokenizer.applychattemplate(
        messages,
        returntensors="pt",

        addgenerationprompt=True

    ).to(model.device)

    outputs = model.generate(
        inputids,
        maxnewtokens=maxtokens,

        temperature=0.7,
        topp=0.9,
        dosample=True,

        repetitionpenalty=1.1
    )

    response = tokenizer.decode(
        outputs[0][inputids.shape[1]:],

        skipspecialtokens=True

    )
    return response

print(generateresponse("Apa keuntungan menggunakan Python untuk data science?"))
print(generateresponse("Tulis fungsi Python untuk menghitung fibonacci:"))

def batchgenerate(prompts, maxtokens=256):
    tokenizer.padtoken = tokenizer.eostoken


    inputs = tokenizer(
        prompts,
        returntensors="pt",
        padding=True,
        truncation=True,
        maxlength=512

    ).to(model.device)

    outputs = model.generate(
        inputs,
        maxnewtokens=maxtokens,
        temperature=0.7,
        dosample=True

    )

    responses = tokenizer.batchdecode(outputs, skipspecialtokens=True)
    return responses

prompts = [
    "Jelaskan konsep OOP dalam satu paragraf:",
    "Apa itu REST API?",
    "Sebutkan 3 database populer:"
]

results = batchgenerate(prompts)

for prompt, result in zip(prompts, results):
    print(f"Q: {prompt}")
    print(f"A: {result}\n")

from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig,
    TrainingArguments
)
from peft import LoraConfig, getpeftmodel, preparemodelforkbittraining

from datasets import loaddataset
from trl import SFTTrainer
import torch

1. Konfigurasi kuantisasi
bnbconfig = BitsAndBytesConfig(

    loadin4bit=True,

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

    bnb4bitusedoublequant=True

)

2. Muat model dan tokenizer
modelname = "mistralai/Mistral-7B-Instruct-v0.3"
tokenizer = AutoTokenizer.frompretrained(modelname)
tokenizer.padtoken = tokenizer.eostoken

model = AutoModelForCausalLM.frompretrained(

    modelname,
    quantizationconfig=bnbconfig,
    devicemap="auto",

    torchdtype=torch.bfloat16
)

3. Persiapkan model untuk k-bit training
model = preparemodelforkbittraining(model)

4. Konfigurasi LoRA
loraconfig = LoraConfig(

    r=16,
    loraalpha=32,
    targetmodules=[

        "qproj", "kproj", "vproj", "oproj",

        "gateproj", "upproj", "downproj"
    ],
    loradropout=0.05,

    bias="none",
    tasktype="CAUSALLM"

)

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

6. Muat dataset
dataset = loaddataset("timdettmers/openassistant-guanaco", split="train[:5000]")


7. Format data
def formatinstruction(sample):
    return f"""### Human: {sample['text'].split('### Human:')[1].split('### Assistant:')[0].strip()}

Assistant: {sample['text'].split('### Assistant:')[1].strip()}"""

8. Konfigurasi training
trainingargs = TrainingArguments(

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

    weightdecay=0.001,
    warmupratio=0.03,

    lrschedulertype="cosine",

    loggingsteps=10,
    savestrategy="steps",

    savesteps=100,
    fp16=False,
    bf16=True,
    optim="pagedadamw32bit",
    gradientcheckpointing=True,

    maxgradnorm=0.3,

    reportto="none"
)

9. Inisialisasi trainer
trainer = SFTTrainer(
    model=model,
    traindataset=dataset,

    tokenizer=tokenizer,
    args=trainingargs,
    maxseqlength=512,
)

10. Mulai training
trainer.train()

11. Simpan adapter
trainer.savemodel("./qlora-adapter")

# r=8: ~0.1% trainable params, cepat, untuk task sederhana
r=16: ~0.2% trainable params, keseimbangan baik
r=64: ~0.8% trainable params, untuk task kompleks

import bitsandbytes as bnb

optimizer = bnb.optim.PagedAdamW32bit(
    model.parameters(),
    lr=2e-4,
    weightdecay=0.001
)

Atau gunakan 8-bit Adam untuk penghematan memori lebih lanjut
optimizer8bit = bnb.optim.Adam8bit(

    model.parameters(),
    lr=2e-4,
    weightdecay=0.001
)

Paged optimizer bekerja dengan memanfaatkan unified memory CUDA untuk melakukan page fault handling secara otomatis, mirip dengan virtual memory di sistem operasi.

Menyimpan dan Memuat Model Terkuantisasi

Menyimpan Adapter QLoRA

# Simpan hanya adapter (berukuran kecil, ~50-200 MB)
model.savepretrained("./my-qlora-adapter")

tokenizer.savepretrained("./my-qlora-adapter")

Memuat Kembali Adapter

from peft import PeftModel

Muat model base dalam 4-bit
basemodel = AutoModelForCausalLM.frompretrained(
    "mistralai/Mistral-7B-Instruct-v0.3",
    quantizationconfig=bnbconfig,
    devicemap="auto"

)

Terapkan adapter
model = PeftModel.frompretrained(basemodel, "./my-qlora-adapter")

from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer

Muat model base dalam full precision untuk merge
basemodel = AutoModelForCausalLM.frompretrained(

    "mistralai/Mistral-7B-Instruct-v0.3",
    torchdtype=torch.float16,
    devicemap="auto"

)

model = PeftModel.frompretrained(basemodel, "./my-qlora-adapter")

mergedmodel = model.mergeandunload()

mergedmodel.savepretrained("./merged-model")
tokenizer.savepretrained("./merged-model")

import bitsandbytes as bnb

Pengganti drop-in untuk torch.optim.Adam
optimizer = bnb.optim.Adam8bit(
    model.parameters(),
    lr=1e-4,
    betas=(0.9, 0.999)
)

Tersedia juga:
bnb.optim.AdamW8bit - AdamW dengan weight decay
bnb.optim.SGD8bit - SGD 8-bit
bnb.optim.Adagrad8bit - Adagrad 8-bit
bnb.optim.LAMB8bit - LAMB 8-bit (untuk batch besar)

import bitsandbytes as bnb
import torch.nn as nn

class EfficientModel(nn.Module):
    def init(self, inputdim, hiddendim, outputdim):
        super().init()
        self.layer1 = bnb.nn.Linear8bitLt(inputdim, hiddendim, hasfp16weights=False)
        self.activation = nn.GELU()
        self.layer2 = bnb.nn.Linear8bitLt(hiddendim, outputdim, hasfp16weights=False)

    def forward(self, x):
        x = self.layer1(x)
        x = self.activation(x)
        x = self.layer2(x)
        return x

Best Practices

1. Pilih Metode Kuantisasi yang Tepat

| Skenario | Rekomendasi |

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

| Inference saja, GPU memadai | 8-bit (LLM.int8()) |

| Inference saja, GPU terbatas | 4-bit NF4 + double quant |

| Fine-tuning | 4-bit NF4 + QLoRA |

| Produksi, perlu kecepatan | GPTQ atau AWQ |

| Riset, perlu fleksibilitas | bitsandbytes 4-bit |

2. Gunakan bfloat16 sebagai Compute Dtype

# Direkomendasikan untuk GPU Ampere+
config = BitsAndBytesConfig(
    loadin4bit=True,
    bnb4bitcomputedtype=torch.bfloat16  # bukan float16

)

model.gradientcheckpointingenable()

Atau melalui TrainingArguments
trainingargs = TrainingArguments(
    gradientcheckpointing=True,

    # ...
)

def printmemorystats():
    print(f"Allocated: {torch.cuda.memoryallocated() / 10243:.2f} GB")

    print(f"Reserved: {torch.cuda.memoryreserved() / 10243:.2f} GB")

    print(f"Max Allocated: {torch.cuda.maxmemoryallocated() / 10243:.2f} GB")


Panggil sebelum dan sesudah operasi berat
printmemorystats()

# Kurangi batch size
trainingargs = TrainingArguments(perdevicetrainbatchsize=1)

Aktifkan gradient accumulation
trainingargs = TrainingArguments(

    perdevicetrainbatchsize=1,

    gradientaccumulation_steps=16
)

Instalasi gagal di Linux:

# Pastikan CUDA toolkit terinstal
nvcc --version

Install versi spesifik
pip install bitsandbytes==0.43.0

Model menghasilkan output buruk setelah kuantisasi:

• Untuk inference: Gunakan 4-bit NF4 dengan double quantization untuk penghematan memori maksimal
• Untuk fine-tuning: Kombinasikan dengan PEFT/LoRA untuk QLoRA, memungkinkan training di GPU consumer
• Optimizer 8-bit: Gunakan Adam8bit atau PagedAdamW32bit untuk mengurangi memori optimizer state
• Pilih compute dtype yang tepat**: bfloat16 untuk GPU Ampere+, float16 untuk GPU lama

Dengan bitsandbytes, barrier untuk bekerja dengan LLM semakin rendah. Anda bisa menjalankan model 7B parameter di GPU dengan 6 GB VRAM, atau melakukan fine-tuning model 13B di GPU dengan 16 GB VRAM. Ini membuka peluang besar untuk eksperimen, penelitian, dan deployment model AI yang lebih mudah diakses.