Handleidingen

Reinforcement learning

Oloproof evalueert een policy voor reinforcement learning door haar in episodes te draaien, of op basis van de log van de policy die ze zou vervangen. Draai haar wanneer dat kan; gebruik de log wanneer de uitkomst alleen in de echte wereld plaatsvindt. Deze pagina is de referentie voor beide, en de tutorial loopt elk ervan door aan de hand van een uitvoerbaar voorbeeld.

Oloproof host, reset of simuleert geen omgeving, en traint geen policies. Je systeem draait zijn eigen omgeving, zoals elk systeem dat Oloproof evalueert zijn eigen code draait.

Episodes

Een taak is een case. Een episode is één meting ervan: je systeem draait de policy in zijn omgeving en legt de episode vast met current_case().rl_episode(...), als een rl_episode/v1-artefact.

Veld	Type	Betekenis
steps	lijst van stappen, index vanaf 1	De reward van elke stap, de cost van zijn beperking (standaard 0), en optioneel action en observation
success	true, false of afwezig	Het eigen oordeel van de omgeving over de episode
truncated	boolean, standaard false	De stapgrens beëindigde de episode voordat een eindtoestand werd bereikt
horizon	geheel getal, optioneel	De stapgrens; de episode mag niet langer zijn

Het record bevat elke stap van de episode. Een afgekapte episode is er een waarvan het evaluatieprotocol bepaalt dat ze bij haar grens eindigt, dus haar return en kosten zijn volledig, geen ondergrenzen.

Declareer de soort die het systeem vastlegt, zodat een run een evaluator kan weigeren die een record nodig heeft dat het systeem nooit schrijft:

system:
  name: grid-agent
  callable: env:run_baseline
  records: [rl_episode/v1]

Episode-evaluators

Type	Meet	Velden
episode_return	De return, elke beloning per stap gewogen met discount, als score	return_range (verplicht), discount (standaard 1)
episode_success	Geslaagd wanneer de episode success: true vastlegt; ontbrekend wanneer ze niets vastlegt	geen
episode_cost_within	Geslaagd wanneer de kosten van de stappen samen hoogstens budget zijn	budget (verplicht)

return_range is het bereik waarin elke return ligt, zoals in het slechtste geval 30 stappen van elk -1 en in het beste geval de beloning voor het doel. Het interval op een gemiddelde return geldt alleen binnen dat bereik, dus een return erbuiten stopt de run met exitcode 2. In de SDK zijn de klassen EpisodeReturn, EpisodeSuccess en EpisodeCostWithin in oloproof.evaluators.

Meerdere episodes per taak

Stel replicates: in om meerdere episodes van elke taak te draaien. current_case().replicate zegt welke er draait (0 voor de eerste), en het maakt deel uit van de sleutel van de opgeslagen uitvoering, dus een omgeving die de episode ermee seedt, speelt voor hetzelfde replicaat dezelfde episode opnieuw af, en een tweede run hergebruikt wat hij opsloeg.

De taak blijft de eenheid. Elk criterium wordt het gemiddelde over taken van het eigen gemiddelde van elke taak over haar episodes, en het interval telt taken: vijf episodes van één taak zijn geen vijf onafhankelijke taken.

Een slagingspercentage over gerepliceerde taken leest per taak het aandeel geslaagde episodes. Wil je in plaats daarvan weten of een taak elke keer slaagt, declareer dan een every_replicate-metriek:

metrics:
  - {id: solved_every_time, type: every_replicate, criterion: episode_success}

Een taak telt alleen wanneer al haar episodes slaagden, dus elke taak is één geslaagd of mislukt, en het exacte binomiale interval is van toepassing. Met één episode per taak is het gelijk aan het slagingspercentage. Een taak met een ontbrekende episode is ontbrekend, ook wanneer een andere episode ervan mislukte.

Twee policies vergelijken

oloproof compare koppelt elke taak aan zichzelf, waarbij elke kant zijn gemiddelde over zijn episodes waard is. Het verschil in een return wordt getoond in de eigen eenheid van de return, dat in een slagingspercentage in procentpunten. De twee runs mogen verschillende aantallen episodes per taak draaien, behalve voor een every_replicate-metriek: slagen in elk van vijf episodes en in de enige episode zijn verschillende vragen, dus die vergelijking wordt niet berekend. Kwantiel- en rangschikkingsvergelijkingen worden niet berekend wanneer een van beide runs meerdere episodes per taak heeft.

Off-policy-evaluatie

Gebruik dit wanneer de uitkomst die je belangrijk vindt alleen in de echte wereld plaatsvindt (een opgelost ticket, een gebruiker die terugkwam) en je de nieuwe policy nog niet op echt verkeer kunt uitproberen. Het bewijs is een log van beslissingen die een oudere policy nam.

Elke case is één gelogde beslissing:

{"id":"t001","input":{"topic":"technical","length":"short"},"expected":{"action":"small","logging_probabilities":{"small":0.7,"large":0.3},"reward":1}}

Veld	Betekenis
input	Wat de policy zag toen ze besliste
expected.action	De actie die de loggingpolicy (logging policy) nam
expected.logging_probabilities	De kans die de loggingpolicy op dat moment aan elke actie gaf, samen 1
expected.reward	Wat volgde, binnen reward_range; afwezig als het nooit aankwam

Het systeem is de policy die je wilt evalueren. Het ontvangt input en geeft zijn eigen kans op elke actie terug onder probabilities, of onder het veld dat je noemt in probabilities_field. Het draait nooit een model en raakt de echte wereld nooit aan. input bevat alleen wat de loggingpolicy zag toen ze besliste: nooit de gelogde actie of de beloning, die de geteste policy niet mag zien. Een policy die haar keuze trekt, geeft de kansen terug waaruit ze trekt, niet de actie die ze trok; elke beslissing wordt opnieuw geëvalueerd, ook wanneer haar input zich herhaalt. Acties heten precies zoals de log ze noemt: een actie die anders gespeld is, telt als een actie die de loggingpolicy nooit nam.

Type	Schat
off_policy_value	De gemiddelde beloning van de policy op beslissingen zoals de gelogde
off_policy_improvement	Dat gemiddelde min dat van de loggingpolicy zelf

Beide nemen reward_range en propensity_floor, de kleinste kans die de loggingpolicy gaf aan een actie die de nieuwe policy kan nemen. Stel die in op basis van hoe de loggingpolicy ontworpen is (een exploratiepercentage, een minimaal aandeel), nooit door waarden op de log uit te proberen. Elke gelogde beslissing wordt herwogen met de kans van de nieuwe policy op haar actie gedeeld door die van de loggingpolicy, en de ondergrens begrenst dat gewicht: zonder haar geldt geen enkel interval. In de SDK zijn de klassen OffPolicyValue en OffPolicyImprovement.

Wat de engine doet met een beslissing die hij niet kan lezen zoals ze gegeven is:

Situatie	Resultaat
Kansen die samen geen 1 zijn, een gelogde actie met kans 0, een beloning buiten reward_range	De run stopt met exitcode 2: een verkeerde kans zou het interval verkeerd maken zonder dat te tonen
De nieuwe policy kan een actie nemen die gelogd is met een kans onder de ondergrens	De beslissing is ontbrekend en wordt in het slechtste geval begrensd
De beloning is afwezig	De beslissing is ontbrekend en wordt in het slechtste geval begrensd

Wat het antwoord veronderstelt:

De kansen werden vastgelegd toen de loggingpolicy besliste, en het zijn de kansen die ze gebruikte. Oloproof schat ze nooit.
De beloning van elke beslissing hangt af van haar eigen input en actie, niet van andere beslissingen.
De loggingpolicy hield dezelfde kansen aan gedurende de periode van de log.
Het antwoord beschrijft beslissingen zoals de gelogde, over de periode die de log beslaat.

Het interval is breed wanneer de ondergrens klein is: de beslissingen die iets zeggen over een zelden gekozen actie zijn er weinig, en elk telt vele malen. Een langere log, en een loggingpolicy die meer verkent, maken het smaller.

Wat niet gebouwd is

Off-policy-evaluatie van een reeks beslissingen, waarbij elke keuze verandert wat er daarna komt.
Een log waarvan de policy haar kansen veranderde terwijl ze leerde tijdens de periode.
Kansen die achteraf geschat zijn.
Het hosten of resetten van omgevingen en simulators.

Verder lezen

Tutorial: een policy voor reinforcement learning evalueren: beide delen, van begin tot eind gedraaid.
Een suite schrijven: replicaten en de andere suitevelden.
Configuratiereferentie: elk veld van deze evaluators.