Comment héberger localement un grand modèle de langage

Les grands modèles de langage (LLM) sont un sous-ensemble de (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. l'intelligence artificielle Conditions préalables Avant de commencer, il est essentiel de s'assurer que votre ordinateur répond aux exigences suivantes : Un ordinateur puissant avec au moins 16 Go de RAM et 1 To de stockage gratuit Un GPU moderne, tel qu'un NVIDIA GeForce ou AMD Radeon, avec au moins 8 Go de mémoire vidéo Un système d'exploitation Linux, comme Ubuntu ou CentOS Connaissance de base de l'interface de ligne de commande (CLI) et du langage de programmation Python Étape 1 : Installer Anaconda 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 Étape 2 : Créer un environnement Python 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 Étape 3 : Installer TensorFlow 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 Étape 4 : Téléchargez un LLM pré-formé 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_ 117M model.py Étape 5 : affiner le LLM pré-formé 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 : Créez un nouveau répertoire pour le modèle affiné en tapant : mkdir my_model Accédez au répertoire my_model en tapant : cd my_model Créez un nouveau fichier Python en tapant : touch train.py Ouvrez le fichier dans un éditeur de texte et collez le code suivant : train.py 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. Étape 6 : Générer du texte à l'aide du LLM affiné 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 : Ouvrez le terminal et accédez au répertoire my_model en tapant : cd my_model Créez un nouveau fichier Python en tapant : touch generate.py Ouvrez le fichier dans un éditeur de texte et collez le code suivant : generate.py 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 = " " 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é ! Conclusion 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. Les références Radford, A., Wu, J., Child, R., Luan, D., Amodei, D. et Sutskever, I. (2019). Les modèles linguistiques sont des apprenants multitâches non supervisés. Blog OpenAI, 1(8), 9. OpenAI. (2019). GPT-2 : les modèles de langage sont des apprenants multitâches non supervisés. Github. Extrait de . https://github.com/openai/gpt-2 TensorFlow. (2021). TensorFlow : un cadre d'apprentissage automatique open source pour tous. Extrait de . https://www.tensorflow.org/ Brown, TB, Mann, B., Ryder, N., Subbiah, M., Kaplan, J., Dhariwal, P., … & Amodei, D. (2020). Les modèles de langage sont des apprenants peu nombreux. prétirage arXiv arXiv:2005.14165. Également publié ici.