Versterkend Leermilieu

Inleiding

Een actief gebied van voortdurende interesse voor AI-onderzoekers en ingenieurs is het integreren van LLM's in end-to-end autonome systemen die bestaan uit multi-agent architecturen. Hoewel LLM's op zichzelf al indrukwekkend zijn, zien we dat de industrie, om er echt waarde uit te halen, steeds vaker gebruikmaakt van Reinforcement Learning (RL) omgevingen.

RL-omgevingen zijn niet nieuw; ze bestaan al langer dan LLM's. Sterker nog, je kunt eigenlijk niet over agenten praten zonder over omgevingen te praten. Over het algemeen biedt een omgeving in een RL-context een beloning of straf voor een actie die een agent in die omgeving uitvoert. De agent wordt gedwongen zich aan te passen om de cumulatieve beloning te maximaliseren. Deze aanpassing om de beloning te maximaliseren is de kern van reinforcement learning.

Nu, met de opkomst van LLM's, is de agent vaak eigenlijk een model. De gewichten van het model worden bijgewerkt op basis van de beoordeling van zijn pogingen bij verschillende taken, waardoor het model zich kan aanpassen. Computergebruik, zoals in een AI-systeem dat je computer kan navigeren, is een bijzonder interessante taak met meerdere agenten. We hebben dit onderwerp eigenlijk onderzocht in een vorig artikel over het werk van Microsoft met het opschalen van computergebruiksgegevens met multi-agent-pijplijnen voor hun model, Fara-7B.

Belangrijkste punten

De industrie wendt zich tot Reinforcement Learning (RL)-omgevingen om echte waarde te halen uit Large Language Models (LLM's).
Een RL-omgeving geeft een beloning of straf voor de actie van een agent, waardoor de agent (vaak een LLM/model) zijn gewichten moet aanpassen om de cumulatieve beloning te maximaliseren.
In tegenstelling tot subjectieve beloningen in RLHF, maakt RLVR gebruik van objectieve en verifieerbare beloningen (bijvoorbeeld bij wiskunde- en codeertaken) die 'niet te manipuleren' zijn, waardoor het model het gewenste redeneringsvermogen ontwikkelt.
Bedrijven gebruiken RL-omgevingen, vaak 'harnassen' of 'UI-gyms' genoemd, om modellen specifiek te trainen voor gebruik binnen hun eigen softwareproducten (bijv. Cursor’s Composer, OpenAI’s Codex).

Versterkend leren van verifieerbare beloningen

De recente toegenomen discussie en interesse in RL-omgevingen kan waarschijnlijk worden teruggevoerd op het succes van RLVR (Reinforcement Learning from Verifiable Rewards), waarbij taken verifieerbaar zijn, zoals met wiskunde en code. We waarderen de manier waarop Andrej Karpathy’s blogpost, 2025 LLM Year in Review, RLVR in de context van de vooruitgang van vorig jaar plaatst. Karpathy legt uit wat RLVR effectief maakt: beloningen die verifieerbaar zijn, kunnen niet worden gemanipuleerd. Een niet-manipuleerbare beloningsfunctie is er een die direct gekoppeld is aan het succesvolle, verifieerbare resultaat van een taak (zoals het oplossen van een puzzel of het doorstaan van een testcase), waardoor het voor het LLM moeilijk is om een hoge beloning te behalen zonder daadwerkelijk de gewenste redeneer- en probleemoplossingsstrategieën te ontwikkelen (beloningsmanipulatie).

RL-omgevingen voor producten

Will Brown legt uit dat modellen voor een specifiek product worden getraind door voorbeelden te geven van Cursor’s Composer en Open AI’s Codex, waarbij het model wordt getraind in een harnas, wat in feite een RL-omgeving is die het product vertegenwoordigt. In dezelfde geest beginnen bedrijven omgevingen rondom hun software te bouwen – die we horen worden aangeduid als UI-gyms.

Het creëren van een RL-omgeving

Er zijn talloze manieren om RL-omgevingen te creëren. Overweeg eerst je doel. Wat wil je dat je model bereikt? Vervolgens wil je een framework kiezen. Afhankelijk van het framework zal de omgeving op verschillende manieren worden gedefinieerd.

Potentiële frameworks zijn onder andere Prime Intellect’s environments hub, SkyRL (dat herbruikbare tools heeft), PyTorch’s OpenEnv en OpenAI’s Gymnasium. Thinking Machines heeft ook documentatie en een kookboek over RL-omgevingen.

Ongeacht het framework, moet je meestal nadenken over en de belangrijkste componenten van je RL-omgeving specificeren:

Toestandruimte: De informatie die de agent waarneemt. Dit kunnen pixels van een game-scherm zijn, numerieke sensorgegevens, schermopnames of representaties van de wereld.
Actieruimte: Alle mogelijke acties die de agent kan ondernemen. Acties kunnen discreet zijn (zoals het indrukken van knoppen) of continu (zoals motorbesturing).
Beloningsfunctie: De beloningsfunctie bepaalt welke gedragingen naar voren komen. Zeldzame beloningen (alleen bij voltooiing van de taak) kunnen moeilijk zijn om van te leren, terwijl frequente beloningen (regelmatige feedback) ongewenst gedrag kunnen belonen.
Voorwaarden voor beëindiging van een episode: Hier bepalen we wanneer de “proef” eindigt. Dit kan zijn na het behalen van een doel, het overschrijden van een tijdslimiet of het bereiken van een faaltoestand.

Na het definiëren van deze componenten, ga je de dynamiek van de omgeving implementeren zoals in de regels die bepalen hoe toestanden veranderen op basis van acties.

Stap 0: Denk na over wat we nodig zullen hebben

Begin met het opzetten van een GPU Droplet. Let goed op hoeveel GPU's je nodig zult hebben. Wij gaan 4 H100's gebruiken. Je hebt ook een Weights and Biases-account nodig.

Stap 1: Clone de repository en stel de omgeving in

git clone https://github.com/NovaSky-AI/SkyRL.git
cd SkyRL
uv venv .venv
source .venv/bin/activate
uv pip install -e ".[vllm]"   ##or ".[sglang]" for alternative inference backends

uv pip install -r requirements.txt

# may need to:
snap install astral-uv

Stap 2: Bereid een dataset voor voor RL-training

SkyRL verwacht gegevens in Parquet-formaat met een schema dat geschikt is voor instructies en RL (prompt, voltooiingen, beloningen, enz.).
Je kunt een van de ingebouwde voorbeelden gebruiken, zoals GSM8K voor wiskundig redeneren (een goede start voordat je aan taken in de stijl van SWE-Bench begint), of je eigen voorbeeld voorbereiden voor een aangepaste omgeving.

We gaan GSM8K-gegevens genereren (redeneren + tool-gebruik stijl) met gsm8k_dataset.py.

cd skyrl-train
uv run examples/gsm8k/gsm8k_dataset.py --output_dir ~/data/gsm8k

Dit maakt dus train.parquet en validation.parquet aan met velden zoals:

```
prompt
```
voltooiing (of trajecten)
beloning (voor offline/hybride opstellingen; online RL berekent beloningen live)

Voor meer zelfstandige taken zouden we misschien SWE-Bench of een vergelijkbare benchmark kunnen gebruiken om naar verifieerbare taken te kijken. SkyRL integreert eigenlijk de OpenHands-runtime (SkyRL-OpenHands) voor codebewerkingsomgevingen.

Stap 3: Maak een YAML-configuratie om een trainingsrun te configureren

Laten we een YAML-bestand maken om een GRPO-trainingssessie te configureren: examples/gsm8k/gsm8k-grpo.yaml

data:
  train_data: ["~/data/gsm8k/train.parquet"]
  val_data: ["~/data/gsm8k/validation.parquet"]

trainer:
  algorithm:
    name: grpo
    advantage_estimator: grpo
  policy:
    model:
      path: Qwen/Qwen2.5-1.5B-Instruct   # Start small; scale to 7B–32B
  epochs: 2                             # Increase for real training
  strategy: fsdp2                       # Or ddp for single node
  placement:
    colocate_all: true
    policy_num_gpus_per_node: 4         # Adjust to your hardware

inference:
  backend: vllm                         # Fast inference for rollouts

logger: wandb

Stap 4: TRAINEN

Voor een enkele knooppunt:

uv run -m skyrl_train.entrypoints.main_base \
  --config examples/gsm8k/gsm8k-grpo.yaml \
  trainer.epochs=5 \
  data.train_data='["~/data/gsm8k/train.parquet"]'

Voor gedistribueerde (multi-GPU/knooppunt via Ray/SkyPilot):

sky launch skyrl_train/examples/gsm8k/gsm8k-grpo-skypilot.yaml \
  --secret WANDB_API_KEY=your_key_here

Stap 5: Evalueren en itereren

from skyrl.agent import SkyRLAgent

agent = SkyRLAgent.from_checkpoint("path/to/checkpoint")
result = agent.run_task(
    prompt="Fix this bug in repo X: ...",
    runtime="openhands",   # Stateful code env
    max_turns=30
)
print(result.success_rate, result.trajectory)

Veelgestelde vragen

Wat zijn RL-omgevingen?
In de context van Reinforcement Learning (RL) biedt een omgeving een beloning of straf voor een actie die een agent (vaak een LLM/model) uitvoert. De agent past zijn gedrag aan om de cumulatieve beloning te maximaliseren.

Waarom schakelt de industrie over naar RL-omgevingen voor LLM's?
De industrie maakt gebruik van RL-omgevingen om LLM's te integreren in end-to-end autonome systemen met multi-agentenarchitecturen, wat wordt gezien als de manier om echte waarde uit deze modellen te halen.

Wat is Reinforcement Learning from Verifiable Rewards (RLVR)?
RLVR is een methode die objectieve en verifieerbare beloningen gebruikt (zoals bij wiskunde- en codeertaken). Deze “niet-manipuleerbare” beloningen zorgen ervoor dat het model de gewenste redeneer- en probleemoplossingsstrategieën ontwikkelt, in tegenstelling tot subjectieve beloningen die bij RLHF worden gebruikt.

Hoe worden RL-omgevingen gebruikt voor commerciële producten?
Bedrijven bouwen omgevingen, vaak aangeduid als “harnesses” of “UI-gym”, rondom hun eigen software om modellen specifiek te trainen voor gebruik binnen hun producten, zoals Cursor's Composer of OpenAI's Codex.

Hoe kunnen RL-omgevingen worden gebruikt voor het genereren van synthetische gegevens?
Omgevingen kennen van nature de grondwaarheid (bijv. dat unittests slagen, correcte spreadsheetuitvoer, nauwkeurige terminalgegevens), waardoor ze nuttig zijn voor het genereren van synthetische gegevens van hoge kwaliteit.

Slotgedachten

Als we vooruitkijken naar 2026, lijkt het erop dat we een betere integratie van AI-modellen in concrete toepassingen zullen zien, dankzij RL-omgevingen die het mogelijk maken modellen te trainen voor specifieke toepassingen. Linux-Console.net wil je ambities met AI mogelijk maken: train, infer en bouw agents met Gradient.

Referenties en aanvullende bronnen

SemiAnalysis: RL-omgevingen en RL voor de wetenschap: Data Foundries en multi-agent architecturen
Epoch AI: Een veelgestelde vragen over reinforcement learning-omgevingen
SkyRL: Een nieuwe omgeving of taak maken — SkyRL-documentatie
Thinking Machines: RL-omgevingen – Tinker API
GPU-modus: RL-omgevingen mini-conferentie

Prime Intellect:
Wat zijn RLVR-omgevingen voor LLM's? | Beleid - Uitrol - Rubrieken
RL-omgevingen op grote schaal – Will Brown, Prime Intellect
Onder de motorkap: Het bouwen van een RL-omgeving met Zapier & Prime Intellect
INTELLECT-3: Technisch rapport

En als je RL vanaf de basis wilt verkennen, hier is de Google Drive van Richard Sutton’s CMPUT 609-cursus.

Bedankt dat je samen met de Linux-Console.net-community hebt geleerd.