Bevezetés a mély Q-tanulásba: játsszuk a Doom-ot

Ez a cikk a mélymegerősítő tanfolyam része a Tensorflow-val? ️. A tantervet itt ellenőrizheti.

Legutóbb a Q-Learningről tanultunk: egy algoritmusról, amely Q-táblázatot állít elő, amelyet az ügynök használ, hogy megtalálja a legjobb intézkedést az adott állapotra vonatkozóan.

De amint látni fogjuk, a Q-tábla előállítása és frissítése hatástalanná válhat nagy állapotú űrkörnyezetekben.

Ez a cikk a mélymegerősítő tanulásról szóló blogbejegyzés-sorozat harmadik része. További információkért és további forrásokért tekintse meg a kurzus tantervét.

Ma létrehozunk egy Deep Q neurális hálózatot. Q-tábla használata helyett egy neurális hálózatot valósítunk meg, amely állapotot vesz fel, és az állapot alapján megközelíti az egyes műveletek Q-értékeit.

Ennek a modellnek köszönhetően képesek leszünk létrehozni egy ügynököt, amely megtanulja játszani a Doom-ot!

Ebben a cikkben megtudhatja:

  • Mi az a mély Q-tanulás (DQL)?
  • Melyek a legjobb stratégiák a DQL-hez?
  • Hogyan kezeljük az időbeli korlátozási problémát
  • Miért használjuk az élményismétlést
  • Milyen matematika áll a DQL mögött
  • Hogyan lehet megvalósítani a Tensorflow-ban

A „Deep” hozzáadása a Q-Learninghez

Az utolsó cikkben létrehoztunk egy ügynököt, amely a Q-learning algoritmusnak köszönhetően játssza a Frozen Lake-t.

A Q-learning funkciót egy Q-tábla létrehozására és frissítésére vezettük be. Gondoljon erre, mint egy „csalólapra”, amely segít megtalálni egy cselekvés várható jövőbeni maximális jutalmát, adott pillanatban. Ez jó stratégia volt - ez azonban nem méretezhető.

Képzelje el, mit fogunk ma csinálni. Létrehozunk egy ügynököt, aki megtanulja játszani a Doom-ot. A Doom egy hatalmas környezet, hatalmas állapotú térrel (különböző államok milliói). Az adott környezethez Q-tábla létrehozása és frissítése egyáltalán nem lenne hatékony.

A legjobb ötlet ebben az esetben egy neurális hálózat létrehozása, amely közelít, adott állapothoz viszonyítva, az egyes tevékenységek különböző Q-értékeit.

Hogyan működik a mély Q-tanulás?

Ez lesz a Deep Q Learning felépítése:

Ez összetettnek tűnhet, de lépésről lépésre elmagyarázom az architektúrát.

A Deep Q Neural Network hálózatunk négy keretből áll egy bemenetként. Ezek áthaladnak a hálózatán, és Q-értékek vektorát adják ki az adott állapotban lehetséges minden művelethez. Ennek a vektornak a legnagyobb Q-értékét kell megadnunk a legjobb cselekvésünk megtalálásához.

Kezdetben az ügynök nagyon rosszul jár. De az idők folyamán a kereteket (állapotokat) a legjobb elvégzendő cselekvésekhez köti.

Előkészítő rész

Az előfeldolgozás fontos lépés. Csökkenteni akarjuk az államok bonyolultságát a képzéshez szükséges számítási idő csökkentése érdekében.

Először szürkeárnyalatos állapotba hozhatjuk az egyes állapotokat. A szín nem ad hozzá fontos információkat (esetünkben csak meg kell találnunk az ellenséget és meg kell ölnünk, és nincs szükség színre, hogy megtaláljuk). Ez fontos megtakarítás, mivel három színcsatornánkat (RGB) 1-re (szürkeárnyalatosra) csökkentjük.

Ezután levágjuk a keretet. Példánkban a tető látása nem igazán hasznos.

Ezután csökkentjük a keret méretét, és négy alkeretet rakunk össze.

Az időbeli korlátozás problémája

Arthur Juliani fantasztikus magyarázatot ad erről a témáról cikkében. Okos ötlete van: az LSTM ideghálózatainak használata a probléma kezelésére.

Úgy gondolom azonban, hogy a kezdőknek jobb halmozott kereteket használni.

Az első kérdés, amit feltesz, hogy miért rakjuk össze a kereteket?

A kereteket egymásra rakjuk, mert ez segít az időbeli korlátozás problémájának kezelésében.

Vegyünk egy példát a Pong játékában. Amikor ezt a keretet látja:

Meg tudnád mondani, merre tart a labda?

Nem, mert egy képkocka nem elegendő a mozgásérzékhez!

De mi van, ha hozzáadok még három keretet? Itt láthatja, hogy a labda jobbra megy.

Ugyanez a helyzet a Doom ügynökünkkel is. Ha egyszerre csak egy keretet adunk neki, akkor fogalma sincs a mozgásról. És hogyan hozhat helyes döntést, ha nem tudja meghatározni, hol és milyen gyorsan mozognak az objektumok?

Konvolúciós hálózatok használata

A kereteket három konvolúciós réteg dolgozza fel. Ezek a rétegek lehetővé teszik a térbeli kapcsolatok kiaknázását a képeken. De azért is, mert a keretek egymásba vannak rakva, kihasználhat néhány térbeli tulajdonságot ezeken a keretek között.

Ha még nem ismeri a konvolúciót, olvassa el Adam Geitgey kiváló intuitív cikkét.

Minden konvolúciós réteg az ELU-t fogja használni aktiválási funkcióként. Az ELU bizonyítottan jó aktivációs funkció a konvolúciós rétegek számára.

Egy teljesen összekapcsolt réteget használunk ELU aktiválási funkcióval és egy kimeneti réteget (teljesen összekapcsolt réteg lineáris aktiválási funkcióval), amely minden művelethez előállítja a Q-érték becslést.

Experience Replay: a megfigyelt tapasztalatok hatékonyabb kihasználása

A tapasztalatok visszajátszása két dolog kezelésében segít:

  • Kerülje a korábbi tapasztalatok elfelejtését.
  • Reduce correlations between experiences.

I will explain these two concepts.

This part and the illustrations were inspired by the great explanation in the Deep Q Learning chapter in the Deep Learning Foundations Nanodegree by Udacity.

Avoid forgetting previous experiences

We have a big problem: the variability of the weights, because there is high correlation between actions and states.

Remember in the first article (Introduction to Reinforcement Learning), we spoke about the Reinforcement Learning process:

At each time step, we receive a tuple (state, action, reward, new_state). We learn from it (we feed the tuple in our neural network), and then throw this experience.

Our problem is that we give sequential samples from interactions with the environment to our neural network. And it tends to forget the previous experiences as it overwrites with new experiences.

For instance, if we are in the first level and then the second (which is totally different), our agent can forget how to behave in the first level.

As a consequence, it can be more efficient to make use of previous experience, by learning with it multiple times.

Our solution: create a “replay buffer.” This stores experience tuples while interacting with the environment, and then we sample a small batch of tuple to feed our neural network.

Think of the replay buffer as a folder where every sheet is an experience tuple. You feed it by interacting with the environment. And then you take some random sheet to feed the neural network

This prevents the network from only learning about what it has immediately done.

Reducing correlation between experiences

We have another problem — we know that every action affects the next state. This outputs a sequence of experience tuples which can be highly correlated.

If we train the network in sequential order, we risk our agent being influenced by the effect of this correlation.

By sampling from the replay buffer at random, we can break this correlation. This prevents action values from oscillating or diverging catastrophically.

It will be easier to understand that with an example. Let’s say we play a first-person shooter, where a monster can appear on the left or on the right. The goal of our agent is to shoot the monster. It has two guns and two actions: shoot left or shoot right.

We learn with ordered experience. Say we know that if we shoot a monster, the probability that the next monster comes from the same direction is 70%. In our case, this is the correlation between our experiences tuples.

Let’s begin the training. Our agent sees the monster on the right, and shoots it using the right gun. This is correct!

Then the next monster also comes from the right (with 70% probability), and the agent will shoot with the right gun. Again, this is good!

And so on and on…

The problem is, this approach increases the value of using the right gun through the entire state space.

And if our agent doesn’t see a lot of left examples (since only 30% will probably come from the left), our agent will only finish by choosing right regardless of where the monster comes from. This is not rational at all.

We have two parallel strategies to handle this problem.

First, we must stop learning while interacting with the environment. We should try different things and play a little randomly to explore the state space. We can save these experiences in the replay buffer.

Then, we can recall these experiences and learn from them. After that, go back to play with updated value function.

As a consequence, we will have a better set of examples. We will be able to generalize patterns from across these examples, recalling them in whatever order.

This helps avoid being fixated on one region of the state space. This prevents reinforcing the same action over and over.

This approach can be seen as a form of Supervised Learning.

We’ll see in future articles that we can also use “prioritized experience replay.” This lets us present rare or “important” tuples to the neural network more frequently.

Our Deep Q-Learning algorithm

First a little bit of mathematics:

Remember that we update our Q value for a given state and action using the Bellman equation:

In our case, we want to update our neural nets weights to reduce the error.

The error (or TD error) is calculated by taking the difference between our Q_target (maximum possible value from the next state) and Q_value (our current prediction of the Q-value)

Initialize Doom Environment EInitialize replay Memory M with capacity N (= finite capacity)Initialize the DQN weights wfor episode in max_episode: s = Environment state for steps in max_steps: Choose action a from state s using epsilon greedy. Take action a, get r (reward) and s' (next state) Store experience tuple  in M s = s' (state = new_state) Get random minibatch of exp tuples from M Set Q_target = reward(s,a) + γmaxQ(s') Update w = α(Q_target - Q_value) * ∇w Q_value

There are two processes that are happening in this algorithm:

  • We sample the environment where we perform actions and store the observed experiences tuples in a replay memory.
  • Select the small batch of tuple random and learn from it using a gradient descent update step.

Vezessük be a Deep Q Neural Network-t

Készítettünk egy videót, ahol egy Deep Q-learning ügynököt valósítunk meg a Tensorflow segítségével, amely megtanulja az Atari Space Invaders játékát? ️ ?.

Most, hogy tudjuk, hogyan működik, lépésről lépésre megvalósítjuk a Deep Q Neural Network-t. A kód minden lépését és minden részét közvetlenül az alább hivatkozott Jupyter jegyzetfüzet magyarázza.

A Deep Reinforcement Learning Course repóban érheti el.

Ez minden! Most létrehoztál egy ügynököt, aki megtanulja játszani a Doom-ot. Fantasztikus!

Ne felejtse el egyedül végrehajtani a kód egyes részeit. Nagyon fontos megpróbálni módosítani az általam megadott kódot. Próbáljon korszakokat hozzáadni, megváltoztatni az architektúrát, rögzített Q-értékeket adni, megváltoztatni a tanulási sebességet, használni egy keményebb környezetet (például az Egészséggyűjtést) ... és így tovább. Jó szórakozást!

A következő cikkben a Deep Q-learning utolsó fejlesztéseit tárgyalom:

  • Rögzített Q-értékek
  • Prioritized Experience Replay
  • Double DQN
  • Dueling Networks

But next time we’ll work on Policy Gradients by training an agent that plays Doom, and we’ll try to survive in an hostile environment by collecting health.

If you liked my article, please click the ? below as many time as you liked the article so other people will see this here on Medium. And don’t forget to follow me!

If you have any thoughts, comments, questions, feel free to comment below or send me an email: [email protected], or tweet me @ThomasSimonini.

Keep learning, stay awesome!

Deep Reinforcement Learning Course with Tensorflow ?️

? Syllabus

? Video version

Part 1: An introduction to Reinforcement Learning

Part 2: Diving deeper into Reinforcement Learning with Q-Learning

Part 3: An introduction to Deep Q-Learning: let’s play Doom

Part 3+: Improvements in Deep Q Learning: Dueling Double DQN, Prioritized Experience Replay, and fixed Q-targets

Part 4: An introduction to Policy Gradients with Doom and Cartpole

Part 5: An intro to Advantage Actor Critic methods: let’s play Sonic the Hedgehog!

Part 6: Proximal Policy Optimization (PPO) with Sonic the Hedgehog 2 and 3

Part 7: Curiosity-Driven Learning made easy Part I