Load-Testen van LLM’s met LLMPerf

Wanneer je een Large Language Model (LLM) implementeert, is dat niet het eindpunt. Het is cruciaal om ervoor te zorgen dat je model bestand is tegen de verwachte belasting in de productieomgeving. Dit proces, bekend als load-testing, helpt bij het garanderen van de prestaties van je model onder verschillende omstandigheden.

In dit artikel onderzoeken we de noodzaak van load-testing bij LLM’s en hoe je de tool LLMPerf kunt inzetten om dit te realiseren. We bespreken specifieke metrics die relevant zijn voor LLM’s, inclusief token-gebaseerde prestaties, en hoe deze essentiële gegevens kunnen worden verzameld.

Wat is Load-Testing?

Load-testing is een techniek waarbij een systeem of model wordt getest met een bepaalde hoeveelheid verkeer, zodat de prestaties kunnen worden geanalyseerd. Dit helpt om te bevestigen dat het systeem of model effectief blijft functioneren onder verschillende belastingsniveaus. Voor traditionele machine learning modellen zijn benchmarks zoals ‘requests per second’ (RPS) vaak gebruikt, maar LLM’s vereisen een andere aanpak.

Waarom is Load-Testing Belangrijk voor LLM’s?

LLM’s, zoals ChatGPT of Claude, hebben doorgaans een lagere RPS en hogere latentie dan traditionele ML-modellen. Dit komt voornamelijk door de complexiteit en de grotere rekenkracht die nodig is voor het verwerken van teksten. Om deze redenen geven we de voorkeur aan token-gebaseerde metrics. Tokens representeren feitelijk de ingangs- en uitgangseenheden van tekst en geven daarmee een nauwkeuriger beeld van de prestaties van een LLM.

Token-Geef Gegevens: Wat Te Meten?

Bij het load-testen van LLM’s zijn er verschillende belangrijke metrics om in de gaten te houden:

1. Tijd tot het Eerste Token: De tijd die verstrijkt voordat het eerste token wordt gegenereerd nadat een verzoek is gedaan.
2. Totaal Aantal Output Tokens per Seconde: Dit geeft weer hoeveel tokens het model per seconde kan genereren, wat een betere indicatie van prestaties is dan RPS.

Wat is LLMPerf?

LLMPerf is een innovatieve tool ontworpen om load-testing voor LLM’s gemakkelijker te maken. Het is gebaseerd op Ray, een populaire framework voor gedistribueerde computing in Python. Met LLMPerf kunnen ontwikkelaars gesimuleerde productieverkeer genereren en zo de respons van hun LLM’s op verschillende scenario’s testen.

Hoe LLMPerf in Te Stellen

LLMPerf biedt een scala aan parameters die aangepast kunnen worden. Dit omvat onder andere:

• Model: Het LLM dat je gebruikt, bijvoorbeeld Claude 3 op Amazon Bedrock.
• Tokens: Zowel de gemiddelde input- als outputtokens kunnen worden gespecificeerd, evenals de standaarddeviatie hiervan.
• Aantal Gelijktijdige Verzoeken: Dit geeft aan hoeveel gelijktijdige verzoeken je model moet kunnen verwerken.
• Duur van de Test: De tijd in seconden dat de test moet duren.

LLMPerf Toepassen op Amazon Bedrock

Configuratie

Om LLMPerf effectief te gebruiken, moet je beginnen met een geschikt AWS-omgeving. Zorg ervoor dat je de juiste AWS-credentials hebt om toegang te krijgen tot het model dat je wilt testen.

Voorbeeldconfiguratie

Hier is een voorbeeldscript om LLMPerf te configureren met een LLM die draait op Amazon Bedrock:

import os
from litellm import completion
os.environ["AWS_ACCESS_KEY_ID"] = "JOUW_ACCESS_KEY_ID"
os.environ["AWS_SECRET_ACCESS_KEY"] = "JOUW_SECRET_ACCESS_KEY"
os.environ["AWS_REGION_NAME"] = "us-east-1"
response = completion(
 model="anthropic.claude-3-sonnet-20240229-v1:0",
 messages=[{ "content": "Wie is Roger Federer?", "role": "user"}]
)
output = response.choices[0].message.content
print(output)

Uitvoeren van de Load-Test

Om de load-test uit te voeren met LLMPerf, kun je een shell-script gebruiken zoals hieronder weergegeven:

python llmperf/token_benchmark_ray.py \ 
 --model bedrock/anthropic.claude-3-sonnet-20240229-v1:0 \ 
 --mean-input-tokens 1024 \ 
 --stddev-input-tokens 200 \ 
 --mean-output-tokens 1024 \ 
 --stddev-output-tokens 200 \ 
 --max-num-completed-requests 30 \ 
 --num-concurrent-requests 1 \ 
 --timeout 300 \ 
 --llm-api litellm \ 
 --results-dir bedrock-outputs

Analyseren van Resultaten

Na het uitvoeren van de test, zal een output-directory met resultaten worden aangemaakt. Je kunt deze resultaten analyseren met behulp van Python en de pandas bibliotheek om een overzicht van de prestaties te genereren.

import json
from pathlib import Path
import pandas as pd

individual_path = Path("bedrock-outputs/bedrock-anthropic-claude-3-sonnet-20240229-v1-0_1024_1024_individual_responses.json")
summary_path = Path("bedrock-outputs/bedrock-anthropic-claude-3-sonnet-20240229-v1-0_1024_1024_summary.json")

with open(individual_path, "r") as f:
 individual_data = json.load(f)
with open(summary_path, "r") as f:
 summary_data = json.load(f)

summary_metrics = { 
 "Model": summary_data.get("model"), 
 "Mean Input Tokens": summary_data.get("mean_input_tokens"), 
 ... 
}
print("Claude 3 Sonnet - Performance Summary:\n")
for k, v in summary_metrics.items():
 print(f"{k}: {v}")

Conclusie

Load-testing is van cruciaal belang voor het garanderen van de prestaties van LLM’s in een productieve omgeving. Met tools zoals LLMPerf kunnen ontwikkelaars de effectiviteit van hun modellen evalueren en optimaliseren voordat ze deze in productie nemen. Dit is niet alleen belangrijk voor de toepassing van de modellen, maar ook voor het waarborgen van een goede gebruikerservaring.

In komende artikelen zullen we meer ingaan op evaluatieprocessen en hoe we een holistische test kunnen opzetten met zowel load-testing als evaluatie. Bedankt voor het lezen, en voel je vrij om feedback te geven of om contact met mij op te nemen via sociale media.