C++ on kenji.blog

पायथन की आवश्यकता नहीं! केवल C++ के साथ AI इन्फेरेंस इंजन का निर्माण

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

1. परिचय: पायथन को छोड़कर केवल C++ से AI इन्फेरेंस इंजन क्यों बनाएं?

आधुनिक AI विकास में, पायथन एक डे-फैक्टो मानक है। PyTorch और TensorFlow जैसे शक्तिशाली फ्रेमवर्क की बदौलत, आप कोड की कुछ पंक्तियों के साथ जटिल न्यूरल नेटवर्क बना, प्रशिक्षित और अनुमान लगा सकते हैं। हालाँकि, इन फ्रेमवर्क के पीछे, C++ और CUDA जैसी निम्न-स्तरीय भाषाएँ भारी गणना प्रसंस्करण को संभालती हैं। पायथन केवल एक “गोंद (glue)” की भूमिका निभाता है।

तो, पायथन को हटाकर केवल C++ के साथ AI इन्फेरेंस इंजन बनाने की क्या आवश्यकता है? इसके कई मजबूत कारण हैं।

अत्यधिक प्रदर्शन और कम लेटेंसी (Extreme Performance and Low Latency): पायथन के GIL (Global Interpreter Lock) और डायनेमिक टाइपिंग के ओवरहेड को पूरी तरह से समाप्त किया जा सकता है। विशेष रूप से उन प्रणालियों में जहां रीयल-टाइम प्रदर्शन आवश्यक है, मिलीसेकंड की देरी भी घातक हो सकती है।
परिनियोजन में आसानी (Ease of Deployment): अंतिम-उपयोगकर्ता के वातावरण में पायथन वातावरण (विशाल लाइब्रेरी, निर्भरताओं का जाल) स्थापित करना बहुत कठिन है। C++ के साथ, आपको केवल एक स्टैटिकली लिंक्ड सिंगल एग्जीक्यूटेबल बाइनरी (.exe या ELF बाइनरी) वितरित करने की आवश्यकता होती है।
एज डिवाइस के लिए समर्थन (Edge Device Support): स्मार्टफोन, एम्बेडेड डिवाइस और रास्पबेरी पाई (Raspberry Pi) जैसे सीमित संसाधनों वाले वातावरण में, कई गीगाबाइट मेमोरी की खपत करने वाले पायथन रनटाइम को चलाने की कोई गुंजाइश नहीं है।
हार्डवेयर का सीधा नियंत्रण (Direct Hardware Control): निम्न-स्तरीय नियंत्रण, जैसे मेमोरी आवंटन का समय, SIMD निर्देशों का स्पष्ट उपयोग, और GPU के साथ मेमोरी ट्रांसफर का अनुकूलन, C++ के साथ संभव है।

इस लेख में, हम Georgi Gerganov द्वारा विकसित “GGML” लाइब्रेरी के आर्किटेक्चर से काफी प्रेरणा लेते हुए, लार्ज लैंग्वेज मॉडल (LLM) आदि को चलाने के लिए स्क्रैच से केवल C++ का उपयोग करके एक इन्फेरेंस इंजन बनाने की प्रक्रिया को तकनीकी गहराई तक जाकर समझाएंगे।

2. इन्फेरेंस इंजन आर्किटेक्चर का समग्र दृष्टिकोण

AI इन्फेरेंस प्रक्रिया, अनिवार्य रूप से, “विशाल मैट्रिक्स गणनाओं की एक श्रृंखला” है। इसे कुशलतापूर्वक निष्पादित करने के लिए, एक इन्फेरेंस इंजन में निम्नलिखित घटक होने चाहिए।

graph TD A["इनपुट डेटा (टोकन/छवियाँ)"] --> B["टेंसर प्रबंधन"] B --> C["कम्प्यूटेशन ग्राफ (DAG)"] C --> D["मेमोरी एरिना और एलोकेटर"] C --> E["शेड्यूलर और थ्रेड पूल"] E --> F["CPU बैकएंड (AVX2/ARM NEON)"] E --> G["GPU बैकएंड (CUDA/Metal)"] F --> H["आउटपुट परिणाम"] G --> H

टेंसर (Tensor) प्रबंधन: बहुआयामी सरणी डेटा संरचना और प्रत्येक आयाम के लिए स्ट्राइड (Stride) का प्रबंधन।
कम्प्यूटेशन ग्राफ (Computation Graph): न्यूरल नेटवर्क की प्रत्येक परत के संचालन को एक निर्देशित चक्रीय ग्राफ (Directed Acyclic Graph - DAG) के रूप में दर्शाना।
मेमोरी एरिना (Memory Arena): गतिशील मेमोरी आवंटन (malloc या new) के ओवरहेड से बचने के लिए एक पूर्व-आवंटित मेमोरी प्रबंधन तंत्र।
बैकएंड (Backend): विशिष्ट हार्डवेयर, जैसे CPU या GPU (कर्नेल) के लिए अनुकूलित संचालन का कार्यान्वयन।

हम इन्हें C++ की शक्तिशाली विशेषताओं (टेम्पलेट, पॉइंटर अरिथमेटिक, RAII, आदि) का उपयोग करके एक साथ जोड़ेंगे।

3. मेमोरी प्रबंधन का रहस्य: मेमोरी एरिना और SIMD अलाइनमेंट

इन्फेरेंस इंजन में मेमोरी प्रबंधन सबसे महत्वपूर्ण कारकों में से एक है जो सीधे प्रदर्शन को प्रभावित करता है। अनुमान के दौरान, विशेष रूप से जब ट्रांसफॉर्मर मॉडल की प्रत्येक परत से गुजरते हैं, तो भारी मात्रा में मध्यवर्ती टेंसर उत्पन्न होते हैं। यदि हर बार इन्हें मानक malloc के साथ आवंटित और मुक्त किया जाता है, तो हीप फ्रैग्मेंटेशन और OS कॉन्टेक्स्ट स्विच के कारण गति में भारी गिरावट आएगी।

इसलिए, हम “मेमोरी एरिना (Memory Arena)” दृष्टिकोण अपनाते हैं। यह एक ऐसी तकनीक है जहां अनुमान की शुरुआत में आवश्यक अधिकतम मेमोरी की गणना (या निर्धारण) की जाती है और एक ही बार में आवंटित की जाती है, और मेमोरी को केवल पॉइंटर को बढ़ाकर (increment) निकाला जाता है।

3.1 अलाइनमेंट का महत्व

आधुनिक CPU, SIMD (Single Instruction, Multiple Data) निर्देशों का समर्थन करते हैं। उदाहरण के लिए Intel/AMD का AVX2/AVX-512 और ARM का NEON। ये निर्देश एक ही बार में 256 बिट्स (32 बाइट्स) या 512 बिट्स (64 बाइट्स) डेटा संसाधित करते हैं, लेकिन संसाधित की जाने वाली डेटा मेमोरी को एक विशिष्ट बाइट सीमा (आमतौर पर 32 बाइट्स या 64 बाइट्स) पर अलाइन (align) होना चाहिए।

नीचे अलाइनमेंट को ध्यान में रखते हुए मेमोरी एरिना का C++ कार्यान्वयन उदाहरण दिया गया है।

 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) {
 // POSIX सिस्टम के लिए posix_memalign, Windows के लिए _aligned_malloc का उपयोग करें
#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) {
 // अलाइनमेंट की गणना (पैडिंग ज्ञात करना)
 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; // मेमोरी मुक्त करने के लिए बस पॉइंटर को रीसेट करें (O(1))
 }
};

इस प्रकार, टेंसर बनाते समय हम हमेशा इस एरिना के माध्यम से मेमोरी प्राप्त करते हैं। अनुमान के प्रत्येक चरण (जैसे प्रत्येक टोकन जनरेशन) के समाप्त होने पर बस reset() कॉल करके, हम तुरंत मेमोरी का पुन: उपयोग कर सकते हैं।

4. टेंसर डेटा संरचना और स्ट्राइड का जादू

टेंसर स्केलर, वेक्टर और मैट्रिक्स की एक सामान्यीकृत अवधारणा है। कार्यान्वयन में जो महत्वपूर्ण है वह यह है कि वास्तविक डेटा को मेमोरी में 1-आयामी सन्निहित सरणी (contiguous array) के रूप में रखा जाता है, जबकि इसे बहुआयामी रूप में व्याख्या करने के लिए “स्ट्राइड (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, // क्वांटिज़ेशन के लिए
 INT4 // क्वांटिज़ेशन के लिए
};

struct Tensor {
 int n_dims; // आयामों की संख्या
 int64_t ne[4]; // प्रत्येक आयाम में तत्वों की संख्या (Number of Elements)
 size_t nb[4]; // प्रत्येक आयाम के लिए स्ट्राइड (Number of Bytes)
 DataType type; // डेटा प्रकार
 void* data; // पेलोड के लिए पॉइंटर

 // कम्प्यूटेशन ग्राफ के लिए
 enum OpType op;
 Tensor* src0;
 Tensor* src1;
};

स्ट्राइड nb[i] आयाम i में आसन्न तत्वों के बीच मेमोरी में बाइट दूरी को दर्शाता है। उदाहरण के लिए, यदि $M \times N$ तत्वों का एक मैट्रिक्स (FP32, 1 तत्व 4 बाइट्स) Row-Major (पंक्ति-प्रमुख) में संग्रहीत किया गया है, तो स्ट्राइड इस प्रकार होगा:

nb[0] = 4 (बाइट्स) : कॉलम दिशा में गति
nb[1] = $N \times 4$ (बाइट्स) : पंक्ति दिशा में गति

इसका उपयोग करके, “ट्रांसपोज़ (Transpose)” और “व्यू (View)” जैसे संचालन, मेमोरी कॉपी के बिना, केवल स्ट्राइड मानों को स्वैप करके प्राप्त किए जा सकते हैं। यह बहुत ही सुरुचिपूर्ण और तेज़ है।

5. कम्प्यूटेशन ग्राफ (DAG) का निर्माण और लेज़ी इवैल्यूएशन

PyTorch आदि के समान, हमारा इन्फेरेंस इंजन भी “Define-by-Run” के करीब एक लेज़ी इवैल्यूएशन (Lazy Evaluation) को अपनाता है। यानी, जब गणितीय फलन को बुलाया जाता है तो गणना नहीं की जाती है, बल्कि केवल ग्राफ (नोड्स के बीच निर्भरता) बनाया जाता है।

 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 अक्सर ट्रांसपोज़ किया हुआ होता है
 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;
}

इन्फेरेंस प्रक्रिया का प्रवाह इस प्रकार है:

graph LR A["टेंसर को परिभाषित करें"] --> B["ऑप्स के माध्यम से ग्राफ बनाएं"] B --> C["टोपोलॉजिकल सॉर्ट"] C --> D["आउटपुट के लिए मेमोरी आवंटित करें"] D --> E["नोड्स को क्रम में निष्पादित करें"]

ग्राफ का मूल्यांकन करते समय (फॉरवर्ड पास), टोपोलॉजिकल सॉर्ट का उपयोग उन नोड्स को संसाधित करने के लिए किया जाता है जिनमें कोई निर्भरता नहीं है। यदि यह केवल इन्फेरेंस के लिए है, तो बैकप्रोपेगेशन के लिए ग्रेडिएंट रखने की आवश्यकता नहीं होती है, इसलिए मेमोरी प्रबंधन बहुत सरल हो जाता है।

6. गणित और अनुकूलन का मूल: मैट्रिक्स गुणन (GEMM)

AI अनुमान के लिए 90% से अधिक कम्प्यूटेशन समय मैट्रिक्स गुणन (GEMM: General Matrix Multiply) पर खर्च होता है। ट्रांसफॉर्मर मॉडल के मूल में अटेंशन मैकेनिज्म और फीडफॉरवर्ड नेटवर्क (FFN) दोनों अंततः विशाल मैट्रिक्स गुणन ही हैं।

2 मैट्रिक्स $A$ (आकार $M \times K$) और $B$ (आकार $K \times N$) का गुणनफल $C = A B$ (आकार $M \times N$) को सूत्र के रूप में इस प्रकार व्यक्त किया जाता है:

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

यदि इसे साधारण ट्रिपल लूप के साथ लागू किया जाता है, तो कैश मिस (cache miss) बार-बार होगा और प्रदर्शन बिल्कुल भी नहीं मिलेगा।

6.1 CPU पर कैश ब्लॉकिंग और SIMD अनुकूलन

CPU पर GEMM को गति देने की बुनियादी रणनीति इस प्रकार है:

लूप टाइलिंग (कैश ब्लॉकिंग): मैट्रिक्स को छोटे ब्लॉकों में विभाजित करें जो गणना के लिए L1/L2 कैश में फिट होते हैं।
डेटा पैकिंग: मेमोरी एक्सेस पैटर्न को सन्निहित (contiguous) बनाने के लिए आंतरिक रूप से डेटा को पुनर्व्यवस्थित करें।
SIMD का उपयोग: AVX-512 में _mm512_fmadd_ps जैसे FMA (Fused Multiply-Add) निर्देशों का उपयोग करके एक ही घड़ी चक्र (clock cycle) में कई गुणा-जोड़ कार्य करें।

नीचे C++ और SIMD इंट्रिंसिक्स का उपयोग करते हुए एक सरलीकृत वेक्टर डॉट उत्पाद (Dot Product) का उदाहरण दिया गया है।

 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> // AVX निर्देशों के लिए

// AVX2 का उपयोग करके FP32 के लिए तेज़ डॉट उत्पाद
float dot_product_avx2(const float* a, const float* b, int n) {
 __m256 sum256 = _mm256_setzero_ps();
 int i = 0;

 // एक बार में 8 तत्वों को संसाधित करें (256 बिट्स = 32 बाइट्स = 8 * 4 बाइट्स)
 for (; i <= n - 8; i += 8) {
 __m256 va = _mm256_loadu_ps(a + i);
 __m256 vb = _mm256_loadu_ps(b + i);
 // FMA निर्देश: sum256 = va * vb + sum256
 sum256 = _mm256_fmadd_ps(va, vb, sum256);
 }

 // SIMD रजिस्टर में मानों का क्षैतिज योग (Horizontal Add)
 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];

 // शेष तत्वों को संभालना
 for (; i < n; ++i) {
 dot += a[i] * b[i];
 }
 return dot;
}

यहां तक कि यह छोटा सा प्रयास भी एक भोले-भाले (naive) कार्यान्वयन की तुलना में गति में कई गुना सुधार कर सकता है।

7. हार्डवेयर बाधाओं को पार करना: CUDA और Metal बैकएंड का एकीकरण

हालाँकि एक शुद्ध C++ कार्यान्वयन CPU पर ठीक-ठाक काम करता है, लेकिन LLM जैसे विशाल मॉडलों को व्यावहारिक गति (उदा. 20 टोकन प्रति सेकंड उत्पन्न करना) से चलाने के लिए, GPU की समानांतर गणना (parallel computing) क्षमता अपरिहार्य है। इसलिए, हम अपने इंजन में बैकएंड एब्स्ट्रैक्शन लेयर पेश करते हैं।

7.1 बैकएंड एब्स्ट्रैक्शन

हम C++ के पॉलीमोर्फिज्म (polymorphism) का उपयोग करते हैं ताकि गणनाओं के निष्पादक (Executor) को स्विच किया जा सके।

 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;

 // विभिन्न परिचालनों का निष्पादन
 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 NVIDIA CUDA बैकएंड का कार्यान्वयन

NVIDIA GPU का लाभ उठाने के लिए, हम CUDA C++ एक्सटेंशन का उपयोग करके बैकएंड लागू करते हैं। यद्यपि अपना स्वयं का कर्नेल लिखना संभव है, लेकिन मैट्रिक्स गुणन के लिए NVIDIA द्वारा प्रदान की गई सर्वोच्च लाइब्रेरी “cuBLAS” का उपयोग करना सबसे अच्छा दृष्टिकोण है।

 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 {
 // CUDA में डिफ़ॉल्ट रूप से Column-Major होता है, इसलिए मापदंडों पर ध्यान दें
 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]; // मानते हुए कि src1 ट्रांसपोज़ किया गया है

 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();
 }
};

CUDA मेमोरी और होस्ट (CPU) मेमोरी के बीच डेटा ट्रांसफर (cudaMemcpy) बहुत भारी (heavy) होता है, इसलिए यह महत्वपूर्ण है कि इन्फेरेंस के दौरान VRAM पर सभी वेट (वजन टेंसर) और मध्यवर्ती टेंसर को यथासंभव बनाए रखा जाए।

7.3 Apple Silicon (Metal) बैकएंड

हाल के वर्षों में, Mac के M1/M2/M3 चिप्स (Apple Silicon) AI इन्फेरेंस मशीन के रूप में उत्कृष्ट हैं। इसका कारण “यूनिफाइड मेमोरी (Unified Memory)” है। चूँकि CPU और GPU एक ही मेमोरी स्पेस साझा करते हैं, ऊपर बताए गए CUDA की तरह PCIe बस पर उच्च-लागत वाले होस्ट-टू-डिवाइस मेमोरी ट्रांसफर की बिल्कुल आवश्यकता नहीं होती है।

C++ से Metal को कॉल करने极, ऑब्जेक्टिव-C++ (.mm फ़ाइलें) को ब्रिज के रूप में उपयोग करें या metal-cpp लाइब्रेरी का उपयोग करें। Metal Compute Shader का उपयोग करके कर्नेल लिखें (जिसे .metal फ़ाइल में C++ की तरह लिखा गया है)।

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


// Metal शेडर (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]; // सरलीकृत
 }
 C[row * n + col] = sum;
 }
}

Apple Silicon वातावरण में, MPS (Metal Performance Shaders) नामक मैट्रिक्स गुणन के लिए एक अनुकूलित लाइब्रेरी भी प्रदान की जाती है, इसलिए उत्पादन में इसका उपयोग करके अद्भुत इन्फेरेंस गति प्राप्त की जा सकती है।

8. ट्रांसफॉर्मर मॉडल विशिष्ट प्रसंस्करण: अटेंशन और KV कैश

LLaMA 2/3 और GPT जैसे अत्याधुनिक LLM ट्रांसफॉर्मर आर्किटेक्चर पर आधारित हैं। C++ में इसे लागू करने के लिए, निम्नलिखित सूत्र द्वारा दर्शाए गए “स्केल्ड डॉट-प्रोडक्ट अटेंशन (Scaled Dot-Product Attention)” का निर्माण आवश्यक है:

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

इसके अलावा, ऑटोरेग्रेसिव (Autoregressive) टोकन जनरेशन में, पिछले टोकन (Key और Value) के गणना परिणामों को बनाए रखना आवश्यक है। इसे “KV कैश (Key-Value Cache)” कहा जाता है।

graph TD T["वर्तमान टोकन"] --> Q["क्वेरी (Query)"] T --> K["कुंजी (Key)"] T --> V["मान (Value)"] K --> KCache["KV कैश में जोड़ें"] V --> VCache["KV कैश में जोड़ें"] Q --> Dot1["Q * K_Cache^T"] KCache --> Dot1 Dot1 --> Scale["स्केल (1/sqrt(d))"] Scale --> Softmax["सॉफ्टमैक्स (Softmax)"] Softmax --> Dot2["SoftmaxOut * V_Cache"] VCache --> Dot2 Dot2 --> Out["संदर्भ वेक्टर (Context Vector)"]

KV कैश मेमोरी का आवंटन भी एक रिंग बफर की तरह काम करता है, जो एरिना में पहले से अधिकतम संदर्भ लंबाई (उदा. 4096 या 8192 टोकन) के लिए मेमोरी स्पेस आरक्षित करता है। यह प्रत्येक जनरेशन चरण में पुनर्आवंटन को रोकता है।

स्थिति एन्कोडिंग (Positional Encoding) के लिए, हम “RoPE (Rotary Position Embedding)” लागू करते हैं, जो हाल के वर्षों में मुख्यधारा बन गया है। यह वह तकनीक है जो जटिल स्थान (complex space) में घूर्णन वैक्टर के रूप में स्थितीय जानकारी को एम्बेड करती है। C++ में sin और cos फ़ंक्शन कॉल (जैसे लुकअप टेबल) का अनुकूलन प्रदर्शन की कुंजी है।

9. मॉडल क्वांटिज़ेशन (Quantization) के माध्यम से चरम अनुकूलन

यदि आप एक बड़े पैमाने के मॉडल (उदाहरण के लिए, 7 बिलियन पैरामीटर वाला LLaMA मॉडल) को FP32 (32-बिट फ्लोटिंग पॉइंट) के रूप में लोड करते हैं, तो यह अकेले वज़न के लिए लगभग 28GB मेमोरी (VRAM) की खपत करता है। यदि आप KV कैश और इन्फेरेंस बफ़र्स को शामिल करते हैं, तो यह आसानी से 30GB से अधिक हो जाता है, जिससे इसे सामान्य उपभोक्ता GPU पर चलाना असंभव हो जाता है।

यहीं पर “क्वांटिज़ेशन (Quantization)” अपरिहार्य हो जाता है। यह GGML प्रारूप का असली मूल्य है।

क्वांटिज़ेशन जानबूझकर वजन की सटीकता को कम करने की तकनीक है।

FP16 (16-बिट): आकार आधा। सटीकता में लगभग कोई गिरावट नहीं।
INT8 (8-बिट): आकार 1/4। मामूली गिरावट।
INT4 (4-बिट): आकार 1/8। अद्वितीय ब्लॉकिंग और स्केलिंग कारकों का उपयोग करके व्यावहारिक इन्फेरेंस संभव है।

इन्फेरेंस इंजन की तरफ से, यह मेमोरी से INT4 (या INT8) में संपीड़ित (compressed) वजन पढ़ता है, और इसे CPU या GPU रजिस्टर में लोड करने के ठीक बाद, गणना करने के लिए इसे FP16 या FP32 (Dequantize) में विस्तारित करता है।

हैरानी की बात है कि मेमोरी से पढ़े जाने वाले डेटा की मात्रा को कम करना, भले ही इससे गणना की मात्रा बढ़ जाए, तेज़ होता है। ऐसा इसलिए है क्योंकि आधुनिक हार्डवेयर में, इन्फेरेंस कार्यों की बाधा (bottleneck) “कंप्यूट बॉउंड (Compute Bound)” नहीं बल्कि “मेमोरी बैंडविड्थ बॉउंड (Memory Bandwidth Bound)” है। INT4 क्वांटिज़ेशन वाले C++ कार्यान्वयन इंजन के साथ, 8GB VRAM वाले MacBook Air पर भी सुचारू रूप से लोकल LLM चलाना संभव है।

10. प्रदर्शन ट्यूनिंग: NUMA आर्किटेक्चर और थ्रेड पूल

CPU का उपयोग करके इन्फेरेंस करते समय, मल्टी-थ्रेडिंग आवश्यक है। हालाँकि, केवल कई std::thread लॉन्च करना इष्टतम नहीं है।

आधुनिक मल्टी-सॉकेट सर्वर और हाई-एंड CPU जैसे Ryzen Threadripper, NUMA (Non-Uniform Memory Access) आर्किटेक्चर को अपनाते हैं। किसी निश्चित CPU कोर से भौतिक रूप से करीब (लोकल मेमोरी) मेमोरी तक पहुंच तेज़ होती है, लेकिन दूसरे प्रोसेसर से जुड़ी मेमोरी तक पहुंच बेहद धीमी होती है।

उन्नत C++ इन्फेरेंस इंजन में निम्नलिखित तकनीकों का उपयोग किया जाता है:

थ्रेड पिनिंग (Thread Pinning): कॉन्टेक्स्ट स्विचिंग के कारण कैश के अमान्य होने को रोकने के लिए प्रत्येक थ्रेड को एक विशिष्ट CPU कोर (एफिनिटी सेट करना) पर पिन करना।
NUMA-अवेयर आवंटन: डेटा को संसाधित करने वाले थ्रेड के समान NUMA नोड पर मेमोरी आवंटित करना।
वर्क-स्टीलिंग थ्रेड पूल: एक कुशल शेड्यूलर लागू करना जो कम्प्यूटेशन ग्राफ के प्रत्येक नोड को छोटे कार्यों में विभाजित करता है, और निष्क्रिय थ्रेड स्वचालित रूप से कार्यों को चुराते और निष्पादित करते हैं।

इनका पूरा उपयोग करके, आप CPU उपयोग को 100% के करीब रख सकते हैं और सैद्धांतिक मान के करीब थ्रूपुट (throughput) प्राप्त कर सकते हैं।

11. निष्कर्ष: C++ की “मांसपेशियों” के साथ AI को चलाने का मज़ा

पायथन निश्चित रूप से सुविधाजनक है। अनुसंधान, विकास और प्रोटोटाइपिंग में, उत्पादकता के मामले में कोई भी भाषा इसके बराबर नहीं है। हालाँकि, जिस क्षण आप पूर्ण किए गए मॉडल को “वास्तविक दुनिया में, कुशलतापूर्वक, किसी भी डिवाइस पर चलाने” के चरण में जाते हैं, C++ का समय आ जाता है।

मेमोरी के बाइट्स में सीधे हेरफेर करना, SIMD निर्देशों के साथ रजिस्टरों को उनकी सीमा तक धकेलना, और GPU की VRAM बैंडविड्थ से जूझते हुए बनाए गए इन्फेरेंस इंजन को कंसोल पर एक के बाद एक प्राकृतिक टेक्स्ट (टोकन) उत्पन्न करते हुए देखने पर जो उपलब्धि की भावना मिलती है, वह पायथन फ्रेमवर्क में model.generate() को कॉल करने पर कभी प्राप्त नहीं हो सकती। यह “एक इंजीनियर के रूप में शुद्ध आनंद” है।

AI तकनीक, जो एक “ब्लैक बॉक्स (Black Box)” बन जाती है, को टेंसर संचालन से लेकर मेमोरी आवंटन तक सब कुछ अपने हाथों से C++ में लिखकर, आप गहराई से समझ सकते हैं कि LLM कैसे “सोचता” है और इसके सही तंत्र क्या हैं।

यदि आपको C++ का बुनियादी ज्ञान है और वर्तमान AI तकनीक में आपकी गहरी रुचि है, तो कृपया अपना खुद का इन्फेरेंस इंजन विकसित करने का प्रयास करें। GGML और llama.cpp का सोर्स कोड सबसे अच्छी जीवित पाठ्यपुस्तकें (living textbooks) होंगी।

तो चलिए, पायथन के भारी रनटाइम को छोड़ दें, और C++ की मांसपेशियों के साथ अत्याधुनिक AI चलाएं!

C++ के साथ छोटे AI मॉडल (जैसे TinyLLaMA) विकसित करने की प्रक्रिया

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

C++ के साथ छोटे AI मॉडल (जैसे TinyLLaMA) विकसित करने की प्रक्रिया

हाल के वर्षों में, स्थानीय वातावरण में बड़े भाषा मॉडल (LLM) चलाने में रुचि तेजी से बढ़ी है। विशेष रूप से, TinyLLaMA (1.1B पैरामीटर) जैसे छोटे मॉडल सीमित संसाधनों वाले एज डिवाइस और सामान्य लैपटॉप (Windows वातावरण सहित) पर भी व्यावहारिक गति से अनुमान लगाने में सक्षम हैं। जहाँ Python और PyTorch का उपयोग करके विकास मुख्यधारा है, वहीं जब अंतिम प्रदर्शन और मेमोरी दक्षता की बात आती है, तो C++ और C-आधारित टेंसर लाइब्रेरी “ggml” का संयोजन वास्तविक मानक बन गया है।

इस लेख में, हम C++ का उपयोग करके TinyLLaMA को लोड करने और पाठ निर्माण के लिए एक अनुमान इंजन को शून्य से बनाने (या मौजूदा llama.cpp की आंतरिक संरचना को गहराई से समझने) के लिए एक बहुत ही विस्तृत विकास प्रक्रिया की व्याख्या करेंगे।

1. C++ और ggml ही क्यों?

AI के प्रशिक्षण चरण में, Python अपने लचीलेपन और समृद्ध इकोसिस्टम के कारण अत्यधिक लाभप्रद है। हालाँकि, परिनियोजन (डिप्लॉयमेंट) या “अनुमान (Inference)” के चरण में, निम्नलिखित कारणों से C++ एक शक्तिशाली विकल्प बन जाता है:

ओवरहेड में कमी: Python के ग्लोबल इंटरप्रेटर लॉक (GIL) और रनटाइम ओवरहेड को पूरी तरह से समाप्त किया जा सकता है।
मेमोरी दक्षता और एरिना एलोकेशन: चूँकि मेमोरी के आवंटन और मुक्ति को मैन्युअल रूप से नियंत्रित किया जा सकता है, इसलिए गार्बेज कलेक्शन के कारण होने वाले अप्रत्याशित स्पाइक्स को रोका जा सकता है।
हार्डवेयर तक सीधी पहुँच: AVX-512, AVX2, और ARM NEON जैसे SIMD इंट्रिंसिक्स (Intrinsics) को सीधे कॉल किया जा सकता है, जिससे CPU की गणना क्षमता को अधिकतम किया जा सकता है।
निर्भरता का उन्मूलन: ggml शून्य-निर्भरता (Zero dependencies) वाली एक C/C++ लाइब्रेरी है, और इसे केवल एक कंपाइलर के साथ Windows पर MSVC वातावरण में भी आसानी से बनाया (बिल्ड किया) जा सकता है।

2. वास्तुकला का समग्र चित्र (आर्किटेक्चर ओवरव्यू)

संपूर्ण अनुमान पाइपलाइन का प्रवाह नीचे दिए गए Mermaid आरेख में दिखाया गया है। यह उपयोगकर्ता के इनपुट पाठ से शुरू होकर अंततः अगले टोकन के उत्पन्न होने तक की एक श्रृंखला है।

graph TD A["उपयोगकर्ता इनपुट पाठ"] --> B["BPE टोकनाइज़र"] B --> C["टोकन आईडी एरे"] C --> D["एम्बेडिंग लेयर लुकअप"] D --> E["ट्रांसफॉर्मर ब्लॉक्स"] E --> F["RMSNorm"] F --> G["LM हेड लेयर"] G --> H["लॉजिट्स एरे"] H --> I["सैंपलर मॉड्यूल"] I --> J["अगला टोकन आईडी"] J --> K["डिटोकनाइज़र"] K --> L["आउटपुट टेक्स्ट चंक"] J -.-> |"संदर्भ में जोड़ें"| C

चूँकि यह एक ऑटो-रिग्रेसिव मॉडल है, इसलिए आउटपुट टोकन को फिर से संदर्भ (कॉन्टेक्स्ट) में जोड़ा जाता है और यह अगले टोकन की भविष्यवाणी के लिए इनपुट के रूप में चक्रित होता है (आरेख में बिंदीदार रेखा वाला भाग)।

3. मॉडल प्रारूप और मेमोरी मैपिंग (mmap)

विशाल न्यूरल नेटवर्क के वेट्स (weights) को संभालने में सबसे बड़ी बाधा डिस्क I/O और मेमोरी की खपत है। C++ कार्यान्वयन में इसे मेमोरी मैपिंग (mmap) से हल किया जाता है।

3.1 मेमोरी मैपिंग का तंत्र और Windows में कार्यान्वयन

mmap का उपयोग करने से, फ़ाइल की सामग्री को सीधे प्रक्रिया के वर्चुअल मेमोरी स्पेस में मैप किया जा सकता है।

ज़ीरो-कॉपी (Zero-copy): डेटा सीधे डिस्क से कर्नेल के पेज कैश में पढ़ा जाता है, जिससे यूज़र स्पेस में कोई अतिरिक्त कॉपी नहीं होती।
ऑन-डिमांड लोड (Page Fault): जब CPU वास्तव में उस मेमोरी एड्रेस तक पहुँचता है, तभी एक पेज फॉल्ट होता है, और केवल आवश्यक चंक (आमतौर पर 4KB) भौतिक मेमोरी में लोड होता है।

Windows वातावरण में, POSIX के mmap के बजाय Win32 API के CreateFileMapping और MapViewOfFile का उपयोग किया जाता है।

sequenceDiagram participant OS["Windows OS"] participant RAM["भौतिक मेमोरी"] participant App["C++ एप्लिकेशन"] App->>OS: "CreateFileMapping / MapViewOfFile" OS-->>App: "वर्चुअल मेमोरी एड्रेस पॉइंटर" App->>App: "पॉइंटर पर टेंसर डेटा पढ़ें" OS->>RAM: "पेज फॉल्ट / डिस्क से पेज लोड करें" RAM-->>App: "SIMD गणना के लिए डेटा तैयार है"

3.2 GGUF प्रारूप की बाइनरी संरचना

Hugging Face जैसे प्लेटफार्मों से .safetensors प्रारूप से परिवर्तित GGUF (GPT-Generated Unified Format) अनुमान के लिए अंतिम प्रारूप है। इसका एक सख्त बाइनरी लेआउट है जैसा कि नीचे दिया गया है:

मैजिक बाइट्स (Magic Bytes): 0x46554747 (GGUF)।
संस्करण (Version): प्रारूप का संस्करण क्रमांक।
टेंसर गणना और मेटाडेटा गणना: टेंसर की संख्या और मेटाडेटा के की-वैल्यू पेयर की संख्या।
मेटाडेटा (Key-Value Pairs): स्ट्रिंग लेंथ प्रीफिक्स के साथ की (Key), और टाइप की गई वैल्यू।
टेंसर इन्फो (Tensor Info): प्रत्येक टेंसर का नाम, आयामों की संख्या, डेटा प्रकार (FP16, Q4_K आदि), और फ़ाइल के भीतर ऑफ़सेट स्थिति।
पैडिंग (Padding): पैडिंग डाली जाती है ताकि टेंसर डेटा एक विशिष्ट सीमा (आमतौर पर 32 बाइट्स या 64 बाइट्स) पर संरेखित (aligned) हो। यह SIMD निर्देशों (विशेष रूप से AVX) में उच्च गति मेमोरी एक्सेस के लिए आवश्यक है।
टेंसर डेटा: संरेखित वास्तविक वेट (weight) डेटा एरे।

4. TinyLLaMA का गणितीय आधार और C++ एल्गोरिदम

TinyLLaMA दक्षता के लिए कई उन्नत आर्किटेक्चरल तकनीकों को शामिल करता है। C++ में इन्हें सही ढंग से लागू करने के लिए हम गणितीय अभिव्यक्तियों की व्याख्या करेंगे।

4.1 RMSNorm (Root Mean Square Normalization)

LayerNorm से माध्य (mean) की सेंटरिंग को हटाकर और केवल वेरिएंस स्केलिंग करके गणना लागत को कम किया जाता है।

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

$d$ आयामों की संख्या है, $\gamma$ सीखा हुआ स्केलिंग टेंसर है। C++ में इसे लागू करते समय, एरे के वर्ग का योग पहले AVX2 के _mm256_fmadd_ps आदि के साथ उच्च गति से गणना किया जाता है, और फिर व्युत्क्रम वर्गमूल (जैसे _mm256_rsqrt_ps निर्देश) से गुणा करके इसे अनुकूलित किया जाता है।

4.2 RoPE (Rotary Position Embedding)

यह एक ऐसी तकनीक है जो टेंसर स्पेस में रोटेशन (Rotate) के रूप में टोकन की स्थितिगत जानकारी लागू करती है। इसे जटिल संख्या तल (complex plane) पर रोटेशन माना जा सकता है, और वेक्टर $x$ के आसन्न आयाम जोड़े $(x_1, x_2)$ पर निम्नलिखित रोटेशन लागू किया जाता है।

$$ \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} $$

यहाँ, $m$ टोकन का पूर्ण स्थिति सूचकांक है, और $\theta$ पूर्व-गणना की गई मूल आवृत्ति है। ggml में, अनुमान ग्राफ के निर्माण के दौरान ggml_rope ऑपरेटर जोड़ने से यह समानांतर रूप से निष्पादित होता है।

4.3 Grouped-Query Attention (GQA)

सामान्य Multi-Head Attention (MHA) में, Query, Key और Value प्रत्येक के लिए समान संख्या में हेड्स होते हैं। हालाँकि, TinyLLaMA मेमोरी बैंडविड्थ और KV कैश खपत को भारी मात्रा में कम करने के लिए Grouped-Query Attention (GQA) का उपयोग करता है।

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

GQA में, कई Query हेड्स एक ही Key/Value हेड साझा shared करते हैं। C++ कार्यान्वयन में, मैट्रिक्स गुणा ggml_mul_mat निष्पादित करने से पहले, Query की संख्या से मेल खाने के लिए KV टेंसर को ब्रॉडकास्ट करने की आवश्यकता होती है।

4.4 SwiGLU एक्टिवेशन फ़ंक्शन

Feed-Forward Network (FFN) लेयर में, GELU के बजाय SwiGLU का उपयोग किया जाता है।

$$ \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}} $$

कम्प्यूटेशन ग्राफ में, इसे ggml_silu ऑपरेटर और ggml_mul के संयोजन से दर्शाया जाता है।

5. ggml के साथ कम्प्यूटेशन ग्राफ का निर्माण और मेमोरी प्रबंधन

ggml “Define-and-Run” दृष्टिकोण अपनाता है, जहाँ यह अनुमान के लिए एक स्थिर कम्प्यूटेशन ग्राफ बनाता है और बाद में उसका मूल्यांकन (evaluate) करता है।

5.1 ggml_context और एरिना एलोकेटर

ggml की सबसे अनूठी विशेषता “एरिना एलोकेशन” है, जो अनुमान लूप के भीतर कोई डायनामिक मेमोरी आवंटन (malloc या new) नहीं करता है। प्रारंभिकरण के दौरान, एक विशाल निरंतर मेमोरी क्षेत्र (एरिना) सुरक्षित किया जाता है, और जब भी ggml_new_tensor आदि को कॉल किया जाता है, तो इस क्षेत्र का पॉइंटर बढ़ा (increment) दिया जाता है। एक अनुमान चरण के पूरा होने के बाद, आवंटन पॉइंटर को प्रारंभिक स्थिति में रीसेट करने से, अगले अनुमान चरण के लिए मेमोरी आवंटन तुरंत पूरा हो जाता है।

5.2 ग्राफ निर्माण का विशिष्ट उदाहरण

प्रत्येक अनुमान चरण के लिए, मेमोरी में निम्नलिखित कम्प्यूटेशन ग्राफ बनाया जाता है।

graph TD A["टोकन इनपुट आईडी"] --> B["एम्बेड लुकअप"] B --> C["ggml_rms_norm"] C --> D["Q / K / V प्रोजेक्शन्स"] D --> E["ggml_rope पोजीशनल"] E --> F["KV कैश स्टोर"] E --> G["KV कैश लोड"] G --> H["सेल्फ अटेंशन"] H --> I["स्केल और सॉफ्टमैक्स"] I --> J["अटेंशन आउटपुट"] J --> K["आउट प्रोजेक्शन"] K --> L["अवशिष्ट जोड़ें (Add Residual)"]

6. क्वांटाइज़ेशन (Quantization) और Windows / SIMD ऑप्टिमाइज़ेशन

TinyLLaMA (1.1B) को FP16 में सँभालने के लिए लगभग 2.2GB मेमोरी की आवश्यकता होती है, लेकिन 4-बिट क्वांटाइज़ेशन (जैसे Q4_K) के साथ इसे नाटकीय रूप से लगभग 600MB तक संपीड़ित किया जा सकता है।

6.1 ब्लॉक क्वांटाइज़ेशन आर्किटेक्चर

ggml पूरे टेंसर को एक साथ क्वांटाइज़ करने के बजाय इसे “ब्लॉक” के आधार पर करता है। Q4_0 प्रारूप में, 32 FP16 मानों को एक ब्लॉक में समूहीकृत किया जाता है।

स्केल फैक्टर: 1 FP16 मान (2 बाइट्स)
क्वांटाइज़्ड डेटा: 32 4-बिट मान (16 बाइट्स) यह स्थानीय आउटलायर्स के प्रभाव को कम करता है।

6.2 AVX2 के साथ डॉट उत्पाद का त्वरण

Windows वातावरण में नवीनतम x86 CPU के लिए बिल्ड करते समय, /arch:AVX2 जैसे कंपाइलर फ्लैग्स का उपयोग करके SIMD प्रोसेसिंग निम्नलिखित प्रवाह में की जाती है:

लोड: मेमोरी से 4-बिट क्वांटाइज़्ड डेटा को 256-बिट AVX रजिस्टर में लोड करना।
विस्तार और अनपैक: बिट मास्क और शिफ्ट ऑपरेशंस का उपयोग करके 4-बिट मानों को Int8 या Int16 में विस्तारित करना।
डीक्वांटाइज़ेशन: फ्लोटिंग पॉइंट में बदलने के लिए स्केल फैक्टर से गुणा करना।
FMA ऑपरेशंस: एक्टिवेशन मानों और _mm256_fmadd_ps (Fused Multiply-Add) के साथ समानांतर में मल्टीप्लाई-ऐड (multiply-add) ऑपरेशंस निष्पादित करना।

7. KV कैश कार्यान्वयन का विवरण

ऑटो-रिग्रेसिव जनरेशन में, पिछले टोकनों के Key और Value की गणना को छोड़ने के लिए “KV कैश” एक आवश्यक विशेषता है।

C++ में इसे लागू करते समय मुख्य बिंदु इस प्रकार हैं:

टेंसर का पूर्व-आवंटन: KV कैश के लिए अधिकतम संदर्भ लंबाई (उदा: 2048 टोकन) के लिए एक विशाल टेंसर को इनिशियलाइज़ किया जाता है (FP16 अनुशंसित है)।
ऑफ़सेट कॉपी: जब टोकन स्थिति $N$ के लिए गणना की जाती है, तो उस चरण पर प्राप्त K और V वेक्टर्स को ggml_cpy आदि का उपयोग करके KV कैश टेंसर की $N$-वीं पंक्ति में स्टोर किया जाता है।
अटेंशन के दौरान व्यू बनाना: अटेंशन की गणना करते समय, एक “व्यू (view)” बनाया जाता है जो केवल 0 से $N$वें टोकन भाग को इंगित करता है और उसे मैट्रिक्स गुणन में पास किया जाता है।

8. BPE टोकनाइज़र और डिकोडिंग

इनपुट स्ट्रिंग को UTF-8 बाइट्स के अनुक्रम के रूप में माना जाता है और पूर्वनिर्धारित शब्दावली के विरुद्ध मिलान किया जाता है। C++ में, शब्दावली खोज को तेज करने के लिए ट्राई ट्री (प्रिफिक्स ट्री) या प्राथमिकता कतारों (priority queues) का उपयोग करने वाले एल्गोरिदम लागू किए जाते हैं।

LM Head से आउटपुट लॉजिट्स (logits) से, संभावितताओं को Temperature पैरामीटर का उपयोग करके स्केल किया जाता है, उम्मीदवारों को Top-K निष्कर्षण या Top-P (न्यूक्लियस सैंपलिंग) विधियों का उपयोग करके कम किया जाता है, और यादृच्छिक संख्याओं का उपयोग करके अंतिम अगला टोकन निर्धारित किया जाता है।

9. C++ प्रोजेक्ट सेट अप करना (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)

# Windows (MSVC) के लिए ऑप्टिमाइज़ेशन और AVX2 फ्लैग की सेटिंग
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)

PowerShell में बिल्ड कमांड का उदाहरण:

1
2
3
4


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

10. निष्कर्ष

C++ और ggml का उपयोग करके TinyLLaMA जैसे छोटे AI मॉडल के लिए शून्य से एक अनुमान इंजन लागू करना डीप लर्निंग के ब्लैक बॉक्स को खोलने और निम्न-स्तरीय हार्डवेयर नियंत्रण की सुंदरता सीखने का एक उत्कृष्ट अवसर है। मेमोरी मैपिंग का उपयोग करके ज़ीरो-कॉपी लोडिंग, SIMD ऑप्टिमाइज़ेशन और KV कैश के निर्माण जैसी सिस्टम प्रोग्रामिंग के सार का आनंद लेते हुए, आइए एज AI के भविष्य का मार्ग प्रशस्त करें।

llama.cpp का उपयोग और C++ में कस्टमाइज़ेशन: एक परिचय

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

हाल के वर्षों में, बड़े भाषा मॉडल (Large Language Models या LLM) का विकास उल्लेखनीय रहा है, और उनके अनुप्रयोग का दायरा हर दिन बढ़ता जा रहा है। हालांकि, अरबों और दसियों अरबों मापदंडों (parameters) वाले मॉडल को स्थानीय वातावरण (local environment) में चलाने के लिए आमतौर पर विशाल VRAM वाले हाई-एंड GPU की आवश्यकता होती है। इस “हार्डवेयर बाधा” को तोड़ते हुए सामान्य PC, Mac और यहां तक कि Raspberry Pi जैसे उपकरणों पर LLM का व्यावहारिक अनुमान (inference) संभव बनाने वाला टूल llama.cpp है।

इस लेख में, हम न केवल कमांड लाइन टूल के उपयोग पर चर्चा करेंगे, बल्कि इसकी मूलभूत तकनीक ggml के आर्किटेक्चर, ट्रांसफॉर्मर और क्वांटाइज़ेशन (Quantization) की गणितीय पृष्ठभूमि, और C++ API का उपयोग करके अपने स्वयं के एप्लिकेशन में LLM को शामिल करने और कस्टमाइज़ करने के तरीकों के बारे में इंजीनियरों के लिए अत्यंत विस्तृत व्याख्या करेंगे।

1. llama.cpp और ggml का अवलोकन

llama.cpp Georgi Gerganov द्वारा विकसित C/C++ में लिखा गया एक हल्का LLM अनुमान इंजन (inference engine) है। यह मूल रूप से Meta के LLaMA मॉडल को Apple Silicon (M1/M2 Mac) पर उच्च गति से चलाने के उद्देश्य से बनाया गया था, लेकिन अब यह विभिन्न आर्किटेक्चर और मॉडलों का समर्थन करता है।

इसकी सबसे बड़ी विशेषता यह है कि यह बाहरी निर्भरता के बिना एक शुद्ध C/C++ कार्यान्वयन (implementation) है। चूंकि इसे Python या PyTorch जैसे विशाल इकोसिस्टम की आवश्यकता नहीं है और इसे एकल निष्पादन योग्य फ़ाइल (single executable file) के रूप में संकलित (compile) किया जा सकता है, इसलिए इसे डिप्लॉय करना बहुत आसान है।

इस llama.cpp का हृदय टेंसर गणितीय लाइब्रेरी ggml है। ggml को मशीन लर्निंग में मैट्रिक्स संचालन को CPU (और कुछ GPU) पर अत्यधिक अनुकूलित (optimize) करने के लिए शून्य से डिज़ाइन किया गया है।

1.1 llama.cpp इतना तेज़ क्यों है?

मेमोरी मैपिंग (mmap) का उपयोग: मॉडल के वज़न (weights) को मेमोरी में लोड करते समय, OS के mmap का उपयोग करके RAM में पूरा लोड करने से बचा जाता है, जिससे तेज़ स्टार्टअप और कम मेमोरी की खपत प्राप्त होती है।
SIMD निर्देशों का संपूर्ण अनुकूलन (Optimization): AVX2, AVX-512, ARM NEON, Apple AMX जैसे CPU-विशिष्ट निर्देश सेट का लाभ उठाकर मैट्रिक्स गुणा को अत्यधिक तेज़ किया गया है।
क्वांटाइज़ेशन (Quantization): 16-बिट फ़्लोटिंग-पॉइंट नंबर (FP16) के वज़न को 4-बिट, 5-बिट, और 8-बिट पूर्णांक (integers) में संकुचित करके मेमोरी बैंडविड्थ की बाधा को समाप्त किया गया है (विवरण नीचे दिया गया है)।

2. गणितीय पृष्ठभूमि: ट्रांसफॉर्मर (Transformer) और क्वांटाइज़ेशन (Quantization)

llama.cpp को गहराई से समझने के लिए, यह जानना आवश्यक है कि यह किन गणितीय सूत्रों (formulas) की गणना कर रहा है और यह गणनाओं का अनुमान कैसे लगाता है।

2.1 ट्रांसफॉर्मर अनुमान प्रक्रिया (Inference Process)

LLaMA जैसे मॉडल ऑटो-रिग्रेसिव (Auto-regressive) ट्रांसफॉर्मर डिकोडर आर्किटेक्चर को अपनाते हैं। टेक्स्ट जनरेशन का मूल Self-Attention तंत्र है।

इनपुट के रूप में छिपी हुई स्थिति (hidden state) के मैट्रिक्स $X \in \mathbb{R}^{N \times d}$ के लिए, क्वेरी $Q$, कुंजी $K$, और वैल्यू $V$ की गणना वज़न मैट्रिक्स (weight matrix) के गुणन से की जाती है।

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

यहाँ, Attention का आउटपुट इस प्रकार परिभाषित किया गया है:

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

llama.cpp के अनुमान लूप (inference loop) में, अड़चन (bottleneck) यह विशाल मैट्रिक्स $W_Q, W_K, W_V$ और फीड-फॉरवर्ड नेटवर्क (FFN) के वज़न मैट्रिक्स और वेक्टर $X$ का गुणन है (क्योंकि जनरेशन चरण में प्रति टोकन संसाधित किया जाता है, $N=1$), यानी GEMV (General Matrix-Vector Multiplication)।

2.2 क्वांटाइज़ेशन (Quantization) का गणितीय आधार

मेमोरी एक्सेस बैंडविड्थ अनुमान (inference) में एक बाधा बन जाती है, इसके लिए वज़न मापदंडों (weight parameters) को छोटे बिट नंबरों में दर्शाने वाला क्वांटाइज़ेशन अनिवार्य है। हम llama.cpp में व्यापक रूप से उपयोग किए जाने वाले ब्लॉक-आधारित क्वांटाइज़ेशन (उदाहरण के लिए Q4_K या Q4_0) के मूल सिद्धांत की व्याख्या करेंगे।

मान लीजिए कि FP16 वज़न मैट्रिक्स $W$ का एक हिस्सा ब्लॉक $w = [w_1, w_2, \dots, w_B]$ है, जिसकी लंबाई $B$ (आमतौर पर 32 या 64) है। यह ब्लॉक 4-बिट पूर्णांक $q_i \in [-8, 7]$ और एकल स्केलिंग फैक्टर $\Delta$ (FP16 या FP32) के अनुमानित रूप में होता है।

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

$\Delta$ का निर्धारण ब्लॉक में अधिकतम पूर्ण मान (absolute value) के आधार पर किया जाता है।

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

क्वांटाइज़्ड वज़न का उपयोग करके डॉट गुणनफल (dot product) $y = w \cdot x$ की गणना करते समय, इनपुट वेक्टर $x$ को भी उसी तरह क्वांटाइज़ करके $x_i \approx \Delta_x \times q_{x, i}$ माना जाता है:

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

यह $\sum q_i q_{x, i}$ भाग शुद्ध पूर्णांक संचालन (pure integer arithmetic) बन जाता है, जिसे SIMD निर्देशों का उपयोग करके बहुत तेज़ी से समानांतर (parallel) रूप में गणना की जा सकती है। यही वह गणितीय रहस्य है जो llama.cpp को CPU पर आश्चर्यजनक गति प्रदान करता है।

3. आर्किटेक्चर और अनुमान प्रवाह (Inference Flow)

llama.cpp के आंतरिक कामकाज को समझने के लिए, नीचे दिया गया Mermaid आरेख (diagram) पूरे सिस्टम के आर्किटेक्चर और डेटा प्रवाह को दर्शाता है।

graph TD A["उपयोगकर्ता इनपुट (स्ट्रिंग)"] --> B["llama.cpp टोकनाइज़र"] B --> C["टोकन IDs (int32 ऐरे)"] C --> D["संदर्भ बफ़र (KV कैश)"] D --> E["ggml गणना ग्राफ"] E --> F["ट्रांसफॉर्मर लेयर्स"] subgraph "ggml इंजन" F --> G["सेल्फ-अटेंशन (RoPE)"] G --> H["फीड फॉरवर्ड नेटवर्क"] H --> F end F --> I["लॉजिट्स (शब्दावली का आकार)"] I --> J["सैम्पलर (टेम्परेचर, Top-K, Top-P)"] J --> K["चयनित टोकन ID"] K --> L["llama.cpp डिटोकनाइज़र"] L --> M["आउटपुट स्ट्रिंग"] K -. "ऑटो-रिग्रेसिव लूप" .-> D

टेक्स्ट जनरेशन एक ऑटो-रिग्रेसिव लूप है जहाँ प्रत्येक नया टोकन आउटपुट होने पर इसे KV Cache में अगले इनपुट के रूप में जोड़ा जाता है और फिर से गणना ग्राफ से गुज़रता है।

4. पर्यावरण सेटअप और बिल्ड विधि

llama.cpp को C++ प्रोजेक्ट में शामिल करने से पहले, आइए सबसे पहले सोर्स कोड को बिल्ड करें।

4.1 रिपॉजिटरी की क्लोनिंग

1
2


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

4.2 CMake का उपयोग करके बिल्ड करना

जब C++ प्रोजेक्ट के रूप में इसे अन्य ऐप्स में शामिल किया जाता है, तो CMake का उपयोग करना सबसे मानक है। प्लेटफ़ॉर्म-विशिष्ट एक्सेलेरेटर (बैकएंड) को सक्षम करके, गणनाओं को तेज़ किया जा सकता है।

केवल CPU (बुनियादी बिल्ड):

1
2
3


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

NVIDIA GPU (CUDA) का उपयोग करते समय:

1
2
3


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

Apple Silicon (Metal) का उपयोग करते समय:

1
2
3


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

यदि बिल्ड सफल होता है, तो build/bin/ निर्देशिका में llama-cli जैसी निष्पादन योग्य फ़ाइलें और बाद में वर्णित C++ API के साथ लिंक करने के लिए llama लाइब्रेरी (और ggml लाइब्रेरी) तैयार हो जाएँगी।

5. C++ में कस्टमाइज़ेशन परिचय: llama.cpp API का उपयोग

यहाँ से हम इस लेख के मुख्य विषय पर चर्चा करेंगे: C++ कोड के माध्यम से llama.cpp का नियंत्रण। केवल कमांड लाइन टूल का उपयोग करने के अलावा, अपने स्वयं के एप्लिकेशन (जैसे गेम इंजन, डेस्कटॉप ऐप, एंबेडेड सिस्टम, आदि) में LLM को शामिल करने के लिए C++ API को सीधे कॉल करना आवश्यक है।

llama.cpp मुख्य रूप से llama.h नामक हेडर फ़ाइल के माध्यम से C भाषा इंटरफ़ेस प्रदान करता है। C++ से कॉल करते समय भी इसी इंटरफ़ेस का उपयोग किया जाता है।

5.1 न्यूनतम आवश्यक इन्क्लूड और सेटिंग्स

अपने प्रोजेक्ट में llama.cpp का उपयोग करते समय, निम्नलिखित शामिल करें:

 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>

// त्रुटि प्रबंधन के लिए मैक्रो
#define LLAMA_ASSERT(x) \
 do { \
 if (!(x)) { \
 std::cerr << "Assertion failed: " << #x << std::endl; \
 std::terminate(); \
 } \
 } while (0)

5.2 मॉडल लोड करना और संदर्भ (Context) इनिशियलाइज़ करना

सबसे पहले, .gguf प्रारूप की मॉडल फ़ाइल लोड करें और अनुमान के लिए संदर्भ (मेमोरी स्पेस और KV कैश) सुरक्षित करें।

 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. बैकएंड का इनिशियलाइज़ेशन (CPU/GPU आदि का पर्यावरण सेटअप)
 llama_backend_init();

 // 2. मॉडल पैरामीटर्स के डिफ़ॉल्ट सेटिंग्स प्राप्त करें
 llama_model_params model_params = llama_model_default_params();
 model_params.n_gpu_layers = 35; // GPU में ऑफ़लोड करने के लिए लेयर्स की संख्या

 // 3. मॉडल को लोड करना
 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. संदर्भ पैरामीटर सेट करना
 llama_context_params ctx_params = llama_context_default_params();
 ctx_params.n_ctx = 2048; // अधिकतम संदर्भ आकार (टोकनों की संख्या)
 ctx_params.n_threads = 8; // अनुमान (inference) के लिए उपयोग किए जाने वाले CPU थ्रेड्स की संख्या

 // 5. संदर्भ (Context) बनाना
 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;
 // ... आगे की प्रक्रिया

5.3 प्रॉम्प्ट का टोकनाइज़ेशन (Tokenization)

LLM टेक्स्ट को सीधे नहीं समझता, बल्कि इसे इंटीजर ID (टोकन) के अनुक्रम के रूप में संसाधित करता है। इनपुट स्ट्रिंग को टोकन में बदलना आवश्यक है।

 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: जापान की राजधानी कहाँ है?\nA:";
 std::vector<llama_token> tokens_list;
 tokens_list.resize(prompt.length() + 4); // अतिरिक्त जगह के साथ बफ़र आकार

 // क्या शुरुआत में विशेष टोकन (BOS: Begin of Sequence आदि) जोड़ना है
 bool add_special = true;
 // स्ट्रिंग को टोकन ID की ऐरे में बदलना
 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) {
 // यदि बफ़र पर्याप्त नहीं है तो पुनः आवंटन (reallocation) करके पुनः प्रयास करना आवश्यक है (सरलता के लिए यहाँ छोड़ा गया है)
 std::cerr << "Failed to tokenize prompt" << std::endl;
 return 1;
 }
 tokens_list.resize(n_tokens);

5.4 अनुमान लूप और सैंपलिंग

टोकन को मॉडल में इनपुट करें, अगले टोकन का संभाव्यता वितरण (Probability Distribution या Logits) प्राप्त करें, और वहां से सैंपलिंग करके अगला टोकन निर्धारित करने वाला लूप बनाएँ।

 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


 // उत्पन्न किए जाने वाले अधिकतम टोकनों की संख्या
 const int max_gen_tokens = 100;

 // बैच मूल्यांकन के लिए संरचना को इनिशियलाइज़ करना
 llama_batch batch = llama_batch_init(512, 0, 1);

 // प्रॉम्प्ट के टोकन को बैच में जोड़ना
 for (size_t i = 0; i < tokens_list.size(); i++) {
 llama_batch_add(batch, tokens_list[i], i, { 0 }, false);
 }
 // केवल प्रॉम्प्ट के अंतिम टोकन पर लॉजिट्स (भविष्यवाणी परिणाम) आउटपुट करने के लिए सेट करें
 batch.logits[batch.n_tokens - 1] = true;

 // पहला मूल्यांकन (प्रॉम्प्ट को मॉडल में फीड करना)
 if (llama_decode(ctx, batch) != 0) {
 std::cerr << "llama_decode() failed" << std::endl;
 return 1;
 }

 int n_cur = batch.n_tokens; // वर्तमान संदर्भ की लंबाई
 int n_decode = 0;

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

 // सैम्पलर संदर्भ का इनिशियलाइज़ेशन (Temperature, Top-K, Top-P आदि की सेटिंग्स)
 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); // सीड वैल्यू

 while (n_decode < max_gen_tokens) {
 // 1. सैंपलिंग: वर्तमान संदर्भ के आधार पर अगले टोकन की भविष्यवाणी
 llama_token new_token_id = llama_sampler_sample(smpl, ctx, -1);

 // 2. यदि टोकन EOS (End of Sequence) है तो लूप समाप्त करें
 if (llama_token_is_eog(model, new_token_id)) {
 break;
 }

 // 3. टोकन को स्ट्रिंग (टेक्स्ट) में डिकोड करें और प्रदर्शित करें
 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. नए उत्पन्न टोकन को अगले बैच के रूप में तैयार करें
 llama_batch_clear(batch);
 llama_batch_add(batch, new_token_id, n_cur, { 0 }, true);

 // 5. मॉडल का मूल्यांकन (KV कैश अपडेट करें, और अगले की भविष्यवाणी करें)
 if (llama_decode(ctx, batch) != 0) {
 std::cerr << "Failed to evaluate" << std::endl;
 break;
 }

 n_cur += 1;
 n_decode += 1;
 }

 std::cout << std::endl;

 // क्लीनअप
 llama_sampler_free(smpl);
 llama_batch_free(batch);
 llama_free(ctx);
 llama_free_model(model);
 llama_backend_free();

 return 0;
}

6. उन्नत कस्टमाइज़ेशन उदाहरण: C++ के माध्यम से लॉजिट्स हेरफेर और पेनाल्टी नियंत्रण

सिर्फ सरल टेक्स्ट जनरेशन तक सीमित न रहकर, जब किसी विशेष प्रारूप (जैसे केवल JSON) में आउटपुट को बाध्य करना हो, या विशिष्ट प्रतिबंधित शब्दों के आउटपुट को रोकना हो, तो सैंपलिंग से पहले के लॉजिट्स (Logits) को सीधे C++ की ओर से नियंत्रित किया जाता है।

आप प्रत्येक टोकन के आउटपुट होने से ठीक पहले रॉ स्कोर की ऐरे (संभाव्यता में परिवर्तित होने से पहले का मान) प्राप्त कर सकते हैं।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// अनुमान के तुरंत बाद, और सैंपलिंग से पहले कच्चे (raw) लॉजिट ऐरे को प्राप्त करना
float * logits = llama_get_logits_ith(ctx, batch.n_tokens - 1);
int n_vocab = llama_n_vocab(model);

// प्रतिबंधित टोकन ID सूची (उदाहरण के लिए 1234, 5678)
std::vector<llama_token> forbidden_tokens = { 1234, 5678 };

// निषिद्ध टोकन की उपस्थिति की संभावना को 0 (Logit को माइनस इन्फिनिटी) पर सेट करना
for (llama_token bad_tok : forbidden_tokens) {
 logits[bad_tok] = -INFINITY;
}

इस तरह, C++ API को सीधे हैंडल करके, “अनुमान चक्र के प्रत्येक माइक्रोसेकंड-स्तर पर हस्तक्षेप” संभव हो जाता है, जो LangChain या Python के माध्यम से प्राप्त करना मुश्किल है या जिसमें अधिक ओवरहेड होता है।

7. परफॉर्मेंस ट्यूनिंग के रहस्य

C++ में कार्यान्वयन समाप्त करने के बाद, वास्तविक संचालन (production) के लिए गति को अधिकतम सीमा तक बढ़ाने के लिए यहां कुछ जांच बिंदु (checkpoints) दिए गए हैं।

बैच प्रोसेसिंग ऑप्टिमाइज़ेशन: कई उपयोगकर्ताओं के अनुरोधों को एक साथ संसाधित करते समय, llama_batch में कई अनुक्रमों को शामिल करें और एक बार में llama_decode को कॉल करें (Continuous Batching)। इससे मेमोरी एक्सेस साझा চরম हो सकता है और थ्रूपुट में काफी सुधार हो सकता है।
फ्लैश अटेंशन (Flash Attention) सक्षम करना: संदर्भ पैरामीटर में ctx_params.flash_attn = true; सेट करके, मेमोरी उपयोग को कम करते हुए अटेंशन गणना को तेज़ किया जा सकता है। लंबे संदर्भ (हजारों टोकन) से निपटने के दौरान यह एक आवश्यक सेटिंग है।
NUMA सपोर्ट: मल्टी-सॉकेट सर्वर वातावरण में llama_backend_init() से पहले NUMA सेटिंग्स को उचित रूप से कॉन्फ़िगर करके मेमोरी एक्सेस लेटेंसी को कम किया जा सकता है।

8. निष्कर्ष

इस लेख में, हमने llama.cpp की गणितीय पृष्ठभूमि से शुरुआत की, इसके आर्किटेक्चर की व्याख्या की, और C++ API का पूरा उपयोग करके कस्टम अनुमान इंजन (custom inference engine) बनाने के तरीके के बारे में विस्तार से बताया।

हालांकि Python इकोसिस्टम प्रोटोटाइपिंग के लिए बहुत सुविधाजनक है, लेकिन एज डिवाइस डिप्लॉयमेंट, गेम्स में एकीकरण (integration), और उत्पादन (production) वातावरण जहां रियल-टाइम प्रोसेसिंग की आवश्यकता होती है, वहां C/C++ आधारित llama.cpp का प्रत्यक्ष नियंत्रण अपना अत्यधिक प्रभाव दिखाता है।

आप भी कृपया स्वयं C++ कोड लिखने का प्रयास करें, और स्थानीय वातावरण (local environment) में LLM को स्वतंत्र रूप से हेरफेर करने के आनंद का अनुभव करें।

संदर्भ लिंक (Reference Links)

llama.cpp Official Repository

ggml - Tensor Library

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