Er zijn meestal drie verschillende trainingsfasen voor grote taalmodellen:

1. Vooraf trainen: In deze fase wordt het model getraind op een grote corpus van ruwe tekstgegevens om te leren hoe het het volgende token of woord kan voorspellen. Het resultaat is een basismodel dat veel algemene kennis heeft verworven uit de tekst, maar nog niet erg nuttig is voor specifieke taken.

2. Supervisie Fine-Tuning: Om het basismodel nuttiger te maken, is de tweede fase supervisie fine-tuning. In deze fase wordt het model getraind op vraag-antwoord paren of instructie-antwoord paren. De input is een vraag of instructie, en de output is het gewenste antwoord. Deze fase stelt het model in staat om taakspecifieke kennis en vaardigheden te leren.

3. Voorkeursafstemming: De optionele derde fase is voorkeursafstemming, waarbij het model wordt getraind om te leren wat de gebruiker prefereert in termen van antwoorden, of om het model af te stemmen op bepaalde principes. Dit wordt vaak gedaan met behulp van technieken als Reinforcement Learning from Human Feedback (RLHF) of Debate Policy Optimization (DPO).

Het doel van deze video is om te focussen op de supervisie fine-tuning fase, specifiek hoe je de Llama 3.1 model kunt fine-tunen met behulp van de Unsloth bibliotheek. De video zal verschillende fine-tuning technieken behandelen, zoals volledige fine-tuning, LoRA en QLoRA, en de afwegingen tussen deze technieken bespreken in termen van prestaties en geheugen vereisten.

Er zijn drie populaire opties voor supervisie fine-tuning:

1. Volledige Fine-Tuning: In deze aanpak neem je het oorspronkelijke model en werk je de gewichten bij met de instructie fine-tune dataset. Dit zal de beste prestaties opleveren, maar de VRAM-vereiste zal hoog zijn.

2. LoRA (Low-Rank Adaptation): In plaats van de gewichten direct bij te werken, voeg je externe adapters toe aan het model. Het aantal parameters in deze externe adapters kan worden gecontroleerd. De gewichtsupdates voor deze adapters worden uitgevoerd in 16-bit precisie, en vervolgens samengevoegd met de oorspronkelijke modelgewichten. Deze aanpak biedt snelle training, maar is nog steeds kostbaar vanwege de 16-bit bewerkingen.

3. QLoRA (Quantized LoRA): Dit is vergelijkbaar met LoRA, maar de gewichtsupdates worden uitgevoerd in 4-bit precisie, en de modelgewichten worden ook in 4-bit gehouden. Dit vereist minder VRAM, maar de prestaties zijn mogelijk niet zo goed als LoRA of volledige fine-tuning.

Om de LoRA adapters in te stellen, zijn er een paar belangrijke hyperparameters om rekening mee te houden:

1. Rang: De rang van de LoRA adapters bepaalt het aantal parameters dat tijdens fine-tuning zal worden bijgewerkt. Een lagere rang betekent minder parameters, wat de VRAM-vereisten vermindert, maar ook de mogelijkheid van het model om aan te passen kan beperken. Een hogere rang biedt meer flexibiliteit, maar vereist meer VRAM.

2. LoRA Alpha: Deze parameter bepaalt de bijdrage van de LoRA adapters aan de uiteindelijke modelgewichten. Een hogere LoRA Alpha-waarde betekent dat de LoRA adapters een sterkere invloed zullen hebben, terwijl een lagere waarde betekent dat ze een zwakkere invloed zullen hebben.

3. LoRA Dropout: Deze parameter bepaalt de dropout-snelheid die wordt toegepast op de LoRA adapters tijdens de training. Het verhogen van de dropout-snelheid kan helpen bij het voorkomen van overfitting, maar kan ook de prestaties van het model verminderen.

Om de gegevens voor fine-tuning voor te bereiden, moeten we de prompt-sjabloon instellen en het einde-van-sequentie-token opgeven.

De prompt-sjabloon is cruciaal, omdat deze het formaat van de invoergegevens definieert waarop het model zal worden getraind. Voor de Llama 3.1 familie zullen we de Alpaca prompt-sjabloon gebruiken, die een instructie en een invoer bevat die meer context biedt. Van het model wordt dan verwacht dat het een passend antwoord genereert.

# Alpaca prompt-sjabloon
prompt_template = "Hieronder staat een instructie die een taak beschrijft, gekoppeld aan een invoer die meer context biedt. Reageer met een relevant antwoord.\n\nInstructie: {instruction}\nInvoer: {input}\nOutput:"

Bovendien moeten we het einde-van-sequentie-token opgeven om te voorkomen dat het model oneindig tekst genereert. Dit is een belangrijke stap waar veel mensen problemen mee hebben gehad bij het gebruik van de gekwantiseerde versies van de modellen met LamaCPP.

# Stel het einde-van-sequentie-token in
end_token = "</s>"

Door de prompt-sjabloon en het einde-van-sequentie-token in te stellen, zorgen we ervoor dat de gegevens goed zijn opgemaakt voor het fine-tuning proces, wat een cruciale stap is om goede resultaten te bereiken.

Om het model te trainen, zullen we de SFT (Supervised Fine-Tuning) Trainer van het TRL pakket gebruiken, dat is gemaakt en onderhouden door Hugging Face.

Eerst geven we ons model, tokenizer en de dataset aan de SFT Trainer. In dit geval gebruiken we de text kolom uit de dataset, omdat we onze prompt-sjabloon hebben ingesteld om dit veld te gebruiken.

We stellen ook de maximale sequentielengte in, die gebaseerd moet zijn op de voorbeelden in je trainingsgegevens. Houd er rekening mee dat een hogere sequentielengte de VRAM-vereisten zal verhogen.

Vervolgens configureren we de trainingsargumenten, zoals het apparaat (in dit geval een T4 GPU op Google Colab met ongeveer 15GB VRAM) en het aantal trainingstappen.

Tenslotte voeren we de trainer uit, en je kunt de afnemende loss observeren, wat een goede indicatie is van de voortgang van de training.

De training duurde ongeveer 8 minuten, en de piek gereserveerd geheugen was ongeveer 8GB, wat ongeveer 53% is van de beschikbare VRAM op de T4 GPU. Dit toont de efficiëntie van de Unsloth aanpak, die fine-tuning mogelijk maakt met een relatief lage VRAM-vereiste.

Om inferentie uit te voeren, kunnen we de for_inference class of methode gebruiken op de FastLanguageModel class. We moeten het getrainde model en de invoer prompt in Alpaca-formaat opgeven. We kunnen ook het maximale aantal tokens instellen dat moet worden gegenereerd.

# Voer inferentie uit
input_prompt = alpaca_prompt(instruction, input)
output = model.for_inference(input_prompt, max_new_tokens=256)
print(output)

Om streaming in te schakelen, kunnen we een Streamer object maken en deze doorgeven aan de for_inference methode. Dit zal de antwoorden één token tegelijk weergeven.

# Schakel streaming in
streamer = Streamer()
output = model.for_inference(input_prompt, max_new_tokens=256, streamer=streamer)

Hiermee kun je nu inferentie uitvoeren op je fine-tuned model en zelfs streaming inschakelen voor een interactievere ervaring.

Om het fine-tuned model en tokenizer op te slaan, kun je de save_pretrained() functie gebruiken op het model en de tokenizer:

model.save_pretrained("pad/om/model/op/te/slaan")
tokenizer.save_pretrained("pad/om/tokenizer/op/te/slaan")

Dit zal de modelgewichten en tokenizer opslaan in de opgegeven mappen als een set JSON-bestanden.

Om het opgeslagen model en tokenizer te laden, kun je dezelfde FastLanguageModel class gebruiken en de lokale mappen opgeven:

model = FastLanguageModel.from_pretrained("pad/om/model/op/te/slaan")
tokenizer = FastLanguageModel.from_pretrained("pad/om/tokenizer/op/te/slaan")

Dit zal het model en de tokenizer laden vanuit de opgeslagen bestanden.

Een ander geweldig kenmerk van Unsloth is de mogelijkheid om de modellen op te slaan in verschillende formaten, zoals 16-bit floating-point precisie voor VLLM of direct in GGUF-formaat voor LamaCPP. Dit maakt eenvoudige implementatie en integratie met verschillende platforms en frameworks mogelijk.

Unsloth introduceert ook een nieuwe UI gebaseerd op Gradio, waarmee je de met Unsloth getrainde modellen kunt uitvoeren en interactieve chatgesprekken kunt voeren. Je kunt de Unsloth Studio repository klonen en het bijgeleverde Colab-notebook uitvoeren om deze functie te ervaren.

Unsloth heeft een nieuwe chat-UI geïntroduceerd op basis van de Radish bibliotheek, waarmee je gemakkelijk kunt communiceren met de taalmodellen die zijn getraind met behulp van Unsloth. Deze chat-UI biedt een gebruiksvriendelijke interface voor het chatten met de modellen en het verkennen van hun mogelijkheden.

Om de chat-UI te gebruiken, kun je de Unsloth studio repository klonen en het bijgeleverde Google Colab-notebook uitvoeren. Dit zal de benodigde omgeving instellen en de chat-UI starten, waar je kunt beginnen te communiceren met het taalmodel.

De chat-UI ondersteunt functies als streaming van antwoorden, waardoor je de output van het model kunt zien terwijl deze wordt gegenereerd. Dit kan nuttig zijn om het denkproces van het model te observeren en te zien hoe het antwoorden genereert.

Bovendien stelt Unsloth's chat-UI je in staat om je fine-tuned modellen op te slaan en te laden, waardoor het gemakkelijk is om door te gaan met het werken aan je aangepaste taalmodellen. Je kunt je modellen ook exporteren in verschillende formaten, zoals 16-bit floating-point precisie voor VLLM of GGUF-formaat voor LamaCPP, wat flexibiliteit biedt in hoe je je modellen gebruikt en implementeert.

Over het algemeen is Unsloth's nieuwe chat-UI een waardevol hulpmiddel voor het communiceren met en verkennen van de mogelijkheden van taalmodellen die zijn getraind met behulp van het Unsloth framework.