gemma.cpp est une implémentation d'exécution d'inférence C++ pure et légère du modèle Gemma.
Pour en savoir plus sur Gemma, consultez la fiche modèle. Les pondérations des modèles, 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 sur mesure qui s'étendent au-delà des environnements d'exécution de réseaux de neurones traditionnels. Cela s'accompagne d'opportunités de recherche et d'innovation par le biais de la co-conception d'algorithmes de haut niveau et de calculs de bas niveau. Toutefois, il existe un écart entre les environnements d'exécution d'inférence C++ orientés déploiement, qui ne sont pas conçus pour l'expérimentation, et les frameworks de recherche de ML axés sur Python, qui éliminent les calculs de bas niveau grâce à la compilation.
gemma.cpp propose une implémentation minimaliste des modèles Gemma 2B et 7B, en mettant l'accent sur la simplicité et la directivité plutôt que sur la généralisation totale. Il s'inspire des implémentations de modèles C++ à intégration verticale telles que ggml, llama.c et llama.rs.
gemma.cpp cible les cas d'utilisation de l'expérimentation et de la recherche, en particulier l'exploration de l'espace de conception des algorithmes d'inférence CPU et d'inférence utilisant un SIMD portable via la bibliothèque Google Highway. Il est conçu pour être simple à intégrer dans d'autres projets avec un minimum de dépendances. Il est également facile à modifier avec une petite implémentation de base de LoC d'environ 2 000 $ (avec une LoC d'environ 4 000 $ pour les utilitaires compatibles).
Pour les déploiements en périphérie en production, nous recommandons des chemins de déploiement standards utilisant des frameworks Python matures tels que JAX, Keras, PyTorch et Transformers (toutes les variantes de modèles ici).
Les contributions de la communauté, petites ou grandes, 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é:
- CMake
- Compilateur C++ Clang
tarpour extraire des archives de Kaggle.
Étape 1: Obtenir les pondérations du modèle et la fonction de tokenisation auprès de Kaggle
Accédez à la page du modèle Gemma sur Kaggle et sélectionnez "Variantes du modèle".
Le menu déroulant "Variation Gemma C++"
. On this tab, theinclut les options suivantes : Notez que les options de pondérations bfloat16 sont plus fidèles, tandis que les pondérations à virgule flottante commutées sur 8 bits permettent une inférence plus rapide.
2 milliards de modèles avec réglage des instructions (it) et pré-entraînés (pt) :
| Nom du modèle | Description |
|---|---|
2b-it |
Modèle à réglage d'instructions avec 2 milliards de paramètres, bfloat16 |
2b-it-sfp |
Modèle à réglage d'instructions avec 2 milliards de paramètres, virgule flottante commutée 8 bits |
2b-pt |
Modèle pré-entraîné de 2 milliards de paramètres, bfloat16 |
2b-pt-sfp |
Modèle pré-entraîné avec 2 milliards de paramètres, virgule flottante commutée de 8 bits |
7 milliards de modèles réglés au niveau des instructions (it) et pré-entraînés (pt) :
| Nom du modèle | Description |
|---|---|
7b-it |
Modèle à réglage des instructions avec 7 milliards de paramètres, bfloat16 |
7b-it-sfp |
Modèle à réglage d'instructions avec 7 milliards de paramètres, virgule flottante commutée de 8 bits |
7b-pt |
Modèle pré-entraîné avec 7 milliards de paramètres, bfloat16 |
7b-pt-sfp |
Modèle pré-entraîné avec 7 milliards de paramètres, virgule flottante commutée de 8 bits |
REMARQUE: Nous vous recommandons de commencer par 2b-it-sfp pour vous lancer.
Étape 2: Extrayez les fichiers
Une fois le formulaire de consentement rempli, le téléchargement doit continuer à 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 les pondérations du modèle, tel que 2b-it-sfp.sbs, et un fichier de tokenisation (tokenizer.spm). Vous pouvez déplacer ces fichiers vers un emplacement de répertoire pratique (par exemple, le répertoire build/ dans ce dépôt).
Étape 3: Compilez
Le système de compilation utilise CMake. Pour compiler 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 devrait maintenant se trouver dans le répertoire build/.
Étape 4: Exécuter
Vous pouvez maintenant exécuter gemma à partir du répertoire build/.
Les arguments requis suivants sont requis pour gemma:
| 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 tokenisation. | 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 pondérations compressé
2b-it-sfp.sbs(modèle à réglage des instructions 2 milliards, à virgule flottante commutée sur 8 bits). - Fichier Tokenizer
tokenizer.spm.
./gemma \
--tokenizer tokenizer.spm \
--compressed_weights 2b-it-sfp.sbs \
--model 2b-it
Utilisation
gemma comporte 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 lors de la saisie par retour à la ligne.
| Niveau de verbosité | Mode d'utilisation | Détails |
|---|---|---|
--verbosity 0 |
Minimum | Uniquement la sortie de génération des impressions. Convient comme outil d'interface de ligne de commande (CLI). |
--verbosity 1 |
Par défaut | Interface utilisateur standard de terminal 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, le niveau de verbosité est défini sur 1, ce qui affiche une interface interactive basée sur le 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 comme outil de ligne de commande
Pour utiliser l'exécutable gemma comme 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 à la fonction de tokenisation à partir du téléchargement.
Voici un exemple de requête gemma avec une entrée tronquée (en utilisant 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 gemma.cpp est expérimentale et doit tenir compte des limites de longueur du contexte.
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.