Alpaca-LoRA op je apparaat uitvoeren: zo doe je dat

Nu generatieve AI steeds meer terrein wint, grijpen ontwikkelaars wereldwijd de kans om spannende toepassingen te bouwen met natuurlijke taal. Eén tool in het bijzonder krijgt de laatste tijd veel aandacht: ChatGPT.

ChatGPT is een taalmodel ontwikkeld door OpenAI. Het is bedoeld als een AI-chatbot die een gesprek kan voeren dat aanvoelt als menselijk. Hoewel het een zeer nuttige tool is, kent het ook nadelen. ChatGPT is niet open-source, wat betekent dat de broncode niet toegankelijk is en niet kan worden aangepast. Het is bovendien extreem rekenintensief, waardoor zelf een implementatie bouwen geen goed idee is.

Dergelijke problemen hebben geleid tot een reeks ChatGPT-alternatieven, zoals Alpaca-LoRA, die vergelijkbaar kunnen functioneren met een open-sourcelicentie en minder resources vereisen.

In deze tutorial richten we ons specifiek op Alpaca-LoRA. We bespreken wat het is, welke vereisten er zijn om het op je apparaat te draaien en de stappen om het uit te voeren.

Wat is Alpaca LoRA?

Begin maart 2023 bracht Eric J. Wang het Alpaca-LoRA-project uit. Het is een project met code om de resultaten van Standford Alpaca te reproduceren met Parameter-Efficient Fine-Tuning (PEFT); dit is een bibliotheek waarmee ontwikkelaars transformer-gebaseerde modellen kunnen fine-tunen met LoRA.

LoRA begrijpen

Low-Rank Adaptation van Large Language Models (LoRA) is een methode om het trainen van grote modellen te versnellen met minder geheugenverbruik.

Zo werkt het:

• Bestaande gewichten bevriezen. Stel je het model voor als een complex web van onderling verbonden knooppunten (dit zijn de "gewichten"). Normaal gesproken pas je al deze knooppunten aan tijdens het trainen om het model te verbeteren. LoRA zegt: "Laten we hier niet aan komen; we laten ze zoals ze zijn."
• Nieuwe gewichten toevoegen. LoRA voegt vervolgens een paar nieuwe, eenvoudigere verbindingen (nieuwe gewichten) toe aan dit web.
• Alleen de nieuwe gewichten trainen. In plaats van het hele complexe web aan te passen, focus je alleen op het verbeteren van deze nieuwe, eenvoudigere verbindingen.

Daardoor bespaar je tijd en geheugen, terwijl je model toch beter wordt in zijn taken.

Voordelen van LoRA

De voordelen van LoRA zijn onder meer:

• Portabiliteit - Rangdecompositie-gewichten bevatten veel minder te trainen parameters dan het oorspronkelijke model; daardoor zijn de getrainde LoRA-gewichten gemakkelijk overdraagbaar en kun je ze zelfs op een Raspberry Pi draaien.
• Toegankelijkheid – In vergelijking met conventioneel fine-tunen is aangetoond dat LoRA het GPU-geheugenverbruik aanzienlijk vermindert; hierdoor is fine-tunen mogelijk op consumentenkaarten zoals Tesla T4, RTX 3080 of zelfs de RTX 2080 Ti.

Alpaca: het open-sourcemodel

Alpaca is daarentegen een open-source, op instructies gefinetuned AI-taalmodel op basis van de Large Language Model Meta AI (LLaMA). Het is ontwikkeld door een team onderzoekers van Stanford University met als doel grote taalmodellen (LLM's) toegankelijker te maken.

En daarmee komen we bij Alpaca-LoRA.

Het Alpaca-LoRA-model is een minder resource-intensieve versie van het Stanford Alpaca-model die LoRA inzet om het trainingsproces te versnellen met minder geheugenverbruik.

Vereisten voor Alpaca-LoRA

Om het Alpaca-LoRA-model lokaal te draaien, heb je een GPU nodig. Dat kan een low-spec GPU zijn zoals een NVIDIA T4 of een consumentenkaart zoals een 4090. Volgens Eric J. Wang, de maker van het project, draait het model “binnen enkele uren op een enkele RTX 4090”.

Let op: de instructies in dit artikel volgen die in de Alpaca-LoRA-repository van Eric J. Wang.

Alpaca-LoRA uitvoeren in 4 stappen

Stap 1: Maak de virtuele omgeving (optioneel)

Virtuele omgevingen zijn geïsoleerde containers waarin je de Python-afhankelijkheden voor een specifiek project bewaart. Zo houd je de dependencies van verschillende projecten gescheiden, wat delen eenvoudiger maakt en conflicten voorkomt.

Het is niet verplicht om er een te gebruiken om het Alpaca-LoRA-model te draaien, maar het is wel aan te raden.

Om via de opdrachtprompt in Windows een virtuele omgeving te maken, voer je het volgende uit:

py -m venv venv

Dit maakt een virtuele omgeving met de naam venv in je huidige werkmap.

Let op: je kunt elke gewenste naam voor je virtuele omgeving gebruiken door de tweede venv te vervangen door je voorkeursnaam.

Voordat je afhankelijkheden installeert, moet je de virtuele omgeving activeren. Voer de volgende opdracht uit om je virtuele omgeving te activeren:

venv\Scripts\activate.bat

Als je de virtuele omgeving niet meer gebruikt, voer je de volgende opdracht uit om deze te deactiveren:

deactivate

Nu ben je klaar om aan de slag te gaan met Alpaca-LoRA.

Stap 2: Setup

De eerste stap om het Alpaca-LoRA-model te draaien is de repository van GitHub klonen en de benodigde dependencies installeren.

Gebruik de volgende opdracht om de GitHub-repository te klonen:

git clone https://github.com/tloen/alpaca-lora.git

Navigeer vervolgens naar de zojuist gekloonde alpaca-lora-repository met:

cd alpaca-lora

En voer de volgende opdracht uit om de dependencies te installeren:

pip install -r requirements.txt

Stap 3: Het model fine-tunen (optioneel)

De alpaca-lora-repository bevat een bestand genaamd finetune.py. finetune.py bevat onder andere een eenvoudige toepassing van Parameter-Efficient Fine-Tuning (PEFT) op het LLaMA-model.

Dit is het bestand dat je moet uitvoeren als je de hyperparameters van het model wilt bijstellen, maar het is niet verplicht. Volgens de auteur van de repository geldt: “Zonder hyperparameter-tuning levert het LoRA-model outputs op die vergelijkbaar zijn met het Stanford Alpaca-model. Verdere tuning kan mogelijk betere prestaties behalen [...].”

Hier is een voorbeeld van hoe je het bestand finetune.py gebruikt:

python -m finetune.py \
    --base_model 'decapoda-research/llama-7b-hf' \
    --data_path 'yahma/alpaca-cleaned' \
    --output_dir './lora-alpaca' \
    --batch_size 128 \
    --micro_batch_size 4 \
    --num_epochs 3 \
    --learning_rate 1e-4 \
    --cutoff_len 512 \
    --val_set_size 2000 \
    --lora_r 8 \
    --lora_alpha 16 \
    --lora_dropout 0.05 \
    --lora_target_modules '[q_proj,v_proj]' \
    --train_on_inputs \
    --group_by_length

Stap 4: Het model draaien / Inference

Ook in de alpaca-lora-repository staat een bestand genaamd generate.py. Het uitvoeren van generate.py doet het volgende:

• Het basismodel inlezen vanaf de Hugging Face model hub
• De modelgewichten inlezen uit tloen/alpaca-lora-7b
• Een Gradio-interface starten waarin inferentie wordt uitgevoerd op een opgegeven input.

Op het moment van schrijven is de meest recente Alpaca-LoRA-adapter die is gebruikt om het model te trainen alpaca-lora-7b. Dit vond plaats op 26 maart 2023 met de volgende opdracht:

python finetune.py \
    --base_model='decapoda-research/llama-7b-hf' \
    --num_epochs=10 \
    --cutoff_len=512 \
    --group_by_length \
    --output_dir='./lora-alpaca' \
    --lora_target_modules='[q_proj,k_proj,v_proj,o_proj]' \
    --lora_r=16 \
    --micro_batch_size=8

Als je een andere adapter wilt gebruiken, kan dat door het bestand generate.py uit te voeren met een link naar de locatie van je voorkeursadapter.

python generate.py \
    --load_8bit \
    --base_model 'decapoda-research/llama-7b-hf' \
    --lora_weights 'tloen/alpaca-lora-7b'

Afronding

Alpaca-LoRA is een minder resource-intensieve versie van het Stanford Alpaca-model. Dit wordt bereikt met low-rank adaptation van large language models (LoRA), waarmee het trainingsproces wordt versneld en veel minder geheugen nodig is dan bij het oorspronkelijke Alpaca-model.

Leer meer over large language models (LLM's) en generatieve AI met de volgende tutorials:

• Introductie tot Meta AI LLaMA
• Hoe train je een LLM met PyTorch: een stapsgewijze gids