Unslot é uma ferramenta incrível que permite que você ajuste eficientemente o modelo LLAMA-3 em seu próprio conjunto de dados. Aqui está um guia passo a passo sobre como fazer isso:

1. Instalar Pacotes Necessários: Comece clonando o repositório GitHub do Unslot e instalando os pacotes necessários com base na sua configuração de hardware.

2. Configurar Parâmetros de Treinamento: Defina seus parâmetros de treinamento, como o comprimento máximo da sequência, tipos de dados e método de quantização. O Unslot usa adaptadores Lora para permitir o ajuste fino eficiente.

3. Formatar seus Dados de Treinamento: Certifique-se de que seus dados estejam estruturados no formato necessário, com colunas para instrução, entrada e saída. O Unslot fornece exemplos usando o conjunto de dados Alpaca, mas você pode adaptá-lo aos seus próprios dados.

4. Configurar o Treinador SFT: Crie um objeto Treinador SFT (Ajuste Fino Supervisionado) da biblioteca Transformers do Hugging Face, especificando o modelo, o tokenizador, o conjunto de dados e outros parâmetros de treinamento.

5. Treinar o Modelo: Chame a função train() no objeto Treinador SFT para iniciar o processo de ajuste fino. O uso de memória otimizado e a velocidade do Unslot garantem um treinamento eficiente, mesmo com recursos limitados de GPU.

6. Realizar Inferência: Após o treinamento, você pode usar a classe FastLanguageModel específica do Unslot para gerar respostas do seu modelo ajustado. O Unslot também fornece opções para salvar o modelo e carregar os adaptadores Lora para uso futuro.

7. Explorar Recursos Adicionais: O Unslot oferece recursos avançados, como a capacidade de usar o modelo com outras estruturas como PyTorch Lightning e a opção de converter o modelo para o formato GGML para uso com LLAMA-CPP ou GoLLAMA.

A abordagem do Unslot para o ajuste fino do LLAMA-3 é altamente eficiente, aproveitando o uso de memória otimizado e a velocidade. Ele fornece uma solução abrangente e fácil de usar, tornando-o uma excelente escolha para o ajuste fino de modelos de linguagem em seus próprios dados.

Primeiro, precisamos importar as classes necessárias da biblioteca unslot:

from unslot.models.fast_language_model import FastLanguageModel

Em seguida, configuramos os parâmetros de treinamento:

• max_sequence_length: O comprimento máximo da sequência para a entrada. Definimos como 248 tokens, pois o conjunto de dados que estamos usando tem texto relativamente curto.
• data_type: Usamos a quantização de 4 bits para um treinamento eficiente.

max_sequence_length = 248
data_type = "4bit"

O Unslot usa adaptadores Lora para permitir o ajuste fino eficiente. Existem duas opções:

1. Use um modelo pré-carregado do repositório Hugging Face do unslot, que já tem os adaptadores Lora mesclados.
2. Use um modelo do repositório Hugging Face e adicione os adaptadores Lora você mesmo.

Neste caso, usaremos o modelo pré-carregado, então não precisamos fazer nenhuma etapa adicional.

model = FastLanguageModel.from_pretrained("unslot/alpaca-7b")

Se você precisar usar um modelo diferente e adicionar os adaptadores Lora você mesmo, pode descomentar a seção a seguir e fornecer os parâmetros necessários.

# model_id = "your-hugging-face-model-id"
# model = FastLanguageModel.from_pretrained(model_id)
# model.add_lora_adapters()

Agora estamos prontos para passar para a próxima etapa: formatar os dados de treinamento.

Para ajustar o modelo Lama 3 usando o Unslot, você precisa formatar seus dados de treinamento de uma maneira específica. O conjunto de dados usado no exemplo tem três colunas: instrução, entrada e saída.

A coluna de instrução contém a descrição da tarefa que o modelo deve concluir. A coluna de entrada fornece contexto adicional para a tarefa, e a coluna de saída contém a resposta esperada do modelo.

Ao formatar seus próprios dados, certifique-se de estruturá-los da mesma maneira, com as colunas de instrução, entrada e saída. Se a entrada estiver faltando em um determinado exemplo, tudo bem, pois a instrução sozinha pode fornecer as informações necessárias para o modelo gerar a saída.

Depois de baixar os dados, você precisa transformar as três colunas em uma única string de texto que siga um formato específico. Esse formato inclui tokens especiais para a instrução, entrada e resposta. O código no exemplo demonstra como realizar essa transformação, criando uma única coluna que pode ser usada para treinar o modelo.

É importante observar que, embora o exemplo use o conjunto de dados padrão Alpaca, você também pode estruturar seus dados usando outros modelos de prompt, como o formato ChatML introduzido pela OpenAI. Basta ter certeza de formatar corretamente seus exemplos de entrada, pois eles serão alimentados no modelo de linguagem durante o treinamento.

Primeiro, precisamos configurar os parâmetros de treinamento. Vamos importar a classe FastLanguageModel do Unslot e definir o comprimento máximo da sequência, os tipos de dados e o método de quantização.

Em seguida, vamos lidar com o caso em que precisamos adicionar adaptadores Lora ao modelo. Se estamos usando um modelo do repositório Hugging Face, talvez precisemos fornecer um token para aceitar os termos de serviço.

Agora, precisamos formatar os dados de treinamento. O conjunto de dados deve ter três colunas: instrução, entrada e saída. Vamos baixar os dados do Hugging Face e mapeá-los para esse formato.

Em seguida, vamos configurar o Treinador de Ajuste Fino Supervisionado da biblioteca Transformers do Hugging Face. Esse treinador aceitará o objeto do modelo, o tokenizador, o conjunto de dados e outros parâmetros, como o otimizador, o cronograma de taxa de aprendizado e o diretório de saída.

Finalmente, vamos chamar a função train() no objeto do treinador. Observaremos a perda de treinamento diminuindo, indicando que o modelo está aprendendo. Observe que estamos executando apenas um pequeno subconjunto dos dados neste exemplo, mas você vai querer executá-lo por pelo menos uma época ou duas para obter melhores resultados.

Depois do treinamento, podemos salvar o modelo e carregar os adaptadores Lora para inferência. O Unslot também fornece opções para usar o modelo com outras estruturas como PyTorch Lightning e TensorFlow.

Depois que o modelo é treinado, você pode usá-lo para inferência. O Unslot fornece uma interface simples para isso:

1. Importe a classe FastLanguageModel do Unslot.
2. Forneça o modelo treinado e diga a ele para realizar a inferência.
3. Tokenize a entrada usando o formato Alpaca (instrução, entrada e saída esperada).
4. Mova as entradas para a GPU para aproveitar os recursos disponíveis.
5. Chame a função generate, fornecendo as entradas tokenizadas, o número máximo de tokens a serem gerados e se deve usar o cache.

O modelo então gerará uma resposta com base na entrada fornecida. Você também pode usar a classe TextStreamer para transmitir a resposta de texto.

Depois do treinamento, você pode salvar o modelo de várias maneiras:

• Envie o modelo para o Hugging Face Hub, que salvará os adaptadores Lora separadamente.
• Salve o modelo localmente, novamente salvando os adaptadores Lora separadamente.

Para carregar o modelo salvo para inferência, você pode definir um sinalizador para mesclar os adaptadores Lora com o modelo.

O Unslot também fornece opções alternativas para inferência, como usar a classe AutoModelForCausalLM da biblioteca Transformers do Hugging Face, que pode ser mais lenta, mas permite usar o modelo com outras ferramentas como LLaMA-CPP ou GoLLaMA.

Depois que o modelo é treinado, você pode salvá-lo de várias maneiras para usá-lo para inferência posteriormente. O Unslot fornece várias opções para salvar e carregar o modelo ajustado:

1. Salvar no Hugging Face Hub: Você pode enviar o modelo ajustado para o Hugging Face Hub, o que permite compartilhar e usar o modelo com outras pessoas. Para fazer isso, você precisa fornecer seu token Hugging Face.

model.push_to_hub("seu-nome-do-modelo")

2. Salvar Localmente: Você também pode salvar o modelo localmente, o que salvará apenas os adaptadores Lora, não o modelo inteiro. Isso permite carregar facilmente os adaptadores Lora e mesclá-los com o modelo base posteriormente.

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

3. Carregar Adaptadores Lora Salvos: Quando você quiser usar o modelo ajustado para inferência, pode carregar os adaptadores Lora salvos e mesclá-los com o modelo base.

model = FastLLamaForCausalLM.from_pretrained("caminho/para/modelo/base")
model.load_adapter("caminho/para/modelo/salvo")

4. Converter para Formato GGML: O Unslot também fornece a capacidade de converter o modelo ajustado para o formato GGML, que pode ser usado com ferramentas como Llama-CPP ou GoLlama. Isso permite usar o modelo em ambientes apenas com CPU.

model.save_pretrained("caminho/para/salvar/modelo", quantization_method="nf16")

Aproveitando essas opções, você pode facilmente salvar, carregar e usar o modelo ajustado para vários casos de uso, incluindo implantação em diferentes ambientes e compartilhamento com a comunidade.

O artigo fornece um guia abrangente sobre como ajustar o modelo Lama 3 usando o pacote Unslot. Os principais pontos abordados nesta seção são:

1. O Unslot oferece uma maneira eficiente e otimizada de ajustar o Lama 3 e outros modelos de linguagem, com recursos como uso de memória reduzido e treinamento mais rápido.
2. O artigo percorre as etapas para configurar o ambiente de treinamento, formatar os dados e treinar o modelo usando as classes e métodos específicos do Unslot.
3. Também demonstra como realizar a inferência usando o modelo ajustado, tanto pela interface do Unslot quanto convertendo o modelo para outros formatos, como ONNX, para uso com outras ferramentas de inferência.
4. O autor destaca as vantagens do Unslot, como sua capacidade de lidar com restrições de GPU e a facilidade de uso em comparação com outras opções de ajuste fino, como o AutoTrain.
5. O artigo conclui incentivando os leitores a explorar o Unslot e outras ferramentas de ajuste fino, e os convida a entrar em contato com quaisquer dúvidas ou problemas que encontrarem.