Technische Samenvatting: Reinforcement Learning voor Computer-Use Agents met Autonome Evaluatie

Probleemstelling

Computer-Use Agents (CUA's) zijn ontworpen om autonoom grafische gebruikersinterfaces (GUI's) te bedienen op basis van natuurlijke taalinstructies. Hoewel recente architecturen veelbelovend zijn gebleken in het generaliseren over applicaties en besturingssystemen, blijven ze onbetrouwbaar in ongecontroleerde, real-world omgevingen. State-of-the-art agents behalen slechts een succespercentage van ongeveer 60% op de OSWorld-benchmark en ongeveer 40% op macOSWorld.

Een primaire flessenhals die effectieve Reinforcement Learning (RL) fine-tuning voor CUA's verhindert, is het gebrek aan schaalbare, machine-leesbare beloningssignalen. In tegenstelling tot robotica-simulatoren of game-omgevingen waar succescriteria expliciet zijn, zijn doelstellingen voor desktoptaken vaak impliciet, visueel gegrond en ongestructureerd. Bestaande oplossingen vertrouwen op breekbare, taakspecifieke heuristieken (bijv. DOM-controles) of kostbare handmatige annotaties, die beide niet schalen over diverse applicaties en besturingssystemen. Bovendien, hoewel Vision-Language Models (VLM's) een potentieel bieden voor autonome evaluatie, zijn hun outputs imperfect en bevatten ze zowel vals-positieven als vals-negatieven. Het naïef gebruiken van deze ruisgevoelige outputs als beloningssignalen introduceert bias en destabiliseert de beleidsoptimalisatie.

Methodologie

De auteurs stellen een principieel kader voor om autonome VLM-gebaseerde evaluatoren te integreren in de RL-loop voor CUA's. De kerninnovatie is het behandelen van de evaluator niet als een bron van de grondwaarheid (ground truth), maar als een ruisgevoelig binair beloningskanaal, en het afleiden van een statistisch onderbouwde, ruis-gecorrigeerde reward-estimator.

1. Autonome Evaluatie Setup

• Evaluator: Een Vision-Language Model (Qwen2-VL-7B) wordt gebruikt in een zero-shot setting. Het ontvangt de uiteindelijke GUI-screenshot en de oorspronkelijke instructie in natuurlijke taal, en geeft een binair signaal $\tilde{r}_i \in \{0, 1\}$ aan dat taakvoltooiing aangeeft.
• Ruiskarakterisering: De imperfecties van de evaluator worden gemodelleerd via conditionele foutpercentages:
  • $e_+$: De False Negative rate ($P(\tilde{r}=0 | r^*=1)$).
  • $e_-$: De False Positive rate ($P(\tilde{r}=1 | r^*=0)$).
• Scheidbaarheid: Het framework gaat uit van een scheidbaarheidsconstante $D = 1 - e_+ - e_- > 0$, wat garandeert dat de evaluator informatieve feedback levert die verder gaat dan willekeurig gokken.

2. Ruis-gecorrigeerde Reward Estimator

Omdat de ware beloning $r^*$ niet geobserveerd kan worden, leiden de auteurs een estimator $\hat{r}$ af die asymptotisch onbevooroordeeld is.

• Theoretische Afleiding: Gebaseerd op de relatie $E[\tilde{r} | r^*] = e_- + D \cdot r^*$, wordt de ware beloning geschat als:
  $$\hat{r} = \frac{\tilde{r} - e_-}{D}$$
• Praktische Implementatie: In de praktijk zijn foutpercentages onbekend. De auteurs schatten $\hat{e}_+$ en $\hat{e}_-$ in via een heldergehouden kalibratiedataset (disjunct van de trainingsset). De plug-in estimator is:
  $$\hat{r}^\sharp = \frac{\tilde{r} - \hat{e}_-}{\hat{D}}$$
  waarbij $\hat{D} = 1 - \hat{e}_+ - \hat{e}_-$. Deze estimator corrigeert voor de bias die wordt geïntroduceerd door de vals-positieven en vals-negatieven van de evaluator.

3. Beleidsoptimalisatie

Het framework maakt gebruik van Proximal Policy Optimization (PPO).

• Beloningsstructuur: Beloningen zijn uitsluitend terminaal, gedefinieerd aan het einde van een episode ($T$).
• Doelstelling: De agent maximaliseert de verwachte return $J(\theta) = E[\gamma^T \hat{r}_i]$, waarbij $\hat{r}_i$ de ruis-gecorrigeerde beloning is.
• Advantage Estimatie: De gecorrigeerde terminale beloning wordt achterwaarts door de traject gepropageerd om advantage-schattingen te berekenen, wat stabiele beleidsupdates mogelijk maakt ondanks de ruis in het feedbacksignaal.

4. Experimentele Setup

• Datasets: Er is een synthetische dataset van 7.560 taken over 42 applicaties op macOS, Windows en Linux gemaakt. Daarnaast zijn taakbeschrijvingen van OmniAct, GUI-World en GUIDE geïntegreerd.
• Benchmarks: Evaluatie werd uitgevoerd op macOSWorld, Windows Agent Arena en OSWorld.
• Baselines: De studie vergelijkt zero-shot baselines met PPO fine-tuning met behulp van:
  1. Ruwe evaluator-beloningen ($\tilde{r}$).
  2. De gecorrigeerde reward-estimator ($\hat{r}$).
  3. Unified (cross-OS) versus per-OS model-parameterisatie.

Belangrijkste Resultaten

Experimenten tonen aan dat het expliciet modelleren en corrigeren van de ruis van de evaluator de prestaties van de agent aanzienlijk verbetert vergeleken met het gebruik van ruwe evaluator-signalen.

• Prestatiewinst: De ruis-gecorrigeerde reward-estimator in combinatie met per-OS fine-tuning behaalde de hoogste succespercentages over alle benchmarks:
  • macOSWorld: Verbeterd van 0,084 (zero-shot) naar 0,203.
  • Windows Agent Arena: Verbeterd van 0,331 naar 0,442.
  • OSWorld: Verbeterd van 0,283 naar 0,432.
• Vergelijking met Ruwe Beloningen: Het gebruik van ruwe evaluator-beloningen leverde matige verbeteringen op, maar werd consistent overtroffen door de gecorrigeerde estimator. In sommige gevallen (bijv. OSWorld met unified modellen) leidde het gebruik van ruwe beloningen tot prestatieverslechtering ten opzien van de zero-shot baseline, wat de bias benadrukt die wordt geïntroduceerd door ongecorrigeerde ruis.
• Generalisatie: Per-OS modellen die zijn gefinetuned met gecorrigeerde beloningen vertoonden superieure generalisatie vergeleken met unified cross-OS modellen, wat suggereert dat OS-specifieke interface-conventies cruciaal zijn voor robuust leren.
• Grootte van de Verbetering: De gecorrigeerde aanpak verbeterde de succespercentages met gemiddeld 12,6 procentpunt ten opzien van de zero-shot prestaties en met 5,1 procentpunt ten opzien van ruwe evaluator fine-tuning.

Betekenis en Claims

Het paper claimt dat autonome evaluatie kan dienen als een praktisch, schaalbaar beloningssignaal voor RL in GUI-omgevingen, mits de inherente ruis van de evaluator expliciet wordt gemodelleerd en gecorrigeerd.

• Schaalbaarheid: Het framework elimineert de noodzaak voor handmatige succeslabels of taakspecifieke heuristieken, wat RL fine-tuning mogelijk maakt op grootschalige interactiedata over diverse besturingssystemen.
• Robuustheid: Door een asymptotisch onbevooroordeelde reward-estimator af te leiden, stabiliseert de methode de beleidsoptimalisatie in de aanwezigheid van imperfecte feedback, wat een centrale flessenhals in de ontwikkeling van CUA's aanpakt.
• Praktische Bruikbaarheid: Het correctiemechanisme is een "drop-in replacement" voor ruwe beloningen in standaard policy-gradient methoden zoals PPO, en vereist geen fundamentele wijzigingen in het RL-algoritme zelf.

De auteurs concluderen dat hoewel er uitdagingen blijven bestaan met betrekking tot niet-stationaire foutpercentages en sparse rewards, deze aanpak een belangrijke stap vertegenwoordigt richting praktische RL-pipelines voor algemene desktop-agents die leren van interactie zonder menselijk toezicht.