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.

github

table des matières

Explication des paramètres communs
Explication des paramètres spécifiques à Rainbow / R2D2
Explication des fonctions autres que l'apprentissage
Visualisation de la couche intermédiaire du modèle NN
Animation
save/load
Obtenez le journal de l'historique d'apprentissage
Exemple de paramétrage Hyper
DQN (papier)
Échantillon Keras-RL Cartpole
Arc-en-ciel (papier)
R2D2 (papier)

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

input_shape Spécifiez le format d'entrée avec tuple. S'il s'agit d'une image, elle est au format (largeur, hauteur). Dans le cas de Gym, c'est le format qui peut être obtenu par env.observation_space.shape.
input_type C'est une spécification qui complète la forme d'entrée ci-dessus. Il est mis en œuvre indépendamment. Les quatre types suivants sont supposés et spécifiés en fonction du contenu de input_shape.

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

image_model C'est le contenu expliqué dans Article précédent. Cependant, il n'existe actuellement que deux types. S'il ne s'agit pas d'une image, spécifiez Aucun, et s'il s'agit d'une image, spécifiez DQNImageModel ().
nb_actions Spécifiez le format de sortie avec int. Cela équivaut au nombre d'actions que l'agent peut sélectionner. Par exemple, si vous vous arrêtez à gauche et à droite, il y aura 3 actions s'il y a 3 méthodes d'opération. Pour Gym, vous pouvez l'obtenir avec env.action_space.n. (Format discret uniquement)
processor Une classe qui fournit des fonctionnalités de personnalisation pour Env fournies par Gym. (processeur (officiel Keras-rl))

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

batch_size La taille de lot utilisée pour l'apprentissage par mini-lots. (Pour le lot, ici (Keras officiel)) On dit que l'augmentation de la taille du lot augmente l'efficacité de l'apprentissage et la vitesse d'apprentissage. Cependant, contrairement à l'apprentissage supervisé, l'apprentissage renforcé n'a pas de restrictions sur les données de formation, donc l'augmentation de la taille du lot augmentera le coût d'apprentissage (la vitesse de convergence dans un apprentissage augmentera, mais cela prendra du temps, donc le nombre de fois pour rechercher de nouvelles expériences (Réduit), donc je pense qu'il vaut mieux ne pas trop augmenter. En outre, la taille du lot doit être de 2 ^ n.
optimizer Spécifie l'optimiseur Keras que vous spécifiez lorsque vous compilez le modèle NN. Pour plus de détails, reportez-vous à Comment utiliser l'optimiseur (optimiseur) (officiel de Keras).
metrics Spécifie la fonction d'évaluation Keras. Je ne sais pas grand chose car je ne l'ai pas utilisé ... Pour plus de détails, reportez-vous à Comment utiliser la fonction d'évaluation (formule Keras).
input_sequence (anciennement window_length) Le nombre d'observations à utiliser pour l'entrée. 1 utilise uniquement la dernière image 1 comme entrée, et 4 utilise les 4 dernières images comme entrée. L'augmentation de cette valeur augmentera l'expressivité de l'entrée, mais augmentera le coût d'apprentissage.
dense_units_num Le nombre d'unités dans la couche Dense. L'augmentation de cette valeur augmentera l'expressivité de NN, mais augmentera le coût d'apprentissage.
enable_dueling_network S'il faut activer Dueling Network. Dueling Network vise à améliorer l'efficacité de l'apprentissage en permettant à NN d'apprendre en séparant les états et les actions.
dueling_network_type C'est l'algorithme utilisé pour séparer les états et les actions dans DuelingNetwork. Vous pouvez spécifier parmi les trois types suivants. Le document a déclaré que Average donnait les meilleurs résultats.

`DuelingNetwork`


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

lstm_type
Spécifiez le type lors de l'utilisation de LSTM. Avec LSTM, vous pouvez également obtenir des informations sur les séries chronologiques, mais le coût d'apprentissage augmentera. S'il n'est pas utilisé, spécifiez AUCUN. La spécification de STATELESS ajoute une couche LSTM simple équivalente à DRQN au modèle NN. La spécification de STATEFUL ajoute une couche LSTM au modèle NN qui effectue un traitement complexe équivalent à R2D2. STATEFUL est plus efficace que STATELESS, mais cela coûte beaucoup plus cher.

`LstmType`


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

lstm_ful_input_length
Le nombre d'apprentissages d'entrée par apprentissage dans l'apprentissage STATEFUL. Lorsque vous apprenez avec STATEFUL, vous pouvez augmenter le nombre d'apprentissage par ordre chronologique. Spécifiez ici le nombre de temps d'apprentissage le long de la série chronologique. (Pour plus de détails, voir Article précédent) L'augmentation du nombre augmentera (probablement) l'efficacité de l'apprentissage, mais augmentera les coûts d'apprentissage.

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
)

capacity
Capacité maximale de stockage en mémoire. Il vaut mieux en avoir plus, mais si c'est trop, la mémoire physique côté PC sera compressée, donc elle est modérée.

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
)

capacity
Capacité maximale de stockage en mémoire.

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

capacity Capacité maximale de stockage en mémoire.
alpha Taux de réflexion de Priority / RankBase. (0,0-1,0) 0.0 est complètement aléatoire (similaire à Replay Memory), 1.0 suit complètement la distribution de probabilité.

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

beta_initial C'est la valeur initiale du taux de réflexion SI. (0.0 n'utilise pas IS, 1.0 reflète IS)
beta_steps Il s'agit du nombre d'étapes nécessaires pour définir le taux de réflexion du SI sur 1,0. Veuillez préciser en fonction du nombre d’apprentissage.
enable_is S'il faut activer IS.

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

memory_warmup_size / remote_memory_warmup_size Dans l'état initial, il n'y a pas d'expérience de la mémoire et l'apprentissage n'est pas possible. Par conséquent, créez une période de non-apprentissage jusqu'à ce que l'expérience soit accumulée dans la mémoire. Spécifiez la période ici. Je pense qu'une valeur supérieure à batch_size et pas trop petite est bonne. (Si vous le réduisez trop, vous risquez de tomber dans une solution locale s'il y a des données empiriques biaisées au début)
target_model_update Intervalle de mise à jour pour Réseau cible dans DQN. Mises à jour DQN à l'aide d'un réseau Q dédié appelé Target Network. TargetNetwork n'apprend pas et copie le réseau Q actuel à intervalles réguliers. En faisant cela, un décalage sera créé dans le réseau Q utilisé pour la mise à jour et la mise à jour sera meilleure.
gamma [Taux de remise sur l'apprentissage Q](https://qiita.com/pocokhc/items/8ed40be84a144b28180d#q%E5%AD%A6%E7%BF%92%E3%81%AB%E3%81%A4%E3% 81% 84% E3% 81% A6). Spécifie le degré de propagation de la récompense. Eh bien, je pense qu'une valeur proche de 1,0 est bien.
enable_double_dqn DoubleDQN apprenait en sélectionnant la valeur Q maximale au moment de l'apprentissage, mais elle peut être surestimée en raison de l'influence du bruit, etc. C'est une méthode proposée car elle a des relations sexuelles et n'est pas bonne. Je pense que l'efficacité de l'apprentissage augmentera si DoubleDQN est utilisé.
enable_rescaling Spécifie s'il faut utiliser la fonction de remise à l'échelle (https://qiita.com/pocokhc/items/408f0f818140924ad4c4#rescaling-%E9%96%A2%E6%95%B0) pour la récompense. Si vous utilisez la fonction de remise à l'échelle, la récompense sera arrondie dans une certaine mesure, vous pouvez donc réduire la fluctuation de l'apprentissage due à la récompense.
rescaling_epsilon Une constante utilisée dans la fonction de redimensionnement. Cela semble être une constante qui l'empêche de devenir 0, et je pense que cela devrait être une valeur proche de 0. (0,001 est le nombre utilisé dans le papier)
priority_exponent [Calcul de la priorité (priorité de l'expérience)] utilisé dans l'apprentissage LSTM (LSTMFUL) équivalent à R2D2 (https://qiita.com/pocokhc/items/3b64d747a2f36da559c3#priority%E3%81%AE%E8%A8% 88% E7% AE% 97% E6% 96% B9% E6% B3% 95). LSTMFUL détermine la priorité finale (priorité d'expérience) en fonction de plusieurs priorités. La méthode de calcul est la valeur maximale de $ Priority + la valeur moyenne de Priority $. Le rapport entre cette valeur maximale et cette valeur moyenne reflétée est priority_exponent. Dans le cas de 0,9, la valeur maximale de $ Priority * 0,9 + la valeur moyenne de Priority * 0,1 $. Dans l'article, il était écrit qu'environ 0,9 était un bon résultat.
burnin_length Il s'agit du nombre de Burn-in utilisé dans l'apprentissage LSTM (LSTMFUL) équivalent à R2D2. En gros, il existe une différence entre l'état passé (lors du stockage des données d'expérience) et l'état actuel dans LST MFUL. Par conséquent, il s'agit d'une méthode pour définir une période pour la circulation des données d'expérience sans apprentissage afin de se rapprocher de l'état actuel avant l'apprentissage. Augmenter burnin_length rendra l'apprentissage plus précis, mais augmentera le coût de l'apprentissage.
reward_multisteps Il s'agit du nombre d'étapes de l 'Apprentissage en plusieurs étapes. Normalement, la récompense pour 1 pas est utilisée, mais la récompense pour n-step est utilisée. C'est comme apprendre avec une petite récompense future en tête (?) 3step est la valeur utilisée dans le papier.

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

action_interval L'intervalle de mise à jour de l'action. Par exemple, si vous le définissez sur 4, l'action sera mise à jour toutes les 4 images. (Effectue la même action sans mise à jour)
action_policy Spécifie la stratégie pour exécuter l'action. Pour plus de détails sur chaque stratégie, reportez-vous à Article précédent.

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

initial_epsilon Initialement $ epsilon $.
final_epsilon L'état final est $ epsilon $.
exploration_steps Spécifiez le nombre d'étapes entre l'état initial et l'état final.

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

actor_index Spécifiez l'index de l'acteur.
actors_length Le nombre total d'acteurs.
epsilon Spécifiez la référence $ epsilon $.
alpha C'est une constante utilisée dans le calcul.

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