100 jours d'IA, jour 13 : comment le réglage fin de l'instruction améliore un LLM pré-entraîné

Dans l’un des articles précédents, nous avons parlé du réglage fin et de son importance. Dans cet article, nous examinerons un type spécifique de réglage fin appelé Instruction Finetuning.

Limites des modèles de base pré-entraînés :

Les modèles de base pré-entraînés comme gpt-3 sont formés sur de grandes quantités de données. Dans le cas de gpt-3, ce sont toutes les données sur Internet. Eh bien, nous ne le savons pas avec certitude, mais la plupart de ces modèles sont formés sur des données à l'échelle Internet après un nettoyage et un formatage manuels considérables. Au fur et à mesure qu'ils sont formés, les modèles basés apprennent à prédire le prochain jeton et deviennent vraiment bons en prédiction de jetons. Mais la prédiction purement symbolique n’est pas aussi utile qu’on pourrait le penser. Si vous demandez à un modèle de base pré-entraîné « Quelle est la capitale du Mexique ? " Il ne répondra pas avec une réponse mais pourrait compléter la phrase d'entrée par " Quelle est la capitale de la Colombie ". Ainsi, même si un modèle comme gpt-3 est puissant en matière de prédiction de jetons, il ne fonctionnera pas comme chatbot ou copilote. Alors, comment convertir un modèle pré-entraîné en un chatbot utile comme chat-gpt ? La réponse est le réglage fin, principalement un type spécifique de réglage fin appelé « Instruction Finetuning ».

Qu’est-ce que le réglage fin des instructions ?

Le réglage fin des instructions, également appelé « suivi des instructions », est un processus permettant d'apprendre à un modèle de base pré-entraîné à se comporter comme un chatbot.

Le réglage fin des instructions nécessite des ensembles de données qui se présentent sous la forme de questions et réponses. Vous pouvez utiliser des ensembles de données publics ou des ensembles de données de votre entreprise sous forme de questions-réponses. Si votre ensemble de données n'est pas sous forme de questions-réponses, vous pouvez convertir les données en questions-réponses en utilisant différentes techniques comme Alpaca ou en utilisant des invites personnalisées sur d'autres LLM. Notez que le réglage fin des instructions donne au modèle un nouveau comportement pour répondre aux questions non seulement sur les données que vous utilisez dans le réglage fin, mais ce nouveau comportement est applicable aux connaissances existantes que le modèle possède déjà, ce qui fait du réglage fin une technique puissante.

Réglage fin des instructions à l’aide de Lamini :

Lamini est une société d'IA qui permet aux développeurs de gérer facilement des modèles de langage en éliminant la complexité de l'hébergement, de la formation et d'autres aspects compliqués. Découvrez toutes ses capacités ici . Nous utiliserons Lamini pour former un petit modèle de langage appelé pythia , qui est un modèle open source créé par Eleuther AI , et peaufiner les instructions à l'aide d'un ensemble de données d'entreprise appelé Alpaca.

Étape 1 : initialiser et charger l'ensemble de données de réglage fin des instructions

Dans cette étape, initialisons le module requis et examinons également l'ensemble de données d'entraînement de l'alpaga. Voici le code.

 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)

Voici à quoi ressemble l’ensemble de données de réglage des instructions. Il contient des données sous forme de questions et réponses.

Étape 2 : Hydratez les invites

Dans cette étape, nous prenons les données de l'ensemble d'alpaga et les insérons dans les invites ci-dessous.

 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"]})

Après cela, l’ensemble de données ressemblera à ceci.

Nous prenons essentiellement les données brutes de questions et réponses et les convertissons dans un format qui a du sens pour le LLM et qui, lorsqu'on nous pose une question, à quoi devrait ressembler la réponse à cette question. Nous faisons cela de manière itérative et stockons dans un fichier jsonl .

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

Étape 3 – Sortie non affinée

Aux étapes 1 et 2, nous avons chargé les données brutes, les avons hydratées et stockées au format jsonl . Mais Lamini a ces données hydratées prêtes à l'emploi, donc techniquement les étapes 1 et 2 ne sont pas nécessaires. Mais il fallait montrer comment fonctionne la mise au point des instructions. Voyons d'abord comment une version non affinée du modèle Pythia répondrait à une question simple.

 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))

C'est le résultat que j'ai obtenu. Vous remarquerez que le résultat n'est pas utile et que le modèle essaie de compléter le jeton et ne donne pas de réponse réelle.

Étape 4 – Sortie affinée des instructions

Une fois que nous utilisons les données de questions et réponses vues à l'étape précédente pour affiner les instructions, le même modèle commencera à se comporter comme un chatbot et fournira des réponses plus précises à vos questions à la fois sur les données affinées mais également sur les données que le modèle a déjà consiste hors. C'est presque comme lorsqu'un enfant apprend une langue pour la première fois, il sera désormais capable d'exprimer les sentiments qu'il éprouve déjà ainsi que les nouvelles choses qu'il a apprises grâce à la formation linguistique. Tout comme la version pré-entraînée du modèle, le modèle d'instructions affiné est également hébergé sur Lamini et peut être déduit avec une commande comme indiqué ci-dessous. (Oui Lamini est génial !)

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

Voici à quoi ressemblera le résultat. Vous remarquerez qu'au lieu du charabia que nous avons vu à l'étape précédente, nous avons un résultat plus précis.

L'objectif de cet article est de donner une introduction au réglage fin des instructions et à la manière dont elles sont utilisées pour créer des modèles de base vers des versions plus utilisables. Dans les prochains articles, je plongerai en profondeur dans le processus réel de mise au point des instructions.

C'est tout pour le jour 13 des 100 jours d'IA.

J'écris une newsletter intitulée Above Average dans laquelle je parle des idées de second ordre derrière tout ce qui se passe dans la grande technologie. Si vous êtes dans la technologie et que vous ne voulez pas être dans la moyenne, abonnez-vous .

Suivez-moi sur Twitter et LinkedIn pour les dernières mises à jour sur 100 jours d'IA. Si vous êtes dans le domaine de la technologie, vous pourriez être intéressé à rejoindre ma communauté de professionnels de la technologie ici .