So hosten Sie ein großes Sprachmodell lokal

Large Language Models (LLMs) sind eine Teilmenge der (KI), die darauf ausgelegt ist, natürliche Sprache zu verstehen und zu generieren. Diese Modelle werden auf riesigen Textdatenmengen trainiert und nutzen komplexe Algorithmen, um Muster in der Sprache zu lernen. LLMs wurden zur Entwicklung einer Reihe von Anwendungen eingesetzt, von Chatbots bis hin zu Sprachübersetzungsdiensten. In diesem Artikel besprechen wir die Erstellung eines LLM auf einem einzelnen Computer und stellen Quellcodebeispiele bereit. künstlichen Intelligenz Voraussetzungen Bevor wir beginnen, müssen Sie unbedingt sicherstellen, dass Ihr Computer die folgenden Anforderungen erfüllt: Ein leistungsstarker Computer mit mindestens 16 GB RAM und 1 TB freiem Speicher Eine moderne GPU, etwa eine NVIDIA GeForce oder AMD Radeon, mit mindestens 8 GB Videospeicher Ein Linux-Betriebssystem wie Ubuntu oder CentOS Grundkenntnisse der Befehlszeilenschnittstelle (CLI) und der Programmiersprache Python Schritt 1: Anaconda installieren Anaconda ist eine beliebte Open-Source-Plattform für Datenwissenschaft und maschinelles Lernen. Es umfasst verschiedene Tools und Bibliotheken, die wir zum Erstellen eines LLM verwenden werden. Um Anaconda zu installieren, gehen Sie folgendermaßen vor: Laden Sie das Anaconda-Installationsprogramm von der offiziellen Website herunter: https://www.anaconda.com/products/individual Öffnen Sie das Terminal und navigieren Sie zu dem Verzeichnis, in das das Installationsprogramm heruntergeladen wurde Führen Sie das Installationsprogramm aus, indem Sie den folgenden Befehl eingeben: bash Anaconda3–2021.11-Linux-x86_ 64.sh Befolgen Sie die Anweisungen auf dem Bildschirm, um die Installation abzuschließen Schritt 2: Erstellen Sie eine Python-Umgebung Wir erstellen eine Python-Umgebung, um die notwendigen Bibliotheken und Abhängigkeiten für das LLM zu installieren. Um eine Umgebung zu erstellen, führen Sie die folgenden Schritte aus: Öffnen Sie das Terminal und geben Sie den folgenden Befehl ein: conda create – Name lm python=3.8 Aktivieren Sie die Umgebung, indem Sie Folgendes eingeben: conda activate lm Schritt 3: TensorFlow installieren TensorFlow ist eine Open-Source-Plattform zum Erstellen und Trainieren von Modellen für maschinelles Lernen. Wir werden TensorFlow verwenden, um das LLM zu erstellen. Führen Sie die folgenden Schritte aus, um TensorFlow zu installieren: Geben Sie im Terminal den folgenden Befehl ein: pip install tensorflow Überprüfen Sie, ob TensorFlow installiert ist, indem Sie es in Python importieren: TensorFlow als TF importieren Schritt 4: Laden Sie ein vorab trainiertes LLM herunter Das Training eines LLM von Grund auf erfordert enorm viel Rechenleistung und Zeit. Glücklicherweise stehen vorab trainierte Modelle zur Verfügung, die wir für unseren spezifischen Anwendungsfall optimieren können. Einer der beliebtesten vorab trainierten LLMs ist GPT-2 (Generative Pre-trained Transformer 2). Um das vorab trainierte GPT-2-Modell herunterzuladen, führen Sie die folgenden Schritte aus: Öffnen Sie das Terminal und geben Sie den folgenden Befehl ein: git clone https://github.com/openai/gpt-2.git Navigieren Sie zum gpt-2-Verzeichnis, indem Sie Folgendes eingeben: cd gpt-2 Laden Sie das vorab trainierte Modell herunter, indem Sie Folgendes eingeben: python download_ 117M model.py Schritt 5: Feinabstimmung des vorab trainierten LLM Die Feinabstimmung eines vorab trainierten LLM umfasst das Training des Modells anhand eines bestimmten Datensatzes für eine bestimmte Aufgabe. In unserem Beispiel werden wir das vorab trainierte GPT-2-Modell für eine Textgenerierungsaufgabe optimieren. Um das Modell zu optimieren, führen Sie die folgenden Schritte aus: Erstellen Sie ein neues Verzeichnis für das feinabgestimmte Modell, indem Sie Folgendes eingeben: mkdir my_model Navigieren Sie zum Verzeichnis „my_model“, indem Sie Folgendes eingeben: cd my_model Erstellen Sie eine neue Python-Datei, indem Sie Folgendes eingeben: touch train.py Öffnen Sie die Datei in einem Texteditor und fügen Sie den folgenden Code ein: 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() Im obigen Code definieren wir die Befehlszeilenargumente für den Datensatzpfad, den Pfad des vorab trainierten Modells, den Ausgabepfad, die Stapelgröße und die Anzahl der Epochen, für die trainiert werden soll. Anschließend laden wir das vorab trainierte GPT-2-Modell und definieren die Eingabefunktion für den Datensatz. Abschließend definieren wir die Trainingsfunktion und starten das Training. Schritt 6: Generieren Sie Text mit dem fein abgestimmten LLM Sobald das LLM fein abgestimmt ist, können wir es zum Generieren von Text verwenden. Um Text zu generieren, gehen Sie folgendermaßen vor: Öffnen Sie das Terminal und navigieren Sie zum Verzeichnis „my_model“, indem Sie Folgendes eingeben: cd my_model Erstellen Sie eine neue Python-Datei, indem Sie Folgendes eingeben: touch generic.py Öffnen Sie die Datei in einem Texteditor und fügen Sie den folgenden Code ein: „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) Im obigen Code definieren wir die Befehlszeilenargumente für den fein abgestimmten Modellpfad, die Länge des generierten Texts und die Temperatur für die Textgenerierung. Anschließend laden wir das fein abgestimmte Modell und definieren die Generierungsfunktion. Schließlich generieren wir Text mit der Funktion „generate_text“ und drucken die Ausgabe aus, und schon sind wir fertig! Abschluss In diesem Artikel haben wir gelernt, wie man mit TensorFlow und der GPT-2-Architektur ein Large Language Model (LLM) auf einem einzelnen Computer erstellt. Wir begannen mit der Installation von TensorFlow und dem Herunterladen des GPT-2-Codes aus dem OpenAI GitHub-Repository. Anschließend haben wir ein GPT-2-Modell anhand eines Datensatzes trainiert und das vorab trainierte GPT-2-Modell mithilfe desselben Datensatzes verfeinert. Schließlich haben wir mithilfe des fein abgestimmten LLM Text generiert. Indem Sie die Schritte in diesem Artikel befolgen, können Sie Ihr eigenes LLM erstellen und Text für verschiedene Aufgaben wie Sprachübersetzung, Chatbots und Inhaltsgenerierung generieren. Verweise Radford, A., Wu, J., Child, R., Luan, D., Amodei, D. & Sutskever, I. (2019). Sprachmodelle sind unbeaufsichtigte Multitasking-Lernende. OpenAI-Blog, 1(8), 9. OpenAI. (2019). GPT-2: Sprachmodelle sind unbeaufsichtigte Multitasking-Lernende. Github. Abgerufen von . https://github.com/openai/gpt-2 TensorFlow. (2021). TensorFlow: Ein Open-Source-Framework für maschinelles Lernen für alle. Abgerufen von . https://www.tensorflow.org/ Brown, TB, Mann, B., Ryder, N., Subbiah, M., Kaplan, J., Dhariwal, P., … & Amodei, D. (2020). Sprachmodelle sind Wenig-Schuss-Lernende. arXiv-Vorabdruck arXiv:2005.14165. Auch hier veröffentlicht.