Es ist dieses $ Q $ -Lernen, das diese Statuswertfunktion durch Wiederholen von Episoden (Spielen) aktualisiert und die optimale Strategie sucht.

Mountain Car Regeln

In dieser Umgebung endet das Spiel, wenn die Position des Autos die Position der Flagge auf der rechten Seite erreicht. Wenn Sie es nicht erreichen, erhalten Sie für jede Aktion, die Sie ausführen, eine Belohnung von -1. Wenn Sie das Ziel nach 200 Aktionen nicht erreichen, ist das Spiel beendet. In diesem Fall haben Sie eine Belohnung von -200 erhalten. Mit anderen Worten, Sie werden darauf trainiert, eine Belohnung von mehr als -200 zu erhalten.

Die Aktionen sind auf drei begrenzt: nach links bewegen: 0, nicht bewegen: 1, nach rechts bewegen: 2.

Vorbereitung

Ich habe verschiedene Dinge in Google Colab eingefügt, um den Zustand zu beschreiben, aber am Ende muss ich nur noch ins Fitnessstudio.

bash

#Installation im Fitnessstudio
$ pip install gym
#Nicht benötigt(Empfohlen bei Verwendung von Colab)
$apt update
$apt install xvfb
$apt-get -qq -y install libcusparse8.0 libnvrtc8.0 $ibnvtoolsext1 > /dev/null
$ln -snf /usr/lib/x86_64-linux-gnu/libnvrtc-builtins.so.8.0 /usr/lib/x86_64-linux-gnu/libnvrtc-builtins.so

$apt-get -qq -y install xvfb freeglut3-dev ffmpeg> /dev/null
$pip install pyglet
$pip install pyopengl
$pip install pyvirtualdisplay

Bibliotheksimport

Einige von ihnen werden nicht benötigt, daher können Sie sie entsprechend auswählen.

import gym
from gym import logger as gymlogger
from gym.wrappers import Monitor
gymlogger.set_level(40) #error only
import tensorflow as tf
import numpy as np
import random
import matplotlib
import matplotlib.pyplot as plt
%matplotlib inline
import math
import glob
import io
import base64
from IPython.display import HTML

Q Lernimplementierung

Ich beziehe mich auf Github für die Arten von Aktionen und die Verwendung der Umgebung. GitHub MountainCar

class Q:
    def __init__(self, env):
        self.env = env
        self.env_low = self.env.observation_space.low #Minimale Position und Geschwindigkeit
        self.env_high = self.env.observation_space.high #Maximale Position und Geschwindigkeit
        self.env_dx = (self.env_high - self.env_low) / 40 #In 50 gleiche Teile teilen
        self.q_table = np.zeros((40,40,3))
        
    def get_status(self, _observation):
        position = int((_observation[0] - self.env_low[0])/self.env_dx[0])
        velocity = int((_observation[1] - self.env_low[1])/self.env_dx[1])
        return position, velocity
    
    def policy(self, s, epsilon = 0.1):
        if np.random.random() <= epsilon:
            return np.random.randint(3)
        else:
            p, v = self.get_status(s)
            if self.q_table[p][v][0] == 0 and self.q_table[p][v][1] == 0 and self.q_table[p][v][2] == 0:
                return np.random.randint(3)
            else:
                return np.argmax(self.q_table[p][v])
    
    def learn(self, time = 5000, alpha = 0.4, gamma = 0.99):
        log = []
        for j in range(time):
            total = 0
            s = self.env.reset()
            done = False
            
            while not done:
                a = self.policy(s)
                next_s, reward, done, _ = self.env.step(a)
                total += reward

                p, v = self.get_status(next_s)
                G = reward + gamma * max(self.q_table[p][v])
                
                p,v = self.get_status(s)
                self.q_table[p][v][a] += alpha*(G - self.q_table[p][v][a])
                s = next_s

            log.append(total)
            if j %100 == 0:
              print(str(j) + " ===total reward=== : " + str(total))
        return plt.plot(log)

    def show(self):
        s = self.env.reset()
        img = plt.imshow(env.render('rgb_array'))
        done = False
        while not done:
          p, v = self.get_status(s)
          s, _, done, _ = self.env.step(self.policy(s))
          display.clear_output(wait=True)
          img.set_data(env.render('rgb_array'))
          plt.axis('off')
          display.display(plt.gcf())
                
        self.env.close()

Der Handhabungszustand $ s $ enthält die aktuelle Position des Fahrzeugs (Position) und die aktuelle Geschwindigkeit (Geschwindigkeit). Da beide kontinuierliche Werte annehmen, werden sie mit der Funktion get_status auf diskrete Werte (40, 40) gesetzt. q_table ist der Speicherort der Zustandswertfunktion, die das Produkt jedes Zustands (40, 40) nach Art der Aktion (3) ist.

env = gym.make('MountainCar-v0')
agent = Q(env)
agent.learn()

Nachdem ich ungefähr 5.000 Mal gelernt habe, hat sich die Anzahl der Male, die ich mein Ziel erreichen kann, erhöht.

Übrigens, wenn Sie die Animation mit Google Colab überprüfen möchten,

from IPython import display
from pyvirtualdisplay import Display
import matplotlib.pyplot as plt

d = Display()
d.start()

agent.show()

Sie können es in sehen.

Impressionen

Dieses Mal ist die Erklärung ziemlich kompliziert, daher werde ich sie schrittweise aktualisieren. Wir werden weiterhin Informationen verbreiten, während wir mehr mit Gym spielen. wir sehen uns!