Como executar o Alpaca-LoRA no seu dispositivo

À medida que a IA generativa ganha espaço, desenvolvedores no mundo todo estão aproveitando a oportunidade para criar aplicações empolgantes com linguagem natural. Uma ferramenta em especial tem chamado muita atenção recentemente: ChatGPT.

O ChatGPT é um modelo de linguagem desenvolvido pela OpenAI. Seu objetivo é atuar como um chatbot com IA capaz de conduzir um diálogo natural, parecido com o humano. Embora seja muito útil, ele também tem limitações. O ChatGPT não é open source, o que significa que o código-fonte não está acessível nem pode ser modificado. Além disso, é extremamente pesado em termos de recursos, o que torna inviável construir sua própria implementação.

Esses desafios impulsionaram uma série de alternativas ao ChatGPT, como o Alpaca-LoRA, que funcionam de maneira semelhante ao ChatGPT, mas com licença open source e exigindo menos recursos.

Neste tutorial, vamos focar especificamente no Alpaca-LoRA. Vamos explicar o que é, os pré-requisitos para rodá-lo no seu dispositivo e o passo a passo para executá-lo.

O que é o Alpaca LoRA?

No início de março de 2023, Eric J. Wang lançou o projeto Alpaca-LoRA. Ele reúne códigos para reproduzir os resultados do Stanford Alpaca usando Parameter-Efficient Fine-Tuning (PEFT) — uma biblioteca que permite ajustar modelos baseados em transformers com LoRA.

Entendendo o LoRA

Low-Rank Adaptation de modelos de linguagem de grande porte (LoRA) é um método que acelera o treinamento de modelos grandes consumindo menos memória.

Funciona assim:

• Congelar os pesos existentes. Imagine o modelo como uma teia complexa de nós interconectados (os “pesos”). Normalmente, você ajustaria todos esses nós durante o treinamento. O LoRA propõe: “Não vamos mexer neles; vamos mantê-los como estão”.
• Adicionar novos pesos. Em seguida, o LoRA inclui algumas conexões novas e mais simples (novos pesos) nessa teia.
• Treinar apenas os novos pesos. Em vez de ajustar toda a teia complexa, você foca apenas em melhorar essas novas conexões mais simples.

Assim, você economiza tempo e memória de máquina, mantendo ou até melhorando o desempenho do modelo nas tarefas.

Vantagens do LoRA

Entre as vantagens do LoRA estão:

• Portabilidade – As matrizes de pesos com decomposição de posto têm bem menos parâmetros treináveis do que o modelo original; por isso, os pesos treinados do LoRA são fáceis de portar e podem rodar até em um Raspberry Pi.
• Acessibilidade – Em comparação ao fine-tuning convencional, o LoRA demonstrou reduzir significativamente o uso de memória de GPU; isso possibilita fazer fine-tuning em GPUs de consumo como Tesla T4, RTX 3080 ou mesmo RTX 2080 Ti.

Alpaca: o modelo open source

O Alpaca, por sua vez, é um modelo de linguagem instruído por fine-tuning e open source, baseado no Large Language Model Meta AI (LLaMA). Ele foi desenvolvido por um time de pesquisadores de Stanford para tornar os modelos de linguagem de grande porte (LLMs) mais acessíveis.

E é aqui que entra o Alpaca-LoRA.

O Alpaca-LoRA é uma versão menos intensiva em recursos do Stanford Alpaca que usa LoRA para acelerar o treinamento enquanto consome menos memória.

Pré-requisitos do Alpaca-LoRA

Para rodar o Alpaca-LoRA localmente, você precisa de uma GPU. Pode ser uma GPU mais simples, como a NVIDIA T4, ou uma GPU de consumo, como a 4090. Segundo Eric J. Wang, criador do projeto, o modelo “roda em algumas horas em uma única RTX 4090”.

Observação: as instruções deste artigo seguem as do repositório Alpaca-LoRA de Eric J. Wang.

Como executar o Alpaca-LoRA em 4 passos

Passo 1: criar o ambiente virtual (opcional)

Ambientes virtuais são contêineres isolados para armazenar as dependências de Python de um projeto específico. Isso ajuda a manter separadas as dependências de projetos diferentes, facilitando o compartilhamento e reduzindo conflitos.

Não é obrigatório usar um para rodar o Alpaca-LoRA, mas é recomendado.

Para criar um ambiente virtual pelo prompt de comando no Windows, execute:

py -m venv venv

Isso vai criar um ambiente virtual chamado venv no diretório de trabalho atual.

Observação: você pode usar qualquer nome, substituindo o segundo venv pelo nome que preferir.

Antes de instalar dependências, ative o ambiente virtual. Rode o comando:

venv\Scripts\activate.bat

Quando não for mais usar o ambiente virtual, desative-o com:

deactivate

Pronto, agora você está preparado para rodar o Alpaca-LoRA.

Passo 2: configuração

O primeiro passo para executar o Alpaca-LoRA é clonar o repositório no GitHub e instalar as dependências necessárias.

Use o comando abaixo para clonar o repositório:

git clone https://github.com/tloen/alpaca-lora.git

Depois, navegue até o repositório alpaca-lora recém-clonado:

cd alpaca-lora

E rode o comando abaixo para instalar as dependências:

pip install -r requirements.txt

Passo 3: fine-tuning do modelo (opcional)

O repositório alpaca-lora inclui um arquivo chamado finetune.py. Ele traz um exemplo simples de Parameter-Efficient Fine-Tuning (PEFT) aplicado ao LLaMA, entre outros recursos.

Esse é o arquivo que você deve executar se quiser ajustar os hiperparâmetros do modelo, mas não é obrigatório. Segundo o autor do repositório, “Sem tuning de hiperparâmetros, o modelo LoRA produz resultados comparáveis ao Stanford Alpaca. Ajustes adicionais podem trazer desempenho ainda melhor [...].”

Veja um exemplo de como usar o finetune.py:

python -m finetune.py \
    --base_model 'decapoda-research/llama-7b-hf' \
    --data_path 'yahma/alpaca-cleaned' \
    --output_dir './lora-alpaca' \
    --batch_size 128 \
    --micro_batch_size 4 \
    --num_epochs 3 \
    --learning_rate 1e-4 \
    --cutoff_len 512 \
    --val_set_size 2000 \
    --lora_r 8 \
    --lora_alpha 16 \
    --lora_dropout 0.05 \
    --lora_target_modules '[q_proj,v_proj]' \
    --train_on_inputs \
    --group_by_length

Passo 4: executando o modelo / inferência

No mesmo repositório alpaca-lora há um arquivo chamado generate.py. Ao executá-lo, ocorre o seguinte:

• Leitura do modelo base no hub de modelos da Hugging Face
• Leitura dos pesos do modelo de tloen/alpaca-lora-7b
• Inicialização de uma interface Gradio para fazer inferência com uma entrada especificada.

No momento da escrita, o adaptador Alpaca-LoRA mais recente usado no treinamento do modelo é o alpaca-lora-7b. Isso foi feito em 26 de março de 2023 com o seguinte comando:

python finetune.py \
    --base_model='decapoda-research/llama-7b-hf' \
    --num_epochs=10 \
    --cutoff_len=512 \
    --group_by_length \
    --output_dir='./lora-alpaca' \
    --lora_target_modules='[q_proj,k_proj,v_proj,o_proj]' \
    --lora_r=16 \
    --micro_batch_size=8

Se preferir usar outro adaptador, basta executar o generate.py apontando para o destino do adaptador desejado.

python generate.py \
    --load_8bit \
    --base_model 'decapoda-research/llama-7b-hf' \
    --lora_weights 'tloen/alpaca-lora-7b'

Para fechar

O Alpaca-LoRA é uma versão menos intensiva em recursos do modelo Stanford Alpaca. Ele atinge esse objetivo usando low-rank adaptation (LoRA) em LLMs, acelerando o treinamento e consumindo muito menos memória do que o Alpaca original.

Aprofunde-se em modelos de linguagem de grande porte (LLMs) e IA generativa com os tutoriais abaixo:

• Introdução ao Meta AI LLaMA
• Como treinar um LLM com PyTorch: guia passo a passo