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

Formatação para ajuste de instruções

Os modelos ajustados por instrução (AI) são treinados com um formatador específico que comenta todos os exemplos de ajuste de instrução com informações extras, tanto no momento do treinamento quanto da inferência. O formatador tem dois propósitos:

1. Indicar funções em uma conversa, como sistema, usuário ou assistente.
2. Delinear turnos em uma conversa, especialmente em uma conversa com vários turnos.

Abaixo, especificamos os tokens de controle usados pela Gemma e os casos de uso deles. Os tokens de controle são reservados e específicos para nosso tokenizer.

• Token para indicar a vez de um usuário: user
• Token para indicar uma mudança de modelo: model
• Token para indicar o início da vez de falar: <start_of_turn>
• Token para indicar o fim da vez de falar: <end_of_turn>

Confira um exemplo 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 turnos, e o prefixo do comando é "<start_of_turn>model\n". Isso significa que, se você quiser pedir ao modelo uma pergunta como "O que é a regra de Cramer?", alimente o modelo da seguinte maneira:

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

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

Instruções do sistema

Para o ajuste fino supervisionado (SFT, na sigla em inglês) e o aprendizado por reforço com feedback humano (RLHF, na sigla em inglês), os modelos não foram treinados com instruções do sistema. Como resultado, os únicos tokens de formatação relevantes para 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 do FIM

As variantes 2B e 7B do CodeGemma são ajustadas especialmente para tarefas de preenchimento de código.

Especificamente, eles são treinados em quatro tokens de controle de formatação que podem ser usados para ajudar a criar comandos de modelo para tarefas de codificação de preenchimento de lacunas.

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

Exemplo: criar um comando FIM

Esta seção reutiliza o exemplo no Programa de treinamento do Keras CodeGemma para mostrar como criar uma solicitação para tarefas de 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 ser concluído. Há um espaço antes do cursor e as linhas 1 e 2 têm 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.

A instrução precisa ser construída da seguinte maneira:

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

Observações:

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

Entender a saída do modelo

A resposta de 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 de FIM, transmita tokens de resposta e use os tokens de FIM ou de separador de arquivos como delimitadores para interromper o streaming e receber o preenchimento de código resultante.