Optimieren Sie Open-Supply-LLMs mit Lamini – Analytics Vidhya

Einführung

Vor kurzem, mit dem Aufstieg von große Sprachmodelle Und KIhaben wir unzählige Fortschritte erlebt in Verarbeitung natürlicher Sprache. Modelle in Bereichen wie Textual content, Code und Bild-/Videogenerierung haben menschliches Denken und Leistung erreicht. Diese Modelle schneiden bei allgemeinen wissensbasierten Fragen außergewöhnlich intestine ab. Modelle wie GPT-4o, Lama 2, ClaudeUnd Zwillinge werden anhand öffentlich verfügbarer Datensätze trainiert. Sie können keine domänen- oder fachspezifischen Fragen beantworten, die für verschiedene organisatorische Aufgaben nützlicher sein könnten.

Durch Feinabstimmung können Entwickler und Unternehmen vorab trainierte Modelle an einen domänenspezifischen Datensatz anpassen und trainieren, der eine hohe Genauigkeit und Kohärenz bei domänenbezogenen Abfragen gewährleistet. Durch Feinabstimmung wird die Leistung des Modells verbessert, ohne dass umfangreiche Rechenressourcen erforderlich sind, da vorab trainierte Modelle den allgemeinen Textual content bereits aus den umfangreichen öffentlichen Daten gelernt haben.

In diesem Weblog wird untersucht, warum wir vorab trainierte Modelle mithilfe der Lamini-Plattform optimieren müssen. Dadurch können wir Modelle optimieren und auswerten, ohne viele Rechenressourcen zu verbrauchen.

Additionally, lasst uns anfangen!

Lernziele

• Um die Notwendigkeit der Feinabstimmung von Open-Supply-LLMs mit Lamini zu untersuchen
• Erfahren Sie mehr über die Verwendung von Lamini und über Anleitungen für fein abgestimmte Modelle
• Um ein praktisches Verständnis des Finish-to-Finish-Prozesses der Feinabstimmung von Modellen zu erlangen.

Dieser Artikel erschien im Rahmen der Information Science Blogathon.

Warum sollte man große Sprachmodelle optimieren?

Vortrainierte Modelle werden in erster Linie anhand großer allgemeiner Datenmengen trainiert, wobei die Wahrscheinlichkeit groß ist, dass Kontext oder domänenspezifisches Wissen fehlen. Vortrainierte Modelle können auch zu Halluzinationen und ungenauen und inkohärenten Ergebnissen führen. Die beliebtesten großen Sprachmodelle, die auf Chatbots basieren, wie ChatGPTGemini und BingChat haben wiederholt gezeigt, dass vortrainierte Modelle anfällig für solche Ungenauigkeiten sind. Hier kommt Feintuning zum Einsatz, das dabei helfen kann, vortrainierte LLMs effektiv an fachspezifische Aufgaben und Fragen anzupassen. Weitere Möglichkeiten, Modelle an Ihre Ziele anzupassen, sind schnelles Engineering Und Wenige-Schuss-Immediate-Engineering.

Dennoch ist die Feinabstimmung bei Leistungsmetriken nach wie vor die beste. Methoden wie die Parameter-effiziente Feinabstimmung und die Feinabstimmung mit niedrigem adaptiven Rating haben die Feinabstimmung des Modells weiter verbessert und Entwicklern geholfen, bessere Modelle zu erstellen. Sehen wir uns an, wie die Feinabstimmung in den Kontext eines großen Sprachmodells passt.

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

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

# put together a samples for a fine-tuning 
if "query" in examples and "reply" in examples:
  textual content = examples("query")(0) + examples("reply")(0)
elif "instruction" in examples and "response" in examples:
  textual content = examples("instruction")(0) + examples("response")(0)
elif "enter" in examples and "output" in examples:
  textual content = examples("enter")(0) + examples("output")(0)
else:
  textual content = examples("textual content")(0)

# Utilizing a immediate template to create instruct tuned dataset for fine-tuning
prompt_template_qa = """### Query:
{query}

### Reply:
{reply}"""

Der obige Code zeigt, dass die Befehlsoptimierung eine Eingabeaufforderungsvorlage verwendet, um einen Datensatz für die Befehlsoptimierung vorzubereiten und ein Modell für einen bestimmten Datensatz zu optimieren. Mithilfe eines solchen benutzerdefinierten Datensatzes können wir das vorab trainierte Modell für einen bestimmten Anwendungsfall optimieren.

Im nächsten Abschnitt erfahren Sie, wie Lamini Ihnen helfen kann Feinabstimmung großer Sprachmodelle (LLMs) für benutzerdefinierte Datensätze.

Wie kann ich Open-Supply-LLMs mit Lamini optimieren?

Mit der Lamini-Plattform können Benutzer Modelle nahtlos optimieren und bereitstellen, ohne dass große Kosten entstehen oder große Anforderungen an die Hardwareeinrichtung gestellt werden. Lamini bietet einen Finish-to-Finish-Stack zum Entwickeln, Trainieren, Optimieren und Bereitstellen von Modellen nach Benutzerfreundlichkeit und Modellanforderungen. Lamini bietet sein eigenes gehostetes GPU-Computernetzwerk zum kostengünstigen Trainieren von Modellen.

Die Speicheroptimierungstools und Rechenoptimierung von Lamini helfen dabei, Modelle mit hoher Genauigkeit zu trainieren und zu optimieren und gleichzeitig die Kosten unter Kontrolle zu halten. Modelle können überall gehostet werden, in einer privaten Cloud oder über das GPU-Netzwerk von Lamini. Als Nächstes sehen wir eine Schritt-für-Schritt-Anleitung zur Vorbereitung von Daten für die Feinabstimmung großer Sprachmodelle (LLMs) mithilfe der Lamini-Plattform.

Datenaufbereitung

Im Allgemeinen müssen wir einen domänenspezifischen Datensatz für die Datenbereinigung, Werbung, Tokenisierungund Speicher, um Daten für jede Feinabstimmungsaufgabe vorzubereiten. Nachdem wir den Datensatz geladen haben, verarbeiten wir ihn vor, um ihn in einen anweisungsoptimierten Datensatz umzuwandeln. Wir formatieren jede Probe aus dem Datensatz in ein Anweisungs-, Frage- und Antwortformat, um sie besser für unsere Anwendungsfälle zu optimieren. Sehen Sie sich die Quelle des Datensatzes über den angegebenen Hyperlink an Hier. Sehen wir uns die Codebeispielanweisungen zum Tuning mit Tokenisierung für das Coaching mithilfe der Lamini-Plattform an.

import pandas as pd

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

if "query" in examples and "reply" in examples:
  textual content = examples("query")(0) + examples("reply")(0)
elif "instruction" in examples and "response" in examples:
  textual content = examples("instruction")(0) + examples("response")(0)
elif "enter" in examples and "output" in examples:
  textual content = examples("enter")(0) + examples("output")(0)
else:
  textual content = examples("textual content")(0)

prompt_template = """### Query:
{query}

### Reply:"""

# Retailer fine-tuning examples as an instruction format
num_examples = len(examples("query"))
finetuning_dataset = ()
for i in vary(num_examples):
  query = examples("query")(i)
  reply = examples("reply")(i)
  text_with_prompt_template = prompt_template.format(query=query)
  finetuning_dataset.append({"query": text_with_prompt_template, 
                             "reply": reply})

Im obigen Beispiel haben wir „Fragen“ und „Antworten“ in einer Eingabeaufforderungsvorlage formatiert und sie vor dem Coaching des LLM zur Tokenisierung und Auffüllung in einer separaten Datei gespeichert.

Tokenisieren Sie den Datensatz

# Tokenization of the dataset with padding and truncation
def tokenize_function(examples):
    if "query" in examples and "reply" in examples:
      textual content = examples("query")(0) + examples("reply")(0)
    elif "enter" in examples and "output" in examples:
      textual content = examples("enter")(0) + examples("output")(0)
    else:
      textual content = examples("textual content")(0)
    
    # padding
    tokenizer.pad_token = tokenizer.eos_token
    tokenized_inputs = tokenizer(
        textual content,
        return_tensors="np",
        padding=True,
    )

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

    return tokenized_inputs

Der obige Code verwendet die Datensatzbeispiele als Eingabe zum Auffüllen und Abschneiden mit Tokenisierung, um vorverarbeitete tokenisierte Datensatzbeispiele zu generieren, die zum Feinabstimmen vorab trainierter Modelle verwendet werden können. Nachdem der Datensatz nun fertig ist, werden wir uns mit dem Trainieren und Auswerten von Modellen mithilfe der Lamini-Plattform befassen.

Feinabstimmungsprozess

Nachdem wir nun einen Datensatz in einem Anweisungsoptimierungsformat vorbereitet haben, laden wir den Datensatz in die Umgebung und optimieren das vortrainierte LLM-Modell mit den benutzerfreundlichen Trainingstechniken von Lamini.

Einrichten einer Umgebung

Um mit der Feinabstimmung von Open-Supply-LLMs mit Lamini zu beginnen, müssen wir zunächst sicherstellen, dass in unserer Codeumgebung geeignete Ressourcen und Bibliotheken installiert sind. Wir müssen sicherstellen, dass Sie über eine geeignete Maschine mit ausreichend GPU-Ressourcen verfügen und die erforderlichen Bibliotheken wie Transformatoren, Datensätze, Torches und Pandas installieren. Sie müssen Umgebungsvariablen wie API_URL und API_KEY sicher laden, normalerweise aus Umgebungsdateien. Sie können Pakete wie dotenv verwenden, um diese Variablen zu laden. Nachdem Sie die Umgebung vorbereitet haben, laden Sie den Datensatz und die Modelle für das Coaching.

import os
from lamini import Lamini

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

# import obligatory library and cargo the atmosphere information
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 structure 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

Datensatz laden

Nachdem Sie die Protokollierung für die Überwachung und Fehlerbehebung eingerichtet haben, bereiten Sie Ihren Datensatz mithilfe von Datensätzen oder anderen Datenverarbeitungsbibliotheken wie jsonlines und pandas vor. Nach dem Laden des Datensatzes richten wir einen Tokenizer und ein Modell mit Trainingskonfigurationen für den Trainingsprozess ein.

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

# dataset path
dataset_path = "lamini/lamini_docs"

Modell, Trainingskonfiguration und Tokenizer einrichten

Als Nächstes wählen wir das Modell zur Feinabstimmung von Open-Supply-LLMs mit Lamini, „EleutherAI/pythia-70m“, aus und definieren seine Konfiguration unter training_config, wobei wir den Namen des vorab trainierten Modells und den Datensatzpfad angeben. Wir initialisieren den AutoTokenizer mit dem Tokenizer des Modells und setzen die Auffüllung auf das Finish-of-Sequence-Token. Dann tokenisieren wir die Daten und teilen sie mithilfe einer benutzerdefinierten Funktion, tokenize_and_split_data, in Trainings- und Testdatensätze auf. Schließlich instanziieren wir das Basismodell mit AutoModelForCausalLM, damit es Aufgaben der kausalen Sprachmodellierung ausführen kann. Außerdem legt der folgende Code die Rechenleistungsanforderungen für unseren Modellfeinabstimmungsprozess fest.

# mannequin identify
model_name = "EleutherAI/pythia-70m"

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

# establishing 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)

# arrange a baseline mannequin from lamini
base_model = Lamini(model_name)

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

Einrichten eines Trainings zur Feinabstimmung des Modells

Schließlich haben wir das Trainingsargument aufgestellt Parameter mit Hyperparametern. Es umfasst Lernrate, Epochen, Batchgröße, Ausgabeverzeichnis, Evaluierungsschritte, SAV, Aufwärmschritte, Evaluierungs- und Protokollierungsstrategie usw., um den benutzerdefinierten Trainingsdatensatz zu optimieren.

max_steps = 3

# skilled mannequin identify
trained_model_name = f"lamini_docs_{max_steps}_steps"
output_dir = trained_model_name

training_args = TrainingArguments(
  # Studying price
  learning_rate=1.0e-5,
  # Variety of coaching epochs
  num_train_epochs=1,

  # Max steps to coach for (every step is a batch of information)
  # Overrides num_train_epochs, if not -1
  max_steps=max_steps,

  # Batch dimension for coaching
  per_device_train_batch_size=1,

  # Listing to save lots of mannequin checkpoints
  output_dir=output_dir,

  # Different arguments
  overwrite_output_dir=False, # Overwrite the content material of the output listing
  disable_tqdm=False, # Disable progress bars
  eval_steps=120, # Variety of replace steps between two evaluations
  save_steps=120, # After # steps mannequin is saved
  warmup_steps=1, # Variety of warmup steps for studying price scheduler
  per_device_eval_batch_size=1, # Batch dimension for analysis
  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
)

Nach dem Festlegen der Trainingsargumente berechnet das System die Gleitkommaoperationen professional Sekunde (FLOPs) des Modells basierend auf der Eingabegröße und den Gradientenakkumulationsschritten. Dies gibt Aufschluss über die Rechenlast. Es bewertet auch die Speichernutzung und schätzt den Platzbedarf des Modells in Gigabyte. Sobald diese Berechnungen abgeschlossen sind, initialisiert ein Coach das Basismodell, die FLOPs, die gesamten Trainingsschritte und die vorbereiteten Datensätze für Coaching und Auswertung. Dieses Setup optimiert den Trainingsprozess und ermöglicht die Überwachung der Ressourcennutzung, die für die effiziente Handhabung der Feinabstimmung von Modellen im großen Maßstab von entscheidender Bedeutung ist. Am Ende des Trainings ist das feinabgestimmte Modell bereit für die Bereitstellung in der Cloud, um Benutzern als API zu dienen.

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

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

# Arrange a coach
coach = Coach(
    mannequin=base_model,
    model_flops=model_flops,
    total_steps=max_steps,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=test_dataset,
)

Abschluss

Zusammenfassend bietet dieser Artikel eine ausführliche Anleitung zum Verständnis der Notwendigkeit der Feinabstimmung von LLMs mithilfe der Lamini-Plattform. Er gibt einen umfassenden Überblick darüber, warum wir das Modell für benutzerdefinierte Datensätze und Geschäftsanwendungsfälle feinabstimmen müssen, und über die Vorteile der Verwendung von Lamini-Instruments. Wir haben auch eine Schritt-für-Schritt-Anleitung zur Feinabstimmung des Modells mithilfe eines benutzerdefinierten Datensatzes und LLM mit Instruments von Lamini gesehen. Lassen Sie uns die wichtigsten Erkenntnisse aus dem Weblog zusammenfassen.

Wichtige Erkenntnisse

1. Für die Feinabstimmung von Modellen anhand von Immediate-Engineering- und Retrieval-Augmented-Technology-Methoden ist Lernen erforderlich.
2. Nutzung von Plattformen wie Lamini für benutzerfreundliche {Hardware}-Setup- und Bereitstellungstechniken für fein abgestimmte Modelle, um die Benutzeranforderungen zu erfüllen
3. Wir bereiten Daten für die Feinabstimmungsaufgabe vor und richten eine Pipeline ein, um ein Basismodell mit einer breiten Palette von Hyperparametern zu trainieren.

Die in diesem Artikel gezeigten Medien sind nicht Eigentum von Analytics Vidhya und werden nach Ermessen des Autors verwendet.

Häufig gestellte Fragen

Ich bin auf Datenwissenschaft und maschinelles Lernen spezialisiert und verfüge über praktische Erfahrung in der Arbeit an verschiedenen Finish-to-Finish-Datenwissenschaftsprojekten. Ich bin Co-Leiter der Mumbai-Niederlassung von Omdena. Außerdem bin ich Kaggle-Meister und Bildungsbotschafter bei Streamlit mit Freiwilligen auf der ganzen Welt.