[PYTHON] Lerne beim Machen! Tiefes Verstärkungslernen_1

Deep Reinforcement Learning-Praktisches Programmieren mit Pytorch-

Ich bin Harima, eine Master of Science-Graduiertenschule im ersten Jahr. Ich werde meine Lerninhalte als Memo zusammenfassen. Es tut mir leid, dass es schwer zu sehen ist. Ich würde gerne wissen, was Sie nicht verstehen.

Implementierungscode (GitHub) https://github.com/YutaroOgawa/Deep-Reinforcement-Learning-Book

Kapitel 2 Lassen Sie uns erweitertes Lernen in die Labyrinthaufgabe implementieren

2.1 Verwendung von Python

2.2 Labyrinthe und Agenten implementieren

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)

Es ist eine Gesamtansicht des Labyrinths.

・ Die Regel, die definiert, wie sich der Agent verhält, heißt ** Richtlinie **.

・ Ausgedrückt als $ \ pi_ \ theta (s, a) $

・ Die Wahrscheinlichkeit, die Aktion $ a $ im Zustand $ s $ zu übernehmen, folgt der durch den Parameter $ \ theta $ bestimmten Richtlinie $ \ pi $.

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]
                    ])

・ Konvertieren Sie den Parameter $ \ theta_0 $, um die Richtlinie $ \ pi_ \ theta (s, a) $ zu finden

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)

・ Die Wahrscheinlichkeit, zur Wand zu gehen, beträgt 0

・ Bewegen Sie sich mit gleicher Wahrscheinlichkeit in andere Richtungen

pi_0

• Verschieben Sie den Agenten seit Abschluss der ersten Richtlinie gemäß der Richtlinie $ \ pi_ {\ theta_ {0}} (s, a) $

・ Bewegen Sie die Agenten weiter, bis Sie das Ziel erreichen

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

・ Überprüfen Sie, welche Art von Flugbahn und wie viele Schritte Sie insgesamt unternommen haben, bis Sie das Ziel erreicht haben

state_history = goal_maze(pi_0)

print(state_history)
print("Die Anzahl der Schritte zur Lösung des Labyrinths" + str(len(state_history) - 1) + "ist")

・ Visualisieren Sie den Verlauf des Zustandsübergangs

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 Implementierung der iterativen Methode für Richtlinien

・ Überlegen Sie, wie Sie den Agenten so trainieren können, dass er direkt zum Ziel gelangt

(1) Methode zur Wiederholung von Richtlinien

Strategie, die das Verhalten erfolgreicher Fälle betont

(2) Wertwiederholungsmethode

Strategie, um anderen Positionen (Staaten) als dem Ziel einen Mehrwert (Priorität) zu verleihen

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

・ Messen Sie $ \ pi_ {{\ theta_0}} $

pi_0 = softmax_convert_into_pi_from_theta(theta_0)
print(pi_0)

• Die in 2.2 behandelte Funktion "get_next_s" wurde geändert

・ Erwerben Sie nicht nur den Staat, sondern auch die verabschiedete Maßnahme

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]

-Fixed "target_maze" Funktion, die den Agenten bewegt, bis das Ziel erreicht ist

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("Die Anzahl der Schritte zur Lösung des Labyrinths" + str(len(s_a_history) - 1) + "ist")

Weggelassen, weil es lang ist ...

Aktualisieren Sie die Richtlinie gemäß der Richtliniengradientenmethode

・ Die Richtliniengradientenmethode aktualisiert den Parameter $ \ theta $ gemäß der folgenden Formel.

\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

• Ich verstehe das hier wirklich nicht! !! !! !!

new_theta = theta + eta * delta_theta

• Warum hinzufügen! ??
• Sollte derjenige mit einer großen Anzahl von Versuchen (der wahrscheinlich nicht der kürzeste Weg ist) gezogen werden?
• Bitte sag mir ...

• Aktualisieren Sie den Parameter $ \ theta $ und beobachten Sie die Änderung der Richtlinie $ \ pi_ {\ theta} $

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

・ Wiederholen Sie die Suche im Labyrinth und aktualisieren Sie den Parameter $ \ theta $, bis das Labyrinth in einer geraden Linie gelöscht werden kann.

・ Messen Sie das Ende, wenn die Summe der Absolutwerte der Änderungen in $ \ pi $ kleiner als $ 10 ^ {-4} $ wird

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

Eigentlich gab es "Drucken" in der Funktion, aber ich habe es geschnitten, weil es nervt ...

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

・ Versuchen Sie zu visualisieren

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())

-Die Softmax-Funktion kann eine Strategie ableiten, selbst wenn der Parameter $ \ theta $ ein negativer Wert wird.

・ Mit dem Richtliniengradientensatz ist es möglich, die Aktualisierungsmethode des Parameters $ \ theta $ mit der Richtliniengradientenmethode zu lösen.

・ Es gibt einen Algorithmus REINFORCE, der den Satz des Richtliniengradienten ungefähr implementiert.

»Diesmal gab es etwas, das ich nicht verstanden habe. »Ich würde es begrüßen, wenn mir jemand davon erzählen könnte.