Dykker dybere ned i forstærkningslæring med Q-læring

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

I dag lærer vi om Q-Learning. Q-Learning er en værdibaseret algoritme til forstærkningslæring.

Denne artikel er den anden del af en gratis serie af blogindlæg om dyb forstærkningslæring. For mere information og flere ressourcer, se kursusplanen. Se den første artikel her.

I denne artikel lærer du:

  • Hvad Q-Learning er
  • Sådan implementeres det med Numpy

Det store billede: Ridderen og prinsessen

Lad os sige, at du er en ridder, og at du skal redde prinsessen fanget i slottet vist på kortet ovenfor.

Du kan flytte en flise ad gangen. Fjenden kan ikke, men lander på samme flise som fjenden, og du vil dø.Dit mål er at gå på slottet på den hurtigste rute. Dette kan evalueres ved hjælp af et "point scoring" -system.

  • Dutab -1 ved hvert trin (tab af point ved hvert trinhjælper vores agent med at være hurtig).
  • Hvis du rører ved en fjende, mister du -100 point, og episoden slutter.
  • Hvis du er i slottet, vinder du, får du +100 point.

Spørgsmålet er: hvordan opretter du en agent, der er i stand til at gøre det?

Her er en første strategi. Lad os sige, at vores agent prøver at gå til hver flise og derefter farve hver flise. Grøn for "sikker" og rød hvis ikke.

Derefter kan vi fortælle vores agent kun at tage grønne fliser.

Men problemet er, at det ikke rigtig er nyttigt. Vi kender ikke den bedste flise at tage, når grønne fliser støder op til hinanden.Så vores agent kan falde i en uendelig løkke ved at prøve at finde slottet!

Introduktion til Q-tabellen

Her er en anden strategi: Opret en tabel, hvor vi beregner den maksimale forventede fremtidige belønning for hver handling i hver stat.

Takket være det ved vi, hvad der er den bedste handling at tage for hver stat.

Hver tilstand (flise) tillader fire mulige handlinger. Disse bevæger sig til venstre, højre, op eller ned.

Med hensyn til beregning kan vi omdanne dette gitter til en tabel.

Dette kaldes en Q-tabel ("Q" for "kvalitet" af handlingen). Kolonnerne er de fire handlinger (venstre, højre, op, ned). Rækkerne vil være staterne. Værdien af ​​hver celle vil være den maksimale forventede fremtidige belønning for den givne tilstand og handling.

Hver Q-tabel-score vil være den maksimale forventede fremtidige belønning, som jeg får, hvis jeg tager den handling i den tilstand med den bedste politik.

Hvorfor siger vi "med den givne politik?" Det er fordi vi ikke implementerer en politik. I stedet forbedrer vi bare vores Q-tabel for altid at vælge den bedste handling.

Tænk på dette Q-bord som et spil "snydeark." Takket være det ved vi for hver stat (hver linje i Q-tabellen), hvad der er den bedste handling at tage ved at finde den højeste score i den linje.

Ja! Vi løste slotsproblemet! Men vent ... Hvordan beregner vi værdierne for hvert element i Q-tabellen?

For at lære hver værdi af denne Q-tabel bruger vi Q-læringsalgoritmen.

Q-læringsalgoritme: læring af Action Value-funktionen

Handlingsværdifunktionen (eller "Q-funktion") tager to input: "tilstand" og "handling." Det returnerer den forventede fremtidige belønning for denne handling i denne stat.

Vi kan se denne Q-funktion som en læser, der ruller gennem Q-tabellen for at finde den linie, der er knyttet til vores tilstand, og den kolonne, der er knyttet til vores handling. Det returnerer Q-værdien fra den matchende celle. Dette er den "forventede fremtidige belønning."

Men inden vi udforsker miljøet, giver Q-tabellen den samme vilkårlige faste værdi (det meste af tiden 0). Når vi udforsker miljøet , vil Q-tabellen give os en bedre og bedre tilnærmelse ved iterativt at opdatere Q (s, a) ved hjælp af Bellman-ligningen (se nedenfor!).

Q-læringsalgoritmeprocessen

Trin 1: Initialiser Q-værdier

Vi bygger en Q-tabel med m cols (m = antal handlinger) og n rækker (n = antal stater). Vi initialiserer værdierne til 0.

Trin 2: For livet (eller indtil læring er stoppet)

Trin 3 til 5 gentages, indtil vi har nået et maksimalt antal episoder (angivet af brugeren), eller indtil vi manuelt stopper træningen.

Trin 3: Vælg en handling

Vælg en handling a i den aktuelle tilstand s baseret på de aktuelle estimater af Q-værdi.

Men ... hvilken handling kan vi tage i starten, hvis hver Q-værdi er lig med nul?

Det er her den efterforskning / udnyttelse, som vi talte om i den sidste artikel, vil være vigtig.

Ideen er, at i starten,vi bruger epsilon-grådige strategi:

  • 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

Vi lavede en video, hvor vi implementerer en Q-læringsagent, der lærer at spille Taxi-v2 med Numpy.

Nu hvor vi ved, hvordan det fungerer, implementerer vi Q-læringsalgoritmen trin for trin. Hver del af koden forklares direkte i Jupyter-notesbogen nedenfor.

Du kan få adgang til det i Deep Reinforcement Learning Course repo.

Eller du kan få adgang til det direkte på Google Colaboratory:

Q * Læring med Frozen Lake

colab.research.google.com

Et resumé ...

  • Q-læring er en værdibaseret algoritme til forstærkningslæring, der bruges til at finde den optimale politik til valg af handling ved hjælp af aq-funktionen.
  • Den evaluerer, hvilken handling der skal udføres baseret på en handlingsværdifunktion, der bestemmer værdien af ​​at være i en bestemt tilstand og tage en bestemt handling i den tilstand.
  • Mål: maksimere værdifunktionen Q (forventet fremtidig belønning givet en tilstand og handling).
  • 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

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 5: En introduktion til Advantage Actor Kritiske metoder: lad os spille Sonic the Hedgehog!

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

Del 7: Nysgerrighedsdrevet læring gjort let del I