Solaris: Building a Multiplayer Video World Model in Minecraft

Dit paper introduceert Solaris, een multi-agent video-wereldmodel voor Minecraft dat wordt getraind op een nieuw, geautomatiseerd multi-player datasetsysteem en dat door middel van een gestructureerde trainingspipeline consistente multi-view observaties en interacties mogelijk maakt.

De kern

🎮 Solaris: De "Twee-Ogen" Simulator voor Minecraft

Stel je voor dat je een video game speelt, maar in plaats van alleen te kijken door de ogen van jouw eigen personage, kun je tegelijkertijd zien wat er gebeurt vanuit de ogen van jijzelf én die van je vriend die naast je staat. En nog belangrijker: de computer kan deze situatie voorspellen.

Dat is precies wat Solaris doet. Het is een slimme computer (een AI) die leert hoe de wereld van Minecraft eruitziet als er meerdere mensen tegelijk spelen.

1. Het Probleem: De "Eenzame" AI

Tot nu toe waren slimme computers die videospellen kunnen simuleren, een beetje als een eenzame speler. Ze konden alleen voorspellen wat er gebeurde als jij een blokje zette of liep.

• De analogie: Stel je voor dat je een film kijkt, maar je ziet alleen wat de hoofdpersoon ziet. Als die hoofdpersoon omkijkt naar een vriend, zie jij die vriend niet, en weet je niet wat de vriend doet. De computer wist niet hoe de wereld eruitzag voor iemand anders.

In de echte wereld zijn we echter allemaal tegelijkertijd aanwezig. Als jij een muur bouwt, ziet je vriend dat ook. Solaris probeert dit "meerdere perspectieven" na te bootsen.

2. De Oplossing: Een Digitale Zool (SolarisEngine)

Om Solaris slim te maken, hadden ze eerst veel voorbeelden nodig. Maar er bestond geen manier om automatisch duizenden uren aan Minecraft-video's te maken waar twee bots (computerpersonages) samenwerken.

Dus bouwden ze SolarisEngine.

• De analogie: Stel je voor dat je een enorme fabriek hebt met honderden kleine robots. In plaats van dat elke robot chaotisch rondloopt, geef je ze een strak script. Robot A graaft goud, Robot B bouwt een huisje, en ze communiceren met elkaar.
• Het resultaat: Ze lieten deze robots urenlang spelen in de achtergrond. Ze verzamelden 12,6 miljoen beelden van twee bots die samenwerken, vechten, bouwen en rennen. Het is alsof ze een enorme bibliotheek hebben gevuld met films van twee vrienden die samen spelen.

3. De Leermethode: Van Solist naar Duo

Het trainen van deze AI was niet makkelijk. Je kunt niet zomaar een computer die alleen speelt, laten denken dat hij nu met iemand anders speelt. Ze gebruikten een stapsgewijze aanpak:

1. Stage 1 (De Solist): Eerst leerden ze de AI hoe het is om alleen te spelen. Dit is als een acteur die eerst zijn solostuk repeteert.
2. Stage 2 (Het Duo): Vervolgens leerden ze de AI hoe het is om met twee personen te spelen. Ze keken naar de video's van de bots en leerden: "Als Robot A hier een blok zet, ziet Robot B dat hier gebeuren."
3. Stage 3 & 4 (De Geduldige Meester): Om te voorkomen dat de AI na een paar seconden de draad verliest (en de wereld begint te vervormen), gebruikten ze een truc genaamd "Checkpointed Self Forcing".
   • De analogie: Stel je voor dat je een lang verhaal schrijft. Als je alleen kijkt naar de laatste zin die je schreef, vergeet je misschien wat er eerder gebeurde. Solaris heeft een "leraar" die het hele verhaal uit het hoofd kent. De AI (de leerling) schrijft een stukje, en de leraar kijkt mee.
   • De slimme truc: Normaal gesproken zou dit de computer te veel geheugen kosten (alsof je te veel boeken tegelijk op je bureau hebt liggen). Solaris gebruikt een slimme methode om alleen de belangrijkste stukken te onthouden en de rest tijdelijk weg te leggen, zodat het toch heel lang kan doorgaan zonder vast te lopen.

4. Wat Kan Solaris Nu?

De resultaten zijn indrukwekkend. Solaris kan:

• Consistentie: Als Robot A een muur bouwt, ziet Robot B die muur ook verschijnen, precies op de juiste plek.
• Geheugen: Als Robot A wegloopt en om de hoek gaat, onthoudt Solaris dat Robot A daar nog steeds is, zelfs als Robot B hem even niet ziet.
• Actie: Het kan vechten, bouwen en rennen voorspellen, inclusief kleine details zoals het openen van een kist of het regenen dat tegelijkertijd begint voor beide spelers.

5. Waarom Is Dit Belangrijk?

Vroeger waren deze modellen beperkt tot één persoon. Solaris toont aan dat we AI kunnen leren om de wereld te begrijpen zoals wij dat doen: samen.

• De toekomst: Dit is de basis voor slimme robots die samenwerken, of voor games waarin de computer echt meespeelt met je vrienden in plaats van alleen maar een achtergrondscène te zijn.

Kortom: Solaris is de eerste AI die echt begrijpt wat het betekent om "samen" in een virtuele wereld te zijn, door te leren van miljoenen uren aan geautomatiseerd samenspel. Het is alsof we de computer eindelijk hebben geleerd om niet alleen te kijken, maar ook te zien wat de ander ziet.

Technische samenvatting

Probleemstelling

Bestaande actie-geconditioneerde videowereldmodellen (video world models) zijn beperkt tot het simuleren van perspectieven van een enkel agent. Ze falen in het vastleggen van de complexe interacties tussen meerdere agenten die kenmerkend zijn voor echte wereldomgevingen. In een fundamenteel multi-agent wereld zijn modellen nodig die de perspectieven van alle agenten in een omgeving gelijktijdig kunnen simuleren om een accurate weergave van de wereldtoestand te krijgen.

Het simuleren van meerdere spelers tegelijk is aanzienlijk uitdagender dan single-player modellering:

1. Consistentie: gegenereerde waarnemingen moeten consistent zijn in de tijd én over verschillende agent-perspectieven heen.
2. Interactie: Acties van de ene speler (bijv. verplaatsing of het plaatsen van blokken) moeten direct en nauwkeurig worden weerspiegeld in het gezichtsveld van alle andere spelers.
3. Complexiteit: Omgevingen zoals Minecraft vereisen omgang met occlusie, ruimtelijk geheugen, dynamische veranderingen en stochastische omgevingsfactoren (zoals weer of mobs).

Er bestond tot dit werk geen publiek beschikbaar systeem om multiplayer Minecraft-gameplay te simuleren, wat de ontwikkeling van dergelijke modellen belemmerde.

Methodologie

De auteurs introduceren Solaris, een multiplayer videowereldmodel, ondersteund door een nieuw data-ecosysteem en een geavanceerde trainingspipeline.

1. SolarisEngine: Data-Collectie Systeem

Om het gebrek aan data op te lossen, hebben de auteurs SolarisEngine ontwikkeld, een framework voor het verzamelen van multiplayer gameplay op schaal.

• Architectuur: Het systeem gebruikt Docker-containers om een game-server, camera-bots en controller-bots te orkestreren.
• Coördinatie: In tegenstelling tot eerdere frameworks (zoals Malmo of MineRL) die vaak RL-agenten vereisen of geen visuele output hebben, gebruikt SolarisEngine Mineflayer (een JavaScript-bibliotheek) voor hoog-niveau besturing. Ze voegden een communicatielaag toe om bots te laten samenwerken (bijv. bouwen, vechten, mijnen).
• Visuele Alignering: Elke controller-bot wordt gekoppeld aan een "camera-bot" die de officiële Minecraft-client draait in headless modus met GPU-versnelde rendering. Een server-side plugin synchroniseert de camera-bot met de acties van de controller-bot in real-time.
• Dataset: Ze hebben een dataset verzameld van 12,64 miljoen frames (6,32 miljoen per speler) uit 9.240 episodes, gedekt over vier categorieën: bouwen, gevechten, verplaatsing en mijnen.

2. Solaris Model Architectuur

Het model is gebaseerd op een Diffusion Transformer (DiT) (specifiek Matrix Game 2.0), aangepast voor multi-agent scenario's.

• Multiplayer Attention: In plaats van frames simpelweg te concateneren, worden tokens van verschillende spelers verwerkt via gedeelde Self-Attention lagen. Er worden leerbare "Player ID embeddings" toegevoegd aan de tokens om de identiteit van de speler te coderen.
• Actie-ruimte: De actie-ruimte is uitgebreid om de volledige MineRL-actie-ruimte van Minecraft te ondersteunen (WASD, muisklikken, itemwisseling, etc.).
• Input: Het model neemt een reeks van waarnemingen en acties van alle spelers als input en genereert toekomstige waarnemingen autoregressief.

3. Trainingspipeline (Staged Approach)

Het trainingsproces verloopt in vier fasen om stabiliteit en prestaties te maximaliseren:

1. Fase 1 (Bidirectioneel Single-Player): Finetunen van het vooraf getrainde DiT-model op single-player data (VPT dataset) om een goede initialisatie te krijgen.
2. Fase 2 (Bidirectioneel Multiplayer): Trainen op de multiplayer dataset met een gedeelde noise-level over alle spelers en frames.
3. Fase 3 (Causaal Multiplayer): Overgang naar een causaal model (Diffusion Forcing) met een schuifend raam (sliding window) voor autoregressieve generatie. Dit dient als initialisatie voor de student in de volgende fase.
4. Fase 4 (Self Forcing): Toepassing van Self Forcing om lange-horizon generaties te verbeteren. Hierbij wordt een "teacher" (het causale model) gebruikt om de "student" te trainen op zijn eigen gegenereerde output.

4. Innovatie: Checkpointed Self Forcing

Een cruciale technische bijdrage is de oplossing voor het geheugenvraagstuk bij Self Forcing met lange context.

• Probleem: Naïeve toepassing van Self Forcing met een schuivend venster vereist dat alle tussenliggende frames in het geheugen worden bewaard voor backpropagation, wat leidt tot $O(L_t \cdot L_s)$ geheugenverbruik (waarbij $L$ de lengte is).
• Oplossing: Checkpointed Self Forcing. Dit is een geheugenefficiënte variant die analog is aan gradient checkpointing.
  • De autoregressieve rollout wordt uitgevoerd zonder gradients (alleen forward pass), waarbij tussenliggende ruisframes worden gecached.
  • Vervolgens wordt de backpropagation uitgevoerd in één parallelle forward pass door de gegenereerde frames opnieuw te berekenen (recomputation).
  • Dit verlaagt het geheugenverbruik naar $O(L_t)$ en maakt het mogelijk om gradients door de KV-cache (Key-Value cache) te laten stromen, wat de visuele kwaliteit verbetert.

Kernbijdragen

1. SolarisEngine: Een schaalbaar, robuust framework voor het verzamelen van gecoördineerde multiplayer Minecraft-data met visuele output.
2. Eerste Multiplayer Dataset: De eerste openbare, actie-geannoteerde multiplayer Minecraft-dataset (12,64M frames) geschikt voor machine learning.
3. Solaris Model: Een nieuw architectuurontwerp dat een single-player DiT succesvol aanpast voor consistente multi-perspectief simulatie.
4. Checkpointed Self Forcing: Een nieuwe, geheugenefficiënte methode voor het trainen van autoregressieve wereldmodellen met lange horizon, die backpropagation door de cache mogelijk maakt.
5. Evaluatie Benchmark: Een nieuw evaluatiekader dat modellen test op beweging, verankering (grounding), geheugen, bouwen en visuele consistentie tussen spelers.

Resultaten

De resultaten tonen aan dat Solaris aanzienlijk beter presteert dan bestaande baselines (zoals frame-concatenatie methoden en modellen zonder single-player pretraining).

• Kwalitatief: Het model kan complexe scenario's simuleren, waaronder het bouwen van structuren, PvP-gevechten, inventarisupdates, weerseffecten (regen) en consistente animaties. Het behoudt visuele trouw over lange tijdshorizonten (bijv. 224 frames), terwijl baselines vaak degradatie vertonen (artefacten, vervormde texturen).
• Kwantitatief:
  • FID (Fréchet Inception Distance): Solaris behaalt de laagste FID-scores (betere beeldkwaliteit) in alle categorieën, met name bij "Building" en "Consistency".
  • VLM Judge: Een Vision-Language Model wordt gebruikt als rechter om te beoordelen of de gegenereerde video's semantisch correct zijn (bijv. "Ziet speler A speler B nog?"). Solaris scoort significant hoger op taken zoals Grounding (62.5% vs 29.2% voor geen pretraining) en Consistency (71.4% vs 49.5% voor frame-concatenatie).
• Ablatie-studies: Het gebruik van "Checkpointed Self Forcing" met backpropagation door de KV-cache bleek essentieel voor de visuele kwaliteit, hoewel het soms een lichte daling in actie-volging veroorzaakte, wat overall werd gecompenseerd door de superieure consistentie.

Significantie en Toekomstperspectief

Solaris legt de basis voor een nieuwe generatie van multi-agent wereldmodellen.

• Onderzoek: Het opent de deur voor het trainen van agenten in gedeelde omgevingen, het ontwikkelen van Vision-Language-Action modellen, en het bestuderen van samenwerking tussen AI-agenten.
• Beperkingen: Het huidige model heeft geen persistent geheugen; zodra spelers elkaars gezichtsveld verlaten, kan de wereldtoestand divergeren omdat er geen onderliggende staat is die de wereld vasthoudt. Ook is de data volledig synthetisch, wat generalisatie naar echte menselijke data kan beperken.
• Impact: Door het openbaar maken van de code, het dataset en het model, faciliteren de auteurs verdere innovatie in het veld van embodied AI en wereldmodellering.

Kortom, Solaris bewijst dat het mogelijk is om coherente, multi-perspectief wereldsimulaties te bouwen, wat een grote stap voorwaarts is ten opzichte van de huidige single-agent beperkingen.