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 = "<|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)  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.

The writer is smart, but don't just like, take their word for it. #DoYourOwnResearch before making any investment decisions or decisions regarding you health or security. (Do not regard any of this content as professional investment advice, or health advice)

The code in this story is for educational purposes. The readers are solely responsible for whatever they build with it.

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

Como hospedar um modelo de idioma grande localmente

About Author

COMENTARIOS

Rótulos

ESTE ARTIGO FOI APRESENTADO EM

Related Stories

Valhalla de Floki se junta como patrocinador associado da viagem da Índia ao Sri Lanka

De fóruns a feeds: como os algoritmos de mídia social moldam a interação digital

Toque para ganhar: Telegram pode integrar os próximos 10 bilhões de usuários criptográficos antes de Solana

Crescimento de Criptomoedas: Criando Personas de Usuários Eficazes

Valhalla de Floki se junta como patrocinador associado da viagem da Índia ao Sri Lanka

De fóruns a feeds: como os algoritmos de mídia social moldam a interação digital

Toque para ganhar: Telegram pode integrar os próximos 10 bilhões de usuários criptográficos antes de Solana

Crescimento de Criptomoedas: Criando Personas de Usuários Eficazes

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps