Jag har läst Googles DeepMind Atari papper och jag försöker att förstå begreppet ”erfarenhetsuppspelning”. Erfarenhetsuppspelning kommer upp i många andra förstärkande lärandepapper (särskilt AlphaGo-papperet), så jag vill förstå hur det fungerar. Nedan följer några utdrag.

Först använde vi en biologiskt inspirerad mekanism som kallas erfarenhetsuppspelning som slumpmässigt över data och därmed tar bort korrelationer i observationssekvensen och utjämnar förändringar i datafördelningen.

Papperet utvecklas sedan enligt följande:

Medan det finns andra stabila metoder för träning av neurala nätverk i inställningen för förstärkningsinlärning, såsom neuralpassad Q-iteration, involverar dessa metoder upprepad träning av nätverk de novo hundratals iterationer. Följaktligen är dessa metoder, till skillnad från vår algoritm, för ineffektivt för att kunna användas framgångsrikt med stora neurala nätverk. Vi parametrar en ungefärlig värdefunktion $ Q (s, a; \ theta_i) $ med hjälp av det djupa fackliga neurala nätverket som visas i fig. 1, där $ \ theta_i $ är parametrarna (det vill säga vikter) för Q-nätverket vid iteration $ i $ . För att utföra återuppspelning av upplevelser lagrar vi agentens upplevelser $ e_t = (s_t, a_t, r_t, s_ {t + 1}) $ vid varje tidsteg $ t $ i en datamängd $ D_t = \ {e_1, \ dots, e_t \} $ . lärande, vi tillämpar uppdateringar av Q-learning, på prover (eller minibatcher) av erfarenhet $ (s, a, r, s ”) \ sim U (D) $ , dras slumpmässigt enhetligt från poolen med lagrade prover. Q-learning-uppdateringen vid iteration $ i $ använder följande förlustfunktion:

$$ L_i (\ theta_i) = \ mathbb {E} _ {(s, a, r, s ”) \ sim U (D)} \ left [\ left (r + \ gamma \ max_ {a”} Q (s), a ”; \ theta_i ^ -) – Q (s, a; \ theta_i) \ right) ^ 2 \ right] $$

Vad är återuppspelning av erfarenheter och vad är fördelarna med lekmän?

Svar

Nyckeldelen av citerad text är:

För att utföra uppspelning igen spelar vi agentens upplevelser $ e_t = (s_t, a_t, r_t, s_ {t + 1} ) $

Detta betyder att i stället för att köra Q-learning på tillstånds- / åtgärdspar när de inträffar under simulering eller faktisk upplevelse lagrar systemet de data som upptäcktes för [tillstånd, åtgärd, belöning, nästa_stat] – vanligtvis i en stor tabell. Observera att detta inte lagrar tillhörande värden – det här är rådata som ska matas in i beräkningar av åtgärdsvärden senare.

Inlärningsfasen är sedan logiskt skild från att få erfarenhet och baseras på att ta slumpmässiga prover från denna tabell. Du vill fortfarande införa de två processerna – agera och lära – för att förbättra policyn kommer att leda till olika beteenden som bör utforska åtgärder närmare de optimala, och du vill lära av dem. Du kan dock dela upp det så du vill – t.ex. ta ett steg, lära dig av tre slumpmässiga tidigare steg etc. Q-Learning-målen när du använder erfarenhetsuppspelning använder samma mål som onlineversionen, så det finns ingen ny formel för det. Den angivna förlustformeln är också den som du skulle använda för DQN utan erfarenhetsuppspelning. Skillnaden är bara vilka s, a, r, s ”, a” du matar in i den.

I DQN upprätthöll DeepMind-teamet också två nätverk och bytte vilket som var inlärning och vilken som matas in i aktuella åtgärdsvärderingar som ”bootstraps”. Detta hjälpte till med algoritmens stabilitet när man använder en icke-linjär funktions approximator. Det är vad fältet står för i $ {\ theta} ^ {\ overline {\ space}} _ i $ – det anger den alternativa frysta versionen av vikterna.

Fördelar med återuppspelning av erfarenhet:

  • Effektivare användning av tidigare erfarenheter genom att lära sig med det flera gånger. Detta är nyckeln när det är dyrt att få erfarenhet från verkliga saker, du kan få full användning av Uppdateringarna av Q-learning är inkrementella och konvergerar inte snabbt, så flera passeringar med samma data är fördelaktiga, särskilt när det finns låg variation i omedelbara resultat (belöning, nästa tillstånd) med tanke på samma tillstånd, åtgärdspar.

  • Bättre konvergensbeteende vid träning av en funktions approximator. Detta beror delvis på att data är mer som iid data som antas i mest övervakade lärande konvergens bevis.

Nackdelen med uppspelning av upplevelse:

  • Det är svårare att använda inlärningsalgoritmer i flera steg, till exempel Q ($ \ lambda $) , som kan ställas in för att ge bättre inlärningskurvor genom att balansera mellan bias (på grund av bootstrapping) och varians (på grund av förseningar och slumpmässighet i långsiktiga resultat). Flerstegs DQN med erfarenhetsuppspelning DQN är en av tilläggen som utforskas i tidningen Rainbow: Combining Improvement in Deep Reinforcement Learning .

Det tillvägagångssätt som används i DQN är kort skisserat av David Silver i delar av denna videoföreläsning (runt 01:17: 00, men värt att se avsnitt innan det). Jag rekommenderar att du tittar på hela serien, som är en kurs på avancerad nivå om förstärkning, om du har tid.

Kommentarer

  • Låt ’ säger under utbildningen att vi är i en stat och vi vidtar en åtgärd enligt epsilon-girig politik och du hamnar i en annan stat. Så du får belöningar och nästa tillstånd. Här kan belöningen vara spelets poäng och staterna kan vara pixelmönstren på skärmen. Och sedan tar vi felet mellan vår funktion aproximator och värdet vi fick från den giriga policyn igen med redan frysta funktions approximator. Men med erfarenhetsuppspelningen när vi optimerar approximatorn tar vi några slumpmässiga datauppsättningar. Har jag rätt?
  • @ShamaneSiriwardhana: Ja, jag tror att du har rätt. Det är exakt samma data från den verkliga banan, men istället för att lära dig bara från det senaste steget sparar du det i en stor tabell och samplar från den tabellen (vanligtvis flera prover, med en butik på 1000-talet av tidigare steg att välja mellan ). Om du behöver mer förtydligande kan du ställa en fråga på webbplatsen.
  • Ja, jag gick igenom tidningen igen. Det står också att den här metoden kan förbättra inlärningen utanför policyn också. Eftersom Q lär sig med agera enligt epsilon-girig policy men uppdatera värden fungerar enligt girig policy. Så när varje gång våra neuronparametrar uppdateras med mini-batchstatistik, vilket är viktigare inte relaterat till exakt tidsstegsstatistik men vad som hände innan detta hjälper också till att korrelera data.
  • @Neil Slater, I ’ har gått igenom Rainbow-papperet och jag såg ’ inte några speciella kommentarer om att använda ett speciellt trick för att kombinera upplevelseuppspelning och multi- stegmetod. Jag har också ’ hört att flerstegsmetoden ursprungligen är omöjlig att kombinera med erfarenhetsuppspelning men varför inte bara slumpmässigt välja n-på varandra upplevelser istället för 1 från erfarenhetsuppspelning utan från uppspelningen så att mellan varje n-upplevelse hittades inga korrelationer? Är inte ’ inte den här uppspelningen i flera steg?
  • @NeilSlater Varför är det ” svårare att använda multi- steginlärningsalgoritmer ”? Vad menade du?

Svar

Algoritmen (eller åtminstone en version av den, som implementerad i Coursera RL capstone-projekt ) är som följer:

  1. Skapa en ”Spela buffert” som lagrar den sista #buffer_size SARS (State, Action, Reward, New State) upplevelser.

  2. Kör din agent och låt den samla upplevelser i omspelningsbufferten tills den (bufferten) har minst #batch_size upplevelser .

    • Du kan välja åtgärder enligt en viss policy (t.ex. soft-max för diskret åtgärdsutrymme, Gaussian för kontinuerlig, etc.) över din $ \ hat {Q} (s, a; \ theta) $ funktionsuppskattning.

  3. När den når #batch_size eller mer:

    • gör en kopia av funktionsuppskattaren ( $ \ hat {Q} (s, a; \ theta) $ ) vid den aktuella tiden, dvs. en kopia av vikterna $ \ theta $ – som du ”fryser” och inte uppdaterar, och använd för att beräkna de ”sanna” tillstånden $ \ hat {Q} (s ”, a”; \ theta) $ . Kör för num_replay uppdateringar:

      1. exempel #batch_size upplevelser från omspelningsbufferten.

      2. Använd de samplade upplevelserna för att pr forma en partiell uppdatering till din funktionsuppskattare (t.ex. i Q-Learning där $ \ hat {Q} (s, a) = $ Neurala nätverk – uppdatera vikterna i nätverket). Använd de frysta vikterna som ”sanna” funktionsvärden, men fortsätt att förbättra den icke-frysta funktionen.

    • gör detta tills du nå ett terminalläge.

    • Glöm inte att ständigt lägga till de nya upplevelserna i Replay Buffer

  4. Kör för så många avsnitt som du behöver.

Vad jag menar med ”sant”: varje upplevelse kan ses som en ”övervakad” inlärningsduo, där du har en verklig värdefunktion $ Q (s, a) $ och en funktionsuppskattare $ \ hat {Q} (s, a) $ . Ditt mål är att minska Value-Error, t.ex. $ \ sum (Q (s, a) – \ hat {Q} (s, a)) ^ 2 $ . Eftersom du förmodligen inte har tillgång till true åtgärdsvärden använder du istället en bootstrapped förbättrad version av den senaste uppskattaren med hänsyn till den nya upplevelsen och belöningen som ges. I Q-learning är det ”sanna” åtgärdsvärdet $ Q (s, a) = R_ {t + 1} + \ gamma \ max_ {a ”} \ hat {Q} (s”, a ”; \ theta) $ där $ R $ är belöningen och $ \ gamma $ är rabattfaktorn.

Här är ett utdrag av koden: 

def agent_step(self, reward, state): action = self.policy(state) terminal = 0 self.replay_buffer.append(self.last_state, self.last_action, reward, terminal, state) if self.replay_buffer.size() > self.replay_buffer.minibatch_size: current_q = deepcopy(self.network) for _ in range(self.num_replay): experiences = self.replay_buffer.sample() optimize_network(experiences, self.discount, self.optimizer, self.network, current_q, self.tau) self.last_state = state self.last_action = action return action

Lämna ett svar

Din e-postadress kommer inte publiceras. Obligatoriska fält är märkta *