Large Language Models (LLM’s) zijn belangrijke onderdelen van moderne AI-toepassingen, vooral voor natural language processing. Ze kunnen menselijke taal efficiënt verwerken en begrijpen, met toepassingen van virtuele assistenten en machinevertaling tot samenvatten van tekst en vraag-en-antwoord.
Bibliotheken zoals LangChain maken het makkelijker om end-to-end AI-toepassingen te bouwen, zoals hierboven genoemd. Onze tutorial Introduction to LangChain for Data Engineering & Data Applications geeft een overzicht van wat je met LangChain kunt doen, inclusief de problemen die LangChain oplost en voorbeelden van datagebruikscases.
Dit artikel legt het volledige proces uit van het trainen van een large language model, van het inrichten van je werkomgeving tot de uiteindelijke implementatie met Pytorch 2.0.1, een dynamisch en flexibel deep-learningframework dat een eenvoudige en duidelijke modelimplementatie mogelijk maakt.
Vereisten
Om het meeste uit deze content te halen, is het belangrijk dat je je prettig voelt met programmeren in Python, basiskennis hebt van deep learning-concepten en transformers, en bekend bent met het Pytorch-framework. De volledige broncode is beschikbaar op GitHub.
Voordat we in de kernimplementatie duiken, moeten we de relevante bibliotheken installeren en importeren. Ook is het belangrijk om te vermelden dat het trainingsscript is geïnspireerd op deze repository van Hugging Face.
Installatie van bibliotheken
Het installatieproces staat hieronder beschreven:
Allereerst gebruiken we de %%bash-instructie om de installatiecommando’s in één cel als een bash-commando in de Jupyter Notebook uit te voeren.
- Trl: gebruikt om transformer-taalmodellen te trainen met reinforcement learning.
- Peft gebruikt parameter-efficiënte fine-tuning (PEFT)-methoden om het voorgetrainde model efficiënt aan te passen.
- Torch: een veelgebruikte open-source machinelearningbibliotheek.
- Datasets: helpt bij het downloaden en laden van veelvoorkomende machinelearningdatasets.
Transformers: een bibliotheek ontwikkeld door Hugging Face met duizenden voorgetrainde modellen voor uiteenlopende teksttaken zoals classificatie, samenvatting en vertaling.
%%bash
pip -q install trl
pip -q install peft
pip -q install torch
pip -q install datasets
pip -q install transformers
Nu kunnen deze modules als volgt worden geïmporteerd:
import torch
from trl import SFTTrainer
from datasets import load_dataset
from peft import LoraConfig, get_peft_model, prepare_model_for_int8_training
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArgumentsData laden en voorbereiden
De alpaca-dataset, vrij beschikbaar op Hugging Face, wordt gebruikt voor deze illustratie. De dataset heeft drie hoofdkolommen: instructions, input en output. Deze kolommen worden gecombineerd tot één uiteindelijke text-kolom.
De instructie om de dataset te laden staat hieronder. Je geeft de naam van de dataset op, in dit geval tatsu-lab/alpaca:
train_dataset = load_dataset("tatsu-lab/alpaca", split="train")
print(train_dataset)We zien dat de resulterende data in een dictionary met twee keys zit:
- Features: bevat de hoofdkolommen van de data
- Num_rows: komt overeen met het totale aantal rijen in de data
Structuur van de train_dataset
De eerste vijf rijen kun je tonen met de volgende instructie. Zet de dictionary eerst om naar een pandas-dataframe en toon vervolgens de rijen.
pandas_format = train_dataset.to_pandas()
display(pandas_format.head())
Eerste vijf rijen van de train_dataset
Voor een betere visualisatie printen we de informatie van de eerste drie rijen. Daarvoor moeten we eerst de bibliotheek textwrap installeren om het maximaal aantal woorden per regel op 50 te zetten. De eerste printopdracht scheidt elk blok met 15 streepjes.
import textwrap
for index in range(3):
print("---"*15)
print("Instruction:
{}".format(textwrap.fill(pandas_format.iloc[index]["instruction"],
width=50)))
print("Output:
{}".format(textwrap.fill(pandas_format.iloc[index]["output"],
width=50)))
print("Text:
{}".format(textwrap.fill(pandas_format.iloc[index]["text"],
width=50)))
Details van de eerste drie rijen
Modeltraining
Voordat we het model gaan trainen, moeten we enkele vereisten instellen:
- Voorgetraind model: We gebruiken het voorgetrainde model Salesforce/xgen-7b-8k-base, beschikbaar op Hugging Face. Salesforce trainde deze serie van 7B LLM’s, XGen-7B genaamd, met standaard dichte attention op sequenties tot 8K voor tot wel 1,5T tokens.
- Tokenizer: Dit is nodig voor tokenisatietaken op de trainingsdata. De code om het voorgetrainde model en de tokenizer te laden is als volgt:
pretrained_model_name = "Salesforce/xgen-7b-8k-base"
model = AutoModelForCausalLM.from_pretrained(pretrained_model_name, torch_dtype=torch.bfloat16)
tokenizer = AutoTokenizer.from_pretrained(pretrained_model_name, trust_remote_code=True)Trainingsconfiguratie
Voor het trainen zijn trainingsargumenten en configuraties nodig. De twee belangrijkste configuratieobjecten worden hieronder gedefinieerd: een instantie van TrainingArguments, een instantie van het LoraConfig-model en tot slot het SFTTrainer-model.
TrainingArguments
Dit wordt gebruikt om de parameters voor modeltraining te definiëren.
In dit specifieke scenario beginnen we met het definiëren van de bestemming waar het getrainde model wordt opgeslagen met het attribuut output_dir, waarna we extra hyperparameters definiëren, zoals de optimalisatiemethode, de learning rate, het aantal epochs en meer.
model_training_args = TrainingArguments(
output_dir="xgen-7b-8k-base-fine-tuned",
per_device_train_batch_size=4,
optim="adamw_torch",
logging_steps=80,
learning_rate=2e-4,
warmup_ratio=0.1,
lr_scheduler_type="linear",
num_train_epochs=1,
save_strategy="epoch"
)LoRAConfig
De belangrijkste argumenten in dit scenario zijn de rang van de low-rank-transformatiematrix in LoRA, ingesteld op 16. Vervolgens staat de schaalfactor voor de extra parameters in LoRA op 32.
Daarnaast is de dropoutratio 0,05, wat betekent dat 5% van de inputeenheden tijdens het trainen wordt genegeerd. Tot slot, omdat we te maken hebben met causale taalmodellering, wordt de taak geïnitialiseerd met het attribuut CAUSAL_LM.
SFTTrainer
Dit traint het model met behulp van de trainingsdata, de tokenizer en aanvullende informatie zoals de bovenstaande modellen.
Omdat we het tekstveld uit de trainingsdata gebruiken, is het belangrijk om naar de verdeling te kijken om te helpen bij het instellen van het maximale aantal tokens in een sequentie.
import matplotlib.pyplot as plt
pandas_format['text_length'] = pandas_format['text'].apply(len)
plt.figure(figsize=(10,6))
plt.hist(pandas_format['text_length'], bins=50, alpha=0.5, color='g')
plt.title('Distribution of Length of Text')
plt.xlabel('Length of Text')
plt.ylabel('Frequency')
plt.grid(True)
plt.show()
Verdeling van de lengte van de text-kolom
Op basis van bovenstaande observatie zien we dat het merendeel van de teksten een lengte tussen 0 en 1000 heeft. Ook zien we hieronder dat slechts 4,5% van de tekstdocumenten een lengte heeft die groter is dan 1024.
mask = pandas_format['text_length'] > 1024
percentage = (mask.sum() / pandas_format['text_length'].count()) * 100
print(f"The percentage of text documents with a length greater than 1024 is: {percentage}%")
Vervolgens stellen we het maximale aantal tokens in de sequentie in op 1024, zodat tekst die langer is wordt afgekapt.
SFT_trainer = SFTTrainer(
model=model,
train_dataset=train_dataset,
dataset_text_field="text",
max_seq_length=1024,
tokenizer=tokenizer,
args=model_training_args,
packing=True,
peft_config=lora_peft_config,
)Training uitvoeren
Met alle vereisten op orde kunnen we nu het trainingsproces van het model starten zoals hieronder:
tokenizer.pad_token = tokenizer.eos_token
model.resize_token_embeddings(len(tokenizer))
model = prepare_model_for_int8_training(model)
model = get_peft_model(model, lora_peft_config)
training_args = model_training_args
trainer = SFT_trainer
trainer.train()Belangrijk om te vermelden: deze training wordt uitgevoerd in een cloudomgeving met een GPU, wat het totale trainingsproces versnelt. Trainen op een lokale computer kost waarschijnlijk meer tijd.
Onze blog Voor- en nadelen van LLM’s in de cloud vs. lokaal draaien biedt belangrijke aandachtspunten om de optimale inzetstrategie voor LLM’s te kiezen
Laten we begrijpen wat er in de bovenstaande codefragmenten gebeurt:
- tokenizer.pad_token = tokenizer.eos_token: Stelt de paddingtoken in op dezelfde token als het einde-van-zin-token.
- model.resize_token_embeddings(len(tokenizer)): Past de token-embeddinglaag van het model aan aan de lengte van de tokenizer-vocabulaire.
- model = prepare_model_for_int8_training(model): Maakt het model klaar voor training met INT8-precisie, waarschijnlijk door kwantisatie.
- model = get_peft_model(model, lora_peft_config): Past het gegeven model aan op basis van de PEFT-configuratie.
- training_args = model_training_args: Wijst de vooraf gedefinieerde trainingsargumenten toe aan training_args.
- trainer = SFT_trainer: Wijst de SFTTrainer-instantie toe aan de variabele trainer.
- trainer.train(): Start het trainingsproces van het model volgens de opgegeven specificaties.
Conclusie
Dit artikel gaf een duidelijke handleiding voor het trainen van een large language model met PyTorch. Beginnend bij de datasetvoorbereiding, liep het door de stappen van het voorbereiden van de vereisten, het instellen van de trainer en uiteindelijk het uitvoeren van het trainingsproces.
Hoewel we een specifieke dataset en een voorgetraind model gebruikten, is het proces grotendeels hetzelfde voor andere compatibele opties. Nu je weet hoe je een LLM traint, kun je deze kennis inzetten om andere geavanceerde modellen te trainen voor diverse NLP-taken.
Bekijk onze gids over hoe je LLM-toepassingen bouwt met LangChain om de kracht van large language models verder te verkennen. Of als je de concepten van large language models nog wilt verkennen, bekijk dan onze cursus om je leerproces voort te zetten.
