Formatação Gemma e instruções do sistema

Formatação para ajuste de instruções

Modelos ajustados por instruções (TI) são treinados com um formatador específico que anota todos os exemplos de ajuste de instruções com informações extras, tanto tempo de treinamento e inferência. O formatador tem duas finalidades:

1. indicar papéis em uma conversa, como sistema, usuário ou; assistant.
2. Delinear os turnos em uma conversa, especialmente em vários turnos conversa.

Abaixo, especificamos os tokens de controle usados pelo Gemma e os casos de uso deles. Observação onde os tokens de controle são reservados e são específicos para o nosso tokenizador.

• Token para indicar um turno de usuário: user
• Token para indicar um turno de modelos: model
• Token para indicar o início do turno do diálogo: <start_of_turn>
• Token para indicar o fim do turno do diálogo: <end_of_turn>

Confira um exemplo de caixa de diálogo:

<start_of_turn>user
knock knock<end_of_turn>
<start_of_turn>model
who is there<end_of_turn>
<start_of_turn>user
Gemma<end_of_turn>
<start_of_turn>model
Gemma who?<end_of_turn>

O token "<end_of_turn>\n" é o separador de rota, e o prefixo da solicitação é "<start_of_turn>model\n". Ou seja, se quiser solicitar que o modelo com uma pergunta como "O que é a Regra de Cramer?", você deve alimentar da seguinte forma:

"<start_of_turn>user
What is Cramer's Rule?<end_of_turn>
<start_of_turn>model"

Se você quiser ajustar os modelos Gemma pré-treinados base com seus próprios dados, é possível usar qualquer esquema desse tipo para tokens de controle, desde que ele seja consistente entre seus casos de uso de treinamento e inferência.

Instruções do sistema

Para ajustes supervisionados (SFT) e aprendizado por reforço com humanos feedback (RLHF), os modelos não foram treinados com instruções do sistema. Como resultado, os únicos tokens de formatação relevantes para o Gemma são <start_of_turn>, <end_of_turn>, user e model. Exemplo:

<start_of_turn>user
What is Cramer's Rule?<end_of_turn>
<start_of_turn>model
Cramer's Rule is ...<end_of_turn>

Formatação para tarefas FIM

As variantes 2B e 7B do CodeGemma especialmente ajustados para tarefas de preenchimento de código.

Especificamente, eles são treinados com quatro tokens de controle de formatação que você pode que ajudam a criar comandos de modelo para tarefas de codificação "fill-in-the-middle" (FIM).

Usar tokens FIM para definir a localização do cursor e o contexto ao redor para que o CodeGemma faça o preenchimento do código. Use o token do separador de arquivos para contextos de vários arquivos.

Exemplo: criar um comando do FIM

Esta seção reutiliza o exemplo do conjunto de dados Keras CodeGemma guia de início rápido para mostrar a criar um comando para tarefas do FIM.

Pense no seguinte código:

import |⏎ # Line 1
if __name__ == '__main__':⏎ # Line 2
   sys.exit(0) # Line 3

O | indica a localização do cursor, que é onde o código precisa estar. concluído. Observe que há um espaço antes do cursor e que as linhas 1 e 2 ter retornos de carro no final.

O prefixo é então,

import

com um espaço no final.

O sufixo é:

⏎
if __name__ == '__main__':⏎
   sys.exit(0)

com uma nova linha no início.

O comando precisa ser criado da seguinte forma:

<|fim_prefix|>import <|fim_suffix|>⏎
if __name == '__main__':⏎
   sys.exit(0)<|fim_middle|>

Observações:

• Não deve haver espaços em branco adicionais entre os tokens FIM e o prefixo e sufixo
• O token do meio do FIM precisa estar no final para preparar o modelo para continuar preenchendo
• O prefixo ou sufixo pode estar vazio dependendo de onde o cursor está estão no arquivo ou quanto contexto você quer fornecer ao modelo com

Noções básicas sobre a saída do modelo

A resposta do modelo para o exemplo acima seria:

<|fim_prefix|>import <|fim_suffix|>⏎
if __name__ == "__main__":\n    sys.exit(0)<|fim_middle|>sys\n<|file_separator|>

O modelo repete o comando de entrada e fornece sys como o preenchimento de código.

Ao usar os modelos CodeGemma para tarefas FIM, faça streaming de tokens de resposta e use os tokens do separador de arquivos ou da FIM como delimitadores para interromper o streaming e receber o o preenchimento de código resultante.