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

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

Sidste gang lærte vi om Q-Learning: en algoritme, der producerer en Q-tabel, som en agent bruger til at finde den bedste handling at tage, givet en tilstand.

Men som vi vil se, kan produktion og opdatering af en Q-tabel blive ineffektiv i store statslige rummiljøer.

Denne artikel er den tredje del af en række blogindlæg om dyb forstærkningslæring. For mere information og flere ressourcer, se kursusplanen.

I dag opretter vi et Deep Q Neural Network. I stedet for at bruge en Q-tabel implementerer vi et neuralt netværk, der tager en tilstand og tilnærmer Q-værdier for hver handling baseret på denne tilstand.

Takket være denne model vil vi være i stand til at oprette en agent, der lærer at spille Doom!

I denne artikel lærer du:

  • Hvad er Deep Q-Learning (DQL)?
  • Hvad er de bedste strategier til brug med DQL?
  • Sådan håndteres problemet med tidsmæssig begrænsning
  • Hvorfor bruger vi gentagelse af erfaring
  • Hvad er matematikken bag DQL
  • Sådan implementeres det i Tensorflow

Tilføjelse af 'Deep' til Q-Learning

I den sidste artikel oprettede vi en agent, der spiller Frozen Lake takket være Q-læringsalgoritmen.

Vi implementerede Q-læringsfunktionen til at oprette og opdatere en Q-tabel. Tænk på dette som et "snydeark" for at hjælpe os med at finde den maksimale forventede fremtidige belønning for en handling, givet en nuværende tilstand. Dette var en god strategi - men dette er ikke skalerbart.

Forestil dig hvad vi skal gøre i dag. Vi opretter en agent, der lærer at spille Doom. Doom er et stort miljø med et gigantisk statsrum (millioner af forskellige stater). Oprettelse og opdatering af en Q-tabel til dette miljø ville slet ikke være effektiv.

Den bedste idé i dette tilfælde er at oprette et neuralt netværk, der, givet en tilstand, tilnærmer de forskellige Q-værdier for hver handling.

Hvordan fungerer Deep Q-Learning?

Dette vil være arkitekturen i vores Deep Q Learning:

Dette kan virke komplekst, men jeg forklarer arkitekturen trin for trin.

Vores Deep Q Neural Network tager en stak på fire billeder som input. Disse passerer gennem dets netværk og udsender en vektor med Q-værdier for hver mulig handling i den givne tilstand. Vi er nødt til at tage den største Q-værdi af denne vektor for at finde vores bedste handling.

I begyndelsen klarer agenten sig virkelig dårligt. Men over tid begynder det at forbinde rammer (stater) med de bedste handlinger at gøre.

Forbehandlingsdel

Forbehandling er et vigtigt skridt. Vi ønsker at reducere kompleksiteten i vores stater for at reducere den beregningstid, der kræves til træning.

For det første kan vi gråtoner hver af vores stater. Farve tilføjer ikke vigtige oplysninger (i vores tilfælde er vi bare nødt til at finde fjenden og dræbe ham, og vi har ikke brug for farve for at finde ham). Dette er en vigtig besparelse, da vi reducerer vores tre farvekanaler (RGB) til 1 (gråtoner).

Derefter beskærer vi rammen. I vores eksempel er det ikke rigtig nyttigt at se taget.

Derefter reducerer vi størrelsen på rammen, og vi stabler fire underrammer sammen.

Problemet med tidsmæssig begrænsning

Arthur Juliani giver en fantastisk forklaring om dette emne i sin artikel. Han har en klog idé: at bruge LSTM neurale netværk til at håndtere problemet.

Jeg synes dog, det er bedre for begyndere at bruge stablede rammer.

Det første spørgsmål, du kan stille, er, hvorfor vi stable rammer sammen?

Vi stabler rammer sammen, fordi det hjælper os med at håndtere problemet med tidsmæssig begrænsning.

Lad os tage et eksempel i spillet Pong. Når du ser denne ramme:

Kan du fortælle mig, hvor bolden skal hen?

Nej, fordi en ramme ikke er nok til at have en følelse af bevægelse!

Men hvad hvis jeg tilføjer yderligere tre rammer? Her kan du se, at bolden går til højre.

Det er det samme for vores Doom-agent. Hvis vi kun giver ham en ramme ad gangen, har den ingen idé om bevægelse. Og hvordan kan den træffe en korrekt beslutning, hvis den ikke kan bestemme, hvor og hvor hurtigt genstande bevæger sig?

Brug af konvolutionsnetværk

Rammerne behandles af tre foldningslag. Disse lag giver dig mulighed for at udnytte rumlige forhold i billeder. Men også, fordi rammer er stablet sammen, kan du udnytte nogle rumlige egenskaber på tværs af disse rammer.

Hvis du ikke er fortrolig med foldning, skal du læse denne fremragende intuitive artikel af Adam Geitgey.

Hvert foldelag bruger ELU som en aktiveringsfunktion. ELU har vist sig at være en god aktiveringsfunktion til foldningslag.

Vi bruger et fuldt tilsluttet lag med ELU-aktiveringsfunktion og et outputlag (et fuldt tilsluttet lag med en lineær aktiveringsfunktion), der producerer Q-værdianslaget for hver handling.

Experience Replay: gør mere effektiv brug af observeret oplevelse

Experience replay hjælper os med at håndtere to ting:

  • Undgå at glemme tidligere oplevelser.
  • 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.

Lad os implementere vores Deep Q Neural Network

Vi lavede en video, hvor vi implementerer en dyb Q-læringsagent med Tensorflow, der lærer at spille Atari Space Invaders? ️ ?.

Nu hvor vi ved, hvordan det fungerer, implementerer vi vores Deep Q Neural Network trin for trin. Hvert trin og hver del af koden forklares direkte i nedenstående Jupyter-notesbog.

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

Det er alt! Du har lige oprettet en agent, der lærer at spille Doom. Fantastisk!

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, tilføje faste Q-værdier, ændre læringshastigheden, brug et hårdere miljø (såsom Health Gathering) ... og så videre. Hav det sjovt!

I den næste artikel vil jeg diskutere de sidste forbedringer inden for dyb Q-læring:

  • Faste Q-værdier
  • 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

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