En introduktion til Advantage Actor Critic-metoder: lad os spille Sonic the Hedgehog!

Siden starten af ​​dette kursus har vi studeret to forskellige forstærkningsindlæringsmetoder:

  • Værdibaserede metoder (Q-læring, Dyb Q-læring): hvor vi lærer en værdifunktion, der kortlægger hvert statshandlingspar til en værdi. Takket være disse metoder finder vi den bedste handling at tage for hver stat - handlingen med den største værdi. Dette fungerer godt, når du har et endeligt sæt handlinger.
  • Politikbaserede metoder (REINFORCE with Policy Gradients): hvor vi direkte optimerer politikken uden at bruge en værdifunktion. Dette er nyttigt, når handlingsrummet er kontinuerligt eller stokastisk. Hovedproblemet er at finde en god score-funktion til beregning af, hvor god en politik er. Vi bruger de samlede belønninger for episoden.

Men begge disse metoder har store ulemper. Derfor studerer vi i dag en ny type forstærkningslæringsmetode, som vi kan kalde en ”hybrid metode”: Actor Critic . Vi bruger to neurale netværk:

  • en kritiker, der måler, hvor god den udførte handling er (værdibaseret)
  • en skuespiller, der styrer, hvordan vores agent opfører sig (politikbaseret)

At beherske denne arkitektur er afgørende for at forstå de nyeste algoritmer, såsom Proximal Policy Optimization (aka PPO). PPO er baseret på Advantage Actor Critic.

Og du implementerer en Advantage Actor Critic (A2C) agent, der lærer at spille Sonic the Hedgehog!

Jakten på en bedre læringsmodel

Problemet med politikgradienter

Policy Gradient-metoden har et stort problem. Vi er i en situation med Monte Carlo og venter til slutningen af ​​episoden for at beregne belønningen. Vi kan konkludere, at hvis vi har en høj belønning ( R (t) ), var alle handlinger, vi foretog, gode, selvom nogle virkelig var dårlige.

Som vi kan se i dette eksempel, selvom A3 var en dårlig handling (førte til negative belønninger), vil alle handlinger blive gennemsnitlige som gode, fordi den samlede belønning var vigtig.

Som en konsekvens at have en optimal politik,vi har brug for en masse prøver. Dette producerer langsom læring, fordi det tager meget tid at konvergere.

Hvad hvis vi i stedet kan foretage en opdatering på hvert tidspunkt?

Introduktion til skuespillerkritiker

Actor Critic-modellen er en bedre score-funktion. I stedet for at vente til slutningen af ​​episoden, som vi gør i Monte Carlo REINFORCE, foretager vi en opdatering ved hvert trin (TD Learning).

Da vi foretager en opdatering for hvert gangstrin, kan vi ikke bruge de samlede belønninger R (t). I stedet er vi nødt til at træne en Critic-model, der tilnærmer sig værdifunktionen (husk at værdifunktionen beregner, hvad der er den maksimale forventede fremtidige belønning givet en tilstand og en handling). Denne værdifunktion erstatter belønningsfunktionen i politikgradient, der kun beregner belønningerne i slutningen af ​​episoden.

Hvordan Actor Critic fungerer

Forestil dig, at du spiller et videospil med en ven, der giver dig feedback. Du er skuespilleren, og din ven er kritikeren.

I starten ved du ikke, hvordan du spiller, så du prøver tilfældigt. Kritikeren observerer din handling og giver feedback.

Når du lærer af denne feedback, opdaterer du din politik og bliver bedre til at spille det spil.

På den anden side opdaterer din ven (Kritiker) også deres egen måde at give feedback, så det kan blive bedre næste gang.

Som vi kan se, er ideen med Actor Critic at have to neurale netværk. Vi estimerer begge:

Begge kører parallelt.

Fordi vi har to modeller (skuespiller og kritiker), der skal trænes, betyder det, at vi har to sæt vægte (? For vores handling og w for vores kritiker), der skal optimeres separat:

Skuespillerkritikprocessen

Ved hvert tidstrin t tager vi den aktuelle tilstand (St) fra miljøet og sender det som et input gennem vores skuespiller og vores kritiker.

Vores politik tager staten, udsender en handling (At) og modtager en ny tilstand (St + 1) og en belønning (Rt + 1).

Tak til det:

  • Kritikeren beregner værdien af ​​at tage denne handling i den tilstand
  • skuespilleren opdaterer sine politikparametre (vægte) ved hjælp af denne q-værdi

Takket være de opdaterede parametre producerer skuespilleren den næste handling, der skal udføres ved At + 1 i betragtning af den nye tilstand St + 1. Kritikeren opdaterer derefter sine værdiparametre:

A2C og A3C

Introduktion til Advantage-funktionen for at stabilisere læring

Som vi så i artiklen om forbedringer i Deep Q Learning, har værdibaserede metoder stor variation.

For at reducere dette problem talte vi om at bruge fordelfunktionen i stedet for værdifunktionen.

Fordelfunktionen er defineret således:

Denne funktion fortæller os forbedringen i forhold til gennemsnittet, som den handling, der er taget i denne tilstand, er. Med andre ord beregner denne funktion den ekstra belønning, jeg får, hvis jeg tager denne handling. Den ekstra belønning er, at den ligger ud over den forventede værdi af denne stat.

Hvis A (s, a)> 0: vores gradient skubbes i den retning.

Hvis A (s, a) <0 (vores handling gør dårligere end den gennemsnitlige værdi af denne tilstand) skubbes vores gradient i den modsatte retning.

Problemet med at implementere denne fordelfunktion er, at der kræves to værdifunktioner - Q (s, a) og V (s). Heldigvis kan vi bruge TD-fejlen som en god estimator af fordelfunktionen.

To forskellige strategier: Asynkron eller Synkron

Vi har to forskellige strategier til implementering af en Actor Critic-agent:

  • A2C (aka Advantage Actor Critic)
  • A3C (aka Asynchronous Advantage Actor Critic)

Derfor vil vi arbejde med A2C og ikke A3C. Hvis du vil se en komplet implementering af A3C, skal du tjekke den fremragende Arthur Julianis A3C-artikel og Doom-implementering.

I A3C bruger vi ikke afspilning af erfaringer, da dette kræver meget hukommelse. I stedet udfører vi asynkront forskellige agenter parallelt på flere forekomster af miljøet. Hver medarbejder (kopi af netværket) opdaterer det globale netværk asynkront.

På den anden side er den eneste forskel i A2C, at vi synkront opdaterer det globale netværk. Vi venter, indtil alle arbejdere er færdige med deres uddannelse og beregner deres gradienter, så de gennemsnittet for at opdatere vores globale netværk.

Vælger du A2C eller A3C?

Problemet med A3C forklares i denne fantastiske artikel. På grund af den asynkrone karakter af A3C vil nogle arbejdere (kopier af agenten) spille med ældre version af parametrene. Den samlede opdatering vil således ikke være optimal.

Derfor venter A2C på, at hver aktør skal afslutte deres oplevelsesegment, inden de opdaterer de globale parametre. Derefter genstarter vi et nyt segment af oplevelse med alle parallelle aktører, der har de samme nye parametre.

Som en konsekvens bliver træningen mere sammenhængende og hurtigere.

Implementering af en A2C-agent, der spiller Sonic the Hedgehog

A2C i praksis

I praksis betyder, som forklaret i dette Reddit-indlæg, den synkrone karakter af A2C, at vi ikke har brug for forskellige versioner (forskellige medarbejdere) af A2C.

Hver arbejdstager i A2C vil have det samme sæt vægte, da A2C i modsætning til A3C opdaterer alle deres arbejdere på samme tid.

Faktisk opretter vi flere versioner af miljøer (lad os sige otte) og udfører dem derefter parallelt.

Processen vil være følgende:

  • Opretter en vektor af n miljøer ved hjælp af multiprocessing-biblioteket
  • Opretter et løberobjekt, der håndterer de forskellige miljøer og udføres parallelt.
  • Har to versioner af netværket:
  1. step_model: der genererer oplevelser fra miljøer
  2. train_model: der træner oplevelserne.

Når løberen tager et skridt (enkelt trin model) udfører dette et trin for hvert af de n miljøer. Dette giver en masse erfaring.

Derefter beregner vi gradienten på én gang ved hjælp af train_model og vores batch af erfaring.

Endelig opdaterer vi trinmodellen med de nye vægte.

Husk, at beregning af gradienten på én gang er den samme ting som at indsamle data, beregne gradienten for hver arbejdstager og derefter beregne et gennemsnit. Hvorfor? Fordi summering af derivaterne (summering af gradienter) er den samme som at tage derivaterne af summen . Men den anden er mere elegant og en bedre måde at bruge GPU på.

A2C med Sonic the Hedgehog

Så nu hvor vi forstår, hvordan A2C fungerer generelt, kan vi implementere vores A2C-agent, der spiller Sonic! Denne video viser adfærdsforskellen for vores agent mellem 10 min træning (venstre) og 10 timers træning (højre).

Implementeringen er i GitHub repo her, og notesbogen forklarer implementeringen. Jeg giver dig den gemte model trænet med cirka 10 timer + på GPU.

Denne implementering er meget kompleks end de tidligere implementeringer. Vi begynder at implementere avancerede algoritmer, så vi skal være mere og mere effektive med vores kode. Derfor adskiller vi koden i denne implementering i forskellige objekter og filer.

Det er alt! Du har lige oprettet en agent, der lærer at spille Sonic the Hedgehog. Det er fantastisk! Vi kan se, at med 10 timers træning forstår vores agent for eksempel ikke loopingen, så vi bliver nødt til at bruge en mere stabil arkitektur: PPO.

Tag dig tid til at overveje alle de præstationer, du har opnået siden det første kapitel på dette kursus: vi gik fra enkle tekstspil (OpenAI taxi-v2) til komplekse spil som Doom og Sonic the Hedgehog ved hjælp af mere og mere kraftfulde arkitekturer. Og det er fantastisk!

Næste gang lærer vi om Proximal Policy Gradients, arkitekturen, der vandt OpenAI Retro Contest. Vi træner vores agent til at spille Sonic the Hedgehog 2 og 3, og denne gang, og det vil afslutte hele niveauer!

Glem ikke at implementere hver del af koden selv. Det er virkelig vigtigt at prøve at ændre den kode, jeg gav dig. Prøv at tilføje epoker, ændre arkitekturen, ændre læringshastigheden osv. Eksperimentering er den bedste måde at lære, så have det sjovt!

Hvis du kunne lide min artikel, skal du klikke på? under så mange gange som du kunne lide artiklen, så andre mennesker kan se dette her på Medium. Og glem ikke at følge mig!

Denne artikel er en del af mit Deep Reinforcement Learning Course med TensorFlow? ️. Se pensum her.

Hvis du har tanker, kommentarer, spørgsmål, er du velkommen til at kommentere nedenfor eller sende mig en e-mail: hej [at] simoninithomas [dot] com, eller tweet mig @ThomasSimonini.

Dyb forstærkningskursus:

Vi laver en videoversion af Deep Reinforcement Learning Course med Tensorflow ? hvor vi fokuserer på implementeringsdelen med tensorflow her.

Del 1: En introduktion til forstærkningslæring

Del 2: Dykke dybere ned i forstærkningslæring med Q-læring

Del 3: En introduktion til Deep Q-Learning: lad os spille Doom

Del 3+: Forbedringer i Deep Q Learning: Duelling Double DQN, Prioriteret Experience Replay og faste Q-mål

Del 4: En introduktion til Policy Gradients med Doom og Cartpole

Del 6: Proximal politikoptimering (PPO) med Sonic the Hedgehog 2 og 3

Del 7: Nysgerrighedsdrevet læring gjort let del I