gemma.cpp é uma implementação de execução de inferência C++ pura leve do modelo Gemma.
Para mais informações sobre o Gemma, consulte o card de modelo. Os pesos do modelo, incluindo artefatos específicos do gemma.cpp, estão disponíveis no Kaggle.
Para quem é este projeto?
Os mecanismos de inferência de LLM modernos são sistemas sofisticados, muitas vezes com recursos personalizados que vão além dos ambientes de execução de rede neural tradicionais. Isso oferece oportunidades de pesquisa e inovação por meio do codesign de algoritmos de alto nível e computação de baixo nível. No entanto, há uma lacuna entre os ambientes de execução de inferência C++ orientados a implantação, que não são projetados para experimentação, e frameworks de pesquisa de ML centrados em Python, que abstraem a computação de baixo nível pela compilação.
O arquivo gemma.cpp fornece uma implementação minimalista dos modelos Gemma 2B e 7B, com foco na simplicidade e na simplicidade, em vez da generalidade completa. Isso é inspirado em implementações de modelo C++ integradas verticalmente, como ggml, llama.c e llama.rs.
O arquivo gemma.cpp é destinado a casos de uso de experimentação e pesquisa, em particular, a exploração do espaço de design de inferência de CPU e algoritmos de inferência usando SIMD portátil pela biblioteca Google Highway. O objetivo é que ele seja fácil de incorporar a outros projetos com dependências mínimas e também facilmente modificável com uma pequena implementação de núcleo de ~2K LoC (junto com ~4K LoC de utilitários de suporte).
Para implantações de ponta orientadas à produção, recomendamos caminhos de implantação padrão usando frameworks avançados do Python, como JAX, Keras, PyTorch e Transformers (todas as variações de modelo aqui).
Todas as contribuições da comunidade são bem-vindas, grandes ou pequenas. Este projeto segue as diretrizes da comunidade de código aberto do Google.
Guia de início rápido
Para concluir este guia de início rápido, clone ou faça o download de gemma.cpp.
Requisitos do sistema
Antes de começar, você precisa ter instalado:
- CMake
- Compilador C++ do Clang
tarpara extrair arquivos do Kaggle.
Etapa 1: receber pesos de modelo e tokenizer do Kaggle
Acesse a página do modelo Gemma no Kaggle e selecione "Model Variations".
O menu suspenso "Gemma C++
. On this tab, theVariation" inclui as seguintes opções abaixo. As opções de peso bfloat16 têm maior fidelidade, enquanto os pesos de ponto flutuante de 8 bits permitem inferências mais rápidas.
Modelos ajustados por instrução de 2B (it) e pré-treinados (pt):
| Nome do modelo | Descrição |
|---|---|
2b-it |
Modelo ajustado por instruções com 2 bilhões de parâmetros, bfloat16 |
2b-it-sfp |
Modelo ajustado por instruções com 2 bilhões de parâmetros, ponto flutuante de 8 bits |
2b-pt |
Modelo pré-treinado com 2 bilhões de parâmetros, bfloat16 |
2b-pt-sfp |
Modelo pré-treinado com 2 bilhões de parâmetros, ponto flutuante de 8 bits |
Modelos ajustados por instrução 7B (it) e pré-treinados (pt):
| Nome do modelo | Descrição |
|---|---|
7b-it |
Modelo ajustado por instruções com 7 bilhões de parâmetros, bfloat16 |
7b-it-sfp |
Modelo ajustado por instruções com 7 bilhões de parâmetros, ponto flutuante de 8 bits |
7b-pt |
Modelo pré-treinado com 7 bilhões de parâmetros, bfloat16 |
7b-pt-sfp |
Modelo pré-treinado com 7 bilhões de parâmetros, ponto flutuante de 8 bits |
NOTA: recomendamos começar com 2b-it-sfp para começar a usar.
Etapa 2: extrair arquivos
Depois de preencher o formulário de consentimento, o download vai extrair um
arquivo tar archive.tar.gz. Extraia os arquivos de archive.tar.gz. Isso pode
levar alguns minutos:
tar -xf archive.tar.gz
Isso vai produzir um arquivo contendo pesos de modelo, como 2b-it-sfp.sbs, e
um arquivo de tokenizer (tokenizer.spm). Talvez seja necessário mover esses arquivos para um
local de diretório conveniente (por exemplo, o diretório build/ neste repositório).
Etapa 3: criar
O sistema de build usa o CMake. Para criar o ambiente de execução de inferência
da Gemma, crie um diretório de build e gere os arquivos de build usando cmake
no diretório de nível superior do projeto:
(cd build && cmake ..)
Em seguida, execute make para criar o executável ./gemma:
cd build make -j [number of parallel threads to use] gemma
Por exemplo, make -j 8 gemma. Se isso for bem-sucedido, você terá um
executável gemma no diretório build/.
Etapa 4: executar
Agora é possível executar gemma no diretório build/.
gemma tem os seguintes argumentos obrigatórios:
| Argumento | Descrição | Valor de exemplo |
|---|---|---|
--model |
O tipo de modelo. | 2b-it, 2b-pt, 7b-it, 7b-pt, ... (consulte acima) |
--compressed_weights |
O arquivo de pesos compactado. | 2b-it-sfp.sbs, ... (veja acima) |
--tokenizer |
O nome do arquivo do tokenizador. | tokenizer.spm |
gemma é invocado como:
./gemma \
--tokenizer [tokenizer file] \
--compressed_weights [compressed weights file] \
--model [2b-it or 2b-pt or 7b-it or 7b-pt]
Exemplo de invocação para a seguinte configuração:
- Arquivo de pesos compactado
2b-it-sfp.sbs(modelo ajustado por instrução de 2B, ponto flutuante comutado de 8 bits). - Arquivo de tokenizador
tokenizer.spm.
./gemma \
--tokenizer tokenizer.spm \
--compressed_weights 2b-it-sfp.sbs \
--model 2b-it
Uso
O gemma tem diferentes modos de uso, controlados pela flag de detalhamento.
Todos os modos de uso são interativos, acionando a geração de texto após a entrada de nova linha.
| Nível de detalhes | Modo de uso | Detalhes |
|---|---|---|
--verbosity 0 |
Mínimo | Só imprime a saída de geração. Adequado como uma ferramenta de CLI. |
--verbosity 1 |
Padrão | Interface padrão do terminal voltada ao usuário. |
--verbosity 2 |
Detalhado | Mostra mais informações de depuração e para desenvolvedores. |
App de terminal interativo
Por padrão, o nível de detalhamento é definido como 1, exibindo uma interface interativa baseada em terminal
quando gemma é invocado com os argumentos necessários:
$ ./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.
...
Uso como uma ferramenta de linha de comando
Para usar o executável gemma como uma ferramenta de linha de comando, pode ser útil
criar um alias para gemma.cpp com argumentos totalmente especificados:
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"
Substitua os caminhos acima pelos seus próprios caminhos para o modelo e os caminhos do tokenizer do download.
Confira um exemplo de como solicitar gemma com uma entrada truncada (usando um
alias gemma2b, conforme definido acima):
cat configs.h | tail -35 | tr '\n' ' ' | xargs -0 echo "What does this C++ code
do: " | gemma2b
OBSERVAÇÃO: o uso da CLI de gemma.cpp é experimental e precisa levar em conta as limitações de comprimento do contexto.
A saída do comando acima deve ser semelhante a esta:
$ 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.