Ottimizzazione degli LLM open source con Lamini – Analytics Vidhya | Intelligenza-Artificiale

Introduzione

Di recente, con l'ascesa di grandi modelli linguistici E Intelligenza artificialeabbiamo assistito a innumerevoli progressi in elaborazione del linguaggio naturale. I modelli in domini come testo, codice e generazione di immagini/video hanno archiviato ragionamento e prestazioni simili a quelli umani. Questi modelli hanno prestazioni eccezionali in domande basate sulla conoscenza generale. Modelli come GPT-4o, Lama 2, ClaudioE Gemelli sono addestrati su dataset disponibili al pubblico. Non riescono a rispondere a domande specifiche di dominio o argomento che potrebbero essere più utili per vari compiti organizzativi.

Il fine-tuning aiuta gli sviluppatori e le aziende ad adattare e addestrare modelli pre-addestrati a un set di dati specifico del dominio che archivia elevata accuratezza e coerenza su query correlate al dominio. Il fine-tuning migliora le prestazioni del modello senza richiedere risorse di elaborazione estese perché i modelli pre-addestrati hanno già appreso il testo generale dai vasti dati pubblici.

Questo blog esaminerà perché dobbiamo perfezionare i modelli pre-addestrati usando la piattaforma Lamini. Ciò ci consente di perfezionare e valutare i modelli senza utilizzare molte risorse computazionali.

Allora, cominciamo!

Obiettivi di apprendimento

• Per esplorare la necessità di perfezionare gli LLM open source utilizzando Lamini
• Per scoprire l'uso di Lamini e sotto le istruzioni sui modelli finemente sintonizzati
• Per acquisire una conoscenza pratica del processo end-to-end di messa a punto dei modelli.

Questo articolo è stato pubblicato come parte della Blogathon sulla scienza dei dati.

Perché è opportuno perfezionare i modelli linguistici di grandi dimensioni?

I modelli pre-addestrati sono principalmente addestrati su vasti dati generali con un'alta probabilità di mancanza di contesto o conoscenza specifica del dominio. I modelli pre-addestrati possono anche causare allucinazioni e output imprecisi e incoerenti. I modelli linguistici più popolari basati su chatbot come ChatGPTGemini e BingChat hanno ripetutamente dimostrato che i modelli pre-addestrati sono inclini a tali imprecisioni. È qui che entra in gioco la messa a punto, che può aiutare ad adattare efficacemente gli LLM pre-addestrati a compiti e domande specifiche per materia. Altri modi per allineare i modelli ai tuoi obiettivi includono ingegneria rapida E ingegneria rapida a pochi scatti.

Tuttavia, il fine-tuning rimane un outperformer quando si tratta di metriche di performance. Metodi come il fine-tuning efficiente dei parametri e il fine-tuning a basso ranking adattivo hanno ulteriormente migliorato il fine-tuning del modello e hanno aiutato gli sviluppatori a generare modelli migliori. Diamo un'occhiata a come il fine-tuning si adatta a un contesto di modello linguistico di grandi dimensioni.

# 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}"""

Il codice soprastante mostra che instruction tuning usa un modello di prompt per preparare un set di dati per instruction tuning e perfezionare un modello per un set di dati specifico. Possiamo perfezionare il modello pre-addestrato per un caso d'uso specifico usando un set di dati personalizzato.

La prossima sezione esaminerà come Lamini può aiutare perfezionare modelli linguistici di grandi dimensioni (LLM) per set di dati personalizzati.

Come ottimizzare gli LLM open source utilizzando Lamini?

La piattaforma Lamini consente agli utenti di mettere a punto e distribuire modelli in modo fluido, senza dover sostenere costi elevati né dover effettuare configurazioni hardware particolari. Lamini fornisce uno stack end-to-end per sviluppare, addestrare, sintonizzare e distribuire modelli in base alle esigenze dell'utente e ai requisiti del modello. Lamini fornisce la propria rete di elaborazione GPU ospitata per addestrare modelli in modo economicamente conveniente.

Gli strumenti di ottimizzazione della memoria e di elaborazione di Lamini aiutano ad addestrare e ottimizzare i modelli con elevata accuratezza, controllando al contempo i costi. I modelli possono essere ospitati ovunque, su un cloud privato o tramite la rete GPU di Lamini. Successivamente, vedremo una guida passo passo per preparare i dati per ottimizzare i modelli di linguaggio di grandi dimensioni (LLM) utilizzando la piattaforma Lamini.

Preparazione dei dati

In genere, dobbiamo selezionare un set di dati specifico del dominio per la pulizia dei dati, la promozione, tokenizzazionee archiviazione per preparare i dati per qualsiasi attività di fine-tuning. Dopo aver caricato il set di dati, lo preelaboriamo per convertirlo in un set di dati con istruzioni ottimizzate. Formattiamo ogni campione dal set di dati in un formato di istruzioni, domande e risposte per ottimizzarlo meglio per i nostri casi d'uso. Dai un'occhiata alla fonte del set di dati utilizzando il collegamento fornito QuiDiamo un'occhiata alle istruzioni di esempio del codice sulla messa a punto con tokenizzazione per l'addestramento utilizzando la piattaforma 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})

Nell'esempio sopra, abbiamo formattato “domande” e “risposte” in un modello di richiesta e le abbiamo archiviate in un file separato per la tokenizzazione e il padding prima di addestrare l'LLM.

Tokenizzare il set di dati

# 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

Il codice soprastante prende i campioni del set di dati come input per il padding e il troncamento con tokenizzazione per generare campioni di set di dati tokenizzati preelaborati, che possono essere utilizzati per la messa a punto di modelli pre-addestrati. Ora che il set di dati è pronto, esamineremo l'addestramento e la valutazione dei modelli utilizzando la piattaforma Lamini.

Processo di messa a punto

Ora che abbiamo un set di dati preparato in un formato di ottimizzazione delle istruzioni, caricheremo il set di dati nell'ambiente e perfezioneremo il modello LLM pre-addestrato utilizzando le tecniche di addestramento di Lamini, facili da usare.

Impostazione di un ambiente

Per iniziare la messa a punto di LLM open source utilizzando Lamini, dobbiamo prima assicurarci che il nostro ambiente di codice abbia risorse e librerie idonee installate. Dobbiamo assicurarci di avere una macchina idonea con risorse GPU sufficienti e installare le librerie necessarie come transformers, dataset, torce e pandas. Devi caricare in modo sicuro variabili di ambiente come api_url e api_key, in genere da file di ambiente. Puoi usare pacchetti come dotenv per caricare queste variabili. Dopo aver preparato l'ambiente, carica il dataset e i modelli per l'addestramento.

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 llama import BasicModelRunner

logger = logging.getLogger(__name__)
global_config = None

Carica set di dati

Dopo aver impostato la registrazione per il monitoraggio e il debug, prepara il tuo set di dati utilizzando set di dati o altre librerie di gestione dati come jsonlines e pandas. Dopo aver caricato il set di dati, imposteremo un tokenizzatore e un modello con configurazioni di training per il processo di training.

# load the dataset from you local 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"

Imposta modello, configurazione di formazione e tokenizzatore

Successivamente, selezioniamo il modello per la messa a punto di LLM open source utilizzando Lamini, “EleutherAI/pythia-70m”, e definiamo la sua configurazione in training_config, specificando il nome del modello pre-addestrato e il percorso del dataset. Inizializziamo l'AutoTokenizer con il tokenizer del modello e impostiamo il padding sul token di fine sequenza. Quindi, tokenizziamo i dati e li dividiamo in dataset di training e test utilizzando una funzione personalizzata, tokenize_and_split_data. Infine, istanziamo il modello di base utilizzando AutoModelForCausalLM, consentendogli di eseguire attività di modellazione del linguaggio causale. Inoltre, il codice seguente imposta i requisiti di calcolo per il nostro processo di messa a punto del modello.

# 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 auto 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")

Imposta la formazione per perfezionare il modello

Infine, impostiamo l'argomento di formazione parametri con iperparametriInclude velocità di apprendimento, epoche, dimensioni del batch, directory di output, fasi di valutazione, salvataggio, fasi di riscaldamento, strategia di valutazione e registrazione, ecc., per ottimizzare il set di dati di formazione personalizzato.

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
)

Dopo aver impostato gli argomenti di training, il sistema calcola le operazioni in virgola mobile al secondo (FLOP) del modello in base alle dimensioni di input e ai passaggi di accumulo del gradiente. In questo modo si ottiene una panoramica del carico computazionale. Valuta inoltre l'utilizzo della memoria, stimando l'ingombro del modello in gigabyte. Una volta completati questi calcoli, un Trainer inizializza il modello di base, i FLOP, i passaggi di training totali e i set di dati preparati per il training e la valutazione. Questa configurazione ottimizza il processo di training e consente il monitoraggio dell'utilizzo delle risorse, fondamentale per gestire in modo efficiente la messa a punto del modello su larga scala. Al termine del training, il modello messo a punto è pronto per la distribuzione sul cloud per servire gli utenti come 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,
)

Conclusione

In conclusione, questo articolo fornisce una guida approfondita per comprendere la necessità di perfezionare gli LLM utilizzando la piattaforma Lamini. Offre una panoramica completa del motivo per cui dobbiamo perfezionare il modello per set di dati personalizzati e casi d'uso aziendali e i vantaggi dell'utilizzo degli strumenti Lamini. Abbiamo anche visto una guida passo passo per perfezionare il modello utilizzando un set di dati personalizzato e LLM con strumenti di Lamini. Riassumiamo i punti critici del blog.

Punti chiave

1. È necessario apprendere per mettere a punto i modelli rispetto ai metodi di ingegneria rapida e di generazione aumentata del recupero.
2. Utilizzo di piattaforme come Lamini per tecniche di installazione e distribuzione hardware di facile utilizzo per modelli ottimizzati per soddisfare i requisiti degli utenti
3. Stiamo preparando i dati per l'attività di messa a punto e impostando una pipeline per addestrare un modello di base utilizzando un'ampia gamma di iperparametri.

I contenuti multimediali mostrati in questo articolo non sono di proprietà di Analytics Vidhya e sono utilizzati a discrezione dell'autore.

Domande frequenti

Sono specializzato in data science e machine learning con esperienza pratica nel lavoro su vari progetti end-to-end di data science. Sono il co-responsabile del capitolo locale di Mumbai di Omdena. Sono anche un kaggle master e un educator ambassador presso streamlit con volontari in tutto il mondo.