gemma.cpp é uma linguagem C++ pura e leve. implementação do ambiente de execução de inferência do modelo Gemma.
Para saber mais sobre o Gemma, consulte o card card. Os pesos do modelo, incluindo artefatos específicos de gemma.cpp, estão disponíveis no no Kaggle.
Qual é o público deste projeto?
Os mecanismos de inferência modernos de LLMs são sistemas sofisticados, muitas vezes com que se estendem além dos ambientes de execução de redes neurais tradicionais. Com este surgem oportunidades para pesquisa e inovação por meio do co-design de projetos e computação de baixo nível. No entanto, há uma lacuna entre 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 e de baixo nível por compilação.
O gemma.cpp fornece uma implementação minimalista dos modelos Gemma 2B e 7B, focando na simplicidade e na objeção em vez da generalidade total. Isso é inspirados em implementações de modelos C++ integrados verticalmente, como ggml, llama.c e llama.rs (link em inglês).
O gemma.cpp visa casos de uso de experimentação e pesquisa, em especial, explorando o espaço de design dos algoritmos de inferência e inferência da CPU usando chipD portátil por meio do Google Highway biblioteca. O objetivo é que ele seja simples de incorporar em outros projetos com dependências mínimas e também facilmente modificáveis com um núcleo pequeno de 2K LoC implementação (junto com aproximadamente 4K LoC de utilitários de suporte).
Para implantações de borda orientadas para produção, recomendamos a implantação padrão caminhos usando frameworks do Python maduros como JAX, Keras, PyTorch e Transformadores (todas as variações de modelo aqui).
Contribuições grandes e pequenas da comunidade são bem-vindas. Este projeto segue 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 gemma.cpp.
Requisitos do sistema
Antes de começar, você precisa ter instalado o seguinte:
- CMake
- Compilador Clang para C++
tarpara extrair arquivos do Kaggle.
Etapa 1: receber pesos de modelo e tokenizador do Kaggle
Acesse a página do modelo gemma Kaggle e selecione `Variações de modelo
O menu suspenso Gemma C++
. On this tab, theVariação inclui o seguinte: opções abaixo. As opções de pesos do bfloat16 têm maior fidelidade, enquanto as opções com pesos de ponto flutuante alternados permitem inferência mais rápida.
Modelos 2B ajustados por instruções (it) e pré-treinados (pt):
| Nome do modelo | Descrição |
|---|---|
2b-it |
Modelo com 2 bilhões de parâmetros ajustado por instruções, bfloat16 |
2b-it-sfp |
Modelo de 2 bilhões de parâmetros ajustado por instruções, ponto flutuante alterado 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 trocado de 8 bits |
7 bilhões de modelos ajustados por instruções (it) e pré-treinados (pt):
| Nome do modelo | Descrição |
|---|---|
7b-it |
Modelo de 7 bilhões de parâmetros ajustado por instruções, bfloat16 |
7b-it-sfp |
Modelo de 7 bilhões de parâmetros ajustado por instruções, ponto flutuante alterado 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 trocado de 8 bits |
OBSERVAÇÃO: recomendamos começar com 2b-it-sfp para que você comece a usar o produto.
Etapa 2: extrair arquivos
Depois de preencher o formulário de consentimento, o download deve continuar para recuperar um
Arquivo .tar archive.tar.gz. Extrair arquivos de archive.tar.gz (isso pode
alguns minutos):
tar -xf archive.tar.gz
Isso produz um arquivo contendo pesos de modelo como 2b-it-sfp.sbs e
um arquivo tokenizador (tokenizer.spm). Talvez você queira mover esses arquivos para um
local do diretório conveniente (por exemplo, o diretório build/ neste repositório).
Etapa 3: criar
O sistema de build usa o CMake. Para criar a inferência de gemma
ambiente de execução, crie um diretório de build e gere os arquivos de build usando cmake.
do diretório do projeto de nível superior:
(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 der certo, você terá um
gemma executável no diretório build/.
Etapa 4: executar
Agora é possível executar gemma de dentro do 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, ... (confira acima) |
--compressed_weights |
O arquivo de pesos compactado. | 2b-it-sfp.sbs, ... (confira acima) |
--tokenizer |
O nome de 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 compactados
2b-it-sfp.sbs(2 bilhões de modelos ajustados por instruções, 8 bits ponto flutuante alterado). - Arquivo tokenizador
tokenizer.spm.
./gemma \
--tokenizer tokenizer.spm \
--compressed_weights 2b-it-sfp.sbs \
--model 2b-it
Uso
A gemma tem diferentes modos de uso, controlados pela sinalização de detalhes.
Todos os modos de uso são interativos, acionando a geração de texto entrada de nova linha.
| Verbosidade | Modo de uso | Detalhes |
|---|---|---|
--verbosity 0 |
Mínimo | Mostra apenas a saída da geração. Adequado como ferramenta de CLI. |
--verbosity 1 |
Padrão | interface padrão do terminal voltada ao usuário |
--verbosity 2 |
Detalhado | Mostra mais informações sobre o desenvolvedor e a depuração. |
App de terminal interativo
Por padrão, o nível de detalhes é definido como 1, mostrando uma interface
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 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 por seus próprios caminhos para o modelo e os caminhos do tokenizador no download.
Aqui está um exemplo de solicitação de gemma com uma entrada truncada (usando uma
gemma2b, como 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 do tamanho do contexto. suas limitações.
A saída do comando acima 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.