Unsloth: domine o fine-tuning com o poder do Llama 3

Gerando respostas com uma LLM - Apresentação

Você já pensou em utilizar modelos de linguagem localmente em seu computador, sem depender de APIs externas ou de modelos pagos? Neste curso, vamos construir um projeto prático no qual faremos o fine-tuning (em português, ajuste fino) de um modelo de código aberto, para que ele se especialize na tarefa de gerar queries em SQL.

Eu sou o João Miranda e irei te acompanhar ao longo dessa jornada!

Audiodescrição: João se descreve como um homem branco, de cabelo castanho-escuro curto e liso, barba castanho-escura curta, e olhos pretos. Ele veste uma camisa azul, e está sentado em uma cadeira branca com detalhes pretos, em frente a uma parede clara iluminada em gradiente azul e verde, com um enfeite preto logo acima do instrutor.

O que vamos aprender?

Para realizar o fine-tuning, utilizaremos uma base de dados contendo perguntas e respostas em SQL para, ao final, aprimorar o resultado das respostas do modelo.

O mais interessante é que conseguiremos utilizar esse modelo localmente em nosso computador. Para isso, usaremos um programa onde teremos acesso a um chat. Nesse chat, será possível enviar perguntas para o modelo, que retornará as respostas em formato de queries em SQL.

Além disso, conseguiremos configurar o modelo a partir de parâmetros. No menu lateral direito, teremos configurações do prompt, e poderemos definir parâmetros como a temperatura, o top K, o top P, e o template desejado para a forma como o modelo retornará o resultado.

O foco deste curso não será em aprender a fazer o RAG desses modelos, nem em criar agentes personalizados, mas em como fazer o fine-tuning do modelo e utilizá-lo localmente, definindo as configurações para ele retornar esses resultados.

Quais são os requisitos?

Para melhor acompanhamento deste conteúdo, é necessário ter conhecimentos sobre a linguagem de programação Python e conceitos de Machine Learning.

Conclusão

Vamos dar início aos nossos estudos? Nos encontramos no próximo vídeo!

Gerando respostas com uma LLM - Carregando o modelo Llama

A equipe de análise de dados de uma empresa precisa consultar informações em uma base de dados para gerar relatórios e insights. No entanto, nem todas as pessoas analistas possuem conhecimentos avançados em SQL, o que gera uma dependência de desenvolvedores para escrever as consultas.

Além disso, a base de dados possui informações sigilosas, então a empresa não gostaria que analistas utilizassem grandes modelos de linguagem, pois as grandes empresas, donas desses modelos, poderiam coletar dados e vazar informações.

Nosso papel neste projeto é realizar o fine-tuning de uma LLM (Large Language Model - Modelo de Linguagem Grande) de código aberto, permitindo que analistas gerem consultas em SQL e utilizem esse modelo localmente, sem depender de APIs externas e de grandes modelos de linguagem.

Como fazer o fine-tuning do modelo de código aberto e utilizá-lo localmente no computador?

Carregando o modelo Llama

Os modelos de linguagem, geralmente, são pesados para o computador processar. Portanto, nossa estratégia será empregar um modelo mais leve e quantizado.

A biblioteca Unsloth AI disponibiliza diversos modelos de linguagem quantizados na plataforma do Hugging Face. Para utilizar essa biblioteca, precisaremos de uma GPU, isto é, uma placa de vídeo. No Colab, podemos utilizar uma placa de vídeo gratuitamente.

Alterando o ambiente de execução

Antes de iniciar os códigos, vamos clicar em "Ambiente de execução > Alterar o tipo de ambiente de execução" no menu superior e selecionar em "Acelerador de hardware" a opção "T4 GPU". Assim, construiremos nosso código utilizando uma GPU para processar as informações.

Instalando a biblioteca Unsloth AI

Na primeira célula do Colab, faremos a instalação da biblioteca Unsloth AI:

!pip install unsloth

Digitado o comando, podemos pressionar "Ctrl + Enter" para executar.

Essa biblioteca é mais pesada, então pode demorar um tempo para instalar.

Atualizando a biblioteca Unsloth AI

Após a instalação, faremos uma atualização da biblioteca com o comando abaixo:

!pip install --upgrade --no-deps 'unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git'

Precisamos do trecho de código unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git para fazer o --upgrade da biblioteca.

Finalizada a instalação, será indicado que devemos reiniciar o ambiente para atualizar as informações. Instalaremos todas as bibliotecas primeiro e depois reiniciaremos o ambiente.

Instalando as dependências da biblioteca Unsloth AI

Como estamos fazendo a instalação sem dependências, precisaremos instalar as dependências das bibliotecas. Dito isso, na próxima célula, escreveremos:

!pip install  --no-deps torch xformers trl peft accelerate bitsandbytes triton

Precisamos instalar todas as bibliotecas que são dependências da Unsloth AI.

Executando com "Ctrl + Enter", recebemos a indicação de que foi instalado. Conferimos isso para garantir que as bibliotecas estão instaladas corretamente.

Caso apareça uma mensagem de aviso de que algumas bibliotecas já foram importadas, o que pode gerar erro de dependência, basta clicar em "Ambiente de execução > Reiniciar sessão" para conseguir fazer a instalação correta das bibliotecas.

Como não precisaremos realizar essas instalações novamente, podemos comentar os comandos de instalação executados nas três células anteriores:

# !pip install unsloth

# !pip install --upgrade --no-deps 'unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git'

# !pip install  --no-deps torch xformers trl peft accelerate bitsandbytes triton

Importando as bibliotecas

Após a instalação, importaremos as bibliotecas com o seguinte comando:

from unsloth import FastLanguageModel
import torch

FastLanguageModel é a função responsável por fazer a importação do modelo de linguagem.

Importando o modelo de linguagem Llama

Agora, faremos a importação de um modelo de linguagem. Nesse caso, escolheremos o modelo Llama 3.1 de 8 bilhões de parâmetros (Meta-Llama-3.1-8B) na plataforma Hugging Face. Nessa página, copiaremos o caminho unsloth/Meta-Llama-3.1-8B.

unsloth/Meta-Llama-3.1-8B

Conforme dito anteriormente, esse modelo possui 8 bilhões de parâmetros, mas existem outros modelos Llama com mais parâmetros, como 70 bilhões ou 405 bilhões, que são mais pesados e não poderiam ser utilizados localmente.

Utilizaremos o modelo de 8 bilhões, mais leve e quantizado, no qual as informações numéricas têm menos bits, como 4 bits, ocupando menos memória no computador.

Para carregar esse modelo, enviaremos o seguinte comando:

checkpoint_modelo = 'unsloth/Meta-Llama-3.1-8B'

Utilizando a função FastLanguageModel

Nosso próximo passo será carregar o modelo para o ambiente Colab.

Para isso, utilizaremos a função FastLanguageModel(), que carrega tanto o modelo quanto o tokenizador, responsável por transformar informações numéricas em texto e vice-versa, de modo que o modelo consiga entender corretamente as informações.

modelo, tokenizador = FastLanguageModel.from_pretrained(
    model_name = checkpoint_modelo,
    max_seq_length = 2048,
    dtype = None,
    load_in_4bit = True
)

Primeiramente, definimos o nome do modelo como checkpoint_modelo em model_name. Como segundo parâmetro, estabelecemos o máximo de tokens que podem ser utilizados no modelo (max_seq_length) com o valor 2048.

Na sequência, definimos o parâmetro dtype igual a None, para que a biblioteca Unsloth AI faça a melhor configuração possível, a depender da GPU utilizada. Como utilizamos a T4, o dtype será definido como Float16.

Por fim, adicionamos o parâmetro load_in_4bit = True, para carregar o modelo em 4 bits e, consequentemente, utilizar menos memória e processamento do computador.

O carregamento do modelo e do tokenizador pode demorar cerca de 1 minuto.

Testando o modelo e o tokenizador

Agora precisamos testar se o modelo e o tokenizador foram carregados corretamente. Para isso, executaremos os comandos modelo e tokenizador:

modelo

Retorno do comando:

LlamaForCausalLM(
  (model): LlamaModel(
    (embed_tokens): Embedding(128256, 4096, padding_idx=128004)
    (layers): ModuleList(
      (0-31): 32 x LlamaDecoderLayer(
        (self_attn): LlamaAttention(
          (q_proj): Linear4bit(in_features=4096, out_features=4096, bias=False)
          (k_proj): Linear4bit(in_features=4096, out_features=1024, bias=False)
          (v_proj): Linear4bit(in_features=4096, out_features=1024, bias=False)
          (o_proj): Linear4bit(in_features=4096, out_features=4096, bias=False)
          (rotary_emb): LlamaExtendedRotaryEmbedding()
        )
        (mlp): LlamaMLP(
          (gate_proj): Linear4bit(in_features=4096, out_features=14336, bias=False)
          (up_proj): Linear4bit(in_features=4096, out_features=14336, bias=False)
          (down_proj): Linear4bit(in_features=14336, out_features=4096, bias=False)
          (act_fn): SiLU()
        )
        (input_layernorm): LlamaRMSNorm((4096,), eps=1e-05)
        (post_attention_layernorm): LlamaRMSNorm((4096,), eps=1e-05)
      )
    )
    (norm): LlamaRMSNorm((4096,), eps=1e-05)
    (rotary_emb): LlamaRotaryEmbedding()
  )
  (lm_head): Linear(in_features=4096, out_features=128256, bias=False)
)

Executando o comando abaixo, receberemos a extensa estrutura do tokenizador:

tokenizador

Conclusão

Entendemos como carregar o modelo e o tokenizador no ambiente do Colab. Agora, precisamos utilizar o modelo para gerar consultas. Faremos isso no próximo vídeo!

Gerando respostas com uma LLM - Gerando consultas com o modelo

Utilizamos a biblioteca Unsloth para fazer o carregamento de um LLM de código aberto: o Llama 3.1, com 8 bilhões de parâmetros. O interessante dessa biblioteca é que ela faz o carregamento desses modelos utilizando menos memória e processamento.

Em segundo plano, a Unsloth usa um método de quantização para reduzir os valores de bits dos números utilizados pelo modelo. Isso é vantajoso para conseguirmos utilizar os modelos localmente em nosso computador e realizar o fine-tuning desses modelos.

Agora que já temos o modelo e o tokenizador carregados, de alguma forma, precisamos utilizar o modelo para gerar queries em SQL. Neste vídeo, descobriremos como fazer isso.

Gerando consultas com o modelo

Definindo o prompt

O primeiro passo será definir a pergunta que faremos ao modelo. Para isso, criaremos um prompt* em formato de *string. Na primeira célula, escrevemos:

prompt = 'Me dê uma query SQL para saber quantas pessoas tem mais de 56 anos.'

Executaremos essa célula com "Ctrl + Enter" para armazenar o prompt.

Criando o prompt_tokenizado

Para o modelo entender essa informação, precisamos utilizar o tokenizador, responsável por transformar a string em números. Na próxima célula, escrevemos:

prompt_tokenizado = tokenizador([prompt], return_tensors='pt').to('cuda')

Utilizamos o tokenizador() carregado anteriormente, passando como primeiro parâmetro o prompt que acabamos de escrever. No segundo parâmetro, definimos que queremos os tensores retornados pelo tokenizador() no formato do PyTorch, que é a biblioteca utilizada. Como usamos a GPU do Google Colab, precisamos indicar que o processamento deve usar essa placa de vídeo.

Feito isso, podemos verificar o resultado gerado com o seguinte comando:

prompt_tokenizado

Retorno do comando:

{'input_ids': tensor([[128000,   7979,    294,   5615,  10832,   3319,   8029,   3429,  42104,
          10484,    300,  47062,   1592,  10071,    409,    220,   3487,  38101,
             13]], device='cuda:0'), 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]],
       device='cuda:0')}

Foi retornado um dicionário contendo:

• Os input_ids, que são números;
• O device, que é o cuda:0;
• E a attention_mask, que é a camada de atenção.

Temos um dicionário com o prompt escrito em formato de string, mas em formato numérico. O Llama 3.1 tem disponibilidade para português, transformando cada palavra em informações numéricas. Agora, podemos utilizar essas informações no modelo para gerar a resposta.

Importando a função TextStreamer()

Para gerar a resposta, precisamos importar uma função que gera novos textos:

from transformers import TextStreamer

A função TextStreamer() será responsável por gerar palavra por palavra da resposta do modelo.

Gerando a resposta

Na próxima célula, vamos definir que o modelo será usado para inferência, isto é, para gerar textos. Depois, inicializaremos a função TextStreamer(), que gera os textos efetivamente.

FastLanguageModel.for_inference(modelo)
streamer_texto = TextStreamer(tokenizador)

_ = modelo.generate(**prompt_tokenizado, streamer = streamer_texto, max_new_tokens = 128)

Com for_inference(), indicamos que queremos usar o modelo para realizar inferência. Na próxima linha, criamos streamer_texto, passando o tokenizador para a função TextStreamer(), de modo que ela saiba como fazer a transformação de palavra para número e de número para palavra.

Na mesma célula, fizemos a geração do texto. Como não queríamos armazenar o texto em nenhuma variável, utilizamos o _, uma estratégia do Python. Assim, não armazenamos o resultado em nenhuma variável, mas conseguimos exibir esse resultado logo abaixo na célula do Colab.

Em generate(), passamos o prompt_tokenizado e as informações de input_ids e attention_mask separadamente. Para desmembrar essas informações, usamos ** antes de prompt_tokenizado.

Como segundo parâmetro, passamos o streamer de texto utilizado (nesse caso, streamer = streamer_texto) e, na sequência, definimos a quantidade máxima de tokens que nosso modelo irá gerar a partir do prompt (max_new_tokens = 128).

Observação: ao executar a célula, talvez seja gerado um texto que não faça tanto sentido. Nesse caso, basta executar até ser retornado um resultado adequado.

Na primeira execução, o modelo gerou uma query em SQL para saber quantas pessoas têm mais de 56 anos, finalizando que a query deve ser feita com o operador IN.

<|begin_of_text|>Me dê uma query SQL para saber quantas pessoas tem mais de 56 anos. A query deve ser feita usando o operador IN.<|end_of_text|>

Como não foi retornada a resposta que queríamos, executamos novamente com o atalho "Ctrl + Enter". Dessa forma, o modelo gerou o seguinte texto:

<|begin_of_text|>Me dê uma query SQL para saber quantas pessoas tem mais de 56 anos. A query deve ser capaz de responder a essa pergunta: "Quantas pessoas têm mais de 56 anos?". O nome da coluna deve ser "Pessoas com mais de 56 anos".
Para esta questão, podemos usar a seguinte query:
SELECT COUNT(*) FROM pessoas WHERE idade >= 56;
Esta query conta o número de linhas na tabela pessoas onde a idade é maior ou igual a 56. A função COUNT retorna o número de linhas que satisfazem a condição.
Note que podemos usar a função COUNT com qualquer tipo de dado, não só com números. […]

Dessa vez, o modelo conseguiu retornar a query e fornecer uma explicação. No entanto, quando executamos novamente a célula, pode ser que ele não gere uma resposta ou comece a retornar queries diferentes do que gostaríamos. Por exemplo:

<|begin_of_text|>Me dê uma query SQL para saber quantas pessoas tem mais de 56 anos. O resultado deve ser o número de pessoas.
```
SELECT COUNT(*) FROM `tabela` WHERE `idade` > 56;
```
```
SELECT COUNT(idade) FROM `tabela` WHERE `idade`
```<|end_of_text|>

Em alguns casos, o modelo simplesmente não retorna resposta, enquanto em outros casos, ele começa a trazer informações que não fazem sentido.

Conclusão

Um modelo carregado do Hugging Face e utilizado para realizar a tarefa de geração de queries em SQL pode não ser tão eficiente neste caso específico.

Sendo assim, precisamos aprimorar nosso modelo com uma base de dados contendo perguntas e respostas em SQL. Começaremos a fazer isso na próxima aula!

Sobre o curso Unsloth: domine o fine-tuning com o poder do Llama 3

O curso Unsloth: domine o fine-tuning com o poder do Llama 3 possui 105 minutos de vídeos, em um total de 46 atividades. Gostou? Conheça nossos outros cursos de IA para Dados em Inteligência Artificial, ou leia nossos artigos de Inteligência Artificial.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Gerando respostas com uma LLM
• Preparando os textos para o fine-tuning
• Adaptando a resposta da LLM
• Usando LLM localmente com Ollama
• Personalizando o modelo com LMStudio