[Renforcement de l'apprentissage] R2D2 implémenté / expliqué Explication du paramètre Revenge Hyper (Keras-RL)

Ceci est une explication hyper paramétrique. J'ai résumé chaque paramètre.

Cliquez ici pour l'algorithme de contenu [Renforcement de l'apprentissage] Implémentation / explication de R2D2 sur la vengeance (Keras-RL)

Code entier

Le code cible de cet article est sur github.

table des matières

Paramètres communs

Ce paramètre est commun à Rainbow (DQN) et R2D2.

paramètres de dépendance env

Aperçu Moule Exemple Remarques
input_shape Forme d'entrée tuple (84,84) env.observation_space.shape
input_type Spécifiez le format d'entrée InputType InputType.GRAY_2ch Mise en œuvre originale
image_model Format du modèle de couche d'image ImageModel(Mise en œuvre originale) DQNImageModel()
nb_actions Nombre d'actions(Nombre de sorties) int 4 env.action_space.n
processor Cours offrant des fonctionnalités Gym personnalisées Processor(Keras-rl) None

InputType


class InputType(enum.Enum):
    VALUES = 1    #Pas d'image
    GRAY_2ch = 3  # (width, height)
    GRAY_3ch = 4  # (width, height, 1)
    COLOR = 5     # (width, height, ch)

Paramètres liés au modèle NN (Neural Network)

Aperçu Moule Exemple Remarques
batch_size Taille du lot int 32
optimizer Algorithme d'optimisation Optimizer(Keras) Adam(lr=0.0001) Implémentation Keras
metrics Fonction d'évaluation array [] Implémentation Keras
input_sequence Nombre de trames d'entrée int 4
dense_units_num Nombre d'unités dans la couche dense int 512
enable_dueling_network Utiliser ou non le réseau de duel bool True
dueling_network_type Algorithmes utilisés dans Dueling Network DuelingNetwork DuelingNetwork.AVERAGE
lstm_type Types lors de l'utilisation de LSTM LstmType(Mise en œuvre originale) LstmType.NONE
lstm_units_num Nombre d'unités dans la couche LSTM int 512
lstm_ful_input_length Nombre d’apprentissage d’entrée par apprentissage int 4 Utilisé uniquement pour STATEFUL

DuelingNetwork


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

LstmType


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

Expérience liée à la mémoire de relecture

Aperçu Moule Exemple Remarques
memory/remote_memory Mémoire à utiliser Memory(Mise en œuvre originale) ReplayMemory(10000) Voir ci-dessous

Spécifie le type de mémoire pour stocker l'expérience. Dans DQN, les données expérimentées sont stockées une fois dans la mémoire. Après cela, l'expérience est extraite au hasard de la mémoire et l'apprentissage est effectué. Il existe plusieurs types en fonction de la façon de récupérer de la mémoire, je vais donc les expliquer.

ReplayMemory C'est une mémoire simple utilisée dans DQN. (Article précédent) Récupérez au hasard des données empiriques.

ReplayMemory(
    capacity=10_000
)

PERGreedyMemory [Replay d'expérience prioritaire](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) est une mise en œuvre simple. Il s'agit d'une méthode pour extraire l'expérience avec la plus grande erreur TD (le taux de réflexion le plus élevé en apprentissage) plutôt que aléatoire. Cependant, comme il n'y a pas d'éléments aléatoires, j'ai l'impression que je vais tout de suite dans une solution locale, donc je ne peux pas bien apprendre ... (Pourquoi mis en œuvre)

PERGreedyMemory(
    capacity=10_000
)

PERProportionalMemory [Replay d'expérience prioritaire](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) Mémoire de priorisation proportionnelle .. Il s'agit d'une méthode d'extraction d'expérience en fonction de la distribution de probabilité de l'erreur TD plutôt que du hasard. (Les expériences avec plus d'erreurs TD sont plus susceptibles d'être récupérées)

Cela semble beaucoup plus efficace que Replay Memory (sélection aléatoire).

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

Les paramètres seront décrits plus loin.

PERRankBaseMemory [Replay d'expérience prioritaire](https://qiita.com/pocokhc/items/fc00f8ea9dca8f8c0297#priority-experience-reply%E5%84%AA%E5%85%88%E9%A0%86%E4%BD% Mémoire RankBase dans 8D% E4% BB% 98% E3% 81% 8D% E7% B5% 8C% E9% A8% 93% E5% 86% 8D% E7% 94% 9F). Prenez l'expérience proportionnellement au rang d'erreur TD plutôt que aléatoire. Par exemple, si vous avez trois expériences, la première place est à 50%, la deuxième à 33% et la troisième à 17%.

Cela semble beaucoup plus efficace que ReplayMemory (sélection aléatoire), Je ne comprends pas vraiment la différence avec le proportionnel. Cela devrait être un peu plus rapide en termes de vitesse ...

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

Les paramètres seront décrits plus loin.

Paramètres de PERProportionalMemory et PERRankBaseMemory

Aperçu Moule Exemple Remarques
capacity Capacité maximale de stockage en mémoire int 1_000_000
alpha Taux de réflexion de probabilité float 0.9 0.0~1.0
beta_initial Valeur initiale du taux de réflexion SI float 0.0 0.0~1.0
beta_steps Taux de réflexion SI 1.Nombre de pas à 0 int 100_000 Dépend du nombre d'apprentissage
enable_is Activer le SI bool True

Ici [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 est-importance-échantillonnage). Lorsqu'on donne des expériences selon la distribution de probabilité, il y a un biais dans le nombre de fois que chaque expérience est sélectionnée. Si le nombre de sélections d'expérience est biaisé, l'apprentissage sera biaisé, et il est important d'éviter cela dans l'échantillonnage par importance.

Plus précisément, une expérience sélectionnée avec une probabilité élevée a un faible taux de réflexion pour mettre à jour la valeur Q, et une expérience sélectionnée avec une faible probabilité a un taux de réflexion élevé pour mettre à jour la valeur Q.

L'apprentissage semble stable en introduisant le SI. De plus, IS recuit (réfléchit progressivement).

Paramètres liés à l'apprentissage

Aperçu Moule Exemple Remarques
memory_warmup_size/ remote_memory_warmup_size Taille qui n'apprend pas tant que l'expérience n'est pas accumulée dans la mémoire int 1000
target_model_update Intervalle de mise à jour vers le modèle cible int 10000
gamma Taux d'actualisation Q Learning float 0.99 0.0~1.0
enable_double_dqn Utiliser ou non DoubleDQN bool True
enable_rescaling Utiliser ou non la fonction de redimensionnement bool True
rescaling_epsilon Constantes utilisées dans la fonction de redimensionnement float 0.001
priority_exponent Ratio lors du calcul des priorités d'expérience float 0.9 Utilisez uniquement LESTFUL
burnin_length burn-en période int 2 Utilisez uniquement LESTFUL
reward_multisteps Nombre d'étapes dans MultiStep Reward int 3

Relation d'action

Aperçu Moule Exemple Remarques
action_interval Intervalle d'exécution de l'action int 1 1 ou plus
action_policy Mesures à utiliser dans l'exécution des actions Policy(Mise en œuvre originale) Voir ci-dessous

ε-greedy ε-greedy agit aléatoirement s'il est inférieur à $ epsilon $ pour des nombres aléatoires (0,0 à 1,0). S'il est plus grand que cela, sélectionnez l'action qui maximise la valeur Q.

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 La méthode utilisée dans% 81% AE% E6% B1% BA% E5% AE% 9A). C'est une méthode pour abaisser $ epsilon $ en ε-gourmand (selon la valeur Q) à mesure que l'apprentissage progresse.

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

ε-greedy(Actor) Méthode utilisée dans Ape-X est. $ Epsilon $ en ε-gourmand est calculé en fonction du nombre d'acteurs.

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

Softmax C'est une méthode pour déterminer l'action par la distribution de probabilité de la fonction Softmax de la valeur Q. En bref, plus la valeur Q est élevée, plus elle est facile à sélectionner, et plus la valeur Q est basse, plus elle est difficile à sélectionner.

SoftmaxPolicy()

Il n'y a pas d'arguments.

UCB(Upper Confidence Bound)1 UCB1 est une méthode de sélection d'une action en considérant non seulement la valeur Q, mais également le nombre de fois où l'action est sélectionnée. L'idée est de rechercher des actions qui ne sont pas beaucoup sélectionnées car la recherche n'est pas si avancée et il peut y avoir des récompenses inconnues.

UCB1()

Il n'y a pas d'arguments. De plus, le coût de la formation augmente car le modèle NN est conservé et formé à l'intérieur.

UCB1-Tuned UCB1-Tuned est un algorithme amélioré pour UCB1 qui prend également en compte la distribution. Il donne de meilleurs résultats que UCB1, mais il n'y a aucune garantie théorique.

UCB1_Tuned()

Il n'y a pas d'arguments. De plus, le coût de la formation augmente car le modèle NN est conservé et formé à l'intérieur.

UCB-V Il s'agit d'un algorithme plus soucieux de la distribution que UCB1-Tuned.

UCBv()

Il n'y a pas d'arguments. De plus, le coût de la formation augmente car le modèle NN est conservé et formé à l'intérieur.

KL-UCB C'est un algorithme qui trouve la valeur optimale théorique du dilemme de recherche et de récompense. Cependant, la mise en œuvre peut être un peu étrange ...

KL_UCB()

Il n'y a pas d'arguments. De plus, le coût de la formation augmente car le modèle NN est conservé et formé à l'intérieur.

Échantillonnage de Thompson (distribution bêta)

Thompson Sampling est un algorithme basé sur une estimation de base. C'est aussi l'optimum théorique pour le dilemme d'exploration et de récompense.

La distribution bêta est une distribution qui peut être appliquée lorsqu'elle prend une valeur binaire de 0 ou 1. Dans l'implémentation, si la récompense est supérieure à 0, elle est traitée comme 1, et si elle est égale ou inférieure à 0, elle est traitée comme 0.

ThompsonSamplingBeta()

Il n'y a pas d'arguments. De plus, le coût de la formation augmente car le modèle NN est conservé et formé à l'intérieur.

Échantillonnage de Thompson (distribution normale)

Thompson Sampling est un algorithme basé sur une estimation de base. C'est aussi l'optimum théorique pour le dilemme d'exploration et de récompense.

L'algorithme est appliqué en supposant que la récompense suit une distribution normale.

ThompsonSamplingGaussian()

Il n'y a pas d'arguments. De plus, le coût de la formation augmente car le modèle NN est conservé et formé à l'intérieur.

Uniquement lié à Rainbow (DQN)

Aperçu Moule Exemple Remarques
train_interval Intervalle d'apprentissage int 1 1 ou plus

Vous pouvez augmenter l'intervalle d'entraînement en augmentant train_interval.

Uniquement lié à R2D2

Aperçu Moule Exemple Remarques
actors Spécifier la classe d'acteur Actor(Mise en œuvre originale) Voir ci-dessous
actor_model_sync_interval Intervalle de synchronisation du modèle NN à partir de l'apprenant int 500

Actor C'est une classe qui exprime Actor par sa propre implémentation. Il en hérite et définit la politique et env.fit que chaque acteur exécute.

Ceci est un exemple de définition.

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()

Dans getPolicy, spécifiez la stratégie d'action utilisée par cet acteur. Dans fit, laissez agetn dans l'argument exécuter fit to learn.

Soyez prudent lorsque vous passez à R2D2, passez la classe elle-même (ne pas instancier)

from src.r2d2 import R2D2
kwargs = {
    "actors": [MyActor]  #Passer le cours lui-même
(réduction)
}
manager = R2D2(**kwargs)

Si vous souhaitez augmenter le nombre d'acteurs, augmentez le nombre d'éléments dans le tableau.

Exemple de 4 acteurs


from src.r2d2 import R2D2
kwargs = {
    "actors": [MyActor, MyActor, MyActor, MyActor]
(réduction)
}
manager = R2D2(**kwargs)

Autre

MovieLogger(Rainbow/R2D2)

Rappel qui produit une vidéo. Il peut être utilisé avec Rainbow et R2D2.

from src.callbacks import MovieLogger

#Ajoutez-le à l'argument callcacks de test.
movie = MovieLogger()
agent.test(env, nb_episodes=1, visualize=False, callbacks=[movie])

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

・ Exemple de sortie pendulum.gif

Visualisation de couche intermédiaire de NN (Rainbow / R2D2)

Rappel pour la visualisation des couches Conv, Advance et Value introduites dans Article précédent. Il peut être utilisé avec Rainbow et R2D2.

from src.callbacks import ConvLayerView

#Spécifiez l'agent lors de l'initialisation.
conv = ConvLayerView(agent)

#Faites un test.
#Spécifiez l'objet ConvLayerView dans l'argument des rappels
agent.test(env, nb_episodes=1, visualize=False, callbacks=[conv])

#Enregistrez le résultat.
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,
)

De plus, ConvLayerView ne fonctionne que si l'entrée est une image (InputType est GRAY_2ch, GRAY_3ch, COLOR).

・ Exemple de sortie pendulum1_min.gif

Logger2Stage(Rainbow) Il fournit les deux fonctions suivantes.

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

#Créer un agent et un environnement séparés pour les tests
kwargs = (réduction)
test_agent = Rainbow(**kwargs)
test_env = gym.make(ENV_NAME)

#divers paramètres
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
)

#Ajouter aux rappels lors de l'apprentissage
#Logger2Stage produit le journal, donc verbeux=0
agent.fit(env, nb_steps=1_750_000, visualize=False, verbose=0, callbacks=[log])

#Vous pouvez obtenir les journaux avec la fonction getLogs(Vous devez spécifier savefile)
history = log.getLogs()

#C'est simple, mais vous pouvez également générer des graphiques(Vous devez spécifier savefile)
log.drawGraph()

・ Exemple de sortie

--- 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)
(réduction)
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 utilise le multitraitement et la méthode de mise en œuvre est assez spéciale. En particulier, cela a considérablement affecté la sauvegarde / le chargement du modèle, je l'ai donc préparé séparément.

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

#Création de R2D2
kwargs = (réduction)
manager = R2D2(**kwargs)

#Créer un SaveManager
save_manager = SaveManager(
    save_dirpath="tmp",
    is_load=False,
    save_overwrite=True,
    save_memory=True,
    checkpoint=True,
    checkpoint_interval=2000,
    verbose=0
)

#Commencez à apprendre, ajoutez à l'argument des rappels.
manager.train(
    nb_trains=20_000,
    callbacks=[save_manager],
)

#Appelez ce qui suit pour créer un agent pour le test
# save_dirpath/last/learner.Veuillez préciser dat.
agent = manager.createTestAgent(MyActor, "tmp/last/learner.dat")

#Faites un test.
agent.test(env, nb_episodes=5, visualize=True)

Il fournit les deux fonctions suivantes.

De plus, contrairement à Rainbow, il n'y a qu'un intervalle d'acquisition dans le temps.

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

#Création de R2D2
kwargs = (réduction)
manager = R2D2(**kwargs)

#Créer un environnement pour le test
test_env = gym.make(ENV_NAME)

#Créer l'étape Logger2
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,
)

#Commencez à apprendre, ajoutez à l'argument des rappels.
manager.train(
    nb_trains=20_000,
    callbacks=[log],
)

#Vous pouvez obtenir les journaux avec getLogs.(Si saveir est spécifié)
history = log.getLogs()

#Vous pouvez également facilement afficher un graphique.(Si saveir est spécifié)
log.drawGraph()

・ Exemple de sortie

--- 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
(réduction)
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

Exemple de valeur de réglage

Papier DQN (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

#Que fait AtariProcessor
#・ Redimensionner l'image(84,84)
#・ Coupure de récompense
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,         #Nombre de trames d'entrée
    "dense_units_num": 256,       #Nombre d'unités dans la couche dense
    "enable_dueling_network": False,
    "lstm_type": LstmType.NONE,           #Algorithme LSTM à utiliser

    # train/lié à l'action
    "memory_warmup_size": 50_000,    #Nombre d'étapes pour l'allocation de mémoire initiale(N'apprends pas)
    "target_model_update": 10_000,  #intervalle de mise à jour du réseau cible
    "action_interval": 4,       #Intervalle pour effectuer l'action
    "train_interval": 4,        #Intervalle d'apprentissage
    "batch_size": 32,     # batch_size
    "gamma": 0.99,        #Taux d'actualisation Q Learning
    "enable_double_dqn": False,
    "enable_rescaling": False,   #Activer ou non le redimensionnement
    "reward_multisteps": 1,      # multistep reward

    #Autre
    "processor": processor,
    "action_policy": AnnealingEpsilonGreedy(
        initial_epsilon=1.0,      #Ε initiale
        final_epsilon=0.05,        #Ε à l'état final
        exploration_steps=1_000_000  #Nombre d'étapes de l'état initial à l'état final
    ),
    "memory": ReplayMemory(capacity=1_000_000),

}
agent = Rainbow(**kwargs)

Échantillon Keras-RL (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,         #Nombre de trames d'entrée
    "dense_units_num": 16,       #Nombre d'unités dans la couche dense
    "enable_dueling_network": False,
    "lstm_type": LstmType.NONE,
    
    # train/lié à l'action
    "memory_warmup_size": 10,    #Nombre d'étapes pour l'allocation de mémoire initiale(N'apprends pas)
    "target_model_update": 1,  #intervalle de mise à jour du réseau cible
    "action_interval": 1,       #Intervalle pour effectuer l'action
    "train_interval": 1,        #Intervalle d'apprentissage
    "batch_size": 32,     # batch_size
    "gamma": 0.99,        #Taux d'actualisation Q Learning
    "enable_double_dqn": False,
    "enable_rescaling": False,
    
    #Autre
    "processor": processor,
    "action_policy": SoftmaxPolicy(),
    "memory": ReplayMemory(capacity=50000)
}
agent = Rainbow(**kwargs)

Papier de Rainbow (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

#Que fait AtariProcessor
#・ Redimensionner l'image(84,84)
#・ Coupure de récompense
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,         #Nombre de trames d'entrée
    "dense_units_num": 512,       #Nombre d'unités dans la couche dense
    "enable_dueling_network": True,
    "dueling_network_type": DuelingNetwork.AVERAGE,  #Algorithme utilisé dans le réseau de duel
    "lstm_type": LstmType.NONE,
    
    # train/lié à l'action
    "memory_warmup_size": 80000,    #Nombre d'étapes pour l'allocation de mémoire initiale(N'apprends pas)
    "target_model_update": 32000,  #intervalle de mise à jour du réseau cible
    "action_interval": 4,       #Intervalle pour effectuer l'action
    "train_interval": 4,        #Intervalle d'apprentissage
    "batch_size": 32,     # batch_size
    "gamma": 0.99,        #Taux d'actualisation Q Learning
    "enable_double_dqn": True,
    "enable_rescaling": False,
    "reward_multisteps": 3,    # multistep reward
    
    #Autre
    "processor": processor,
    "action_policy": AnnealingEpsilonGreedy(
        initial_epsilon=1.0,      #Ε initiale
        final_epsilon=0.05,        #Ε à l'état final
        exploration_steps=1_000_000  #Nombre d'étapes de l'état initial à l'état final
    ),
    "memory": PERProportionalMemory(
        capacity=1_000_000,
        alpha=0.5,           #Taux de réflexion de probabilité du PER
        beta_initial=0.4,    #Valeur initiale du taux de réflexion SI
        beta_steps=1_000_000,  #Nombre d'étapes pour augmenter le taux de réflexion du SI
        enable_is=True,     #Activer le SI
    )
}
agent = Rainbow(**kwargs)

Papier R2D2 (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()


#Que fait AtariProcessor
#・ Redimensionner l'image(84,84)
#・ Coupure de récompense
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,             #Nombre de trames d'entrée
    "dense_units_num": 512,           #Nombre d'unités dans la couche dense
    "enable_dueling_network": True,  # dueling_indicateur valide du réseau
    "dueling_network_type": DuelingNetwork.AVERAGE,   # dueling_algorithme de réseau
    "lstm_type": LstmType.STATEFUL,  #Algorithme LSTM
    "lstm_units_num": 512,            #Nombre d'unités dans la couche LSTM
    "lstm_ful_input_length": 40,      #Entrées LSTM avec état

    # train/lié à l'action
    "remote_memory_warmup_size": 50_000,  #Nombre d'étapes pour l'allocation de mémoire initiale(N'apprends pas)
    "target_model_update": 10_000,  #intervalle de mise à jour du réseau cible
    "action_interval": 4,    #Intervalle pour effectuer l'action
    "batch_size": 64,
    "gamma": 0.997,           #Taux d'actualisation Q Learning
    "enable_double_dqn": True,   #Indicateur valide DDQN
    "enable_rescaling": enable_rescaling,    #Activer ou non le redimensionnement(priotrity)
    "rescaling_epsilon": 0.001,  #constante de remise à l'échelle
    "priority_exponent": 0.9,   #priorité prioritaire
    "burnin_length": 40,          # burn-en période
    "reward_multisteps": 3,  # multistep reward

    #Autre
    "processor": processor,
    "actors": [MyActor for _ in range(256)],
    "remote_memory": PERProportionalMemory(
        capacity= 1_000_000,
        alpha=0.6,             #Taux de réflexion de probabilité du PER
        beta_initial=0.4,      #Valeur initiale du taux de réflexion SI
        beta_steps=1_000_000,  #Nombre d'étapes pour augmenter le taux de réflexion du SI
        enable_is=True,        #Activer le SI
    ),

    #relation d'acteur
    "actor_model_sync_interval": 400,  #Intervalle de synchronisation du modèle à partir de l'apprenant

}
manager = R2D2(**kwargs)

Épilogue

Il y a trop de paramètres ... Il semble que quelque chose appelé R2D3 a été annoncé, et nous allons l'implémenter bientôt.

Recommended Posts

[Renforcement de l'apprentissage] R2D2 implémenté / expliqué Explication du paramètre Revenge Hyper (Keras-RL)
[Renforcement de l'apprentissage] Commentaire de vengeance (Keras-RL) qui a tenté de mettre en œuvre / d'expliquer R2D2
[Renforcer l'apprentissage] J'ai implémenté / expliqué R2D3 (Keras-RL)
Apprentissage par renforcement profond 2 Mise en œuvre de l'apprentissage par renforcement
[Python] Essayez facilement l'apprentissage amélioré (DQN) avec Keras-RL
Apprentissage par renforcement futur_2
Apprentissage par renforcement futur_1