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

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

Udfordringerne ved at udlevere store sprogmodeller

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

Beregningsressourcer

LLM’er er berygtede for deres enorme parameterantal, der varierer 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. Dette enorme størrelse oversætter sig til betydelige beregningskrav for 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 GPU’er eller TPU’er er ofte nødvendige, og energiforbruget af disse systemer er betydeligt.

Eksempel:
Kørsel af en kluster af NVIDIA A100 GPU’er (ofte brugt til LLM-inferens) kan koste tusinder af dollars om dagen i skyberegningengebyrer.

Traditionelle tilgange til LLM-udlevering

Før vi udforsker mere avancerede løsninger, lad os kort gennemgå nogle traditionelle tilgange til LLM-udlevering:

Enkel udlevering med Hugging Transformers

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

Kodeeksempel:

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

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

<p>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)</p>

<p>print(generate_text("Fremtiden for AI er"))</p>

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

Brug af TorchServe eller lignende rammer

Rammer som TorchServe tilbyder mere robuste udleveringsmuligheder, herunder belastningsfordeling og modelversionering. Imidlertid løser de stadig ikke de specifikke udfordringer ved LLM-udlevering, såsom effektiv hukommelsesstyring for store modeller.

Forståelse af hukommelsesstyring i LLM-udlevering

Effektiv hukommelsesstyring er afgørende for udlevering 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 ofte bruges i operativsystemer (OS).

• Segmenteret hukommelse: Denne teknik deler hukommelsen op i forskellige segmenter, hver svarende til et andet program eller proces. For eksempel kan forskellige segmenter i en LLM-udleveringskontekst 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 kan også føre til fragmentering, hvis segmenterne ikke håndteres ordentligt.
• Pagineret hukommelse: Her deles hukommelsen op i faststørrelses sider, der kan ombyttes efter behov. Dette giver mulighed for effektiv brug af hukommelsesressourcer. I LLM-udlevering kan dette være afgørende for at håndtere de store mængder hukommelse, der kræves til at gemme modelvægte og mellemregninger.

Hukommelsesstyring i OS vs. vLLM

Dette billede sammenligner traditionel hukommelsesstyring i OS med hukommelsesstyrings tilgangen i vLLM.

• OS-hukommelsesstyring: I traditionelle operativsystemer allokeres processer (f.eks. proces A og proces B) sider af hukommelse (side 0, side 1 osv.) i fysisk hukommelse. Denne alloering 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-hukommelse til at styre hukommelsen mere effektivt. Anmodninger (f.eks. anmodning A og anmodning B) allokeres blokke af nøgle-værdi-hukommelsen (blok 0, blok 1 osv.). Denne tilgang hjælper med at minimere fragmentering og optimere hukommelsesbrug, hvilket giver mulighed for hurtigere og mere effektiv modeludlevering.

Opmærksomhedsmekanismen i LLM’er

Opmærksomhedsmekanismen i LLM

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

• Spørgsmål (Q): En ny token i dekodertrinnet 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ærksomhedsscorene ved at tage prikproduktet af spørgsmålet med nøglerne, skalerer med 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 den genererer hver token.

Udleveringstæftelighedssammenligning

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

Dette billede præsenterer en sammenligning af udleveringstæftelighed mellem forskellige rammer (HF, TGI og vLLM) ved hjælp af LLaMA-modeller på forskellige hardware-konfigurationer.

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

vLLM: En ny LLM-udleveringsarkitektur

vLLM, udviklet af forskere på UC Berkeley, repræsenterer et betydeligt skridt fremad i LLM-udleveringsteknologi. 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 virker:

– Nøgle-værdi-hukommelsespartitionering: I stedet for at gemme den samlede nøgle-værdi-hukommelse kontinuert i hukommelse, deler PagedAttention den op i faststørrelses blokke.
– Ikke-kontinuert lagring: Disse blokke kan lagres ikke-kontinuert i hukommelse, hvilket giver mulighed for mere fleksibel hukommelsesstyring.
– Allokeringsanmodning: Blokke allokeres kun, når de er nødvendige, hvilket reducerer hukommelsesødsel.
– Effektiv deling: Flere sekvenser kan dele blokke, hvilket giver mulighed for optimering af teknikker som parallelsampling og beam-søgning.

Illustration:

“`
Traditionel nøgle-værdi-hukommelse:
[Token 1 KV][Token 2 KV][Token 3 KV]…[Token N KV]
(Kontinuert hukommelsesallokering)
“`

PagedAttention-nøgle-værdi-hukommelse:
[Blok 1] -> Fysisk adresse A
[Blok 2] -> Fysisk adresse C
[Blok 3] -> Fysisk adresse B
…
(Ikke-kontinuert hukommelsesallokering)
“`

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

Kontinuerlig batchbehandling

vLLM implementerer kontinuerlig batchbehandling, der dynamisk behandler anmodninger, mens de ankommer, i stedet for at vente på at danne faststørrelses batcher. Dette giver lavere latency og højere tæftelighed.

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 batchbehandling kan vLLM starte behandling af hver anmodning med det samme, i stedet for at vente på at gruppere dem i foruddefinerede batcher.

Effektiv parallelsampling

Til applikationer, der kræver flere outputeksempler per prompt (f.eks. kreative skriveassistenter), kan vLLM’s hukommelsesdelingsfunktioner bruges til at generere flere outputeksempler, mens de deler nøgle-værdi-hukommelsen for fælles præfikser.

Kodeeksempel med vLLM:

from vllm import LLM, SamplingParams

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

<p># Generer 3 eksempler per prompt
sampling_params = SamplingParams(n=3, temperature=0.8, max_tokens=100)
outputs = llm.generate(prompts, sampling_params)</p>

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

Denne kode genererer effektivt flere eksempler for den givne prompt, mens den udnytter vLLM’s optimeringer.

Test af vLLM-ydelse

For at virkelig værdsætte vLLM’s indvirkning, lad os se på nogle ydelsesammenligninger:

Tæftelighedssammenligning

Baseret på de oplysninger, der er givet, opnår vLLM betydeligt højere tæftelighed end andre udleveringsløsninger:

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

Illustration:

“`
Tæftelighed (Token/sekund)
|
| ****
| ****
| ****
| **** ****
| **** **** ****
| **** **** ****
|————————
HF TGI vLLM
“`

Hukommelseseffektivitet

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

– Kun omkring 4% hukommelsesødsel, sammenlignet med 60-80% i traditionelle systemer
– Denne effektivitet giver mulighed for at udlevere større modeller eller håndtere flere samtidige anmodninger med samme hardware

Introduktion til vLLM

Nu, hvor vi har udforsket vLLM’s fordele, lad os gå igennem processen med at konfigurere og bruge det i jeres projekter.

6.1 Installation

Installation af vLLM er direkte med pip:

!pip install vllm

6.2 Grundlæggende brug til offline-inferens

Her er et enkelt eksempel på, hvordan man kan bruge vLLM til offline-tekstgenerering:

from vllm import LLM, SamplingParams

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

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

<p># Angiv samplingparametre
sampling_params = SamplingParams(temperature=0.8, max_tokens=100)</p>

<p># Generer svar
outputs = llm.generate(prompts, sampling_params)</p>

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

Dette script demonstrerer, hvordan man kan indlæse en model, angive samplingparametre og generere tekst for flere prompts.

6.3 Konfiguration af en vLLM-server

Til online-udlevering tilbyder vLLM en OpenAI-kompatibel API-server. Her er, hvordan man kan konfigurere den:

1. Start serveren:

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

2. Anmod om serveren med 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 at udlevere 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-udlevering, er der yderligere overvejelser og avancerede emner at udforske:

7.1 Modelkvantificering

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

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

<p># 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)</p>

<p># Brug den kvantificerede model med vLLM
from vllm import LLM</p>

<p>llm = LLM(model=model, tokenizer=tokenizer)</p>

7.2 Fordelt inferens

Til ekstremt store modeller eller højtrafik-applikationer kan fordelte inferens over flere GPU’er eller maskiner være nødvendig. Selvom vLLM ikke naturligt understøtter dette, kan det integreres i fordelte systemer med rammer som Ray:

import ray
from vllm import LLM

<p>@ray.remote(num_gpus=1)
class DistributedLLM:</p>

<p> def __init__(self, model_name):</p>

<p> self.llm = LLM(model=model_name)</p>

<p> def generate(self, prompt, params):</p>

<p> return self.llm.generate(prompt, params)</p>

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

<p># Brug dem i parallel
result1 = llm1.generate.remote("Prompt 1", sampling_params)
result2 = llm2.generate.remote("Prompt 2", sampling_params)</p>

<p># Hent resultaterne
print(ray.get([result1, result2]))</p>

7.3 Overvågning og observerbarhed

Når LLM’er udleveres 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)

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

# Jeres serverloop her

Konklusion

Udlevering af store sprogmodeller effektivt er en kompleks, men afgørende opgave i AI-alderen. vLLM, med sin innovative PagedAttention-algoritme og optimeret implementering, repræsenterer et betydeligt skridt fremad i at gøre LLM-udlevering mere tilgængelig og omkostningseffektiv.

Ved at dramatisk forbedre tæftelighed, reducere hukommelsesødsel og give mulighed for mere fleksible udleveringsmuligheder åbner vLLM op for nye muligheder for at integrere 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.