gemma.cpp आसान C++ है Gemma मॉडल के अनुमान रनटाइम को लागू करना.
Gemma के बारे में ज़्यादा जानकारी के लिए, मॉडल कार्ड देखें. मॉडल का वेट, gemma.cpp से जुड़े खास आर्टफ़ैक्ट के साथ यहां उपलब्ध है Kaggle.
यह प्रोजेक्ट किसके लिए है?
आधुनिक एलएलएम अनुमान इंजन, बेहतरीन सिस्टम होते हैं. इनमें अक्सर लोगों की पसंद के हिसाब से अनुमान लगाने की सुविधा होती है जिसमें सामान्य न्यूरल नेटवर्क रनटाइम से ज़्यादा सुविधाएं शामिल हैं. इसके साथ साथ मिलकर डिज़ाइन करने से, रिसर्च और इनोवेशन के अवसर मिलते हैं एल्गोरिदम और लो-लेवल कंप्यूटेशन की सेवा का इस्तेमाल करें. हालांकि, डाइग्नोस्टिक टूल की मदद से डिप्लॉयमेंट-ओरिएंटेड C++ के अनुमान रनटाइम, जिन्हें इनके लिए नहीं बनाया गया है: एक्सपेरिमेंट के तौर पर उपलब्ध कराया गया है. साथ ही, Python पर आधारित ML रिसर्च फ़्रेमवर्क के बारे में भी बताया गया है. कंपाइलेशन के ज़रिए लो-लेवल कंप्यूटेशन की सेवा.
gemma.cpp, Gemma 2B और 7B मॉडल को कम से कम लागू करता है, सामान्यता के बजाय, सादगी और सीधे तौर पर काम करने पर फ़ोकस करना. यह है ये मॉडल, वर्टिकल तौर पर इंटिग्रेट किए गए C++ मॉडल को लागू करते हैं ggml, llama.c, और llama.rs.
gemma.cpp प्रयोग तथा शोध उपयोग के मामलों को लक्षित करता है – विशेष रूप से, हम सीपीयू के अनुमान और अनुमान एल्गोरिदम के डिज़ाइन स्पेस को Google हाइवे के किनारे बना पोर्टेबल सिमडी लाइब्रेरी. इसे इस तरह से डिज़ाइन किया गया है कि लोग आसानी से दूसरे प्रोजेक्ट में जुड़ सकें कम से कम डिपेंडेंसी. साथ ही, छोटे ~2K लॉसी कोर की मदद से, इसमें आसानी से बदलाव किया जा सकता है लागू करना (साथ में काम करने वाली सुविधाओं के ~4K LoC के साथ).
हमारा सुझाव है कि प्रोडक्शन के हिसाब से काम के डिप्लॉयमेंट के लिए स्टैंडर्ड डिप्लॉयमेंट का इस्तेमाल करें JAX, Keras, PyTorch, और अन्य Python फ़्रेमवर्क का इस्तेमाल करने वाले पाथवे ट्रांसफ़ॉर्मर (सभी मॉडल वैरिएशन यहां देखें).
बड़े और छोटे समुदाय के योगदानों का स्वागत है. यह प्रोजेक्ट इस तरह से बनाया गया है Google के ओपन सोर्स कम्यूनिटी दिशा-निर्देश.
क्विकस्टार्ट
इस क्विकस्टार्ट को पूरा करने के लिए, आपको क्लोन करना होगा या डाउनलोड करना होगा gemma.cpp.
सिस्टम की ज़रूरतें
शुरू करने से पहले, आपको इन्हें इंस्टॉल करना चाहिए:
- CMake
- Clang C++ कंपाइलर
- Kaggle से संग्रह निकालने के लिए
tar.
पहला चरण: Kaggle से मॉडल का वेट और टोकनाइज़र हासिल करना
जेमा मॉडल पेज Kaggle और `मॉडल वैरिएशन' चुनें
Gemma C++
. On this tab, theविविधता` ड्रॉप-डाउन में ये शामिल हैं विकल्प देखें. नोट bfloat16 मोटाई के विकल्प उच्च फ़िडेलिटी, जबकि 8-बिट वाले हैं स्विच किए गए फ़्लोटिंग पॉइंट वेट का इस्तेमाल करके, तेज़ी से अनुमान लगाने की सुविधा चालू की जा सकती है.
निर्देश के मुताबिक 2B (it) और पहले से ट्रेन किए गए (pt) मॉडल:
| मॉडल का नाम | ब्यौरा |
|---|---|
2b-it |
2 अरब पैरामीटर के निर्देश वाला मॉडल, bfloat16 |
2b-it-sfp |
8-बिट स्विच किया गया फ़्लोटिंग पॉइंट वाला, 2 अरब पैरामीटर के निर्देश वाला मॉडल |
2b-pt |
2 अरब पैरामीटर का प्री-ट्रेन्ड मॉडल, bfloat16 |
2b-pt-sfp |
8-बिट स्विच किया गया फ़्लोटिंग पॉइंट वाला, 2 अरब पैरामीटर का प्री-ट्रेन किया गया मॉडल |
निर्देश के मुताबिक 7B (it) और पहले से ट्रेन किए गए (pt) मॉडल:
| मॉडल का नाम | ब्यौरा |
|---|---|
7b-it |
7 अरब पैरामीटर के लिए निर्देश देने वाला मॉडल, bfloat16 |
7b-it-sfp |
8-बिट स्विच किया गया फ़्लोटिंग पॉइंट वाला, 7 अरब पैरामीटर के निर्देश वाला मॉडल |
7b-pt |
7 अरब पैरामीटर का प्री-ट्रेन्ड मॉडल, bfloat16 |
7b-pt-sfp |
8-बिट स्विच किया गया फ़्लोटिंग पॉइंट वाला, 7 अरब पैरामीटर का पहले से ट्रेन किया गया मॉडल |
ध्यान दें: हमारा सुझाव है कि आप शुरुआत करने और इसका इस्तेमाल करने के लिए, 2b-it-sfp से शुरू करें.
दूसरा चरण: फ़ाइलें निकालना
सहमति फ़ॉर्म भरने के बाद, डाउनलोड की प्रोसेस के ज़रिए
टार संग्रह फ़ाइल archive.tar.gz. archive.tar.gz से फ़ाइलें निकालें (यह ये काम कर सकता है
थोड़ा समय लें):
tar -xf archive.tar.gz
इससे एक ऐसी फ़ाइल बनेगी जिसमें मॉडल के वज़न की जानकारी होगी, जैसे कि 2b-it-sfp.sbs और
टोकनाइज़र फ़ाइल (tokenizer.spm) मौजूद होनी चाहिए. हो सकता है कि आप इन फ़ाइलों को
सुविधाजनक डायरेक्ट्री लोकेशन (उदाहरण के लिए, इस रेपो में मौजूद बिल्ड/ डायरेक्ट्री).
चरण 3: बनाएं
बिल्ड सिस्टम CMake का इस्तेमाल करता है. जेमा अनुमान बनाने के लिए
रनटाइम, बिल्ड डायरेक्ट्री बनाएं और cmake का इस्तेमाल करके बिल्ड फ़ाइलें जनरेट करें
टॉप लेवल प्रोजेक्ट डायरेक्ट्री से:
(cd build && cmake ..)
इसके बाद, ./gemma की एक्ज़ीक्यूटेबल फ़ाइल बनाने के लिए make चलाएं:
cd build make -j [number of parallel threads to use] gemma
उदाहरण के लिए, make -j 8 gemma. अगर यह प्रोसेस पूरी होती है, तो अब आपके पास
gemma को build/ डायरेक्ट्री में एक्ज़ीक्यूट किया जा सकता है.
चरण 4: चलाएं
अब आप build/ डायरेक्ट्री के अंदर से gemma को चला सकते हैं.
gemma में ये ज़रूरी आर्ग्युमेंट मौजूद हैं:
| आर्ग्यूमेंट | ब्यौरा | उदाहरण के तौर पर दी गई वैल्यू |
|---|---|---|
--model |
मॉडल टाइप. | 2b-it, 2b-pt, 7b-it, 7b-pt, ... (ऊपर देखें) |
--compressed_weights |
कंप्रेस की गई वज़न वाली फ़ाइल. | 2b-it-sfp.sbs, ... (ऊपर देखें) |
--tokenizer |
टोकनाइज़र का फ़ाइल नाम. | tokenizer.spm |
gemma को इस तरह शुरू किया गया है:
./gemma \
--tokenizer [tokenizer file] \
--compressed_weights [compressed weights file] \
--model [2b-it or 2b-pt or 7b-it or 7b-pt]
नीचे दिए गए कॉन्फ़िगरेशन के लिए शुरू करने का उदाहरण:
- कंप्रेस की गई वेट फ़ाइल
2b-it-sfp.sbs(2B निर्देशों के मुताबिक मॉडल, 8-बिट फ़्लोटिंग पॉइंट स्विच किया गया). - टोकनाइज़र फ़ाइल
tokenizer.spm.
./gemma \
--tokenizer tokenizer.spm \
--compressed_weights 2b-it-sfp.sbs \
--model 2b-it
इस्तेमाल
gemma में इस्तेमाल करने के अलग-अलग मोड हैं, जिन्हें 'कितने शब्दों में जानकारी दी जाए' फ़्लैग से कंट्रोल किया जाता है.
इस्तेमाल के सभी मोड इंटरैक्टिव हैं. इनसे टेक्स्ट जनरेट करने की सुविधा मिलती है न्यूलाइन इनपुट.
| कितने शब्दों में जानकारी दी जाए | इस्तेमाल मोड | ब्यौरा |
|---|---|---|
--verbosity 0 |
मिनिमल | यह सिर्फ़ आउटपुट को प्रिंट करता है. सीएलआई टूल के तौर पर इस्तेमाल किया जा सकता है. |
--verbosity 1 |
डिफ़ॉल्ट | उपयोगकर्ताओं को दिखने वाला स्टैंडर्ड यूज़र इंटरफ़ेस (यूआई). |
--verbosity 2 |
विस्तृत | डेवलपर और डीबग की अतिरिक्त जानकारी दिखाता है. |
इंटरैक्टिव टर्मिनल ऐप्लिकेशन
'कितने शब्दों में जानकारी दी जाए' सेटिंग, डिफ़ॉल्ट रूप से 1 पर सेट होती है. इससे टर्मिनल पर आधारित इंटरैक्टिव एलिमेंट बन जाता है
इंटरफ़ेस जब gemma को ज़रूरी आर्ग्युमेंट के साथ शुरू किया जाए:
$ ./gemma [...]
__ _ ___ _ __ ___ _ __ ___ __ _ ___ _ __ _ __
/ _` |/ _ \ '_ ` _ \| '_ ` _ \ / _` | / __| '_ \| '_ \
| (_| | __/ | | | | | | | | | | (_| || (__| |_) | |_) |
\__, |\___|_| |_| |_|_| |_| |_|\__,_(_)___| .__/| .__/
__/ | | | | |
|___/ |_| |_|
tokenizer : tokenizer.spm
compressed_weights : 2b-it-sfp.sbs
model : 2b-it
weights : [no path specified]
max_tokens : 3072
max_generated_tokens : 2048
*Usage*
Enter an instruction and press enter (%Q quits).
*Examples*
- Write an email to grandma thanking her for the cookies.
- What are some historical attractions to visit around Massachusetts?
- Compute the nth fibonacci number in javascript.
- Write a standup comedy bit about WebGPU programming.
> What are some outdoorsy places to visit around Boston?
[ Reading prompt ] .....................
**Boston Harbor and Islands:**
* **Boston Harbor Islands National and State Park:** Explore pristine beaches, wildlife, and maritime history.
* **Charles River Esplanade:** Enjoy scenic views of the harbor and city skyline.
* **Boston Harbor Cruise Company:** Take a relaxing harbor cruise and admire the city from a different perspective.
* **Seaport Village:** Visit a charming waterfront area with shops, restaurants, and a seaport museum.
**Forest and Nature:**
* **Forest Park:** Hike through a scenic forest with diverse wildlife.
* **Quabbin Reservoir:** Enjoy boating, fishing, and hiking in a scenic setting.
* **Mount Forest:** Explore a mountain with breathtaking views of the city and surrounding landscape.
...
कमांड लाइन टूल के तौर पर इस्तेमाल
एक्ज़ीक्यूटेबल gemma को कमांड-लाइन टूल के तौर पर इस्तेमाल करने के लिए, यह
पूरी तरह से तय आर्ग्युमेंट के साथ gemma.cpp के लिए उपनाम बनाएं:
alias gemma2b="~/gemma.cpp/build/gemma -- --tokenizer
~/gemma.cpp/build/tokenizer.spm --compressed_weights
~/gemma.cpp/build/2b-it-sfp.sbs --model 2b-it --verbosity 0"
ऊपर दिए गए पाथ को अपने पाथ से बदलकर मॉडल और टोकनाइज़र पाथ करें से हटा दिया गया है.
यहां छोटे किए गए इनपुट के साथ gemma को प्रॉम्प्ट भेजने का उदाहरण दिया गया है (इसका इस्तेमाल करके
gemma2b उपनाम, जैसा कि ऊपर बताया गया है):
cat configs.h | tail -35 | tr '\n' ' ' | xargs -0 echo "What does this C++ code
do: " | gemma2b
ध्यान दें: gemma.cpp को सीएलआई के तौर पर इस्तेमाल करना अभी प्रयोग के तौर पर शुरू हुआ है और इसे इस्तेमाल, कॉन्टेक्स्ट के हिसाब से किया जाना चाहिए सीमित कर दिया जाता है.
ऊपर दिए गए निर्देश का आउटपुट ऐसा दिखना चाहिए:
$ cat configs.h | tail -35 | tr '\n' ' ' | xargs -0 echo "What does this C++ code do: " | gemma2b
[ Reading prompt ] ......................................................................................................................................................................................................................................................................................................................................................................................................................................................................................
The code defines two C++ structs, `ConfigGemma7B` and `ConfigGemma2B`, which are used for configuring a deep learning model.
**ConfigGemma7B**:
* `seq_len`: Stores the length of the sequence to be processed. It's set to 7168.
* `vocab_size`: Stores the size of the vocabulary, which is 256128.
* `n_layers`: Number of layers in the deep learning model. It's set to 28.
* `dim_model`: Dimension of the model's internal representation. It's set to 3072.
* `dim_ffw_hidden`: Dimension of the feedforward and recurrent layers' hidden representations. It's set to 16 * 3072 / 2.
**ConfigGemma2B**:
* `seq_len`: Stores the length of the sequence to be processed. It's also set to 7168.
* `vocab_size`: Size of the vocabulary, which is 256128.
* `n_layers`: Number of layers in the deep learning model. It's set to 18.
* `dim_model`: Dimension of the model's internal representation. It's set to 2048.
* `dim_ffw_hidden`: Dimension of the feedforward and recurrent layers' hidden representations. It's set to 16 * 2048 / 2.
These structs are used to configure a deep learning model with specific parameters for either Gemma7B or Gemma2B architecture.