Optimering af LLM-udvikling: vLLM PagedAttention og fremtiden for effektiv AI-servering

Store sprogmodeller (LLM’er) udgør unikke udfordringer, når de anvendes i virkelige applikationer, især i forhold til beregningsressourcer, latency og omkostningseffektivitet. I denne omfattende vejledning vil vi udforske landskabet for LLM-servering, med særlig fokus på vLLM (vektor-sprogmodel), en løsning, der former omgangen med disse kraftfulde modeller.

Udfordringerne ved at servere store sprogmodeller

Før vi dykker ned i specifikke løsninger, lad os undersøge de nøgleudfordringer, der gør LLM-servering til en kompleks opgave:

Beregningsressourcer

LLM’er er berygtede for deres enorme parameterantal, der strækker sig fra milliarder til hundredvis af milliarder. For eksempel har GPT-3 175 milliarder parametre, mens mere nylige modeller som GPT-4 formodes at have endnu flere. Denne enorme størrelse oversætter sig til betydelige beregningskrav til inferens.

Eksempel:
Overvej en relativt beskeden LLM med 13 milliarder parametre, såsom LLaMA-13B. Selv dette model kræver:

– Cirka 26 GB hukommelse bare for at gemme modelparametrene (antagende 16-bit præcision)
– Yderligere hukommelse til aktiveringer, opmærksomhedsmekanismer og mellemregninger
– Betydelig GPU-beregningsevne til realtidsinferens

Latency

I mange applikationer, såsom chatbots eller realtidsindholdsgenerering, er lav latency afgørende for en god brugeroplevelse. Imidlertid kan kompleksiteten af LLM’er føre til betydelige processtider, især for længere sekvenser.

Eksempel:
Forestil dig en kundeservicechatbot, der er drevet af en LLM. Hvis hver respons tager flere sekunder at generere, vil samtalen føles unaturlig og frustrerende for brugerne.

Omkostninger

Den hardware, der kræves for at køre LLM’er i stor skala, kan være ekstremt dyrt. Højendte GPUs eller TPUs er ofte nødvendige, og energiforbrug af disse systemer er betydeligt.

Eksempel:
At køre en cluster af NVIDIA A100 GPUs (ofte brugt til LLM-inferens) kan koste tusinder af dollars om dagen i skyregningsgebyrer.

Traditionelle tilgange til LLM-servering

Før vi udforsker mere avancerede løsninger, lad os kort gennemgå nogle traditionelle tilgange til servering af LLM’er:

Enkel installation med Hugging Face Transformers

Hugging Face Transformers-biblioteket tilbyder en direkte måde at installere LLM’er på, men det er ikke optimeret til høj-gennemstrømningsservering.

Eksempelkode:

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_name = "meta-llama/Llama-2-13b-hf"
model = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto")
tokenizer = AutoTokenizer.from_pretrained(model_name)

def generate_text(prompt, max_length=100):
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_length=max_length)
return tokenizer.decode(outputs[0], skip_special_tokens=True)

print(generate_text("Fremtiden for AI er"))

Selvom denne tilgang fungerer, er den ikke egnet til højtrafik-applikationer på grund af dens ineffektive brug af ressourcer og mangel på optimeringer til servering.

Brug af TorchServe eller lignende rammer

Rammer som TorchServe tilbyder mere robust servering, herunder belastningsfordeling og modelversionering. Imidlertid løser de ikke de specifikke udfordringer i forbindelse med LLM-servering, såsom effektiv hukommelsesstyring til store modeller.

Forståelse af hukommelsesstyring i LLM-servering

Effektiv hukommelsesstyring er afgørende for servering af store sprogmodeller (LLM’er) på grund af de omfattende beregningsressourcer, der kræves. Følgende billeder illustrerer forskellige aspekter af hukommelsesstyring, der er integreret i optimering af LLM-ydelse.

Segmenteret vs. pagineret hukommelse

Hukommelsesstyring i OS vs. vLLM

 

Hukommelsesstyring i OS vs. vLLM

Disse to diagrammer sammenligner segmenteret hukommelse og pagineret hukommelsesstyringsteknikker, der normalt bruges i operativsystemer (OS).

• Segmenteret hukommelse: Denne teknik opdeler hukommelsen i forskellige segmenter, hver svarende til et forskelligt program eller proces. For eksempel i en LLM-serveringskontekst kan forskellige segmenter være allokeret til forskellige komponenter af modellen, såsom tokenisering, indlejring og opmærksomhedsmekanismer. Hvert segment kan vokse eller mindske uafhængigt, hvilket giver fleksibilitet, men potentielt kan føre til fragmentering, hvis segmenterne ikke styres korrekt.
• Pagineret hukommelse: Her opdeles hukommelsen i faste størrelser, der kan mappes til fysisk hukommelse. Sider kan byttes ind og ud efter behov, hvilket giver mulighed for effektiv brug af hukommelsesressourcer. I LLM-servering kan dette være afgørende for at styre den store mængde hukommelse, der kræves til at gemme modelvægte og mellemregninger.

Hukommelsesstyring i OS vs. vLLM

Dette billede sammenligner traditionel OS-hukommelsesstyring med hukommelsesstyrings tilgangen, der bruges i vLLM.

• OS-hukommelsesstyring: I traditionelle operativsystemer allokeres processer (f.eks. Process A og Process B) sider af hukommelse (Side 0, Side 1 osv.) i fysisk hukommelse. Denne allokering kan føre til fragmentering over tid, når processer anmoder om og frigør hukommelse.
• vLLM-hukommelsesstyring: vLLM-rammen bruger en nøgle-værdi (KV)-cache til at styre hukommelsen mere effektivt. Anmodninger (f.eks. Anmodning A og Anmodning B) allokeres blokke af KV-cachen (KV-blok 0, KV-blok 1 osv.). Denne tilgang hjælper med at minimere fragmentering og optimerer hukommelsesbrug, hvilket giver mulighed for hurtigere og mere effektiv modelservering.

Opmærksomhedsmekanismen i LLM’er

Opmærksomhedsmekanismen i LLM’er

Opmærksomhedsmekanismen er en grundlæggende komponent af transformermodeller, der ofte bruges til LLM’er. Dette diagram illustrerer opmærksomhedsformlen og dets komponenter:

• Spørgsmål (Q): En ny token i decodertrinnet eller den sidste token, som modellen har set.
• Nøgle (K): Tidligere kontekst, som modellen skal opmærksomme sig på.
• Værdi (V): Vægtet sum over den tidligere kontekst.

Formlen beregner opmærksomheds-scorene ved at tage prikproduktet af spørgsmålet med nøglerne, skalerer ved kvadratrod af nøgledimensionen, anvender en softmax-funktion og tager derefter prikproduktet med værdierne. Denne proces giver modellen mulighed for at fokusere på relevante dele af inputsekvensen, når hver token genereres.

Serveringsgennemstrømningssammenligning

vLLM: Let, hurtig og billig LLM-servering med PagedAttention

Dette billede præsenterer en sammenligning af serveringsgennemstrømning mellem forskellige rammer (HF, TGI og vLLM) ved brug af LLaMA-modeller på forskellige hardware-konfigurationer.

• LLaMA-13B, A100-40GB: vLLM opnår 14 gange – 24 gange højere gennemstrømning end Hugging Face Transformers (HF) og 2,2 gange – 2,5 gange højere gennemstrømning end Hugging Face Text Generation Inference (TGI).
• LLaMA-7B, A10G: Lignende tendenser observeres, med vLLM, der betydeligt overgår både HF og TGI.

vLLM: En ny LLM-serveringsarkitektur

vLLM, udviklet af forskere ved UC Berkeley, repræsenterer et betydeligt skridt fremad i LLM-serveringsteknologi. Lad os udforske dets nøglefunktioner og innovationer:

PagedAttention

I hjertet af vLLM ligger PagedAttention, en ny opmærksomhedsalgoritme inspireret af virtuel hukommelsesstyring i operativsystemer. Her er, hvordan det fungerer:

– Nøgle-værdi (KV)-cacheopdelt: I stedet for at gemme den samlede KV-cache kontinuert i hukommelse, opdeler PagedAttention den i faste størrelser.
– Ikke-kontinuert lagring: Disse blokke kan gemmes ikke-kontinuert i hukommelse, hvilket giver mulighed for mere fleksibel hukommelsesstyring.
– Allokering på krav: Blokke allokeres kun, når de er nødvendige, hvilket reducerer hukommelses-spild.
– Effektiv deling: Flere sekvenser kan dele blokke, hvilket giver mulighed for optimeringer til teknikker som parallelsampling og strålesøgning.

Illustration:

“`
Traditionel KV-cache:
[Token 1 KV][Token 2 KV][Token 3 KV]…[Token N KV]
(Kontinuert hukommelsesallokering)

PagedAttention KV-cache:
[Block 1] -> Fysisk adresse A
[Block 2] -> Fysisk adresse C
[Block 3] -> Fysisk adresse B
…
(Ikke-kontinuert hukommelsesallokering)
“

Denne tilgang reducerer betydeligt hukommelsesfragmentering og giver mulighed for langt mere effektiv brug af GPU-hukommelse.

Kontinuerlig batchning

vLLM implementerer kontinuerlig batchning, der dynamisk behandler anmodninger, mens de ankommer, i stedet for at vente på at danne faste batch-størrelser. Dette giver lavere latency og højere gennemstrømning.

Eksempel:
Forestil dig en strøm af indkommende anmodninger:

“`
Tid 0ms: Anmodning A ankommer
Tid 10ms: Start behandling af Anmodning A
Tid 15ms: Anmodning B ankommer
Tid 20ms: Start behandling af Anmodning B (i parallel med A)
Tid 25ms: Anmodning C ankommer
…
“

Med kontinuerlig batchning kan vLLM starte behandling af hver anmodning med det samme, i stedet for at vente på at gruppere dem i foruddefinerede batch-størrelser.

Effektiv parallelsampling

Til applikationer, der kræver multiple output-eksemplarer per prompt (f.eks. kreative skrivehjælpere), udmærker vLLM’s hukommelsesdelingsfunktioner sig. Det kan generere multiple output, mens det genbruger KV-cachen til fælles præfikser.

Eksempelkode ved brug af vLLM:

from vllm import LLM, SamplingParams

llm = LLM(model="meta-llama/Llama-2-13b-hf")
prompts = ["Fremtiden for AI er"]

# Generer 3 eksemplarer per prompt
sampling_params = SamplingParams(n=3, temperature=0.8, max_tokens=100)
outputs = llm.generate(prompts, sampling_params)

for output in outputs:
print(f"Prompt: {output.prompt}")
for i, out in enumerate(output.outputs):
print(f"Eksempel {i + 1}: {out.text}")

Denne kode genererer effektivt multiple eksemplarer for den givne prompt, udnyttende vLLM’s optimeringer.

Test af vLLM-ydelse

For at virkelig værdsætte impacten af vLLM, lad os se på nogle ydelsesammenligninger:

Gennemstrømningssammenligning

Baseret på den tilgængelige information overgår vLLM betydeligt andre serveringsløsninger:

– Op til 24 gange højere gennemstrømning i forhold til Hugging Face Transformers
– 2,2 gange til 3,5 gange højere gennemstrømning end Hugging Face Text Generation Inference (TGI)

Illustration:

“`
Gennemstrømning (Token/sekund)
|
| ****
| ****
| ****
| **** ****
| **** **** ****
| **** **** ****
|————————
HF TGI vLLM
“`

Hukommelseseffektivitet

vLLM’s PagedAttention resulterer i næsten optimal hukommelsesbrug:

– Kun omkring 4% hukommelsesspild, i forhold til 60-80% i traditionelle systemer
– Denne effektivitet giver mulighed for servering af større modeller eller håndtering af flere samtidige anmodninger med den samme hardware

Kom i gang med vLLM

Nu, hvor vi har udforsket fordelene ved vLLM, lad os gå gennem processen med at konfigurere og bruge det i jeres projekter.

6.1 Installation

Installation af vLLM er direkte ved brug af pip:

!pip install vllm

6.2 Grundlæggende brug til offline-inferens

Her er et enkelt eksempel på brug af vLLM til offline-tekstgenerering:

from vllm import LLM, SamplingParams

# Initialiser modellen
llm = LLM(model="meta-llama/Llama-2-13b-hf")

# Forbered prompts
prompts = [
"Skrib en kort digt om kunstig intelligens:",
" Forklar kvantecomputering på en simpel måde:"
]

# Angiv samplingparametre
sampling_params = SamplingParams(temperature=0.8, max_tokens=100)

# Generer svar
outputs = llm.generate(prompts, sampling_params)

# Udskriv resultaterne
for output in outputs:
print(f"Prompt: {output.prompt}")
print(f"Genereret tekst: {output.outputs[0].text}\n")

Denne skript demonstrerer, hvordan man kan indlæse en model, angive samplingparametre og generere tekst for multiple prompts.

6.3 Konfiguration af en vLLM-server

Til online-servering tilbyder vLLM en OpenAI-kompatibel API-server. Her er, hvordan man konfigurerer den:

1. Start serveren:

python -m vllm.entrypoints.openai.api_server --model meta-llama/Llama-2-13b-hf

2. Anmod om serveren ved brug af curl:

curl http://localhost:8000/v1/completions \
-H "Content-Type: application/json" \
-d '{
"model": "meta-llama/Llama-2-13b-hf",
"prompt": "Fremtiden for AI er:",
"max_tokens": 100,
"temperature": 0.7
}'

Denne konfiguration giver mulighed for servering af jeres LLM med en grænseflade, der er kompatibel med OpenAI’s API, hvilket gør det let at integrere i eksisterende applikationer.

Avancerede emner om vLLM

Selvom vLLM tilbyder betydelige forbedringer i LLM-servering, er der yderligere overvejelser og avancerede emner at udforske:

7.1 Modelkvantificering

Til endnu mere effektiv servering, især på hardware med begrænset hukommelse, kan kvantificeringsteknikker anvendes. Selvom vLLM ikke selv understøtter kvantificering, kan det anvendes i kombination med kvantificerede modeller:

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# Indlæs en kvantificeret model
model_name = "meta-llama/Llama-2-13b-hf"
model = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto", load_in_8bit=True)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Anvend den kvantificerede model med vLLM
from vllm import LLM

llm = LLM(model=model, tokenizer=tokenizer)

7.2 Fordelt inferens

Til ekstremt store modeller eller højtrafik-applikationer kan fordelte inferens over multiple GPUs eller maskiner være nødvendig. Selvom vLLM ikke naturligt understøtter dette, kan det integreres i fordelt system ved brug af rammer som Ray:

import ray
from vllm import LLM

@ray.remote(num_gpus=1)
class DistributedLLM:
def __init__(self, model_name):
self.llm = LLM(model=model_name)

def generate(self, prompt, params):
return self.llm.generate(prompt, params)

# Initialiser fordelt LLM'er
llm1 = DistributedLLM.remote("meta-llama/Llama-2-13b-hf")
llm2 = DistributedLLM.remote("meta-llama/Llama-2-13b-hf")

# Anvend dem i parallel
result1 = llm1.generate.remote("Prompt 1", sampling_params)
result2 = llm2.generate.remote("Prompt 2", sampling_params)

# Hent resultater
print(ray.get([result1, result2]))

7.3 Overvågning og observerbarhed

Når LLM’er serveres i produktion, er overvågning afgørende. Selvom vLLM ikke tilbyder indbygget overvågning, kan det integreres med værktøjer som Prometheus og Grafana:

from prometheus_client import start_http_server, Summary
from vllm import LLM

# Definer målinger
REQUEST_TIME = Summary('request_processing_seconds', 'Tid brugt på at behandle anmodning')

# Initialiser vLLM
llm = LLM(model="meta-llama/Llama-2-13b-hf")

# Eksponer målinger
start_http_server(8000)

# Anvend modellen med overvågning
@REQUEST_TIME.time()
def process_request(prompt):
return llm.generate(prompt)

# Jeres serveringsløkke her

Denne konfiguration giver mulighed for at spore målinger som anmodningsbehandlingstid, som kan visualiseres i Grafana-dashboard.

Konklusion

Servering af store sprogmodeller effektivt er en kompleks, men afgørende opgave i AI-alderen. vLLM, med sin innovative PagedAttention-algoritme og optimerede implementering, repræsenterer et betydeligt skridt fremad i LLM-serveringsteknologi.

Ved at dramatisk forbedre gennemstrømning, reducere hukommelsesspild og give mulighed for mere fleksible serveringsmuligheder åbner vLLM op for nye muligheder for integration af kraftfulde sprogmodeller i en bred vifte af applikationer. Uanset om du bygger en chatbot, et indholdsgenereringssystem eller en anden NLP-drevet applikation, vil forståelse og udnyttelse af værktøjer som vLLM være afgørende for succes.