gemma.cpp est une implémentation légère de l'environnement d'exécution d'inférence C++ pur du modèle Gemma.
Pour en savoir plus sur Gemma, consultez la fiche de modèle. Les poids du modèle, y compris les artefacts spécifiques à gemma.cpp, sont disponibles sur Kaggle.
À qui s'adresse ce projet ?
Les moteurs d'inférence LLM modernes sont des systèmes sophistiqués, souvent dotés de fonctionnalités personnalisées qui vont au-delà des environnements d'exécution de réseaux de neurones traditionnels. Cela offre des opportunités de recherche et d'innovation grâce à la coconception d'algorithmes de haut niveau et de calcul de bas niveau. Toutefois, il existe un écart entre les environnements d'exécution d'inférence C++ axés sur le déploiement, qui ne sont pas conçus pour l'expérimentation, et les frameworks de recherche ML axés sur Python, qui abstraient le calcul de bas niveau via la compilation.
gemma.cpp fournit une implémentation minimaliste des modèles Gemma 2B et 7B, en se concentrant sur la simplicité et la simplicité plutôt que sur la généralité complète. Cette approche s'inspire des implémentations de modèles C++ intégrées verticalement, telles que ggml, llama.c et llama.rs.
gemma.cpp cible les cas d'utilisation d'expérimentation et de recherche, en particulier l'exploration de l'espace de conception des algorithmes d'inférence et d'inférence du processeur à l'aide de SIMD portables via la bibliothèque Google Highway. Il est conçu pour être facilement intégré à d'autres projets avec des dépendances minimales et également facilement modifiable avec une petite implémentation de base de 2 ko de code (avec environ 4 ko de code d'utilitaires associés).
Pour les déploiements edge orientés production, nous recommandons les voies de déploiement standards à l'aide de frameworks Python matures tels que JAX, Keras, PyTorch et Transformers (toutes les variantes de modèle ici).
Les contributions de la communauté, qu'elles soient grandes ou petites, sont les bienvenues. Ce projet respecte le 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é les éléments suivants:
- CMake
- Compilateur Clang C++
tarpour extraire des archives depuis Kaggle.
Étape 1: Obtenez les poids du modèle et le tokenizer sur Kaggle
Accédez à la page du modèle Gemma sur Kaggle, puis sélectionnez "Variations du modèle".
La liste déroulante Gemma C++
. On this tab, theVariation` inclut les options suivantes ci-dessous. Notez que les options de poids bfloat16 offrent une fidélité plus élevée, tandis que les poids à virgule flottante à 8 bits permettent une inférence plus rapide.
Modèles 2B avec réglage des instructions (it) et pré-entraînés (pt) :
| Nom du modèle | Description |
|---|---|
2b-it |
Modèle à 2 milliards de paramètres réglé en suivant les instructions, bfloat16 |
2b-it-sfp |
Modèle à 2 milliards de paramètres réglé en suivant les instructions, virgule flottante à 8 bits |
2b-pt |
Modèle pré-entraîné à 2 milliards de paramètres, bfloat16 |
2b-pt-sfp |
Modèle pré-entraîné à 2 milliards de paramètres, virgule flottante à point flottant commuté 8 bits |
Modèles 7B avec réglage des instructions (it) et pré-entraînés (pt) :
| Nom du modèle | Description |
|---|---|
7b-it |
Modèle à 7 milliards de paramètres réglé en suivant les instructions, bfloat16 |
7b-it-sfp |
Modèle à 7 milliards de paramètres réglé en suivant les instructions, virgule flottante à 8 bits |
7b-pt |
Modèle pré-entraîné à 7 milliards de paramètres, bfloat16 |
7b-pt-sfp |
Modèle pré-entraîné à 7 milliards de paramètres, à virgule flottante à point de commutation 8 bits |
REMARQUE: Nous vous recommandons de commencer par 2b-it-sfp pour vous lancer.
Étape 2: Extrayez les fichiers
Une fois le formulaire d'autorisation rempli, le téléchargement doit récupérer un fichier d'archive tar archive.tar.gz. Extrayez les fichiers de archive.tar.gz (cela peut prendre quelques minutes):
tar -xf archive.tar.gz
Cela devrait générer un fichier contenant des poids de modèle tels que 2b-it-sfp.sbs et un fichier de tokenizer (tokenizer.spm). Vous pouvez déplacer ces fichiers vers un emplacement de répertoire pratique (par exemple, le répertoire build/ de ce dépôt).
Étape 3: Compilation
Le système de compilation utilise CMake. Pour créer l'environnement d'exécution d'inférence Gemma, créez un répertoire de compilation et générez 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 l'opération réussit, un exécutable gemma doit maintenant se trouver dans le répertoire build/.
Étape 4: Exécuter
Vous pouvez désormais exécuter gemma à partir du répertoire build/.
gemma inclut 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 poids compressé. | 2b-it-sfp.sbs, etc. (voir ci-dessus) |
--tokenizer |
Nom du fichier du tokenizer. | tokenizer.spm |
gemma est appelé comme suit:
./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 poids compressé
2b-it-sfp.sbs(modèle adapté aux instructions 2 milliards, virgule flottante à commutation 8 bits). - Fichier de tokenizer
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 à la saisie d'une nouvelle ligne.
| Niveau de verbosité | Mode d'utilisation | Détails |
|---|---|---|
--verbosity 0 |
Minimum | Affiche uniquement la sortie de génération. Convient comme outil CLI. |
--verbosity 1 |
Par défaut | Interface utilisateur standard du terminal |
--verbosity 2 |
Détaillé | Affiche des informations supplémentaires pour les développeurs et le débogage. |
Application de terminal interactif
Par défaut, le niveau d'affichage est défini sur 1, ce qui affiche une interface interactive basée sur un terminal lorsque gemma est appelé 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 en tant qu'outil de ligne de commande
Pour utiliser l'exécutable gemma en tant qu'outil de ligne de commande, il peut être utile de créer 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 au tokenizer à partir du téléchargement.
Voici un exemple d'invite gemma avec une entrée tronquée (à l'aide d'un alias 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 la CLI de gemma.cpp est expérimentale et doit tenir compte des limites de longueur de contexte.
Le résultat de la commande ci-dessus devrait ressembler à ceci:
$ 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.