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.

Apprentissage automatique pratique avec scikit-learn et TensorFlow
[Texte officiel du Deep Learning Textbook Deep Learning G Test (Generalist)](https://www.amazon.co.jp/%E6%B7%B1%E5%B1%A4%E5%AD%A6%E7%BF % 92% E6% 95% 99% E7% A7% 91% E6% 9B% B8-% E3% 83% 87% E3% 82% A3% E3% 83% BC% E3% 83% 97% E3% 83% A9% E3% 83% BC% E3% 83% 8B% E3% 83% B3% E3% 82% B0-G% E6% A4% 9C% E5% AE% 9A-% E3% 82% B8% E3% 82 % A7% E3% 83% 8D% E3% 83% A9% E3% 83% AA% E3% 82% B9% E3% 83% 88-% E5% 85% AC% E5% BC% 8F% E3% 83% 86% E3% 82% AD% E3% 82% B9% E3% 83% 88 / dp / 4798157554)
Implémentation et explication de Q-learning avec CartPole [Renforcer l'apprentissage avec Phython: Partie 1]

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.

Cette action

Rupture de bloc → Déplacer à gauche et à droite
Aller → Position pour frapper la pierre
Mario (2D) → Déplacer vers la gauche, la droite, le haut et le bas

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.

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

Position du chariot (-2,4 à +2,4)
Vitesse du chariot (-inf à + inf): Infinity
Angle des pôles (-41,8 ° à + 41,8 °): Réduit lorsque la valeur absolue est de 40 ou plus
Vitesse du pôle (-inf ~ + inf)

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

Le chariot se déplace vers la gauche (0)
Le chariot se déplace vers la droite (1)

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

Succès si vous obtenez 195 récompenses ou plus d'affilée pour 100 épisodes
Jusqu'à 200 pas de temps d'épisode

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

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

Position du chariot (-2,4 à +2,4)
Vitesse du chariot (-inf à + inf): Infinity
Angle des pôles (-41,8 ° à + 41,8 °): Réduit lorsque la valeur absolue est de 40 ou plus
Vitesse du pôle (-inf ~ + inf)

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

$ Q (s, a) $ State s, Valeur pour agir a
$ α $ Taux d'apprentissage
$ γ $ Taux de remise
$ max_ {a '} E [Q (s', a ')] $ Valeur maximale de la valeur Q des actions pouvant être sélectionnées la prochaine fois

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

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