Cómo alojar localmente un modelo de lenguaje grande

Los modelos de lenguaje grande (LLM) son un subconjunto de (IA) que están diseñados para comprender y generar lenguaje natural. Estos modelos están entrenados en grandes cantidades de datos textuales y usan algoritmos complejos para aprender patrones en el lenguaje. Los LLM se han utilizado para desarrollar una variedad de aplicaciones, desde chatbots hasta servicios de traducción de idiomas. En este artículo, discutiremos cómo crear un LLM en una sola computadora y proporcionaremos ejemplos de código fuente. inteligencia artificial requisitos previos Antes de comenzar, es esencial asegurarse de que su computadora cumpla con los siguientes requisitos: Una computadora potente con al menos 16 GB de RAM y 1 TB de almacenamiento gratuito Una GPU moderna, como NVIDIA GeForce o AMD Radeon, con al menos 8 GB de memoria de video Un sistema operativo Linux, como Ubuntu o CentOS Conocimientos básicos de la interfaz de línea de comandos (CLI) y el lenguaje de programación Python Paso 1: Instalar Anaconda Anaconda es una popular plataforma de código abierto para la ciencia de datos y el aprendizaje automático. Incluye varias herramientas y bibliotecas que usaremos para crear un LLM. Para instalar Anaconda, siga estos pasos: Descargue el instalador de Anaconda desde el sitio web oficial: https://www.anaconda.com/products/individual Abra la terminal y navegue hasta el directorio donde se descargó el instalador. Ejecute el instalador escribiendo el siguiente comando: bash Anaconda3–2021.11-Linux-x86_ 64.sh Siga las instrucciones en pantalla para completar la instalación Paso 2: Cree un entorno de Python Crearemos un entorno de Python para instalar las bibliotecas y dependencias necesarias para el LLM. Para crear un entorno, siga estos pasos: Abra la terminal y escriba el siguiente comando: conda create — name lm python=3.8 Activa el entorno escribiendo: conda activar lm Paso 3: Instalar TensorFlow TensorFlow es una plataforma de código abierto para crear y entrenar modelos de aprendizaje automático. Usaremos TensorFlow para crear el LLM. Para instalar TensorFlow, siga estos pasos: Escribe el siguiente comando en la terminal: pip install tensorflow Verifique que TensorFlow esté instalado importándolo en Python: import tensorflow as tf Paso 4: Descarga un LLM pre-entrenado Entrenar un LLM desde cero requiere una enorme cantidad de tiempo y poder computacional. Afortunadamente, hay modelos preentrenados disponibles que podemos ajustar para nuestro caso de uso específico. Uno de los LLM preentrenados más populares es GPT-2 (Transformador preentrenado generativo 2). Para descargar el modelo GPT-2 preentrenado, siga estos pasos: Abra la terminal y escriba el siguiente comando: git clone https://github.com/openai/gpt-2.git Navegue al directorio gpt-2 escribiendo: cd gpt-2 Descargue el modelo previamente entrenado escribiendo: python download_ 117M model.py Paso 5: afinar el LLM preentrenado El ajuste fino de un LLM preentrenado implica entrenar el modelo en un conjunto de datos específico para una tarea específica. En nuestro ejemplo, ajustaremos el modelo GPT-2 previamente entrenado en una tarea de generación de texto. Para ajustar el modelo, siga estos pasos: Cree un nuevo directorio para el modelo ajustado escribiendo: mkdir my_model Navegue al directorio my_model escribiendo: cd my_model Cree un nuevo archivo de Python escribiendo: touch train.py Abra el archivo en un editor de texto y pegue el siguiente código: 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() En el código anterior, definimos los argumentos de la línea de comandos para la ruta del conjunto de datos, la ruta del modelo previamente entrenado, la ruta de salida, el tamaño del lote y la cantidad de épocas para entrenar. Luego cargamos el modelo GPT-2 previamente entrenado y definimos la función de entrada para el conjunto de datos. Finalmente, definimos la función de entrenamiento y comenzamos el entrenamiento. Paso 6: Genere texto utilizando el LLM perfeccionado Una vez que el LLM esté ajustado, podemos usarlo para generar texto. Para generar texto, siga estos pasos: Abra la terminal y navegue hasta el directorio my_model escribiendo: cd my_model Cree un nuevo archivo de Python escribiendo: toque generar.py Abra el archivo en un editor de texto y pegue el siguiente código: 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) En el código anterior, definimos los argumentos de la línea de comandos para la ruta del modelo ajustada, la longitud del texto generado y la temperatura para la generación de texto. Luego cargamos el modelo ajustado y definimos la función de generación. Finalmente, generamos texto usando la función generar_texto e imprimimos la salida, ¡y listo! Conclusión En este artículo, aprendimos cómo crear un modelo de lenguaje grande (LLM) en una sola computadora usando TensorFlow y la arquitectura GPT-2. Comenzamos instalando TensorFlow y descargando el código GPT-2 del repositorio de OpenAI GitHub. Luego entrenamos un modelo GPT-2 en un conjunto de datos y ajustamos el modelo GPT-2 previamente entrenado usando el mismo conjunto de datos. Finalmente, generamos texto utilizando el LLM perfeccionado. Siguiendo los pasos de este artículo, puede crear su propio LLM y generar texto para diversas tareas, como traducción de idiomas, chatbots y generación de contenido. Referencias Radford, A., Wu, J., Child, R., Luan, D., Amodei, D. y Sutskever, I. (2019). Los modelos de lenguaje son aprendices multitarea sin supervisión. Blog de OpenAI, 1(8), 9. IA abierta. (2019). GPT-2: Los modelos de lenguaje son aprendices multitarea sin supervisión. Github. Obtenido de . https://github.com/openai/gpt-2 TensorFlow. (2021). TensorFlow: un marco de aprendizaje automático de código abierto para todos. Obtenido de . https://www.tensorflow.org/ Brown, TB, Mann, B., Ryder, N., Subbiah, M., Kaplan, J., Dhariwal, P., … y Amodei, D. (2020). Los modelos de lenguaje son aprendices de pocas oportunidades. preimpresión de arXiv arXiv:2005.14165. También publicado aquí.