[PYTHON] [Stärkung des Lernens] Endlich die Menschen übertroffen! ?? Ich habe versucht, Agent57 (Keras-RL) zu erklären / zu implementieren.

Es ist ein Atari-Spiel, das häufig zur Bewertung des verstärkenden Lernens verwendet wird, aber es scheint, dass in allen 57 Spielen endlich eine Methode jenseits des Menschen aufgetaucht ist. Ich habe versucht, es sofort umzusetzen.

• Bitte beachten Sie, dass es nicht korrekt ist, da es Informationen im Internet sammelt und auf seine eigene Weise implementiert.
• Bitte beachten Sie, dass es zu Missverständnissen kommen kann (einige Teile werden möglicherweise nicht verstanden).

Ganzer Code

Der in diesem Artikel erstellte Code ist unten aufgeführt.

• github
• Google Colaboratory (mit Ausführungsergebnissen)

• Google Colaboratory scheint mit Multiprocessing nicht kompatibel zu sein, sodass nur 1 Schauspieler gelernt wird.)
• Erfahren Sie mehr über Mountain Car

Inhaltsverzeichnis

Bei der Konfiguration ist die erste Hälfte die technische Erklärung und die zweite Hälfte die Erklärung der Implementierung.

• Was ist Agent57?
• Erklärung der NGU (niemals aufgeben)
• Über interne Belohnungen
• Maßnahmen gegen POMDP (UVFA und Retrace)
• Erklärung von Agent57
• Über die Aktionswertfunktion (Q-Funktion)
• Über den Meta Controller
• Implementierung
• Implementierung interner Belohnungen
• Implementierung der Erkennungsrichtlinie
• Implementierung des Aktionswertfunktionsmodells (Q-Funktion)

Einführung

Agent57 ist eine sogenannte Lernmethode zur Verstärkung der DQN-Serie. Ich habe bereits über die Technologie bis Agent 57 der DQN-Serie geschrieben, also zögern Sie bitte nicht

• [[Stärkung des Lernens] Wir werden einen Algorithmus zur Stärkung des Lernens mit OpenAI Gym x Keras-rl (Vorbereitung)] implementieren (https://qiita.com/pocokhc/items/a8120b0abd5941dd7a9f).
• [Stärkung des Lernens] Wir werden einen Algorithmus zur Stärkung des Lernens mit OpenAI Gym x Keras-rl (Q-Lernen) implementieren.
• [Stärkung des Lernens] Wir werden einen Algorithmus zur Stärkung des Lernens mit OpenAI Gym x Keras-rl (DQN-Ausgabe) implementieren.
• [Lernen stärken] Rainbow mit Keras-rl implementieren / erklären
• [Lernen stärken] Ape-X mit Keras-rl implementieren / erklären (parallele Programmierung)
• [Lernen stärken] Ich habe R2D2 implementiert / erklärt, das 2018 angeblich das stärkste sein soll
• [Stärkung des Lernens] R2D2-Implementierung / Erklärung Rachekommentar (Keras-RL)
• [Lernen stärken] Ich habe R2D3 (Keras-RL) implementiert / erklärt

Über Agent 57

Die 57 Spiele von Atari2600 werden häufig als Indikatoren für das verstärkte Lernen verwendet, aber schließlich haben alle 57 Spiele Methoden des verstärkten Lernens ergeben, die die menschliche Leistung übertreffen. Es gab Spiele wie Montezumas Revenge, die mit der vorhandenen Methode schwer zu erlernen waren, aber Agent57 scheint in der Lage zu sein, richtig zu lernen.

Nachfolgend finden Sie einen Vergleich der im Deep Mind-Artikel zitierten Methoden.

Ich fand F (ApeX) und G (R2D2) erstaunlich, aber darüber hinaus ist die Leistung überwältigend.

·Referenz Agent57: Outperforming the human Atari benchmark Atari Complete Conquest! Atari57 Was ist Agent57, das Menschen in allen Spielen übertrifft!?

Bis zu Agent57

(Abbildung aus dem Deep Mind Artikel)

Dieser Artikel beschreibt NGU (Never Give Up) und Agent57.

Wie in der Abbildung gezeigt, ist Agent 57 eine Verbesserung der vorhandenen DQN-Methode. Ich hoffe, Sie können in meinen früheren Artikeln nach Inhalten suchen, die Sie über frühere Methoden interessieren.

Die wichtigste Änderung bei NGU / Agent57 besteht darin, dass es sich auf Exploration und Exploitation konzentriert und einen Mechanismus einführt, der eine effiziente Exploration auch in Umgebungen ermöglicht, in denen es schwierig ist, Belohnungen zu erhalten. Darüber hinaus wurden verschiedene Methoden angewendet, weshalb ich sie nacheinander erläutern möchte.

NGU(Never Give Up)

Es gibt einen Kompromiss zwischen der Erkundung eines unbekannten Gebiets und der Erlangung einer Belohnung (Ausbeutung) beim intensiven Lernen. Es gab ein Problem, dass die vorhandene Methode in Spielen, in denen die Belohnung spärlich war, nicht gut lernen konnte (es dauerte lange, bis die Belohnung erhalten wurde). Daher realisiert NGU eine effiziente Suche, indem der Belohnung eine interne Belohnung (intrinsische Belohnung) hinzugefügt wird.

Interne Belohnungen erfüllen die folgenden drei Bedingungen.

+1 Vermeiden Sie es, denselben Zustand in einer Episode zu besuchen (stärken)

• Vermeiden Sie es, während des Trainings dieselbe Situation zu besuchen (schwach)
• Ignorieren Sie sich ändernde Zustände unabhängig vom Verhalten des Agenten

·Referenz (Papier) Niemals aufgeben: Directed Exploration Strategies lernen [Gib niemals auf! Atari Stärkung des Suchlernens, ohne auch in schwierigen Umgebungen aufzugeben, was zu völliger Herrschaft führt!](Https://ai-scholar.tech/articles/reinforcement-learning/never-give-up-ai- 394)

Eigenbelohnung

NGU definiert Belohnungen durch Hinzufügen interner Belohnungen (Intrinsic Rewards) zu externen Belohnungen (Extrinsic Rewards).

Wobei $ r ^ e_t $ die externe Belohnung ist, $ r ^ i_t $ die interne Belohnung ist und $ \ beta $ die Konstante ist, die die interne Belohnung gewichtet. Dann werden wir mit $ r_ {t} $ (erweiterte Belohnung) trainieren, was die Summe davon ist.

Schauen wir uns die internen Belohnungen an. (Die Abbildung stammt aus dem Papier und wird im Folgenden als Abbildung A bezeichnet.)

Interne Belohnungen werden aus dem Modul für lebenslange Neuheiten (grüner Rahmen auf der rechten Seite von Abbildung A) und dem Episodenspeicher (roter Rahmen auf der rechten Seite von Abbildung A) erstellt.

Generieren Sie einen Wert von $ \ alpha_t $ aus dem lebenslangen Speicher und $ r ^ {episoden} _t $ aus dem Episodenspeicher und synthetisieren Sie diese wie folgt.

In Japanisch geschrieben, interne Belohnung = Episodenspeicher x Lebenszeitspeicher.

• Wenn der Lebensdauerspeicher jedoch 1 oder weniger beträgt, ist er 1, und wenn er L oder mehr ist, ist er L.
• L ist eine Konstante, die die maximale Skalenbelohnung darstellt (L = 5 im Papier)

Beginnen wir mit dem Episodenspeicher.

Episodenspeicher (episodisches Neuheitsmodul)

Im Episodenspeicher wird die Belohnung so festgelegt, dass derselbe Status nicht in einer Episode besucht wird. Der Gesamtfluss ist wie folgt. (Entspricht dem roten Rahmen in Abb. A)

1. Verwenden Sie eine eingebettete Funktion (Einbettungsnetzwerk), um einen steuerbaren Zustand aus dem aktuellen Zustand auszugeben
2. Verwenden Sie aus dem steuerbaren Zustand und dem Episodenspeicher M die Methode der k-nächsten Nachbarn, um eine Annäherung an die Anzahl der Besuche im aktuellen Zustand zu erhalten.
3. Geben Sie den Episodenspeicher ($ r ^ {Episode} _t $) aus dem ungefähren Wert der Anzahl der Besuche aus
4. Fügen Sie dem Episodenspeicher einen steuerbaren Status hinzu

Die eingebettete Funktion und der ungefähre Wert der Anzahl der Besuche werden später beschrieben. Der Episodenspeicher wird zu Beginn einer Episode initialisiert. Dies scheint die Anzahl der Besuche innerhalb einer Episode zu bestimmen.

Eingebettete Funktion (Netzwerk einbetten)

Eingebettete Funktionen sind neuronale Netzwerkfunktionen, die steuerbare Zustände erzeugen.

Es sieht aus wie ein einfaches neuronales Netzwerk, das nur den aktuellen Zustand auf die p-Dimension komprimiert. Das Problem ist das Lernen, das wie folgt mit dem siamesischen Netzwerk verglichen wird.

(Diese Abbildung ist eine detaillierte Abbildung auf der linken Seite von Abbildung A)

Die Eingabe ist der vorherige Zustand und der aktuelle Zustand, und die Ausgabe ist die Wahrscheinlichkeit, dass jede Aktion ausgewählt wird. Kurz gesagt, es ist ein Netzwerk, das aus der Differenz zwischen dem vorherigen und dem aktuellen Status lernt, welche Aktion ausgeführt wurde.

Es scheint, dass dieses Netzwerk nur die Zustände lernt, die sich im Zusammenhang mit dem Verhalten ändern.

Referenz: [Deep Distance Learning] Gründliche Erklärung des siamesischen Netzwerks und des kontrastiven Verlusts

Ungefähre Anzahl der Besuche nach der k-Nachbarschaftsmethode

Der Episodenspeicher ($ r ^ {Episode} _t $) wird basierend auf der Anzahl der Besuche berechnet. Die Anzahl der Besuche wird berechnet, indem der Episodenspeicher und der aktuelle Zustand unter Verwendung der k-Nachbarschaftsmethode angenähert werden. Das Folgende ist eine Erklärung unter Verwendung einer Formel.

Der Episodenspeicher ($ r ^ {Episode} _t $) ist wie folgt.

$ n (f (x_t)) $ ist die Anzahl der Besuche. Die Anzahl der Besuche wird unter Verwendung der Kernelfunktion K angenähert und ist wie folgt.

c ist eine Konstante, die eine minimale Anzahl von Pseudobesuchen garantiert. (c = 0,001) K wird durch das k-Nachbarschaftsverfahren des speicherinternen steuerbaren Zustands und des aktuellen steuerbaren Zustands berechnet.

$ \ Epsilon $ ist eine kleine Konstante. ($ \ Epsilon $ = 0,001) d repräsentiert die euklidische Distanz und $ d ^ 2_m $ repräsentiert den gleitenden Durchschnitt der euklidischen Distanz.

Lebenslanges Neuheitsmodul

RND (Random Network Distillation) wird für den lebenslangen Speicher verwendet.

·Referenz Die Exploration durch zufällige Netzwerkdestillation wurde auf MountainCar getestet. (Papier) Exploration durch zufällige Netzwerkdestillation

Was die Erklärung von RND betrifft, wenn Sie beurteilen möchten, ob es sich in einem bestimmten Zustand um einen unbekannten Zustand handelt, zählen Sie normalerweise die Anzahl der Besuche und denken, je mehr Besuche Sie haben, desto bekannter ist der Zustand. RND hat jedoch eine Umkehridee. Die Analogie des Referenzblogs war gut, daher werde ich sie verwenden, aber bei RND werde ich zuerst eine Rubbelkarte vorbereiten. Die Karte ist zunächst mit Silberpapier bedeckt, wird aber bei jedem Besuch nach und nach abgekratzt. RND ist eine Methode, um zu beurteilen, wie unbekannt es ist, indem der Grad des Schabens betrachtet wird.

Um dies zu realisieren, müssen zwei neuronale Netze mit derselben Struktur vorbereitet werden. (A, B) Lassen Sie A im Ausgangszustand und B lernt, sich A zu nähern. Dieses Lernen von B entspricht dem Schaben von Silberpapier. Beim Vergleich von A und B ist der Fehler daher groß = der Ort, an dem nicht gesucht wurde, und der Fehler ist klein = der Ort, an dem gut gesucht wurde.

MDP und POMDP

Kehren wir zur Prämisse des intensiven Lernens zurück. Q-Learning basiert auf einem probabilistischen MDP-Modell (Markov-Bestimmungsprozess). Einfach ausgedrückt, wenn Sie eine Aktion in einem bestimmten Zustand ausführen, wechselt sie in einen zufälligen Zustand und Sie erhalten eine feste Belohnung. (Es ist ein allgemeines Modell des verstärkenden Lernens)

In NGU werden jedoch interne Belohnungen hinzugefügt. Selbst wenn Sie in denselben Status wechseln, ändern sich die Belohnungen. Daher sollte NGU als Modell für POMDP (Partial Observation Markov Determination Process) und nicht für MDP betrachtet werden.

·Referenz [Markov-Entscheidungsprozess (Wikipedia)](https://ja.wikipedia.org/wiki/%E3%83%9E%E3%83%AB%E3%82%B3%E3%83%95%E6%B1% BA% E5% AE% 9A% E9% 81% 8E% E7% A8% 8B) [Teilbeobachtung Markov-Entscheidungsprozess (Wikipedia)](https://ja.wikipedia.org/wiki/%E9%83%A8%E5%88%86%E8%A6%B3%E6%B8%AC%E3% 83% 9E% E3% 83% AB% E3% 82% B3% E3% 83% 95% E6% B1% BA% E5% AE% 9A% E9% 81% 8E% E7% A8% 8B)

Da POMDP jedoch viel schwieriger zu denken ist als MDP, hat NGU zwei Problemumgehungen eingeführt:

1. Geben Sie externe Belohnungen direkt in das Q-Netzwerk ein
2. Pflegen Sie eine interne Zustandsdarstellung, die den Verlauf aller Eingaben (Zustände, Aktionen und Belohnungen) in der Episode zusammenfasst

Da die Suchaktion der internen Belohnung direkt zur Belohnung hinzugefügt wird, kann die Suchaktion nicht einfach deaktiviert werden. Um dieses Problem zu lösen, schlägt NGU eine Methode vor, um gleichzeitig externe Belohnung und Erkundungsverhalten zu lernen.

UVFA(Universal Value Function Approximators)

DQN schätzt den Q-Wert im Allgemeinen, indem ein bestimmter Zustand als Eingabe verwendet wird. Hier ist UVFA eine Wertefunktion, die die Eingabe verallgemeinert, indem nicht nur der Status, sondern auch das Ziel hinzugefügt werden.

NGU verwendet diese UVFA, aber anstelle des Ziels wird $ \ beta $ (interne Belohnungsreflexionsrate: Suchrate) eingegeben. Auf diese Weise schlagen wir vor, gleichzeitig exploratives Verhalten zu lernen. Wenn $ \ beta = 0 $, können Sie das Ergebnis erhalten, wenn die Suche deaktiviert ist, und wenn $ \ beta> 0 $, können Sie das Ergebnis erhalten, wenn die Suche aktiviert ist.

·Referenz (Deep Mind Folie) Universal Value Function Approximators (Papier) Universal Value Function Approximators

Retrace

Q-Lernen verwendet beim TD-Lernen eine Suchmethode außerhalb der Richtlinien. (Umgekehrt ist Sarsa eine der On-Policy-Suchanfragen beim TD-Lernen.)

Der Unterschied besteht in der Bezugnahme auf den zu aktualisierenden Q-Wert. Im Fall von Off-Policy wird die Richtlinie nicht befolgt. (Beim Q-Lernen wird die Aktion mit dem maximalen Q-Wert ausgewählt.) Im Fall von On-Policy wird es gemäß der Police erworben. (Wenn Sie beispielsweise mit ε-gierig suchen, verwenden Sie auch ε-gierig als Referenzziel.)

Das Problem mit Off-Policy besteht darin, dass die Richtlinie, auf die Sie tatsächlich reagiert haben (Verhaltensrichtlinie), und die Richtlinie, die Sie lernen möchten (Zielrichtlinie), unterschiedlich sind. Wenn dies anders ist, konvergieren die Werte möglicherweise nie (unsicher). In Retraces Artikel gibt es vier Methoden, um dies zu lösen (vorhandene Methode 3). (2 + Retrace) wird verglichen und zeigt, dass Retrace überlegen ist.

Um es einfach auszudrücken: Retrace ist eine Methode, um eine Strategie basierend auf früheren Ergebnissen vorherzusagen und das Lernen anhand des Unterschieds zu steuern. (Die zur Steuerung des Lernens verwendeten Koeffizienten werden als Schnittspurkoeffizienten ($ c_s $) bezeichnet.)

NGU enthält Retrace.

·Referenz Stärkung des Lernens (10), das ich nicht mehr hören kann: Unterschied zwischen Sarsa und Q-Lernen On-Policy und Off-Policy zur Stärkung des Lernens (Papier zu Off-Policy 1) Q (λ) mit Off-Policy-Korrekturen (Artikel 2 über Off-Policy) Off-Policy-Lernen mit zeitlichen Unterschieden und Funktionsannäherung (Deep Mind Folie) Off-Policy Deep RL (Retraces Artikel) Sicheres und effizientes Lernen zur Stärkung außerhalb der Politik (Japanische Folie mit Retrace-Papier) sicheres und effizientes Lernen außerhalb der Politikverstärkung Grundlagen der Theorie des erweiterten Lernens 2 [Review] UCL_RL Lecture05 Model Free Control

Diskontsatz

Der Abzinsungssatz ($ \ gamma $) hängt von $ \ beta $ (Reflexionsrate der internen Belohnung) und Änderungen ab. Wenn $ \ beta = 0 $, dann ist $ \ gamma = max $, und wenn $ \ beta = max $, dann ist $ \ gamma = min $. (Insbesondere ist $ \ beta = 0 $ $ \ gamma = 0,997 $, $ \ beta = max $ ist $ \ gamma = 0,99 $)

Da der Einfluss externer Belohnungen während der Exploration gering ist, handelt es sich um einen Abzinsungssatz für die Anpassung.

Agent57

Wir konnten mit NGU eine effiziente Erkundung erreichen, aber in einigen Spielen konnten wir nur die gleiche Punktzahl erzielen wie bei einer einfachen zufälligen Erkundung. Einer der Nachteile von NGU ist auch, dass es unabhängig vom Lernfortschritt sucht.

Agent57 hat Folgendes vorgeschlagen und verbessert.

1. Einführung eines neuen Parameters, der externe und interne Belohnungen trennt, um das Lernen interner Belohnungen zu stabilisieren
2. Einführung eines Meta-Controllers und Einführung eines Mechanismus, mit dem die Suchrate nach Priorität ausgewählt werden kann.

(Papier) Agent57: Übertreffen des Atari Human Benchmark

Änderungen in der Architektur der Aktionswertfunktion (Q-Funktion)

Das Lernen kann an der NGU instabil sein. Es passiert, wenn die externen und internen Belohnungen unterschiedliche Skalenschwächen aufweisen oder wenn nur eine Belohnung im Vergleich zu anderen Belohnungen übermäßig reagiert.

Agent57 spekulierte, dass es schwierig sein würde, die Verhaltenswertfunktion zu lernen, wenn die Art der Belohnung zwischen externen und internen Belohnungen sehr unterschiedlich war, und schlug eine Änderung der Architektur der Verhaltenswertfunktion vor.

Insbesondere wird die Aktionswertfunktion in $ Q (x, a, j; \ theta ^ e) $ zum Lernen externer Belohnungen und $ Q (x, a, j; \ theta ^ i) $ zum Lernen interner Belohnungen gesetzt. Teilen Sie und finden Sie den Q-Wert mit der folgenden Formel. (Es scheint auf dem transformierten Bellman-Operator zu basieren)

$ \ Beta_j $ ist die Reflexionsrate (Suchrate) der internen Wertfunktion und h ist die Belman-Operatorfunktion? h ist nicht sehr gut verstanden, aber es ist dasselbe wie die Neuskalierungsfunktion von R2D2 und ist wie folgt.

Meta-Controller

NGU und Agent57 können jetzt die Suchrate ($ \ beta_j $) mithilfe interner Belohnungen festlegen.

In NGU wurde die Suchrate jedoch für jeden Schauspieler festgelegt. Wenn der Schauspieler beispielsweise 4 ist, sieht es wie folgt aus. (Wert ist vorläufig)

Schauspieler1: $ \ beta_j $ = 0 (keine Suche) Schauspieler2: $ \ beta_j $ = 0.1 (irgendwie suchen) Schauspieler3: $ \ beta_j $ = 0.2 (ein wenig suchen) Schauspieler 4: $ \ beta_j $ = 0,3 (mittelmäßige Suche)

Es ist besser, in der frühen Phase des Trainings einen höheren Wert für die Suchrate zu verwenden, aber es wird erwartet, dass es im Verlauf des Trainings besser ist, einen niedrigeren Wert zu verwenden. Daher schlug Agent57 einen Meta-Controller vor, um eine Methode zur Auswahl einer effizienten Suchrate anzuwenden.

Im Meta-Controller wird die Auswahl einer effizienten Suchrate mit dem Problem der mehrarmigen Banditen (MAB-Problem) verglichen, dessen Suchrichtlinie (Akteur in NGU) ausgewählt werden sollte, um die maximale Belohnung zu erhalten. Dies wird gelöst. (Die Belohnung bezieht sich hier auf die Summe der nicht abgezinsten externen Belohnungen innerhalb einer Episode.)

·Referenz Artikel, den ich zuvor geschrieben habe: [Lernen stärken] Mehrere Suchrichtlinien implementiert / erklärt und verglichen (Problem mit mehreren bewaffneten Banditen) Theorie und Algorithmus des mehrarmigen Banditenproblems Einführung in die Stärkung des Lernens: Mehrarmiges Banditenproblem

Mehrarmiges Banditenproblem (MAB-Problem)

Einfach ausgedrückt besteht das MAB-Problem darin, die Belohnung zu maximieren, wenn eine bestimmte Anzahl von Malen aus mehreren Slots (Armen) ausgewählt wird. Angenommen, Sie haben 4 Steckplätze (A, B, C, D). Was ist der beste Weg, um den maximalen Preis zu wählen, nachdem Sie 100 Mal einen Slot ausgewählt haben? Ist das Problem. Ich weiß nicht, mit welcher Wahrscheinlichkeit die vier Slots gewinnen werden.

Bei einem allgemeinen MAB-Problem ist die Wahrscheinlichkeit, einen Preis zu gewinnen, für jeden Slot konstant. (Es ändert sich nicht nach der ersten Entscheidung) Mit Agent57 ändert sich jedoch die Wahrscheinlichkeit, eine Belohnung (Belohnungsergebnis) zu erhalten. Daher ist der Meta-Controller ein wenig entwickelt.

UCB-Methode mit Schiebefenster

Agent57 verwendet die UCB-Methode als Algorithmus für MAB-Probleme. Da sich die Belohnung ändert, kann die UCB-Methode nicht so angewendet werden, wie sie ist. Daher schlagen wir vor, die UCB-Methode nur für die letzten Episoden zu verwenden. Dies wird in der Veröffentlichung als UCB-Methode mit Schiebefenster bezeichnet. Es ist dasselbe wie die UCB-Methode, außer dass Sie nur die letzten Episoden sehen.

Implementierung

Eigenbelohnung

Eingebettete Funktion (Netzwerk einbetten)

Es ist notwendig, ein spezielles neuronales Netzwerk zu erstellen, in dem die Netzwerkstruktur zum Zeitpunkt des Lernens und die Netzwerkstruktur zum Zeitpunkt der Verwendung unterschiedlich sind. Erstens ist die eingebettete Funktion zur Werterfassung.

Die in diesem Artikel verwendete Bildverarbeitungsschicht wird in dem Papier nicht erwähnt. (Weil das Papier auf Bildeingabe basiert)

Als nächstes folgt die eingebettete Funktion zum Lernen.

Der Code, der die obige Abbildung implementiert, lautet wie folgt.

• Es wird ein Modell für die Bildeingabe sein
• Jede Schicht wird benannt, um das Gewicht zu teilen.

input_sequence =Anzahl der Eingaberahmen
input_shape =Eingabeformat
nb_actions =Anzahl der Aktionen

Eingebettete Funktion zur Werterfassung

c = input_ = Input(shape=(input_sequence,) + input_shape)
c = Conv2D(32, (8, 8), strides=(4, 4), padding="same", name="l0")(c)
c = Conv2D(64, (4, 4), strides=(2, 2), padding="same", name="l1")(c)
c = Conv2D(64, (3, 3), strides=(1, 1), padding="same", name="l2")(c)
c = Dense(32, activation="relu", name="l3")(c)
emb_model = Model(input_, c)

Eingebettete Funktion für das Training

#Machen Sie zwei Eingaben
c1 = input1 = Input(shape=(input_sequence,) + input_shape)
c2 = input2 = Input(shape=(input_sequence,) + input_shape)

#Erstellen Sie ein Netzwerk, während Sie Gewichte teilen
l = Conv2D(32, (8, 8), strides=(4, 4), padding="same", name="l0")
c1 = l(c1)
c2 = l(c2)
l = Conv2D(32, (4, 4), strides=(2, 2), padding="same", name="l1")
c1 = l(c1)
c2 = l(c2)
l = Conv2D(64, (3, 3), strides=(1, 1), padding="same", name="l2")
c1 = l(c1)
c2 = l(c2)
l = Dense(32, activation="relu", name="l3")
c1 = l(c1)
c2 = l(c2)

#Beitreten
c = Concatenate()([c1, c2])
c = Dense(128, activation="relu")(c)
c = Dense(nb_actions, activation="softmax")(c)

emb_train_model = Model([input1, input2], c)

#Optimierer aus dem Papier
model.compile(
    loss='mean_squared_error', 
    optimizer=Adam(lr=0.0005, epsilon=0.0001))

Obwohl es sich um eine Verlustfunktion handelt, gab es in der Arbeit nur eine Beschreibung, dass sie mit der wahrscheinlichsten Schätzmethode gelernt wurde. (Vielleicht…) Daher wird vorerst der durchschnittliche quadratische Fehler verwendet.

·Referenz Keras 'TPU-Technik im Dunkeln: So übertragen Sie die Koeffizienten eines Modells mit zwei Eingaben und eines Modells mit einer Eingabe untereinander Multi-Input-Multi-Output-Modell (Keras offiziell)

Als nächstes folgt der Code, der die Gewichte von emb_train_model nach emb_model kopiert.

def sync_embedding_model():
    for i in range(4):  #Schicht Einige Minuten drehen
        train_layer = emb_train_model.get_layer("l" + str(i))
        val_layer = emb_model.get_layer("l" + str(i))

        #Gewicht kopieren
        val_layer.set_weights(train_layer.get_weights())

Wir haben ein großartiges Modell mit nicht zusammenhängenden Eingaben und gemeinsamen Gewichten erstellt. .. ..

Eingebettete Funktionen lernen (Netzwerk einbetten)

Es scheint, dass es kaum in der Zeitung geschrieben ist ... Derzeit wird das Aktualisierungsintervall des Einbettungsziels einmal pro Episode geschrieben. Was ist ein Embeddings-Ziel ...

Vorläufig wurde die Lernmethode unter Verwendung des gleichen Beispiels wie das Training der Aktionswertfunktion ausgeführt, und die Synchronisation mit emb_train_model → emb_model wurde auf einmal pro Episode eingestellt.

batch_size =Chargengröße

def forward(observation):
    #Zeitpunkt des Lernens jedes Frames

    #Sammeln Sie zufällig Erfahrung für Batch aus dem Erfahrungsspeicher
    batchs = memory.sample(batch_size)

    #Formatieren Sie die Daten
    state0_batch = []   #Vorheriger Status
    state1_batch = []   #Nächster Zustand
    emb_act_batch = []
    for batch in batchs:
        state0_batch.append(batchs["Vorheriger Status"])
        state1_batch.append(batchs["Nächster Zustand"])

        #Die Aktion ist eine-Erstellen Sie Daten als heißen Vektor
        a = np_utils.to_categorical(
            batchs["Aktion"],
            num_classes=nb_actions
        )
        emb_act_batch.append(a)
    
    #Ausbildung
    emb_train_model.train_on_batch(
        [state0_batch, state1_batch],  #Es gibt zwei Eingänge, den vorherigen und den nächsten Status
        emb_act_batch                  #Der Lehrer ist Handlung
    )

def backward(self, reward, terminal):
    if terminal:
        #Am Ende der Episode synchronisieren
        sync_embedding_model()    

* Numpy weglassen

Holen Sie sich den Wert einer eingebetteten Funktion (Einbettungsnetzwerk)

Sie erhalten den Wert nur von emb_model.

state =Aktuellen Zustand
cont_state = emb_model.predict([state], batch_size=1)[0]

* Numpy weglassen

Berechnung der Episodenspeicherung

Glücklicherweise wurde der Pseudocode für die Berechnung hier in das Papier geschrieben. Es ist wie folgt, wenn es durch Python-ähnlichen Pseudocode ausgedrückt wird.

def calc_int_episode_reward(():
    state =Aktuellen Zustand
    k =Nummer in der k-Nachbarschaftsmethode(k=10)
    epsilon = 0.001
    c = 0.001
    cluster_distance = 0.008
    maximum_similarity = 8

    #Erhalten Sie den steuerbaren Status von der eingebetteten Funktion
    cont_state = embedding_network.predict(state, batch_size=1)[0]

    #Finde alle Elemente im Episodenspeicher und in der euklidischen Distanz
    euclidean_list = []
    for mem_cont_state in int_episodic_memory:
        euclidean = np.linalg.norm(mem_cont_state - cont_state)
        euclidean_list.append(euclidean)

    #Top k
    euclidean_list.sort()
    euclidean_list = euclidean_list[:k]

    #Euklidischer Abstand im Quadrat
    euclidean_list = np.asarray(euclidean_list) ** 2

    #Holen Sie sich den Durchschnitt
    ave = np.average(euclidean_list)

    #Ungefähre Anzahl der Besuche(Berechnung von Σ in der Formel)
    count = 0
    for euclidean in euclidean_list:
        d = euclidean / ave

        #Es gibt keine Erklärung in dem Papier, aber es ist im Pseudocode geschrieben ...
        #Wird eine bestimmte Entfernung in der kürzesten Entfernung zusammengefasst?
        d -= cluster_distance
        if d < euclidean_list[0]:
            d = euclidean_list[0]
        
        count += epsilon / (d+epsilon)
    s = np.sqrt(count) + c

    #Auch hier gibt es keine Erklärung, aber sind einige kleine Werte auf 0 gerundet?
    if s > maximum_similarity:
        episode_reward = 0
    else:
        episode_reward = 1/s

    #Steuerbarer Status zum Episodenspeicher hinzugefügt, nicht im Pseudocode des Papiers
    int_episodic_memory.append(cont_state)
    if len(int_episodic_memory) >= 30000:
        int_episodic_memory.pop(0)

    return episode_reward

Lebenslanges Neuheitsmodul

RND-Modell

Das Modell von RND ist wie folgt.

Die Ausgabe bedeutet nicht viel. Der Code, wenn es eine Bildverarbeitungsschicht gibt, ist wie folgt.

def build_rnd_model():
    #Eingabeebene
    c = input = Input(shape=(input_sequence,) + input_shape)

    #Bildverarbeitungsschicht
    c = Conv2D(32, (8, 8), strides=(4, 4), padding="same")(c)
    c = Conv2D(64, (4, 4), strides=(2, 2), padding="same")(c)
    c = Conv2D(64, (3, 3), strides=(1, 1), padding="same")(c)

    # Dense
    c = Dense(128)(c)

    model = Model(input, c)

    #Verlust, Optimierer aus dem Papier
    model.compile(
        loss='mean_squared_error', 
        optimizer=Adam(lr=0.0005, epsilon=0.0001))
    
    return model

# train_Modell ist Ziel_Es ist ein bildnahes Modell
rnd_target_model = build_rnd_model()
rnd_train_model = build_rnd_model()

RND lernen

Ich denke, das steht auch selten in der Zeitung ... Es verwendet dasselbe Beispiel wie das Erlernen der Aktionswertfunktion sowie der eingebetteten Funktion. (Ich habe es zum Lernen benutzt = ich habe es besucht (aber es kann ein wenig verdächtig sein ...))

def forward(observation):
    #Zeitpunkt des Lernens jedes Frames

    #Sammeln Sie zufällig Erfahrung für Batch aus dem Erfahrungsspeicher
    batchs = memory.sample(batch_size)

    #Formatieren Sie die Daten
    state0_batch = []   #Vorheriger Status
    state1_batch = []   #Nächster Zustand
    for batch in batchs:
        state0_batch.append(batchs["Vorheriger Status"])
        state1_batch.append(batchs["Nächster Zustand"])

    #Holen Sie sich den Wert des Ziels
    rnd_target_val = rnd_target_model.predict(state1_batch, batch_size)
    #Ausbildung
    rnd_train_model.train_on_batch(state1_batch, rnd_target_val)

* Numpy weglassen

Berechnung des Lebenszeitspeichers

In Bezug auf die Berechnungsformel des Lebensdauerspeichers wird zunächst der quadratische Fehler von rnd_target_model und rnd_train_model berechnet.

Basierend darauf wird der Lebensdauerspeicherabschnitt unter Verwendung der folgenden Formel berechnet.

Wobei $ \ sigma_e $ die Standardabweichung von $ err (x_t) $ und $ \ mu_e $ der Durchschnitt von $ err (x_t) $ ist.

Die Standardabweichung und der Durchschnitt sind herausgekommen ... Das Papier enthält keine Beschreibung zur Berechnung, aber um es zu berechnen, müssen Sie die vergangenen Ergebnisse speichern. Vorerst habe ich ein Array zum Speichern von $ err (x_t) $ erstellt. Ich mache jedoch eine Obergrenze, weil es ein Problem sein wird, wenn es unendlich hinzugefügt wird.

Unten ist der Code.

#---Variablen zur Berechnung
rnd_err_vals = []
rnd_err_capacity = 10_000

#---Berechnungsteil
def calc_int_lifelong_reward():
    state =Aktuellen Zustand

    #Holen Sie sich RND
    rnd_target_val = rnd_target_model.predict(state, batch_size=1)[0]
    rnd_train_val = rnd_train_model.predict(state, batch_size=1)[0]

    #Geben Sie einen quadratischen Fehler an
    mse = np.square(rnd_target_val - rnd_train_val).mean()
    rnd_err_vals.append(mse)
    if len(rnd_err_vals) > rnd_err_capacity:
        rnd_err_vals.pop(0)

    #Standardabweichung
    sd = np.std(rnd_err_vals)
    if sd == 0:
        return 1

    #durchschnittlich
    ave = np.average(rnd_err_vals)

    # life long reward
    lifelong_reward = 1 + (mse - ave)/sd

    return lifelong_reward

Berechnung der internen Belohnung

Die interne Belohnung ist die folgende Formel.

L = 5
episode_reward =Episodenspeicher
lifelong_reward =Abteilung für lebenslanges Gedächtnis

if lifelong_reward < 1:
    lifelong_reward = 1
if lifelong_reward > L:
    lifelong_reward = L

intrinsic_reward = episode_reward * lifelong_reward

Suchrate (β) und Diskontsatz (γ)

Die Suchrichtlinie wird durch ein Paar aus Suchrate (β) und Diskontsatz ($ \ gamma $) dargestellt und nach der folgenden Formel berechnet. Der Abzinsungssatz wird für NGU und Agent57 unterschiedlich berechnet. (Ich werde beide vorerst verlassen)

Erstens ist die Formel zur Berechnung der Suchrate.

\beta_i = \left\{
\begin{array}{ll}
0 \qquad (i = 0) \\
\beta \qquad (i = N-1) \\
\Beta ·\sigma(10\frac{2i-(N-2)}{N-2}) \quad (otherwise)
\end{array}
\right.

$ \ Sigma $ ist die Sigmoidfunktion und $ \ beta $ ist die maximale Reflexionsrate.

def sigmoid(x, a=1):
    return 1 / (1 + np.exp(-a * x))

def create_beta_list(N, max_beta=0.3):
    beta_list = []
    for i in range(N):
        if i == 0:
            b = 0
        elif i == N-1:
            b = max_beta
        else:
            b = 10 * (2*i-(N-2)) / (N-2)
            b = max_beta * sigmoid(b)
        beta_list.append(b)
    return beta_list

NGU-Diskontsatz.

def create_gamma_list_ngu(N, gamma_min=0.99, gamma_max=0.997):
    if N == 1:
        return [gamma_min]
    if N == 2:
        return [gamma_min, gamma_max]
    gamma_list = []
    for i in range(N):
        g = (N - 1 - i)*np.log(1 - gamma_max) + i*np.log(1 - gamma_min)
        g /= N - 1
        g = 1 - np.exp(g)
        gamma_list.append(g)
    return gamma_list

Agent57 Diskontsatz.

\gamma_j = \left\{
\begin{array}{ll}
\gamma0 \qquad (j=0) \\
\gamma1 + (\gamma0 - \gamma1)\sigma(10 \frac{2i-6}{6} ) \qquad (j \in (1,...,6)) \\
\gamma1 \qquad (j=7) \\
1-exp(\frac{(N-9)log(1-\gamma1) + (j-8)log(1-\gamma2)}{N-9}) \quad (otherwise)
\end{array}
\right.

def create_gamma_list_agent57(N, gamma0=0.9999, gamma1=0.997, gamma2=0.99):
    gamma_list = []
    for i in range(N):
        if i == 1:
            g = gamma0
        elif 2 <= i and i <= 6:
            g = 10*((2*i-6)/6)
            g = gamma1 + (gamma0 - gamma1)*sigmoid(g)
        elif i == 7:
            g = gamma1
        else:
            g = (N-9)*np.log(1-gamma1) + (i-8)*np.log(1-gamma2)
            g /= N-9
            g = 1-np.exp(g)
        gamma_list.append(g)
    return gamma_list

Internes Belohnungsmodell (UVFA)

Ich bin misstrauisch, hier zu verstehen ...

Die folgende Abbildung zeigt ein Modell der Verhaltenswertfunktion von Agent 57.

Unten rechts befindet sich die Beschreibung von [Aktion, Externe Belohnung, Interne Belohnung, Suchrate]. Es sagt jedoch nicht, wie man das hinzufügt ...

Derzeit wird die Suchrate nur als heißer Vektor zur Aktionswertfunktion der internen Belohnung hinzugefügt, wie unten gezeigt. (Wenn Sie die interne oder externe Belohnung so eingeben, wie sie ist, werden Sie nicht lernen ...)

Unten ist der Code. Es wird nur die Aktionswertfunktion für die interne Belohnung beschrieben. (Der Teil mit dem Kommentar (UVFA) ist der Teil, der durch UVFA geändert wurde.)

from keras.utils import to_categorical

#Wo erstelle ich ein Modell für die Q-Funktion?
def build_actval_int_model():

    #Eingabeebene
    c1 = input1 = Input(shape=(input_sequence,) + input_shape)
    c2 = input1 = Input(shape=(policy_num,))  # (UVFA)hinzufügen

    #Bildverarbeitungsschicht
    c1 = Conv2D(32, (8, 8), strides=(4, 4), padding="same")(c1)
    c1 = Conv2D(64, (4, 4), strides=(2, 2), padding="same")(c1)
    c1 = Conv2D(64, (3, 3), strides=(1, 1), padding="same")(c1)

    c = Concatenate()([c1, c2])  # (UVFA)hinzufügen

    # lstm
    c = LSTM(512)(c)

    # dueling network
    c =Erstellen Sie ein Modell für Dueling Network(c)

    model = Model([input1, input2], c)  # (UVFA)Veränderung
    model.compile(loss=clipped_error_loss, optimizer=Adam(lr=0.0001, epsilon=0.0001))

    return model

#Erstellen Sie ein Modell
actval_int_model = build_actval_int_model()
actval_int_model_target = build_actval_int_model()

Internes Belohnungsmodelltraining

#Jeder Rahmen
def forward(observation):
    #Batch-Daten abrufen
    batchs = memory.sample()

    #Daten formatieren
    state0_batch = []
    state1_batch = []
    policy_batch = []
    for batch in batchs:
        state0_batch.append(batchs["Vorheriger Status"])
        state1_batch.append(batchs["Nächster Zustand"])
        #Erkennungsrichtlinie eins-Heiß
        t = to_categorical(batchs["Erkennungsrichtlinie"], num_classes=policy_num)
        policy_batch.append(t)

    #Die Eingabe ist eine Status- und Erkennungsrichtlinie
    state0_batch = [state0_batch, policy_batch]
    state1_batch = [state1_batch, policy_batch]
    
    #Beispiel für die Angabe des Q-Wertes
    state0_qvals = actval_int_model.predict(state0_batch, batch_size)

(State0 für Update_Berechnung von qvals)

    #Lernen
    actval_int_model.train_on_batch(state0_batch, state0_qvals)

Berechnung des Q-Wertes

Die Berechnung des Q-Werts in NGU entfällt, da dies nicht mehr auf die Aufteilung der Aktionswertfunktion von Agent57 zurückzuführen ist. Die Formel zur Berechnung des Q-Werts in Agent57 lautet wie folgt: Es handelt sich um eine Kombination aus internen und externen Belohnungen.

def rescaling(x, epsilon=0.001):
    if x == 0:
        return 0
    n = math.sqrt(abs(x)+1) - 1
    return np.sign(x)*n + epsilon*x

def rescaling_inverse(x, epsilon=0.001):
    if x == 0:
        return 0
    n = math.sqrt(1 + 4*epsilon*(abs(x)+1+epsilon)) - 1
    return np.sign(x)*( n/(2*epsilon) - 1)


def get_qvals():
    state =Aktuellen Zustand
    policy_index =Erkennungsrichtlinie

    #Holen Sie sich einen externen Q-Wert
    qvals_ext = avtval_ext_model.predict(state, batch_size=1)[0]

    #Erkennungsrichtlinie eins-hot
    policy_onehot = to_categorical(policy_index, num_classes=policy_num)

    #Holen Sie sich den internen Q-Wert
    qvals_int = avtval_int_model.predict([state, policy_onehot], batch_size=1)[0]

    #Suchrate
    beta = int_beta_list[policy_index]

    #Q-Wert berechnen
    qvals = []
    for i in range(nb_actions):
        q_ext = rescaling_inverse(qvals_ext[i])
        q_int = rescaling_inverse(qvals_int[i])
        qval = rescaling(q_ext + beta * q_int)
        qvals.append(qvals)

    return qvals

Retrace

Wie ich bereits sagte, wird die Implementierung von Retrace unterbrochen (ich kann den Inhalt nicht verstehen ...) Ich werde die Inhalte beschreiben, die ich nicht verstehe.

Die Retrace-Funktion lautet:

$ \ pi $ ist die Zielrichtlinie und $ \ mu $ ist die Wahrscheinlichkeitsverteilung für jede Aktion in der Verhaltensrichtlinie.

In DQN ist die Suchrichtlinie jedoch vollständig gierig (wählen Sie nur den maximalen Q-Wert aus), sodass ich der Meinung bin, dass die Wahrscheinlichkeitsverteilung für die Aktion 1 mit dem maximalen Q-Wert und für die anderen 0 ist. In diesem Fall nimmt das Molekül nur 0 oder 1 an, daher habe ich das Gefühl, dass es immer 0 sein wird, aber ... orz

Die Verhaltensrichtlinie wird wahrscheinlich ε-gierig sein, daher denke ich, dass sie wie folgt aussehen wird (?)

\mu(\alpha|s) = \left\{
\begin{array}{ll}
\epsilon/N + 1 - \epsilon \quad (argmax_{\alpha \in A} Q(s, \alpha)) \\
\epsilon/N \quad (otherwise)
\end{array}
\right.

Wobei N die Anzahl der Aktionen ist.

Nachwort

Ich habe die Details von LSTM, Warteschlangen, Parallelverarbeitung usw. nicht vollständig erklärt. .. .. Der Quellcode ist öffentlich zugänglich. Überprüfen Sie daher die Details dort.

Damit habe ich das Gefühl, ein Ziel als Algorithmus für das verstärkte Lernen erreicht zu haben, aber ich denke, es gibt noch Raum für Verbesserungen. Ich möchte, dass Sie sich am meisten verbessern, sind die erforderlichen Spezifikationen. Dies ist seit R2D2 der Fall, aber die Anzahl der Akteure in dem Papier beträgt 512. Mein PC hat ein Limit von 2 und höchstens 4 ... (obwohl er möglicherweise nur eine CPU hat) Ich freue mich auf die nächste neue Methode.