Perfeccione sus LLM de código hendido con Lamini – Analytics Vidhya

Comienzo

Recientemente, con el auge de modelos de lengua de gran tamaño y AIHemos conocido innumerables avances en procesamiento del lengua naturalLos modelos en dominios como texto, código y gestación de imágenes y videos han rematado un razonamiento y un desempeño similares a los humanos. Estos modelos funcionan excepcionalmente perfectamente en preguntas generales basadas en conocimientos. Modelos como GPT-4o, Fogata 2, Claudioy Géminis Se capacitan con conjuntos de datos disponibles públicamente. No responden preguntas específicas de dominio o tema que podrían ser más bártulos para diversas tareas organizacionales.

El ajuste fino ayuda a los desarrolladores y a las empresas a adaptar y entrenar modelos previamente entrenados a un conjunto de datos específico del dominio que logra una entrada precisión y coherencia en las consultas relacionadas con el dominio. El ajuste fino restablecimiento el rendimiento del maniquí sin requerir medios informáticos extensos porque los modelos previamente entrenados ya han aprendido el texto genérico de la gran cantidad de datos públicos.

En este blog, analizaremos por qué debemos ajustar los modelos previamente entrenados utilizando la plataforma Lamini. Esto nos permite ajustar y evaluar los modelos sin utilizar muchos medios computacionales.

Entonces, ¡comencemos!

Objetivos de enseñanza

• Explorar la obligación de perfeccionar los LLM de código hendido utilizando Lamini
• Para conocer el uso de Lamini y las instrucciones sobre los modelos afinados
• Obtener una comprensión experiencia del proceso de principio a fin de ajuste de modelos.

Este artículo fue publicado como parte de la Blogatón sobre ciencia de datos.

¿Por qué conviene afinar los modelos lingüísticos de gran tamaño?

Los modelos preentrenados se entrenan principalmente con una gran cantidad de datos generales y es muy probable que carezcan de contexto o de conocimiento específico del dominio. Los modelos preentrenados incluso pueden difundir alucinaciones y resultados inexactos e incoherentes. Los modelos de lengua más populares basados ​​en chatbots son ChatGPTGemini y BingChat han demostrado repetidamente que los modelos entrenados previamente son propensos a tales imprecisiones. Aquí es donde el ajuste fino viene al rescate, lo que puede ayudar a adaptar los modelos LLM entrenados previamente a las tareas y preguntas específicas de la materia de modo efectiva. Otras formas de alinear los modelos a sus objetivos incluyen Ingeniería rápida y Ingeniería de mensajes instantáneos de pocos disparos.

Aun así, el ajuste fino sigue siendo superior en lo que respecta a las métricas de rendimiento. Métodos como el ajuste fino de parámetros eficientes y el ajuste fino de clasificación adaptativa devaluación han mejorado aún más el ajuste fino del maniquí y han ayudado a los desarrolladores a difundir mejores modelos. Veamos cómo encaja el ajuste fino en un contexto de maniquí de lengua amplio.

# Load the fine-tuning dataset
filename = "lamini_docs.json"
instruction_dataset_df = pd.read_json(filename, lines=True)
instruction_dataset_df

# Load it into a python's dictionary
examples = instruction_dataset_df.to_dict()

# prepare a samples for a fine-tuning 
if "question" in examples and "answer" in examples:
  text = examples("question")(0) + examples("answer")(0)
elif "instruction" in examples and "response" in examples:
  text = examples("instruction")(0) + examples("response")(0)
elif "input" in examples and "output" in examples:
  text = examples("input")(0) + examples("output")(0)
else:
  text = examples("text")(0)

# Using a prompt template to create instruct tuned dataset for fine-tuning
prompt_template_qa = """### Question:
{question}

### Answer:
{answer}"""

El código preliminar muestra que el ajuste de instrucciones utiliza una plantilla de solicitud para preparar un conjunto de datos para el ajuste de instrucciones y ajustar un maniquí para un conjunto de datos específico. Podemos ajustar el maniquí previamente entrenado para un caso de uso específico utilizando un conjunto de datos personalizado.

La posterior sección examinará cómo Lamini puede ayudar Afinar modelos de lengua de gran tamaño (LLM) para conjuntos de datos personalizados.

¿Cómo perfeccionar los LLM de código hendido utilizando Lamini?

La plataforma Lamini permite a los usuarios ajustar e implementar modelos sin problemas y sin grandes costos ni requisitos de configuración de hardware. Láminas Proporciona una pila de extremo a extremo para desarrollar, entrenar, ajustar e implementar modelos según la conveniencia del agraciado y los requisitos del maniquí. Lamini proporciona su propia red de computación de GPU alojada para entrenar modelos de modo rentable.

Las herramientas de ajuste de memoria y optimización computacional de Lamini ayudan a entrenar y ajustar modelos con entrada precisión mientras se controlan los costos. Los modelos se pueden meter en cualquier circunstancia, en una nimbo privada o a través de la red de GPU de Lamini. A continuación, veremos una director paso a paso para preparar datos para ajustar modelos de lengua grandes (LLM) utilizando la plataforma Lamini.

Preparación de datos

Generalmente, necesitamos clasificar un conjunto de datos específico del dominio para la exactitud y promoción de datos. Tokenizacióny almacenamiento para preparar los datos para cualquier tarea de ajuste fino. Posteriormente de cargar el conjunto de datos, lo procesamos previamente para convertirlo en un conjunto de datos adecuado por instrucciones. Formateamos cada muestra del conjunto de datos en un formato de instrucción, pregunta y respuesta para ajustarlo mejor para nuestros casos de uso. Consulte la fuente del conjunto de datos utilizando el enlace proporcionado aquíVeamos las instrucciones del ejemplo de código sobre cómo ajustar con tokenización para el entrenamiento utilizando la plataforma Lamini.

import pandas as pd

# load the dataset and store it as an instruction dataset
filename = "lamini_docs.json"
instruction_dataset_df = pd.read_json(filename, lines=True)
examples = instruction_dataset_df.to_dict()

if "question" in examples and "answer" in examples:
  text = examples("question")(0) + examples("answer")(0)
elif "instruction" in examples and "response" in examples:
  text = examples("instruction")(0) + examples("response")(0)
elif "input" in examples and "output" in examples:
  text = examples("input")(0) + examples("output")(0)
else:
  text = examples("text")(0)

prompt_template = """### Question:
{question}

### Answer:"""

# Store fine-tuning examples as an instruction format
num_examples = len(examples("question"))
finetuning_dataset = ()
for i in range(num_examples):
  question = examples("question")(i)
  answer = examples("answer")(i)
  text_with_prompt_template = prompt_template.format(question=question)
  finetuning_dataset.append({"question": text_with_prompt_template, 
                             "answer": answer})

En el ejemplo preliminar, hemos formateado “preguntas” y “respuestas” en una plantilla de solicitud y las hemos almacenado en un archivo separado para la tokenización y el relleno antaño de entrenar el LLM.

Tokenizar el conjunto de datos

# Tokenization of the dataset with padding and truncation
def tokenize_function(examples):
    if "question" in examples and "answer" in examples:
      text = examples("question")(0) + examples("answer")(0)
    elif "input" in examples and "output" in examples:
      text = examples("input")(0) + examples("output")(0)
    else:
      text = examples("text")(0)
    
    # padding
    tokenizer.pad_token = tokenizer.eos_token
    tokenized_inputs = tokenizer(
        text,
        return_tensors="np",
        padding=True,
    )

    max_length = min(
        tokenized_inputs("input_ids").shape(1),
        2048
    )
    # truncation of the text
    tokenizer.truncation_side = "left"
    tokenized_inputs = tokenizer(
        text,
        return_tensors="np",
        truncation=True,
        max_length=max_length
    )

    return tokenized_inputs

El código preliminar toma las muestras del conjunto de datos como entrada para el relleno y el truncamiento con tokenización para difundir muestras de conjuntos de datos tokenizados preprocesados, que se pueden usar para ajustar los modelos entrenados previamente. Ahora que el conjunto de datos está agudo, analizaremos el entrenamiento y la evaluación de los modelos utilizando la plataforma Lamini.

Proceso de ajuste fino

Ahora que tenemos un conjunto de datos preparado en un formato de ajuste de instrucciones, cargaremos el conjunto de datos en el entorno y ajustaremos el maniquí LLM previamente entrenado utilizando las técnicas de entrenamiento fáciles de usar de Lamini.

Configuración de un entorno

Para comenzar a ajustar los LLM de código hendido con Lamini, primero debemos asegurarnos de que nuestro entorno de código tenga instalados los medios y las bibliotecas adecuados. Debemos asegurarnos de que tenga una máquina adecuada con suficientes medios de GPU e instalar las bibliotecas necesarias, como transformers, datasets, antorchas y pandas. Debe cargar de forma segura las variables de entorno como api_url y api_key, generalmente desde archivos de entorno. Puede usar paquetes como dotenv para cargar estas variables. Posteriormente de preparar el entorno, cargue el conjunto de datos y los modelos para el entrenamiento.

import os
from lamini import Lamini

lamini.api_url = os.getenv("POWERML__PRODUCTION__URL")
lamini.api_key = os.getenv("POWERML__PRODUCTION__KEY")

# import necessary library and load the environment files
import datasets
import tempfile
import logging
import random
import config
import os
import yaml
import time
import torch
import transformers
import pandas as pd
import jsonlines

# Loading transformer architecture and ((
from utilities import *
from transformers import AutoTokenizer
from transformers import AutoModelForCausalLM
from transformers import TrainingArguments
from transformers import AutoModelForCausalLM
from pasión import BasicModelRunner

logger = logging.getLogger(__name__)
global_config = None

Cargar conjunto de datos

Posteriormente de configurar el registro para la supervisión y la depuración, prepare su conjunto de datos utilizando conjuntos de datos u otras bibliotecas de manejo de datos como jsonlines y pandas. Posteriormente de cargar el conjunto de datos, configuraremos un tokenizador y un maniquí con configuraciones de entrenamiento para el proceso de entrenamiento.

# load the dataset from you específico system or HF cloud
dataset_name = "lamini_docs.jsonl"
dataset_path = f"/content/{dataset_name}"
use_hf = False

# dataset path
dataset_path = "lamini/lamini_docs"

Configurar el maniquí, la configuración de entrenamiento y el tokenizador

A continuación, seleccionamos el maniquí para ajustar los LLM de código hendido con Lamini, “EleutherAI/pythia-70m”, y definimos su configuración en training_config, especificando el nombre del maniquí entrenado previamente y la ruta del conjunto de datos. Inicializamos el AutoTokenizer con el tokenizador del maniquí y establecemos el relleno en el token de fin de secuencia. Luego, tokenizamos los datos y los dividimos en conjuntos de datos de entrenamiento y prueba utilizando una función personalizada, tokenize_and_split_data. Finalmente, instanciamos el maniquí pulvínulo utilizando AutoModelForCausalLM, lo que le permite realizar tareas de modelado de lengua causal. Por otra parte, el código a continuación establece los requisitos de enumeración para nuestro proceso de ajuste fino del maniquí.

# model name
model_name = "EleutherAI/pythia-70m"

# training config
training_config = {
    "model": {
        "pretrained_name": model_name,
        "max_length" : 2048
    },
    "datasets": {
        "use_hf": use_hf,
        "path": dataset_path
    },
    "verbose": True
}

# setting up coche tokenizer
tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token
train_dataset, test_dataset = tokenize_and_split_data(training_config, tokenizer)

# set up a baseline model from lamini
base_model = Lamini(model_name)

# gpu parallization
device_count = torch.cuda.device_count()
if device_count > 0:
    logger.debug("Select GPU device")
    device = torch.device("cuda")
else:
    logger.debug("Select CPU device")
    device = torch.device("cpu")

Configuración del entrenamiento para afinar el maniquí

Finalmente, configuramos el argumento de entrenamiento. parámetros con hiperparámetrosIncluye tasa de enseñanza, épocas, tamaño de división, directorio de salida, pasos de evaluación, guardado, pasos de calentamiento, logística de evaluación y registro, etc., para ajustar el conjunto de datos de entrenamiento personalizado.

max_steps = 3

# trained model name
trained_model_name = f"lamini_docs_{max_steps}_steps"
output_dir = trained_model_name

training_args = TrainingArguments(
  # Learning rate
  learning_rate=1.0e-5,
  # Number of training epochs
  num_train_epochs=1,

  # Max steps to train for (each step is a batch of data)
  # Overrides num_train_epochs, if not -1
  max_steps=max_steps,

  # Batch size for training
  per_device_train_batch_size=1,

  # Directory to save model checkpoints
  output_dir=output_dir,

  # Other arguments
  overwrite_output_dir=False, # Overwrite the content of the output directory
  disable_tqdm=False, # Disable progress bars
  eval_steps=120, # Number of update steps between two evaluations
  save_steps=120, # After # steps model is saved
  warmup_steps=1, # Number of warmup steps for learning rate scheduler
  per_device_eval_batch_size=1, # Batch size for evaluation
  evaluation_strategy="steps",
  logging_strategy="steps",
  logging_steps=1,
  optim="adafactor",
  gradient_accumulation_steps = 4,
  gradient_checkpointing=False,

  # Parameters for early stopping
  load_best_model_at_end=True,
  save_total_limit=1,
  metric_for_best_model="eval_loss",
  greater_is_better=False
)

Posteriormente de configurar los argumentos de entrenamiento, el sistema calcula las operaciones de punto flotante por segundo (FLOP) del maniquí en función del tamaño de entrada y los pasos de acumulación de gradiente, lo que proporciona una idea de la carga computacional. Todavía evalúa el uso de la memoria y estima la huella del maniquí en gigabytes. Una vez que se completan estos cálculos, un monitor inicializa el maniquí pulvínulo, las FLOP, los pasos de entrenamiento totales y los conjuntos de datos preparados para el entrenamiento y la evaluación. Esta configuración optimiza el proceso de entrenamiento y permite el monitoreo del uso de medios, lo que es fundamental para manejar de modo competente el ajuste fino del maniquí a gran escalera. Al final del entrenamiento, el maniquí adecuado está agudo para su implementación en la nimbo para servir a los usuarios como una API.

# model parameters
model_flops = (
  base_model.floating_point_ops(
    {
       "input_ids": torch.zeros(
           (1, training_config("model")("max_length"))
      )
    }
  )
  * training_args.gradient_accumulation_steps
)

print(base_model)
print("Memory footprint", base_model.get_memory_footprint() / 1e9, "GB")
print("Flops", model_flops / 1e9, "GFLOPs")

# Set up a trainer
trainer = Trainer(
    model=base_model,
    model_flops=model_flops,
    total_steps=max_steps,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=test_dataset,
)

Conclusión

En conclusión, este artículo ofrece una director detallada para comprender la obligación de ajustar los LLM mediante la plataforma Lamini. Ofrece una descripción genérico completa de por qué debemos ajustar el maniquí para conjuntos de datos personalizados y casos de uso comercial y los beneficios de usar las herramientas de Lamini. Todavía vimos una director paso a paso para ajustar el maniquí utilizando un conjunto de datos personalizado y LLM con herramientas de Lamini. Resumamos las conclusiones más importantes del blog.

Conclusiones secreto

1. Se necesita enseñanza para ajustar los modelos frente a métodos de gestación aumentada de ingeniería y recuperación rápida.
2. Utilización de plataformas como Lamini para técnicas de instalación y despliegue de hardware fáciles de usar para modelos ajustados a los requisitos del agraciado.
3. Estamos preparando datos para la tarea de ajuste fino y configurando una canalización para entrenar un maniquí pulvínulo utilizando una amplia tono de hiperparámetros.

Los medios que se muestran en este artículo no son propiedad de Analytics Vidhya y se utilizan a discreción del autor.

Preguntas frecuentes