Format GGUF: Panduan Lengkap Inferensi LLM Lokal

Apa Itu GGUF?

GGUF, singkatan dari GGML Unified Format, adalah format berkas biner yang mengemas bobot model, data tokenizer, metadata arsitektur, dan informasi kuantisasi ke dalam satu berkas portabel untuk inferensi dengan runtime berbasis GGMLntimes, terutama llama.cpp.

GGUF memecahkan masalah deployment LLM. Banyak format model mengharuskan pengguna menyimpan beberapa berkas bersama, termasuk bobot model, berkas tokenizer, berkas konfigurasi, dan kode pemuatan khusus arsitektur. GGUF menyederhanakan ini dengan membuat berkas model sebagian besar dapat menjelaskan dirinya sendiri.

Sebuah berkas GGUF biasanya berisi:

• Tensor model
• Bobot terkuantisasi atau tidak terkuantisasi
• Kosakata tokenizer
• Konfigurasi tokenizer
• Metadata arsitektur model
• Pengaturan panjang konteks
• Dimensi embedding
• Jumlah head attention
• Konfigurasi RoPE
• Nama, bentuk, dan tipe data tensor

Gagasan utamanya adalah berkas tersebut mendeskripsikan dirinya sendiri. Runtime dapat memeriksa metadata, memahami arsitektur, memuat tokenizer, dan memetakan tensor tanpa bergantung pada config.json terpisah atau folder tokenizer.

Ini tidak berarti setiap berkas GGUF kompatibel secara universal dengan setiap runtime selamanya. Runtime tetap perlu mendukung arsitektur model dan tipe tensor yang digunakan dalam berkas. Namun, GGUF membuat kompatibilitas itu jauh lebih mudah dibanding format lama karena berkas membawa informasi terstruktur yang lebih lengkap.

Empat karakteristik yang mendefinisikan GGUF adalah:

1. Deployment satu berkas
2. Dukungan memory mapping untuk pemuatan efisien
3. Metadata key-value bertipe yang dapat diperluas
4. Dukungan untuk banyak tipe kuantisasi, dari format low-bit agresif hingga presisi penuh

GGUF diperkenalkan sebagai bagian dari ekosistem llama.cpp dan GGML pada 2023. Kini menjadi format utama untuk mendistribusikan LLM lokal terkuantisasi di Hugging Face.

GGUF vs. GGML

Format GGML (Georgi Gerganov Machine Learning) adalah pendahulu GGUF. Format ini penting karena membantu mewujudkan inferensi lokal pada tahap awal. Namun, ia memiliki keterbatasan praktis ketika ekosistem berkembang melampaui model LLaMA asli.

Titik nyeri GGML yang umum meliputi:

• Penanganan metadata yang kurang fleksibel
• Asumsi pemuatan yang lebih spesifik arsitektur
• Penanganan tokenizer dan konfigurasi yang kurang mandiri
• Ekstensibilitas yang lebih sulit saat keluarga model baru muncul

GGUF mengatasi keterbatasan tersebut dengan format yang lebih terstruktur. Ia memperkenalkan metadata bertipe, embedding tokenizer yang lebih baik, dan tata letak berkas yang lebih jelas. Ini memudahkan llama.cpp dan alat terkait untuk mendukung lebih banyak arsitektur tanpa terus-menerus mendesain ulang pipeline pemuatan.

Bagi pengguna, perbedaan pentingnya sederhana: GGUF adalah format modern. Jika Anda mengunduh model saat ini, hampir selalu pilih GGUF alih-alih berkas GGML yang lebih lama.

GGUF vs. GPTQ dan AWQ

Dalam riset Anda tentang format berkas, Anda pasti menemukan GGUF, GPTQ (Generative Post-Training Quantization), dan AWQ (Activation-Aware Weight Quantization). Saya sering melihatnya dibahas bersama karena ketiganya digunakan untuk membuat inferensi LLM lebih efisien. Namun, ini bukan kategori yang identik.

GGUF terutama adalah format berkas dan kontainer deployment. Ia mendukung banyak tipe kuantisasi dan erat kaitannya dengan inferensi lokal gaya llama.cpp.

GPTQ dan AWQ adalah metode kuantisasi dan ekosistem yang umum digunakan untuk inferensi yang dioptimalkan GPU, khususnya pada perangkat keras NVIDIA melalui kerangka kerja seperti Transformers, ExLlama, AutoGPTQ, dan alur kerja yang kompatibel vLLM.

Jika tujuan Anda adalah kompatibilitas maksimum di laptop, desktop, Apple Silicon, dan perangkat keras campuran, GGUF biasanya pilihan yang lebih aman.

Jika tujuan Anda adalah throughput maksimum pada server inferensi NVIDIA khusus, GPTQ, AWQ, FP8, atau format serving lain yang dioptimalkan untuk GPU mungkin lebih tepat.

Mengapa Menggunakan GGUF?

GGUF menjadi populer karena menyelesaikan masalah deployment praktis. Saya juga mendapati format ini sangat nyaman saat melakukan deployment lokal tanpa repot pengaturan.

Menjalankan LLM lokal dulunya melibatkan tooling yang terfragmentasi, bobot tidak terkompres besar, format model yang tidak kompatibel, dan langkah pengaturan yang rumit. GGUF kini dapat membantu Anda menstandardisasi sebagian besar alur kerja tersebut.

Alih-alih memikirkan banyak berkas terpisah dan skrip pemuatan, pengguna dapat fokus memilih model yang tepat, memilih tingkat kuantisasi, dan menjalankan inferensi.

Jalankan model secara lokal

GGUF memungkinkan Anda menjalankan LLM di mesin Anda sendiri. Ini berarti:

• Tidak ada biaya API per token
• Tidak bergantung pada penyedia inferensi hosted
• Tidak perlu mengirim prompt ke API pihak ketiga
• Inferensi offline dimungkinkan setelah model diunduh

Ini sangat berguna untuk alur kerja yang sensitif terhadap privasi. Pengembang mungkin tidak ingin mengirim kode kepemilikan, dokumen internal, catatan pelanggan, atau prompt rahasia ke API eksternal.

Inferensi lokal tidak otomatis aman dengan sendirinya. Anda tetap perlu mengelola mesin, log, aplikasi, dan kontrol akses dengan baik. Namun, GGUF membuat deployment lokal yang privat jauh lebih mudah diakses.

Untuk praktik langsung menjalankan model secara lokal, lihat tutorial kami tentang menyajikan Mistral Medium 3.5 dengan SGLang, menjalankan DeepSeek V4 Flash secara lokal, menjalankan model Bonsai 1-bit yang efisien di laptop lama, dan menjalankan MiniMax M2 secara lokal sebagai asisten coding.

Fleksibilitas perangkat keras

GGUF berguna karena bekerja di banyak konfigurasi perangkat keras.

Bergantung pada runtime dan backend, model GGUF dapat berjalan di:

• Mesin hanya CPU
• GPU NVIDIA melalui CUDA
• Apple Silicon melalui Metal
• GPU AMD melalui HIP atau Vulkan
• GPU Intel melalui SYCL atau Vulkan
• Beberapa lingkungan ARM dan seluler

Fleksibilitas ini menjadi alasan utama llama.cpp berpengaruh. Ia tidak dirancang hanya untuk GPU server kelas atas. Ia dirancang untuk memungkinkan inferensi lokal di berbagai perangkat keras.

Sebagai contoh, pengguna Mac dapat mengandalkan akselerasi Metal, sementara pengguna desktop Linux dapat menggunakan CUDA atau Vulkan. Pengguna hanya CPU masih dapat menjalankan model terkuantisasi yang lebih kecil, meskipun kecepatan generasi akan lebih lambat.

Dukungan ekosistem yang luas

GGUF didukung oleh banyak alat inferensi lokal. Contohnya meliputi:

• llama.cpp untuk inferensi command-line dan server
• Ollama untuk manajemen model berbasis CLI dan akses API
• LM Studio untuk GUI desktop
• GPT4All untuk percakapan lokal yang berfokus pada privasi
• KoboldCpp untuk roleplay lokal dan alur kerja generasi teks
• Jan dan Open WebUI untuk antarmuka AI lokal

Ini penting karena pengguna tidak terkunci pada satu antarmuka. Format model yang sama secara umum dapat digunakan di berbagai alur kerja.

Seorang pengembang mungkin melakukan benchmark model dengan llama.cpp, mengobrol dengannya di LM Studio, menyajikannya melalui Ollama, dan menghubungkannya ke UI peramban melalui Open WebUI.

Distribusi di Hugging Face

Hugging Face telah menjadi hub distribusi utama untuk model GGUF.

Sumber: Hugging Face

Banyak model open-weight populer menerima varian GGUF yang diunggah komunitas segera setelah rilis. Repositori ini sering menyertakan beberapa opsi kuantisasi sehingga pengguna dapat memilih model yang sesuai dengan perangkat keras mereka.

Varian unggahan yang umum mencakup:

• Q4_K_M
• Q5_K_M
• Q6_K
• Q8_0
• IQ4_XS
• IQ3_M
• IQ2_XXS

Ini berarti konversi manual sering kali tidak diperlukan. Untuk model paling populer, seseorang di komunitas biasanya sudah membuat berkas GGUF untuk tingkat kuantisasi umum.

Kontrol granular ukuran-kualitas

GGUF memberi pengguna kontrol halus atas kompromi ukuran-kualitas. Anda dapat memilih:

• Kuantisasi lebih kecil untuk mesin dengan memori rendah
• Kuantisasi menengah untuk penggunaan harian yang seimbang
• Kuantisasi bit lebih tinggi untuk coding, penalaran, atau keluaran terstruktur
• Presisi penuh atau mendekati penuh saat memori tidak menjadi kendala

Fleksibilitas ini adalah salah satu keunggulan terbesar format ini. Alih-alih satu target deployment tetap, GGUF memungkinkan pengguna menyesuaikan keluarga model yang sama ke banyak kelas perangkat keras.

Bagaimana GGUF Bekerja?

Sebuah berkas GGUF diorganisasi menjadi tiga bagian utama:

1. Header
2. Metadata dan informasi tensor
3. Data tensor

Struktur tepatnya ditentukan oleh spesifikasi GGUF. Gagasan pentingnya adalah metadata dan informasi tensor muncul sebelum data tensor mentah, memungkinkan runtime memahami apa yang akan dimuat.

Header

Header mengidentifikasi berkas sebagai GGUF dan memberi tahu runtime cara mengurai sisa berkas. Ini mencakup:

• Magic number untuk GGUF
• Versi format
• Jumlah tensor
• Jumlah pasangan key-value metadata

Berkas GGUF modern umumnya menggunakan GGUF versi 3.

Mesin inferensi memeriksa magic number terlebih dahulu. Jika berkas tidak dimulai dengan pengenal GGUF yang diharapkan, runtime dapat menolaknya sebelum mencoba mengurai tensor atau mengalokasikan memori.

Ini adalah langkah keamanan dan keandalan yang sederhana namun penting. Ini mencegah runtime secara tidak sengaja memperlakukan berkas biner yang tidak terkait sebagai model.

Pasangan key-value metadata

Metadata GGUF adalah penyimpanan key-value bertipe. Metadata ini dapat mendeskripsikan:

• Informasi umum model
• Keluarga arsitektur
• Panjang konteks
• Ukuran embedding
• Jumlah layer
• Jumlah attention head
• Parameter RoPE
• Kosakata tokenizer
• Token khusus
• Informasi kuantisasi

Key biasanya menggunakan namespace. Contohnya meliputi:

• general.architecture
• general.alignment
• llama.context_length
• tokenizer.ggml.tokens

Penamaan namespace penting karena memungkinkan GGUF mendukung banyak arsitektur tanpa mengubah seluruh format berkas. Model keluarga LLaMA dapat menggunakan key llama.*, sementara keluarga model lain dapat menggunakan metadata khusus arsitekturnya sendiri.

Ini salah satu alasan GGUF dapat beradaptasi dengan baik untuk model di luar keluarga LLaMA asli, termasuk arsitektur seperti Qwen, Mistral, Gemma, DeepSeek, Phi, dan lainnya.

Informasi tensor dan data tensor

Setelah metadata, berkas menyimpan informasi tensor dan data tensor.

Informasi tensor menjelaskan:

• Nama tensor
• Bentuk
• Tipe data
• Offset ke bagian data tensor

Bagian data tensor berisi bobot model yang sebenarnya. Bobot ini dapat disimpan dalam presisi penuh atau dalam salah satu tipe tensor terkuantisasi yang didukung GGUF.

GGUF menggunakan nilai alignment yang didefinisikan dalam metadata, umumnya general.alignment. Banyak berkas GGUF menggunakan alignment 32-byte, namun cara yang benar untuk menjelaskannya adalah alignment dikendalikan oleh metadata alih-alih dikodekan secara permanen.

Alignment penting karena memungkinkan runtime mengakses blok tensor secara efisien.

Memory mapping

Salah satu keunggulan praktis GGUF adalah memory mapping, yang sering disebut mmap.

Dengan memory mapping, sistem operasi dapat memetakan berkas model ke memori virtual alih-alih memaksa runtime menyalin seluruh berkas ke RAM di awal.

Ini dapat membuat waktu mulai model terasa jauh lebih cepat, terutama di SSD. Ini juga memungkinkan sistem operasi melakukan paging data model sesuai kebutuhan.

Namun, memory mapping bukanlah sihir. Model tetap membutuhkan bandwidth memori dan RAM atau VRAM yang cukup agar berjalan baik. Jika sistem Anda terus-menerus melakukan paging dari disk, inferensi bisa menjadi lambat.

Cara yang lebih baik untuk memikirkan mmap adalah:

• Meningkatkan efisiensi pemuatan
• Mengurangi penyalinan yang tidak perlu
• Membiarkan OS mengelola paging
• Tidak menghilangkan kebutuhan memori untuk inferensi

Memahami Tipe Kuantisasi GGUF

Kuantisasi mengompresi bobot model ke representasi presisi lebih rendah.

Alih-alih menyimpan setiap bobot sebagai nilai floating point 16-bit, model terkuantisasi menyimpan nilai perkiraan menggunakan bit yang lebih sedikit. Ini mengurangi ukuran disk, penggunaan RAM dan VRAM, serta tekanan bandwidth memori.

Wawasan kuncinya adalah banyak bobot jaringan saraf tidak membutuhkan presisi floating point penuh saat inferensi. Model yang dikuantisasi dengan cermat dapat mempertahankan banyak perilaku model asli sambil menjadi jauh lebih kecil.

Penamaan kuantisasi GGUF

Nama kuantisasi GGUF biasanya mengikuti pola ini:

• Q berarti terkuantisasi
• Angka menunjukkan perkiraan bit per bobot
• K mengacu pada keluarga k-quant
• S, M, dan L biasanya berarti varian kecil, sedang, dan besar

Contohnya meliputi:

• Q4_K_M
• Q5_K_M
• Q6_K
• Q8_0

Nama tersebut berguna sebagai panduan, tetapi tidak selalu merupakan pernyataan tepat tentang total ukuran berkas. Ukuran berkas nyata bergantung pada campuran tensor, arsitektur, metadata, ukuran tokenizer, dan apakah beberapa tensor tetap pada presisi lebih tinggi.

Tipe kuantisasi GGUF yang umum

Angka-angka ini merupakan perkiraan untuk model dense kelas 7B. Arsitektur yang lebih baru, model mixture-of-experts, tokenizer yang lebih besar, dan tata letak tensor yang berbeda dapat mengubah ukuran berkas sebenarnya.

Dalam praktiknya, Q4_K_M menjadi default populer karena memberikan keseimbangan kuat antara ukuran dan kualitas. Banyak pengguna menganggapnya sudah cukup baik untuk chat umum, peringkasan, penulisan ulang, dan kerja AI lokal eksploratif.

Q5_K_M dan Q6_K sering menjadi pilihan yang lebih baik untuk beban kerja yang lebih menuntut, seperti coding atau mengikuti instruksi multi-langkah

Alasannya sederhana: tugas-tugas ini lebih sensitif terhadap sedikit degradasi kualitas.

K-quant vs. I-quant

K-quant adalah keluarga kuantisasi yang banyak digunakan di balik format seperti Q4_K_M, Q5_K_M, dan Q6_K.

Mereka menggunakan skema kuantisasi berkelompok dengan informasi penskalaan yang membantu mempertahankan perilaku model sambil mengurangi kebutuhan memori. Mereka populer karena andal, didukung luas, dan mudah ditemukan dalam rilis GGUF komunitas.

I-quant, yang sering ditulis sebagai format IQ, adalah tipe kuantisasi yang lebih baru seperti:

• IQ4_XS
• IQ3_M
• IQ2_XXS
• IQ1_S

I-quant dirancang untuk mencapai kualitas lebih baik pada ukuran yang sangat kecil. Mereka dapat menggunakan teknik seperti kuantisasi sadar-importance dan codebook kuantisasi non-linear. Beberapa alur kerja menggunakan matriks importance, sering disebut imatrix, untuk membantu mempertahankan bobot yang lebih penting selama kuantisasi.

Komprominya adalah kompleksitas. I-quant dapat menghasilkan hasil ukuran-kualitas yang sangat baik, terutama pada bitrate yang sangat rendah, namun mungkin memerlukan alur kerja kuantisasi dan dukungan runtime yang lebih cermat.

Untuk sebagian besar pemula, K-quant tetap menjadi titik awal termudah.

Memilih tingkat kuantisasi untuk perangkat keras Anda

Tabel berikut memberikan titik awal praktis. Anggap ini sebagai patokan umum, bukan jaminan ketat. Panjang konteks, overhead sistem operasi, offloading GPU, ukuran cache KV, dan arsitektur model tertentu semuanya dapat mengubah kebutuhan memori.

Patokan umum:

• Gunakan Q4_K_M sebagai default aman untuk sebagian besar inferensi lokal.
• Gunakan Q5_K_M ketika kualitas lebih penting daripada menghemat setiap gigabita.
• Gunakan Q6_K atau Q8_0 saat memori tersedia, dan Anda menginginkan fidelitas lebih baik.
• Hindari Q2_K untuk pekerjaan serius kecuali Anda menguji skenario dengan memori sangat terbatas.
• Sisakan memori ekstra untuk cache KV, terutama saat menggunakan jendela konteks panjang.

Cache KV mudah diabaikan. Sebuah model mungkin muat ke dalam RAM pada panjang konteks pendek tetapi gagal atau melambat pada panjang konteks yang jauh lebih panjang karena cache bertambah seiring panjang sekuens.

Ekosistem GGUF

Adopsi GGUF didorong oleh tooling sama besarnya dengan format itu sendiri.

Sebuah format baru menjadi berguna ketika pengguna dapat dengan mudah mengunduh, menjalankan, memeriksa, mengonversi, dan menyajikan model. GGUF mendapat manfaat dari ekosistem yang kuat di alat command-line, aplikasi desktop, API, dan repositori model hosted.

1. llama.cpp

llama.cpp adalah runtime GGUF yang asli dan terpenting. Ini adalah mesin inferensi C/C++ ringan yang dibuat oleh Georgi Gerganov dan dipelihara oleh komunitas GGML. Tujuan utamanya adalah memungkinkan inferensi LLM yang efisien dengan pengaturan minimal di banyak platform perangkat keras.

llama.cpp modern mendukung banyak backend, termasuk:

• CPU
• CUDA untuk GPU NVIDIA
• Metal untuk perangkat Apple
• Vulkan
• HIP untuk GPU AMD melalui ROCm
• SYCL untuk GPU Intel
• OpenCL di lingkungan tertentu
• Backend khusus lain seperti CANN, OpenVINO, dan WebGPU, bergantung pada dukungan platform

Ini juga menyertakan alat untuk konversi, kuantisasi, serving, benchmarking, dan inferensi command-line. Alat umum meliputi:

• convert_hf_to_gguf.py
• llama-quantize
• llama-cli
• llama-server
• llama-bench

Perintah untuk membuat build CMake CPU dasar adalah:

cmake -B build
cmake --build build --config Release

Untuk beberapa konfigurasi, flag tertentu perlu ditambahkan ke perintah pertama dari dua perintah tersebut:

• Nonaktifkan Apple Metal di macOS (diaktifkan secara default): -DGGML_METAL=OFF
• Build Vulkan: -DGGML_VULKAN=1
• Build CUDA untuk GPU NVIDIA: -DGGML_CUDA=ON

Perlu diperhatikan bahwa build saat ini menggunakan opsi CMake GGML_* seperti GGML_CUDA, GGML_VULKAN, dan GGML_HIP.

2. Ollama

Ollama adalah salah satu cara termudah untuk menjalankan model lokal. Ia menyediakan:

• CLI yang sederhana
• Penarikan dan manajemen model
• REST API lokal
• Library resmi Python dan JavaScript
• Integrasi dengan banyak frontend AI lokal

Ollama menyimpan dan mengelola model untuk Anda, sehingga pengguna biasanya tidak berinteraksi langsung dengan berkas .gguf. Namun, Ollama dibangun di sekitar inferensi lokal yang kompatibel dengan llama.cpp dan juga dapat mengimpor berkas GGUF melalui alur kerja Modelfile.

Ollama mengekspose API lokal di:

http://localhost:11434/api

Dua endpoint yang sering digunakan adalah:

• /api/generate untuk penyelesaian prompt
• /api/chat untuk pesan bergaya chat

Bagi pemula, Ollama sering menjadi jalur tercepat dari nol hingga inferensi lokal.

3. LM Studio

Sumber: LM Studio

LM Studio adalah aplikasi desktop untuk menemukan, mengunduh, dan mengobrol dengan model lokal. Ini berguna bagi pengguna yang lebih memilih antarmuka grafis daripada alat command-line.

4. GPT4All

Sumber: GPT4All

GPT4All adalah aplikasi AI lokal lintas platform lain yang berfokus pada alur kerja chatbot lokal yang privat. Ia mendukung model GGUF dan menyediakan lingkungan yang ramah pemula untuk inferensi lokal.

Alat-alat ini membuat GGUF dapat diakses oleh non-spesialis. Pengguna tidak perlu memahami CMake, tata letak tensor, atau internal kuantisasi hanya untuk mencoba model lokal.

Cara Memulai dengan Model GGUF

Ada dua cara praktis untuk memulai:

1. Gunakan Ollama untuk pengalaman yang paling sederhana.
2. Gunakan llama.cpp secara langsung untuk kendali lebih.

Menjalankan model dengan Ollama

Alur kerja paling sederhana adalah mengunduh model dan memulai sesi chat interaktif:

ollama pull llama3.3
ollama run llama3.3

Untuk memanggil model dari Python menggunakan REST API:

import requests

payload = {
    "model": "llama3.3",
    "prompt": "Give me three practical use cases for GGUF.",
    "stream": False
}

response = requests.post(
    "http://localhost:11434/api/generate",
    json=payload
)

print(response.json()["response"])

Untuk aplikasi bergaya chat, gunakan /api/chat:

import requests

payload = {
    "model": "llama3.3",
    "messages": [
        {"role": "user", "content": "What is GGUF used for?"}
    ],
    "stream": False
}

response = requests.post(
    "http://localhost:11434/api/chat",
    json=payload
)

print(response.json()["message"]["content"])

Field stream: false penting untuk skrip sederhana. Tanpanya, Ollama mengembalikan stream objek JSON alih-alih satu respons JSON final.

Anda juga bisa menggunakan library resmi Python Ollama:

from ollama import chat

response = chat(
    model="llama3.3",
    messages=[
        {"role": "user", "content": "Explain GGUF quantization simply."}
    ]
)

print(response.message.content)

Menjalankan berkas GGUF dengan llama.cpp

Jika Anda sudah memiliki berkas .gguf, Anda dapat menjalankannya langsung dengan llama.cpp setelah membangun proyek.

Contoh:

./build/bin/llama-cli \
  -m models/model.Q4_K_M.gguf \
  -p "Explain the difference between GGUF and GPTQ." \
  -n 256

Jika Anda mengaktifkan dukungan GPU, Anda dapat melakukan offload layer ke GPU:

./build/bin/llama-cli \
  -m models/model.Q4_K_M.gguf \
  -p "Summarize GGUF in five bullet points." \
  -n 256 \
  -ngl 99

Flag -ngl mengontrol jumlah layer yang di-offload ke GPU. Nilai tinggi seperti 99 umum digunakan untuk meng-offload sebanyak mungkin, dengan asumsi model muat di VRAM.

Untuk serving API, gunakan llama-server:

./build/bin/llama-server \
  -m models/model.Q4_K_M.gguf \
  -ngl 99 \
  --host 127.0.0.1 \
  --port 8080

Ini memberi Anda antarmuka server lokal untuk mengintegrasikan llama.cpp ke dalam aplikasi.

Mengonversi model Hugging Face ke GGUF

Sebagian besar pengguna tidak perlu mengonversi model secara manual karena rilis GGUF dari komunitas tersedia luas.

Namun, konversi manual berguna ketika:

• Anda melakukan fine-tune model sendiri
• Belum ada versi GGUF
• Anda ingin mengendalikan proses kuantisasi sendiri
• Anda membutuhkan tipe kuantisasi tertentu

Alur kerja tipikal adalah:

1. Unduh model Hugging Face.
2. Konversi ke GGUF.
3. Kuantisasi berkas GGUF.

Contoh:

huggingface-cli download mistralai/Mistral-7B-Instruct-v0.3 \
  --local-dir mistral-7b

Lalu konversi ke GGUF:

python convert_hf_to_gguf.py mistral-7b \
  --outfile mistral-f16.gguf \
  --outtype f16

Lalu kuantisasi:

./build/bin/llama-quantize \
  mistral-f16.gguf \
  mistral-q4_k_m.gguf \
  Q4_K_M

Dalam alur kerja llama.cpp saat ini, convert_hf_to_gguf.py dan llama-quantize adalah alat yang relevan. Tutorial lama mungkin merujuk skrip konversi yang sudah usang atau nama biner yang lebih lama.

Kelebihan dan Keterbatasan Format GGUF

GGUF dioptimalkan untuk inferensi lokal yang praktis. Ini bukan pengganti universal untuk setiap format model atau tumpukan serving.

Untuk inferensi yang berfokus pada CPU, Apple Silicon, perangkat keras campuran, dan privasi, GGUF sering menjadi pilihan yang sangat baik.

Untuk deployment server NVIDIA ber-throughput tinggi, format dan engine lain mungkin lebih cepat bergantung pada model, ukuran batch, metode kuantisasi, dan kerangka serving.

Penutup

GGUF membuat inferensi LLM lokal menjadi praktis dengan mengemas semua yang dibutuhkan runtime (bobot, tokenizer, metadata, info kuantisasi) ke dalam satu berkas portabel. Kekuatan sesungguhnya ada pada ekosistem di sekitarnya: llama.cpp, Ollama, LM Studio, dan Hugging Face semuanya menjadikannya format default untuk deployment AI lokal.

Bagi sebagian besar pengguna, jalurnya sederhana: instal Ollama, tarik model, dan jalankan. Q4_K_M adalah default yang solid; naikkan ke Q5_K_M atau Q6_K saat Anda membutuhkan keluaran penalaran atau coding yang lebih baik dan memiliki memori yang cukup.

Jika Anda ingin menggali lebih dalam tentang deployment LLM, optimasi model, dan alur kerja inferensi lokal, Anda sebaiknya mengeksplorasi jalur karier Associate AI Engineer for Data Scientists atau Associate AI Engineer for Developers.