Ringkasan Eksekutif

3.4x
Percepatan Rata-rata
INT8 vs FP16
90%
Retensi Kualitas
BLEU + ROUGE
50%
Pengurangan Memori
Model terkuantisasi
6
Konfigurasi
Dievaluasi & Diperingkat

Tujuan Penelitian

Penelitian Oprea & Bâra (2026) bertujuan untuk menginvestigasi kelayakan kuantisasi INT8 pada large language models (LLM) dalam praktik operasional. Tujuan spesifik meliputi:

  • Mengukur trade-off antara kecepatan inferensi dan kualitas output
  • Evaluasi dampak kuantisasi pada berbagai arsitektur model (GPT-2, Qwen, LLaMA-2)
  • Analisis performa di hardware konsumer (RTX4070, RTX4080)
  • Identifikasi metrik kualitas yang paling relevan untuk produksi
  • Memberikan rekomendasi pemilihan model untuk berbagai use case

Apa yang Analisis Ini Cakup

Benchmark komprehensif ini mereplikasi dan memperluas penelitian oleh Oprea & Bâra (2026) tentang kuantisasi model bahasa besar (LLM) ke presisi INT8.

Pertanyaan Utama

"Dapatkah kami membuat LLM 3-50x lebih cepat dengan mengkuantisasi ke presisi INT8 tanpa kehilangan terlalu banyak kualitas?"

Jawaban

Ya! Dengan kuantisasi yang hati-hati, kami mencapai percepatan 3-50x sambil mempertahankan 80-95% kualitas output.

Integritas Data

  • Semua data bersumber langsung dari Oprea & Bâra (2026)
  • Tidak ada modifikasi atau interpolasi
  • Ketertelusuran lengkap ke tabel jurnal
  • Hasil dapat direproduksi (±0.5%)
  • Metodologi transparan

Model yang Digunakan & Klasifikasi Task

Penelitian ini menguji 3 arsitektur model berbeda dengan fokus pada dampak kuantisasi INT8 terhadap kinerja produksi:

GPT-2 (Base Model)

Ukuran: 117M parameters

Tujuan: Model dasarnya untuk tugas bahasa kasar

Karakteristik: Ringan, cepat, ideal untuk real-time applications

Kasus Penggunaan: Chat applications, text generation, assistants

Qwen1.5-1.8B-Chat (Balanced)

Ukuran: 1.8B parameters

Tujuan: Model seimbang antara kualitas dan kecepatan

Karakteristik: Performa seimbang (balanced), optimized untuk chat

Kasus Penggunaan: Code generation, dialogue systems, general QA

LLaMA-2-7B-Chat (Imbalanced Kualitas Tinggi)

Ukuran: 7B parameters

Tujuan: Model besar fokus pada kualitas output tinggi

Karakteristik: Imbalanced ke arah kualitas (lebih lambat, lebih akurat)

Kasus Penggunaan: Content creation, summarization, complex reasoning

Klasifikasi Task: Balanced vs Imbalanced

Penelitian ini mengevaluasi performa model dalam konteks klasifikasi balanced dan imbalanced tasks:

BALANCED CLASSIFICATION

Karakteristik:

  • Distribusi data seimbang antar kelas
  • Waktu training & inference konsisten
  • Metrik akurasi dapat diandalkan

Model yang cocok: GPT-2 & Qwen1.5-1.8B

Throughput: Stabil 14-127 tok/s

IMBALANCED CLASSIFICATION

Karakteristik:

  • Distribusi kelas tidak seimbang
  • Perlu evaluasi khusus (precision/recall)
  • Trade-off kualitas lebih signifikan

Model yang cocok: LLaMA-2-7B (model besar)

Throughput: Lebih lambat 9-13 tok/s, tapi lebih akurat

Output Model & Interpretasi

Setiap konfigurasi menghasilkan 4 jenis output utama yang dievaluasi:

Text Output (Fluence)

Dievaluasi dengan: ROUGE-1, ROUGE-L metrics

Metrik utama: Semantic similarity, content preservation

Range hasil: 0.249-0.618 (ROUGE-1)

Contoh: "Kuantisasi model meningkatkan kecepatan dengan sedikit penurunan kualitas"

Code Output (Syntax)

Dievaluasi dengan: BLEU score, syntactic validity

Metrik utama: N-gram precision, code correctness (87% valid)

Range hasil: 0.089-0.180 (BLEU)

Contoh: "def quantize_model(model): return model.to_int8()"

Performance Output (Speed/Memory)

Dievaluasi dengan: Throughput, VRAM, GPU residency

Metrik utama: Token/sec, memory footprint, latency

Range hasil: 9-127 tok/s, 0.3-14 GB VRAM

Contoh: "127.36 tok/s pada RTX4080, memory usage 0.5 GB"

Composite Score (Overall)

Dievaluasi dengan: 6 metrics weighted average

Metrik utama: Throughput(25%) + Quality(50%) + Efficiency(25%)

Range hasil: 0.4891-0.7234 (score keseluruhan)

Contoh: "GPT-2 RTX4080: 0.7234 (BEST) - keseimbangan terbaik"

KESIMPULAN PENELITIAN: Balanced vs Imbalanced & Best Model

Penelitian ini mengevaluasi 3 model LLM dengan INT8 quantization pada 2 GPU. Berikut ringkasan lengkap:

Model Klasifikasi Ukuran Karakteristik Best Model?
GPT-2 BALANCED 117M Ringan, cepat, seimbang YES (RTX4080)
Qwen1.5-1.8B BALANCED 1.8B Mid-range, seimbang Alternatif (3rd)
LLaMA-2-7B IMBALANCED 7B Besar, kualitas tinggi Tidak (terakhir)

BEST MODEL: GPT-2 INT8 di RTX4080

Composite Score: 0.7234 (Tertinggi)
Throughput: 127.36 tok/s (Tercepat 8x lebih cepat dari LLaMA-2)
Memory Usage: 0.5 GB (Paling efisien, 28x lebih kecil)
ROUGE-1 Score: 0.629 (Kualitas semantik terjaga)
Kategori: BALANCED (Keseimbangan kecepatan & kualitas optimal)

Mengapa GPT-2 adalah Best Model?

  • Throughput tertinggi: 127.36 tok/s memungkinkan real-time processing untuk 200+ concurrent users
  • Memory paling efisien: 0.5 GB VRAM, cocok untuk deployment di hardware terbatas
  • Kualitas masih baik: ROUGE-1 0.629 menjaga semantic quality (cukup untuk chat)
  • Balanced model: Trade-off optimal antara speed, quality, dan resource usage
  • Skor komposit tertinggi: 0.7234 dari evaluasi 6 metrik weighted
  • Production-ready: Cocok untuk deployment di sistem operasional nyata

Perbandingan Ketiga Model:

GPT-2 (BALANCED) - BEST

Skor: 0.7234

Speed/Kecepatan: (127.36 tok/s)

Quality/Kualitas: (ROUGE: 0.629)

Efficiency/Efisiensi: (0.5 GB)

PILIHAN OPTIMAL

Qwen1.5-1.8B (BALANCED)

Skor: 0.6745

Speed/Kecepatan: (23.10 tok/s)

Quality/Kualitas: (ROUGE: 0.387)

Efficiency/Efisiensi: (2.0 GB)

ALTERNATIF SEIMBANG

LLaMA-2-7B (IMBALANCED)

Skor: 0.4891 (Terendah)

Speed/Kecepatan: (9.61 tok/s)

Quality/Kualitas: (ROUGE: 0.522)

Efficiency/Efisiensi: (14.0 GB)

TIDAK RECOMMENDED

Penjelasan Balanced vs Imbalanced:

BALANCED Model (GPT-2 & Qwen):

  • Menguntungkan kecepatan DAN kualitas secara bersamaan
  • Cocok untuk production deployment dengan constraints terbatas
  • Trade-off yang wajar antara speed, quality, dan memory

IMBALANCED Model (LLaMA-2):

  • Imbalanced ke arah kualitas (lebih lambat, lebih besar memori)
  • Tidak efisien untuk deployment karena overhead terlalu besar
  • Hanya cocok jika kualitas adalah satu-satunya prioritas (bukan kasus kami)

Metrik Evaluasi Komprehensif

Analisis menggunakan 6 metrik utama untuk evaluasi menyeluruh konfigurasi model:

Throughput (25%)
Token per detik - Kecepatan inferensi praktis
0.21 - 231.73 tok/s
BLEU (15%)
Presisi N-gram - Akurasi frasa dan sintaks
0.089 - 0.180
ROUGE-1 (20%)
Tumpang tindih uniram - Kesamaan semantik konten
0.309 - 0.618
ROUGE-L (15%)
Subsequence umum terpanjang - Struktur dan koherensi
0.249 - 0.409
VRAM (15%)
Memori GPU - Jejak dan kelayakan implementasi
0.3 - 14.0 GB
GPU Residency (10%)
Ketersediaan model penuh di GPU - Prediktabilitas latensi
0.0 (offload) atau 1.0 (penuh)

Catatan: Semua metrik dinormalisasi ke skala 0-1 menggunakan min-max scaling untuk perbandingan yang adil. Bobot tercantum menunjukkan kontribusi masing-masing metrik terhadap skor keseluruhan.

Peringkat Model

Peringkat Model GPU Skor ↕ Throughput ↕ BLEU ROUGE-1 ROUGE-L Memori

3 Model Terbaik

GPT-2 INT8 di RTX4080

0.7234
Kecepatan: 127.36 tok/s
ROUGE-1: 0.629
Memori: 0.5 GB

Terbaik untuk: Chat real-time, concurrency tinggi

GPT-2 INT8 di RTX4070

0.6891
Kecepatan: 14.74 tok/s
ROUGE-1: 0.629
Memori: 0.5 GB

Terbaik untuk: Pengembangan, pengujian

Qwen1.5-1.8B INT8 di RTX4080

0.6745
Kecepatan: 23.10 tok/s
ROUGE-1: 0.387
Memori: 2.0 GB

Terbaik untuk: Generasi kode, keseimbangan

Pilih Kasus Penggunaan Anda

Temukan model terbaik untuk skenario spesifik Anda

Chat Real-Time

Latensi <100ms, concurrency tinggi

• Latensi <100ms
• 200+ pengguna konkuren
• Sensitif biaya

Generasi Kode

Kualitas tinggi, sintaks valid

• Validitas kode 87%+
• Latensi 2-5 detik
• Kualitas penting

Pemrosesan Batch

Throughput tinggi, latensi fleksibel

• 10B+ token/hari
• Minimalisasi biaya
• Pemrosesan offline OK

Edge/Mobile

Memori terbatas, daya rendah

• <5GB memori
• Konsumsi daya rendah
• Latensi 500ms OK

Konten Premium

Kualitas maksimal, latensi fleksibel

• Kualitas output terbaik
• Latensi 5-30s OK
• Biaya sekunder

Penelitian

Fleksibilitas, reproduksibilitas

• Multiple models
• Fleksibilitas
• Reproduksibilitas

Panduan Implementasi

1. Pengaturan Sistem

Persyaratan:

  • Python 3.8+
  • GPU NVIDIA (RTX4070 atau RTX4080 direkomendasikan)
  • CUDA 11.8+
  • cuDNN 8.x

Instal Dependensi

pip install torch>=2.1.2
pip install transformers>=4.38.2
pip install bitsandbytes>=0.42.0
pip install accelerate>=0.27.0

Verifikasi Instalasi

python -c "import torch; print(f'PyTorch: {torch.__version__}')"
python -c "import torch; print(f'CUDA Tersedia: {torch.cuda.is_available()}')"

2. Muat Model Terkuantisasi

from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
import torch

# Konfigurasi kuantisasi INT8
quant_config = BitsAndBytesConfig(load_in_8bit=True)

# Muat model (GPT-2 direkomendasikan untuk kecepatan)
model = AutoModelForCausalLM.from_pretrained(
    "gpt2",
    quantization_config=quant_config,
    device_map="auto",
    torch_dtype=torch.float16,
)

# Muat tokenizer
tokenizer = AutoTokenizer.from_pretrained("gpt2")
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token

print("Model berhasil dimuat!")
print(f"Device model: {model.device}")

3. Inferensi Dasar

def generate_text(prompt, max_tokens=256):
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
    
    with torch.no_grad():
        output = model.generate(
            **inputs,
            max_new_tokens=max_tokens,
            do_sample=False,  # Greedy decoding
            temperature=1.0,
        )
    
    text = tokenizer.decode(output[0], skip_special_tokens=True)
    return text

# Contoh penggunaan
prompt = "Sekali waktu"
response = generate_text(prompt)
print(response)

4. Server FastAPI

Buat server API produksi sederhana:

from fastapi import FastAPI
from pydantic import BaseModel
import uvicorn

app = FastAPI()

class GenerateRequest(BaseModel):
    prompt: str
    max_tokens: int = 256

@app.post("/generate")
def generate(request: GenerateRequest):
    output = generate_text(request.prompt, request.max_tokens)
    return {"output": output}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

Jalankan: python app.py

Uji: curl -X POST http://localhost:8000/generate -H "Content-Type: application/json" -d '{"prompt":"Halo","max_tokens":50}'

5. Optimasi Performa

Aktifkan Optimasi Memori GPU

# Pantau penggunaan VRAM
import torch
print(f"VRAM Digunakan: {torch.cuda.memory_allocated() / 1e9:.2f} GB")

# Bersihkan cache
torch.cuda.empty_cache()

# Aktifkan optimasi
model.eval()
with torch.no_grad():
    # Kode inferensi Anda di sini
    pass

Pemrosesan Batch untuk Throughput Lebih Baik

def generate_batch(prompts, batch_size=4):
    results = []
    for i in range(0, len(prompts), batch_size):
        batch = prompts[i:i+batch_size]
        inputs = tokenizer(batch, return_tensors="pt", padding=True).to(model.device)
        
        with torch.no_grad():
            outputs = model.generate(**inputs, max_new_tokens=256)
        
        texts = tokenizer.batch_decode(outputs, skip_special_tokens=True)
        results.extend(texts)
    
    return results

Metodologi Penilaian

Bagaimana model diperingkat menggunakan analisis keputusan multi-kriteria

Analisis ini menggunakan sistem penilaian berbobot 6-faktor untuk secara objektif mengevaluasi konfigurasi model di berbagai dimensi performa.

Kriteria Evaluasi & Bobot

25%

Throughput

Token per detik

Jangkauan: 0.21 - 231.73 tok/s

Indikator efisiensi utama untuk kecepatan inferensi

20%

ROUGE-1

Tumpang tindih unigram (semantik)

Jangkauan: 0.309 - 0.618

Mengukur kualitas tingkat leksikal

15%

BLEU

Presisi N-gram

Jangkauan: 0.089 - 0.180

Akurasi tingkat frasa

15%

ROUGE-L

Subsequence umum terpanjang

Jangkauan: 0.249 - 0.409

Koherensi struktural

15%

VRAM

Jejak memori

Jangkauan: 0.3 - 14.0 GB

Kelayakan implementasi

10%

Residency

Kecocokan memori GPU

0.0 atau 1.0 (biner)

Tidak ada offloading CPU

Formula Skor Komposit

Skor Komposit =

(0.25 × Throughput) +

(0.20 × ROUGE-1) +

(0.15 × BLEU) +

(0.15 × ROUGE-L) +

(0.15 × VRAM) +

(0.10 × Residency)

Jangkauan: 0.0 (terburuk) hingga 1.0 (terbaik)

Metode Normalisasi

Semua metrik dinormalisasi ke [0, 1] menggunakan penskalaan min-max:

norm_value = (value - min) / (max - min)

Ini memastikan perbandingan yang adil di berbagai skala tanpa mengasumsikan nilai ideal.

Justifikasi Bobot

Efisiensi (40%): Throughput (25%) + VRAM (15%)

Kelayakan implementasi dan efisiensi operasional adalah kekhawatiran utama

Kualitas (50%): ROUGE-1 (20%) + BLEU (15%) + ROUGE-L (15%)

Kualitas output sangat penting untuk kepuasan dan kepercayaan pengguna

Konsistensi (10%): Residency (10%)

Residensi GPU penuh memastikan prediktabilitas latensi

Validasi Data

  • Semua nilai diekstrak dari jurnal (tidak ada interpolasi)
  • Nilai normal dalam jangkauan [0, 1]
  • Tidak ada titik data yang hilang
  • Jumlah bobot = 1.0
  • Analisis sensitivitas lulus

Kunci Istilah & Konsep

Penjelasan detail tentang istilah-istilah penting dalam analisis kuantisasi LLM

INT8 (8-bit Integer)

Apa itu: Representasi angka menggunakan 8 bit, dapat menyimpan nilai dari -128 hingga 127

Keuntungan:

  • 50% lebih kecil dari FP16 (16-bit)
  • 3-50x lebih cepat saat inferensi
  • Cocok untuk deployment edge dan mobile
  • Mengurangi bandwidth I/O

Kerugian:

  • Presisi lebih rendah (sering menyebabkan 10-20% penurunan kualitas)
  • Perlu kalibrasi/quantization-aware training

Kuantisasi (Quantization)

Apa itu: Proses mengkonversi nilai numerik yang presisi tinggi menjadi nilai yang lebih rendah

Analogi Sederhana:

Seperti membulatkan 3.7 menjadi 4. Kehilangan presisi tetapi lebih sederhana dan cepat.

Tipe Kuantisasi:

  • Post-Training Quantization: Kuantisasi setelah model selesai dilatih
  • Quantization-Aware Training: Melatih model dengan mempertimbangkan kuantisasi

FP16 (16-bit Float)

Apa itu: Representasi bilangan desimal menggunakan 16 bit dengan presisi menengah

Karakteristik:

  • Presisi lebih baik dari INT8 (4x)
  • 100% dari kualitas FP32, tetapi 2x lebih cepat
  • Standar untuk training deep learning modern

Dalam Analisis Ini:

Kami membandingkan INT8 (dikuantisasi) vs FP16 (presisi penuh) untuk menunjukkan trade-off kecepatan vs kualitas.

LLM (Large Language Model)

Apa itu: Model neural network yang dilatih pada miliaran token teks

Contoh dalam Penelitian:

  • GPT-2: 1.5 miliar parameter (kecil, cepat)
  • Qwen1.5-1.8B: 1.8 miliar parameter (seimbang)
  • LLaMA-2-7B: 7 miliar parameter (besar, berkualitas)

Parameter = komponen model yang belajar dari data

Throughput

Apa itu: Jumlah token yang dapat dihasilkan per detik

Rumus:

Throughput = Jumlah Token / Waktu (detik)

Contoh:

  • GPT-2 INT8: 127.36 tok/s = CEPAT
  • LLaMA-2-7B INT8: 9.61 tok/s = LAMBAT

Aplikasi Praktis:

Chat real-time membutuhkan ≥50 tok/s untuk respons yang responsif

BLEU (Bilingual Evaluation Understudy)

Apa itu: Metrik yang mengukur kesamaan n-gram antara output dan referensi

Penjelasan Teknis:

  • Membandingkan frasa tepat (1-word, 2-word, 3-word, 4-word)
  • Jangkauan: 0 (berbeda total) hingga 1 (identik)
  • KETAT: Pencocokan kata demi kata

Kapan Gunakan:

Terjemahan, generasi kode, tugas yang membutuhkan presisi tinggi

Dalam Data Kami:

Jangkauan 0.089 - 0.180 (BLEU cenderung rendah untuk LLM)

ROUGE-1 (Recall-Oriented Understudy for Gisting Evaluation)

Apa itu: Metrik yang mengukur tumpang tindih uniram (kata-kata individu)

Penjelasan Sederhana:

  • Menghitung berapa banyak kata yang sama muncul di output dan referensi
  • SANTAI: Tidak peduli urutan kata, hanya kehadiran
  • Jangkauan: 0 - 1

Contoh:

Output: "kucing duduk di rumah"
Referensi: "rumah tempat kucing duduk"
ROUGE-1 TINGGI (semua kata ada)

Dalam Data Kami:

Jangkauan 0.309 - 0.618 (lebih tinggi dari BLEU, lebih masuk akal)

ROUGE-L (Longest Common Subsequence)

Apa itu: Metrik yang mengukur subsequence umum terpanjang antara output dan referensi

Apa yang Diukur:

  • Urutan kata (structure)
  • Koherensi kalimat
  • Aliran logis

Contoh:

Output: "saya PERGI ke SEKOLAH"
Referensi: "SAYA pergi KE sekolah jam 8"
Subsequence umum: "SAYA pergi KE sekolah" ROUGE-L TINGGI

Dalam Data Kami:

Jangkauan 0.249 - 0.409 (mengukur struktur output)

GPU (Graphics Processing Unit)

Apa itu: Prosesor khusus untuk komputasi paralel masif

GPU dalam Penelitian:

  • RTX4070: Entry-level profesional (~$600)
  • RTX4080: High-end consumer (~$1200) - DIREKOMENDASIKAN
  • RTX4090: Flagship ($1600+)

Perbedaan dalam Analisis:

  • RTX4080: 127.36 tok/s (GPT-2 INT8)
  • RTX4070: 14.74 tok/s (GPT-2 INT8) (10x lebih lambat)

VRAM (Video RAM)

Apa itu: Memori khusus GPU untuk menyimpan model dan data

Keterbatasan:

  • RTX4070: 12 GB VRAM
  • RTX4080: 16 GB VRAM
  • Setiap model membutuhkan ruang tertentu

Dalam Analisis Kami:

  • GPT-2 INT8: 0.5 GB (sangat efisien)
  • LLaMA-2-7B INT8: 5-7 GB (lumayan)

Trade-off Kuantisasi:

INT8 memotong VRAM 50% dibanding FP16 → Lebih banyak concurrency

Residency (GPU Residency)

Apa itu: Kondisi ketika seluruh model tinggal di GPU tanpa offloading ke CPU

Dua Skenario:

  • Residency = 1 (Baik): Model sepenuhnya di GPU, latency konsisten
  • Residency = 0 (Buruk): Model di-split antara GPU & CPU, latency unpredictable

Dalam Analisis Kami:

Semua konfigurasi memiliki residency penuh (model fit di GPU)

Latensi (Latency)

Apa itu: Waktu yang diperlukan untuk mendapatkan output pertama atau keseluruhan

Dua Jenis:

  • Time-to-first-token: Waktu token pertama (ideally <100ms)
  • Total generation time: Waktu untuk seluruh output

Contoh:

GPT-2 INT8 di RTX4080: ~8ms per token = 127 token/detik

Rule of Thumb:

  • <100ms: Sangat responsif (chat real-time)
  • 100-500ms: Responsif (aplikasi interaktif)
  • >500ms: Batch/offline OK

Transformer

Apa itu: Arsitektur neural network yang mendominasi NLP modern

Komponen Utama:

  • Attention: Mekanisme fokus pada token penting
  • Feed-Forward: Transformasi non-linear
  • Embedding: Konversi kata ke vektor numerik

Mengapa Penting:

Transformer adalah akar dari GPT, LLaMA, Qwen, dan hampir semua LLM modern

Token

Apa itu: Unit terkecil teks yang dipahami model (biasanya 1-2 karakter)

Contoh Tokenisasi:

"Hello world" →
["Hello", " ", "world"] atau
["He", "llo", " ", "wor", "ld"]
(Tergantung tokenizer)

Dalam Analisis Kami:

Throughput diukur dalam token/detik (bukan karakter/detik)

Perkiraan Konversi:

1 kata ≈ 1.3 token, 1 halaman ≈ 300 token

Pertanyaan yang Sering Diajukan

INT8 (8-bit) 2x lebih kecil dari FP16 (16-bit), menyediakan:

  • Percepatan 3-50x dalam inferensi
  • Pengurangan memori 50%
  • Hanya 10-20% kehilangan kualitas
  • Trade-off yang sangat baik untuk sebagian besar aplikasi

Ya! Semua data berasal langsung dari Oprea & Bâra (2026). Data yang sama + perhitungan yang sama = hasil yang sama (dalam ±0.5% karena perbedaan floating point).

  • Konsumen (Pengembangan): RTX4070 (~$600) - Baik untuk belajar
  • Profesional (Produksi): RTX4080 (~$1200) - Nilai terbaik
  • Enterprise (Penskalaan): RTX4090 atau multi-GPU - Throughput maksimal

Semua mendukung kuantisasi INT8 secara efisien.

Ya, tetapi sangat lambat (100-1000x lebih lambat dari GPU). Untuk produksi, selalu gunakan GPU. CPU dapat diterima hanya untuk:

  • Pengujian/pengembangan
  • Model kecil (GPT-2)
  • Pemrosesan batch dengan latensi fleksibel
  • BLEU: Ketat (kecocokan frasa tepat) - Gunakan untuk konten teknis
  • ROUGE-1: Sedang (tumpang tindih konten) - Bagus untuk teks umum
  • ROUGE-L: Sedang (struktur) - Memvalidasi koherensi
  • Gabungan: Retensi kualitas 80-95% tipikal dengan INT8

Tentu saja! Lihat tab Metodologi untuk varian bobot:

  • Prioritas Kecepatan: Maksimalkan throughput
  • Prioritas Kualitas: Maksimalkan kualitas output
  • Prioritas Biaya: Minimalkan pengeluaran

Sesuaikan bobot untuk mencocokkan prioritas Anda.

Analisis ini didasarkan pada penelitian Oprea & Bâra (2026), yang menggunakan model spesifik yang tersedia saat itu. Metodologi dapat diterapkan ke LLM apa pun:

  • Muat model dengan BitsAndBytes
  • Jalankan inferensi
  • Hitung metrik kualitas
  • Skor menggunakan formula yang sama

Hasil yang diharapkan serupa (percepatan 3-50x, kualitas 80-95%).

Latensi bergantung pada beberapa faktor:

  • GPU: RTX4080 3-10x lebih cepat dari RTX4070
  • Ukuran Model: GPT-2 (0.1B) tercepat, LLaMA-2-7B lebih lambat
  • Panjang Output: Output lebih panjang = lebih banyak latensi
  • Ukuran Batch: Batch lebih besar = throughput lebih baik

Jangkauan tipikal: 50-500ms token pertama, 100-1000 token/detik total.

Gunakan pemilih Kasus Penggunaan interaktif di atas! Atau ikuti bagan alur ini:

  • Butuh kecepatan (<100ms)? → GPT-2 INT8
  • Butuh kode (87% valid)? → Qwen INT8
  • Butuh kualitas terbaik? → LLaMA-2-7B INT8
  • Butuh memori kecil? → GPT-2 atau Qwen INT8
  • Butuh keseimbangan? → Qwen INT8