Optimering av LLM-distribution: vLLM PagedAttention och framtiden för effektiv AI-service

Stora språkmodeller (LLM) som distribueras i realvärldens applikationer presenterar unika utmaningar, särskilt i termer av beräkningsresurser, latens och kostnadseffektivitet. I den här omfattande guiden kommer vi att utforska landskapet för LLM-service, med särskild fokus på vLLM (vektor språkmodell), en lösning som omdefinierar hur vi distribuerar och interagerar med dessa kraftfulla modeller.

Utmaningarna med att serva stora språkmodeller

Innan vi dyker in i specifika lösningar, låt oss undersöka de viktigaste utmaningarna som gör LLM-service till en komplex uppgift:

Beräkningsresurser

LLM är ökända för sina enorma parameterantal, som sträcker sig från miljarder till hundratals miljarder. Till exempel har GPT-3 175 miljarder parametrar, medan mer moderna modeller som GPT-4 beräknas ha ännu fler. Denna enorma storlek översätts till betydande beräkningskrav för inferens.

Exempel:
Tänk på en relativt blygsam LLM med 13 miljarder parametrar, som LLaMA-13B. Även denna modell kräver:

– Cirka 26 GB minne bara för att lagra modellparametrarna (antagande 16-bitars precision)
– Ytterligare minne för aktiveringar, uppmärksamhetsmekanismer och mellanliggande beräkningar
– Avsevärd GPU-beräkningskraft för realtidsinferens

Latens

I många applikationer, som chattbotar eller realtidsinnehållsgenerering, är låg latens avgörande för en bra användarupplevelse. Men komplexiteten i LLM kan leda till betydande bearbetningstider, särskilt för längre sekvenser.

Exempel:
Tänk på en kundtjänstchattbot som drivs av en LLM. Om varje svar tar flera sekunder att generera, kommer samtalet att kännas onaturligt och frustrerande för användarna.

Kostnad

Hårdvaran som krävs för att köra LLM i stor skala kan vara extremt dyrt. Högpresterande GPU eller TPU är ofta nödvändiga, och energiförbrukningen för dessa system är betydande.

Exempel:
Att köra en kluster av NVIDIA A100 GPU (ofta används för LLM-inferens) kan kosta tusentals dollar per dag i molntjänster.

Traditionella tillvägagångssätt för LLM-service

Innan vi utforskar mer avancerade lösningar, låt oss kortfattat granska några traditionella tillvägagångssätt för att serva LLM:

Enkel distribution med Hugging Transformers

Hugging Face Transformers-biblioteket tillhandahåller ett enkelt sätt att distribuera LLM, men det är inte optimerat för högpresterande service.

Exempelkod:

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"))

Medan detta tillvägagångssätt fungerar, är det inte lämpligt för högtrafikapplikationer på grund av dess ineffektiva användning av resurser och brist på optimeringar för service.

Användning av TorchServe eller liknande ramverk

Ramverk som TorchServe tillhandahåller mer robusta servicer, inklusive lastbalansering och modellversionering. Men de adresserar fortfarande inte de specifika utmaningarna med LLM-service, som effektiv minneshantering för stora modeller.

Förstå minneshantering i LLM-service

Effektiv minneshantering är avgörande för att serva stora språkmodeller (LLM) på grund av de omfattande beräkningsresurser som krävs. Följande bilder illustrerar olika aspekter av minneshantering, som är integrerade för att optimera LLM-prestanda.

Segmenterad vs. sidminne

Minneshantering i OS vs. vLLM

 

Minneshantering i OS vs. vLLM

Dessa två diagram jämför segmenterad minnes- och sidminneshanteringsmetoder, som vanligtvis används i operativsystem (OS).

• Segmenterad minnes: Denna teknik delar minnet i olika segment, var och en motsvarar ett annat program eller process. Till exempel i en LLM-servicekontext kan olika segment allokeras till olika komponenter i modellen, som tokenisering, inbäddning och uppmärksamhetsmekanismer. Varje segment kan växa eller minska oberoende, vilket ger flexibilitet men kan leda till fragmentering om segmenten inte hanteras korrekt.
• Sidminne: Här delas minnet in i fastställda sidor, som mappas till fysiskt minne. Sidor kan bytas in och ut som behövs, vilket möjliggör en effektiv användning av minnesresurser. I LLM-service kan detta vara avgörande för att hantera de stora mängder minne som krävs för att lagra modellvikter och mellanliggande beräkningar.

Minneshantering i OS vs. vLLM

Denna bild kontrasterar traditionell OS-minneshantering med minneshanteringsmetoden som används i vLLM.

• OS-minneshantering: I traditionella operativsystem allokeras processer (t.ex. Process A och Process B) sidor av minne (Sida 0, Sida 1, etc.) i fysiskt minne. Denna allokering kan leda till fragmentering över tid när processer begär och släpper minne.
• vLLM-minneshantering: vLLM-ramverket använder en Key-Value (KV)-cache för att hantera minnet mer effektivt. Begäranden (t.ex. Begäran A och Begäran B) allokeras block av KV-cachen (KV-block 0, KV-block 1, etc.). Denna metod hjälper till att minimera fragmentering och optimera minnesanvändning, vilket möjliggör snabbare och mer effektiv modellservice.

Uppmärksamhetsmekanism i LLM

Uppmärksamhetsmekanism i LLM

Uppmärksamhetsmekanismen är en grundläggande komponent i transformermodeller, som vanligtvis används för LLM. Denna bild illustrerar uppmärksamhetsformeln och dess komponenter:

• Förfrågan (Q): En ny token i dekodarsteget eller den sista token som modellen har sett.
• Nyckel (K): Tidigare kontext som modellen ska uppmärksamma.
• Värde (V): Vägd summa över tidigare kontext.

Formeln beräknar uppmärksamhetsskörden genom att ta dotprodukten av förfrågan med nycklarna, skalera med kvadratroten av nyckelstorleken, tillämpa en softmax-funktion och sedan ta dotprodukten med värdena. Denna process tillåter modellen att fokusera på relevanta delar av inmatningssekvensen när den genererar varje token.

Servicestudie jämförelse

vLLM: Enkel, snabb och billig LLM-service med PagedAttention

Denna bild presenterar en jämförelse av servicestudie mellan olika ramverk (HF, TGI och vLLM) med användning av LLaMA-modeller på olika hårdvarukonfigurationer.

• LLaMA-13B, A100-40GB: vLLM uppnår 14x – 24x högre servicestudie än HuggingFace Transformers (HF) och 2,2x – 2,5x högre servicestudie än HuggingFace Text Generation Inference (TGI).
• LLaMA-7B, A10G: Liknande trender observeras, med vLLM som signifikant överträffar både HF och TGI.

vLLM: En ny LLM-servicearkitektur

vLLM, utvecklad av forskare vid UC Berkeley, representerar ett betydande steg framåt i LLM-service-teknologi. Låt oss utforska dess viktigaste funktioner och innovationer:

PagedAttention

I hjärtat av vLLM ligger PagedAttention, en ny uppmärksamhetsalgoritm inspirerad av virtuell minneshantering i operativsystem. Här är hur det fungerar:

– Nyckel-Värde (KV)-cacheuppdelning: Istället för att lagra hela KV-cachen kontinuerligt i minnet, delar PagedAttention den in i fastställda block.
– Icke-sammanhängande lagring: Dessa block kan lagras icke-sammanhängande i minnet, vilket möjliggör mer flexibel minneshantering.
– Allokeringsbegäran: Block allokeras endast när de behövs, vilket minskar minnesavfall.
– Effektiv delning: Flera sekvenser kan dela block, vilket möjliggör optimeringar för tekniker som parallell sampling och strålsökning.

Illustration:

“`
Traditionell KV-cache:
[Token 1 KV][Token 2 KV][Token 3 KV]…[Token N KV]
(Sammanhängande minnesallokering)
“`

PagedAttention KV-cache:
[Block 1] -> Fysisk adress A
[Block 2] -> Fysisk adress C
[Block 3] -> Fysisk adress B
…
(Icke-sammanhängande minnesallokering)
“`

Denna metod minskar signifikant minnesfragmentering och möjliggör en mycket mer effektiv användning av GPU-minne.

Kontinuerlig batchning

vLLM implementerar kontinuerlig batchning, som dynamiskt bearbetar begäranden när de anländer, snarare än att vänta på att bilda fastställda batchar. Detta leder till lägre latens och högre servicestudie.

Exempel:

Tid 0ms: Begäran A anländer
Tid 10ms: Starta bearbetning av Begäran A
Tid 15ms: Begäran B anländer
Tid 20ms: Starta bearbetning av Begäran B (parallellt med A)
Tid 25ms: Begäran C anländer
…
“`

Med kontinuerlig batchning kan vLLM starta bearbetning av varje begäran omedelbart, snarare än att vänta på att gruppera dem i fördefinierade batchar.

Effektiv parallell sampling

För applikationer som kräver flera utdatasekvenser per prompt (t.ex. kreativa skrivhjälpmedel), lyser vLLM:s minneshanteringsegenskaper. Det kan generera flera utdata samtidigt som det återanvänder KV-cachen för delade prefix.

Exempelkod med vLLM:

from vllm import LLM, SamplingParams

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

<p># Generera 3 exempel 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"Exempel {i + 1}: {out.text}")

Denna kod genererar effektivt flera exempel för den angivna prompten, med vLLM:s optimeringar.

Prestandamätning av vLLM

För att verkligen uppskatta vLLM:s påverkan, låt oss titta på några prestandajämförelser:

Servicestudie jämförelse

Baserat på den tillgängliga informationen, överträffar vLLM signifikant andra servicerelösningar:

– Upp till 24x högre servicestudie jämfört med Hugging Face Transformers
– 2,2x till 3,5x högre servicestudie jämfört med Hugging Face Text Generation Inference (TGI)

Illustration:

“`
Servicestudie (Token/sekund)
|
| ****
| ****
| ****
| **** ****
| **** **** ****
| **** **** ****
|————————
HF TGI vLLM
“`

Minneseffektivitet

vLLM:s PagedAttention resulterar i nästan optimal minnesanvändning:

– Endast cirka 4% minnesavfall, jämfört med 60-80% i traditionella system
– Denna effektivitet möjliggör service av större modeller eller hantering av fler samtidiga begäranden med samma hårdvara

Komma igång med vLLM

Nu när vi har utforskat vLLM:s fördelar, låt oss gå igenom processen att ställa in och använda det i dina projekt.

6.1 Installation

Att installera vLLM är enkelt med pip:

!pip install vllm

6.2 Grundläggande användning för offline-inferens

Här är ett enkelt exempel på hur du använder vLLM för offline-textgenerering:

from vllm import LLM, SamplingParams

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

<p># Förbered prompts
prompts = [
"Skriv en kort dikt om artificiell intelligens:",
"Förklara kvantberäkning på ett enkelt sätt:"
]</p>

<p># Ställ in sampelparametrar
sampling_params = SamplingParams(temperature=0.8, max_tokens=100)</p>

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

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

Detta skript demonstrerar hur du laddar en modell, ställer in sampelparametrar och genererar text för flera prompts.

6.3 Konfigurera en vLLM-server

För online-service tillhandahåller vLLM en OpenAI-kompatibel API-server. Här är hur du ställer in den:

1. Starta servern:

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

2. Fråga servern med curl:

curl http://localhost:8000/v1/completions \
-H "Content-Type: application/json" \
-d '{
"model": "meta-llama/Llama-2-13b-hf",
"prompt": "The benefits of artificial intelligence include:",
"max_tokens": 100,
"temperature": 0.7
}'

Denna konfiguration möjliggör service av din LLM med ett gränssnitt som är kompatibelt med OpenAI:s API, vilket gör det enkelt att integrera i befintliga applikationer.

Avancerade ämnen om vLLM

Medan vLLM erbjuder signifikanta förbättringar i LLM-service, finns det ytterligare överväganden och avancerade ämnen att utforska:

7.1 Modellkvantisering

För ännu mer effektiv service, särskilt på hårdvara med begränsat minne, kan kvantiseringstekniker användas. Medan vLLM själv inte stöder kvantisering, kan det användas i kombination med kvantiserade modeller:

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

<p># Ladda en kvantiserad 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># Använd den kvantiserade modellen med vLLM
from vllm import LLM</p>

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

7.2 Distribuerad inferens

För extremt stora modeller eller högtrafikapplikationer kan distribuerad inferens över flera GPU eller maskiner vara nödvändig. Medan vLLM inte stöder detta naturligt, kan det integreras i distribuerade system med hjälp av ramverk som Ray:

import ray
from vllm import LLM

<p>@ray.remote(num_gpus=1)
class DistributedLLM:
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># Initiera distribuerade LLM
llm1 = DistributedLLM.remote("meta-llama/Llama-2-13b-hf")
llm2 = DistributedLLM.remote("meta-llama/Llama-2-13b-hf")</p>

<p># Använd dem parallellt
result1 = llm1.generate.remote("Prompt 1", sampling_params)
result2 = llm2.generate.remote("Prompt 2", sampling_params)</p>

<p># Hämta resultaten
print(ray.get([result1, result2]))

7.3 Övervakning och observerbarhet

När du servar LLM i produktion är övervakning avgörande. Medan vLLM inte tillhandahåller inbyggd övervakning, kan du integrera det med verktyg som Prometheus och Grafana:

from prometheus_client import start_http_server, Summary
from vllm import LLM

# Definiera mått
REQUEST_TIME = Summary(‘request_processing_seconds’, ‘Tid som tillbringats med att bearbeta begäran’)

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

# Exponera mått
start_http_server(8000)

# Använd modellen med övervakning
@REQUEST_TIME.time()
def process_request(prompt):
return llm.generate(prompt)

# Din serveloop här

Slutsats

Att serva stora språkmodeller effektivt är en komplex men avgörande uppgift i AI-eran. vLLM, med sin innovativa PagedAttention-algoritm och optimerad implementering, representerar ett betydande steg framåt för att göra LLM-distribution mer tillgänglig och kostnadseffektiv.

Genom att dramatiskt förbättra servicestudie, minska minnesavfall och möjliggöra mer flexibla servicer, öppnar vLLM upp nya möjligheter för att integrera kraftfulla språkmodeller i en mängd olika applikationer. Oavsett om du bygger en chattbot, ett innehållsgenereringssystem eller någon annan NLP-driven applikation, kommer förståelse och användning av verktyg som vLLM att vara avgörande för framgång.