Merüljön el mélyebben a megerősítő tanulásban a Q-Learning segítségével

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

Ma megismerjük a Q-tanulást. A Q-Learning egy értékalapú Reinforcement Learning algoritmus.

Ez a cikk egy ingyenes blogbejegyzés-sorozat második része a mély megerősítésű tanulásról. További információkért és további forrásokért tekintse meg a kurzus tantervét. Lásd az első cikket itt.

Ebben a cikkben megtudhatja:

  • Mi a Q-Learning
  • Hogyan lehet megvalósítani a Numpy-val

Az összkép: a lovag és a hercegnő

Tegyük fel, hogy lovag vagy, és meg kell mentened a hercegnőt, aki a fenti térképen látható kastélyban rekedt.

Egyszerre egy csempét mozgathat. Az ellenség nem tud, de ugyanazon a cserepen landol, mint az ellenség, és akkor meghal.A cél az, hogy a lehető leggyorsabb úton haladjon a várba. Ezt egy „pontszerző” rendszerrel lehet értékelni.

  • te-1-et veszít minden lépésnél (pontok elvesztése minden lépésnélsegít ügynökünknek abban, hogy gyors legyen).
  • Ha megérinti az ellenséget, elveszíti -100 pontot, és az epizód véget ér.
  • Ha a kastélyban vagy, akkor nyersz, +100 pontot kapsz.

A kérdés az: hogyan hozhat létre egy ügynököt, amely képes erre?

Itt van az első stratégia. Tegyük fel, hogy ügynökünk megpróbál minden egyes lapkához menni, majd mindegyik lapot kiszínezi. Zöld a „biztonságos” és piros, ha nem.

Aztán elmondhatjuk ügynökünknek, hogy csak zöld csempét vegyen.

De a probléma az, hogy nem igazán hasznos. Nem tudjuk a legjobb csempét, ha a zöld csempék szomszédosak egymással.Ügynökünk tehát végtelen hurkba eshet, ha megpróbálja megtalálni a várat!

A Q-tábla bemutatása

Itt van egy második stratégia: hozzon létre egy táblázatot, ahol kiszámoljuk a jövőben várható maximális jutalmat, az egyes államok egyes műveleteire.

Ennek köszönhetően megtudjuk, mi a legjobb intézkedés az egyes államok esetében.

Minden állapot (csempe) négy lehetséges műveletet tesz lehetővé. Ezek balra, jobbra, felfelé vagy lefelé mozognak.

A számítás szempontjából ezt a rácsot táblává alakíthatjuk át.

Ezt Q-táblának hívjuk („Q” a művelet „minőségének”). Az oszlopok a négy művelet lesznek (bal, jobb, fel, le). A sorok az állapotok lesznek. Az egyes cellák értéke az adott állapot és cselekvés maximálisan várható jövőbeni jutalma lesz.

Minden Q-tábla pontszám lesz a maximálisan várható jövőbeni jutalom, amelyet akkor kapok, ha az adott államban a legjobb politikával hajtom végre ezt a lépést.

Miért mondjuk azt, hogy „a megadott politikával?” Azért, mert nem hajtunk végre politikát. Ehelyett csak javítjuk a Q-táblánkat, hogy mindig a legjobb cselekvést válasszuk.

Gondoljon erre a Q-asztalra, mint egy játék „csalólapra”. Ennek köszönhetően minden államnál (a Q-táblázat minden soránál) tudjuk, hogy mi a legjobb teendő, ha megtaláljuk a legmagasabb pontszámot ebben a sorban.

Igen! Megoldottuk a vár problémáját! De várjon ... Hogyan számoljuk ki a Q táblázat egyes elemeinek értékeit?

A Q-tábla egyes értékeinek megismeréséhez a Q tanulási algoritmust fogjuk használni.

Q-learning algoritmus: az Action Value függvény megtanulása

Az Action Value függvény (vagy „Q-function”) két bemenetet vesz igénybe: „állapot” és „művelet”. Visszaadja a cselekvés várható jövőbeni jutalmát abban az állapotban.

Ezt a Q függvényt olvasóként láthatjuk, amely végiglapozza a Q táblázatot, hogy megtalálja az állapotunkhoz társított vonalat és a műveletünkhöz tartozó oszlopot. Visszaadja a Q értéket az egyező cellából. Ez a „várható jövedelem”.

Mielőtt azonban felfedeznénk a környezetet, a Q-tábla ugyanazt a tetszőleges fix értéket adja (legtöbbször 0). Ahogy feltárjuk a környezetet , a Q-tábla jobb és jobb közelítést nyújt számunkra azáltal, hogy a Bell (X) egyenletet iteratív módon frissíti Q (s, a) (lásd alább!).

A Q-learning algoritmus folyamata

1. lépés: Inicializálja a Q-értékeket

Felépítünk egy Q táblázatot, m oszloppal (m = műveletek száma) és n sorral (n = állapotok száma). Az értékeket 0-nál inicializáljuk.

2. lépés: Egy életre (vagy amíg a tanulás le nem áll)

A 3–5. Lépéseket addig ismételjük, amíg el nem érjük a maximális (a felhasználó által meghatározott) epizódok számát, vagy amíg manuálisan le nem állítjuk az edzést.

3. lépés: Válasszon egy műveletet

Válasszon egy műveletet a jelenlegi állapotában s az aktuális Q-érték becslések.

De ... mit tehetünk az elején, ha minden Q-érték nulla?

Itt lesz fontos a feltárási / kiaknázási kompromisszum, amelyről az utolsó cikkben beszéltünk.

Az ötlet az, hogy az elejénaz epsilon kapzsi stratégiát fogjuk használni:

  • We specify an exploration rate “epsilon,” which we set to 1 in the beginning. This is the rate of steps that we’ll do randomly. In the beginning, this rate must be at its highest value, because we don’t know anything about the values in Q-table. This means we need to do a lot of exploration, by randomly choosing our actions.
  • We generate a random number. If this number > epsilon, then we will do “exploitation” (this means we use what we already know to select the best action at each step). Else, we’ll do exploration.
  • The idea is that we must have a big epsilon at the beginning of the training of the Q-function. Then, reduce it progressively as the agent becomes more confident at estimating Q-values.

Steps 4–5: Evaluate!

Take the action a and observe the outcome state s’ and reward r. Now update the function Q(s,a).

We take the action a that we chose in step 3, and then performing this action returns us a new state s’ and a reward r (as we saw in the Reinforcement Learning process in the first article).

Then, to update Q(s,a) we use the Bellman equation:

The idea here is to update our Q(state, action) like this:

New Q value = Current Q value + lr * [Reward + discount_rate * (highest Q value between possible actions from the new state s’ ) — Current Q value ]

Let’s take an example:

  • One cheese = +1
  • Two cheese = +2
  • Big pile of cheese = +10 (end of the episode)
  • If you eat rat poison =-10 (end of the episode)

Step 1: We init our Q-table

Step 2: Choose an action

From the starting position, you can choose between going right or down. Because we have a big epsilon rate (since we don’t know anything about the environment yet), we choose randomly. For example… move right.

We found a piece of cheese (+1), and we can now update the Q-value of being at start and going right. We do this by using the Bellman equation.

Steps 4–5: Update the Q-function

  • First, we calculate the change in Q value ΔQ(start, right)
  • Then we add the initial Q value to the ΔQ(start, right) multiplied by a learning rate.

Think of the learning rate as a way of how quickly a network abandons the former value for the new. If the learning rate is 1, the new estimate will be the new Q-value.

Good! We’ve just updated our first Q value. Now we need to do that again and again until the learning is stopped.

Implement a Q-learning algorithm

Készítettünk egy videót, ahol megvalósítunk egy Q-learning ügynököt, amely megtanulja a Taxi-v2 játékát a Numpy-val.

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

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

Vagy közvetlenül elérheti a Google Colaboratory-n:

Q * Tanulás a Frozen Lake-vel

colab.research.google.com

Összefoglalás…

  • A Q-learning egy értékalapú Reinforcement Learning algoritmus, amelyet arra használnak, hogy megtalálják az optimális művelet-kiválasztási politikát az aq függvény segítségével.
  • Kiértékeli, hogy melyik műveletet kell végrehajtani egy olyan cselekvés-érték függvény alapján, amely meghatározza annak értékét, hogy egy bizonyos állapotban tartózkodik, és abban az állapotban bizonyos intézkedést hajt végre.
  • Cél: maximalizálni a Q értékfüggvényt (állapot és cselekvés esetén várható jövőbeni jutalom).
  • Q table helps us to find the best action for each state.
  • To maximize the expected reward by selecting the best of all possible actions.
  • The Q come from qualityof a certain action in a certain state.
  • Function Q(state, action) → returns expected future reward of that action at that state.
  • This function can be estimated using Q-learning, which iteratively updates Q(s,a) using the Bellman Equation
  • Before we explore the environment: Q table gives the same arbitrary fixed value → but as we explore the environment → Q gives us a better and better approximation.

That’s all! Don’t forget to implement each part of the code by yourself — it’s really important to try to modify the code I gave you.

Try to add epochs, change the learning rate, and use a harder environment (such as Frozen-lake with 8x8 tiles). Have fun!

Next time we’ll work on Deep Q-learning, one of the biggest breakthroughs in Deep Reinforcement Learning in 2015. And we’ll train an agent that that plays Doom and kills enemies!

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