Store sprogmodeller (LLM’er) anvendes i stigende grad til komplekse opgaver, der kræver multiple genereringskald, avancerede promptteknikker, kontrollflow og strukturerede input/output. Men effektive systemer til programmering og udførelse af disse programmer mangler. SGLang, et nyt introduceret system, søger at løse dette problem ved at give en effektiv udførelse af komplekse sprogmodelprogrammer. SGLang består af et frontend-sprog og en runtime. Frontenden forenkler programmeringen med primitiver for generering og parallelisme-kontrol, mens runtime accelererer udførelsen gennem nye optimeringer som RadixAttention til KV-cache-genbrug og komprimerede endelige tilstandsmaskiner til hurtigere struktureret output-dekodning. Eksperimenter viser, at SGLang opnår op til 6,4× højere gennemløb sammenlignet med nuværende inferenssystemer på forskellige store sprog- og multimodale modeller, der løser opgaver som agent-kontrol, logisk resonnering, få-skud-læringsbenchmarks, JSON-dekodning, retrieval-forstærket genereringsrørledninger og multi-turn-chat.

Seneste fremskridt i LLM-kapaciteter har udvidet deres nytte, så de kan håndtere en bredere vifte af generelle opgaver og fungere som selvstændige agenter. I disse anvendelser engagerer LLM’er sig i multi-rundt planlægning, resonnering og interaktion med eksterne miljøer. Dette faciliteres gennem værktøjsanvendelse, multiple input-modaliteter og forskellige promptteknikker, såsom få-skud-læring, selv-konsistens, skelet-af-tanke og træ-af-tanke. Disse nye brugsområder nødvendiggør multiple, ofte afhængige, LLM-genereringskald, hvilket indikerer en trend over for at anvende multi-kald-strukturer til at fuldføre komplekse opgaver.

Denne skift markerer en overgang fra simple chat til en mere sofistikeret programmatisk anvendelse af LLM’er, hvor programmer planlægger og kontrollerer genereringsprocesserne for LLM’er. Disse programmer kaldes “Sprogmodelprogrammer” (LM-programmer). Avancerede promptteknikker og agente-arbejdsgange falder inden for rammerne af LM-programmer. Der er to almindelige egenskaber ved LM-programmer: (1) LM-programmer involverer typisk multiple LLM-kald med kontrollflow for at fuldføre komplekse opgaver og forbedre den samlede kvalitet. (2) LM-programmer modtager strukturerede input og producerer strukturerede output, hvilket muliggør sammensætning af LM-programmer og integration i eksisterende software-systemer.

I denne artikel vil vi dykke dybere ind i SGLang-rammeværket, udforske dets arkitektur, analysere dets ydeevne og sammenligne det med nuværende frameworks. Så lad os komme i gang.

En introduktion til SGLang

På trods af den udbredte anvendelse af LM-programmer er nuværende systemer til at udtrykke og udføre dem ineffektive. SGLang identificerer to primære udfordringer i forbindelse med den effektive anvendelse af LM-programmer:

• Programmeringskompleksitet: Udvikling af LM-programmer er kedelige og svære på grund af den ikke-deterministiske natur af LLM’er. Dette indebærer omfattende strengmanipulation, eksperimentel finjustering af prompts, skrøbelig output-parsing, håndtering af multiple input-modaliteter og implementering af parallelisme-mekanismer. Denne kompleksitet reducerer betydeligt læseligheden af selv simple programmer.
• Udførelse-ineffektivitet: Udførelse af LM-programmer er ineffektiv på grund af redundant beregning og hukommelse. Nuværende inferens-motorer, optimeret til at reducere latency og forbedre gennemløb, mangler direkte viden om arbejdsbyrden, hvilket resulterer i betydelige ineffektiviteter. Et bemærkelsesværdigt eksempel er genbrug af Key-Value (KV)-cachen, der består af genbrugelige mellemvariable tensorer, der er essentielle for generativ inferens. Nuværende systemer mangler effektive mekanismer til at faciliterer KV-cache-genbrug på tværs af multiple LLM-kald, der deler en fælles præfiks, hvilket fører til unødvendige beregninger og spild af hukommelse. Derudover er begrænset dekodning for strukturerede output, såsom JSON-mode, underoptimalt, da eksisterende systemer kun dekoder én token ad gangen.

For at løse disse udfordringer introducerer SGLang et struktureret genereringssprog for LLM’er. Det centrale idé er at systematisk udnytte multi-kald-strukturen i LM-programmer til effektiv udførelse. Som vist i følgende figur, har SGLang to dele: et frontend-sprog og en backend-runtime.

Frontenden forenkler programmeringen af LM-programmer, og runtime accelererer deres udførelse. Disse dele kan arbejde sammen for bedre ydeevne eller fungere uafhængigt.

SGLang er et domænespecifikt sprog indlejret i Python, der giver primitiver for generering (f.eks. extend, gen, select) og parallelisme-kontrol (f.eks. fork, join). Det er kompatibelt med Pythons kontrollflow og biblioteker, hvilket muliggør udvikling af avancerede prompt-arbejdsgange med naturlig Python-syntaks. SGLang inkluderer en interpreter og en compiler. Interpreteren styrer prompt-tilstanden som en strøm og sender primitive operationer til strømmen for asynkron udførelse, hvilket sikrer korrekt kontrol over synkronisering og intra-program-parallelisme. Derudover kan SGLang-programmer spores og kompilieres for yderligere optimeringer. Runtime-delen af SGLang foreslår flere nye optimeringer til at accelerere udførelsen af LM-programmer:

• RadixAttention: Denne teknik muliggør automatisk genbrug af KV-cachen på tværs af multiple genereringskald. I eksisterende inferens-motorer bliver KV-cachen for en anmodning kasseret efter behandling, hvilket forhindrer genbrug på tværs af multiple kald og langsommere udførelse. SGLang vedligeholder en LRU-cache af KV-cachen inden for en radix-træ, der styrer KV-cachen som en traditionel cache og bruger radix-træet til effektiv matching, indsættelse og eviction. Dette muliggør, at runtime kan håndtere forskellige genbrugs-mønstre effektivt.
• Komprimeret endelig tilstandsmaskine: Denne teknik muliggør hurtigere begrænset dekodning for strukturerede output. Eksisterende systemer følger kun begrænsninger for den næste token, hvilket gør dem i stand til at dekodere én token ad gangen. I stedet analyserer SGLang begrænsningerne og opbygger en komprimeret endelig tilstandsmaskine til at repræsentere dem, hvilket komprimerer en multi-token-sti til en enkelt-trin-sti, når det er muligt, og muliggør dekodning af multiple tokens på én gang for hurtigere hastighed.
• API-speculative udførelse: For API-kun-modeller som OpenAI’s GPT-4 introducerer SGLang API-speculative udførelse til at optimere multi-kald-programmer.

Med SGLang blev forskellige LLM-anvendelser implementeret, herunder agent-kontrol, logisk resonnering, få-skud-læringsbenchmarks, JSON-dekodning, retrieval-forstærket genereringsrørledninger, multi-turn-chat og multi-modalitet-behandling. Ydeevnen blev testet på modeller, herunder Llama-7B/70B, Mistral-8x7B, LLaVA-v1.5-7B (billede) og LLaVA-NeXT-34B (video) på NVIDIA A10G og A100 GPU’er. Eksperimentelle resultater viser, at SGLang opnår op til 6,4× højere gennemløb på tværs af en bred vifte af workloads, modeller og hardware-konfigurationer, sammenlignet med eksisterende programmerings- og inferens-systemer, herunder Guidance, vLLM og LMQL.

SGLang: Programmeringsmodel og metode

SGLang-programmeringsmodellen introduceres gennem et løbende eksempel, der beskriver sprogets primitiver og udførelse-tilstande, og fremhæver runtime-optimeringsmuligheder. Denne model forenkler kedelige operationer i multi-kald-arbejdsgange (f.eks. strengmanipulation, API-kald, begrænsnings-specifikation, parallelisme) ved at give fleksible og sammensætnings-primitiver. SGLang er et domænespecifikt sprog indlejret i Python.

Funktionen multi_dimensional_judge tager tre argumenter: `s`, `path`, og `essay`. s styrer prompt-tilstanden, path er billedfil-stien, og essay er essay-teksten. Nye streng og SGLang-primitiver kan føjes til tilstanden s for udførelse ved hjælp af +=-operatoren. Først føjer funktionen billedet og essayet til prompten. Den checker derefter, om essayet er relateret til billedet ved hjælp af select, og gemmer resultatet i s[“related”]. Hvis relateret, forkedes prompten til tre kopier for parallel vurdering fra forskellige dimensioner, ved hjælp af gen til at gemme resultater i f[“judgment”]. Herefter samles vurderingerne, genereres en sammenfatning, og tildèles en bogstav-karakter. Til sidst returneres resultaterne i JSON-format, efter en skema defineret af en regulær udtryks-begrænsning regex. SGLang forenkler betydeligt dette program, da et tilsvarende program ved hjælp af en OpenAI-API-lignende grænseflade ville kræve 2,1× så mange linjer kode på grund af manuel strengmanipulation og parallelisme-kontrol.

SGLang giver primitiver for at kontrollere prompt-tilstand, generering og parallelisme, der kan anvendes med Python-syntaks og biblioteker. Her er primitiverne:

gen: Kalder en model til at generere og gemmer resultaterne i en variabel med det navn, der er specificeret i dens første argument. Det understøtter et `regex`-argument til at begrænse output til at følge en grammatik defineret af en regulær udtryks-sætning (f.eks. en JSON-skema).

• select: Kalder en model til at vælge den højeste sandsynlighedsoption fra en liste.
• += eller extend: Føjer en streng til prompten.
• [variabel_navn]: Henter resultaterne af en generering.
• fork: Oprettelse af parallelle fork af prompt-tilstanden.
• join: Genforening af prompt-tilstanden.
• image og video: Tager imod input fra billeder og videoer.

Den nemmeste måde at udføre et SGLang-program er gennem en interpreter, hvor en prompt behandles som en asynkron strøm. Primitiver som extend, gen og select sendes til strømmen for asynkron udførelse. Disse non-blocking-kald muliggør, at Python-kode kan fortsætte med at køre uden at vente på, at genereringen er færdig, ligesom lancering af CUDA-kerner asynkront. Hver prompt styrer en strøm-eksekutor i en baggrundstråd, hvilket muliggør intra-program-parallelisme. Henting af genereringsresultater vil blokere, indtil de er klar, hvilket sikrer korrekt synkronisering. Alternativt kan SGLang-programmer kompilieres som beregningsgrafer og udføres med en graf-eksekutor, hvilket muliggør yderligere optimeringer. Denne artikel bruger interpreter-tilstand som standard og diskuterer compiler-tilstands-resultater i Appendiks D. SGLang understøtter åbne-vægt-modeller med sin egen SGLang Runtime (SRT), samt API-modeller som OpenAI og Anthropic-modeller.

Programmeringssystemer for LLM’er kan klassificeres som højniveau (f.eks. LangChain, DSPy) og lavniveau (f.eks. LMQL, Guidance, SGLang). Højniveau-systemer giver foruddefinerede eller auto-genererede prompts, såsom DSPy’s prompt-optimizer. Lavniveau-systemer tillader typisk ikke ændring af prompts, men giver direkte manipulation af prompts og primitiver. SGLang er et lavniveau-system lignende LMQL og Guidance. Følgende tabel sammenligner deres funktioner.

SGLang fokuserer mere på runtime-effektivitet og kommer med sin egen co-designet runtime, der muliggør nye optimeringer. Højniveau-sprog (f.eks. DSPy) kan kompilieres til lavniveau-sprog (f.eks. SGLang). Integrationen af SGLang som en backend i DSPy til bedre runtime-effektivitet demonstreres senere.

Ovenstående eksempel illustrerer RadixAttention-operationer med en LRU-evictionspolitik på tværs af ni tidspunkter, der viser den dynamiske udvikling af radix-træet i respons til forskellige anmodninger. Disse anmodninger inkluderer to chat-sessions, en batch af få-skud-lærings-spørgsmål og selv-konsistens-prøvning. Hver træ-kant bærer en mærkning, der angiver en understreng eller en sekvens af tokens. Noderne er farvekodede for at reflektere forskellige tilstande: grøn for nyt tilføjede noder, blå for cachede noder, der er adgang til under tidspunktet, og rød for noder, der er blevet eviceret.

Trin 1: Radix-træet er initialt tomt.

Trin 2: Serveren behandler en indkommende brugerbesked “Hej” og responderer med LLM-udgang “Hej”. Systemprompten “Du er en hjælpsom assistent”, brugerbeskeden “Hej!” og LLM-svaret “Hej!” konsolideres til træet som en enkelt kant forbundet til en ny node.

Trin 3: En ny prompt ankommer, og serveren finder præfikset af prompten (dvs. den første runde af samtalen) i radix-træet og genbruger dens KV-cache. Den nye runde føjes til træet som en ny node.

Trin 4: En ny chat-session begynder. Noden fra Trin 3 deles i to noder for at tillade, at de to chat-sessions kan dele systemprompten.

Trin 5: Den anden chat-session fortsætter. Men på grund af hukommelsesbegrænsninger skal en node fra Trin 4 eviceres. Den nye runde føjes til efter den tilbageværende node fra Trin 4.

Trin 6: Serveren modtager en få-skud-lærings-anmodning, behandler den og indsætter den i træet. Rod-noden deles, fordi den nye anmodning ikke deler nogen præfiks med eksisterende noder.

Trin 7: Serveren modtager en batch af yderligere få-skud-lærings-anmodninger. Disse anmodninger deler den samme samling af få-skud-eksempler, så en node fra Trin 6 deles for at muliggøre deling.

Trin 8: Serveren modtager en ny besked fra den første chat-session. Den evicerer alle noder fra den anden chat-session, da de er mindst nyligt brugt.

Trin 9: Serveren modtager en anmodning om at prøve mere svar på spørgsmål i en node fra Trin 8, sandsynligvis for selv-konsistens-prøvning. For at give plads til disse anmodninger eviceres multiple noder.

Dette eksempel demonstrerer, hvordan RadixAttention håndterer den dynamiske tildeling og eviction af noder i respons til forskellige typer anmodninger, hvilket sikrer effektiv KV-cache-genbrug og hukommelsesstyring.

SGLang: Evaluering og resultater

Resultater på åbne-vægt-modeller

Latens- og gennemløbsresultaterne vises i følgende figurer. SGLang forbedrer gennemløbet med op til 6,4× og reducerer latensen med op til 3,7×. Disse forbedringer skyldes KV-cache-genbrug, udnyttelse af parallelisme inden for et enkelt program og hurtigere begrænset dekodning.

På disse benchmarks ligger cache-ramme-raten mellem 50% og 99%. Figur 13 (Appendiks) viser de opnåede og optimale cache-ramme-rater for alle af dem, hvilket viser, at SGLang’s cache-bevidst scheduling nærmer sig 96% af den optimale ramme-rate i gennemsnit.

Resultater på større modeller med tensor-parallelisme

Større modeller, Mixtral-8x7B og Llama-70B, blev testet med tensor-parallelisme på den samme samling af benchmarks, og resultaterne rapporteres i følgende figur. Speedup på større modeller viser en tendens lignende den, der observeres på mindre modeller, hvilket indikerer, at SGLang’s optimering generaliserer godt til større modeller. Guidance og LMQL blev udeladt på grund af manglen på effektive implementationer af tensor-parallelisme.

Resultater på multi-modale modeller

SGLang har naturlig støtte til multi-modale modeller med image- og video-primitiver. Optimeringerne i denne artikel er kompatible med multi-modale modeller. For RadixAttention beregnes hashen af input-billeder og bruges som nøgle i radix-træet, hvilket muliggør genbrug af KV-cachen af billed-token fra samme billede. LLaVA-v1.5-7B (billede) blev kørt på llava-bench-in-the-wild og LLaVA-NeXT-34B (video) på ActivityNet. Da disse modeller ikke er godt understøttet af andre baseline-systemer, blev model-forfatternes originale implementation i Hugging Face Transformers brugt som baseline. Som vist i følgende tabel giver SGLang op til 6× højere gennemløb på disse benchmarks. I llava-bench-in-the-wild blev multiple spørgsmål om samme billede behandlet, og SGLang-runtime genbrugte KV-cachen i dette tilfælde.

Produktions-udrulning

SGLang er blevet udrullet i Chatbot Arena til at betjene åbne-vægt-modeller. På grund af lav trafik for nogle modeller betjener kun én SGLang-arbejder hver. Efter en måned blev en 52,4% RadixAttention-cache-ramme-rate for LLaVA-Next-34B og 74,1% for Vicuna-33B observeret. Cache-rammer kom fra fælles system-besked, hyppigt genbrugte eksempel-billeder og multi-turn-chat-historik. Dette reducerede første-token-latensen i gennemsnit med 1,7× for Vicuna-33B.

Endelige tanker

I denne artikel har vi talt om SGLang, et nyt introduceret system, der søger at løse dette problem ved at give en effektiv udførelse af komplekse sprogmodelprogrammer. SGLang består af et frontend-sprog og en runtime. Frontenden forenkler programmeringen med primitiver for generering og parallelisme-kontrol, mens runtime accelererer udførelsen gennem nye optimeringer som RadixAttention til KV-cache-genbrug og komprimerede endelige tilstandsmaskiner til hurtigere struktureret output-dekodning. Eksperimenter viser, at SGLang opnår op til 6,4× højere gennemløb sammenlignet med nuværende inferens-systemer på forskellige store sprog- og multimodale modeller, der løser opgaver som agent-kontrol, logisk resonnering, få-skud-læringsbenchmarks, JSON-dekodning, retrieval-forstærket genereringsrørledninger og multi-turn-chat.