💻 computer science

RIO: Flexible Real-Time Robot I/O for Cross-Embodiment Robot Learning

Dit artikel introduceert RIO, een open-source Python-framework dat is ontworpen om gefragmenteerde robotinfrastructuur te overwinnen door flexibele, lichtgewicht componenten te bieden voor besturing en gegevensverwerking op diverse hardwareplatforms, waardoor efficiënte training en implementatie van state-of-the-art Vision-Language-Action-modellen over verschillende robotlichamen mogelijk wordt gemaakt.

Oorspronkelijke auteurs: Pablo Ortega-Kral, Eliot Xing, Arthur Bucker, Vernon Luk, Junseo Kim, Owen Kwon, Angchen Xie, Nikhil Sobanbabu, Yifu Yuan, Megan Lee, Deepam Ameria, Bhaswanth Ayapilla, Jaycie Bussell, Guanya Shi, Jon

Gepubliceerd 2026-05-13

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Pablo Ortega-Kral, Eliot Xing, Arthur Bucker, Vernon Luk, Junseo Kim, Owen Kwon, Angchen Xie, Nikhil Sobanbabu, Yifu Yuan, Megan Lee, Deepam Ameria, Bhaswanth Ayapilla, Jaycie Bussell, Guanya Shi, Jonathan Francis, Jean Oh

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je probeert een robot huiswerk te leren, zoals een overhemd vouwen of een kom schrobben. In de wereld van de robotica is dit momenteel vergelijkbaar met het proberen een kind elke verschillende taal ter wereld te leren spreken, maar dan met een addertje onder het gras: elke keer als je overschakelt naar een andere robot (een ander "lichaam" of "embodiment"), moet je volledig opnieuw leren hoe je met die robot communiceert.

Als je een robotarm van het ene bedrijf hebt en een camera van een ander, is de code die ze samen doet werken vaak een rommel van aangepaste instructies. Als je wilt overschakelen naar een andere robotarm, kun je het onderdeel niet zomaar verwisselen; vaak moet je het volledige "brein" van de robot vanaf nul herschrijven. Dit maakt het delen van vooruitgang tussen wetenschappers ongelooflijk moeilijk en traag.

Presentatie van RIO (Robot I/O).

Stel je RIO voor als een universele vertaler en een modulaire "plug-and-play"-systeem voor robots. Het is een lichtgewicht softwaretoolkit die onderzoekers in staat stelt verschillende robotonderdelen te mixen en matchen zonder elke keer de code te herschrijven.

Zo werkt het, met behulp van enkele eenvoudige analogieën:

1. De "Lego"-benadering (Flexibiliteit)

Stel je een doos met Lego-blokjes voor. Sommige zijn robotarmen, sommige zijn grijpers (handen), sommige zijn camera's en sommige zijn teleoperatiecontrollers (de dingen die mensen gebruiken om de robot te bewegen).

Zonder RIO: Je moet de blokjes met supersterke, permanente lijm aan elkaar plakken. Als je de arm wilt veranderen, moet je het hele ding uit elkaar breken en opnieuw beginnen.
Met RIO: De blokjes hebben standaardconnectoren. Je kunt een "Franka-arm" op een "Robotiq-grijper" klikken of een "VR-headset" op een "humanoid robot", gewoon door een configuratiebestand te wijzigen. De kernlogica (het "brein" dat de robot vertelt wat het moet doen) blijft exact hetzelfde; alleen het "lichaam" verandert.

2. De "Universele Stroomstrip" (Middleware)

Robots moeten met elkaar praten met bliksemsnelheid. Meestal spreken verschillende onderdelen verschillende "talen" (protocollen).

De oplossing van RIO: Het fungeert als een slimme stroomstrip of een universele adapter. Het zit tussen de hardware van de robot en de software. Of je nu een snel gedeeld geheugen gebruikt (zoals twee mensen die direct in dezelfde kamer fluisteren) of een netwerkverbinding (zoals praten via internet), RIO regelt de vertaling automatisch. Dit betekent dat je de communicatiemethode kunt wisselen zonder de code van de robot te veranderen.

3. De "Teleoperatie"-afstandsbediening

Om een robot te leren, laten mensen het vaak "teleopereren" – wat betekent dat ze een controller dragen en de robot met hun eigen handen bewegen.

RIO ondersteunt een enorme verscheidenheid aan deze controllers: van eenvoudige toetsenborden en gamepads tot high-tech VR-headsets (zoals de Apple Vision Pro) en gespecialiseerde robotarmen die menselijke bewegingen nabootsen.
Het artikel toont aan dat je dezelfde software kunt gebruiken om een enkele robotarm, een robot met twee armen of zelfs een volwaardige humanoid robot die rondloopt te besturen, gewoon door de controller en het robotlichaam te verwisselen.

4. De "Slimme Bezorger" (Policy Inference)

Zodra de robot getraind is, moet het beslissingen nemen (zoals "pak het kopje op") en bewegen. Dit heet "inference".

RIO is ontworpen om snel te zijn. Het scheidt het "denken" (het draaien van het AI-model) van het "doen" (het verzenden van commando's naar de motoren).
Het artikel vergelijkt RIO met een ander populair systeem genaamd LeRobot. Ze ontdekten dat RIO veel sneller is in het krijgen van een commando van de camera naar de hand van de robot.
- LeRobot: Duurde ongeveer 581 milliseconden (een lange tijd in robotsnelheid).
- RIO: Duurde slechts 130 milliseconden.
- Analogie: Als LeRobot is als het sturen van een brief per post, dan is RIO als het sturen van een tekstbericht. Deze snelheid is cruciaal voor dynamische taken, zoals het omdraaien van een tortilla of het gooien van een bal, waarbij een vertraging van een fractie van een seconde tot mislukking leidt.

Wat hebben ze eigenlijk gedaan?

De auteurs hebben niet alleen het gereedschap gebouwd; ze hebben het in de echte wereld getest. Ze gebruikten RIO om:

Data te verzamelen door mensen robots te laten besturen om huishoudelijke taken uit te voeren (overhemden vouwen, kommen schrobben, dozen oppakken).
Geavanceerde AI-modellen (zoals π0.5 en GR00T) op deze data te trainen.
Deze getrainde modellen te implementeren op drie zeer verschillende soorten robots:
1. Enkelarmige robots (zoals een standaard fabrieksarm).
2. Tweearmige robots (robots met twee armen).
3. Humanoids (robots die eruitzien als mensen en lopen).

Ze slaagden erin deze robots kleding te laten vouwen, objecten op te pakken en zelfs te lopen, wat bewijst dat dezelfde softwarestapel volledig verschillende hardware kan aandrijven.

De conclusie

Het artikel stelt dat de grootste bottleneck in robotleren niet alleen het hebben van meer data of betere AI-modellen is; het is de infrastructuur. Wetenschappers verspillen momenteel te veel tijd aan het bouwen van aangepaste "bedrading" voor elke nieuwe robot.

RIO is een gratis, open-source tool die de "bedrading" eens en voor altijd biedt. Het stelt de robotica-gemeenschap in staat om te stoppen met het opnieuw uitvinden van het wiel en zich te gaan richten op het leren van robots om complexere, nuttigere dingen te doen, ongeacht hoe de robot eruitziet.

Technische Samenvatting: RIO – Flexibele Realtime Robot I/O voor Robotleren over Verschillende Embodiments

Probleemstelling

Ondanks recente vooruitgang in Vision-Language-Action (VLA)-modellen en de aggregatie van grootschalige, multi-embodiment datasets (bijv. Open X-Embodiment), wordt de implementatie van generalistische robotbeleid nog steeds gehinderd door gefragmenteerde infrastructuur. Huidige robotica-code is doorgaans sterk specifiek voor de exacte hardwareopstelling van de gebruiker, wat aanzienlijke overhead creëert bij het proberen om artefacten opnieuw te gebruiken, te delen of aan te passen aan verschillende platformen.

De kernproblematiek is het ontbreken van een flexibele, herbruikbare en performante full-stack robotinfrastructuur. Onderzoekers staan vaak voor de last om volledige besturingsstapels opnieuw te schrijven bij het wisselen tussen robotmorfologieën (bijv. van een enkele arm naar een humanoid) of hardwareconfiguraties (bijv. verschillende grijpers of camera's). Deze fragmentatie verhindert de cumulatieve vooruitgang die in andere gebieden van machine learning wordt gezien, waar hoogwaardige abstracties snelle iteratie op diverse hardware mogelijk maken. Bijgevolg vereist het reproduceren van resultaten vaak het één-op-één repliceren van hardwareopstellingen, of het ondernemen van aanzienlijke engineeringinspanning om geleerde beleidslijnen aan te passen aan nieuwe platformen.

Methodologie: Het RIO-kader

Om deze uitdagingen aan te pakken, presenteren de auteurs RIO (Robot I/O), een lichtgewicht, open-source Python-kader dat is ontworpen om flexibele, realtime I/O te bieden voor robotleren over verschillende embodiments. RIO is geen monolithische oplossing, maar een set herbruikbare bouwstenen waarmee gebruikers besturingsstapels kunnen samenstellen die zijn afgestemd op hun specifieke configuraties.

Ontwerpphilosophie

RIO is gebaseerd op vijf uitgangspunten:

Flexibel: Onafhankelijk van componenten; gebruikers kunnen op elke laag (robots, sensoren, teleoperatie, middleware, beleidslijnen) kiezen en wisselen tussen opties met minimale herconfiguratie.
Herbruikbaar: Samengesteld uit lichtgewicht bouwstenen die snel kunnen worden gecombineerd.
Toegankelijk: Snel te installeren, Python-gebaseerd en te bedienen via één configuratiebestand en CLI.
Performant: Capabel van hoogfrequente realtime besturing met asynchrone beleidsinferentie.
Consistent: Zorgt voor schaalbare en reproduceerbare datacollectie en learning.

Systeemarchitectuur

Het kader maakt gebruik van een Node-gebaseerde architectuur waarbij elke component (teleoperatie-interface, sensoren, robots, beleidslijnen) is geïmplementeerd als een Node die afstamt van een gemeenschappelijk sjabloon.

Nodes en Middleware: Nodes erven dynamisch af van een gespecificeerde Middleware (bijv. Gedeeld Geheugen, Zenoh, ZeroRpc, Threads, Portal) die het doorgeven van berichten afhandelt. Nodes ondersteunen drie uitvoeringspatronen: alleen publiceren, alleen aanvragen, of gecombineerd. Deze abstractie stelt dezelfde logica in staat om te draaien op verschillende transportlagen (bijv. lokaal gedeeld geheugen voor debugging versus op netwerk gebaseerd voor gedistribueerde robots).
Robotstations: De instantiatie van alle nodes voor een specifieke omgeving wordt samengevoegd in één configuratiebestand voor een "station" (een samenstelbaar dataclass). Dit definieert de hardwaretopologie (bijv. {arm, grijper, polscamera}). De hoofdcontrolelus communiceert uitsluitend via hoogwaardige API's, waardoor applicatielogica wordt ontkoppeld van hardware-specifieke details.
Teleoperatie en Datacollectie: RIO ondersteunt diverse teleoperatiemethoden, waaronder relatieve eind-effectorbesturing (Spacemouse, Gamepad), absolute joint-mapping (Leader-Follower/ALOHA) en VR-gebaseerde retargeting voor humanoids. Data wordt verzameld in een gestandaardiseerd RLDS-stijl formaat met consistente eenheden (meters/radiaan) en gecomprimeerd met RoboDM voor efficiënte opslag.
Beleidsinferentie: Een hoogwaardige API maakt het naadloze wisselen van beleidslijnen mogelijk (VLA's, Diffusion Policies, RL). Een beleidswrapper-node behandelt asynchrone inferentie, converteert gestandaardiseerde observaties naar beleids-specifieke formaten en gladde acties voordat commando's naar de hardware worden verzonden.

Belangrijkste Bijdragen

RIO-kader: Introductie van een flexibel, realtime Robot I/O-kader dat herbruikbare infrastructuur biedt voor datacollectie en beleidsimplementatie over diverse embodiments. Het maakt combinatorische configuratie van robots, sensoren, teleoperatie-apparaten en beleidslijnen mogelijk.
Validatie over Morphologieën: Demonstratie van de capaciteit van RIO om VLA-implementatie-workflows te ondersteunen over drie verschillende morfologieën (enkele arm, bimanueel, humanoid) en vier hardwareplatforms met variërende grijpers en camera's.
Implementatie in de Reële Wereld: Succesvolle fine-tuning en implementatie van state-of-the-art VLA's (specifiek $\pi0.5$ en GR00T) en andere beleidslijnen (Diffusion Policy, PPO) op huishoudelijke taken (pak-en-leg, vouwen, kom schrobben) en locomotie-taken. Dit omvat een cross-embodiment-beleid dat is getraind op gemengde data van twee verschillende robotmorfologieën.

Resultaten en Evaluatie

De auteurs hebben RIO geëvalueerd op een desktop uitgerust met een NVIDIA RTX 4090, met focus op prestaties, latentie en slagingspercentages over diverse taken.

Beleidsprestaties:
- Enkele Arm (xArm7): $\pi0.5$ behaalde >90% succes bij vouw- en pak-en-leg-taken. Diffusion Policy behaalde 66,7% succes bij dynamisch tortilla-flippen en 100% bij balwerpen.
- Bimanueel (SO-100): $\pi0.5$ behaalde $\ge$ 60% succes bij kleding vouwen en kom schrobben.
- Humanoid (Unitree G1, Booster T1): GR00T N1.5 behaalde 95% succes bij het oppakken van dozen. RL-PPO-beleidslijnen controleerden succesvol de locomotie op beide platformen.
Latentie en Prestaties:
- Middleware Latentie: Gedeeld Geheugen en Zenoh behaalde een round-trip latentie onder de milliseconde (~0,4–0,5 ms), terwijl Thread en ZeroRpc dichtbij bleven op ~1 ms.
- End-to-End Latentie: RIO behaalde een observatie-naar-actie latentie van 130,3 ms vergeleken met 581,2 ms voor LeRobot onder identieke omstandigheden. Deze efficiëntie wordt toegeschreven aan de gestroomlijnde architectuur van RIO en directe middleware-gebaseerde asynchrone inferentie, waarbij de overhead van dedicated beleidslijnen-servers wordt vermeden.
- Resourcegebruik: Asynchrone inferentie behield een hoog GPU-gebruik (tot ~80%) gedurende de uitvoering, wat efficiënte compute-saturatie aantoont.

Betekenis en Beweringen

Het artikel stelt dat het ontbreken van flexibele, herbruikbare infrastructuur een kritieke barrière is voor cumulatieve vooruitgang in robotica. Door een "bring-your-own-training-stack"-aanpak te bieden, verlaagt RIO de drempel voor practitioners om moderne robotlering-aanpakken te implementeren, te benchmarken en te itereren over diverse hardware.

De auteurs beweren dat RIO gebruikerslogica succesvol abstraheert, waardoor deze één keer kan worden geschreven en opnieuw kan worden gebruikt op elk robotstation. Het wisselen van hardware of beleidslijnen wordt een configuratiewijziging in plaats van een herschrijving van code. Hoewel het huidige werk zich richt op fine-tuning voor single-embodiment en erkent dat cross-embodiment generalisatie een open onderzoeksprobleem blijft, is het kader ontworpen om de collectie van hoogwaardige, gestandaardiseerde cross-embodiment data te faciliteren, wat een voorwaarde is voor toekomstige vooruitgang in generalistische robotbeleid. De auteurs maken het kader open-source om het tempo van robotleren op hardware uit de reële wereld te versnellen.