C++ on kenji.blog

Tanpa Python! Membangun Mesin Inferensi AI Hanya dengan C++

Fri, 11 Sep 2026 17:00:00 +0900

1. Pendahuluan: Mengapa Meninggalkan Python dan Membangun Mesin Inferensi AI dengan C++?

Dalam pengembangan AI modern, Python adalah standar de facto. Berkat framework tangguh seperti PyTorch dan TensorFlow, kita dapat membangun, melatih, dan menjalankan inferensi untuk jaringan saraf (neural network) yang kompleks hanya dengan beberapa baris kode. Namun, di balik framework tersebut, bahasa tingkat rendah seperti C++ dan CUDA lah yang menangani proses komputasi berat. Python hanyalah sekadar “lem” (glue) belaka.

Lalu, mengapa kita perlu repot-repot menyingkirkan Python dan membuat mesin inferensi AI menggunakan C++ saja? Ada beberapa alasan kuat untuk itu.

Performa Ekstrem dan Latensi Rendah: Kita dapat sepenuhnya menghilangkan overhead dari GIL (Global Interpreter Lock) dan pengetikan dinamis (dynamic typing) milik Python. Terutama dalam sistem yang membutuhkan pemrosesan real-time, keterlambatan dalam skala milidetik bisa sangat fatal.
Kemudahan Deployment: Membangun lingkungan Python (kumpulan library raksasa dan neraka dependensi) di lingkungan pengguna akhir (end-user) sangatlah sulit. Dengan C++, kita hanya perlu mendistribusikan sebuah binari eksekusi tunggal yang ditautkan secara statis (file .exe atau binari ELF).
Dukungan untuk Perangkat Edge: Di lingkungan dengan sumber daya yang sangat terbatas seperti smartphone, perangkat tertanam (embedded devices), atau Raspberry Pi, tidak ada ruang untuk menjalankan runtime Python yang memakan memori hingga beberapa gigabyte.
Kontrol Perangkat Keras Secara Langsung: Kontrol tingkat rendah seperti penentuan waktu alokasi memori, penggunaan instruksi SIMD secara eksplisit, dan pengoptimalan transfer memori dengan GPU dimungkinkan dengan C++.

Pada artikel ini, dengan mengambil banyak inspirasi dari arsitektur library “GGML” yang dikembangkan oleh Georgi Gerganov, kami akan menyelami jurang teknis dan menjelaskan proses pembuatan mesin inferensi dari nol untuk menjalankan Large Language Model (LLM) hanya menggunakan C++.

2. Gambaran Keseluruhan Arsitektur Mesin Inferensi

Proses inferensi AI pada dasarnya adalah “rangkaian komputasi matriks raksasa”. Agar dapat dieksekusi secara efisien, mesin inferensi harus terdiri dari komponen-komponen berikut.

graph TD A["Data Input (Token/Gambar)"] --> B["Manajemen Tensor"] B --> C["Grafik Komputasi (DAG)"] C --> D["Arena Memori & Alokator"] C --> E["Penjadwal & Kumpulan Utas"] E --> F["Backend CPU (AVX2/ARM NEON)"] E --> G["Backend GPU (CUDA/Metal)"] F --> H["Hasil Output"] G --> H

Manajemen Tensor: Mengelola struktur data array multidimensi dan stride untuk setiap dimensi.
Grafik Komputasi (Computation Graph): Merepresentasikan komputasi setiap lapisan pada neural network sebagai Directed Acyclic Graph (DAG).
Arena Memori (Memory Arena): Mekanisme manajemen memori pra-alokasi untuk menghindari overhead dari alokasi memori dinamis (malloc atau new).
Backend: Implementasi komputasi (kernel) yang dioptimalkan untuk perangkat keras tertentu seperti CPU atau GPU.

Kita akan menyusun komponen-komponen ini menggunakan fitur-fitur tangguh dari C++ (seperti template, aritmetika pointer, dan RAII).

3. Rahasia Manajemen Memori: Arena Memori dan Penjajaran (Alignment) SIMD

Manajemen memori pada mesin inferensi adalah salah satu faktor terpenting yang berhubungan langsung dengan performa. Selama inferensi, khususnya saat melewati setiap lapisan pada model Transformer, sejumlah besar tensor perantara dihasilkan. Jika tensor-tensor ini dialokasikan dan dibebaskan menggunakan malloc standar setiap saat, fragmentasi heap dan pertukaran konteks (context switch) dari OS akan menyebabkan penurunan kecepatan yang sangat fatal.

Oleh karena itu, kita mengadopsi pendekatan “Arena Memori (Memory Arena)”. Pendekatan ini merupakan metode di mana memori maksimal yang dibutuhkan dihitung (atau ditetapkan) lalu dialokasikan secara keseluruhan pada saat inferensi dimulai, dan memori dipotong-potong hanya dengan menggunakan penambahan (increment) pada pointer.

3.1 Pentingnya Penjajaran (Alignment)

CPU modern mendukung instruksi SIMD (Single Instruction, Multiple Data). Contohnya adalah AVX2/AVX-512 dari Intel/AMD dan NEON dari ARM. Instruksi-instruksi ini memproses data sebesar 256-bit (32 byte) atau 512-bit (64 byte) secara sekaligus, namun memori data yang diproses harus disejajarkan (aligned) pada batasan byte tertentu (biasanya 32 byte atau 64 byte).

Berikut ini adalah contoh implementasi C++ dari Arena Memori dengan mempertimbangkan alignment.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


#include <cstdint>
#include <cstddef>
#include <stdexcept>
#include <iostream>

struct MemoryArena {
 size_t size;
 size_t offset;
 uint8_t* data;

 MemoryArena(size_t size) : size(size), offset(0) {
 // Menggunakan posix_memalign untuk sistem POSIX, dan _aligned_malloc untuk Windows
#ifdef _WIN32
 data = static_cast<uint8_t*>(_aligned_malloc(size, 64));
#else
 if (posix_memalign(reinterpret_cast<void**>(&data), 64, size) != 0) {
 throw std::bad_alloc();
 }
#endif
 }

 ~MemoryArena() {
#ifdef _WIN32
 _aligned_free(data);
#else
 free(data);
#endif
 }

 void* allocate(size_t bytes, size_t alignment = 64) {
 // Kalkulasi alignment (mencari padding)
 size_t pad = (alignment - (offset % alignment)) % alignment;
 if (offset + pad + bytes > size) {
 throw std::runtime_error("OOM: MemoryArena out of memory");
 }
 offset += pad;
 void* ptr = data + offset;
 offset += bytes;
 return ptr;
 }

 void reset() {
 offset = 0; // Pembebasan memori hanya dengan mengembalikan pointer (O(1))
 }
};

Dengan cara ini, saat membuat tensor, kita selalu memperoleh memori melalui arena ini. Setiap kali sebuah langkah inferensi selesai (seperti setiap kali sebuah token dihasilkan), kita hanya perlu memanggil reset() untuk dapat menggunakan ulang memori tersebut secara instan.

4. Struktur Data Tensor dan Keajaiban Stride

Tensor adalah konsep yang menggeneralisasi skalar, vektor, dan matriks. Yang penting dalam implementasinya adalah bahwa data yang sebenarnya ditempatkan di dalam memori sebagai array satu dimensi yang berurutan, sedangkan untuk dapat menerjemahkannya ke dalam multidimensi, kita menggunakan konsep “Stride”.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


enum class DataType {
 FP32,
 FP16,
 INT8, // Untuk Kuantisasi
 INT4 // Untuk Kuantisasi
};

struct Tensor {
 int n_dims; // Jumlah Dimensi
 int64_t ne[4]; // Jumlah elemen per dimensi (Number of Elements)
 size_t nb[4]; // Stride per dimensi (Number of Bytes)
 DataType type; // Tipe Data
 void* data; // Pointer ke payload

 // Untuk Grafik Komputasi
 enum OpType op;
 Tensor* src0;
 Tensor* src1;
};

Stride nb[i] merepresentasikan jarak byte di dalam memori antara elemen-elemen yang bersebelahan pada dimensi i. Sebagai contoh, jika sebuah matriks dengan jumlah elemen $M \times N$ (FP32, 1 elemen 4 byte) disimpan dalam bentuk Row-Major (prioritas baris), nilai stride-nya akan seperti berikut:

nb[0] = 4 (byte) : Pergerakan ke arah kolom
nb[1] = $N \times 4$ (byte) : Pergerakan ke arah baris

Dengan menggunakan teknik ini, operasi seperti “Transpos (Transpose)” dan “Tampilan (View)” dapat diimplementasikan tanpa harus menyalin memori, melainkan cukup dengan menukar nilai stride. Cara ini sangat elegan dan cepat.

5. Membangun Grafik Komputasi (DAG) dan Evaluasi Malas (Lazy Evaluation)

Sama seperti PyTorch dan framework lainnya, mesin inferensi kita mengadopsi Evaluasi Malas (Lazy Evaluation) yang mirip dengan “Define-by-Run”. Dengan kata lain, ketika sebuah fungsi komputasi dipanggil, komputasi tidak langsung dieksekusi, melainkan hanya membangun grafik (hubungan dependensi antar node) terlebih dahulu.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


Tensor* tensor_add(MemoryArena& arena, Tensor* a, Tensor* b) {
 Tensor* out = create_tensor(arena, a->type, a->n_dims, a->ne);
 out->op = OpType::ADD;
 out->src0 = a;
 out->src1 = b;
 return out;
}

Tensor* tensor_mul_mat(MemoryArena& arena, Tensor* a, Tensor* b) {
 // b biasanya sudah di-transpose
 int64_t ne[2] = { a->ne[0], b->ne[1] };
 Tensor* out = create_tensor(arena, a->type, 2, ne);
 out->op = OpType::MUL_MAT;
 out->src0 = a;
 out->src1 = b;
 return out;
}

Alur proses inferensi adalah sebagai berikut:

graph LR A["Mendefinisikan Tensor"] --> B["Membangun Grafik via Operasi"] B --> C["Pengurutan Topologi"] C --> D["Alokasikan Memori untuk Output"] D --> E["Mengeksekusi Node Secara Berurutan"]

Ketika mengevaluasi grafik (forward pass), kita menggunakan pengurutan topologi (topological sort) untuk mengeksekusi proses secara berurutan, dimulai dari node yang tidak memiliki dependensi. Karena ini hanya untuk inferensi, tidak perlu menyimpan gradien untuk backpropagation, sehingga manajemen memori menjadi sangat sederhana.

6. Inti dari Matematika dan Optimasi: Perkalian Matriks (GEMM)

Lebih dari 90% komputasi dalam inferensi AI dihabiskan untuk Perkalian Matriks (GEMM: General Matrix Multiply). Baik mekanisme Attention maupun Feed-Forward Network (FFN), yang merupakan inti dari model Transformer, pada akhirnya adalah perkalian matriks raksasa.

Hasil kali $C = A B$ (ukuran $M \times N$) dari dua matriks $A$ (ukuran $M \times K$) dan $B$ (ukuran $K \times N$), jika direpresentasikan dalam rumus matematika adalah sebagai berikut.

$$ C_{i,j} = \sum_{k=0}^{K-1} A_{i,k} \cdot B_{k,j} $$

Jika hal ini diimplementasikan dengan loop tiga tingkat (triple loop) biasa, akan sering terjadi cache miss dan performa tidak akan tercapai sama sekali.

6.1 Pemblokiran Cache (Cache Blocking) pada CPU dan Optimasi SIMD

Strategi dasar untuk mempercepat GEMM di CPU adalah sebagai berikut.

Loop Tiling (Pemblokiran Cache): Membagi matriks ke dalam blok-blok kecil yang muat di dalam cache L1/L2 untuk dihitung.
Pengepakan Data (Data Packing): Menyusun ulang data secara internal agar pola akses memori menjadi berurutan.
Pemanfaatan SIMD: Menggunakan instruksi FMA (Fused Multiply-Add) seperti _mm512_fmadd_ps pada AVX-512 untuk menangani banyak operasi multiply-add dalam satu siklus clock.

Berikut adalah contoh penyederhanaan produk titik (Dot Product) vektor menggunakan C++ dan SIMD Intrinsics.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


#include <immintrin.h> // Untuk instruksi AVX

// Dot product berkecepatan tinggi FP32 menggunakan AVX2
float dot_product_avx2(const float* a, const float* b, int n) {
 __m256 sum256 = _mm256_setzero_ps();
 int i = 0;

 // Memproses 8 elemen sekaligus (256-bit = 32 byte = 8 * 4 byte)
 for (; i <= n - 8; i += 8) {
 __m256 va = _mm256_loadu_ps(a + i);
 __m256 vb = _mm256_loadu_ps(b + i);
 // Instruksi FMA: sum256 = va * vb + sum256
 sum256 = _mm256_fmadd_ps(va, vb, sum256);
 }

 // Penjumlahan horizontal dari nilai di dalam register SIMD
 float result[8];
 _mm256_storeu_ps(result, sum256);
 float dot = result[0] + result[1] + result[2] + result[3] +
 result[4] + result[5] + result[6] + result[7];

 // Pemrosesan sisanya
 for (; i < n; ++i) {
 dot += a[i] * b[i];
 }
 return dot;
}

Dengan trik kecil ini saja, kita bisa memperoleh peningkatan kecepatan hingga beberapa hingga belasan kali lipat dibandingkan dengan implementasi yang biasa.

7. Melampaui Batas Perangkat Keras: Integrasi Backend CUDA dan Metal

Implementasi C++ murni saja sudah cukup untuk dijalankan dengan lumayan di CPU. Namun, agar model raksasa seperti LLM dapat berjalan dengan kecepatan yang praktis (misalnya menghasilkan 20 token lebih per detik), kemampuan komputasi paralel dari GPU sangatlah penting. Oleh karena itu, kita akan memperkenalkan layer abstraksi backend ke dalam mesin inferensi kita.

7.1 Abstraksi Backend

Dengan menggunakan polimorfisme C++, kita dapat beralih dari satu pengeksekusi komputasi (Executor) ke pengeksekusi lainnya.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


class Backend {
public:
 virtual ~Backend() = default;
 virtual void alloc_buffer(Tensor* t) = 0;
 virtual void free_buffer(Tensor* t) = 0;
 virtual void copy_to_device(Tensor* t) = 0;
 virtual void copy_to_host(Tensor* t) = 0;

 // Eksekusi berbagai macam komputasi
 virtual void compute_add(Tensor* src0, Tensor* src1, Tensor* dst) = 0;
 virtual void compute_mul_mat(Tensor* src0, Tensor* src1, Tensor* dst) = 0;
};

7.2 Implementasi Backend NVIDIA CUDA

Untuk memanfaatkan GPU NVIDIA, kita akan mengimplementasikan backend menggunakan ekstensi CUDA C++. Meskipun kita bisa saja menulis kernel sendiri, untuk perkalian matriks, cara terbaik adalah memanfaatkan “cuBLAS”, yaitu library tingkat tinggi yang disediakan oleh NVIDIA.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


#include <cublas_v2.h>
#include <cuda_runtime.h>

class CUDABackend : public Backend {
private:
 cublasHandle_t handle;

public:
 CUDABackend() {
 cublasCreate(&handle);
 }

 ~CUDABackend() {
 cublasDestroy(handle);
 }

 void compute_mul_mat(Tensor* src0, Tensor* src1, Tensor* dst) override {
 // Pada CUDA default-nya adalah Column-Major, jadi parameternya harus diperhatikan
 const float alpha = 1.0f;
 const float beta = 0.0f;

 int m = src0->ne[0];
 int k = src0->ne[1];
 int n = src1->ne[1]; // Diasumsikan src1 sudah di-transpose

 cublasSgemm(handle, CUBLAS_OP_T, CUBLAS_OP_N,
 m, n, k,
 &alpha,
 (const float*)src0->data, k,
 (const float*)src1->data, k,
 &beta,
 (float*)dst->data, m);
 cudaDeviceSynchronize();
 }
};

Transfer data (cudaMemcpy) antara memori CUDA dan memori host (CPU) sangatlah berat. Oleh karena itu, penting untuk merancang agar semaksimal mungkin semua weight (tensor bobot) dan tensor perantara tetap berada di VRAM selama proses inferensi.

7.3 Backend Apple Silicon (Metal)

Belakangan ini, chip Mac M1/M2/M3 (Apple Silicon) sangat mumpuni sebagai mesin inferensi AI. Alasannya terletak pada “Unified Memory”. Karena CPU dan GPU berbagi ruang memori yang sama, transfer memori antara host dan device yang memakan biaya tinggi melalui bus PCIe—seperti pada CUDA yang disebutkan sebelumnya—menjadi sama sekali tidak diperlukan.

Untuk memanggil Metal dari C++, kita bisa menggunakan Objective-C++ (file .mm) sebagai perantara, atau menggunakan library metal-cpp. Kernel ditulis dengan menggunakan Metal Compute Shader (yang ditulis mirip dengan sintaks C++ pada file .metal).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


// Metal Shader (kernel.metal)
#include <metal_stdlib>
using namespace metal;

kernel void mul_mat_kernel(
 device const float* A [[buffer(0)]],
 device const float* B [[buffer(1)]],
 device float* C [[buffer(2)]],
 constant uint3& dims [[buffer(3)]],
 uint2 gid [[thread_position_in_grid]]
) {
 uint m = dims.x; uint k = dims.y; uint n = dims.z;
 uint row = gid.y; uint col = gid.x;

 if (row < m && col < n) {
 float sum = 0.0;
 for (uint i = 0; i < k; ++i) {
 sum += A[row * k + i] * B[i * n + col]; // Penyederhanaan
 }
 C[row * n + col] = sum;
 }
}

Di lingkungan Apple Silicon, juga disediakan library optimasi perkalian matriks yang disebut MPS (Metal Performance Shaders). Untuk penggunaan nyata, memanfaatkannya bisa menghasilkan kecepatan inferensi yang luar biasa.

8. Proses Khusus pada Model Transformer: Attention dan Cache KV

LLM termutakhir seperti LLaMA 2/3 dan GPT didasarkan pada arsitektur Transformer. Untuk mengimplementasikannya dalam C++, kita wajib membangun “Scaled Dot-Product Attention” yang diekspresikan dengan rumus berikut:

$$ \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V $$

Selain itu, dalam generasi token tipe Autoregresif (Autoregressive), kita perlu menyimpan hasil komputasi (Key dan Value) dari token-token sebelumnya. Hal ini disebut “Cache KV (Key-Value Cache)”.

graph TD T["Token Saat Ini"] --> Q["Query"] T --> K["Key"] T --> V["Value"] K --> KCache["Tambahkan ke Cache KV"] V --> VCache["Tambahkan ke Cache KV"] Q --> Dot1["Q * K_Cache^T"] KCache --> Dot1 Dot1 --> Scale["Skala (1/sqrt(d))"] Scale --> Softmax["Softmax"] Softmax --> Dot2["SoftmaxOut * V_Cache"] VCache --> Dot2 Dot2 --> Out["Vektor Konteks"]

Untuk alokasi memori dari Cache KV, kita menggunakan konsep seperti ring buffer dengan menyiapkan ruang memori untuk konteks maksimal (misalnya, 4096 atau 8192 token) di dalam arena secara pra-alokasi. Dengan melakukan ini, kita dapat mencegah realokasi di setiap langkah pembuatan (generation step).

Selain itu, untuk pengodean posisi (Positional Encoding), kita mengimplementasikan “RoPE (Rotary Position Embedding)” yang saat ini menjadi arus utama. Ini adalah metode untuk menyematkan informasi posisi sebagai vektor rotasi di ruang kompleks. Pengoptimalan dari pemanggilan fungsi sin dan cos di C++ (misalnya, menggunakan Look-Up Table) memegang peranan penting terhadap performa.

9. Optimasi Ekstrem dengan Kuantisasi Model (Quantization)

Jika kita memuat model skala besar (misalnya model LLaMA dengan 7 miliar parameter) menggunakan format FP32 (floating point 32-bit), bobotnya saja akan memakan memori (VRAM) sekitar 28GB. Apalagi jika ditambah dengan Cache KV dan buffer inferensi, penggunaannya dapat dengan mudah melampaui 30GB, sehingga mustahil dijalankan pada GPU konsumen (consumer GPU) biasa.

Oleh karena itu, “Kuantisasi (Quantization)” menjadi hal yang wajib dilakukan. Ini juga merupakan nilai utama dari format GGML.

Kuantisasi adalah teknik untuk menurunkan presisi dari bobot (weight) secara sengaja.

FP16 (16-bit): Ukuran berkurang separuh. Hampir tidak ada degradasi presisi.
INT8 (8-bit): Ukuran menjadi 1/4. Sedikit terjadi degradasi.
INT4 (4-bit): Ukuran menjadi 1/8. Dapat digunakan untuk inferensi yang praktis dengan menggunakan teknik blocking dan scaling factor khusus.

Pada sisi mesin inferensi, bobot yang dikompres dalam format INT4 (atau INT8) akan dibaca dari memori, kemudian segera setelah dimuat ke dalam register CPU atau GPU, akan diekspansi (Dequantize) ke dalam FP16 atau FP32 untuk melakukan komputasi.

Hal yang menakjubkan adalah bahwa akan jauh lebih cepat jika kita mengurangi jumlah data yang dibaca dari memori meskipun itu berarti harus menambah beban komputasi. Hal ini dikarenakan pada perangkat keras modern, bottleneck pada tugas inferensi bukanlah “Kekuatan Komputasi (Compute Bound)” melainkan “Bandwidth Memori (Memory Bandwidth Bound)”. Jika kita mengimplementasikan mesin inferensi di C++ dengan kuantisasi INT4, kita dapat menjalankan LLM lokal dengan lancar bahkan di MacBook Air dengan VRAM 8GB.

10. Penyesuaian Performa (Performance Tuning): Arsitektur NUMA dan Kumpulan Utas (Thread Pool)

Saat melakukan inferensi menggunakan CPU, multithreading sangatlah wajib. Akan tetapi, hanya sekadar menjalankan banyak std::thread bukanlah sebuah hal yang optimal.

Pada server multi-soket modern maupun CPU high-end seperti Ryzen Threadripper, telah mengadopsi arsitektur NUMA (Non-Uniform Memory Access). Mengakses memori yang secara fisik dekat dengan suatu core CPU (memori lokal) sangatlah cepat, tetapi mengakses memori yang terhubung dengan prosesor lain akan berjalan sangat lambat.

Di mesin inferensi C++ yang canggih, teknik-teknik berikut dimanfaatkan secara maksimal:

Penyematan Utas (Thread Pinning): Mengunci setiap thread ke core CPU tertentu (dengan mengatur Affinity) untuk mencegah kerusakan cache yang disebabkan oleh context switch.
Alokasi Sadar-NUMA (NUMA-aware Allocation): Mengalokasikan memori di node NUMA yang sama dengan thread yang sedang memproses data tersebut.
Kumpulan Utas dengan Pencurian Kerja (Work-Stealing Thread Pool): Membagi setiap node di dalam grafik komputasi ke dalam tugas-tugas kecil, dan mengimplementasikan penjadwal (scheduler) yang efisien di mana thread yang sedang kosong akan secara otomatis mencuri tugas untuk dieksekusi.

Dengan memanfaatkan teknik-teknik tersebut, kita dapat menjaga pemanfaatan CPU agar selalu menempel pada kisaran 100%, serta memeras tingkat throughput yang mendekati nilai teoretisnya.

11. Kesimpulan: Kegembiraan Menjalankan AI dengan “Otot” C++

Python memang nyaman digunakan. Untuk tahap penelitian dan pengembangan (R&D) atau pembuatan prototipe, tidak ada bahasa pemrograman lain yang bisa menyaingi produktivitasnya. Namun, pada saat kita beralih ke fase “menjalankan model yang sudah jadi secara efisien di semua perangkat pada dunia nyata”, di situlah saatnya C++ mengambil peran.

Mesin inferensi yang dibangun dengan memanipulasi deretan byte memori secara langsung, memeras register hingga batas maksimalnya menggunakan instruksi SIMD, dan bergulat dengan bandwidth VRAM GPU—rasa pencapaian ketika melihat mesin tersebut menghasilkan teks (token) bahasa Jepang yang natural satu per satu di konsol merupakan “kegembiraan murni seorang insinyur” yang tidak akan pernah Anda dapatkan hanya dengan memanggil model.generate() di framework Python.

Teknologi AI seringkali menjadi “Kotak Hitam (Black Box)”, tetapi dengan menulis semuanya—mulai dari komputasi tensor hingga alokasi memori—sendiri menggunakan C++, Anda dapat memperoleh pemahaman yang mendalam tentang mekanisme nyata di balik bagaimana LLM “berpikir”.

Jika Anda memiliki pengetahuan dasar tentang C++ dan ketertarikan yang kuat pada teknologi AI saat ini, cobalah untuk menantang diri dalam membuat mesin inferensi sendiri. Kode sumber dari GGML dan llama.cpp pasti akan menjadi buku pelajaran hidup yang terbaik.

Ayo, buang runtime Python yang berat itu dan jalankan AI mutakhir dengan otot C++!

Panduan Pengembangan Model AI Skala Kecil (seperti TinyLLaMA) Menggunakan C++

Fri, 11 Sep 2026 14:00:00 +0900

Panduan Pengembangan Model AI Skala Kecil (seperti TinyLLaMA) Menggunakan C++

Baru-baru ini, minat terhadap eksekusi model bahasa besar (LLM) di lingkungan lokal telah meningkat secara pesat. Secara khusus, model berskala kecil seperti TinyLLaMA (1.1B parameter) dapat diinferensi dengan kecepatan praktis bahkan pada perangkat edge dengan sumber daya terbatas atau laptop umum (termasuk lingkungan Windows). Sementara pengembangan menggunakan Python dan PyTorch adalah arus utama, ketika mengejar kinerja dan efisiensi memori terbaik, kombinasi C++ dan pustaka tensor berbasis C, “ggml”, telah menjadi standar de facto.

Artikel ini akan menjelaskan secara rinci prosedur pengembangan (atau pemahaman mendalam tentang struktur internal llama.cpp yang sudah ada) untuk membangun mesin inferensi dari awal guna memuat TinyLLaMA dan melakukan pembuatan teks menggunakan C++.

1. Mengapa C++ dan ggml?

Dalam tahap pelatihan AI, Python sangat diuntungkan dengan fleksibilitas dan ekosistemnya yang kaya. Namun, dalam fase penerapan dan “Inferensi”, C++ menjadi pilihan yang kuat karena alasan berikut:

Pengurangan Overhead: Global Interpreter Lock (GIL) Python dan overhead runtime dapat dihilangkan sepenuhnya.
Efisiensi Memori dan Alokasi Arena: Karena alokasi dan dealokasi memori dapat dikontrol secara manual, lonjakan yang tidak dapat diprediksi akibat garbage collection dapat dicegah.
Akses Langsung ke Perangkat Keras: Dapat langsung memanggil fungsi bawaan SIMD (Intrinsics) seperti AVX-512, AVX2, dan ARM NEON untuk memaksimalkan kemampuan komputasi CPU.
Tanpa Dependensi: ggml adalah pustaka C/C++ dengan nol dependensi (Zero dependencies), yang dapat dengan mudah dibangun bahkan di lingkungan MSVC di Windows asalkan ada kompilator.

2. Gambaran Keseluruhan Arsitektur

Alur dari seluruh pipeline inferensi ditunjukkan dalam diagram Mermaid di bawah ini. Ini adalah serangkaian proses mulai dari teks masukan pengguna hingga pembuatan token berikutnya.

graph TD A["Teks Masukan Pengguna"] --> B["BPE Tokenizer"] B --> C["Array ID Token"] C --> D["Pencarian Lapisan Embedding"] D --> E["Blok Transformer"] E --> F["RMSNorm"] F --> G["Lapisan LM Head"] G --> H["Array Logit"] H --> I["Modul Sampler"] I --> J["ID Token Berikutnya"] J --> K["Detokenizer"] K --> L["Potongan Teks Keluaran"] J -.-> |"Tambahkan ke Konteks"| C

Karena ini adalah model auto-regresif, token yang dihasilkan ditambahkan kembali ke konteks dan disirkulasikan sebagai masukan untuk memprediksi token berikutnya (bagian garis putus-putus pada diagram).

3. Format Model dan Pemetaan Memori (mmap)

Kendala terbesar dalam menangani bobot jaringan saraf yang sangat besar adalah operasi I/O disk dan konsumsi memori. Implementasi C++ menyelesaikan masalah ini dengan pemetaan memori (mmap).

3.1 Cara Kerja Pemetaan Memori dan Implementasi di Windows

Menggunakan mmap memungkinkan konten file dipetakan langsung ke dalam ruang memori virtual proses.

Zero-copy (Tanpa Salinan): Data dibaca langsung dari disk ke dalam tembolok halaman kernel, dan tidak ada salinan ekstra ke ruang pengguna yang terjadi.
On-demand Load (Page Fault): Tepat saat CPU mengakses alamat memori tersebut, page fault terjadi, dan hanya chunk yang diperlukan (biasanya 4KB) yang dimuat ke dalam memori fisik.

Di lingkungan Windows, API Win32 CreateFileMapping dan MapViewOfFile digunakan sebagai pengganti POSIX mmap.

sequenceDiagram participant OS["OS Windows"] participant RAM["Memori Fisik"] participant App["Aplikasi C++"] App->>OS: "CreateFileMapping / MapViewOfFile" OS-->>App: "Penunjuk Alamat Memori Virtual" App->>App: "Baca Data Tensor pada Penunjuk" OS->>RAM: "Page Fault / Muat halaman dari Disk" RAM-->>App: "Data siap untuk Komputasi SIMD"

3.2 Struktur Biner Format GGUF

GGUF (GPT-Generated Unified Format), yang dikonversi dari format seperti .safetensors Hugging Face, adalah format pamungkas untuk inferensi. GGUF memiliki tata letak biner ketat berikut:

Magic Bytes: 0x46554747 (GGUF).
Version: Nomor versi format.
Tensor Count & Metadata Count: Jumlah tensor dan jumlah pasangan kunci-nilai metadata.
Metadata (Key-Value Pairs): Kunci dengan prefiks panjang string, dan nilai yang diketik.
Tensor Info: Nama setiap tensor, jumlah dimensi, tipe data (FP16, Q4_K, dll.), dan posisi offset di dalam file.
Padding: Padding yang dimasukkan agar data tensor sejajar (aligned) pada batas tertentu (biasanya 32 byte atau 64 byte). Ini penting untuk akses memori cepat dalam instruksi SIMD (khususnya AVX).
Tensor Data: Array data bobot aktual yang telah disejajarkan.

4. Basis Matematis TinyLLaMA dan Algoritma C++

TinyLLaMA menggabungkan beberapa penyempurnaan arsitektur tingkat lanjut untuk efisiensi. Ekspresi matematis untuk mengimplementasikan ini dengan benar dalam C++ dijelaskan di bawah ini.

4.1 RMSNorm (Root Mean Square Normalization)

Ini mengurangi biaya komputasi dengan menghilangkan pemusatan rata-rata dari LayerNorm dan hanya melakukan penskalaan varians.

$$ \text{RMSNorm}(x) = \frac{x}{\sqrt{\frac{1}{d}\sum_{i=1}^{d} x_i^2 + \epsilon}} \odot \gamma $$

$d$ adalah jumlah dimensi, dan $\gamma$ adalah tensor penskalaan yang telah dipelajari. Saat diimplementasikan di C++, ini dioptimalkan dengan terlebih dahulu menghitung jumlah kuadrat array pada kecepatan tinggi menggunakan _mm256_fmadd_ps dari AVX2, dll., dan mengalikannya dengan akar kuadrat terbalik (seperti instruksi _mm256_rsqrt_ps).

4.2 RoPE (Rotary Position Embedding)

Ini adalah teknik yang menerapkan informasi posisi token sebagai rotasi (Rotate) di ruang tensor. Ini dapat dianggap sebagai rotasi pada bidang kompleks, dan rotasi berikut diterapkan ke pasangan dimensi yang berdekatan $(x_1, x_2)$ dari vektor $x$.

$$ \text{RoPE}(x, m) = \begin{pmatrix} x_{1} \cos(m\theta) - x_{2} \sin(m\theta) \\ x_{1} \sin(m\theta) + x_{2} \cos(m\theta) \end{pmatrix} $$

Di sini, $m$ adalah indeks posisi absolut token, dan $\theta$ adalah frekuensi dasar yang dihitung sebelumnya. Dalam ggml, eksekusi paralel dapat dicapai hanya dengan menambahkan operator ggml_rope selama pembangunan grafik inferensi.

4.3 Grouped-Query Attention (GQA)

Dalam Multi-Head Attention (MHA) reguler, terdapat jumlah head yang sama untuk masing-masing Query, Key, dan Value. Namun, TinyLLaMA mengadopsi Grouped-Query Attention (GQA) untuk secara drastis mengurangi bandwidth memori dan konsumsi tembolok KV (KV Cache).

$$ \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{Q K^T}{\sqrt{d_k}}\right) V $$

Di GQA, beberapa head Query berbagi satu head Key/Value. Dalam implementasi C++, perlu melakukan operasi broadcast pada tensor KV agar sesuai dengan jumlah Query sebelum menjalankan perkalian matriks ggml_mul_mat.

4.4 Fungsi Aktivasi SwiGLU

Pada lapisan Feed-Forward Network (FFN), SwiGLU digunakan sebagai pengganti GELU.

$$ \text{SwiGLU}(x) = \text{Swish}(x W_{\text{gate}}) \otimes (x W_{\text{up}}) $$ $$ \text{Swish}(z) = z \cdot \sigma(z) = z \cdot \frac{1}{1 + e^{-z}} $$

Dalam grafik komputasi, ini diekspresikan dengan menggabungkan operator ggml_silu dan ggml_mul.

5. Pembangunan Grafik Komputasi dan Manajemen Memori dengan ggml

ggml mengambil pendekatan “Define-and-Run”, di mana grafik komputasi statis untuk inferensi dibangun dan dievaluasi nanti.

5.1 ggml_context dan Arena Allocator

Fitur ggml yang paling unik adalah “alokasi arena”, yang sama sekali tidak menggunakan alokasi memori dinamis (malloc atau new) dalam putaran inferensi. Area memori (arena) bersebelahan yang besar dialokasikan saat inisialisasi, dan penunjuk area ini dinaikkan nilainya (incremented) setiap kali ggml_new_tensor dll. dipanggil. Ketika satu langkah inferensi selesai, hanya dengan mengatur ulang penunjuk alokasi ke posisi awalnya, alokasi memori untuk langkah inferensi berikutnya selesai secara instan.

5.2 Contoh Konkret Pembangunan Grafik

Untuk setiap langkah inferensi, grafik komputasi berikut dirakit dalam memori.

graph TD A["ID Masukan Token"] --> B["Pencarian Embed"] B --> C["ggml_rms_norm"] C --> D["Proyeksi Q / K / V"] D --> E["Posisi ggml_rope"] E --> F["Simpan Tembolok KV"] E --> G["Muat Tembolok KV"] G --> H["Self Attention"] H --> I["Skala & Softmax"] I --> J["Keluaran Attention"] J --> K["Proyeksi Keluar"] K --> L["Tambah Residual"]

6. Kuantisasi (Quantization) dan Optimisasi Windows / SIMD

Jika Anda menangani TinyLLaMA (1.1B) dalam FP16, Anda membutuhkan sekitar 2,2GB memori, tetapi melalui kuantisasi 4-bit (seperti Q4_K), ini dapat dikompresi secara dramatis menjadi sekitar 600MB.

6.1 Arsitektur Kuantisasi Blok

ggml tidak mengkuantisasi seluruh tensor secara seragam, melainkan dalam satuan “blok”. Dalam format Q4_0, 32 nilai FP16 dikelompokkan ke dalam satu blok.

Faktor Skala: Satu nilai FP16 (2 byte)
Data Terkuantisasi: 32 nilai 4-bit (16 byte) Ini meminimalkan dampak dari outlier lokal.

6.2 Akselerasi Produk Titik dengan AVX2

Saat membangun untuk CPU x86 terbaru di lingkungan Windows, pemrosesan SIMD dilakukan dalam alur berikut, memanfaatkan tanda (flag) kompilator seperti /arch:AVX2.

Muat: Muat data terkuantisasi 4-bit dari memori ke dalam register AVX 256-bit.
Ekspansi dan Buka Paket: Ekspansi nilai 4-bit menjadi Int8 atau Int16 dengan bit mask dan operasi pergeseran (shift).
Dikuantisasi Balik (Dequantization): Kalikan faktor skala untuk mengonversi ke angka floating-point.
Operasi FMA: Jalankan operasi perkalian-penjumlahan secara paralel dengan nilai aktivasi dan _mm256_fmadd_ps (Fused Multiply-Add).

7. Detail Implementasi Tembolok KV (KV Cache)

Dalam generasi auto-regresif, “Tembolok KV” (KV Cache) adalah fitur penting untuk mengabaikan penghitungan Key dan Value dari token masa lalu.

Poin-poin penting saat menerapkan dalam C++ adalah sebagai berikut:

Prapengalokasian Tensor: Inisialisasi tensor yang sangat besar untuk ukuran konteks maksimum (misalnya: 2048 token) untuk tembolok KV (FP16 disarankan).
Salinan Offset: Saat komputasi dilakukan untuk posisi token $N$, simpan vektor K dan V yang diperoleh pada langkah tersebut di baris ke-$N$ dari tensor tembolok KV menggunakan ggml_cpy atau sejenisnya.
Pembuatan Tampilan Saat Attention: Saat menghitung Attention, buat “tampilan” (view) yang hanya menunjuk ke bagian dari token ke-0 hingga ke-$N$ dan teruskan ke perkalian matriks.

8. BPE Tokenizer dan Decoding

String masukan diperlakukan sebagai urutan byte UTF-8 dan dicocokkan dengan kosakata yang telah ditentukan sebelumnya. Di C++, algoritma menggunakan Pohon Trie (Pohon Prefiks) atau antrean prioritas (priority queue) diimplementasikan untuk mempercepat pencarian kosakata.

Dari logit yang dikeluarkan dari LM Head, probabilitas diskalakan menggunakan parameter Temperature, kandidat dipersempit dengan metode ekstraksi Top-K atau Top-P (Nucleus Sampling), dan token berikutnya pada akhirnya ditentukan menggunakan angka acak.

9. Mempersiapkan Proyek C++ (Lingkungan Windows / PowerShell)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


cmake_minimum_required(VERSION 3.14)
project(TinyLLaMACpp)

set(CMAKE_CXX_STANDARD 17)

# Pengaturan Optimisasi dan bendera AVX2 untuk Windows (MSVC)
if(MSVC)
 add_compile_options(/O2 /arch:AVX2 /fp:fast)
 add_link_options(/STACK:8388608)
else()
 add_compile_options(-O3 -march=native -ffast-math)
endif()

add_library(ggml OBJECT ggml/ggml.c ggml/ggml-alloc.c)
target_compile_definitions(ggml PRIVATE GGML_USE_AVX2 GGML_USE_F16C GGML_USE_FMA)

add_executable(main main.cpp)
target_link_libraries(main ggml)

Contoh perintah pembuatan (build) di PowerShell:

1
2
3
4


mkdir build
cd build
cmake .. -G "Visual Studio 17 2022" -A x64
cmake --build . --config Release

10. Kesimpulan

Membangun mesin inferensi dari awal untuk model AI berskala kecil seperti TinyLLaMA menggunakan C++ dan ggml adalah kesempatan bagus untuk mengungkap kotak hitam (black box) pembelajaran mendalam dan mempelajari keindahan kontrol perangkat keras tingkat rendah. Mari kita membuka masa depan Edge AI sambil menikmati sepenuhnya esensi pemrograman sistem, seperti pemuatan zero-copy menggunakan pemetaan memori, optimisasi SIMD, dan pembangunan tembolok KV.

Panduan Menggunakan llama.cpp dan Pengenalan Kustomisasi dengan C++

Fri, 11 Sep 2026 11:00:00 +0900

Dalam beberapa tahun terakhir, evolusi Large Language Models (LLM) sangat luar biasa, dan jangkauan aplikasinya meluas dari hari ke hari. Namun, menjalankan model dengan miliaran atau puluhan miliar parameter di lingkungan lokal biasanya membutuhkan GPU high-end dengan VRAM yang sangat besar. llama.cpp hadir untuk menerobos “dinding perangkat keras” ini, memungkinkan inferensi LLM secara praktis pada PC umum, Mac, dan bahkan perangkat seperti Raspberry Pi.

Pada artikel ini, kita tidak hanya membahas cara menggunakan alat baris perintah (CLI), tetapi juga menjelaskan secara sangat rinci bagi para engineer mengenai arsitektur ggml yang menjadi teknologi dasarnya, latar belakang matematis dari Transformer dan kuantisasi, serta cara menggunakan API C++ untuk mengintegrasikan dan menyesuaikan LLM ke dalam aplikasi Anda sendiri.

1. Ikhtisar llama.cpp dan ggml

llama.cpp adalah mesin inferensi LLM ringan yang ditulis dalam bahasa C/C++, dikembangkan oleh Georgi Gerganov. Awalnya dibuat dengan tujuan agar model LLaMA dari Meta dapat berjalan cepat di Apple Silicon (Mac M1/M2), tetapi kini telah mendukung berbagai arsitektur dan model.

Fitur terbesarnya adalah merupakan implementasi murni C/C++ tanpa dependensi eksternal. Ia tidak membutuhkan ekosistem besar seperti Python atau PyTorch, dan karena dapat dikompilasi menjadi satu file executable, proses deployment menjadi sangat mudah.

Jantung dari llama.cpp ini adalah library komputasi tensor bernama ggml. ggml dirancang dari nol untuk mengoptimalkan operasi matriks dalam machine learning ke batas maksimal di CPU (dan sebagian GPU).

1.1 Mengapa llama.cpp Cepat?

Pemanfaatan Memory Mapping (mmap): Saat memuat bobot (weights) model ke memori, penggunaan mmap dari OS menghindari pemuatan penuh ke RAM, sehingga menghasilkan startup yang cepat dan hemat memori.
Optimasi Ekstensif Instruksi SIMD: Memanfaatkan set instruksi khusus CPU seperti AVX2, AVX-512, ARM NEON, dan Apple AMX untuk sangat mempercepat perkalian matriks.
Kuantisasi (Quantization): Mengompresi bobot floating-point 16-bit (FP16) menjadi bilangan bulat 4-bit, 5-bit, dan 8-bit untuk mengatasi bottleneck pada bandwidth memori (detail lebih lanjut akan dijelaskan nanti).

2. Latar Belakang Matematis: Transformer dan Kuantisasi (Quantization)

Untuk memahami llama.cpp secara mendalam, kita perlu mengetahui rumus matematika yang dihitungnya dan bagaimana komputasi tersebut diaproksimasi.

2.1 Proses Inferensi Transformer

Model seperti LLaMA menggunakan arsitektur Transformer decoder yang bersifat auto-regressive. Inti dari pembuatan teks adalah mekanisme Self-Attention.

Untuk matriks keadaan tersembunyi (hidden state) $X \in \mathbb{R}^{N \times d}$ sebagai input, Query $Q$, Key $K$, dan Value $V$ dihitung dengan perkalian bersama matriks bobot (weights matrix):

$$ Q = X W_Q, \quad K = X W_K, \quad V = X W_V $$

Di sini, keluaran dari Attention didefinisikan sebagai berikut:

$$ \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V $$

Dalam loop inferensi llama.cpp, yang menjadi hambatan (bottleneck) adalah perkalian antara matriks bobot raksasa $W_Q, W_K, W_V$ atau matriks bobot Feed Forward Network (FFN) dengan vektor $X$ (pada fase generasi teks, vektor diproses token demi token sehingga $N=1$), yang juga dikenal sebagai GEMV (General Matrix-Vector Multiplication).

2.2 Dasar Matematis Kuantisasi (Quantization)

Dalam inferensi di mana bandwidth akses memori menjadi hambatan, kuantisasi yang merepresentasikan parameter bobot dengan jumlah bit kecil sangatlah penting. Berikut adalah penjelasan prinsip dasar dari kuantisasi berbasis blok (seperti Q4_K atau Q4_0) yang banyak digunakan di llama.cpp.

Misalkan kita memiliki blok $w = [w_1, w_2, \dots, w_B]$ dengan panjang $B$ (biasanya 32 atau 64) yang merupakan bagian dari matriks bobot FP16 $W$. Blok ini diaproksimasikan menjadi bilangan bulat 4-bit $q_i \in [-8, 7]$ dan sebuah faktor penskalaan (scaling factor) tunggal $\Delta$ (FP16 atau FP32).

$$ w_i \approx \Delta \times q_i $$

Nilai $\Delta$ ditentukan berdasarkan nilai absolut maksimum di dalam blok tersebut:

$$ \Delta = \frac{\max_i |w_i|}{7} $$

Ketika menghitung perkalian titik (dot product) $y = w \cdot x$ menggunakan bobot yang telah dikuantisasi, jika vektor masukan $x$ juga dikuantisasi menjadi $x_i \approx \Delta_x \times q_{x, i}$, maka:

$$ y = \sum_{i=1}^{B} w_i x_i \approx \Delta \Delta_x \sum_{i=1}^{B} q_i q_{x, i} $$

Bagian $\sum q_i q_{x, i}$ ini sepenuhnya merupakan operasi bilangan bulat murni (pure integer arithmetic), yang dapat dikomputasi secara paralel dengan sangat cepat menggunakan instruksi SIMD. Inilah rahasia matematis di balik kecepatan llama.cpp yang luar biasa di CPU.

3. Arsitektur dan Alur Inferensi

Untuk memahami operasi internal llama.cpp, diagram Mermaid berikut menunjukkan arsitektur keseluruhan sistem dan aliran datanya.

graph TD A["Input Pengguna (String)"] --> B["Tokenizer llama.cpp"] B --> C["Token ID (array int32)"] C --> D["Buffer Konteks (KV Cache)"] D --> E["Grafik Komputasi ggml"] E --> F["Lapisan Transformer"] subgraph "Mesin ggml" F --> G["Self-Attention (RoPE)"] G --> H["Jaringan Feed Forward"] H --> F end F --> I["Logits (Ukuran Kosakata)"] I --> J["Sampler (Suhu, Top-K, Top-P)"] J --> K["ID Token Terpilih"] K --> L["Detokenizer llama.cpp"] L --> M["String Output"] K -. "Loop Auto-regressive" .-> D

Generasi teks adalah loop auto-regressive di mana setiap kali satu token dihasilkan, token tersebut ditambahkan ke KV Cache sebagai input berikutnya, lalu melewati grafik komputasi lagi.

4. Pengaturan Lingkungan dan Cara Build

Sebelum mengintegrasikan llama.cpp ke dalam proyek C++, mari kita mulai dengan mem-build kode sumbernya.

4.1 Kloning Repositori

1
2


git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp

4.2 Build Menggunakan CMake

Ketika mengintegrasikannya ke aplikasi lain sebagai proyek C++, menggunakan CMake adalah pendekatan yang paling standar. Anda dapat mempercepat komputasi dengan mengaktifkan akselerator (backend) yang sesuai dengan platform masing-masing.

Hanya CPU (Build Dasar):

1
2
3


mkdir build && cd build
cmake ..
cmake --build . --config Release -j 8

Jika Menggunakan NVIDIA GPU (CUDA):

1
2
3


mkdir build && cd build
cmake .. -DGGML_CUDA=ON
cmake --build . --config Release -j 8

Jika Menggunakan Apple Silicon (Metal):

1
2
3


mkdir build && cd build
cmake .. -DGGML_METAL=ON
cmake --build . --config Release -j 8

Jika proses build berhasil, file eksekusi seperti llama-cli dan pustaka llama (serta pustaka ggml) yang akan di-link melalui API C++ yang dijelaskan nanti, akan dibuat di direktori build/bin/.

5. Pengenalan Kustomisasi dengan C++: Menggunakan API llama.cpp

Mulai dari sini, kita akan membahas topik utama yaitu mengendalikan llama.cpp dari kode C++. Untuk tidak sekadar menggunakan alat baris perintah (CLI), melainkan mengintegrasikan LLM ke dalam aplikasi Anda sendiri (seperti game engine, aplikasi desktop, sistem embedded, dll.), Anda perlu memanggil langsung API C++.

llama.cpp menyediakan antarmuka bahasa C terutama melalui header file bernama llama.h. Antarmuka ini juga digunakan ketika dipanggil dari C++.

5.1 Include dan Pengaturan Minimal yang Diperlukan

Jika Anda menggunakan llama.cpp di proyek Anda sendiri, masukkan pustaka berikut.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include "llama.h"
#include <iostream>
#include <vector>
#include <string>
#include <stdexcept>

// Makro untuk error handling
#define LLAMA_ASSERT(x) \
 do { \
 if (!(x)) { \
 std::cerr << "Assertion failed: " << #x << std::endl; \
 std::terminate(); \
 } \
 } while (0)

5.2 Memuat Model dan Inisialisasi Konteks

Pertama, kita muat file model berformat .gguf dan menyiapkan konteks (ruang memori dan KV Cache) untuk inferensi.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


int main(int argc, char ** argv) {
 if (argc < 2) {
 std::cerr << "Usage: " << argv[0] << " <model.gguf>" << std::endl;
 return 1;
 }
 std::string model_path = argv[1];

 // 1. Inisialisasi backend (Pengaturan lingkungan seperti CPU/GPU)
 llama_backend_init();

 // 2. Mendapatkan pengaturan default parameter model
 llama_model_params model_params = llama_model_default_params();
 model_params.n_gpu_layers = 35; // Jumlah layer yang dialihkan ke GPU

 // 3. Memuat model
 llama_model * model = llama_load_model_from_file(model_path.c_str(), model_params);
 if (model == nullptr) {
 std::cerr << "Failed to load model" << std::endl;
 return 1;
 }

 // 4. Pengaturan parameter konteks
 llama_context_params ctx_params = llama_context_default_params();
 ctx_params.n_ctx = 2048; // Ukuran konteks maksimum (jumlah token)
 ctx_params.n_threads = 8; // Jumlah thread CPU yang digunakan untuk inferensi

 // 5. Membuat konteks
 llama_context * ctx = llama_new_context_with_model(model, ctx_params);
 if (ctx == nullptr) {
 std::cerr << "Failed to create context" << std::endl;
 llama_free_model(model);
 return 1;
 }

 std::cout << "Model and context loaded successfully!" << std::endl;
 // ... Pemrosesan selanjutnya

5.3 Tokenisasi Prompt (Tokenization)

LLM tidak secara langsung memahami teks, melainkan memprosesnya sebagai urutan ID integer (token). String input perlu dikonversi ke token.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


 std::string prompt = "Q: Apa ibu kota Jepang?\nA:";
 std::vector<llama_token> tokens_list;
 tokens_list.resize(prompt.length() + 4); // Ukuran buffer dengan ruang ekstra

 // Apakah akan menambahkan token khusus (seperti BOS: Begin of Sequence) di awal
 bool add_special = true;
 // Mengonversi string menjadi array ID token
 int n_tokens = llama_tokenize(
 model,
 prompt.c_str(),
 prompt.length(),
 tokens_list.data(),
 tokens_list.size(),
 add_special,
 false // parse_special
 );

 if (n_tokens < 0) {
 // Jika buffer tidak cukup, diperlukan proses untuk realokasi dan mencoba ulang (dihilangkan untuk penyederhanaan)
 std::cerr << "Failed to tokenize prompt" << std::endl;
 return 1;
 }
 tokens_list.resize(n_tokens);

5.4 Loop Inferensi dan Sampling

Kita membangun sebuah loop di mana token dimasukkan ke model untuk mendapatkan distribusi probabilitas (Logits) token berikutnya, lalu melakukan sampling dari sana untuk menentukan token selanjutnya.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72


 // Jumlah token maksimum yang dihasilkan
 const int max_gen_tokens = 100;

 // Inisialisasi struktur untuk evaluasi batch
 llama_batch batch = llama_batch_init(512, 0, 1);

 // Menambahkan token prompt ke dalam batch
 for (size_t i = 0; i < tokens_list.size(); i++) {
 llama_batch_add(batch, tokens_list[i], i, { 0 }, false);
 }
 // Diatur agar hanya mengeluarkan logit (hasil prediksi) di token terakhir prompt
 batch.logits[batch.n_tokens - 1] = true;

 // Evaluasi awal (memasukkan prompt ke model)
 if (llama_decode(ctx, batch) != 0) {
 std::cerr << "llama_decode() failed" << std::endl;
 return 1;
 }

 int n_cur = batch.n_tokens; // Panjang konteks saat ini
 int n_decode = 0;

 std::cout << "\nOutput: ";

 // Inisialisasi konteks sampler (Pengaturan Temperature, Top-K, Top-P, dll.)
 llama_sampler * smpl = llama_sampler_chain_init(llama_sampler_chain_default_params());
 llama_sampler_chain_add_top_k(smpl, 40);
 llama_sampler_chain_add_top_p(smpl, 0.9f, 1);
 llama_sampler_chain_add_temp(smpl, 0.7f);
 llama_sampler_chain_add_dist(smpl, 1234); // Nilai seed

 while (n_decode < max_gen_tokens) {
 // 1. Sampling: memprediksi token berikutnya berdasarkan konteks saat ini
 llama_token new_token_id = llama_sampler_sample(smpl, ctx, -1);

 // 2. Jika token adalah EOS (End of Sequence), hentikan loop
 if (llama_token_is_eog(model, new_token_id)) {
 break;
 }

 // 3. Dekode token menjadi string (teks) untuk ditampilkan
 char buf[128];
 int n_chars = llama_token_to_piece(model, new_token_id, buf, sizeof(buf), 0, false);
 if (n_chars > 0) {
 std::cout << std::string(buf, n_chars) << std::flush;
 }

 // 4. Persiapkan token baru yang dihasilkan sebagai batch berikutnya
 llama_batch_clear(batch);
 llama_batch_add(batch, new_token_id, n_cur, { 0 }, true);

 // 5. Evaluasi model (memperbarui KV Cache dan memprediksi selanjutnya)
 if (llama_decode(ctx, batch) != 0) {
 std::cerr << "Failed to evaluate" << std::endl;
 break;
 }

 n_cur += 1;
 n_decode += 1;
 }

 std::cout << std::endl;

 // Bersihkan
 llama_sampler_free(smpl);
 llama_batch_free(batch);
 llama_free(ctx);
 llama_free_model(model);
 llama_backend_free();

 return 0;
}

Kode ini merupakan implementasi dari loop inferensi kustom yang menggunakan API dasar llama.cpp. Kode ini menggunakan struktur llama_batch untuk mengelola sekumpulan token, dan menggunakan llama_decode untuk menjalankan forward pass dari jaringan saraf.

6. Contoh Kustomisasi Lanjutan: Manipulasi Logit dan Kontrol Penalti dengan C++

Jika kita tidak hanya melakukan pembuatan teks sederhana, tetapi ingin memaksakan format output tertentu (seperti hanya JSON), atau mencegah dihasilkannya kata-kata terlarang tertentu, kita bisa secara langsung memanipulasi Logit dari sisi C++ sebelum sampling dilakukan.

Anda bisa mendapatkan array dari skor mentah (nilai sebelum dikonversi menjadi probabilitas) yang dihasilkan model tepat sebelum setiap token dikeluarkan.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// Dapatkan array logit mentah tepat setelah inferensi, sebelum sampling dilakukan
float * logits = llama_get_logits_ith(ctx, batch.n_tokens - 1);
int n_vocab = llama_n_vocab(model);

// Daftar ID token terlarang (sebagai contoh 1234, 5678)
std::vector<llama_token> forbidden_tokens = { 1234, 5678 };

// Mengatur probabilitas kemunculan token terlarang menjadi 0 (Logit menjadi minus tak terhingga)
for (llama_token bad_tok : forbidden_tokens) {
 logits[bad_tok] = -INFINITY;
}

Dengan mengelola API C++ secara langsung, “intervensi berskala mikromilidetik pada setiap siklus inferensi” bisa dilakukan, sesuatu yang mungkin sulit dicapai atau memakan overhead yang terlalu besar jika dilakukan melalui LangChain atau Python.

7. Rahasia Penyetelan Kinerja (Performance Tuning)

Setelah implementasi di C++ selesai, berikut adalah beberapa poin untuk diperiksa guna meningkatkan kecepatan hingga batas maksimal untuk produksi yang sebenarnya.

Optimasi Pemrosesan Batch: Jika Anda memproses permintaan dari beberapa pengguna secara bersamaan, sertakan beberapa sequence dalam llama_batch dan panggil llama_decode sekaligus (Continuous Batching). Hal ini memungkinkan akses memori untuk dibagikan sehingga dapat meningkatkan throughput secara dramatis.
Mengaktifkan Flash Attention: Dengan menetapkan ctx_params.flash_attn = true; pada parameter konteks, komputasi Attention bisa dipercepat sembari mengurangi penggunaan memori. Ini merupakan pengaturan yang diwajibkan bila menangani konteks yang panjang (puluhan ribu token).
Dukungan NUMA: Di lingkungan server multi-socket, konfigurasi NUMA yang tepat sebelum memanggil llama_backend_init() dapat mengurangi latensi dari akses memori.

8. Kesimpulan

Pada artikel ini, kita telah membahas secara mendalam mulai dari latar belakang matematis llama.cpp, penjelasan arsitektur, hingga cara membangun mesin inferensi kustom menggunakan API C++.

Ekosistem Python sangat berguna untuk pembuatan prototype, namun untuk deployment di perangkat edge, integrasi ke dalam game, atau dalam lingkungan produksi yang menuntut pemrosesan secara real-time, pengontrolan langsung llama.cpp berbasis C/C++ menunjukkan kekuatan yang luar biasa.

Kami sangat menyarankan Anda untuk mencoba menulis kode C++ dengan tangan Anda sendiri dan merasakan serunya mengendalikan LLM secara bebas di lingkungan lokal.

Tautan Referensi

Repositori Resmi llama.cpp

ggml - Tensor Library

Attention Is All You Need (Vaswani et al., 2017)