gemma.cpp est un code C++ pur léger Implémentation d'exécution d'inférence du modèle Gemma.
Pour en savoir plus sur Gemma, consultez la fiche du modèle. Les pondérations du modèle, y compris les artefacts spécifiques à gemma.cpp, sont disponibles sur Kaggle
À qui ce projet est-il destiné ?
Les moteurs d'inférence LLM modernes sont des systèmes sophistiqués, souvent avec des API des fonctionnalités s'étendant au-delà des environnements d'exécution des réseaux de neurones traditionnels. Grâce à cette offre des opportunités de recherche et d'innovation grâce à la coconception de et les calculs de bas niveau. Cependant, il existe un écart entre d'inférence C++ orientés déploiement, qui ne sont pas conçus pour l'expérimentation et les frameworks de recherche en ML basés sur Python, qui permettent des calculs de bas niveau via une compilation.
gemma.cpp fournit une implémentation minimaliste des modèles Gemma 2B et 7B, en se concentrant sur la simplicité et la franchise plutôt que sur la généralité complète. C'est inspiré des implémentations de modèles C++ à intégration verticale telles que ggml, llama.c et llama.rs.
gemma.cpp cible des cas d'utilisation de recherche et d'expérimentation, en particulier explorant l'espace de conception des algorithmes d'inférence et d'inférence CPU à l'aide SIMD portable via le réseau Google Highway bibliothèque. Il est conçu pour être facile à intégrer dans d'autres projets avec des dépendances minimales et facilement modifiable grâce à un petit cœur LoC d'environ 2 000 secondes. (ainsi qu'environ 4 000 services d'utilitaires compatibles).
Pour les déploiements en périphérie orientés production, nous recommandons un déploiement standard à l'aide de frameworks Python matures comme JAX, Keras, PyTorch et Transformateurs (toutes les variantes de modèle ici).
Toutes les contributions de la communauté sont les bienvenues. Ce projet suit Règlement de la communauté Open Source de Google.
Guide de démarrage rapide
Pour suivre ce guide de démarrage rapide, vous devez cloner ou télécharger gemma.cpp.
Configuration requise
Avant de commencer, vous devez avoir installé:
- CMake
- Compilateur C++ Clang
tarpour extraire des archives de Kaggle.
Étape 1: Obtenir les pondérations et la fonction de tokenisation du modèle à partir de Kaggle
Consultez la page du modèle gemma sur Kaggle et sélectionnez "Variantes du modèle"
Le menu déroulant
. On this tab, theVariation Gemma C++" inclut les éléments suivants : options ci-dessous. Notez que les options de pondération bfloat16 sont plus fidèles, tandis que celles en 8 bits les pondérations à virgule flottante inversées permettent une inférence plus rapide.
2 milliards de modèles réglés pour l'instruction (it) et pré-entraînés (pt) :
| Nom du modèle | Description |
|---|---|
2b-it |
Modèle réglé par instruction avec 2 milliards de paramètres, bfloat16 |
2b-it-sfp |
Modèle à réglage des instructions avec 2 milliards de paramètres, virgule flottante commutée de 8 bits |
2b-pt |
Modèle pré-entraîné de paramètres à 2 milliards (bfloat16) |
2b-pt-sfp |
Modèle pré-entraîné avec 2 milliards de paramètres, virgule flottante commutée 8 bits |
7 milliards de modèles réglés pour l'instruction (it) et pré-entraînés (pt) :
| Nom du modèle | Description |
|---|---|
7b-it |
Modèle à réglage par instruction avec 7 milliards de paramètres, bfloat16 |
7b-it-sfp |
Modèle à réglage par instruction avec 7 milliards de paramètres, virgule flottante commutée de 8 bits |
7b-pt |
Modèle pré-entraîné de 7 milliards de paramètres, bfloat16 |
7b-pt-sfp |
Modèle pré-entraîné de 7 milliards de paramètres, virgule flottante commutée de 8 bits |
REMARQUE: Nous vous recommandons de commencer par 2b-it-sfp pour être opérationnel.
Étape 2: Extrayez les fichiers
Une fois le formulaire de consentement rempli, le téléchargement devrait récupérer un
fichier d'archive tar archive.tar.gz. Extraire les fichiers de archive.tar.gz (peut
prenez quelques minutes):
tar -xf archive.tar.gz
Vous devriez obtenir un fichier contenant des pondérations de modèle telles que 2b-it-sfp.sbs et
un fichier de tokenisation (tokenizer.spm). Il peut être judicieux de déplacer ces fichiers
l'emplacement pratique du répertoire (par exemple, le répertoire build/ dans ce dépôt).
Étape 3: Compiler
Le système de compilation utilise CMake. Créer l'inférence gemma
créer un répertoire de compilation et générer les fichiers de compilation à l'aide de cmake
à partir du répertoire de projet de premier niveau:
(cd build && cmake ..)
Exécutez ensuite make pour créer l'exécutable ./gemma:
cd build make -j [number of parallel threads to use] gemma
Par exemple, make -j 8 gemma. Si cela fonctionne, vous devez
Exécutable gemma dans le répertoire build/.
Étape 4: Exécuter
Vous pouvez maintenant exécuter gemma à partir du répertoire build/.
gemma comporte les arguments obligatoires suivants:
| Argument | Description | Exemple de valeur |
|---|---|---|
--model |
Type de modèle | 2b-it, 2b-pt, 7b-it, 7b-pt, etc. (voir ci-dessus) |
--compressed_weights |
Fichier de pondérations compressé. | 2b-it-sfp.sbs, ... (voir ci-dessus) |
--tokenizer |
Nom de fichier de la fonction de tokenisation. | tokenizer.spm |
gemma est appelé en tant que:
./gemma \
--tokenizer [tokenizer file] \
--compressed_weights [compressed weights file] \
--model [2b-it or 2b-pt or 7b-it or 7b-pt]
Exemple d'appel pour la configuration suivante:
- Fichier de pondérations compressées
2b-it-sfp.sbs(modèle réglé sur 2 milliards d'instructions, 8 bits à virgule flottante inversée). - Fichier de tokenisation
tokenizer.spm.
./gemma \
--tokenizer tokenizer.spm \
--compressed_weights 2b-it-sfp.sbs \
--model 2b-it
Utilisation
gemma propose différents modes d'utilisation, contrôlés par l'indicateur de verbosité.
Tous les modes d'utilisation sont interactifs et déclenchent la génération de texte au moment de retour à la ligne.
| Niveau de verbosité | Mode d'utilisation | Détails |
|---|---|---|
--verbosity 0 |
Minimum | Imprime uniquement les résultats de génération. Convient comme outil d'interface de ligne de commande. |
--verbosity 1 |
Par défaut | Interface utilisateur de terminal standard visible par l'utilisateur |
--verbosity 2 |
Détaillé | Affiche des informations supplémentaires sur le développeur et le débogage. |
Application de terminal interactive
Par défaut, la verbosité est définie sur 1, ce qui permet d'obtenir
lorsque la méthode gemma est appelée avec les arguments requis:
$ ./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.
...
Utilisation comme outil de ligne de commande
Pour utiliser l'exécutable gemma comme outil de ligne de commande, il peut être utile de
Créez un alias pour gemma.cpp avec des arguments entièrement spécifiés:
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"
Remplacez les chemins d'accès ci-dessus par vos propres chemins d'accès au modèle et à la fonction de tokenisation. à partir du téléchargement.
Voici un exemple de requête gemma avec une entrée tronquée (à l'aide d'un
gemma2b comme défini ci-dessus):
cat configs.h | tail -35 | tr '\n' ' ' | xargs -0 echo "What does this C++ code
do: " | gemma2b
REMARQUE: L'utilisation de gemma.cpp dans la CLI est expérimentale et doit prendre une certaine longueur du contexte leurs limites.
Le résultat de la commande ci-dessus doit se présenter comme suit:
$ 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.