Grote taalmodellen (LLM’s) worden steeds vaker gebruikt voor complexe taken die meerdere generatieaanroepen, geavanceerde prompttechnieken, controle van de werkstroom en gestructureerde invoer/uitvoer vereisen. Echter, efficiënte systemen voor het programmeren en uitvoeren van deze toepassingen ontbreken. SGLang, een nieuw geïntroduceerd systeem, heeft als doel dit probleem aan te pakken door efficiënte uitvoering van complexe taalmodelprogramma’s te bieden. SGLang bestaat uit een frontend-taal en een runtime. De frontend vereenvoudigt het programmeren met primitieven voor generatie en parallelle controle, terwijl de runtime de uitvoering versnelt door middel van nieuwe optimalisaties zoals RadixAttention voor hergebruik van de KV-cache en compressie van eindige statemachines voor snellere gestructureerde uitvoerdecoding. Experimenten laten zien dat SGLang tot 6,4 keer hogere doorvoer bereikt in vergelijking met state-of-the-art-inferentiesystemen op diverse grote taal- en multimodale modellen, waarmee taken zoals agentcontrole, logisch redeneren, few-shot learning-benchmarks, JSON-decoding, retrieval-augmented generatiepijplijnen en multi-turn chat worden aangepakt.

Recente vooruitgang in de mogelijkheden van LLM’s heeft hun bruikbaarheid uitgebreid, waardoor ze een bredere reeks algemene taken kunnen uitvoeren en als autonome agenten kunnen functioneren. In deze toepassingen engageren LLM’s zich in meerdere ronden van planning, redenering en interactie met externe omgevingen. Dit wordt gefaciliteerd door het gebruik van tools, meerdere invoermodi en verschillende prompttechnieken, zoals few-shot learning, zelfconsistentie, skelet-van-gedachten en boom-van-gedachten. Deze nieuwe use cases vereisen meerdere, vaak afhankelijke, LLM-generatieaanroepen, wat een trend aanduidt van het gebruik van multi-call-structuren om complexe taken te voltooien.

Deze verschuiving markeert een overgang van eenvoudig chatten naar een meer geavanceerd programmatisch gebruik van LLM’s, waarbij programma’s de generatieprocessen van LLM’s plannen en controleren. Deze programma’s worden “Taalmodelprogramma’s” (LM-programma’s) genoemd. Geavanceerde prompttechnieken en agentic workflows vallen binnen het bereik van LM-programma’s. Er zijn twee veelvoorkomende eigenschappen van LM-programma’s: (1) LM-programma’s omvatten meestal meerdere LLM-aanroepen die zijn geïnterpoleerd met controle van de werkstroom om complexe taken te voltooien en de algehele kwaliteit te verbeteren. (2) LM-programma’s ontvangen gestructureerde invoer en produceren gestructureerde uitvoer, waardoor ze kunnen worden samengesteld en geïntegreerd in bestaande softwaresystemen.

In dit artikel zullen we dieper ingaan op het SGLang-framework, waarbij we de architectuur, prestaties en vergelijking met state-of-the-art-frameworks zullen onderzoeken. Laten we beginnen.

Een introductie tot SGLang

Ondanks het wijdverbreide gebruik van LM-programma’s, blijven de huidige systemen voor het uitdrukken en uitvoeren ervan inefficiënt. SGLang identificeert twee primaire uitdagingen die verband houden met het efficiënte gebruik van LM-programma’s:

• Programmeercomplexiteit: Het ontwikkelen van LM-programma’s is tijdrovend en moeilijk vanwege de niet-deterministische aard van LLM’s. Dit omvat uitgebreide stringmanipulatie, experimentele afstemming van prompts, broze outputparsing, het afhandelen van meerdere invoermodi en het implementeren van parallelle mechanismen. Deze complexiteit vermindert de leesbaarheid van zelfs eenvoudige programma’s aanzienlijk.
• Uitvoerinefficiëntie: Het uitvoeren van LM-programma’s is inefficiënt vanwege redundantie in berekeningen en geheugengebruik. State-of-the-art-inferentiesystemen, geoptimaliseerd om latentie te verminderen en doorvoer te verbeteren, ontbreken directe kennis van de workload, waardoor significante inefficiënties ontstaan. Een opvallend voorbeeld is het hergebruik van de Key-Value (KV)-cache, die bestaat uit herbruikbare tussenliggende tensors die essentieel zijn voor generatieve inferentie. Huidige systemen ontbreken effectieve mechanismen om KV-cache-hergebruik te faciliteren over meerdere LLM-aanroepen die een gemeenschappelijk voorvoegsel delen, waardoor onnodige berekeningen en verspilde geheugen ontstaan. Bovendien is geconstrueerde decoding voor gestructureerde uitvoer, zoals JSON-modus, suboptimaal, omdat bestaande systemen alleen één token tegelijk decoderen.

Om deze uitdagingen aan te pakken, introduceert SGLang een gestructureerde generatietaal voor LLM’s. Het kernidee is om systematisch de multi-call-structuur in LM-programma’s te exploiteren voor efficiënte uitvoering. Zoals weergegeven in de volgende figuur, bestaat SGLang uit twee delen: een frontend-taal en een backend-runtime.

De frontend vereenvoudigt het programmeren van LM-programma’s, en de runtime versnelt hun uitvoering. Deze delen kunnen samenwerken voor betere prestaties of onafhankelijk functioneren.

SGLang is een domeinspecifieke taal die is ingebed in Python, met primitieven voor generatie (bijv. extend, gen, select) en parallelle controle (bijv. fork, join). Het is compatibel met Python’s controle van de werkstroom en bibliotheken, waardoor gebruikers gemakkelijk geavanceerde promptworkflows kunnen ontwikkelen met native Python-syntaxis. SGLang omvat een interpreter en een compiler. De interpreter beheert de promptstatus als een stream en verzendt primitieve operaties naar de stream voor asynchrone uitvoering, waardoor een juiste controle over synchronisatie en intra-programmaparallelle verwerking wordt gewaarborgd. Bovendien kunnen SGLang-programma’s worden getraceerd en gecompileerd voor verdere optimalisaties. De runtime van SGLang stelt verschillende nieuwe optimalisaties voor om de uitvoering van LM-programma’s te versnellen:

• RadixAttention: Deze techniek maakt het automatisch hergebruik van de KV-cache over meerdere generatieaanroepen mogelijk. In bestaande inferentiesystemen wordt de KV-cache van een aanvraag verwijderd na verwerking, waardoor hergebruik over meerdere aanroepen wordt voorkomen en de uitvoering wordt vertraagd. SGLang onderhoudt een LRU-cache van de KV-cache in een radix-boom, waardoor de KV-cache als een traditionele cache wordt beheerd en de radix-boom wordt gebruikt voor efficiënte matching, invoeging en verwijdering.
• Compressed Finite State Machine: Deze techniek maakt snellere geconstrueerde decoding voor gestructureerde uitvoer mogelijk. Bestaande systemen volgen alleen de beperkingen voor het volgende token, waardoor ze alleen één token tegelijk kunnen decoderen. In plaats daarvan analyseert SGLang de beperkingen en bouwt een gecomprimeerde eindige statemachine om ze te representeren, waardoor een multi-token-pad in één stap kan worden gecomprimeerd wanneer dit mogelijk is, waardoor meerdere tokens tegelijk kunnen worden gedecodeerd voor een snellere snelheid.
• API Speculative Execution: Voor API-only-modellen zoals OpenAI’s GPT-4 introduceert SGLang API-speculatieve uitvoering om multi-call-programma’s te optimaliseren.

Met SGLang zijn verschillende LLM-toepassingen geïmplementeerd, waaronder agentcontrole, logisch redeneren, few-shot learning-benchmarks, JSON-decoding, retrieval-augmented generatiepijplijnen, multi-turn chat en multi-modale verwerking. De prestaties werden getest op modellen zoals Llama-7B/70B, Mistral-8x7B, LLaVA-v1.5-7B (beeld) en LLaVA-NeXT-34B (video) op NVIDIA (NVDA ) A10G- en A100-GPU’s. Experimentele resultaten laten zien dat SGLang tot 6,4 keer hogere doorvoer bereikt over een breed scala aan workloads, modellen en hardwareconfiguraties, in vergelijking met bestaande programmerings- en inferentiesystemen, waaronder Guidance, vLLM en LMQL.

SGLang: Programmeringsmodel en methodologie

Het SGLang-programmeringsmodel wordt geïntroduceerd door middel van een lopend voorbeeld, waarin de taalprimitieven en uitvoermodi worden beschreven en de runtime-optimalisatiekansen worden aangegeven. Dit model vereenvoudigt tijdrovende bewerkingen in multi-call-workflows (bijv. stringmanipulatie, API-aanroepen, beperkingsspecificatie, parallelle verwerking) door flexibele en componerenbare primitieven te bieden. SGLang is een domeinspecifieke taal die is ingebed in Python. De volgende figuur toont een programma dat een essay over een beeld beoordeelt met behulp van de branch-solve-merge-promptmethode.

De functie multi_dimensional_judge neemt drie argumenten: `s`, `path` en `essay`. s beheert de promptstatus, path is het bestandspad van het beeld en essay is de tekst van het essay. Nieuwe strings en SGLang-primitieven kunnen worden toegevoegd aan de status s voor uitvoering met behulp van de +=-operator. Eerst voegt de functie het beeld en het essay toe aan de prompt. Vervolgens controleert het of het essay verband houdt met het beeld met behulp van select en slaat het resultaat op in s[“related”]. Als het essay verband houdt, wordt de prompt gesplitst in drie kopieën voor parallelle evaluatie vanuit verschillende dimensies, met behulp van gen om de resultaten op te slaan in f[“judgment”]. Vervolgens worden de oordelen samengevoegd, wordt een samenvatting gegenereerd en wordt een lettercijfer toegewezen. Ten slotte wordt het resultaat geretourneerd in JSON-formaat, volgens een schema dat is gedefinieerd door een reguliere expressiebeperking regex. SGLang vereenvoudigt dit programma aanzienlijk, aangezien een equivalent programma met een OpenAI-API-achtige interface 2,1 keer zoveel regels code zou vereisen vanwege handmatige stringmanipulatie en parallelle controle.

SGLang biedt primitieven voor het controleren van de promptstatus, generatie en parallelle verwerking, die kunnen worden gebruikt met Python-syntaxis en -bibliotheken. Hier zijn de primitieven:

gen: roept een model aan om te genereren en slaat de resultaten op in een variabele met de naam die is opgegeven in het eerste argument. Het ondersteunt een `regex`-argument om de uitvoer te beperken tot een grammatica die is gedefinieerd door een reguliere expressie (bijv. een JSON-schema).

• select: roept een model aan om de hoogstwaarschijnlijke optie te kiezen uit een lijst.
• += of extend: voegt een string toe aan de prompt.
• [variabele_naam]: haalt de resultaten van een generatie op.
• fork: maakt parallelle forks van de promptstatus.
• join: voegt de promptstatus weer samen.
• beeld en video: nemen beeld- en videoinvoer.

De eenvoudigste manier om een SGLang-programma uit te voeren is via een interpreter, waarbij een prompt wordt behandeld als een asynchrone stream. Primitieven zoals extend, gen en select worden naar de stream verzonden voor asynchrone uitvoering. Deze niet-blokkerende aanroepen stellen Python-code in staat om door te gaan zonder te wachten tot de generatie is voltooid, vergelijkbaar met het asynchroon lanceren van CUDA-kernels. Elke prompt wordt beheerd door een stream-uitvoerder in een achtergrondthread, waardoor intra-programmaparallelle verwerking mogelijk wordt. Het ophalen van generatieresultaten zal worden geblokkeerd totdat ze klaar zijn, waardoor een correcte synchronisatie wordt gegarandeerd. Alternatief kunnen SGLang-programma’s worden gecompileerd als computationele grafieken en worden uitgevoerd met een grafiekuitvoerder, waardoor verdere optimalisaties mogelijk worden. Dit artikel gebruikt de interpretermodus standaard en bespreekt de resultaten van de compilermodus in Bijlage D. SGLang ondersteunt open-weight-modellen met zijn eigen SGLang-runtime (SRT), evenals API-modellen zoals OpenAI en Anthropic-modellen.

Programmeersystemen voor LLM’s kunnen worden ingedeeld in high-level (bijv. LangChain, DSPy) en low-level (bijv. LMQL, Guidance, SGLang). High-level-systemen bieden vooraf gedefinieerde of automatisch gegenereerde prompts, zoals DSPy’s prompt-optimizer. Low-level-systemen doen dit meestal niet, maar stellen directe manipulatie van prompts en primitieven toe. SGLang is een low-level-systeem dat vergelijkbaar is met LMQL en Guidance. De volgende tabel vergelijkt hun functies.

SGLang richt zich meer op runtime-efficiëntie en komt met zijn eigen co-ontworpen runtime, waardoor nieuwe optimalisaties mogelijk worden. High-level-talen (bijv. DSPy) kunnen worden gecompileerd naar low-level-talen (bijv. SGLang). De integratie van SGLang als backend in DSPy voor betere runtime-efficiëntie wordt later aangetoond.

Het bovenstaande voorbeeld illustreert RadixAttention-bewerkingen met een LRU-verwijderingsbeleid over negen tijdpunten, waarbij de dynamische toewijzing en verwijdering van knooppunten in reactie op verschillende aanvragen wordt getoond. Deze aanvragen omvatten twee chatsessies, een batch few-shot learning-vragen en zelfconsistentie-sampling. Elke boomrand draagt een label dat een substring of een reeks tokens aanduidt. De knooppunten zijn gekleurd om verschillende staten aan te duiden: groen voor nieuw toegevoegde knooppunten, blauw voor gekoppelde knooppunten die tijdens het tijdstip zijn geopend, en rood voor knooppunten die zijn verwijderd.

Stap 1: De radix-boom is aanvankelijk leeg.

Stap 2: De server verwerkt een binnenkomende gebruikersbericht “Hallo” en reageert met de LLM-uitvoer “Hoi”. De systeemprompt “Je bent een behulpzame assistent”, het gebruikersbericht “Hallo!” en de LLM-reactie “Hoi!” worden samengevoegd in de boom als één rand die is gekoppeld aan een nieuw knooppunt.

Stap 3: Een nieuwe prompt arriveert en de server vindt het voorvoegsel van de prompt (d.w.z. de eerste beurt van het gesprek) in de radix-boom en hergebruikt de KV-cache. De nieuwe beurt wordt toegevoegd aan de boom als een nieuw knooppunt.

Stap 4: Een nieuwe chatsessie begint. Het knooppunt uit stap 3 wordt gesplitst in twee knooppunten om de twee chatsessies te laten delen van de systeemprompt.

Stap 5: De tweede chatsessie gaat verder. Echter, vanwege geheugenbeperkingen, moet een knooppunt uit stap 4 worden verwijderd. De nieuwe beurt wordt toegevoegd na het resterende knooppunt uit stap 4.

Stap 6: De server ontvangt een few-shot learning-aanvraag, verwerkt deze en voegt deze toe aan de boom. De rootknoop wordt gesplitst omdat de nieuwe aanvraag geen voorvoegsel deelt met bestaande knooppunten.

Stap 7: De server ontvangt een batch aanvullende few-shot learning-aanvragen. Deze aanvragen delen hetzelfde set few-shot-voorbeelden, dus een knooppunt uit stap 6 wordt gesplitst om delen mogelijk te maken.

Stap 8: De server ontvangt een nieuw bericht van de eerste chatsessie. Het verwijdert alle knooppunten van de tweede chatsessie omdat ze het minst recent zijn gebruikt.

Stap 9: De server ontvangt een aanvraag om meer antwoorden te genereren voor de vragen in een knooppunt uit stap 8, waarschijnlijk voor zelfconsistentie-prompting. Om ruimte te maken voor deze aanvragen, worden meerdere knooppunten verwijderd.

Dit voorbeeld illustreert hoe RadixAttention de dynamische toewijzing en verwijdering van knooppunten in reactie op verschillende aanvragen afhandelt, waardoor efficiënt hergebruik van de KV-cache en geheugenbeheer mogelijk wordt.

SGLang: Evaluatie en resultaten

Resultaten op open-weight-modellen

De latentie- en doorvoerresultaten worden weergegeven in de volgende figuren. SGLang verbetert de doorvoer met tot 6,4 keer en vermindert de latentie met tot 3,7 keer. Deze verbeteringen zijn het resultaat van KV-cache-hergebruik, exploitatie van parallelle verwerking binnen een enkel programma en snellere geconstrueerde decoding.

Op deze benchmarks varieert de cache-treffersnelheid van 50% tot 99%. Figuur 13 (Bijlage) vermeldt de behaalde en optimale cache-treffersnelheden voor alle benchmarks, waaruit blijkt dat SGLang’s cache-gevoelige planning 96% van de optimale treffersnelheid benadert.

Resultaten op grotere modellen met tensorparallelle verwerking

Grotere modellen, Mixtral-8x7B en Llama-70B, werden getest met tensorparallelle verwerking op dezelfde set benchmarks, en de resultaten worden gerapporteerd in de volgende figuur. De snelheidsverbetering op grotere modellen vertoont een trend die vergelijkbaar is met die op kleinere modellen, wat aangeeft dat SGLang’s optimalisatie goed generaliseert naar grotere modellen. Guidance en LMQL werden weggelaten vanwege het ontbreken van efficiënte implementaties van tensorparallelle verwerking.

Resultaten op multi-modale modellen

SGLang heeft native ondersteuning voor multi-modale modellen met de beeld- en video-primitieven. De optimalisaties in dit artikel zijn compatibel met multi-modale modellen. Voor RadixAttention wordt de hash van de invoerbeelden berekend en gebruikt als sleutel in de radix-boom, waardoor hergebruik van de KV-cache van de beeldtokens van hetzelfde beeld mogelijk wordt. LLaVA-v1.5-7B (beeld) werd uitgevoerd op llava-bench-in-the-wild en LLaVA-NeXT-34B (video) op ActivityNet. Omdat deze modellen niet goed worden ondersteund door andere basissystemen, werd de oorspronkelijke implementatie van de modelauteurs in Hugging Face Transformers gebruikt als baseline. Zoals weergegeven in de volgende tabel, biedt SGLang een doorvoer tot 6 keer hoger op deze benchmarks. In llava-bench-in-the-wild werden meerdere vragen over hetzelfde beeld afgehandeld, en de SGLang-runtime hergebruikte de KV-cache in dit geval.

Productie-implementatie

SGLang is geïmplementeerd in Chatbot Arena om open-weight-modellen te bedienen. Vanwege lage verkeer voor sommige modellen, dient slechts één SGLang-werker elk model. Na een maand werd een RadixAttention-cache-treffersnelheid van 52,4% voor LLaVA-Next-34B en 74,1% voor Vicuna-33B waargenomen. Cache-treffers kwamen van algemene systeemboodschappen, vaak hergebruikte voorbeeldbeelden en multi-turn chatgeschiedenissen. Dit vermindert de latentie van het eerste token met gemiddeld 1,7 keer voor Vicuna-33B.

Slotbeschouwingen

In dit artikel hebben we het over SGLang gehad, een nieuw geïntroduceerd systeem dat als doel heeft efficiënte uitvoering van complexe taalmodelprogramma’s te bieden. SGLang bestaat uit een frontend-taal en een runtime. De frontend vereenvoudigt het programmeren met primitieven voor generatie en parallelle controle, terwijl de runtime de uitvoering versnelt door middel van nieuwe optimalisaties zoals RadixAttention voor KV-cache-hergebruik en compressie van eindige statemachines voor snellere gestructureerde uitvoerdecoding. Experimenten laten zien dat SGLang tot 6,4 keer hogere doorvoer bereikt in vergelijking met state-of-the-art-inferentiesystemen op diverse grote taal- en multimodale modellen, waarmee taken zoals agentcontrole, logisch redeneren, few-shot learning-benchmarks, JSON-decoding, retrieval-augmented generatiepijplijnen en multi-turn chat worden aangepakt.