[PYTHON] Ich lernte die Grundlagen des intensiven Lernens und spielte mit Cart Pole (Implementierung von einfachem Q-Lernen).

Einführung

Ich habe maschinelles Lernen und Statistik studiert. Unter ihnen habe ich das Lernen zur Stärkung des Lernens nicht sehr gut studiert, deshalb habe ich mein Verständnis mit der Implementierung vertieft. 　 Die Referenzmaterialien sind wie folgt.

• Praktisches maschinelles Lernen mit Scikit-Learn und TensorFlow

• [Deep Learning Lehrbuch Deep Learning G Test (Generalist) Offizieller Text](https://www.amazon.co.jp/%E6%B7%B1%E5%B1%A4%E5%AD%A6%E7%BF % 92% E6% 95% 99% E7% A7% 91% E6% 9B% B8-% E3% 83% 87% E3% 82% A3% E3% 83% BC% E3% 83% 97% E3% 83% A9% E3% 83% BC% E3% 83% 8B% E3% 83% B3% E3% 82% B0-G% E6% A4% 9C% E5% AE% 9A-% E3% 82% B8% E3% 82 % A7% E3% 83% 8D% E3% 83% A9% E3% 83% AA% E3% 82% B9% E3% 83% 88-% E5% 85% AC% E5% BC% 8F% E3% 83% 86% E3% 82% AD% E3% 82% B9% E3% 83% 88 / dp / 4798157554)

• Implementierung und Erklärung von Q-Learning mit CartPole [Stärkung des Lernens mit Phython: Teil 1]

Überblick über verbessertes Lernen

Reinforcement Learning (RL) ist eine der Methoden des maschinellen Lernens, die die optimale Systemsteuerung durch Ausprobieren durch das System selbst realisiert.

Alpha Go ist berühmt.

In Bezug auf die Klassifizierung wird es als ** anders als das Lernen mit / ohne Lehrer ** positioniert. Es ist sinnlich, ohne Lehrer zu lernen, aber es scheint anders zu sein.

Die folgende Abbildung ist eine schematische Darstellung. In einer bestimmten Umgebung lernen wir die Optimierung der Maßnahmen zur Maximierung der Zielbelohnung (Punktzahl) als Modell.

Diese Aktion

• Blockbruch → Nach links und rechts bewegen
• Gehe zu → Position, um den Stein zu treffen
• Mario (2D) → Bewegen Sie sich nach links, rechts, oben und unten

Es hängt von dem Spiel ab, das Sie lernen möchten.

Obwohl die Forschung selbst in den 1990er Jahren aktiv betrieben wurde, war es schwierig auszudrücken, wie man "Zustand" ausdrückt und wie man ihn mit "Verhalten" auf der Grundlage dieses "Zustands" verbindet, und die Dynamik der Forschung nahm in den 2000er Jahren ab. Es scheint.

Tiefes Verstärkungslernen

Als Antwort auf dieses Problem führte DeepMind 2013 Block Breaking by Enhanced Learning ** in Kombination mit einem Convolutional Neural Network (CNN) ein. Es wurde veröffentlicht und erhielt eine große Resonanz.

Es heißt DQN (Deep Q-Network), weil es ** Q-Lernen (Q-Lernen) ** und Deep Learning mit der hier verwendeten Methode des verstärkenden Lernens kombiniert. 　 ** In dieser Implementierung werden wir dies jedoch mit einfachem Q-Lernen tun. ** Ab dem nächsten Mal möchte ich eine Implementierungsversion mit DQN erstellen. ..

Wagenstange implementieren

Dieses Mal werden wir uns mit ** Cart Pole ** befassen, einer MNIST-ähnlichen Existenz des verstärkenden Lernens. Es hat einen Stab auf einer Riemenscheibe, der eindimensionale Bewegungen ausführt (links und rechts). Es ist ein Inhalt, die Bewegung der Riemenscheibe zu lernen, damit dieser Stab nicht herunterfällt.

Es ist sehr einfach. ** Die Statusparameter sind die folgenden 4 **.

• Wagenposition (-2,4 bis +2,4)
• Wagengeschwindigkeit (-inf bis + inf): Unendlich
• Polwinkel (-41,8 ° bis + 41,8 °): Reduzieren, wenn der Absolutwert 40 oder mehr beträgt
• Polgeschwindigkeit (-inf ~ + inf)

Andererseits sind ** Verhaltensparameter ** die folgenden zwei.

• Wagen fährt nach links (0)
• Der Wagen fährt nach rechts (1)

Sie erhalten 1 Belohnung, solange der Ball nicht fällt. Eine Episode ist auch der Zeitraum bis zum Ende eines Spiels. Und

• Erfolg, wenn Sie 195 oder mehr Belohnungen hintereinander für 100 Folgen erhalten
• Bis zu 200 Episodenzeitschritte

Wird besorgt.

Wenn Sie es einfach bewegen

Machen Sie einfach "np.random.choice ([0,1])", ohne sich um irgendetwas zu kümmern, und bewegen Sie "0" oder "1" nach dem Zufallsprinzip. Was passiert dann?

import gym
import numpy as np

env = gym.make('CartPole-v0')

goal_average_steps = 195
max_number_of_steps = 200
num_consecutive_iterations = 100
num_episodes = 200
last_time_steps = np.zeros(num_consecutive_iterations)

for episode in range(num_episodes):
    #Umgebungsinitialisierung
    observation = env.reset()

    episode_reward = 0
    for t in range(max_number_of_steps):
        #CartPole zeichnen
        env.render()
        if env.viewer == None:
            env.render()
        #Zufällige Auswahl der Aktion
        action = np.random.choice([0, 1])

        #Handeln Sie und erhalten Sie Feedback
        observation, reward, done, info = env.step(action)
        episode_reward += reward

        if done:
            print('%d Episode finished after %d time steps / mean %f' % (episode, t + 1,
                last_time_steps.mean()))
            last_time_steps = np.hstack((last_time_steps[1:], [episode_reward]))
            break

    if (last_time_steps.mean() >= goal_average_steps): #Erfolg, wenn die letzten 100 Folgen 195 oder höher sind
        print('Episode %d train agent successfuly!' % episode)
        break

Dann wird es wie folgt angezeigt.

185 Episode finished after 21 time steps / mean 21.350000
186 Episode finished after 23 time steps / mean 21.390000
187 Episode finished after 22 time steps / mean 21.510000
188 Episode finished after 39 time steps / mean 21.420000
189 Episode finished after 13 time steps / mean 21.320000
190 Episode finished after 9 time steps / mean 21.160000
191 Episode finished after 26 time steps / mean 20.980000
192 Episode finished after 17 time steps / mean 21.100000
193 Episode finished after 94 time steps / mean 21.120000
194 Episode finished after 15 time steps / mean 21.870000
195 Episode finished after 26 time steps / mean 21.880000
196 Episode finished after 13 time steps / mean 21.970000
197 Episode finished after 13 time steps / mean 21.940000
198 Episode finished after 31 time steps / mean 21.760000
199 Episode finished after 23 time steps / mean 21.950000

Sie können sehen, dass es nach etwa Dutzenden von Zeitschritten bricht. Ich verstehe, dass die Anzahl nicht steigt, weil ich nicht gelernt habe.

Lernen Sie mit Q Learning

Jetzt lernen wir mit Q Learning.

Die Schlüsselidee hierbei ist, einen Index festzulegen, um die nächste Aktion auszuwählen, die in einer bestimmten Situation ausgeführt werden soll. Dieser Wert wird als Q-Wert bezeichnet. Programmatisch ist es als Q_table definiert und hat die folgende Matrix.

In diesem Fall bilden $ 4 ^ 4 = 256 $ und die linken und rechten Aktionen $ 2 $ bilden eine $ 256 x 2 $ Matrix, da es vier Zustände gibt, in denen die Zustände des Wagens und der Stange unten jeweils in vier unterteilt sind.

• Wagenposition (-2,4 bis +2,4)
• Wagengeschwindigkeit (-inf bis + inf): Unendlich
• Polwinkel (-41,8 ° bis + 41,8 °): Reduzieren, wenn der Absolutwert 40 oder mehr beträgt
• Polgeschwindigkeit (-inf ~ + inf)

Wir werden diesen Q-Wert für jede Aktion verbessern. Je größer der Q-Wert ist, desto einfacher ist die Auswahl. Wenn Sie diesen Q-Wert so erhöhen, dass sich die Belohnung erhöht, wird Ihr Verhalten verbessert.

Die Aktualisierung dieses Q-Wertes ist übrigens wie folgt.

Q(s, a) = (1 - \alpha)Q(s, a) + \alpha(R(s, a) + \gamma max_{a'} E[Q(s', a')])

Hier

• $ Q (s, a) $ State s, Wert, um Maßnahmen zu ergreifen a
• $ α $ Lernrate
• $ γ $ Diskontsatz
• $ max_ {a '} E [Q (s', a ')] $ Maximaler Wert des Q-Werts von Aktionen, die beim nächsten Mal ausgewählt werden können

Es wird sein.

Wenn dies implementiert ist, wird es wie folgt sein.

def get_action(state, action, observation, reward):
    next_state = digitize_state(observation)
    next_action = np.argmax(q_table[next_state])

    #Q-Tabelle aktualisieren
    alpha = 0.2
    gamma = 0.99
    q_table[state, action] = (1 - alpha) * q_table[state, action] +\
            alpha * (reward + gamma * q_table[next_state, next_action])

    return next_action, next_state

for episode in range(num_episodes):
    #Umgebungsinitialisierung
    observation = env.reset()

    state = digitize_state(observation)
    action = np.argmax(q_table[state])

    episode_reward = 0
    for t in range(max_number_of_steps):
        #CartPole zeichnen
        #env.render()

        #Handeln Sie und erhalten Sie Feedback
        observation, reward, done, info = env.step(action)

        #Aktionsauswahl
        action, state = get_action(state, action, observation, reward)
        episode_reward += reward

Damit konvergiert das Lernen tatsächlich in etwa 100 Versuchen und ist erfolgreich.

das Ende

Ich spielte mit dem Entwurf, das Lernen und Cart Pole zu stärken. Ich möchte auch DQN herausfordern.

Das vollständige Programm finden Sie weiter unten. https://github.com/Fumio-eisan/RL20200527