Les grands modèles de langage (LLM) sont un sous-ensemble de l'intelligence artificielle (IA) conçu pour comprendre et générer le langage naturel. Ces modèles sont entraînés sur de grandes quantités de données textuelles et utilisent des algorithmes complexes pour apprendre des modèles de langage. Les LLM ont été utilisés pour développer une gamme d'applications, des chatbots aux services de traduction linguistique. Dans cet article, nous expliquerons comment créer un LLM sur un seul ordinateur et fournirons des exemples de code source.
Avant de commencer, il est essentiel de s'assurer que votre ordinateur répond aux exigences suivantes :
Anaconda est une plate-forme open source populaire pour la science des données et l'apprentissage automatique. Il comprend divers outils et bibliothèques que nous utiliserons pour créer un LLM. Pour installer Anaconda, suivez ces étapes :
Téléchargez le programme d'installation d'Anaconda sur le site officiel : https://www.anaconda.com/products/individual
Ouvrez le terminal et accédez au répertoire où le programme d'installation a été téléchargé
Exécutez le programme d'installation en saisissant la commande suivante : bash Anaconda3–2021.11-Linux-x86_ 64.sh
Suivez les instructions à l'écran pour terminer l'installation
Nous allons créer un environnement Python pour installer les bibliothèques et dépendances nécessaires pour le LLM. Pour créer un environnement, procédez comme suit :
Ouvrez le terminal et tapez la commande suivante : conda create — name lm python=3.8
Activez l'environnement en tapant : conda activate lm
TensorFlow est une plate-forme open source pour la création et la formation de modèles d'apprentissage automatique. Nous utiliserons TensorFlow pour créer le LLM. Pour installer TensorFlow, procédez comme suit :
Tapez la commande suivante dans le terminal : pip install tensorflow
Vérifiez que TensorFlow est installé en l'important dans Python : import tensorflow as tf
La formation d'un LLM à partir de zéro nécessite une énorme quantité de puissance de calcul et de temps. Heureusement, des modèles pré-formés sont disponibles que nous pouvons affiner pour notre cas d'utilisation spécifique. L'un des LLM pré-formés les plus populaires est GPT-2 (Generative Pre-trained Transformer 2). Pour télécharger le modèle GPT-2 pré-entraîné, procédez comme suit :
Ouvrez le terminal et tapez la commande suivante : git clone https://github.com/openai/gpt-2.git
Accédez au répertoire gpt-2 en tapant : cd gpt-2
Téléchargez le modèle pré-entraîné en tapant : python download_ model.py 117M
Le réglage fin d'un LLM pré-formé implique la formation du modèle sur un ensemble de données spécifique pour une tâche spécifique. Dans notre exemple, nous allons affiner le modèle GPT-2 pré-entraîné sur une tâche de génération de texte. Pour affiner le modèle, procédez comme suit :
import tensorflow as tf
import numpy as np
import os
import json
import random
import time
import argparse
#Define the command-line arguments
parser = argparse.ArgumentParser()
parser.add_argument("--dataset_path", type=str, required=True, help="Path to the dataset") parser.add_argument("--model_path", type=str, required=True, help="Path to the pre-trained model") parser.add_argument("--output_path", type=str, required=True, help="Path to save the fine-tuned model")
parser.add_argument("--batch_size", type=int, default=16, help="Batch size for training") parser.add_argument("--epochs", type=int, default=1, help="Number of epochs to train for")
args = parser.parse_args()
#Load the pre-trained GPT-2 model
with open(os.path.join(args.model_path, "hparams.json"), "r") as f:
hparams = json.load(f)
model = tf.compat.v1.estimator.Estimator( model_fn=model_fn, model_dir=args.output_path, params=hparams, config=tf.compat.v1.estimator.RunConfig( save_checkpoints_steps=5000, keep_checkpoint_max=10, save_summary_steps=5000 ))
#Define the input function for the dataset
def input_fn(mode):
dataset = tf.data.TextLineDataset(args.dataset_path)
dataset = dataset.repeat()
dataset = dataset.shuffle(buffer_size=10000)
dataset = dataset.batch(args.batch_size)
dataset = dataset.map(lambda x: tf.strings.substr(x, 0, hparams["n_ctx"]))
iterator = dataset.make_one_shot_iterator()
return iterator.get_next()
#Define the training function
def train():
for epoch in range(args.epochs):
model.train(input_fn=lambda: input_fn(tf.estimator.ModeKeys.TRAIN)) print(f"Epoch {epoch+1} completed.")
#Start the training
train()
Dans le code ci-dessus, nous définissons les arguments de ligne de commande pour le chemin de l'ensemble de données, le chemin du modèle pré-entraîné, le chemin de sortie, la taille du lot et le nombre d'époques pour lesquelles s'entraîner. Nous chargeons ensuite le modèle GPT-2 pré-formé et définissons la fonction d'entrée pour l'ensemble de données. Enfin, nous définissons la fonction d'entraînement et commençons l'entraînement.
Une fois le LLM affiné, nous pouvons l'utiliser pour générer du texte. Pour générer du texte, procédez comme suit :
import tensorflow as tf
import numpy as np
import os
import json
import random
import time
import argparse
#Define the command-line arguments
parser = argparse.ArgumentParser()
parser.add_argument("--model_path", type=str, required=True, help="Path to the fine-tuned model") parser.add_argument("--length", type=int, default=100, help="Length of the generated text") parser.add_argument("--temperature", type=float, default=0.7, help="Temperature for text generation")
args = parser.parse_args()
#Load the fine-tuned model
with open(os.path.join(args.model_path, "hparams.json"), "r") as f:
hparams = json.load(f)
model_fn = model_fn(hparams, tf.estimator.ModeKeys.PREDICT)
model = tf.compat.v1.estimator.Estimator( model_fn=model_fn, model_dir=args.model_path, params=hparams )
#Define the generation function
def generate_text(length, temperature):
start_token = "<|startoftext|>"
tokens = tokenizer.convert_tokens_to_ids([start_token])
token_length = len(tokens)
while token_length < length:
prediction_input = np.array(tokens[-hparams["n_ctx"]:])
output = list(model.predict(input_fn=lambda: [[prediction_input]]))[0]["logits"]
logits = output[-1] / temperature
logits = logits - np.max(logits)
probs = np.exp(logits) / np.sum(np.exp(logits))
token = np.random.choice(range(hparams["n_vocab"]), p=probs)
tokens.append(token)
token_length += 1
output_text = tokenizer.convert_ids_to_tokens(tokens)
output_text = "".join(output_text).replace("▁", " ")
output_text = output_text.replace(start_token, "")
return output_text
#Generate text
text = generate_text(args.length, args.temperature)
print(text)
Dans le code ci-dessus, nous définissons les arguments de ligne de commande pour le chemin du modèle affiné, la longueur du texte généré et la température pour la génération de texte. Nous chargeons ensuite le modèle affiné et définissons la fonction de génération. Enfin, nous générons du texte à l'aide de la fonction generate_text et imprimons la sortie, et nous avons terminé !
Dans cet article, nous avons appris à créer un grand modèle de langage (LLM) sur un seul ordinateur à l'aide de TensorFlow et de l'architecture GPT-2. Nous avons commencé par installer TensorFlow et télécharger le code GPT-2 depuis le référentiel OpenAI GitHub. Nous avons ensuite formé un modèle GPT-2 sur un jeu de données et affiné le modèle GPT-2 pré-formé en utilisant le même jeu de données. Enfin, nous avons généré du texte à l'aide du LLM affiné.
En suivant les étapes de cet article, vous pouvez créer votre propre LLM et générer du texte pour diverses tâches telles que la traduction linguistique, les chatbots et la génération de contenu.
Également publiéici.