100 dias de IA, dia 13: como o ajuste fino de instruções melhora um LLM pré-treinado

Em um dos posts anteriores falamos sobre o ajuste fino e por que ele é importante. Neste post daremos uma olhada em um tipo específico de ajuste fino chamado ajuste fino de instrução.

Limitações dos modelos básicos pré-treinados:

Modelos básicos pré-treinados como gpt-3 são treinados em uma grande quantidade de dados. No caso do gpt-3 são todos os dados da internet. Bem, não temos certeza disso, mas a maioria desses modelos é treinada em dados em escala da Internet após considerável limpeza e formatação manual. À medida que são treinados, os modelos baseados aprendem como prever o próximo token e ficam realmente bons na previsão de tokens. Mas a previsão pura de tokens não é tão útil quanto você imagina. Se você perguntar a um modelo básico pré-treinado “ Qual é a capital do México? ”não responderá com uma resposta, mas poderá completar a frase de entrada com“ Qual é a capital da Colômbia “. Portanto, embora um modelo como o gpt-3 seja poderoso na previsão de tokens, ele não funcionará como chatbot ou copiloto. Então, como convertemos um modelo pré-treinado em um chatbot útil como o chat-gpt? A resposta é o ajuste fino, principalmente um tipo específico de ajuste fino chamado “ Ajuste fino de instrução ”.

O que é ajuste fino de instrução?

O ajuste fino de instruções, também conhecido como “seguimento de instruções”, é um processo para ensinar um modelo básico pré-treinado a se comportar como um bot de bate-papo.

O ajuste fino de instruções precisa de conjuntos de dados na forma de perguntas e respostas. Você pode usar conjuntos de dados públicos ou o conjunto de dados de sua empresa, que está na forma de perguntas e respostas. Se o seu conjunto de dados não estiver na forma de perguntas e respostas, você poderá converter os dados em perguntas e respostas usando diferentes técnicas, como Alpaca, ou usando prompts personalizados em outros LLMs. Observe que o ajuste fino de instruções dá ao modelo um novo comportamento de responder perguntas não apenas sobre os dados que você usa no ajuste fino, mas esse novo comportamento é aplicável ao conhecimento existente que o modelo já possui, o que torna o ajuste fino uma técnica poderosa.

Ajuste fino de instruções usando Lamini:

Lamini é uma empresa de IA que permite aos desenvolvedores lidar com modelos de linguagem de maneira fácil, abstraindo a complexidade de hospedagem, treinamento e outros aspectos complicados. Confira todos os seus recursos aqui . Usaremos o Lamini para treinar um pequeno modelo de linguagem chamado pythia , que é um modelo de código aberto criado pela Eleuther AI e faremos o ajuste fino de instruções nele usando um conjunto de dados da empresa chamado Alpaca.

Etapa 1: inicializar e carregar o conjunto de dados de ajuste fino de instruções

Nesta etapa vamos inicializar o módulo necessário e também observar o conjunto de dados de treinamento da alpaca. Aqui está o código.

 import itertools import jsonlines from datasets import load_dataset from pprint import pprint from llama import BasicModelRunner from transformers import AutoTokenizer, AutoModelForCausalLM from transformers import AutoModelForSeq2SeqLM, AutoTokenizer ## we are using alpaca data set, which is an open source fine tuning data set instruction_tuned_dataset = load_dataset("tatsu-lab/alpaca", split="train", streaming=True) m = 5 print("Instruction-tuned dataset:") top_m = list(itertools.islice(instruction_tuned_dataset, m)) for j in top_m: print(j)

Esta é a aparência do conjunto de dados de ajuste de instruções. Ele contém dados na forma de perguntas e respostas.

Passo 2: Hidrate os prompts

Nesta etapa pegamos os dados do conjunto alpaca e os colocamos nos prompts mostrados abaixo.

 prompt_template_with_input = """Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request. ### Instruction: {instruction} ### Input: {input} ### Response:""" prompt_template_without_input = """Below is an instruction that describes a task. Write a response that appropriately completes the request. ### Instruction: {instruction} ### Response:""" ## hydrate prompts - meaning add data to the above prompts processed_data = [] for j in top_m: if not j["input"]: processed_prompt = prompt_template_without_input.format(instruction=j["instruction"]) else: processed_prompt = prompt_template_with_input.format(instruction=j["instruction"], input=j["input"]) processed_data.append({"input": processed_prompt, "output": j["output"]})

Depois de fazer isso, o conjunto de dados terá a seguinte aparência.

Basicamente, estamos pegando os dados brutos de perguntas e respostas e convertendo-os em um formato que faça sentido para o LLM que, quando questionado, como deveria ser a resposta a essa pergunta. Fazemos isso iterativamente e armazenamos em um arquivo jsonl .

 with jsonlines.open(f'alpaca_processed.jsonl', 'w') as writer: writer.write_all(processed_data)

Etapa 3 – Saída não ajustada

Nas etapas 1 e 2, carregamos os dados brutos, os hidratamos e os armazenamos no formato jsonl . Mas Lamini tem esses dados hidratados prontos para uso, então tecnicamente as etapas 1 e 2 não são necessárias. Mas era preciso mostrar para entender como funciona o ajuste fino de instruções. Vamos primeiro ver como uma versão não ajustada do modelo Pythia responderia a uma pergunta simples.

 tokenizer = AutoTokenizer.from_pretrained("EleutherAI/pythia-70m") #70M parameter model that is not instruction tuned. model = AutoModelForCausalLM.from_pretrained("EleutherAI/pythia-70m") def inference(text, model, tokenizer, max_input_tokens=1000, max_output_tokens=100): # Tokenize input_ids = tokenizer.encode( text, return_tensors="pt", truncation=True, max_length=max_input_tokens ) # Generate device = model.device generated_tokens_with_prompt = model.generate( input_ids=input_ids.to(device), max_length=max_output_tokens ) # Decode generated_text_with_prompt = tokenizer.batch_decode(generated_tokens_with_prompt, skip_special_tokens=True) # Strip the prompt generated_text_answer = generated_text_with_prompt[0][len(text):] return generated_text_answer ## the 70M model doesnt have any company specific data, we will use the alpace data set from hosted on lamini and fine tune this model # load alpaca dataset finetuning_dataset_path = "lamini/lamini_docs" finetuning_dataset = load_dataset(finetuning_dataset_path) #print(finetuning_dataset) test_sample = finetuning_dataset["test"][0] print(test_sample) print("untrained output sample") print(inference(test_sample["question"], model, tokenizer))

Esta é a saída que obtive. Você notará que a saída não é útil e o modelo está tentando completar o token e não está dando uma resposta real.

Etapa 4 – Saída ajustada da instrução

Uma vez que usamos os dados de perguntas e respostas vistos na etapa anterior para o ajuste fino das instruções, o mesmo modelo começará a se comportar como um bot de bate-papo e fornecerá respostas mais precisas às suas perguntas, tanto nos dados detalhados, mas também nos dados que o modelo já consiste desligado. É quase como se uma criança aprende um idioma pela primeira vez, agora ela será capaz de expressar os sentimentos que já tem junto com as coisas novas que aprendeu com o treinamento do idioma. Assim como a versão pré-treinada do modelo, o modelo ajustado por instrução também está hospedado no Lamini e pode ser inferido com um comando conforme mostrado abaixo. (Sim, Lamini é ótimo!)

 ## finetuned output instruction_model = AutoModelForCausalLM.from_pretrained("lamini/lamini_docs_finetuned") print("instruction finetuned output") print(inference(test_sample["question"], instruction_model, tokenizer))

Aqui está a aparência da saída. Você notará que, em vez do jargão que vimos na etapa anterior, temos uma saída mais precisa.

O objetivo desta postagem é fornecer uma introdução ao ajuste fino de instruções e como ele é usado para transformar modelos básicos em versões mais utilizáveis. Em postagens futuras, irei me aprofundar no processo real de ajuste fino de instruções.

É isso no dia 13 de 100 dias de IA.

Escrevo um boletim informativo chamado Above Average, onde falo sobre os insights de segunda ordem por trás de tudo o que está acontecendo nas grandes tecnologias. Se você trabalha com tecnologia e não quer ser mediano, inscreva-se .

Siga-me no Twitter e LinkedIn para obter as últimas atualizações sobre 100 dias de IA. Se você trabalha com tecnologia, pode estar interessado em ingressar na minha comunidade de profissionais de tecnologia aqui .