Cornserve: A Distributed Serving System for Any-to-Any Multimodal Models

Cornserve is een open-source, gedistribueerd serversysteem dat Any-to-Any multimodale modellen ondersteunt door flexibele taakabstractie en een efficiënte record-and-replay-uitvoeringsmodus te gebruiken, wat resulteert in tot 3,81 keer hogere doorvoer en 5,79 keer lagere tail-latency.

De kern

Stel je voor dat je een superkrachtige robot hebt die niet alleen tekst kan lezen en schrijven, maar ook foto's kan bekijken, video's kan analyseren, geluid kan horen én zelf muziek of video's kan maken. Dit soort robots noemen we "Any-to-Any" modellen. Ze zijn ongelooflijk slim, maar ze zijn ook heel lastig om te laten werken in de praktijk.

Waarom? Omdat elke vraag die je aan de robot stelt, een heel ander pad door zijn brein neemt.

• Vraag je alleen een tekst? Dan gebruikt hij alleen zijn taalcentrum.
• Vraag je een foto te maken? Dan moet hij eerst een tekenaar activeren.
• Vraag je een video met geluid? Dan moet hij een regisseur, een cameraman én een geluidstechnicus tegelijk aan het werk zetten.

Het probleem met de huidige systemen is dat ze de robot als één groot, stijf blok behandelen. Of je nu een simpele tekst vraagt of een complexe video, het hele blok moet aan het werk, wat veel energie kost en langzaam is.

Cornserve is de oplossing die de onderzoekers van de Universiteit van Michigan hebben bedacht. Ze noemen het een "distribueerd serversysteem", maar laten we het zo zien:

1. De Grote Keuken (Het Concept)

Stel je een restaurant voor.

• De oude manier (Monolithisch): Er is één enkele chef-kok die alles doet. Hij moet de soep koken, het vlees braden, de salade snijden én het dessert bakken. Als er een bestelling binnenkomt voor alleen een salade, moet de chef toch zijn hele keukenactiviteit starten. Het is inefficiënt en traag.
• De Cornserve-methode: Ze breken de keuken op in gespecialiseerde stations. Er is een saladebar, een grillstation, een bakkerij en een drankenstation.
  • Als je een salade bestelt, gaat die direct naar de saladebar.
  • Als je een steak met aardappelen wilt, gaat het vlees naar de grill en de aardappels naar de bakkerij, en worden ze pas aan het einde samengevoegd.
  • Als je een complex gerecht wilt, werken alle stations tegelijk, maar elk station doet alleen wat het nodig heeft.

2. Hoe werkt Cornserve precies?

A. De "Fissie" (Het Opbreken van de Robot)
Cornserve neemt het enorme model en splitst het op in losse onderdelen (zoals de chef-koks in de keuken).

• De Encoder (die beelden of geluid begrijpt) zit op zijn eigen computer.
• De LLM (het brein dat denkt) zit op een andere.
• De Generator (die nieuwe beelden of geluid maakt) zit weer ergens anders.
  Elk onderdeel kan onafhankelijk groeien. Als er veel mensen zijn die audio willen maken, kun je gewoon meer "geluidschefs" toevoegen zonder dat je nieuwe "beeldschefs" nodig hebt.

B. De "Opname en Afspeel" Truc (Record-and-Replay)
Dit is het slimste stukje. Omdat de robot soms gekke dingen doet (bijv. "als de foto donker is, maak hem lichter, anders niet"), is het moeilijk om van tevoren te weten welke stations er nodig zijn.
Cornserve doet het zo:

1. Opname: De robot doet alsof hij de taak uitvoert, maar in "snelheid 1000x". Hij schrijft op: "Oké, eerst station A, dan station B, en als het resultaat X is, dan station C". Hij doet dit zonder echt te rekenen, dus het is supersnel.
2. Afspeel: Zodra het pad bekend is, stuurt het systeem de echte opdracht naar de juiste stations. De stations werken dan echt, maar ze weten precies wat ze moeten doen en hoe ze met elkaar moeten praten.

C. De Koeriers (Sidecars)
Omdat de onderdelen op verschillende computers staan, moeten ze gegevens uitwisselen (bijvoorbeeld: het resultaat van de beeldherkenning moet naar het brein).
Cornserve gebruikt speciale koeriers (Sidecars) die de data direct van de ene computer naar de andere slepen, zonder dat het de "chef-kok" (de besturing) hoeft te storen. Ze gebruiken snelle wegen (zoals RDMA en gedeeld geheugen) zodat de data in milliseconden over is.

3. Wat levert dit op?

De resultaten zijn indrukwekkend:

• Snelheid: Het systeem is tot 3,8 keer sneller dan de oude methoden.
• Reageren: De tijd die wachtende klanten moeten wachten (de "staartlatency") is tot 5,8 keer korter.
• Flexibiliteit: Het kan elk type "Any-to-Any" model aan, van tekst-naar-beeld tot video-naar-geluid.

Samenvattend

Cornserve is als het bouwen van een modulair, slim restaurant in plaats van een statische fabriek. Het laat de verschillende onderdelen van een AI-robot los van elkaar werken, zodat ze precies doen wat er gevraagd wordt, op het moment dat het nodig is. Hierdoor wordt de robot niet alleen sneller, maar ook veel efficiënter in het gebruik van zijn energie (GPU's).

Het is een open-systeem, wat betekent dat iedereen het kan gebruiken om de volgende generatie slimme, multimodale AI's te bouwen.

Technische samenvatting

Hier is een gedetailleerde technische samenvatting van het paper "Cornserve: A Distributed Serving System for Any-to-Any Multimodal Models" in het Nederlands.

Probleemstelling

De opkomst van Any-to-Any multimodale modellen (modellen die willekeurige combinaties van invoer- en uitvoermodi zoals tekst, afbeeldingen, video en audio kunnen verwerken) stelt nieuwe uitdagingen aan bestaande inferentiesystemen. Deze modellen worden weergegeven als een computationele graaf van heterogene componenten (bijv. encoders, Large Language Models (LLMs), en generators).

De belangrijkste uitdagingen zijn:

1. Heterogeniteit van verzoekpaden: Afhankelijk van de specifieke combinatie van invoer en uitvoer (bijv. tekst-naar-afbeelding versus tekst-naar-audio), doorlopen verzoeken verschillende paden door de modelgraaf en roepen ze verschillende componenten aan.
2. Heterogeniteit van schaalbaarheid: Verschillende componenten hebben verschillende schaalingskarakteristieken en resource-eisen. Bijvoorbeeld, een tekstgeneratie-component kan op dezelfde GPU 4x meer doorvoer halen dan een audiogenerator.
3. Beperkingen van bestaande systemen: Bestaande oplossingen zoals vLLM (gericht op tekst) of xDiT (gericht op diffusie-modellen voor afbeeldingen/video) zijn vaak "point solutions" die specifieke architecturen ondersteunen, maar geen generieke oplossing bieden voor complexe Any-to-Any modellen met willekeurige computationele grafen.

Methodologie: Cornserve

Cornserve is een gedistribueerd serversysteem dat is ontworpen om generieke Any-to-Any modellen efficiënt te bedienen. Het systeem is gebouwd op Kubernetes en bestaat uit ongeveer 23.000 regels Python-code. De kernarchitectuur omvat een Control Plane en een Data Plane.

1. Flexibele Taak-Abstractie

Cornserve introduceert een drie-laags abstractiemodel om complexe computationele grafen in simpele Python uit te drukken:

• Unit Tasks: Atomische modelcomponenten (bijv. LLMTask, EncoderTask, GeneratorTask).
• Composite Tasks: Klassen die unit tasks combineren om de logica van een model te definiëren.
• Apps: Python-modules die instanties van taken definiëren en een serve-functie als entry point hebben.
  Dit stelt ontwikkelaars in staat om complexe logica (zoals loops en conditionele vertakkingen) te definiëren zonder de onderliggende distributie te hoeven beheren.

2. Model Fission (Opsplitsing)

In plaats van een model monolithisch op één set GPUs te draaien, splitst Cornserve modellen op bij componentgrenzen. Elke component kan onafhankelijk worden geschaald en draait op zijn eigen dedicated GPU's met gespecialiseerde executors:

• Eric: Voor multimodale encoders (afbeelding, video, audio).
• vLLM (fork): Voor LLM-inferentie.
• Geri: Voor multimodale generators (audio vocoders, image DiT).
  Het systeem ondersteunt ook component sharing: als meerdere apps dezelfde component gebruiken (bijv. een gedeelde visuele encoder), deelt Cornserve de deployement om GPU-gebruik te optimaliseren.

3. Gedistribueerde Runtime: Record-and-Replay

Om de heterogene verzoekpaden te hanteren, gebruikt Cornserve een Record-and-Replay-uitvoeringsmodel:

• Record-fase: Bij een inkomend verzoek wordt de invoke-methode van de composite task aangeroepen, maar in plaats van echte berekeningen te doen, worden de aanroepen en data-afhankelijkheden vastgelegd. Unit tasks geven placeholder-resultaten terug. Dit creëert een subgraaf van de exacte paden die voor dit specifieke verzoek nodig zijn.
• Dispatch: De vastgelegde graaf wordt naar de Task Dispatcher gestuurd, die de taken gelijktijdig naar de juiste executors routeert.
• Replay-fase: De invoke-methode wordt opnieuw aangeroepen, maar nu ontvangt elke unit task de echte resultaten van de dispatcher en wordt de definitieve respons gegenereerd.
  Dit maakt het mogelijk om complexe controleflows te ondersteunen zonder dat de ontwikkelaar de distributielogica hoeft te coderen.

4. Efficiënte Data Forwarding

Tussen de gesplitste componenten (die op verschillende GPUs of nodes kunnen staan) worden tensor-data direct doorgegeven via Sidecars (daemon-processen per GPU):

• Intra-node: Gebruik van Linux shared memory (/dev/shm) om interferentie met NVLink/NVSwitch-bandbreedte te minimaliseren.
• Inter-node: Gebruik van RDMA via de UCX-bibliotheek voor lage latentie.
  De data stroomt direct van producent naar consument, zonder tussenkomst van de control plane.

Belangrijkste Resultaten

Het systeem is geëvalueerd met modellen zoals Qwen 2.5 Omni en Qwen 3 Omni op clusters met NVIDIA A100-80GB GPU's.

• Doorvoer (Throughput):

  • Cornserve bereikte tot 3,81x hogere doorvoer vergeleken met een monolithische deployment voor Qwen 2.5 Omni op 16 GPU's.
  • Voor Qwen 3 Omni (30B parameters) faalde de monolithische deployment volledig door "Out-of-Memory" (OOM) fouten, terwijl Cornserve dit succesvol kon bedienen door het model te fissioneren.
  • Schalen van 8 naar 16 GPU's leverde een 2,68x verbetering op (meer dan lineair), dankzij betere balans tussen componenten.

• Latentie:

  • De tail-latentie (P99) werd met 5,79x verlaagd vergeleken met monolithische deployments.
  • Dit komt door het verwijderen van blokkering (in monolithische systemen draait slechts één component tegelijk) en het mogelijk maken van continuous batching voor audio-generators, wat in een monolithische setup technisch zeer moeilijk is.

• Overhead:

  • De overhead van de Sidecar-transfers (via RDMA of shared memory) is minimaal (bijv. 5-10 ms voor 8 MB data) en vormt geen bottleneck.

Betekenis en Conclusie

Cornserve vertegenwoordigt een doorbraak in het serveren van de volgende generatie multimodale AI-modellen.

1. Eerste generieke oplossing: Het is het eerste systeem dat Any-to-Any modellen met willekeurige computationele grafen ondersteunt, in plaats van zich te beperken tot specifieke architecturen.
2. Ontkoppeling van schaalbaarheid: Door modellen op te splitsen in onafhankelijk schaalbare componenten, kunnen systemen beter inspelen op de variabele eisen van verschillende verzoeken en componenten.
3. Ontwikkelaarservaring: Het abstractiemodel in Python maakt het voor onderzoekers en ingenieurs eenvoudig om complexe multimodale workflows te definiëren zonder diepgaande kennis van gedistribueerde systemen.

Het paper concludeert dat Cornserve een fundamentele basis legt voor de ontwikkeling van krachtigere en efficiëntere Any-to-Any modellen, en dat het systeem open-source beschikbaar is.