paint-brush
Comment héberger localement un grand modèle de langage par@thomascherickal
24,876 lectures
24,876 lectures

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

par Thomas Cherickal6 min read2023/06/05
Read on Terminal Reader
Print this story

Trop long; Pour lire

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. 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.
featured image - Comment héberger localement un grand modèle de langage
Thomas Cherickal HackerNoon profile picture
0-item
1-item
2-item


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.


Conditions préalables

Avant de commencer, il est essentiel de s'assurer que votre ordinateur répond aux exigences suivantes :


  1. Un ordinateur puissant avec au moins 16 Go de RAM et 1 To de stockage gratuit
  2. Un GPU moderne, tel qu'un NVIDIA GeForce ou AMD Radeon, avec au moins 8 Go de mémoire vidéo
  3. Un système d'exploitation Linux, comme Ubuntu ou CentOS
  4. 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 :


  1. Téléchargez le programme d'installation d'Anaconda sur le site officiel : https://www.anaconda.com/products/individual

  2. Ouvrez le terminal et accédez au répertoire où le programme d'installation a été téléchargé

  3. Exécutez le programme d'installation en saisissant la commande suivante : bash Anaconda3–2021.11-Linux-x86_ 64.sh

  4. 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 :


  1. Ouvrez le terminal et tapez la commande suivante : conda create — name lm python=3.8

  2. 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 :


  1. Tapez la commande suivante dans le terminal : pip install tensorflow

  2. 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 :


  1. Ouvrez le terminal et tapez la commande suivante : git clone https://github.com/openai/gpt-2.git

  2. Accédez au répertoire gpt-2 en tapant : cd gpt-2

  3. Téléchargez le modèle pré-entraîné en tapant : python download_ model.py 117M


É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 :


  1. Créez un nouveau répertoire pour le modèle affiné en tapant : mkdir my_model
  2. Accédez au répertoire my_model en tapant : cd my_model
  3. Créez un nouveau fichier Python en tapant : touch train.py
  4. Ouvrez le fichier train.py dans un éditeur de texte et collez le code suivant :


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 :


  1. Ouvrez le terminal et accédez au répertoire my_model en tapant : cd my_model
  2. Créez un nouveau fichier Python en tapant : touch generate.py
  3. Ouvrez le fichier generate.py dans un éditeur de texte et collez le code suivant :



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é !


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.


La prochaine génération?

La prochaine génération?


Les références

  1. 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.
  2. 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 .
  3. TensorFlow. (2021). TensorFlow : un cadre d'apprentissage automatique open source pour tous. Extrait de https://www.tensorflow.org/ .
  4. 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.

X REMOVE AD