Store språkmodeller (LLM) brukes stadig oftere for komplekse oppgaver som krever flere genereringsanrop, avanserte promptteknikker, kontrollflyt og strukturerte inndata/utdata. Likevel mangler det effektive systemer for programmering og utførelse av disse applikasjonene. SGLang, et nytt introdusert system, har som mål å løse dette ved å tilby effektiv utførelse av komplekse språkmodellprogrammer. SGLang består av et frontend-språk og en runtime. Frontenden forenkler programmeringen med primitiver for generering og parallellkontroll, mens runtime akselerer utførelsen gjennom nye optimaliseringer som RadixAttention for KV-cache-gjenbruk og komprimerte finitte tilstandsmaskiner for raskere strukturert utdata-dekoding. Eksperimenter viser at SGLang oppnår opptil 6,4× høyere gjennomstrømming sammenlignet med statens kunstige inferenssystemer på ulike store språk- og multimodale modeller, som løser oppgaver som agentkontroll, logisk resonnering, få-skudd-læring-benchmark, JSON-dekoding, gjenoppretting-forbedret genereringsrørledninger og multi-samtale.

Nylige fremgang i LLM-egenskaper har utvidet deres nytte, og de kan nå håndtere en bredere rekke generelle oppgaver og fungere som autonome agenter. I disse applikasjonene engasjerer LLM i multi-rund planlegging, resonnering og interaksjon med eksterne miljøer. Dette muliggjøres gjennom verktøybruk, flere inndata-modi og ulike promptteknikker, som f.eks. få-skudd-læring, selv-konsistens, skjelett-av-tenkning og tre-av-tenkning. Disse nye bruksområdene nødvendiggjør flere, ofte avhengige, LLM-genereringsanrop, og indikerer en trend mot å bruke multi-anropsstrukturer for å fullføre komplekse oppgaver.

Denne overgangen markerer en overgang fra enkel chatt til en mer sofistikert programmatisk bruk av LLM, hvor programmer planlegger og kontrollerer genereringsprosessene til LLM. Disse programmene kalles “Språkmodellprogrammer” (LM-programmer). Avanserte promptteknikker og agente-arbeidsflyter faller innenfor omfanget av LM-programmer. Det finnes to vanlige egenskaper ved LM-programmer: (1) LM-programmer innebærer vanligvis flere LLM-anrop innimellom kontrollflyt for å fullføre komplekse oppgaver og forbedre den totale kvaliteten. (2) LM-programmer mottar strukturerte inndata og produserer strukturerte utdata, og muliggjør komposisjon av LM-programmer og integrasjon i eksisterende programvaresystemer.

I denne artikkelen vil vi dykke dyptere inn i SGLang-rammeverket, utforske dets arkitektur, analysere dets ytelse og sammenligne det med statens kunstige rammeverk. La oss begynne.

En introduksjon til SGLang

Til tross for den utbredte bruken av LM-programmer, er nåværende systemer for å uttrykke og utføre dem ineffektive. SGLang identifiserer to primære utfordringer forbundet med den effektive bruken av LM-programmer:

• Programmeringskompleksitet: Utvikling av LM-programmer er kjedelig og vanskelig på grunn av den ikke-deterministiske naturen til LLM. Dette inkluderer omfattende strengmanipulering, eksperimentell finjustering av prompter, skjør utdataparsing, håndtering av flere inndata-modi og implementering av parallellisme-mekanismer. Denne kompleksiteten reduserer betydelig lesbarheten av selv enkle programmer.
• Utførelse-ineffektivitet: Utførelse av LM-programmer er ineffektiv på grunn av redundant beregning og minnebruk. Statens kunstige inferensmotorer, optimalisert for å redusere latens og forbedre gjennomstrømming, mangler direkte kunnskap om arbeidsbelastningen, og resulterer i betydelige ineffektiviteter. Et bemerkelsesverdig eksempel er gjenbruk av Key-Value (KV)-cachen, som består av gjenbrukbare mellomliggende tensorer essensielle for generativ inferens. Nåværende systemer mangler effektive mekanismer for å muliggjøre KV-cache-gjenbruk over flere LLM-anrop som deler en felles prefiks, og fører til unødvendige beregninger og spild av minne. I tillegg er begrenset dekoding for strukturerte utdata, som f.eks. JSON-modus, underoptimalt, da eksisterende systemer bare dekoder ett token om gangen.

For å løse disse utfordringene, introduserer SGLang et strukturert genereringsspråk for LLM. Kjernen i dette er å systematisk utnytte den multi-anropsstrukturen i LM-programmer for effektiv utførelse. Som vist i figuren nedenfor, har SGLang to deler: et frontend-språk og en backend-runtime.

Frontenden forenkler programmeringen av LM-programmer, og runtime akselerer deres utførelse. Disse delene kan fungere sammen for bedre ytelse eller fungere uavhengig.

SGLang er et domene-spesifikt språk innbygget i Python, og tilbyr primitiver for generering (f.eks. extend, gen, select) og parallellkontroll (f.eks. fork, join). Det er kompatibelt med Pythons kontrollflyt og biblioteker, og lar brukerne utvikle avanserte prompt-workflows enkelt med naturlig Python-syntaks. SGLang inkluderer en tolker og en kompilator. Tolkeren håndterer prompt-tilstanden som en strøm og sender primitive operasjoner til strømmen for asynkron utførelse, og sikrer korrekt kontroll over synkronisering og intra-program-parallellisme. I tillegg kan SGLang-programmer spores og kompilert for ytterligere optimaliseringer. Runtime-delen i SGLang foreslår flere nye optimaliseringer for å akselerere utførelsen av LM-programmer:

• RadixAttention: Denne teknikken muliggjør automatisk gjenbruk av KV-cachen over flere genereringsanrop. I eksisterende inferensmotorer, blir KV-cachen til en forespørsel kastet etter behandling, og hindrer gjenbruk over flere anrop, og sakte utførelse. SGLang opprettholder en LRU-cache av KV-cachen innenfor en radix-tre, og håndterer KV-cachen som en tradisjonell cache, og bruker radix-treet for effektiv matching, innsetting og utvisning. Dette lar runtime håndtere ulike gjenbruksmønster effektivt.
• Komprimert finitt tilstandsmaskin: Denne teknikken muliggjør raskere begrenset dekoding for strukturerte utdata. Eksisterende systemer følger begrensninger bare for det neste tokenet, og kan bare dekodere ett token om gangen. I stedet analyserer SGLang begrensningene og bygger en komprimert finitt tilstandsmaskin for å representere dem, og komprimerer en multi-token-sti til en enkelt-steg-sti når det er mulig, og lar dekodningen av flere tokener på en gang for raskere hastighet.
• API-spekulativ utførelse: For API-bare modeller som OpenAIs GPT-4, introduserer SGLang API-spekulativ utførelse for å optimalisere multi-anropsprogrammer.

Med SGLang, ble ulike LLM-applikasjoner implementert, inkludert agentkontroll, logisk resonnering, få-skudd-læring-benchmark, JSON-dekoding, gjenoppretting-forbedret genereringsrørledninger, multi-samtale og multi-modalitet-prosesser. Ytelsen ble testet på modeller inkludert Llama-7B/70B, Mistral-8x7B, LLaVA-v1.5-7B (bilde) og LLaVA-NeXT-34B (video) på NVIDIA A10G og A100 GPU-er. Eksperimentelle resultater viser at SGLang oppnår opptil 6,4× høyere gjennomstrømming over en rekke arbeidsbelastninger, modeller og maskinvare-konfigurasjoner, sammenlignet med eksisterende programmerings- og inferenssystemer, inkludert Guidance, vLLM og LMQL.

SGLang: Programmeringsmodell og metode

SGLang-programmeringsmodellen introduseres gjennom et eksempel, som beskriver språkprimitivene og utførelsemodusene, og skisserer runtime-optimaliseringer. Denne modellen forenkler kjedelige operasjoner i multi-anrops-arbeidsflyter (f.eks. strengmanipulering, API-anrop, begrensningsspesifikasjon, parallellisme) ved å tilby fleksible og komponerbare primitiver. SGLang er et domene-spesifikt språk innbygget i Python. Følgende figur viser et program som vurderer en essai om et bilde med hjelp av gren-til-løsning-sammenføyning-metoden.

Funksjonen multi_dimensional_judge tar tre argumenter: `s`, `path` og `essay`. s håndterer prompt-tilstanden, path er bilde-fil-stien, og essay er essai-teksten. Nye strenger og SGLang-primitiver kan legges til tilstanden s for utførelse ved hjelp av +=-operatoren. Først legger funksjonen til bilde og essai til prompten. Den sjekker deretter om essaiet er relatert til bilde ved hjelp av select, og lagrer resultatet i s[“related”]. Hvis relatert, deles prompten inn i tre kopier for parallell vurdering fra ulike dimensjoner, ved hjelp av gen for å lagre resultater i f[“judgment”]. Deretter slås vurderingene sammen, genereres en sammenfatting, og tildeles en bokstav-karakter. Til slutt returneres resultatene i JSON-format, etter et skjema definert av en regulær uttrykk-begrensning regex. SGLang forenkler betydelig dette programmet, da et ekvivalent program som bruker et OpenAI-API-lignende grensesnitt ville kreve 2,1× så mange kode-linjer på grunn av manuell strengmanipulering og parallellisme-kontroll.

SGLang tilbyr primitiver for å kontrollere prompt-tilstand, generering og parallellisme, som kan brukes med Python-syntaks og biblioteker. Her er primitivene:

gen: Kaller en modell for å generere og lagrer resultater i en variabel med navnet spesifisert i dens første argument. Den støtter et `regex`-argument for å begrense utdata til å følge en grammatikk definert av et regulært uttrykk (f.eks. et JSON-skjema).

• select: Kaller en modell for å velge det høyest sannsynlige alternativet fra en liste.
• += eller extend: Legger til en streng til prompten.
• [variabel_navn]: Henter resultater fra en generering.
• fork: Oppretter parallele forgreninger av prompt-tilstanden.
• join: Gjenforener prompt-tilstanden.
• image og video: Tar imot bilde- og video-inndata.

Den enkleste måten å utføre et SGLang-program er gjennom en tolker, hvor en prompt behandles som en asynkron strøm. Primitiver som extend, gen og select sendes til strømmen for asynkron utførelse. Disse non-blokkerende anrop lar Python-koden fortsette å kjøre uten å vente på at genereringen er ferdig, lignende å lansere CUDA-kjerner asynkront. Hver prompt håndteres av en strøm-utfører i en bakgrunnstråd, og muliggjør intra-program-parallellisme. Henting av genereringsresultater vil blokkere til de er klare, og sikrer korrekt synkronisering. Alternativt kan SGLang-programmer kompilert som beregningsgrafer og utført med en graf-utfører, og tillate ytterligere optimaliseringer. Denne artikkelen bruker tolker-modus som standard, og diskuterer kompilator-modus-resultater i Appendiks D. SGLang støtter åpne vekt-modeller med sin egen SGLang Runtime (SRT), samt API-modeller som OpenAI og Anthropic-modeller.

Programmeringssystemer for LLM kan klassifiseres som høynivå (f.eks. LangChain, DSPy) og lavnivå (f.eks. LMQL, Guidance, SGLang). Høynivå-systemer tilbyr forhåndsdefinerte eller auto-genererte prompter, som f.eks. DSPys prompt-optimizer. Lav-nivå-systemer tillater vanligvis ikke å endre prompter, men lar direkte manipulering av prompter og primitiver. SGLang er et lav-nivå-system lignende LMQL og Guidance. Følgende tabell sammenligner deres funksjoner.

SGLang fokuserer mer på runtime-effektivitet og kommer med sin egen co-designet runtime, og tillater nye optimaliseringer. Høynivå-språk (f.eks. DSPy) kan kompilert til lav-nivå-språk (f.eks. SGLang). Integreringen av SGLang som en bakende i DSPy for bedre runtime-effektivitet demonstreres senere.

Eksempelet ovenfor illustrerer RadixAttention-operasjoner med en LRU-utvisningspolitikk over ni tidspunkter, og viser den dynamiske utviklingen av radix-treet i respons til ulike forespørsler. Disse forespørslene inkluderer to chatsesjoner, en batch med få-skudd-læring-spørsmål og selv-konsistens-prøving. Hver tre-kant bærer en etikett som angir en understreng eller en sekvens av token. Nodene er farge-kodet for å reflektere ulike tilstander: grønn for nytt tilføyede noder, blå for cachede noder aksessert under tidspunktet, og rød for noder som har blitt utvist.

Steg 1: Radix-treet er initialt tomt.

Steg 2: Serveren prosesserer en innkommende bruker-melding “Hei” og responderer med LLM-utdata “Hi”. System-prompten “Du er en hjelpsom assistent”, bruker-meldingen “Hei!” og LLM-svaret “Hi!” konsolideres til treet som en enkelt kant koblet til en ny node.

Steg 3: En ny prompt ankommer, og serveren finner prefikset til prompten (dvs. den første runden i samtalen) i radix-treet og gjenbruker dens KV-cache. Den nye runden legges til treet som en ny node.

Steg 4: En ny chatsesjon begynner. Noden fra steg 3 deles inn i to noder for å tillate at de to chatsesjonene kan dele system-prompten.

Steg 5: Den andre chatsesjonen fortsetter. Imidlertid, på grunn av minnebegrensninger, må en node fra steg 4 utvises. Den nye runden legges til etter den gjenværende noden fra steg 4.

Steg 6: Serveren mottar en få-skudd-læring-forespørsel, prosesserer den og setter den inn i treet. Rot-noden deles fordi den nye forespørselen ikke deler noen prefiks med eksisterende noder.

Steg 7: Serveren mottar en batch med flere få-skudd-læring-forespørsler. Disse forespørslene deler samme sett med få-skudd-eksempler, så en node fra steg 6 deles for å muliggjøre deling.

Steg 8: Serveren mottar en ny melding fra den første chatsesjonen. Den utviser alle noder fra den andre chatsesjonen, da de er minst nylig brukt.

Steg 9: Serveren mottar en forespørsel om å prøve flere svar for spørsmålene i en node fra steg 8, sannsynligvis for selv-konsistens-prøving. For å gi plass til disse forespørslene, utvises flere noder.

Dette eksempelet demonstrerer hvordan RadixAttention håndterer den dynamiske tildelingen og utvisningen av noder i respons til ulike typer forespørsler, og sikrer effektivt KV-cache-gjenbruk og minnehåndtering.

SGLang: Evaluering og resultater

Resultater på åpne vekt-modeller

Latens- og gjennomstrømningsresultatene vises i følgende figurer. SGLang forbedrer gjennomstrømmingen med opptil 6,4× og reduserer latensen med opptil 3,7×. Disse forbedringene skyldes KV-cache-gjenbruk, utnyttelse av parallellisme innenfor et enkelt program, og raskere begrenset dekoding.

På disse benchmarkene var cache-treff-raten mellom 50% og 99%. Figur 13 (Appendiks) lister opp de oppnådde og optimale cache-treff-ratene for alle, og viser at SGLang sin cache-bevisst planlegging nærmer seg 96% av den optimale treff-raten i gjennomsnitt.

Resultater på større modeller med tensor-parallellisme

Større modeller, Mixtral-8x7B og Llama-70B, ble testet med tensor-parallellisme på samme sett med benchmark, og resultater rapporteres i følgende figur. Hastigheten på større modeller viser en trend lignende den observerte på mindre modeller, og indikerer at SGLang sin optimalisering generaliserer godt til større modeller. Guidance og LMQL ble utelatt på grunn av manglende effektive implementeringer av tensor-parallellisme.

Resultater på multi-modale modeller

SGLang har nativ støtte for multi-modale modeller med bilde- og video-primitiver. Optimaliseringene i denne artikkelen er kompatible med multi-modale modeller. For RadixAttention, beregnes hashen til inndata-bildene og brukes som nøkkel i radix-treet, og muliggjør gjenbruk av KV-cachen til bildetokene fra samme bilde. LLaVA-v1.5-7B (bilde) ble kjørt på llava-bench-in-the-wild og LLaVA-NeXT-34B (video) på ActivityNet. Fordi disse modellene ikke er godt støttet av andre baseline-systemer, ble modell-forfatterens originale implementering i Hugging Face Transformers brukt som baseline. Som vist i følgende tabell, tilbyr SGLang opptil 6× høyere gjennomstrømming på disse benchmarkene. I llava-bench-in-the-wild ble flere spørsmål om samme bilde behandlet, og SGLang-runtime gjenbrukte KV-cachen i dette tilfelle.

Produksjons-utplassering

SGLang har blitt utplassert i Chatbot Arena for å betjene åpne vekt-modeller. På grunn av lav trafikk for noen modeller, betjener bare en SGLang-arbeider hver. Etter en måned, ble en RadixAttention-cache-treff-rate på 52,4% for LLaVA-Next-34B og 74,1% for Vicuna-33B observert. Cache-treff kom fra vanlige system-meldinger, ofte gjenbrukte eksempel-bilder og multi-rundes chats-historier. Dette reduserte første-token-latensen i gjennomsnitt med 1,7× for Vicuna-33B.

Slutt-tanker

I denne artikkelen har vi talt om SGLang, et nytt introdusert system, som har som mål å løse dette ved å tilby effektiv utførelse av komplekse språkmodellprogrammer. SGLang består av et frontend-språk og en runtime. Frontenden forenkler programmeringen med primitiver for generering og parallellkontroll, mens runtime akselerer utførelsen gjennom nye optimaliseringer som RadixAttention for KV-cache-gjenbruk og komprimerte finitte tilstandsmaskiner for raskere strukturert utdata-dekoding. Eksperimenter viser at SGLang oppnår opptil 6,4× høyere gjennomstrømming sammenlignet med statens kunstige inferenssystemer på ulike store språk- og multimodale modeller, som løser oppgaver som agentkontroll, logisk resonnering, få-skudd-læring-benchmark, JSON-dekoding, gjenoppretting-forbedret genereringsrørledninger og multi-samtale.