Há tipicamente três estágios diferentes de treinamento para modelos de linguagem de grande porte:

1. Pré-treinamento: Nesta etapa, o modelo é treinado em um grande corpus de dados de texto bruto para aprender a prever o próximo token ou palavra. O resultado é um modelo base que adquiriu muito conhecimento geral do texto, mas ainda não é muito útil para tarefas específicas.

2. Ajuste Fino Supervisionado: Para tornar o modelo base mais útil, o segundo estágio é o ajuste fino supervisionado. Nesta etapa, o modelo é treinado em pares de perguntas e respostas ou pares de instruções e respostas. A entrada é uma pergunta ou instrução, e a saída é a resposta ou resposta desejada. Esta etapa permite que o modelo aprenda conhecimento e capacidades específicas da tarefa.

3. Alinhamento de Preferências: A terceira etapa opcional é o alinhamento de preferências, onde o modelo é treinado para aprender o que o usuário prefere em termos de respostas, ou para alinhar o modelo a certos princípios. Isso geralmente é feito usando técnicas como Aprendizagem por Reforço de Feedback Humano (RLHF) ou Otimização da Política de Debate (DPO).

O objetivo deste vídeo é focar no estágio de ajuste fino supervisionado, especificamente como fazer o ajuste fino do modelo Llama 3.1 usando a biblioteca Unsloth. O vídeo cobrirá diferentes técnicas de ajuste fino, como ajuste fino completo, LoRA e QLoRA, e discutirá os trade-offs entre eles em termos de desempenho e requisitos de memória.

Há três opções populares para ajuste fino supervisionado:

1. Ajuste Fino Completo: Nesta abordagem, você pega o modelo original e atualiza os pesos com o conjunto de dados de ajuste fino de instrução. Isso lhe dará o melhor desempenho, mas o requisito de VRAM será alto.

2. LoRA (Adaptação de Baixa Classificação): Em vez de atualizar diretamente os pesos, você adiciona adaptadores externos ao modelo. O número de parâmetros nesses adaptadores externos pode ser controlado. As atualizações de peso para esses adaptadores são feitas em precisão de 16 bits e, em seguida, mescladas de volta nos pesos originais do modelo. Essa abordagem fornece treinamento rápido, mas ainda é onerosa devido às operações de 16 bits.

3. QLoRA (LoRA Quantizado): Isso é semelhante ao LoRA, mas as atualizações de peso são feitas em precisão de 4 bits, e os pesos do modelo também são mantidos em 4 bits. Isso requer menos VRAM, mas o desempenho pode não ser tão bom quanto o LoRA ou o ajuste fino completo.

Para configurar os adaptadores LoRA, há alguns parâmetros-chave a serem considerados:

1. Classificação: A classificação dos adaptadores LoRA controla o número de parâmetros que serão atualizados durante o ajuste fino. Uma classificação mais baixa significa menos parâmetros, o que reduz os requisitos de VRAM, mas também pode limitar a capacidade do modelo de se adaptar. Por outro lado, uma classificação mais alta permite mais flexibilidade, mas requer mais VRAM.

2. LoRA Alpha: Este parâmetro controla a contribuição dos adaptadores LoRA para os pesos finais do modelo. Um valor de LoRA Alpha mais alto significa que os adaptadores LoRA terão uma influência mais forte, enquanto um valor mais baixo significa que eles terão uma influência mais fraca.

3. LoRA Dropout: Este parâmetro controla a taxa de dropout aplicada aos adaptadores LoRA durante o treinamento. Aumentar a taxa de dropout pode ajudar a evitar o overfitting, mas também pode reduzir o desempenho do modelo.

Para preparar os dados para o ajuste fino, precisamos configurar o modelo de prompt e especificar o token de fim de sequência.

O modelo de prompt é crucial, pois define o formato dos dados de entrada que o modelo será treinado. Para a família Llama 3.1, usaremos o modelo de prompt Alpaca, que inclui uma instrução e uma entrada que fornece mais contexto. Espera-se então que o modelo gere uma resposta apropriada.

# Modelo de prompt Alpaca
prompt_template = "Abaixo está uma instrução que descreve uma tarefa emparelhada com uma entrada que fornece mais contexto. Responda com uma saída relevante.\n\nInstrução: {instruction}\nEntrada: {input}\nSaída:"

Adicionalmente, precisamos especificar o token de fim de sequência para evitar que o modelo gere texto indefinidamente. Esse é um passo importante que muitas pessoas enfrentaram problemas ao usar as versões quantizadas dos modelos com o LamaCPP.

# Definir o token de fim de sequência
end_token = "</s>"

Para treinar o modelo, usaremos o Treinador SFT (Ajuste Fino Supervisionado) do pacote TRL, criado e mantido pelo Hugging Face.

Primeiro, fornecemos nosso modelo, tokenizador e o conjunto de dados ao Treinador SFT. Neste caso, estamos usando a coluna text do conjunto de dados, pois configuramos nosso modelo de prompt para usar esse campo.

Também definimos o comprimento máximo da sequência, que deve ser baseado nos exemplos em seus dados de treinamento. Tenha em mente que um comprimento de sequência maior aumentará os requisitos de VRAM.

Em seguida, configuramos os argumentos de treinamento, como o dispositivo (neste caso, uma GPU T4 no Google Colab com cerca de 15GB de VRAM) e o número de etapas de treinamento.

Finalmente, executamos o treinador e você pode observar a perda decrescente, o que é um bom indicativo do progresso do treinamento.

O treinamento levou cerca de 8 minutos, e a memória reservada de pico foi de aproximadamente 8GB, o que representa cerca de 53% da VRAM disponível na GPU T4. Isso demonstra a eficiência da abordagem Unsloth, que permite o ajuste fino com um requisito de VRAM relativamente baixo.

Para fazer inferência, podemos usar a classe ou método for_inference na classe FastLanguageModel. Precisamos fornecer o modelo treinado e o prompt de entrada no formato Alpaca. Também podemos definir o número máximo de tokens a serem gerados.

# Realizar inferência
input_prompt = alpaca_prompt(instruction, input)
output = model.for_inference(input_prompt, max_new_tokens=256)
print(output)

Para habilitar o streaming, podemos criar um objeto Streamer e passá-lo para o método for_inference. Isso exibirá as respostas um token por vez.

# Habilitar streaming
streamer = Streamer()
output = model.for_inference(input_prompt, max_new_tokens=256, streamer=streamer)

Com isso, você agora pode realizar inferência em seu modelo ajustado e até mesmo habilitar o streaming para uma experiência mais interativa.

Para salvar o modelo ajustado e o tokenizador, você pode usar a função save_pretrained() no modelo e no tokenizador:

model.save_pretrained("caminho/para/salvar/modelo")
tokenizer.save_pretrained("caminho/para/salvar/tokenizador")

Isso salvará os pesos do modelo e o tokenizador nos diretórios especificados como um conjunto de arquivos JSON.

Para carregar o modelo e o tokenizador salvos, você pode usar a mesma classe FastLanguageModel e fornecer os diretórios locais:

model = FastLanguageModel.from_pretrained("caminho/para/salvar/modelo")
tokenizer = FastLanguageModel.from_pretrained("caminho/para/salvar/tokenizador")

Isso carregará o modelo e o tokenizador a partir dos arquivos salvos.

Outro ótimo recurso do Unsloth é a capacidade de salvar os modelos em diferentes formatos, como precisão de ponto flutuante de 16 bits para VLLM ou diretamente no formato GGUF para LamaCPP. Isso permite uma implantação e integração fáceis com várias plataformas e estruturas.

O Unsloth também introduz uma nova interface do usuário baseada no Gradio, que permite executar os modelos treinados usando o Unsloth e participar de sessões de bate-papo interativas. Você pode clonar o repositório Unsloth Studio e executar o notebook do Colab fornecido para experimentar esse recurso.

O Unsloth introduziu uma nova interface de bate-papo baseada na biblioteca Radish, que permite interagir facilmente com os modelos de linguagem treinados usando o Unsloth. Essa interface de bate-papo fornece uma interface amigável para conversar com os modelos e explorar suas capacidades.

Para usar a interface de bate-papo, você pode clonar o repositório Unsloth Studio e executar o notebook do Google Colab fornecido. Isso configurará o ambiente necessário e iniciará a interface de bate-papo, onde você poderá começar a conversar com o modelo de linguagem.

A interface de bate-papo do Unsloth suporta recursos como respostas em streaming, permitindo que você veja a saída do modelo à medida que é gerada. Isso pode ser útil para observar o processo de pensamento do modelo e como ele gera respostas.

Adicionalmente, a interface de bate-papo do Unsloth permite que você salve e carregue seus modelos ajustados, facilitando a continuação do trabalho com seus modelos de linguagem personalizados. Você também pode exportar seus modelos em vários formatos, como precisão de ponto flutuante de 16 bits para VLLM ou formato GGUF para LamaCPP, proporcionando flexibilidade na forma como você usa e implanta seus modelos.

Em geral, a nova interface de bate-papo do Unsloth é uma ferramenta valiosa para interagir e explorar as capacidades dos modelos de linguagem treinados usando a estrutura Unsloth.