Optimalisering av LLM-utbredelse: vLLM PagedAttention og fremtiden for effektiv AI-tjeneste

Store språkmodeller (LLM) som utbredes på virkelige applikasjoner presenterer unike utfordringer, særlig når det gjelder beregningsressurser, latency og kostnadseffektivitet. I denne omfattende guiden vil vi utforske landskapet av LLM-tjeneste, med særlig fokus på vLLM (vektor språkmodell), en løsning som former om hvordan vi utbreder og samhandler med disse kraftfulle modellene.

Utfordringene ved å tjene store språkmodeller

Før vi dykker inn i spesifikke løsninger, la oss undersøke de viktigste utfordringene som gjør LLM-tjeneste til en kompleks oppgave:

Beregningsressurser

LLM-er er beryktet for sine enorme parameterantall, som varierer fra milliarder til hundre milliarder. For eksempel har GPT-3 175 milliarder parametre, mens mer nylige modeller som GPT-4 estimeres å ha enda flere. Dette enorme størrelsen oversettes til betydelige beregningskrav for inferens.

Eksempel:
Vurdér en relativt beskjeden LLM med 13 milliarder parametre, som LLaMA-13B. Selv denne modellen krever:

– Omtrent 26 GB minne bare for å lagre modellparametrene (antagelse: 16-bit presisjon)
– Ekstra minne for aktiveringer, oppmerksomhetsmekanismer og mellomliggende beregninger
– Betydelig GPU-beregningsevne for sanntidsinferens

Latens

I mange applikasjoner, som chatboter eller sanntidsinnholdsgenerering, er lav latens avgjørende for en god brukeropplevelse. Imidlertid kan kompleksiteten i LLM-er føre til betydelige prosesseringstider, særlig for lengre sekvenser.

Eksempel:
Forestall en kundeservice-chatbot drevet av en LLM. Hvis hver respons tar flere sekunder å generere, vil samtalen føles unaturlig og frustrerende for brukerne.

Kostnad

Maskinvaren som kreves for å kjøre LLM-er i stor skala kan være ekstremt dyrt. Høyhastighets-GPU-er eller TPU-er er ofte nødvendige, og energiforbruket til disse systemene er betydelig.

Eksempel:
Kjøring av en cluster av NVIDIA A100-GPU-er (ofte brukt for LLM-inferens) kan koste tusenvis av dollar per dag i skytjenestegjeld.

Tradisjonelle tilnærminger til LLM-tjeneste

Før vi utforsker mer avanserte løsninger, la oss kort omtale noen tradisjonelle tilnærminger til LLM-tjeneste:

Enkel utbredelse med Hugging Transformers

Hugging Face Transformers-biblioteket tilbyr en enkel måte å utbrede LLM-er på, men det er ikke optimalisert for høyt gjennomstrømmingstjeneste.

Eksempelkode:

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("The future of AI is"))

Selv om denne tilnærmingen fungerer, er den ikke egnet for høyt-trafikk-applikasjoner på grunn av dens ineffektive bruk av ressurser og manglende optimalisering for tjeneste.

Bruke TorchServe eller lignende rammeverk

Rammeverk som TorchServe tilbyr mer robuste tjenestekapasiteter, inkludert lastbalansering og modellversjonering. Imidlertid addreserer de ikke de spesifikke utfordringene ved LLM-tjeneste, som effektiv minnehåndtering for store modeller.

Forståelse av minnehåndtering i LLM-tjeneste

Effektiv minnehåndtering er avgjørende for tjeneste av store språkmodeller (LLM-er) på grunn av de omfattende beregningsressursene som kreves. Følgende bilder illustrerer ulike aspekter av minnehåndtering, som er integrert i optimalisering av LLM-ytelse.

Segmentert mot paged minne

Minnehåndtering i OS vs. vLLM

 

Minnehåndtering i OS vs. vLLM

Disse to diagrammene sammenligner segmentert minne og paged minnehåndteringsteknikker, som vanligvis brukes i operativsystemer (OS).

• Segmentert minne: Denne teknikken deler minnet inn i ulike segmenter, hver korresponderer til et annet program eller prosess. For eksempel, i en LLM-tjenestekontekst, kan ulike segmenter bli tildelt til ulike komponenter av modellen, som tokenisering, innbedding og oppmerksomhetsmekanismer. Hvert segment kan vokse eller krympe uavhengig, og gi fleksibilitet, men potensielt føre til fragmentering hvis segmenter ikke håndteres ordentlig.
• Paged minne: Her blir minnet delt inn i faste størrelser på sider, som blir kartlagt over fysisk minne. Sider kan byttes inn og ut etter behov, og tillate effektiv bruk av minneressurser. I LLM-tjeneste kan dette være avgjørende for å håndtere de store mengdene minne som kreves for å lagre modellvekter og mellomliggende beregninger.

Minnehåndtering i OS vs. vLLM

Dette bildet kontrasterer tradisjonell OS-minnehåndtering med minnehåndteringsmetoden brukt i vLLM.

• OS-minnehåndtering: I tradisjonelle operativsystemer blir prosesser (f.eks. Prosess A og Prosess B) tildelt sider av minne (Side 0, Side 1, osv.) i fysisk minne. Denne tildelingen kan føre til fragmentering over tid, når prosesser ber og frigjør minne.
• vLLM-minnehåndtering: vLLM-rammeverket bruker en nøkkel-verdi-cache for å håndtere minne mer effektivt. Forespørsler (f.eks. Forespørsel A og Forespørsel B) blir tildelt blokker av nøkkel-verdi-cachen (Nøkkel-verdi-blokk 0, Nøkkel-verdi-blokk 1, osv.). Denne metoden hjelper med å minimere fragmentering og optimalisere minnebruk, og tillater raskere og mer effektiv modelltjeneste.

Oppmerksomhetsmekanisme i LLM-er

Oppmerksomhetsmekanisme i LLM-er

Oppmerksomhetsmekanismen er en grunnleggende komponent av transformermodeller, som vanligvis brukes for LLM-er. Dette bildet illustrerer oppmerksomhetsformelen og dens komponenter:

• Spørring (Q): En ny token i dekodertrinnet eller den siste token som modellen har sett.
• Nøkkel (K): Tidligere kontekst som modellen skal fokusere på.
• Verdi (V): Vektsum over tidligere kontekst.

Formelen beregner oppmerksomhetsscorene ved å ta punktproduktet av spørringen med nøklene, skalerer med kvadratrot av nøkkel-dimensjonen, anvender en softmax-funksjon og til slutt tar punktproduktet med verdiene. Denne prosessen tillater modellen å fokusere på relevante deler av inndata-sekvensen når hver token genereres.

Tjenestegjennomstrømningssammenligning

vLLM: Enkel, rask og billig LLM-tjeneste med PagedAttention

Dette bildet presenterer en sammenligning av tjenestegjennomstrømning mellom ulike rammeverk (HF, TGI og vLLM) som bruker LLaMA-modeller på ulike maskinvareoppsett.

• LLaMA-13B, A100-40GB: vLLM oppnår 14 ganger til 24 ganger høyere gjennomstrømning enn Hugging Face Transformers (HF) og 2,2 ganger til 2,5 ganger høyere gjennomstrømning enn Hugging Face Text Generation Inference (TGI).
• LLaMA-7B, A10G: Lignende trender observeres, med vLLM som signifikant overgår både HF og TGI.

vLLM: En ny LLM-tjenestearkitektur

vLLM, utviklet av forskere ved UC Berkeley, representerer et betydelig sprang fremover i LLM-tjenesteteknologi. La oss utforske dens nøkkel-funksjoner og innovasjoner:

PagedAttention

I hjertet av vLLM ligger PagedAttention, en ny oppmerksomhetsalgoritme inspirert av virtuell minnehåndtering i operativsystemer. Her er hvordan den fungerer:

– Nøkkel-verdi-cache-partisjonering: I stedet for å lagre hele nøkkel-verdi-cachen kontinuerlig i minne, deler PagedAttention den inn i faste størrelser på blokker.
– Ikke-kontinuerlig lagring: Disse blokkene kan lagres ikke-kontinuerlig i minne, og tillater mer fleksibel minnehåndtering.
– Etterspørsels-allocering: Blokker blir bare allokert når de er nødvendige, og reduserer minne-spilling.
– Effektiv deling: Flere sekvenser kan dele blokker, og tillater optimalisering for teknikker som parallell sampling og søkestrategi.

Illustrasjon:

“`
Tradisjonell nøkkel-verdi-cache:
[Token 1 KV][Token 2 KV][Token 3 KV]…[Token N KV]
(Kontinuerlig minne-allocering)
“`

PagedAttention-nøkkel-verdi-cache:
[Block 1] -> Fysisk adresse A
[Block 2] -> Fysisk adresse C
[Block 3] -> Fysisk adresse B
…
(Ikke-kontinuerlig minne-allocering)
“`

Denne tilnærmingen reduserer betydelig minne-fragmentering og tillater mye mer effektiv bruk av GPU-minne.

Kontinuerlig batching

vLLM implementerer kontinuerlig batching, som dynamisk prosesserer forespørsler når de ankommer, i stedet for å vente til å danne faste størrelser på batcher. Dette fører til lavere latens og høyere gjennomstrømning.

Eksempel:
Forestall en strøm av inkomne forespørsler:

“`
Tid 0ms: Forespørsel A ankommer
Tid 10ms: Start prosessering av Forespørsel A
Tid 15ms: Forespørsel B ankommer
Tid 20ms: Start prosessering av Forespørsel B (i parallell med A)
Tid 25ms: Forespørsel C ankommer
…
“`

Med kontinuerlig batching kan vLLM starte prosessering av hver forespørsel umiddelbart, i stedet for å vente til å gruppere dem i forhåndsdefinerte batcher.

Effektiv parallell sampling

For applikasjoner som krever flere utdata-eksemplarer per forespørsel (f.eks. kreative skrivehjelpere), skinner vLLM sin minne-delingskapasitet. Den kan generere flere utdata samtidig som den gjenbruker nøkkel-verdi-cachen for felles prefikser.

Eksempelkode som bruker vLLM:

from vllm import LLM, SamplingParams

<p>llm = LLM(model="meta-llama/Llama-2-13b-hf")
prompts = ["The future of AI is"]</p>

<p># Generer 3 eksemplarer per forespørsel
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}")

Denne koden genererer effektivt flere eksemplarer for den gitte forespørselen, og utnytter vLLM sine optimaliseringer.

Benchmarking av vLLM-ytelse

For å virkelig sette pris på vLLM, la oss se på noen ytelses-sammenligninger:

Gjennomstrømningssammenligning

Basert på informasjonen, overgår vLLM betydelig andre tjenesteløsninger:

– Opptil 24 ganger høyere gjennomstrømning sammenlignet med Hugging Face Transformers
– 2,2 ganger til 3,5 ganger høyere gjennomstrømning enn Hugging Face Text Generation Inference (TGI)

Illustrasjon:

“`
Gjennomstrømning (Token per sekund)
|
| ****
| ****
| ****
| **** ****
| **** **** ****
| **** **** ****
|————————
HF TGI vLLM
“`

Minne-effektivitet

vLLM sin PagedAttention resulterer i nærmest optimal minnebruk:

– Bare om lag 4% minne-spilling, sammenlignet med 60-80% i tradisjonelle systemer
– Denne effektiviteten tillater tjeneste av større modeller eller håndtering av flere samtidige forespørsler med samme maskinvare.

Komme i gang med vLLM

Nå som vi har utforsket fordelen med vLLM, la oss gå gjennom prosessen med å sette det opp og bruke det i dine prosjekter.

6.1 Installasjon

Installasjon av vLLM er rett frem ved å bruke pip:

!pip install vllm

6.2 Grunnleggende bruk for offline-inferens

Her er et enkelt eksempel på å bruke vLLM for offline-tekstgenerering:

from vllm import LLM, SamplingParams

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

<p># Forbered forespørsler
prompts = [
"Skriv en kort dikt om kunstig intelligens:",
"Forklar kvanteberegning på en enkel måte:"
]</p>

<p># Sett sampling-parametre
sampling_params = SamplingParams(temperature=0.8, max_tokens=100)</p>

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

<p># Skriv ut resultater
for output in outputs:
print(f"Prompt: {output.prompt}")
print(f"Generert tekst: {output.outputs[0].text}\n")

Denne skripten demonstrerer hvordan du kan laste en modell, sette sampling-parametre og generere tekst for flere forespørsler.

6.3 Oppsett av en vLLM-tjener

For online-tjeneste tilbyr vLLM en OpenAI-kompatibel API-tjener. Her er hvordan du setter den opp:

1. Start tjeneren:

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

2. Spør tjeneren 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}'

Dette oppsettet tillater deg å tjene din LLM med et grensesnitt kompatibelt med OpenAI sitt API, og gjør det enkelt å integrere i eksisterende applikasjoner.

Avanserte emner om vLLM

Mens vLLM tilbyr betydelige forbedringer i LLM-tjeneste, er det noen ekstra overveielser og avanserte emner å utforske:

7.1 Modell-kvantifisering

For enda mer effektiv tjeneste, særlig på maskinvare med begrenset minne, kan kvantifiserings-teknikker brukes. Selv om vLLM selv ikke støtter kvantifisering, kan det brukes i sammenheng med kvantifiserte modeller:

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

<p># Last en kvantifisert modell
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># Bruk den kvantifiserte modellen med vLLM
from vllm import LLM</p>

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

7.2 Distribuert inferens

For ekstremt store modeller eller høyt-trafikk-applikasjoner kan distribuert inferens over flere GPU-er eller maskiner være nødvendig. Selv om vLLM ikke støtter dette nativt, kan det integreres i distribuerte systemer ved å bruke rammeverk som Ray:

import ray
from vllm import LLM

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

<p> def __init__(self, model_name):
self.llm = LLM(model=model_name)</p>

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

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

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

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

7.3 Overvåking og observasjon

Når du tjener LLM-er i produksjon, er overvåking avgjørende. Selv om vLLM ikke tilbyr innebygd overvåking, kan du integrere det med verktøy 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 brukt på å prosessere forespørsel’)

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

# Eksponer målinger
start_http_server(8000)

# Bruk modellen med overvåking
@REQUEST_TIME.time()
def prosesser_forespørsel(prompt):
return llm.generate(prompt)

# Din tjenestesløyfe her

Konklusjon

Tjeneste av store språkmodeller på en effektiv måte er en kompleks, men avgjørende oppgave i AI-eran. vLLM, med sin innovative PagedAttention-algoritme og optimalisert implementering, representerer et betydelig sprang fremover i å gjøre LLM-utbredelse mer tilgjengelig og kostnadseffektiv.

Ved å dramatisk forbedre gjennomstrømning, redusere minne-spilling og tillate mer fleksible tjeneste-tilbud, åpner vLLM opp for nye muligheter for å integrere kraftfulle språkmodeller i en rekke applikasjoner. Uansett om du bygger en chatbot, et innholdsgenereringssystem eller andre NLP-drevne applikasjoner, å forstå og utnytte verktøy som vLLM vil være nøkkel til suksess.