J'ai appris les bases de l'apprentissage intensif et joué avec Cart Pole (implémentation simple de Q Learning)

introduction

J'ai étudié l'apprentissage automatique et les statistiques. Parmi eux, je n'ai pas très bien étudié le renforcement de l'apprentissage, j'ai donc approfondi ma compréhension avec la mise en œuvre.   Les matériaux de référence sont les suivants.

Aperçu de l'apprentissage amélioré

L'apprentissage par renforcement (RL) est l'une des méthodes d'apprentissage automatique qui réalise le contrôle optimal du système par essais et erreurs par le système lui-même.

Alpha Go est célèbre.

En termes de classification, il se positionne comme ** différent de l'apprentissage avec / sans enseignant **. C'est apprendre sensuellement sans enseignant, mais cela semble différent.

La figure ci-dessous est un diagramme schématique. Dans un certain environnement, nous apprendrons l'optimisation des actions à entreprendre pour maximiser la récompense cible (score) en tant que modèle.

image.png

Cette action

Cela dépend du jeu que vous souhaitez apprendre.

Bien que la recherche elle-même ait été activement menée dans les années 1990, il était difficile d'exprimer comment exprimer «état» et comment le relier à un «comportement» basé sur cet «état», et l'élan de la recherche diminuait dans les années 2000. Il semble.

Apprentissage par renforcement profond

En réponse à ce problème, DeepMind a introduit en 2013 Block Breaking by Enhanced Learning ** combiné à un réseau neuronal convolutif (CNN). Il a été publié et a reçu une excellente réponse.

Il est appelé DQN (Deep Q-Network) car il combine ** Q learning (Q Learning) ** et Deep Learning avec la méthode d'apprentissage par renforcement utilisée ici.   ** Cependant, dans cette implémentation, nous le ferons avec un apprentissage Q simple. ** À partir de la prochaine fois, j'aimerais créer une version d'implémentation avec DQN. ..

Mettre en œuvre le poteau de chariot

Cette fois, nous traiterons de ** Cart Pole **, qui est une existence de type MNIST d'apprentissage par renforcement. Il a un bâton sur une poulie qui effectue des mouvements unidimensionnels (gauche et droite). C'est un contenu d'apprendre le mouvement de la poulie pour que ce bâton ne tombe pas.

001.png

C'est très simple. ** Les paramètres d'état sont les suivants 4 **.

En revanche, les ** paramètres de comportement ** sont les deux suivants.

Vous obtiendrez 1 récompense tant que la balle ne tombe pas. En outre, un épisode est la période jusqu'à la fin d'un match. Et

ça ira.

Si vous le déplacez simplement

Faites simplement np.random.choice ([0,1]) sans vous soucier de quoi que ce soit et déplacez 0 ou 1 au hasard. Que se passe-t-il alors?

import gym
import numpy as np

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

goal_average_steps = 195
max_number_of_steps = 200
num_consecutive_iterations = 100
num_episodes = 200
last_time_steps = np.zeros(num_consecutive_iterations)

for episode in range(num_episodes):
    #Initialisation de l'environnement
    observation = env.reset()

    episode_reward = 0
    for t in range(max_number_of_steps):
        #Chariot de dessin
        env.render()
        if env.viewer == None:
            env.render()
        #Choix aléatoire de l'action
        action = np.random.choice([0, 1])

        #Agissez et obtenez des commentaires
        observation, reward, done, info = env.step(action)
        episode_reward += reward

        if done:
            print('%d Episode finished after %d time steps / mean %f' % (episode, t + 1,
                last_time_steps.mean()))
            last_time_steps = np.hstack((last_time_steps[1:], [episode_reward]))
            break

    if (last_time_steps.mean() >= goal_average_steps): #Succès si les 100 derniers épisodes sont de 195 ou plus
        print('Episode %d train agent successfuly!' % episode)
        break

Ensuite, il sera affiché comme suit.

185 Episode finished after 21 time steps / mean 21.350000
186 Episode finished after 23 time steps / mean 21.390000
187 Episode finished after 22 time steps / mean 21.510000
188 Episode finished after 39 time steps / mean 21.420000
189 Episode finished after 13 time steps / mean 21.320000
190 Episode finished after 9 time steps / mean 21.160000
191 Episode finished after 26 time steps / mean 20.980000
192 Episode finished after 17 time steps / mean 21.100000
193 Episode finished after 94 time steps / mean 21.120000
194 Episode finished after 15 time steps / mean 21.870000
195 Episode finished after 26 time steps / mean 21.880000
196 Episode finished after 13 time steps / mean 21.970000
197 Episode finished after 13 time steps / mean 21.940000
198 Episode finished after 31 time steps / mean 21.760000
199 Episode finished after 23 time steps / mean 21.950000

Vous pouvez voir qu'il se brise après environ des dizaines de pas de temps. Je comprends que le nombre n'augmente pas parce que je n'ai pas appris.

Apprenez avec Q Learning

Maintenant, apprenons avec Q Learning.

L'idée clé ici est de définir un index pour sélectionner la prochaine action à entreprendre dans une certaine situation. Cette valeur est appelée la valeur Q. Par programme, il est défini comme Q_table et a la matrice suivante.

image.png

Dans ce cas, comme il y a quatre états dans lesquels les états du panier et des pôles suivants sont divisés en quatre, $ 4 ^ 4 = 256 $ et les actions gauche et droite $ 2 $ forment une matrice de 256 $ x 2 $.

Nous améliorerons cette valeur Q pour chaque action. Plus la valeur Q est élevée, plus il est facile de sélectionner, donc augmenter cette valeur Q d'une manière qui augmente la récompense améliorera votre comportement.

À propos, la mise à jour de cette valeur Q est la suivante.

Q(s, a) = (1 - \alpha)Q(s, a) + \alpha(R(s, a) + \gamma max_{a'} E[Q(s', a')])

ici

Ce sera.

Lorsque cela sera mis en œuvre, ce sera comme suit.


def get_action(state, action, observation, reward):
    next_state = digitize_state(observation)
    next_action = np.argmax(q_table[next_state])

    #Mettre à jour la table Q
    alpha = 0.2
    gamma = 0.99
    q_table[state, action] = (1 - alpha) * q_table[state, action] +\
            alpha * (reward + gamma * q_table[next_state, next_action])

    return next_action, next_state

for episode in range(num_episodes):
    #Initialisation de l'environnement
    observation = env.reset()

    state = digitize_state(observation)
    action = np.argmax(q_table[state])

    episode_reward = 0
    for t in range(max_number_of_steps):
        #Chariot de dessin
        #env.render()

        #Agissez et obtenez des commentaires
        observation, reward, done, info = env.step(action)

        #Choix d'action
        action, state = get_action(state, action, observation, reward)
        episode_reward += reward

Avec cela, l'apprentissage converge en fait dans environ 100 essais et réussit.

la fin

J'ai joué avec le contour du renforcement de l'apprentissage et du Cart Pole. Je voudrais également défier DQN.

Le programme complet est ci-dessous. https://github.com/Fumio-eisan/RL20200527

Recommended Posts

J'ai appris les bases de l'apprentissage intensif et joué avec Cart Pole (implémentation simple de Q Learning)
Deep Learning from scratch La théorie et la mise en œuvre de l'apprentissage profond appris avec Python Chapitre 3
Apprenez en implémentant avec Scipy Les bases de la régression logistique et du perceptron multicouche
J'ai comparé la vitesse de Hash avec Topaz, Ruby et Python
[Introduction à StyleGAN] J'ai joué avec "The Life of a Man" ♬
[Super basiques de Python] J'ai appris les bases des bases, donc je l'ai résumé brièvement.
Explorez le labyrinthe avec l'apprentissage augmenté
J'ai joué avec PyQt5 et Python3
J'ai remplacé le calcul numérique de Python par Rust et comparé la vitesse
J'ai vectorisé l'accord de la chanson avec word2vec et je l'ai visualisé avec t-SNE
J'ai fait GAN avec Keras, donc j'ai fait une vidéo du processus d'apprentissage.
J'ai mesuré la vitesse de la notation d'inclusion de liste, pendant et pendant avec python2.7.
[Scikit-learn] J'ai joué avec la courbe ROC
Je ne connaissais pas les bases de Python
J'ai tweeté l'éclairement de la pièce avec Raspberry Pi, Arduino et un capteur optique
J'ai comparé la moyenne mobile du type de filtre IIR avec les pandas et scipy
L'histoire de l'apprentissage profond avec TPU
Bases de l'apprentissage avec un enseignant Partie 1-Régression simple- (Remarque)
Un mémorandum d'étude et de mise en œuvre du Deep Learning
J'ai joué avec Floydhub pour le moment
J'ai lu et implémenté les variantes de UKR
[Mac] J'ai essayé de renforcer l'apprentissage avec Open AI Baselines
J'ai essayé d'implémenter "Bases de l'analyse des séries temporelles et du modèle d'espace d'état" (Hayamoto) avec pystan
[Exemple d'amélioration de Python] Apprentissage des bases de Python sur un site gratuit en 2 semaines
J'ai essayé d'automatiser la mise à jour de l'article du blog Livedoor avec Python et sélénium.
Je voulais juste extraire les données de la date et de l'heure souhaitées avec Django
J'ai essayé de comparer la vitesse de traitement avec dplyr de R et pandas de Python