Passons à l’apprentissage par renforcement. Dans cet article, nous aborderons un problème concret avec les bibliothèques modernes telles que TensorFlow, TensorBoard, Keras et OpenAI gym. Vous verrez comment implémenter l'un des algorithmes fondamentaux appelés deep $ Q $ -learning pour apprendre son fonctionnement interne. En ce qui concerne le matériel, tout le code fonctionnera sur un PC typique et utilisera tous les cœurs de processeur trouvés (cela est géré par TensorFlow).

Le problème s'appelle Mountain Car: une voiture est sur une piste unidimensionnelle, positionnée entre deux montagnes. Le but est de monter la montagne à droite (atteindre le drapeau). Cependant, le moteur de la voiture n’est pas assez puissant pour gravir la montagne en un seul passage. Par conséquent, la seule façon de réussir est de faire des allers-retours pour créer une dynamique.

Ce problème a été choisi car il est assez simple de trouver une solution avec apprentissage par renforcement en quelques minutes sur un seul cœur de processeur. Cependant, il est suffisamment complexe pour être un bon représentant.

Tout d'abord, je vais donner un bref résumé de ce que fait l'apprentissage par renforcement en général. Ensuite, nous couvrirons les termes de base et exprimerons notre problème avec eux. Après cela, je décrirai l'algorithme d'apprentissage profond de $ Q $ et nous l'implémenterons pour résoudre le problème.

Principes de base de l'apprentissage par renforcement

L'apprentissage par renforcement dans les mots les plus simples est l'apprentissage par essais et erreurs. Le personnage principal est appelé un «agent», ce qui serait une voiture dans notre problème. L'agent fait une action dans un environnement et reçoit une nouvelle observation et une récompense pour cette action. Les actions menant à des récompenses plus importantes sont renforcées, d'où le nom. Comme pour beaucoup d'autres choses en informatique, celle-ci a également été inspirée par l'observation de créatures vivantes.

Les interactions de l'agent avec un environnement sont résumées dans le graphique suivant:

analyse de régression dans les évaluations immobilières

L'agent obtient une observation et une récompense pour l'action effectuée. Ensuite, il effectue une autre action et passe à la deuxième étape. L'environnement renvoie maintenant une observation et une récompense (probablement) légèrement différentes. Cela continue jusqu'à ce que l'état du terminal soit atteint, signalé par l'envoi de «terminé» à un agent. Toute la séquence de observations> actions> prochaines_observations> récompenses s'appelle un épisode (ou une trajectoire).

Revenons à notre Mountain Car: notre voiture est un agent. L'environnement est un monde en boîte noire de montagnes unidimensionnelles. L’action de la voiture se résume à un seul chiffre: s’il est positif, le moteur pousse la voiture vers la droite. S'il est négatif, il pousse la voiture vers la gauche. L'agent perçoit un environnement à travers une observation: la position X et la vitesse de la voiture. Si nous voulons que notre voiture roule au sommet de la montagne, nous définissons la récompense d'une manière pratique: l'agent obtient -1 à sa récompense pour chaque étape dans laquelle il n'a pas atteint l'objectif. Lorsqu'il atteint l'objectif, l'épisode se termine. Donc, en fait, l'agent est puni pour ne pas être dans la position que nous voulons qu'il soit. Plus vite il l'atteint, mieux c'est pour lui. L’objectif de l’agent est de maximiser la récompense totale, qui correspond à la somme des récompenses d’un épisode. Donc, s'il atteint le point souhaité après, par exemple, 110 étapes, il reçoit un rendement total de -110, ce qui serait un excellent résultat pour Mountain Car, car s'il n'atteint pas l'objectif, il est puni de 200 étapes. (d'où un retour de -200).

C'est toute la formulation du problème. Maintenant, nous pouvons le donner aux algorithmes, qui sont déjà assez puissants pour résoudre de tels problèmes en quelques minutes (s'ils sont bien réglés). Il convient de noter que nous ne disons pas à l’agent comment atteindre l’objectif. Nous ne fournissons même aucun indice (heuristique). L'agent trouvera un moyen (une politique) de gagner par lui-même.

Configuration de l'environnement

Tout d'abord, copiez l'intégralité du code du didacticiel sur votre disque:

git clone https://github.com/AdamStelmaszczyk/rl-tutorial cd rl-tutorial

Maintenant, nous devons installer les packages Python que nous utiliserons. Pour ne pas les installer dans votre espace utilisateur (et risquer des collisions), nous allons les nettoyer et les installer dans l'environnement conda. Si vous n'avez pas installé conda, veuillez suivre https://conda.io/docs/user-guide/install/index.html .

Pour créer notre environnement conda:

conda create -n tutorial python=3.6.5 -y

Pour l'activer:

source activate tutorial

Vous devriez voir (tutorial) près de votre invite dans le shell. Cela signifie qu'un environnement conda avec le nom «tutoriel» est actif. Désormais, toutes les commandes doivent être exécutées dans cet environnement conda.

Maintenant, nous pouvons installer toutes les dépendances dans notre environnement conda hermétique:

pip install -r requirements.txt

Nous avons terminé l’installation, alors exécutons du code. Nous n'avons pas besoin de mettre en œuvre nous-mêmes l'environnement Mountain Car; la bibliothèque OpenAI Gym fournit cette implémentation. Voyons un agent aléatoire (un agent qui effectue des actions aléatoires) dans notre environnement:

import gym env = gym.make('MountainCar-v0') done = True episode = 0 episode_return = 0.0 for episode in range(5): for step in range(200): if done: if episode > 0: print('Episode return: ', episode_return) obs = env.reset() episode += 1 episode_return = 0.0 env.render() else: obs = next_obs action = env.action_space.sample() next_obs, reward, done, _ = env.step(action) episode_return += reward env.render()

C'est see.py fichier; pour l'exécuter, exécutez:

python see.py

Vous devriez voir une voiture aller et venir au hasard. Chaque épisode comprendra 200 étapes; le rendement total sera de -200.

meilleurs tutoriels c++

Nous devons maintenant remplacer les actions aléatoires par quelque chose de mieux. Il existe de nombreux algorithmes que l'on pourrait utiliser. Pour un didacticiel d'introduction, je pense qu'une approche appelée deep $ Q $ -learning est une bonne solution. Comprendre cette méthode donne une base solide pour apprendre d'autres approches.

Apprentissage profond en $ Q $

L'algorithme que nous utiliserons a été décrit pour la première fois en 2013 par Mnih et al. dans Jouer à Atari avec l'apprentissage par renforcement profond et poli deux ans plus tard en Contrôle au niveau humain grâce à un apprentissage par renforcement profond . De nombreux autres travaux reposent sur ces résultats, y compris l'algorithme de pointe actuel arc en ciel (2017):

Rainbow réalise des performances surhumaines sur de nombreux jeux Atari 2600. Nous nous concentrerons sur la version de base de DQN, avec le moins d'améliorations supplémentaires possible, pour garder ce tutoriel à une taille raisonnable.

Une politique, généralement notée $ π (s) $, est une fonction renvoyant des probabilités de prendre des actions individuelles dans un état donné $ s $. Ainsi, par exemple, une politique de Mountain Car aléatoire revient pour n'importe quel état: 50% à gauche, 50% à droite. Pendant le jeu, nous échantillonnons cette politique (distribution) pour obtenir des actions réelles.

$ Q $ -learning (Q est pour la qualité) fait référence à la fonction valeur-action notée $ Q_π (s, a) $. Il retourne le rendement total d'un état donné $ s $, en choisissant l'action $ a $, suivant une politique concrète $ π $. Le rendement total est la somme de toutes les récompenses dans un épisode (trajectoire).

Si nous connaissions la fonction optimale $ Q $, notée $ Q ^ * $, nous pourrions résoudre le jeu facilement. Nous suivrions simplement les actions avec la valeur la plus élevée de $ Q ^ * $, c'est-à-dire le rendement attendu le plus élevé. Cela garantit que nous atteindrons le rendement le plus élevé possible.

Cependant, nous ne connaissons souvent pas $ Q ^ * $. Dans de tels cas, nous pouvons l'approcher - ou «apprendre» - cela à partir des interactions avec l'environnement. C'est la partie «$ Q $ -learning» dans le nom. Il y a aussi le mot «profond» dedans parce que, pour approcher cette fonction, nous utiliserons des réseaux neuronaux profonds, qui sont des approximateurs de fonction universels. Les réseaux de neurones profonds qui se rapprochent des valeurs $ Q $ ont été appelés Deep Q-Networks (DQN). Dans des environnements simples (avec le nombre d'états en mémoire), on pourrait simplement utiliser une table au lieu d'un réseau neuronal pour représenter la fonction $ Q $, auquel cas elle serait nommée «tabulaire $ Q $ -learning».

Donc, notre objectif est maintenant d'approximer la fonction $ Q ^ * $. Nous utiliserons l'équation de Bellman:

[Q (s, a) = r + γ espace textrm {max} _ {a '} Q (s', a ') ]

$ s ’$ est l’état après $ s $. $ γ $ (gamma), généralement 0,99, est un facteur de remise (c'est un hyperparamètre). Cela donne moins de poids aux récompenses futures (car elles sont moins sûres que les récompenses immédiates avec nos $ Q $ imparfaits). L'équation de Bellman est au cœur de l'apprentissage profond en $ Q $. Il dit que la valeur $ Q $ pour un état et une action donnés est une récompense $ r $ reçue après avoir agi $ a $ plus la valeur $ Q $ la plus élevée pour l’État où nous atterrissons en $ s ’$. Le plus élevé est en ce sens que nous choisissons une action $ a ’$, ce qui conduit au rendement total le plus élevé à partir de $ s’ $.

Avec l'équation de Bellman, nous pouvons utiliser l'apprentissage supervisé pour approximer $ Q ^ * $. La fonction $ Q $ sera représentée (paramétrée) par des poids de réseau neuronal notés $ θ $ (thêta). Une implémentation simple prendrait un état et une action en tant qu'entrée réseau et produirait la valeur Q. L'inefficacité est que si nous voulons connaître les valeurs $ Q $ pour toutes les actions dans un état donné, nous devons appeler $ Q $ autant de fois qu'il y a d'actions. Il y a une bien meilleure façon: de ne prendre que l'état comme entrée et de sortir les valeurs $ Q $ pour toutes les actions possibles. Grâce à cela, nous pouvons obtenir des valeurs $ Q $ pour toutes les actions en une seule passe avant.

Nous commençons à entraîner le réseau $ Q $ avec des pondérations aléatoires. De l'environnement, nous obtenons de nombreuses transitions (ou «expériences»). Ce sont des tuples de (état, action, état suivant, récompense) ou, en bref, ($ s $, $ a $, $ s '$, $ r $). Nous stockons des milliers d’entre eux dans un tampon en anneau appelé «relecture d’expérience». Ensuite, nous échantillonnons les expériences de ce tampon avec le désir que l'équation de Bellman tienne pour elles. Nous aurions pu sauter le tampon et appliquer les expériences une par une (cela s'appelle «en ligne» ou «sur politique»); le problème est que les expériences ultérieures sont fortement corrélées les unes aux autres et que DQN s'entraîne mal lorsque cela se produit. C'est pourquoi la relecture de l'expérience a été introduite (une approche «hors ligne», «hors politique») pour briser cette corrélation de données. Le code de notre implémentation de tampon en anneau la plus simple se trouve dans le replay_buffer.py fichier, je vous encourage à le lire.

Au début, étant donné que les poids de notre réseau de neurones étaient aléatoires, la valeur du côté gauche de l'équation de Bellman sera loin du côté droit. La différence au carré sera notre fonction de perte. Nous minimiserons la fonction de perte en modifiant les poids du réseau neuronal $ θ $. Écrivons notre fonction de perte:

[L (θ) = [Q (s, a) - r - γ espace textrm {max} _ {a '} Q (s', a ')] ^ 2 ]

C’est une équation de Bellman réécrite. Supposons que nous ayons échantillonné une expérience ($ s $, gauche, $ s ’$, -1) à partir de la rediffusion de l'expérience Mountain Car. Nous faisons un passage en avant à travers notre réseau $ Q $ avec l'état $ s $ et pour l'action à gauche, il nous donne -120, par exemple. Donc, $ Q (s, textrm {gauche}) = -120 $. Ensuite, nous transmettons $ s ’$ au réseau, ce qui nous donne, par exemple, -130 pour la gauche et -122 pour la droite. Donc, clairement, la meilleure action pour $ s ’$ est juste, donc $ textrm {max} _ {a’} Q (s ’, a’) = -122 $. Nous connaissons $ r $, c'est la vraie récompense, qui était de -1. Donc, notre prédiction de réseau $ Q $ était légèrement fausse, car $ L (θ) = [-120 - 1 + 0.99 ⋅ 122] ^ 2 = (-0.22 ^ 2) = 0.0484 $. Nous propageons donc l'erreur en arrière et corrigeons légèrement les poids $ θ $. Si nous devions calculer à nouveau la perte pour la même expérience, elle serait maintenant inférieure.

Une observation importante avant de passer au code. Notons que, pour mettre à jour notre DQN, nous allons faire deux passes avant sur DQN… lui-même. Cela conduit souvent à un apprentissage instable. Pour éviter cela, pour la prédiction $ Q $ de l'état suivant, nous n'utilisons pas le même DQN. Nous utilisons une ancienne version de celui-ci, qui dans le code s'appelle target_model (au lieu de model, étant le DQN principal). Grâce à cela, nous avons un objectif stable. Nous mettons à jour target_model en le définissant sur model poids tous les 1000 pas. Mais model met à jour chaque étape.

Examinons le code créant le modèle DQN:

def create_model(env): n_actions = env.action_space.n obs_shape = env.observation_space.shape observations_input = keras.layers.Input(obs_shape, name='observations_input') action_mask = keras.layers.Input((n_actions,), name='action_mask') hidden = keras.layers.Dense(32, activation='relu')(observations_input) hidden_2 = keras.layers.Dense(32, activation='relu')(hidden) output = keras.layers.Dense(n_actions)(hidden_2) filtered_output = keras.layers.multiply([output, action_mask]) model = keras.models.Model([observations_input, action_mask], filtered_output) optimizer = keras.optimizers.Adam(lr=LEARNING_RATE, clipnorm=1.0) model.compile(optimizer, loss='mean_squared_error') return model

Tout d'abord, la fonction prend les dimensions de l'espace d'action et d'observation à partir de l'environnement OpenAI Gym donné. Il est nécessaire de savoir, par exemple, combien de sorties notre réseau aura. Il doit être égal au nombre d'actions. Les actions sont codées à chaud:

def one_hot_encode(n, action): one_hot = np.zeros(n) one_hot[int(action)] = 1 return one_hot

Donc (par exemple) à gauche sera [1, 0] et à droite sera [0, 1].

Nous pouvons voir que les observations sont passées en entrée. On passe aussi action_mask comme deuxième entrée. Pourquoi? Lors du calcul de $ Q (s, a) $, nous n'avons besoin de connaître la valeur $ Q $ que pour une action donnée, pas toutes. action_mask contient 1 pour les actions que nous voulons transmettre à la sortie DQN. Si action_mask a 0 pour une action, alors la valeur $ Q $ correspondante sera remise à zéro sur la sortie. Le filtered_output couche fait cela. Si nous voulons toutes les valeurs $ Q $ (pour le calcul maximum), nous pouvons simplement passer toutes.

Le code utilise keras.layers.Dense pour définir une couche entièrement connectée. Keras est une bibliothèque Python pour une abstraction de niveau supérieur au-dessus de TensorFlow. Sous le capot, Keras crée un graphique TensorFlow, avec des biais, une initialisation de poids appropriée et d'autres choses de bas niveau. Nous aurions pu simplement utiliser TensorFlow brut pour définir le graphique, mais ce ne sera pas une ligne unique.

Les observations sont donc transmises à la première couche cachée, avec des activations ReLU (unité linéaire rectifiée). ReLU(x) est juste une fonction $ textrm {max} (0, x) $. Cette couche est entièrement connectée à une deuxième couche identique, hidden_2. La couche de sortie réduit le nombre de neurones au nombre d'actions. En fin de compte, nous avons filtered_output, qui multiplie simplement la sortie par action_mask.

Pour trouver les poids $ θ $, nous utiliserons un optimiseur nommé «Adam» avec une perte d'erreur quadratique moyenne.

Ayant un modèle, nous pouvons l'utiliser pour prédire les valeurs $ Q $ pour des observations d'état données:

def predict(env, model, observations): action_mask = np.ones((len(observations), env.action_space.n)) return model.predict(x=[observations, action_mask])

Nous voulons des valeurs $ Q $ pour toutes les actions, donc action_mask est un vecteur de uns.

Pour faire la formation proprement dite, nous utiliserons fit_batch():

apprendre c vs c++

def fit_batch(env, model, target_model, batch): observations, actions, rewards, next_observations, dones = batch # Predict the Q values of the next states. Passing ones as the action mask. next_q_values = predict(env, target_model, next_observations) # The Q values of terminal states is 0 by definition. next_q_values[dones] = 0.0 # The Q values of each start state is the reward + gamma * the max next state Q value q_values = rewards + DISCOUNT_FACTOR_GAMMA * np.max(next_q_values, axis=1) one_hot_actions = np.array([one_hot_encode(env.action_space.n, action) for action in actions]) history = model.fit( x=[observations, one_hot_actions], y=one_hot_actions * q_values[:, None], batch_size=BATCH_SIZE, verbose=0, ) return history.history['loss'][0]

Le lot contient BATCH_SIZE expériences. next_q_values est $ Q (s, a) $. q_values est $ r + γ space textrm {max} _ {a ’} Q (s’, a ’) $ de l’équation de Bellman. Les actions que nous avons entreprises sont encodées à chaud et passées comme action_mask à l'entrée lors de l'appel model.fit(). $ y $ est une lettre courante pour une «cible» dans l'apprentissage supervisé. Ici, nous passons le q_values. Je fais q_values[:. None] pour augmenter la dimension du tableau car elle doit correspondre à la dimension de one_hot_actions tableau. C'est ce qu'on appelle la notation de tranche si vous souhaitez en savoir plus à ce sujet.

Nous renvoyons la perte pour la sauvegarder dans le fichier journal TensorBoard et la visualiser ultérieurement. Il y a beaucoup d'autres choses que nous surveillerons: le nombre de pas par seconde que nous faisons, l'utilisation totale de la RAM, quel est le retour d'épisode moyen, etc. Voyons ces graphiques.

Fonctionnement

Pour visualiser le fichier journal TensorBoard, nous devons d'abord en avoir un. Alors, exécutons simplement la formation:

python run.py

Cela imprimera d'abord le résumé de notre modèle. Ensuite, il créera un répertoire de journal avec la date actuelle et commencera la formation. Toutes les 2000 étapes, une ligne de connexion sera imprimée comme ceci:

episode 10 steps 200/2001 loss 0.3346639 return -200.0 in 1.02s 195.7 steps/s 9.0/15.6 GB RAM

Tous les 20000, nous évaluerons notre modèle sur 10000 étapes:

Evaluation 100%|█████████████████████████████████████████████████████████████████████████████████| 10000/10000 [00:07<00:00, 1254.40it/s] episode 677 step 120000 episode_return_avg -136.750 avg_max_q_value -56.004

Après 677 épisodes et 120 000 pas, le retour d'épisode moyen est passé de -200 à -136,75! C’est définitivement apprendre. Quoi avg_max_q_value est-ce que je pars comme un bon exercice pour le lecteur. Mais c’est une statistique très utile à examiner pendant la formation.

Après 200 000 pas, notre formation est terminée. Sur mon processeur à quatre cœurs, cela prend environ 20 minutes. Nous pouvons regarder à l'intérieur du date-log répertoire, par exemple, 06-07-18-39-log. Il y aura quatre fichiers de modèle avec le .h5 extension. Ceci est un instantané des poids des graphiques TensorFlow, nous les sauvegardons toutes les 50 000 étapes pour avoir plus tard un aperçu de la politique que nous avons apprise. Pour le visualiser:

python run.py --model 06-08-18-42-log/06-08-18-42-200000.h5 --view

Pour voir les autres drapeaux possibles: python run.py --help.

Maintenant, la voiture fait un bien meilleur travail pour atteindre l'objectif souhaité. Dans le date-log répertoire, il y a aussi le events.out.* fichier. C'est le fichier dans lequel TensorBoard stocke ses données. Nous y écrivons en utilisant le plus simple TensorBoardLogger défini dans loggers.py. Pour afficher le fichier d'événements, nous devons exécuter le serveur TensorBoard local:

tensorboard --logdir=.

--logdir pointe juste vers le répertoire dans lequel il y a des répertoires de date-log, dans notre cas, ce sera le répertoire courant, donc .. TensorBoard imprime l'URL sur laquelle il écoute. Si vous ouvrez http://127.0.0.1:6006 , vous devriez voir huit graphiques similaires à ceux-ci:

Emballer

train() fait toute la formation. Nous créons d'abord le modèle et rejouons le tampon. Ensuite, dans une boucle très similaire à celle de see.py, nous interagissons avec l'environnement et stockons les expériences dans le tampon. Ce qui est important, c’est que nous suivions une politique gourmande en epsilon. Nous pourrions toujours choisir la meilleure action en fonction de la fonction $ Q $; cependant, cela décourage l'exploration, ce qui nuit à la performance globale. Donc, pour forcer l'exploration avec la probabilité epsilon, nous effectuons des actions aléatoires:

def greedy_action(env, model, observation): next_q_values = predict(env, model, observations=[observation]) return np.argmax(next_q_values) def epsilon_greedy_action(env, model, observation, epsilon): if random.random()

Epsilon a été fixé à 1%. Après 2000 expériences, la rediffusion se remplit suffisamment pour commencer la formation. Nous le faisons en appelant fit_batch() avec un lot aléatoire d'expériences échantillonnées à partir du tampon de relecture:

batch = replay.sample(BATCH_SIZE) loss = fit_batch(env, model, target_model, batch)

Toutes les 20000 pas, nous évaluons et enregistrons les résultats (l'évaluation est avec epsilon = 0, politique totalement gourmande):

comment construire un conseil consultatif

if step >= TRAIN_START and step % EVAL_EVERY == 0: episode_return_avg = evaluate(env, model) q_values = predict(env, model, q_validation_observations) max_q_values = np.max(q_values, axis=1) avg_max_q_value = np.mean(max_q_values) print( 'episode {} ' 'step {} ' 'episode_return_avg {:.3f} ' 'avg_max_q_value {:.3f}'.format( episode, step, episode_return_avg, avg_max_q_value, )) logger.log_scalar('episode_return_avg', episode_return_avg, step) logger.log_scalar('avg_max_q_value', avg_max_q_value, step)

Le code entier fait environ 300 lignes et run.py contient environ 250 des plus importants.

On peut remarquer qu'il y a beaucoup d'hyperparamètres:

DISCOUNT_FACTOR_GAMMA = 0.99 LEARNING_RATE = 0.001 BATCH_SIZE = 64 TARGET_UPDATE_EVERY = 1000 TRAIN_START = 2000 REPLAY_BUFFER_SIZE = 50000 MAX_STEPS = 200000 LOG_EVERY = 2000 SNAPSHOT_EVERY = 50000 EVAL_EVERY = 20000 EVAL_STEPS = 10000 EVAL_EPSILON = 0 TRAIN_EPSILON = 0.01 Q_VALIDATION_SIZE = 10000

Et ce ne sont même pas tous. Il existe également une architecture réseau - nous avons utilisé deux couches cachées avec 32 neurones, des activations ReLU et un optimiseur Adam, mais il existe de nombreuses autres options. Même de petits changements peuvent avoir un impact énorme sur la formation. On peut passer beaucoup de temps à régler les hyperparamètres. Lors d'un récent concours OpenAI, un candidat à la deuxième place découvert il est possible de presque double Score de Rainbow après le réglage des hyperparamètres. Naturellement, il ne faut pas oublier qu’il est facile de sur-adapter. Actuellement, les algorithmes de renforcement ont du mal à transférer des connaissances vers des environnements similaires. Notre Mountain Car ne se généralise pas actuellement à tous les types de montagnes. Vous pouvez en fait modifier l'environnement OpenAI Gym et voir jusqu'où l'agent peut généraliser.

Un autre exercice sera de trouver un meilleur ensemble d'hyperparamètres que le mien. C'est tout à fait possible. Cependant, un seul entraînement ne suffira pas pour juger si votre changement est une amélioration. Il y a généralement une grande différence entre les courses d'entraînement; la variance est grande. Vous auriez besoin de plusieurs essais pour déterminer que quelque chose est mieux. Si vous souhaitez en savoir plus sur un sujet aussi important que la reproductibilité, je vous encourage à lire Apprentissage par renforcement profond qui compte . Au lieu de régler manuellement, nous pouvons automatiser ce processus dans une certaine mesure, si nous sommes prêts à dépenser plus de puissance de calcul sur le problème. Une approche simple consiste à préparer une plage de valeurs prometteuse pour certains hyperparamètres et à lancer une recherche de grille (en vérifiant leurs combinaisons), avec des formations fonctionnant en parallèle. La parallélisation elle-même est un sujet important en soi car elle est cruciale pour la haute performance.

Deep $ Q $ -learning représente une grande famille d'algorithmes d'apprentissage par renforcement qui utilisent l'itération de la valeur. Nous avons essayé d'approcher la fonction $ Q $, et nous l'avons simplement utilisée de manière gourmande la plupart du temps. Il existe une autre famille qui utilise l'itération de stratégie. Ils ne se concentrent pas sur l’approximation de la fonction $ Q $, mais sur la recherche directe de la politique optimale $ π ^ * $. Pour voir où l'itération de valeur s'inscrit dans le paysage des algorithmes d'apprentissage par renforcement:

Vous pensez peut-être que l'apprentissage par renforcement profond semble fragile. Vous aurez raison; il y a de nombreux problèmes. Vous pouvez vous référer à L'apprentissage par renforcement profond ne fonctionne pas encore et L’apprentissage par renforcement n’a jamais fonctionné et «en profondeur» n’a aidé qu’un peu .

Ceci conclut le didacticiel. Nous avons implémenté notre propre DQN de base à des fins d'apprentissage. Code très similaire peut être utilisé pour obtenir de bonnes performances dans certains jeux Atari. Dans les applications pratiques, on utilise souvent des implémentations testées et performantes, par exemple une de Lignes de base OpenAI . Si vous souhaitez voir les défis auxquels on peut faire face en essayant d'appliquer l'apprentissage par renforcement profond dans un environnement plus complexe, vous pouvez lire Notre approche NIPS 2017: Apprendre à courir . Si vous souhaitez en savoir plus dans un environnement de compétition amusant, jetez un œil à Compétitions NIPS 2018 ou crowdai.org .

Si vous êtes en passe de devenir un apprentissage automatique expert et souhaitez approfondir vos connaissances en apprentissage supervisé, consultez Analyse vidéo d'apprentissage automatique: identification des poissons pour une expérience amusante sur l'identification des poissons.

En relation: Schooling Flappy Bird: un didacticiel d'apprentissage par renforcement

Comprendre les bases

Qu'est-ce que l'apprentissage par renforcement?

L'apprentissage par renforcement est une méthode d'essai et d'erreur d'inspiration biologique pour former un agent. Nous récompensons l'agent pour ses bonnes actions pour renforcer le comportement souhaité. Nous avons également sanctionné les mauvaises actions, de sorte qu'elles se produisent moins fréquemment.

Qu'est-ce que Q dans Q-learning?

Q est pour «qualité». Il fait référence à la fonction valeur-action notée Qπ (s, a). Il renvoie le rendement total d'un état s donné, en choisissant l'action a, en suivant une politique concrète π. Le rendement total est la somme de toutes les récompenses dans un épisode.

Qu'est-ce que l'équation de Bellman?

Q (s, a) = r + γ maxa'Q (s ', a'). Verbalement: la valeur Q pour un état et une action donnés est une récompense r reçue après avoir effectué une action a + la valeur Q la plus élevée pour l'état dans lequel nous atterrissons dans s '. Le plus élevé dans le sens où nous choisissons une action a 'qui conduit au rendement total le plus élevé de s'.

Quel est le principe d'optimalité de Bellman?

Principe d'optimalité: Une politique optimale a la propriété que quels que soient l'état initial et les actions, les actions restantes doivent constituer une politique optimale par rapport à l'état résultant de l'action initiale. Il est utilisé dans le Q-learning, mais en général dans toutes les techniques de programmation dynamique.

Que sont les paramètres et les hyperparamètres?

Les paramètres font référence aux paramètres du modèle, donc si vous utilisez des réseaux de neurones, cela fait référence à leurs poids. En règle générale, nous avons des milliers ou des millions de paramètres. Les hyperparamètres sont utilisés pour régler le processus d'apprentissage - par exemple, le taux d'apprentissage, le nombre de couches, les neurones, etc. Habituellement, nous avons moins d'une centaine d'hyperparamètres.