Hoe je Llama-2 (7B) kunt fine-tunen om ChatGPT te verslaan

Large language models (LLMs) worden steeds krachtiger en worden gebruikt voor uiteenlopende taken, waaronder chatbots, tekstgeneratie en vraag-antwoordsystemen. Het trainen van LLMs kan echter duur en bronintensief zijn. In dit blogbericht laten we je zien hoe je een kleiner LLM (7B) kunt fine-tunen om beter te presteren dan ChatGPT.

Fine-tuning is een proces waarbij een LLM wordt getraind op een specifieke dataset om de prestaties op een bepaalde taak te verbeteren. In dit geval gaan we een 7B LLM fine-tunen om twee getallen met elkaar te vermenigvuldigen.

Laten we dus beginnen met de prestaties van verschillende large language models op een eenvoudige vermenigvuldigingstaak: 458*987 = 452046.

Eerst kijken we naar het recent uitgebrachte Llama-2-7B-model van Meta. We hebben Llama-2 geïmplementeerd op TrueFoundry en het uitgeprobeerd met de LangChain-integraties van TrueFoundry. Hier is het resultaat daarvan.

We kunnen duidelijk zien dat het model niet goed presteert op deze taak (wat ook te verwachten is gezien de grootte van het model). Laten we kijken hoe de state-of-the-art modellen presteren op dezelfde taak:

Laten we kijken naar het resultaat van ChatGPT (GPT-3.5 Turbo):

Het antwoord (451.086) ligt erg dicht bij het werkelijke antwoord (452.046), maar het is niet correct.
Laten we het proberen met een andere prompt (om een stapsgewijze berekening uit te voeren en te zien wat er gebeurt):

0:00/1×

ChatGPT met aangepaste prompt voor vermenigvuldiging

Maar opnieuw komt het uit op een onjuist resultaat: 450.606 🤨

Laten we tot slot de State of the Art (GPT-4) proberen en kijken hoe deze presteert op de taak:

Het zit heel dicht bij het juiste antwoord (452.046) en kan voor iedereen correct lijken. Maar het antwoord is duidelijk onjuist.

Waarom presteren LLMs slecht op eenvoudige vermenigvuldigingstaken?

Het antwoord op deze vraag is heel eenvoudig. Ze zijn er niet voor "getraind".

LLMs worden getraind op gigantische datasets met tekst en code, maar deze data is niet altijd gestructureerd op een manier die helpt bij wiskundig redeneren. De data bevat bijvoorbeeld mogelijk geen expliciete representaties van wiskundige concepten zoals optellen, aftrekken, vermenigvuldigen en delen. Hierdoor kan het voor LLMs moeilijk zijn om te leren hoe ze deze bewerkingen correct moeten uitvoeren.

Dus vroegen we ons af of het mogelijk is om een LLM te trainen in het uitvoeren van wiskundige bewerkingen? We hebben een experiment uitgevoerd en de resultaten waren zeer veelbelovend!

Llama-2 7B fine-tunen om te vermenigvuldigen

Een dataset samenstellen

Om te beginnen hebben we een dataset samengesteld van 40.000 rijen met prompts en instructies. We hebben geprobeerd de exacte stappen van de lange vermenigvuldigingsmethode na te bootsen: het vermenigvuldigtal en de vermenigvuldiger opsplitsen in hun afzonderlijke cijfers, elk cijfer van het vermenigvuldigtal vermenigvuldigen met elk cijfer van de vermenigvuldiger en de resultaten op de juiste posities plaatsen op basis van hun plaatswaarden. Ten slotte worden alle afzonderlijke producten bij elkaar opgeteld om tot het eindresultaat te komen.

Hier is een voorbeeldprompt:

You are a helpful assistant providing detailed answers to multiplication questions. Ensure you provide a thorough explanation using the long multiplication method for the math problem given below.

If you don't know the answer to a question, please don't share false information. What is 5244 * 1932?

En hier is een voorbeeldrespons:

Here are the steps for multiplying 5244 * 1932 using the long multiplication method.
Step 1: Break 5244 into its individual digits: 5 (thousands place), 2 (hundreds place), 4 (tens place), and 4 (ones place).
Step 2: Similarly, break 1932 into its individual digits: 1 (thousands place), 9 (hundreds place), 3 (tens place), and 2 (ones place).
- 4 (from 1 place of first number) * 2 (from 1 place of second number) = 8 -> Shift it 0 places to the left (because we are multiplying with the 1 place of the second number) to get 8
- 4 (from 1 place of first number) * 3 (from 10 place of second number) = 12 -> Shift it 1 places to the left (because we are multiplying with the 10 place of the second number) to get 120
- 4 (from 1 place of first number) * 9 (from 100 place of second number) = 36 -> Shift it 2 places to the left (because we are multiplying with the 100 place of the second number) to get 3600
- 4 (from 1 place of first number) * 1 (from 1000 place of second number) = 4 -> Shift it 3 places to the left (because we are multiplying with the 1000 place of the second number) to get 4000
- 4 (from 10 place of first number) * 2 (from 1 place of second number) = 8 -> Shift it 1 places to the left (because we are multiplying with the 1 place of the second number) to get 80
- 4 (from 10 place of first number) * 3 (from 10 place of second number) = 12 -> Shift it 2 places to the left (because we are multiplying with the 10 place of the second number) to get 1200
- 4 (from 10 place of first number) * 9 (from 100 place of second number) = 36 -> Shift it 3 places to the left (because we are multiplying with the 100 place of the second number) to get 36000
- 4 (from 10 place of first number) * 1 (from 1000 place of second number) = 4 -> Shift it 4 places to the left (because we are multiplying with the 1000 place of the second number) to get 40000
- 2 (from 100 place of first number) * 2 (from 1 place of second number) = 4 -> Shift it 2 places to the left (because we are multiplying with the 1 place of the second number) to get 400
- 2 (from 100 place of first number) * 3 (from 10 place of second number) = 6 -> Shift it 3 places to the left (because we are multiplying with the 10 place of the second number) to get 6000
- 2 (from 100 place of first number) * 9 (from 100 place of second number) = 18 -> Shift it 4 places to the left (because we are multiplying with the 100 place of the second number) to get 180000
- 2 (from 100 place of first number) * 1 (from 1000 place of second number) = 2 -> Shift it 5 places to the left (because we are multiplying with the 1000 place of the second number) to get 200000
- 5 (from 1000 place of first number) * 2 (from 1 place of second number) = 10 -> Shift it 3 places to the left (because we are multiplying with the 1 place of the second number) to get 10000
- 5 (from 1000 place of first number) * 3 (from 10 place of second number) = 15 -> Shift it 4 places to the left (because we are multiplying with the 10 place of the second number) to get 150000
- 5 (from 1000 place of first number) * 9 (from 100 place of second number) = 45 -> Shift it 5 places to the left (because we are multiplying with the 100 place of the second number) to get 4500000
- 5 (from 1000 place of first number) * 1 (from 1000 place of second number) = 5 -> Shift it 6 places to the left (because we are multiplying with the 1000 place of the second number) to get 5000000

Now, add all these results together:
The sum of 8 + 120 + 3600 + 4000 + 80 + 1200 + 36000 + 40000 + 400 + 6000 + 180000 + 200000 + 10000 + 150000 + 4500000 + 5000000 = 10131408.

Vervolgens hebben we een Python-script geschreven dat prompt-respons-paren genereert door willekeurig twee getallen te selecteren voor vermenigvuldiging. We hebben zo een dataset van 40.000 rijen samengesteld.

Het model fine-tunen

Zodra de dataset gereed is, moeten we het model fine-tunen.
We gebruiken de gefine-tunde chat-variant van Meta (7 miljard parameters) van Llama-2 als basismodel.

We hebben de fine-tuning uitgevoerd met QLoRA fine-tuning met behulp van de BitsAndBytes- en Peft-bibliotheken. Hier is de LoRA-configuratie die we hebben gebruikt:

LoraConfig(
   lora_alpha=16,
   lora_dropout=0.1,
   r=64,
   bias="none",
   task_type="CAUSAL_LM",
   target_modules=[
       "q_proj",
       "k_proj",
       "v_proj",
       "o_proj",
   ],
)


Het kostte ongeveer 8 uur om te trainen op een A100 40GB GPU-machine voor een dataset van 40.000 rijen.

Ten slotte hebben we het gefine-tunde model opnieuw geïmplementeerd op TrueFoundry en dit zijn de resultaten:

Uiteindelijk!! We kunnen zien dat het gefine-tunde model in staat is het resultaat correct te berekenen.

Conclusie

Hoewel rekenen geen taak is waarvoor we een LLM primair zouden gebruiken, laat dit voorbeeld zien hoe een "klein" LLM (7B parameters) dat goed is gefine-tund voor een specifieke taak, beter kan presteren dan de "grote" LLMs (zoals GPT-3.5 Turbo - 175B parameters en GPT-4) op een specifieke taak.

De kleinere, gefine-tunde modellen zijn goedkoop in inference, beter in gespecialiseerde taken en kunnen eenvoudig in je eigen cloud worden geïmplementeerd!

We hebben een gedetailleerde blog geschreven over het fine-tunen van Llama 2

‍

Llama 2 LLM: Implementeer & Fine-tune in je cloud

Meta's open-source LLM, Llama 2, is gratis te gebruiken. In deze blog leggen we uit hoe je het kunt fine-tunen en implementeren in je cloud.

TrueFoundry Blog Truefoundry