gemma.cpp è un file C++ puro e leggero del runtime di inferenza del modello Gemma.
Per ulteriori informazioni su Gemma, consulta la scheda del modello. I pesi del modello, inclusi gli artefatti specifici di gemma.cpp, sono disponibili Kaggle.
A chi è destinato questo progetto?
I moderni motori di inferenza LLM sono sistemi sofisticati, spesso con modelli oltre ai tradizionali runtime delle reti neurali. Con questo offre opportunità di ricerca e innovazione attraverso la co-progettazione di e calcolo di basso livello. Tuttavia, esiste un divario tra runtime di inferenza C++ orientati al deployment, che non sono progettati per sperimentazione e framework di ricerca ML incentrati su Python, che astraggono di basso livello mediante compilazione.
gemma.cpp offre un'implementazione minimalista dei modelli Gemma 2B e 7B, concentrandosi sulla semplicità e sull'immediatezza piuttosto che sulla generalità completa. Questo è ispirate alle implementazioni dei modelli C++ integrati verticalmente, come ggml, llama.c e llama.rs.
gemma.cpp si concentra sui casi d'uso di sperimentazione e ricerca, in particolare esplorare lo spazio di progettazione degli algoritmi di inferenza e inferenza della CPU utilizzando SIMD portatile tramite la autostrada Google libreria. È pensato per essere semplice da incorporare in altri progetti con con dipendenze minime, ma anche facilmente modificabile con un piccolo core LoC di circa 2000 passi dell'implementazione (oltre a circa 4000 LoC delle utenze di supporto).
Per deployment a livello perimetrale orientati alla produzione, consigliamo il deployment standard utilizzando framework Python maturi come JAX, Keras, PyTorch e Trasformatori (tutte le varianti del modello qui).
Sono ben accetti contributi della community, grandi e piccoli. Questo progetto segue Norme della community open source di Google.
Guida rapida
Per completare questa guida rapida, devi clonare o scaricare gemma.cpp.
Requisiti di sistema
Prima di iniziare, devi aver installato:
- CMake
- Compilatore Clang C++
tarper l'estrazione di archivi da Kaggle.
Passaggio 1: recupera i pesi del modello e il tokenizzatore da Kaggle
Visita la pagina del modello gemma su Kaggle e seleziona "Varianti del modello".
Il menu a discesa Variante C++
. On this tab, thedi Gemma' include quanto segue opzioni riportate di seguito. Nota: le opzioni dei pesi bfloat16 hanno una fedeltà maggiore, mentre le le ponderazioni in virgola mobile scambiate consentono un'inferenza più rapida.
2 miliardi di modelli ottimizzati per le istruzioni (it) e preaddestrati (pt):
| Nome modello | Descrizione |
|---|---|
2b-it |
Modello ottimizzato per l'istruzione con 2 miliardi di parametri, bfloat16 |
2b-it-sfp |
Modello ottimizzato per l'istruzione da 2 miliardi di parametri, 8 bit con commutazione in virgola mobile |
2b-pt |
Modello preaddestrato con 2 miliardi di parametri, bfloat16 |
2b-pt-sfp |
Modello preaddestrato con 2 miliardi di parametri, rappresentazione in virgola mobile a 8 bit |
7 miliardi di modelli ottimizzati per l'istruzione (it) e preaddestrati (pt):
| Nome modello | Descrizione |
|---|---|
7b-it |
Modello ottimizzato per l'istruzione con 7 miliardi di parametri, bfloat16 |
7b-it-sfp |
Modello ottimizzato per l'istruzione di 7 miliardi di parametri, 8 bit con commutazione in virgola mobile |
7b-pt |
Modello preaddestrato con 7 miliardi di parametri, bfloat16 |
7b-pt-sfp |
Modello preaddestrato con 7 miliardi di parametri, rappresentazione in virgola mobile a 8 bit |
NOTA: per iniziare, consigliamo di iniziare con 2b-it-sfp.
Passaggio 2: estrai i file
Dopo aver compilato il modulo di consenso, il download dovrebbe procedere per recuperare un
file di archivio tar archive.tar.gz. Estrai file da archive.tar.gz (puoi eseguire questa operazione
richiede qualche minuto):
tar -xf archive.tar.gz
Dovrebbe essere restituito un file contenente i pesi del modello, come 2b-it-sfp.sbs e
un file tokenizzatore (tokenizer.spm). Ti consigliamo di spostare questi file in un
comoda posizione della directory (ad es. la directory build/ in questo repository).
Passaggio 3. Creazione
Il sistema di compilazione utilizza CMake. Per creare l'inferenza gemma
runtime, crea una directory di build e genera i file di build utilizzando cmake
dalla directory del progetto di primo livello:
(cd build && cmake ..)
Poi esegui make per creare l'eseguibile ./gemma:
cd build make -j [number of parallel threads to use] gemma
Ad esempio, make -j 8 gemma. Se l'operazione riesce, ora dovresti avere
Eseguibile gemma nella directory build/.
Passaggio 4: esegui
Ora puoi eseguire gemma dalla directory build/.
gemma ha i seguenti argomenti obbligatori:
| Argomento | Descrizione | Valore di esempio |
|---|---|---|
--model |
Il tipo di modello. | 2b-it, 2b-pt, 7b-it, 7b-pt, ... (vedi sopra) |
--compressed_weights |
Il file dei pesi compresso. | 2b-it-sfp.sbs, ... (vedi sopra) |
--tokenizer |
Il nome file del tokenizzatore. | tokenizer.spm |
gemma è richiamato come:
./gemma \
--tokenizer [tokenizer file] \
--compressed_weights [compressed weights file] \
--model [2b-it or 2b-pt or 7b-it or 7b-pt]
Esempio di chiamata per la seguente configurazione:
- File dei pesi compressi
2b-it-sfp.sbs(modello ottimizzato per le istruzioni da 2 miliardi, a 8 bit rappresentazione in virgola mobile scambiata). - File tokenizzatore
tokenizer.spm.
./gemma \
--tokenizer tokenizer.spm \
--compressed_weights 2b-it-sfp.sbs \
--model 2b-it
Utilizzo
gemma prevede diverse modalità di utilizzo, controllate dal flag di livello di dettaglio.
Tutte le modalità di utilizzo sono interattive e attivano la generazione di testo input di nuova riga.
| Preferenze di lettura | Modalità di utilizzo | Dettagli |
|---|---|---|
--verbosity 0 |
Minimo | Stampa solo l'output di generazione. Adatto come strumento di interfaccia a riga di comando. |
--verbosity 1 |
Predefinito | UI del terminale standard rivolta agli utenti. |
--verbosity 2 |
Dettagliato | Mostra informazioni aggiuntive sullo sviluppatore e sul debug. |
App terminale interattiva
Per impostazione predefinita, il livello di dettaglio è impostato su 1, mostrando un'interfaccia
a riga di comando quando gemma viene richiamato con gli argomenti richiesti:
$ ./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.
...
Utilizzo come strumento a riga di comando
Per l'utilizzo dell'eseguibile gemma come strumento a riga di comando, può essere utile
crea un alias per gemma.cpp con argomenti completamente specificati:
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"
Sostituisci i percorsi precedenti con i tuoi percorsi ai percorsi del modello e del tokenizzatore a partire dal download.
Ecco un esempio di prompt gemma con un input troncato (utilizzando un
gemma2b alias come definito sopra):
cat configs.h | tail -35 | tr '\n' ' ' | xargs -0 echo "What does this C++ code
do: " | gemma2b
NOTA: l'utilizzo dell'interfaccia a riga di comando di gemma.cpp è sperimentale e dovrebbe richiedere la lunghezza del contesto i limiti di spesa.
L'output del comando precedente dovrebbe essere simile al seguente:
$ 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.