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)
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
・ 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")
・ 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.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)
-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")
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)
・ 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)
・ 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())
-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