Apprenez en faisant! Apprentissage par renforcement profond_1

Apprentissage par renforcement profond - Programmation pratique avec Pytorch -

Je suis Harima, une école supérieure de premier cycle en sciences. Je vais résumer mon contenu d'apprentissage sous forme de mémo. Je suis désolé, c'est difficile à voir. Je voudrais savoir ce que vous ne comprenez pas.


Code d'implémentation (GitHub) https://github.com/YutaroOgawa/Deep-Reinforcement-Learning-Book


Chap.2 Implémentons un apprentissage amélioré dans la tâche de labyrinthe

2.1 Comment utiliser Python

2.2 Mettre en œuvre des labyrinthes et des agents

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
fig=plt.figure(figsize=(5,5))
ax=plt.gca()


plt.plot([1,1],[0,1],color='red',linewidth=2)
plt.plot([1,2],[2,2],color='red',linewidth=2)
plt.plot([2,2],[2,1],color='red',linewidth=2)
plt.plot([2,3],[1,1],color='red',linewidth=2)


plt.text(0.5,2.5,'S0',size=14,ha='center')
plt.text(1.5,2.5,'S1',size=14,ha='center')
plt.text(2.5,2.5,'S2',size=14,ha='center')
plt.text(0.5,1.5,'S3',size=14,ha='center')
plt.text(1.5,1.5,'S4',size=14,ha='center')
plt.text(2.5,1.5,'S5',size=14,ha='center')
plt.text(0.5,0.5,'S6',size=14,ha='center')
plt.text(1.5,0.5,'S7',size=14,ha='center')
plt.text(2.5,0.5,'S8',size=14,ha='center')
plt.text(0.5,2.3,'START',ha='center')

plt.text(2.5,0.3,'GOAL',ha='center')


ax.set_xlim(0,3)
ax.set_ylim(0,3)
plt.tick_params(axis='both',which='both',bottom='off',top='off',
                labelbottom='off',right='off',left='off',labelleft='off')


line, =ax.plot([0.5],[2.5],marker="o",color='g',markersize=60)

Screenshot from 2019-12-18 17-42-22.png

C'est une vue d'ensemble du labyrinthe.

・ Les règles qui définissent le comportement des agents sont appelées ** politiques **.

・ Exprimé en $ \ pi_ \ theta (s, a) $

・ La probabilité d'adopter l'action $ a $ dans l'état $ s $ suit la politique $ \ pi $ déterminée par le paramètre $ \ theta $.

theta_0 = np.array([[np.nan, 1, 1, np.nan],
                    [np.nan, 1, np.nan, 1],
                    [np.nan, np.nan, 1, 1],
                    [1, 1, 1, np.nan],
                    [np.nan, np.nan, 1, 1],
                    [1, np.nan, np.nan, np.nan],
                    [1, np.nan, np.nan, np.nan],
                    [1, 1, np.nan, np.nan]
                    ])

-Convertissez le paramètre $ \ theta_0 $ pour trouver la politique $ \ pi_ \ theta (s, a) $


def simple_convert_into_pi_fron_theta(theta):

     [m,n] = theta.shape
     pi = np.zeros((m,n))
     for i in range(0,m):
         pi[i, :] = theta[i, :] / np.nansum(theta[i, :])

     pi = np.nan_to_num(pi)

     return pi
pi_0 = simple_convert_into_pi_fron_theta(theta_0)

・ La probabilité d'aller vers le mur est de 0

・ Déplacez-vous dans d'autres directions avec une probabilité égale

pi_0

Screenshot from 2019-12-18 17-43-53.png

・ La politique initiale étant terminée, déplacez l'agent selon la politique $ \ pi_ {\ theta_ {0}} (s, a) $

・ Continuez à déplacer les agents jusqu'à ce que vous atteigniez l'objectif

def get_next_s(pi, s):
    direction = ["up", "right", "down", "left"]

    next_direction = np.random.choice(direction, p=pi[s, :])

    if next_direction == "up":
        s_next = s - 3
    elif next_direction == "right":
        s_next = s + 1
    elif next_direction == "down":
        s_next = s + 3
    elif next_direction == "left":
        s_next = s - 1

    return s_next
def goal_maze(pi):
    s = 0
    state_history = [0]

    while (1):
        next_s = get_next_s(pi, s)
        state_history.append(next_s)

        if next_s == 8:
            break
        else:
            s = next_s

    return state_history

・ Vérifiez le type de trajectoire et le nombre de pas que vous avez effectués au total jusqu'à ce que vous atteigniez l'objectif

state_history = goal_maze(pi_0)
print(state_history)
print("Le nombre d'étapes nécessaires pour résoudre le labyrinthe" + str(len(state_history) - 1) + "est")

Screenshot from 2019-12-18 17-45-49.png

・ Visualisez la trajectoire de la transition d'état

from matplotlib import animation
from IPython.display import HTML


def init():
    line.set_data([], [])
    return (line,)


def animate(i):
    state = state_history[i]
    x = (state % 3) + 0.5
    y = 2.5 - int(state / 3)
    line.set_data(x, y)
    return (line,)


anim = animation.FuncAnimation(fig, animate, init_func=init, frames=len(
    state_history), interval=200, repeat=False)

HTML(anim.to_jshtml())

2_2_maze_random.gif

2.3 Mise en œuvre de la méthode itérative de politique

・ Pensez à la façon de former l'agent à aller directement au but

(1) Méthode de répétition de la politique

Stratégie qui met l'accent sur le comportement des cas réussis

(2) Méthode de répétition des valeurs

Stratégie pour ajouter de la valeur (priorité) aux positions (états) autres que l'objectif

def softmax_convert_into_pi_from_theta(theta):

    beta = 1.0
    [m, n] = theta.shape
    pi = np.zeros((m, n))

    exp_theta = np.exp(beta * theta)

    for i in range(0, m):

        pi[i, :] = exp_theta[i, :] / np.nansum(exp_theta[i, :])

    pi = np.nan_to_num(pi)

    return pi

・ Mesurer $ \ pi_ {{\ theta_0}} $

pi_0 = softmax_convert_into_pi_from_theta(theta_0)
print(pi_0)

Screenshot from 2019-12-18 18-14-44.png

-Modification de la fonction "get_next_s" gérée en 2.2

・ Acquérir non seulement l'État mais aussi l'action adoptée

def get_action_and_next_s(pi, s):
    direction = ["up", "right", "down", "left"]
    next_direction = np.random.choice(direction, p=pi[s, :])

    if next_direction == "up":
        action = 0
        s_next = s - 3
    elif next_direction == "right":
        action = 1
        s_next = s + 1
    elif next_direction == "down":
        action = 2
        s_next = s + 3
    elif next_direction == "left":
        action = 3
        s_next = s - 1

    return [action, s_next]

-Fixation de la fonction "goal_maze" qui déplace l'agent jusqu'à ce que l'objectif soit atteint

def goal_maze_ret_s_a(pi):
    s = 0
    s_a_history = [[0, np.nan]]

    while (1):
        [action, next_s] = get_action_and_next_s(pi, s)
        s_a_history[-1][1] = action

        s_a_history.append([next_s, np.nan])

        if next_s == 8:
            break
        else:
            s = next_s

    return s_a_history
s_a_history = goal_maze_ret_s_a(pi_0)
print(s_a_history)
print("Le nombre d'étapes nécessaires pour résoudre le labyrinthe" + str(len(s_a_history) - 1) + "est")

Screenshot from 2019-12-18 18-15-43.png

Omis car il est long ...

Mettre à jour la politique selon la méthode du gradient de politique

・ La méthode du gradient de politique met à jour le paramètre $ \ theta $ selon la formule suivante.


\theta_{s_i,a_j}=\theta_{s_i,a_j}+\eta*\Delta\theta_{s,a_j} \\
\Delta\theta{s,a_j}=\{ N(s_i,a_j)-P(s_i,a_j)N(s_i,a) \}/T


def update_theta(theta, pi, s_a_history):
    eta = 0.1
    T = len(s_a_history) - 1

    [m, n] = theta.shape
    delta_theta = theta.copy()

    for i in range(0, m):
        for j in range(0, n):
            if not(np.isnan(theta[i, j])):

                SA_i = [SA for SA in s_a_history if SA[0] == i]

                SA_ij = [SA for SA in s_a_history if SA == [i, j]]

                N_i = len(SA_i)
                N_ij = len(SA_ij)

                delta_theta[i, j] = (N_ij - pi[i, j] * N_i) / T

    new_theta = theta + eta * delta_theta

    return new_theta
  • Je ne comprends vraiment pas ici! !! !! !!
new_theta = theta + eta * delta_theta

--Pourquoi ajouter! ??

  • Est-ce que celui avec un grand nombre d'essais (qui n'est probablement pas le chemin le plus court) devrait être retiré?
  • Veuillez me dire ...

-Mettre à jour le paramètre $ \ theta $ et observer le changement de politique $ \ pi_ {\ theta} $

new_theta = update_theta(theta_0, pi_0, s_a_history)
pi = softmax_convert_into_pi_from_theta(new_theta)
print(pi)

Screenshot from 2019-12-18 18-16-52.png

・ Répétez la recherche dans le labyrinthe et mettez à jour le paramètre $ \ theta $ jusqu'à ce que le labyrinthe puisse être effacé en ligne droite.

・ Mesure Fin lorsque la somme des valeurs absolues des changements de $ \ pi $ devient inférieure à 10 $ ^ {-4} $

stop_epsilon = 10**-4

theta = theta_0
pi = pi_0

is_continue = True
count = 1
while is_continue:
    s_a_history = goal_maze_ret_s_a(pi)
    new_theta = update_theta(theta, pi, s_a_history)
    new_pi = softmax_convert_into_pi_from_theta(new_theta)

    if np.sum(np.abs(new_pi - pi)) < stop_epsilon:
        is_continue = False
    else:
        theta = new_theta
        pi = new_pi

En fait, il y avait du "print" dans la fonction, mais je l'ai coupé car c'est ennuyeux ...

np.set_printoptions(precision=3, suppress=True)
print(pi)

Screenshot from 2019-12-18 18-18-08.png

・ Essayez de visualiser

from matplotlib import animation
from IPython.display import HTML


def init():
    line.set_data([], [])
    return (line,)


def animate(i):
    state = s_a_history[i][0]
    x = (state % 3) + 0.5
    y = 2.5 - int(state / 3)
    line.set_data(x, y)
    return (line,)

anim = animation.FuncAnimation(fig, animate, init_func=init, frames=len(
    s_a_history), interval=200, repeat=False)

HTML(anim.to_jshtml())

2_3_maze_reinforce.gif

-La fonction softmax peut dériver une stratégie même si le paramètre $ \ theta $ devient une valeur négative.

・ En utilisant le théorème du gradient de politique, il est possible de résoudre la méthode de mise à jour du paramètre $ \ theta $ par la méthode du gradient de politique.

・ Il existe un algorithme REINFORCE qui implémente approximativement le théorème du gradient de politique.


«Cette fois, il y avait quelque chose que je n'ai pas compris. «J'apprécierais que quelqu'un puisse me le dire.

Recommended Posts

Apprenez en faisant! Apprentissage par renforcement profond_1
"Apprenez en créant! Développement en deep learning par PyTorch" sur Colaboratory.
Apprentissage amélioré pour apprendre de zéro à profond
Renforcer l'apprentissage Apprendre d'aujourd'hui
Apprentissage par renforcement profond 1 Introduction au renforcement de l'apprentissage
Apprentissage par renforcement profond 2 Mise en œuvre de l'apprentissage par renforcement
Deep Strengthening Learning 3 Édition pratique: Briser des blocs
L'apprentissage en profondeur
<Cours> Deep Learning Day4 Renforcement de l'apprentissage / flux de tension
[Introduction] Renforcer l'apprentissage
Mémorandum d'apprentissage profond
Commencer l'apprentissage en profondeur
Apprentissage par renforcement futur_2
Apprentissage par renforcement futur_1
Apprentissage profond × Python
Premier apprentissage profond ~ Lutte ~
Investissement en actions par apprentissage approfondi (méthode du gradient de politique) (1)
Apprentissage amélioré 1 installation de Python
Renforcer l'apprentissage 3 Installation d'OpenAI
Python: pratique du Deep Learning
Fonctions d'apprentissage en profondeur / d'activation
Apprentissage profond à partir de zéro
Deep learning 1 Pratique du deep learning
Renforcer l'apprentissage de la troisième ligne
Première solution d'apprentissage en profondeur ~
[AI] Apprentissage métrique profond
J'ai essayé le deep learning
Apprenez en quelque sorte le machine learning
Python: réglage du Deep Learning
Technologie d'apprentissage en profondeur à grande échelle
Apprentissage amélioré Python + Unity (apprentissage)
Fonction d'apprentissage profond / softmax
Un amateur a trébuché dans le Deep Learning ❷ fait à partir de zéro Note: Chapitre 5
Un amateur a trébuché dans le Deep Learning ❷ fait à partir de zéro Note: Chapitre 2
Un amateur a trébuché dans le Deep Learning ❷ fait à partir de zéro Note: Chapitre 4
Renforcer l'apprentissage 18 Colaboratory + Acrobat + ChainerRL
Apprentissage profond à partir de zéro 1 à 3 chapitres
Apprentissage amélioré 7 Sortie du journal des données d'apprentissage
Deep Learning Gaiden ~ Programmation GPU ~
<Cours> Apprentissage en profondeur: Day2 CNN
Renforcer l'apprentissage 17 Colaboratory + CartPole + ChainerRL
Renforcer l'apprentissage 28 collaboratif + OpenAI + chainerRL
Renforcer l'apprentissage 19 Colaboratory + Mountain_car + ChainerRL
Renforcement de l'apprentissage 2 Installation de chainerrl
[Renforcer l'apprentissage] Suivi par multi-agents
Deep running 2 Réglage de l'apprentissage profond
Renforcer l'apprentissage 6 First Chainer RL
<Cours> Apprentissage en profondeur: Jour 1 NN
Apprentissage profond du noyau avec Pyro
Essayez le Deep Learning avec FPGA
Apprentissage par renforcement 5 Essayez de programmer CartPole?
Apprentissage par renforcement 9 Remodelage magique ChainerRL
Apprentissage profond pour la formation composée?
Présentation d'Udacity Deep Learning Nanodegree
Sujets> Deep Learning: Day3 RNN
Introduction au Deep Learning ~ Règles d'apprentissage ~