[PYTHON] [Lernen stärken] R2D2 implementiert / erklärt Revenge Hyper Parameter Explanation (Keras-RL)

Dies ist eine Erklärung der Hyperparameter. Ich habe jeden Parameter zusammengefasst.

Klicken Sie hier für den Inhaltsalgorithmus [Stärkung des Lernens] R2D2-Implementierung / Erklärung Rache Erklärung (Keras-RL)

Ganzer Code

Der Zielcode für diesen Artikel befindet sich auf Github.

Inhaltsverzeichnis

Gemeinsame Parameter

Dieser Parameter ist für Rainbow (DQN) und R2D2 gleich.

env-Abhängigkeitsparameter

Überblick Schimmel Beispiel Bemerkungen
input_shape Form eingeben tuple (84,84) env.observation_space.shape
input_type Geben Sie das Eingabeformat an InputType InputType.GRAY_2ch Ursprüngliche Implementierung
image_model Bildebenenmodellformat ImageModel(Ursprüngliche Implementierung) DQNImageModel()
nb_actions Anzahl der Aktionen(Anzahl der Ausgänge) int 4 env.action_space.n
processor Klassen, die benutzerdefinierte Fitnessfunktionen bieten Processor(Keras-rl) None

InputType


class InputType(enum.Enum):
    VALUES = 1    #Kein Bild
    GRAY_2ch = 3  # (width, height)
    GRAY_3ch = 4  # (width, height, 1)
    COLOR = 5     # (width, height, ch)

Modellbezogene Parameter des NN (Neural Network)

Überblick Schimmel Beispiel Bemerkungen
batch_size Chargengröße int 32
optimizer Optimierungsalgorithmus Optimizer(Keras) Adam(lr=0.0001) Keras-Implementierung
metrics Bewertungsfunktion array [] Keras-Implementierung
input_sequence Anzahl der Eingaberahmen int 4
dense_units_num Anzahl der Einheiten in der dichten Ebene int 512
enable_dueling_network Ob Dueling Network verwendet werden soll bool True
dueling_network_type Im Duell-Netzwerk verwendete Algorithmen DuelingNetwork DuelingNetwork.AVERAGE
lstm_type Typen bei Verwendung von LSTM LstmType(Ursprüngliche Implementierung) LstmType.NONE
lstm_units_num Anzahl der Einheiten in der LSTM-Schicht int 512
lstm_ful_input_length Anzahl der Eingabelernen pro Lernen int 4 Wird nur für STATEFUL verwendet

DuelingNetwork


class DuelingNetwork(enum.Enum):
    AVERAGE = 0
    MAX = 1
    NAIVE = 2

LstmType


class LstmType(enum.Enum):
    NONE = 0
    STATELESS = 1
    STATEFUL = 2

Erleben Sie Replay Memory

Überblick Schimmel Beispiel Bemerkungen
memory/remote_memory Speicher zu verwenden Memory(Ursprüngliche Implementierung) ReplayMemory(10000) Siehe unten

Gibt den Speichertyp an, in dem die Erfahrung gespeichert werden soll. In DQN werden die erlebten Daten einmal im Speicher gespeichert. Danach wird die Erfahrung zufällig aus dem Gedächtnis extrahiert und gelernt. Es gibt verschiedene Arten, je nachdem, wie aus dem Speicher abgerufen werden soll, daher werde ich sie erläutern.

ReplayMemory Es ist ein einfacher Speicher, der in DQN verwendet wird. (Vorheriger Artikel) Ruft empirische Daten nach dem Zufallsprinzip ab.

ReplayMemory(
    capacity=10_000
)

PERGreedyMemory [Wiedergabe vorrangiger Erfahrungen](https://qiita.com/pocokhc/items/fc00f8ea9dca8f8c0297#priority-experience-reply%E5%84%AA%E5%85%88%E9%A0%86%E4%BD% 8D% E4% BB% 98% E3% 81% 8D% E7% B5% 8C% E9% A8% 93% E5% 86% 8D% E7% 94% 9F) ist eine einfache Implementierung. Dies ist eine Methode, um die Erfahrung mit dem größten TD-Fehler (der höchsten Reflexionsrate beim Lernen) und nicht zufällig zu extrahieren. Da es jedoch keine zufälligen Elemente gibt, habe ich das Gefühl, sofort eine lokale Lösung zu finden, sodass ich nicht gut lernen kann ... (Warum implementiert)

PERGreedyMemory(
    capacity=10_000
)

PERProportionalMemory [Priority Experience Replay](https://qiita.com/pocokhc/items/fc00f8ea9dca8f8c0297#priority-experience-reply%E5%84%AA%E5%85%88%E9%A0%86%E4%BD% 8D% E4% BB% 98% E3% 81% 8D% E7% B5% 8C% E9% A8% 93% E5% 86% 8D% E7% 94% 9F) Proportionaler Priorisierungsspeicher .. Dies ist eine Methode zum Extrahieren von Erfahrungen anhand der Wahrscheinlichkeitsverteilung des TD-Fehlers und nicht anhand der Zufälligkeit. (Erfahrungen mit mehr TD-Fehlern werden eher abgerufen)

Es fühlt sich viel effizienter an als Replay Memory (zufällige Auswahl).

PERGreedyMemory(
    capacity=100000,
    alpha=0.9,
    beta_initial,
    beta_steps,
    enable_is,
)

Die Parameter werden später beschrieben.

PERRankBaseMemory [Priority Experience Replay](https://qiita.com/pocokhc/items/fc00f8ea9dca8f8c0297#priority-experience-reply%E5%84%AA%E5%85%88%E9%A0%86%E4%BD% RankBase-Speicher in 8D% E4% BB% 98% E3% 81% 8D% E7% B5% 8C% E9% A8% 93% E5% 86% 8D% E7% 94% 9F). Nehmen Sie Erfahrung im Verhältnis zum Rang des TD-Fehlers und nicht zufällig. Wenn Sie beispielsweise drei Erfahrungen gemacht haben, beträgt der erste Platz 50%, der zweite 33% und der dritte 17%.

Es fühlt sich viel effizienter an als ReplayMemory (zufällige Auswahl), Ich verstehe den Unterschied zu Proportional nicht wirklich. Dies sollte in Bezug auf die Geschwindigkeit etwas schneller sein ...

PERRankBaseMemory(
    capacity=100000,
    alpha=0.9,
    beta_initial,
    beta_steps, 
    enable_is,
)

Die Parameter werden später beschrieben.

Parameter für PERProportionalMemory und PERRankBaseMemory

Überblick Schimmel Beispiel Bemerkungen
capacity Maximale Speicherkapazität int 1_000_000
alpha Wahrscheinlichkeitsreflexionsrate float 0.9 0.0～1.0
beta_initial Anfangswert der IS-Reflexionsrate float 0.0 0.0～1.0
beta_steps IS Reflexionsrate 1.Anzahl der Schritte bis 0 int 100_000 Hängt von der Anzahl der Lernvorgänge ab
enable_is Gibt an, ob IS aktiviert werden soll bool True

Hier [Importance Sampling (IS)](https://qiita.com/pocokhc/items/fc00f8ea9dca8f8c0297#%E9%87%8D%E8%A6%81%E5%BA%A6%E3%82%B5% E3% 83% B3% E3% 83% 97% E3% 83% AA% E3% 83% B3% E3% 82% B0 ist eine wichtige Stichprobe. Wenn Erfahrungen gemäß der Wahrscheinlichkeitsverteilung gegeben werden, gibt es eine Verzerrung in der Häufigkeit, mit der jede Erfahrung ausgewählt wird. Wenn die Anzahl der Erfahrungsauswahlen verzerrt ist, ist das Lernen voreingenommen, und es ist wichtig, dies bei der Stichprobenerhebung zu vermeiden.

Insbesondere hat eine mit hoher Wahrscheinlichkeit ausgewählte Erfahrung eine niedrige Reflexionsrate zum Aktualisieren des Q-Werts, und eine mit niedriger Wahrscheinlichkeit ausgewählte Erfahrung hat eine hohe Reflexionsrate zum Aktualisieren des Q-Werts.

Das Lernen scheint durch die Einführung von IS stabil zu sein. Darüber hinaus wird IS glühen (allmählich reflektieren).

Lernbezogene Parameter

Überblick Schimmel Beispiel Bemerkungen
memory_warmup_size/ remote_memory_warmup_size Größe, die erst lernt, wenn Erfahrung im Gedächtnis gesammelt wird int 1000
target_model_update Aktualisierungsintervall für das Zielmodell int 10000
gamma Q Lernrabatt float 0.99 0.0～1.0
enable_double_dqn Gibt an, ob DoubleDQN verwendet werden soll bool True
enable_rescaling Gibt an, ob die Neuskalierungsfunktion verwendet werden soll bool True
rescaling_epsilon Konstanten, die in der Neuskalierungsfunktion verwendet werden float 0.001
priority_exponent Verhältnis bei der Berechnung der Erfahrungsprioritäten float 0.9 Verwenden Sie nur LESTFUL
burnin_length burn-in der Periode int 2 Verwenden Sie nur LESTFUL
reward_multisteps Anzahl der Schritte in MultiStep Reward int 3

Aktionsbeziehung

Überblick Schimmel Beispiel Bemerkungen
action_interval Aktionsausführungsintervall int 1 1 oder mehr
action_policy Maßnahmen zur Ausführung von Aktionen Policy(Ursprüngliche Implementierung) Siehe unten

ε-greedy ε-gierig wirkt zufällig, wenn es für Zufallszahlen (0,0 bis 1,0) weniger als $ epsilon $ beträgt. Wenn es größer als das ist, wählen Sie die Aktion aus, die den Q-Wert maximiert.

EpsilonGreedy(
    epsilon
)

ε-greedy(Annealing) [DQN](https://qiita.com/pocokhc/items/125479c9ae0df1de4234#%E3%82%A2%E3%82%AF%E3%82%B7%E3%83%A7%E3%83%B3%E3 Die in% 81% AE% E6% B1% BA% E5% AE% 9A) verwendete Methode. Eine Technik, um $ epsilon $ in ε-gierig (entsprechend dem Q-Wert) im Verlauf des Lernens zu senken.

AnnealingEpsilonGreedy(
    initial_epsilon=1,
    final_epsilon=0.1,
    exploration_steps=1_000_000
)

ε-greedy(Actor) In [Ape-X] verwendete Methode (https://qiita.com/pocokhc/items/980640c6a7b5dc9d524e#%CE%B5-greedy%E3%81%AE%E5%9B%BA%E5%AE%9A) ist. $ Epsilon $ in ε-gierig wird basierend auf der Anzahl der Schauspieler berechnet.

EpsilonGreedyActor(
    actor_index,
    actors_length,
    epsilon=0.4,
    alpha=7
)

Softmax Es ist eine Methode, um die Aktion durch die Wahrscheinlichkeitsverteilung der Softmax-Funktion des Q-Werts zu bestimmen. Kurz gesagt, je höher der Q-Wert ist, desto einfacher ist die Auswahl, und je niedriger der Q-Wert ist, desto schwieriger ist die Auswahl.

SoftmaxPolicy()

Es gibt keine Argumente.

UCB(Upper Confidence Bound)1 UCB1 ist eine Methode zum Auswählen einer Aktion, bei der nicht nur der Q-Wert, sondern auch die Häufigkeit der Auswahl der Aktion berücksichtigt wird. Die Idee ist, nach Aktionen zu suchen, die nicht sehr ausgewählt sind, weil die Suche nicht so weit fortgeschritten ist und es möglicherweise unbekannte Belohnungen gibt.

UCB1()

Es gibt keine Argumente. Darüber hinaus erhöhen sich die Schulungskosten, da das NN-Modell im Inneren gehalten und trainiert wird.

UCB1-Tuned UCB1-Tuned ist ein verbesserter Algorithmus für UCB1, der auch die Verteilung berücksichtigt. Es liefert bessere Ergebnisse als UCB1, es gibt jedoch keine theoretische Garantie.

UCB1_Tuned()

Es gibt keine Argumente. Darüber hinaus erhöhen sich die Schulungskosten, da das NN-Modell im Inneren gehalten und trainiert wird.

UCB-V Es ist ein Algorithmus, der verteilungsbewusster ist als UCB1-Tuned.

UCBv()

Es gibt keine Argumente. Darüber hinaus erhöhen sich die Schulungskosten, da das NN-Modell im Inneren gehalten und trainiert wird.

KL-UCB Es ist ein Algorithmus, der den theoretischen optimalen Wert des Such- und Belohnungsdilemmas findet. Die Implementierung kann jedoch etwas seltsam sein ...

KL_UCB()

Es gibt keine Argumente. Darüber hinaus erhöhen sich die Schulungskosten, da das NN-Modell im Inneren gehalten und trainiert wird.

Thompson Sampling (Beta-Verteilung)

Thompson Sampling ist ein Algorithmus, der auf der Basisschätzung basiert. Dies ist auch das theoretische Optimum für das Explorations- und Belohnungsdilemma.

Die Beta-Verteilung ist eine Verteilung, die angewendet werden kann, wenn ein Binärwert von 0 oder 1 angenommen wird. Wenn in der Implementierung die Belohnung größer als 0 ist, wird sie als 1 behandelt, und wenn sie 0 oder weniger ist, wird sie als 0 behandelt.

ThompsonSamplingBeta()

Es gibt keine Argumente. Darüber hinaus erhöhen sich die Schulungskosten, da das NN-Modell im Inneren gehalten und trainiert wird.

Thompson Sampling (Normalverteilung)

Thompson Sampling ist ein Algorithmus, der auf der Basisschätzung basiert. Dies ist auch das theoretische Optimum für das Explorations- und Belohnungsdilemma.

Der Algorithmus wird unter der Annahme angewendet, dass die Belohnung einer Normalverteilung folgt.

ThompsonSamplingGaussian()

Es gibt keine Argumente. Darüber hinaus erhöhen sich die Schulungskosten, da das NN-Modell im Inneren gehalten und trainiert wird.

Nur im Zusammenhang mit Rainbow (DQN)

Überblick Schimmel Beispiel Bemerkungen
train_interval Lernintervall int 1 1 oder mehr

Sie können das Trainingsintervall verlängern, indem Sie train_interval erhöhen.

Nur im Zusammenhang mit R2D2

Überblick Schimmel Beispiel Bemerkungen
actors Geben Sie die Actor-Klasse an Actor(Ursprüngliche Implementierung) Siehe unten
actor_model_sync_interval Intervall zum Synchronisieren des NN-Modells vom Lernenden int 500

Actor Es ist eine Klasse, die Actor durch ihre eigene Implementierung ausdrückt. Es erbt dies und definiert die Richtlinie und Umgebung, die jeder Akteur ausführt.

Dies ist ein Definitionsbeispiel.

from src.r2d2 import Actor
from src.policy import EpsilonGreedy

ENV_NAME = "xxx"

class MyActor(Actor):
    def getPolicy(self, actor_index, actor_num):
        return EpsilonGreedy(0.1)

    def fit(self, index, agent):
        env = gym.make(ENV_NAME)
        agent.fit(env, visualize=False, verbose=0)
        env.close()

getPolicy gibt die von diesem Akteur verwendete Aktionsrichtlinie an. Lassen Sie agetn, ein Argument in fit, fit ausführen, um zu lernen.

Seien Sie vorsichtig, wenn Sie an R2D2 übergeben, übergeben Sie die Klasse selbst (nicht instanziieren)

from src.r2d2 import R2D2
kwargs = {
    "actors": [MyActor]  #Übergeben Sie die Klasse selbst
(Kürzung)
}
manager = R2D2(**kwargs)

Wenn Sie die Anzahl der Akteure erhöhen möchten, erhöhen Sie die Anzahl der Elemente im Array.

Beispiel von 4 Schauspielern


from src.r2d2 import R2D2
kwargs = {
    "actors": [MyActor, MyActor, MyActor, MyActor]
(Kürzung)
}
manager = R2D2(**kwargs)

Andere

MovieLogger(Rainbow/R2D2)

Rückruf, der ein Video ausgibt. Es kann sowohl mit Rainbow als auch mit R2D2 verwendet werden.

from src.callbacks import MovieLogger

#Fügen Sie es dem Argument callcacks von test hinzu.
movie = MovieLogger()
agent.test(env, nb_episodes=1, visualize=False, callbacks=[movie])

#du sparst.
movie.save(
    start_frame=0,
    end_frame=0,
    gifname="pendulum.gif",
    mp4name="",
    interval=200,
    fps=30
):

・ Ausgabebeispiel pendulum.gif

Zwischenschichtvisualisierung von NN (Rainbow / R2D2)

Rückruf für die Visualisierung der Conv-Ebene, der erweiterten Ebene und der Wertebene, eingeführt in Vorheriger Artikel. Es kann sowohl mit Rainbow als auch mit R2D2 verwendet werden.

from src.callbacks import ConvLayerView

#Geben Sie den Agenten in der Initialisierung an.
conv = ConvLayerView(agent)

#Führen Sie einen Test durch.
#Geben Sie das ConvLayerView-Objekt im Rückrufargument an
agent.test(env, nb_episodes=1, visualize=False, callbacks=[conv])

#Speichern Sie das Ergebnis.
conv.save(
    grad_cam_layers=["conv_1", "conv_2", "conv_3"],
    add_adv_layer=True,
    add_val_layer=True,
    start_frame=0,
    end_frame=200,
    gifname="tmp/pendulum.gif",
    interval=200,
    fps=10,
)

Außerdem funktioniert ConvLayerView nur, wenn die Eingabe ein Bild ist (InputType ist GRAY_2ch, GRAY_3ch, COLOR).

・ Ausgabebeispiel pendulum1_min.gif

Logger2Stage(Rainbow) Es bietet die folgenden zwei Funktionen.

from src.rainbow import Rainbow
from src.callbacks import Logger2Stage

#Erstellen Sie einen separaten Agenten und eine Umgebung zum Testen
kwargs = (Kürzung)
test_agent = Rainbow(**kwargs)
test_env = gym.make(ENV_NAME)

#verschiedene Einstellungen
log = Logger2Stage(
    logger_type=LoggerType.STEP,
    warmup=1000,
    interval1=200,
    interval2=20_000,
    change_count=5,
    savefile="tmp/log.json",
    test_agent=test_agent,
    test_env=test_env,
    test_episodes=10
)

#Fügen Sie Rückrufe beim Lernen hinzu
#Logger2Stage gibt das Protokoll aus, also ausführlich=0
agent.fit(env, nb_steps=1_750_000, visualize=False, verbose=0, callbacks=[log])

#Sie können die Protokolle mit der Funktion getLogs abrufen(Sie müssen savefile angeben)
history = log.getLogs()

#Es ist einfach, aber Sie können auch Diagramme ausgeben(Sie müssen savefile angeben)
log.drawGraph()

・ Ausgabebeispiel

--- start ---
'Ctrl + C' is stop.
Steps 0, Time: 0.00m, TestReward:  21.12 -  92.80 (ave:  51.73, med:  46.99), Reward:   0.00 -   0.00 (ave:   0.00, med:   0.00)
Steps 200, Time: 0.05m, TestReward:  22.06 -  99.94 (ave:  43.85, med:  31.24), Reward: 108.30 - 108.30 (ave: 108.30, med: 108.30)
Steps 1200, Time: 0.28m, TestReward:  40.99 -  73.88 (ave:  52.41, med:  47.69), Reward:  49.05 - 141.53 (ave:  87.85, med:  90.89)
(Kürzung)
Steps 17200, Time: 3.95m, TestReward: 167.68 - 199.49 (ave: 184.34, med: 188.30), Reward: 166.29 - 199.66 (ave: 181.79, med: 177.36)
Steps 18200, Time: 4.19m, TestReward: 165.84 - 199.53 (ave: 186.16, med: 188.50), Reward: 188.00 - 199.50 (ave: 190.64, med: 188.41)
Steps 19200, Time: 4.43m, TestReward: 163.63 - 188.93 (ave: 186.15, med: 188.59), Reward: 165.56 - 188.45 (ave: 183.75, med: 188.23)
done, took 4.626 minutes
Steps 0, Time: 4.63m, TestReward: 188.37 - 199.66 (ave: 190.83, med: 188.68), Reward: 188.34 - 188.83 (ave: 188.63, med: 188.67)

rainbow_pendium.png

SaveManager(R2D2) R2D2 verwendet Multiprocessing und die Implementierungsmethode ist etwas ganz Besonderes. Insbesondere hat sich dies auf das Speichern / Laden des Modells erheblich ausgewirkt, sodass ich es separat vorbereitet habe.

from src.r2d2 import R2D2
from src.r2d2_callbacks import SaveManager

#R2D2 erstellen
kwargs = (Kürzung)
manager = R2D2(**kwargs)

#Erstellen eines SaveManager
save_manager = SaveManager(
    save_dirpath="tmp",
    is_load=False,
    save_overwrite=True,
    save_memory=True,
    checkpoint=True,
    checkpoint_interval=2000,
    verbose=0
)

#Beginnen Sie mit dem Lernen und fügen Sie das Argument für Rückrufe hinzu.
manager.train(
    nb_trains=20_000,
    callbacks=[save_manager],
)

#Rufen Sie Folgendes auf, um einen Agenten zum Testen zu erstellen
# save_dirpath/last/learner.Bitte geben Sie dat an.
agent = manager.createTestAgent(MyActor, "tmp/last/learner.dat")

#Führen Sie einen Test durch.
agent.test(env, nb_episodes=5, visualize=True)

Es bietet die folgenden zwei Funktionen.

Im Gegensatz zum Regenbogen gibt es nur ein zeitliches Erfassungsintervall.

from src.r2d2 import R2D2
from src.r2d2_callbacks import Logger2Stage

#R2D2 erstellen
kwargs = (Kürzung)
manager = R2D2(**kwargs)

#Erstellen Sie eine Umgebung zum Testen
test_env = gym.make(ENV_NAME)

#Erstellen Sie Logger2 Stage
log = Logger2Stage(
    warmup=0,
    interval1=10,
    interval2=60,
    change_count=20,
    savedir="tmp",
    test_actor=MyActor,
    test_env=test_env,
    test_episodes=10,
    verbose=1,
)

#Beginnen Sie mit dem Lernen und fügen Sie das Argument für Rückrufe hinzu.
manager.train(
    nb_trains=20_000,
    callbacks=[log],
)

#Sie können die Protokolle mit getLogs abrufen.(Wenn savedir angegeben ist)
history = log.getLogs()

#Sie können auch einfach ein Diagramm anzeigen.(Wenn savedir angegeben ist)
log.drawGraph()

・ Ausgabebeispiel

--- start ---
'Ctrl + C' is stop.
Learner Start!
Actor0 Start!
Actor1 Start!
actor1   Train 1, Time: 0.24m, Reward    :  27.80 -  27.80 (ave:  27.80, med:  27.80), nb_steps: 200
learner  Train 1, Time: 0.19m, TestReward:  29.79 -  76.71 (ave:  58.99, med:  57.61)
actor0   Train 575, Time: 0.35m, Reward    :  24.88 - 133.09 (ave:  62.14, med:  50.83), nb_steps: 3400
learner  Train 651, Time: 0.36m, TestReward:  24.98 -  51.67 (ave:  38.86, med:  38.11)
actor1   Train 651, Time: 0.41m, Reward    :  22.15 -  88.59 (ave:  41.14, med:  35.62), nb_steps: 3200
actor0   Train 1249, Time: 0.51m, Reward    :  22.97 -  61.41 (ave:  35.24, med:  31.99), nb_steps: 8000
(Kürzung)
learner  Train 16476, Time: 4.53m, TestReward: 165.56 - 199.57 (ave: 180.52, med: 177.73)
actor1   Train 16880, Time: 4.67m, Reward    : 128.88 - 188.45 (ave: 169.13, med: 165.94), nb_steps: 117600
Learning End. Train Count:20001
learner  Train 20001, Time: 5.29m, TestReward: 175.72 - 188.17 (ave: 183.21, med: 187.48)
Actor0 End!
Actor1 End!
actor0   Train 20001, Time: 5.34m, Reward    : 151.92 - 199.61 (ave: 181.68, med: 187.48), nb_steps: 0
actor1   Train 20001, Time: 5.34m, Reward    : 130.39 - 199.26 (ave: 170.83, med: 167.99), nb_steps: 0
done, took 5.350 minutes

r2d2_pendium.png

Einstellwert Probe

DQN-Papier (Atari)

from src.rainbow import Rainbow
from src.processor import AtariProcessor
from src.image_model import DQNImageModel
from src.memory import ReplayMemory
from src.policy import AnnealingEpsilonGreedy

nb_steps = 1_750_000

#Was AtariProcessor macht
#· Bildgröße anpassen(84,84)
#・ Belohnungsausschnitt
processor = AtariProcessor(reshape_size=(84, 84), is_clip=True)

kwargs={
    "input_shape": processor.image_shape, 
    "input_type": InputType.GRAY_2ch,
    "nb_actions": env.action_space.n, 
    "optimizer": Adam(lr=0.0001),
    "metrics": [],

    "image_model": DQNImageModel(),
    "input_sequence": 4,         #Anzahl der Eingaberahmen
    "dense_units_num": 256,       #Anzahl der Einheiten in der dichten Schicht
    "enable_dueling_network": False,
    "lstm_type": LstmType.NONE,           #Zu verwendender LSTM-Algorithmus

    # train/handlungsbezogen
    "memory_warmup_size": 50_000,    #Anzahl der Schritte für die anfängliche Speicherzuweisung(Lerne nicht)
    "target_model_update": 10_000,  #Zielnetzwerk-Aktualisierungsintervall
    "action_interval": 4,       #Intervall zur Ausführung der Aktion
    "train_interval": 4,        #Intervall zum Lernen
    "batch_size": 32,     # batch_size
    "gamma": 0.99,        #Q Lernrabatt
    "enable_double_dqn": False,
    "enable_rescaling": False,   #Gibt an, ob die Neuskalierung aktiviert werden soll
    "reward_multisteps": 1,      # multistep reward

    #Andere
    "processor": processor,
    "action_policy": AnnealingEpsilonGreedy(
        initial_epsilon=1.0,      #Anfängliches ε
        final_epsilon=0.05,        #Ε im Endzustand
        exploration_steps=1_000_000  #Anzahl der Schritte vom Anfangs- bis zum Endzustand
    ),
    "memory": ReplayMemory(capacity=1_000_000),

}
agent = Rainbow(**kwargs)

Keras-RL-Probe (Cartpole)

from src.rainbow import Rainbow
from src.memory import ReplayMemory
from src.policy import SoftmaxPolicy

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

kwargs={
    "input_shape": env.observation_space.shape, 
    "input_type": InputType.VALUES,
    "nb_actions": env.action_space.n, 
    "optimizer": Adam(lr=0.0001),
    "metrics": [],

    "image_model": None,
    "input_sequence": 1,         #Anzahl der Eingaberahmen
    "dense_units_num": 16,       #Anzahl der Einheiten in der dichten Schicht
    "enable_dueling_network": False,
    "lstm_type": LstmType.NONE,
    
    # train/handlungsbezogen
    "memory_warmup_size": 10,    #Anzahl der Schritte für die anfängliche Speicherzuweisung(Lerne nicht)
    "target_model_update": 1,  #Zielnetzwerk-Aktualisierungsintervall
    "action_interval": 1,       #Intervall zur Ausführung der Aktion
    "train_interval": 1,        #Intervall zum Lernen
    "batch_size": 32,     # batch_size
    "gamma": 0.99,        #Q Lernrabatt
    "enable_double_dqn": False,
    "enable_rescaling": False,
    
    #Andere
    "processor": processor,
    "action_policy": SoftmaxPolicy(),
    "memory": ReplayMemory(capacity=50000)
}
agent = Rainbow(**kwargs)

Regenbogenpapier (Atari)

from src.rainbow import Rainbow
from src.processor import AtariProcessor
from src.image_model import DQNImageModel
from src.memory import PERProportionalMemory
from src.policy import AnnealingEpsilonGreedy

nb_steps = 1_750_000

#Was AtariProcessor macht
#· Bildgröße anpassen(84,84)
#・ Belohnungsausschnitt
processor = AtariProcessor(reshape_size=(84, 84), is_clip=True)

kwargs={
    "input_shape": processor.image_shape, 
    "input_type": InputType.GRAY_2ch,
    "nb_actions": env.action_space.n, 
    "optimizer": Adam(lr=0.0000625, epsilon=0.00015),
    "metrics": [],

    "image_model": DQNImageModel(),
    "input_sequence": 4,         #Anzahl der Eingaberahmen
    "dense_units_num": 512,       #Anzahl der Einheiten in der dichten Schicht
    "enable_dueling_network": True,
    "dueling_network_type": DuelingNetwork.AVERAGE,  #Algorithmus im Duell-Netzwerk
    "lstm_type": LstmType.NONE,
    
    # train/handlungsbezogen
    "memory_warmup_size": 80000,    #Anzahl der Schritte für die anfängliche Speicherzuweisung(Lerne nicht)
    "target_model_update": 32000,  #Zielnetzwerk-Aktualisierungsintervall
    "action_interval": 4,       #Intervall zur Ausführung der Aktion
    "train_interval": 4,        #Intervall zum Lernen
    "batch_size": 32,     # batch_size
    "gamma": 0.99,        #Q Lernrabatt
    "enable_double_dqn": True,
    "enable_rescaling": False,
    "reward_multisteps": 3,    # multistep reward
    
    #Andere
    "processor": processor,
    "action_policy": AnnealingEpsilonGreedy(
        initial_epsilon=1.0,      #Anfängliches ε
        final_epsilon=0.05,        #Ε im Endzustand
        exploration_steps=1_000_000  #Anzahl der Schritte vom Anfangs- bis zum Endzustand
    ),
    "memory": PERProportionalMemory(
        capacity=1_000_000,
        alpha=0.5,           #Wahrscheinlichkeitsreflexionsrate von PER
        beta_initial=0.4,    #Anfangswert der IS-Reflexionsrate
        beta_steps=1_000_000,  #Anzahl der Schritte zur Erhöhung der IS-Reflexionsrate
        enable_is=True,     #Gibt an, ob IS aktiviert werden soll
    )
}
agent = Rainbow(**kwargs)

R2D2-Papier (Atari)

from src.r2d2 import R2D2, Actor
from src.processor import AtariProcessor
from src.image_model import DQNImageModel
from src.memory import PERProportionalMemory
from src.policy import EpsilonGreedyActor

ENV_NAME = "xxxxx"

class MyActor(Actor):
    def getPolicy(self, actor_index, actor_num):
        return EpsilonGreedyActor(actor_index, actor_num, epsilon=0.4, alpha=7)

    def fit(self, index, agent):
        env = gym.make(ENV_NAME)
        agent.fit(env, visualize=False, verbose=0)
        env.close()


#Was AtariProcessor macht
#· Bildgröße anpassen(84,84)
#・ Belohnungsausschnitt
processor = AtariProcessor(reshape_size=(84, 84), is_clip=True)

kwargs={
    "input_shape": processor.image_shape, 
    "input_type": InputType.GRAY_2ch,
    "nb_actions": env.action_space.n, 
    "optimizer": Adam(lr=0.0001, epsilon=0.001),
    "metrics": [],

    "image_model": DQNImageModel(),
    "input_sequence": 4,             #Anzahl der Eingaberahmen
    "dense_units_num": 512,           #Anzahl der Einheiten in der dichten Ebene
    "enable_dueling_network": True,  # dueling_Netzwerk gültige Flagge
    "dueling_network_type": DuelingNetwork.AVERAGE,   # dueling_Netzwerkalgorithmus
    "lstm_type": LstmType.STATEFUL,  #LSTM-Algorithmus
    "lstm_units_num": 512,            #Anzahl der Einheiten in der LSTM-Schicht
    "lstm_ful_input_length": 40,      #Stateful LSTM-Eingänge

    # train/handlungsbezogen
    "remote_memory_warmup_size": 50_000,  #Anzahl der Schritte für die anfängliche Speicherzuweisung(Lerne nicht)
    "target_model_update": 10_000,  #Zielnetzwerk-Aktualisierungsintervall
    "action_interval": 4,    #Intervall zur Ausführung der Aktion
    "batch_size": 64,
    "gamma": 0.997,           #Q Lernrabatt
    "enable_double_dqn": True,   #DDQN gültiges Flag
    "enable_rescaling": enable_rescaling,    #Gibt an, ob die Neuskalierung aktiviert werden soll(priotrity)
    "rescaling_epsilon": 0.001,  #Neuskalierungskonstante
    "priority_exponent": 0.9,   #Priorität Priorität
    "burnin_length": 40,          # burn-in der Periode
    "reward_multisteps": 3,  # multistep reward

    #Andere
    "processor": processor,
    "actors": [MyActor for _ in range(256)],
    "remote_memory": PERProportionalMemory(
        capacity= 1_000_000,
        alpha=0.6,             #Wahrscheinlichkeitsreflexionsrate von PER
        beta_initial=0.4,      #Anfangswert der IS-Reflexionsrate
        beta_steps=1_000_000,  #Anzahl der Schritte zur Erhöhung der IS-Reflexionsrate
        enable_is=True,        #Gibt an, ob IS aktiviert werden soll
    ),

    #Schauspieler Beziehung
    "actor_model_sync_interval": 400,  #Intervall zum Synchronisieren des Modells vom Lernenden

}
manager = R2D2(**kwargs)

Nachwort

Es gibt zu viele Parameter ... Es scheint, dass etwas namens R2D3 angekündigt wurde, und wir werden es bald implementieren.

Recommended Posts

[Lernen stärken] R2D2 implementiert / erklärt Revenge Hyper Parameter Explanation (Keras-RL)
[Lernen stärken] Rache-Kommentar (Keras-RL), der versucht hat, R2D2 zu implementieren / zu erklären
[Lernen stärken] Ich habe R2D3 (Keras-RL) implementiert / erklärt.
Tiefes Lernen der Verstärkung 2 Implementierung des Lernens der Verstärkung
[Python] Probieren Sie mit Keras-RL ganz einfach erweitertes Lernen (DQN) aus
Zukünftiges Verstärkungslernen_2
Zukünftiges Verstärkungslernen_1