Como hospedar um modelo de idioma grande localmente

Os Large Language Models (LLMs) são um subconjunto de (IA) projetado para entender e gerar linguagem natural. Esses modelos são treinados em grandes quantidades de dados textuais e usam algoritmos complexos para aprender padrões na linguagem. Os LLMs têm sido usados para desenvolver uma variedade de aplicativos, de chatbots a serviços de tradução de idiomas. Neste artigo, discutiremos como criar um LLM em um único computador e fornecer exemplos de código-fonte. inteligência artificial Pré-requisitos Antes de começar, é essencial garantir que seu computador atenda aos seguintes requisitos: Um computador poderoso com pelo menos 16 GB de RAM e 1 TB de armazenamento gratuito Uma GPU moderna, como NVIDIA GeForce ou AMD Radeon, com pelo menos 8 GB de memória de vídeo Um sistema operacional Linux, como Ubuntu ou CentOS Conhecimento básico da interface de linha de comando (CLI) e da linguagem de programação Python Passo 1: Instale o Anaconda Anaconda é uma popular plataforma de código aberto para ciência de dados e aprendizado de máquina. Inclui várias ferramentas e bibliotecas que usaremos para criar um LLM. Para instalar o Anaconda, siga estas etapas: Baixe o instalador do Anaconda no site oficial: https://www.anaconda.com/products/individual Abra o terminal e navegue até o diretório onde o instalador foi baixado Execute o instalador digitando o seguinte comando: bash Anaconda3–2021.11-Linux-x86_ 64.sh Siga as instruções na tela para concluir a instalação Etapa 2: criar um ambiente Python Criaremos um ambiente Python para instalar as bibliotecas e dependências necessárias para o LLM. Para criar um ambiente, siga estas etapas: Abra o terminal e digite o seguinte comando: conda create — name lm python=3.8 Ative o ambiente digitando: conda activate lm Etapa 3: instalar o TensorFlow O TensorFlow é uma plataforma de código aberto para criar e treinar modelos de aprendizado de máquina. Usaremos o TensorFlow para criar o LLM. Para instalar o TensorFlow, siga estas etapas: Digite o seguinte comando no terminal: pip install tensorflow Verifique se o TensorFlow está instalado importando-o em Python: import tensorflow as tf Passo 4: Baixe um LLM pré-treinado Treinar um LLM do zero requer uma quantidade enorme de poder computacional e tempo. Felizmente, estão disponíveis modelos pré-treinados que podemos ajustar para nosso caso de uso específico. Um dos LLMs pré-treinados mais populares é o GPT-2 (Transformador Pré-treinado Generativo 2). Para baixar o modelo GPT-2 pré-treinado, siga estas etapas: Abra o terminal e digite o seguinte comando: git clone https://github.com/openai/gpt-2.git Navegue até o diretório gpt-2 digitando: cd gpt-2 Baixe o modelo pré-treinado digitando: python download_ 117M model.py Passo 5: Ajuste o LLM pré-treinado O ajuste fino de um LLM pré-treinado envolve treinar o modelo em um conjunto de dados específico para uma tarefa específica. Em nosso exemplo, ajustaremos o modelo GPT-2 pré-treinado em uma tarefa de geração de texto. Para ajustar o modelo, siga estas etapas: Crie um novo diretório para o modelo ajustado digitando: mkdir my_model Navegue até o diretório my_model digitando: cd my_model Crie um novo arquivo Python digitando: touch train.py Abra o arquivo em um editor de texto e cole o seguinte 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() No código acima, definimos os argumentos de linha de comando para o caminho do conjunto de dados, caminho do modelo pré-treinado, caminho de saída, tamanho do lote e número de épocas para treinar. Em seguida, carregamos o modelo GPT-2 pré-treinado e definimos a função de entrada para o conjunto de dados. Por fim, definimos a função de treinamento e iniciamos o treinamento. Etapa 6: gerar texto usando o LLM ajustado Depois que o LLM estiver ajustado, podemos usá-lo para gerar texto. Para gerar texto, siga estas etapas: Abra o terminal e navegue até o diretório my_model digitando: cd my_model Crie um novo arquivo Python digitando: touch generate.py Abra o arquivo em um editor de texto e cole o seguinte 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) No código acima, definimos os argumentos de linha de comando para o caminho do modelo ajustado, comprimento do texto gerado e temperatura para geração de texto. Em seguida, carregamos o modelo ajustado e definimos a função de geração. Por fim, geramos o texto usando a função generate_text e imprimimos a saída, e pronto! Conclusão Neste artigo, aprendemos como criar um Large Language Model (LLM) em um único computador usando o TensorFlow e a arquitetura GPT-2. Começamos instalando o TensorFlow e baixando o código GPT-2 do repositório OpenAI GitHub. Em seguida, treinamos um modelo GPT-2 em um conjunto de dados e ajustamos o modelo GPT-2 pré-treinado usando o mesmo conjunto de dados. Por fim, geramos texto usando o LLM ajustado. Seguindo as etapas deste artigo, você pode criar seu próprio LLM e gerar texto para várias tarefas, como tradução de idiomas, chatbots e geração de conteúdo. Referências Radford, A., Wu, J., Child, R., Luan, D., Amodei, D., & Sutskever, I. (2019). Os modelos de linguagem são aprendizes multitarefa não supervisionados. OpenAI Blog, 1(8), 9. OpenAI. (2019). GPT-2: Os modelos de linguagem são aprendizes multitarefa não supervisionados. Github. Obtido em . https://github.com/openai/gpt-2 TensorFlow. (2021). TensorFlow: uma estrutura de aprendizado de máquina de código aberto para todos. Obtido em . https://www.tensorflow.org/ Brown, TB, Mann, B., Ryder, N., Subbiah, M., Kaplan, J., Dhariwal, P., … & Amodei, D. (2020). Os modelos de linguagem são aprendizes de poucos tiros. pré-impressão arXiv arXiv:2005.14165. Também publicado aqui.