Une réimpression en japonais de l'article du blog rédigé en anglais.

1.Tout d'abord

Le 26 mai, DeepMind a publié Reverb en tant que cadre pour Experience Replay dans un apprentissage amélioré. (Référence)

Reverb is an efficient and easy-to-use data storage and transport system designed for machine learning research. Reverb is primarily used as an experience replay system for distributed reinforcement learning algorithms but the system also supports multiple data structure representations such as FIFO, LIFO, and priority queues.

Reverb est un système de stockage et de transfert de données efficace et facile à utiliser conçu pour la recherche en apprentissage automatique. La réverbération est principalement utilisée pour la relecture d'expérience pour les algorithmes d'apprentissage amélioré distribués, mais le système prend en charge les structures de données telles que FIFO, LIFO et les files d'attente pondérées. (Jusqu'à ici traduit par l'auteur)

Le cadre d'apprentissage par renforcement de DeepMind Acme (Un cadre de recherche pour l'apprentissage par renforcement) utilise cette réverbération. (Pour Acme, saisissez une autre opportunité)

2. Installation

Au 26 juin, au moment de la rédaction de cet article, Reverb déclare officiellement qu'il ne prend en charge que les systèmes d'exploitation basés sur Linux et n'est pas au niveau de l'utilisation en production.

Une version de développement de TensorFlow est requise et peut être installée à partir de PyPI avec la commande suivante

pip install tf-nightly==2.3.0.dev20200604 dm-reverb-nightly

3. Architecture

Reverb utilise une approche serveur-client, et je pense que ses règles de dénomination sont plus proches des termes de la base de données que les autres implémentations de Replay Buffer.

3.1 Serveur

L'exemple de code côté serveur est le suivant.

import reverb

server = reverb.Server(tables=[
    reverb.Table(
        name='my_table',
        sampler=reverb.selectors.Uniform(),
        remover=reverb.selectors.Fifo(),
        max_size=100,
        rate_limiter=reverb.rate_limiters.MinSize(1)),
    ],
    port=8000
)

Dans cet exemple, un tampon de relecture normal d'une capacité de «100» (échantillonnage uniforme, écrasement du plus ancien au plus récent) écoute sur le port «8000». reverb.rate_limiters.MinSize (1) signifie bloquer toute demande d'échantillonnage jusqu'à ce qu'au moins "1" éléments soient dans.

3.1.1 Sélection des éléments (`sampler` / `remove`)

Comme vous pouvez le voir dans l'exemple ci-dessus, Reverb vous permet de spécifier indépendamment la logique d'échantillonnage et de suppression (écrasement) des éléments.

La logique prise en charge par Reverb est implémentée dans reverb.selectors et présente les éléments suivants:

ʻUniform`: sélectionné au hasard parmi tous les articles avec une distribution uniforme
Prioritaire: sélectionné au hasard selon la priorité
Fifo: Sélectionnez les données les plus anciennes
Lifo: Sélectionnez les dernières données
MinHeap: Sélectionnez les données avec la priorité la plus basse
MaxHeap: Sélectionnez les données avec la priorité la plus élevée

3.1.2 Spécification de contrainte (`rate_limiter`)

L'argument rate_limiter peut définir les conditions d'utilisation du tampon de relecture. Les conditions supportées par Reverb sont implémentées dans reverb.rate_limiters et Il y a les suivants

MinSize: Définissez le nombre minimum d'éléments pouvant être échantillonnés
SampleToInsertRatio: Définit le ratio moyen d'insertion de données (mise à jour) et d'échantillon de données
Utile pour combien de fois il est échantillonné avant qu'il ne soit écrasé (apparemment)
Queue: extrait exactement une fois avant d'être écrasé (pour FIFO)
Stack: extrait exactement une fois avant d'être écrasé (pour LIFO)

En regardant les commentaires dans le code source, il n'est pas recommandé d'utiliser reverb.rate_limiters.Queue et reverb.rate_limiters.Stack directement, à la place les méthodes statiques reverb.Table.queue etIl définitsampler, removeetrate_limiter de manière appropriée pour que reverb.Table.stack soit un tampon de relecture avec respectivement les logiques FIFO et LIFO.

3.2 Client

L'exemple de code du programme client est ci-dessous

import reverb

client = reverb.Client('localhost:8000') #Si le serveur et le client sont la même machine

# [0,1]Etat(observation)Priorité 1.Exemple de mise en mémoire tampon de relecture avec 0
client.insert([0, 1], priorities={'my_table': 1.0})

#Après échantillonnage, le générateur est retourné
client.sample('my_table', num_samples=2))

3.3 Enregistrer / charger

Reverb prend en charge les fonctions de sauvegarde / chargement de données. En exécutant le code suivant à partir du client, les données du serveur actuel sont enregistrées sur le fichier et le chemin du fichier enregistré peut être obtenu.

checkpoint_path = client.checkpoint()

L'état des données d'origine peut être restauré en créant un serveur à l'aide des données enregistrées. Il est à noter que l'argument tables du constructeur ne spécifie pas ** exactement la même chose que le serveur d'origine qui a stocké les données ** sous la responsabilité de l'utilisateur.

checkpointer = reverb.checkpointers.DefaultCheckpointer(path=checkpoint_path)
server = reverb.Server(tables=[...], checkpointer=checkpointer)

finalement

Le nouveau cadre de DeepMind pour Experience Replay, Reverb, n'a pas encore atteint une version stable, mais j'ai senti qu'il était prometteur pour un apprentissage d'augmentation flexible et à grande échelle.

Pour ma bibliothèque Experience Replay cpprb, un énorme rival est soudainement apparu, mais dans une expérience d'entraînement plus petite, cpprb Je pense que certaines pièces sont plus pratiques et plus faciles à utiliser. (Voir Anciens articles Qiita)

(Mise à jour: 2020.6.29) J'ai recherché et écrit Comment utiliser le client!

[Renforcement de l'apprentissage] Bomb: DeepMind Experience Replay Framework Reverb