Warum geht Q Learning auseinander?

Die Zustandswerte meines Q-Learning-Algorithmus weichen immer wieder ins Unendliche ab, was bedeutet, dass auch meine Gewichte voneinander abweichen. Ich verwende ein neuronales Netzwerk für meine Wertzuordnung.

Ich habe es versucht:

Beschneiden des "Belohnungs + Rabatt * Maximalwert der Aktion" (max / min auf 50 / -50 eingestellt)
Einstellen einer niedrigen Lernrate (0,00001 und ich verwenden die klassische Backpropagation zum Aktualisieren der Gewichte)
Verringern der Werte der Belohnungen
Erhöhung der Explorationsrate
Normalisieren der Eingänge auf 1 ~ 100 (zuvor 0 ~ 1)
Ändern Sie den Abzinsungssatz
Verringern Sie die Schichten des neuronalen Netzwerks (nur zur Validierung).

Ich habe gehört, dass Q Learning bekanntermaßen bei nichtlinearen Eingaben divergiert, aber gibt es noch etwas, mit dem ich versuchen kann, die Divergenz der Gewichte zu stoppen?

Update Nr. 1 am 14. August 2017:

Ich habe mich entschlossen, einige spezifische Details zu dem, was ich gerade mache, aufgrund einer Anfrage an hinzuzufügen.

Ich versuche gerade, einen Agenten dazu zu bringen, zu lernen, wie man in einer Top-Down-Ansicht eines Schießspiels kämpft. Der Gegner ist ein einfacher Bot, der sich stochastisch bewegt.

Jeder Charakter hat in jeder Runde 9 Aktionen zur Auswahl:

nach oben bewegen
sich abwärts bewegen
geh nach links
nach rechts bewegen
schieße eine Kugel nach oben
schieße eine Kugel nach unten
schieße eine Kugel nach links
schieße eine Kugel nach rechts
nichts tun

Die Belohnungen sind:

Wenn der Agent den Bot mit einer Kugel trifft, +100 (ich habe viele verschiedene Werte ausprobiert)
Wenn der Agent von einer vom Bot abgefeuerten Kugel getroffen wird, -50 (ich habe wieder viele verschiedene Werte ausprobiert)
Wenn der Agent versucht, eine Kugel abzufeuern, während Kugeln nicht abgefeuert werden können (z. B. wenn der Agent gerade eine Kugel abgefeuert hat usw.), -25 (Nicht erforderlich, aber ich wollte, dass der Agent effizienter ist.)
Wenn der Bot versucht, die Arena zu verlassen, -20 (Nicht notwendig, aber ich wollte, dass der Agent effizienter ist)

Die Eingaben für das neuronale Netzwerk sind:

Abstand zwischen dem Agenten und dem Bot auf der X-Achse normalisiert auf 0 ~ 100
Abstand zwischen dem Agenten und dem Bot auf der Y-Achse normalisiert auf 0 ~ 100
X- und y-Positionen des Agenten
X- und y-Positionen des Bots
Bots Kugelposition. Wenn der Bot keine Kugel abgefeuert hat, werden die Parameter auf die x- und y-Positionen des Bots gesetzt.

Ich habe auch mit den Eingaben herumgespielt; Ich habe versucht, neue Funktionen wie den x-Wert der Position des Agenten (nicht die Entfernung, sondern die tatsächliche Position) und die Position der Kugel des Bots hinzuzufügen. Keiner von ihnen hat funktioniert.

Hier ist der Code:

from pygame import *
from pygame.locals import *
import sys
from time import sleep
import numpy as np
import random
import tensorflow as tf
from pylab import savefig
from tqdm import tqdm


#Screen Setup
disp_x, disp_y = 1000, 800
arena_x, arena_y = 1000, 800
border = 4; border_2 = 1

#Color Setup
white = (255, 255, 255); aqua= (0, 200, 200)
red = (255, 0, 0); green = (0, 255, 0)
blue = (0, 0, 255); black = (0, 0, 0)
green_yellow = (173, 255, 47); energy_blue = (125, 249, 255)

#Initialize character positions
init_character_a_state = [disp_x/2 - arena_x/2 + 50, disp_y/2 - arena_y/2 + 50]
init_character_b_state = [disp_x/2 + arena_x/2 - 50, disp_y/2 + arena_y/2 - 50]

#Setup character dimentions
character_size = 50
character_move_speed = 25

#Initialize character stats
character_init_health = 100

#initialize bullet stats
beam_damage = 10
beam_width = 10
beam_ob = -100

#The Neural Network
input_layer = tf.placeholder(shape=[1,7],dtype=tf.float32)
weight_1 = tf.Variable(tf.random_uniform([7,9],0,0.1))
#weight_2 = tf.Variable(tf.random_uniform([6,9],0,0.1))

#The calculations, loss function and the update model
Q = tf.matmul(input_layer, weight_1)
predict = tf.argmax(Q, 1)
next_Q = tf.placeholder(shape=[1,9],dtype=tf.float32)
loss = tf.reduce_sum(tf.square(next_Q - Q))
trainer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
updateModel = trainer.minimize(loss)

initialize = tf.global_variables_initializer()

jList = []
rList = []

init()
font.init()
myfont = font.SysFont('Comic Sans MS', 15)
myfont2 = font.SysFont('Comic Sans MS', 150)
myfont3 = font.SysFont('Gothic', 30)
disp = display.set_mode((disp_x, disp_y), 0, 32)

#CHARACTER/BULLET PARAMETERS
agent_x = agent_y = int()
bot_x = bot_y = int()
agent_hp = bot_hp = int()
bot_beam_dir = int()
agent_beam_fire = bot_beam_fire = bool()
agent_beam_x = bot_beam_x = agent_beam_y = bot_beam_y = int()
agent_beam_size_x = agent_beam_size_y = bot_beam_size_x = bot_beam_size_y = int()
bot_current_action = agent_current_action = int()

def param_init():
    """Initializes parameters"""
    global agent_x, agent_y, bot_x, bot_y, agent_hp, bot_hp, agent_beam_fire, bot_beam_fire, agent_beam_x, bot_beam_x, agent_beam_y, bot_beam_y

    agent_x = list(init_character_a_state)[0]; agent_y = list(init_character_a_state)[1]
    bot_x = list(init_character_b_state)[0]; bot_y = list(init_character_b_state)[1]
    agent_hp = bot_hp = character_init_health
    agent_beam_fire = bot_beam_fire = False
    agent_beam_x = bot_beam_x = agent_beam_y = bot_beam_y = beam_ob
    agent_beam_size_x = agent_beam_size_y = bot_beam_size_x = bot_beam_size_y = 0


def screen_blit():
    global disp, disp_x, disp_y, arena_x, arena_y, border, border_2, character_size, agent_x, \
    agent_y, bot_x, bot_y, character_init_health, agent_hp, bot_hp, red, blue, aqua, green, black, green_yellow, energy_blue, \
    agent_beam_fire, bot_beam_fire, agent_beam_x, agent_beam_y, bot_beam_x, bot_beam_y, agent_beam_size_x, agent_beam_size_y, bot_beam_size_x, bot_beam_size_y, beam_width

    disp.fill(aqua)
    draw.rect(disp, black, (disp_x / 2 - arena_x / 2 - border, disp_y /
                            2 - arena_y / 2 - border, arena_x + border * 2, arena_y + border * 2))
    draw.rect(disp, green, (disp_x / 2 - arena_x / 2,
                            disp_y / 2 - arena_y / 2, arena_x, arena_y))
    if bot_beam_fire == True:
        draw.rect(disp, green_yellow, (agent_beam_x, agent_beam_y, agent_beam_size_x, agent_beam_size_y))
        bot_beam_fire = False
    if agent_beam_fire == True:
        draw.rect(disp, energy_blue, (bot_beam_x, bot_beam_y, bot_beam_size_x, bot_beam_size_y))
        agent_beam_fire = False

    draw.rect(disp, red, (agent_x, agent_y, character_size, character_size))
    draw.rect(disp, blue, (bot_x, bot_y, character_size, character_size))

    draw.rect(disp, red, (disp_x / 2 - 200, disp_y / 2 + arena_y / 2 +
                            border + 1, float(agent_hp) / float(character_init_health) * 100, 14))
    draw.rect(disp, blue, (disp_x / 2 + 200, disp_y / 2 + arena_y / 2 +
                            border + 1, float(bot_hp) / float(character_init_health) * 100, 14))


def bot_take_action():
    return random.randint(1, 9)

def beam_hit_detector(player):
    global agent_x, agent_y, bot_x, bot_y, agent_beam_fire, bot_beam_fire, agent_beam_x, \
    bot_beam_x, agent_beam_y, bot_beam_y, agent_beam_size_x, agent_beam_size_y, \
    bot_beam_size_x, bot_beam_size_y, bot_current_action, agent_current_action, beam_width, character_size

    if player == "bot":
        if bot_current_action == 1:
            if disp_y/2 - arena_y/2 <= agent_y <= bot_y and (agent_x < bot_beam_x + beam_width < agent_x + character_size or agent_x < bot_beam_x < agent_x + character_size):
                return True
            else:
                return False
        elif bot_current_action == 2:
            if bot_x <= agent_x <= disp_x/2 + arena_x/2 and (agent_y < bot_beam_y + beam_width < agent_y + character_size or agent_y < bot_beam_y < agent_y + character_size):
                return True
            else:
                return False
        elif bot_current_action == 3:
            if bot_y <= agent_y <= disp_y/2 + arena_y/2 and (agent_x < bot_beam_x + beam_width < agent_x + character_size or agent_x < bot_beam_x < agent_x + character_size):
                return True
            else:
                return False
        elif bot_current_action == 4:
            if disp_x/2 - arena_x/2 <= agent_x <= bot_x and (agent_y < bot_beam_y + beam_width < agent_y + character_size or agent_y < bot_beam_y < agent_y + character_size):
                return True
            else:
                return False
    else:
        if agent_current_action == 1:
            if disp_y/2 - arena_y/2 <= bot_y <= agent_y and (bot_x < agent_beam_x + beam_width < bot_x + character_size or bot_x < agent_beam_x < bot_x + character_size):
                return True
            else:
                return False
        elif agent_current_action == 2:
            if agent_x <= bot_x <= disp_x/2 + arena_x/2 and (bot_y < agent_beam_y + beam_width < bot_y + character_size or bot_y < agent_beam_y < bot_y + character_size):
                return True
            else:
                return False
        elif agent_current_action == 3:
            if agent_y <= bot_y <= disp_y/2 + arena_y/2 and (bot_x < agent_beam_x + beam_width < bot_x + character_size or bot_x < agent_beam_x < bot_x + character_size):
                return True
            else:
                return False
        elif bot_current_action == 4:
            if disp_x/2 - arena_x/2 <= bot_x <= agent_x and (bot_y < agent_beam_y + beam_width < bot_y + character_size or bot_y < agent_beam_y < bot_y + character_size):
                return True
            else:
                return False


def mapping(maximum, number):
    return number#int(number * maximum)

def action(agent_action, bot_action):
    global agent_x, agent_y, bot_x, bot_y, agent_hp, bot_hp, agent_beam_fire, \
    bot_beam_fire, agent_beam_x, bot_beam_x, agent_beam_y, bot_beam_y, agent_beam_size_x, \
    agent_beam_size_y, bot_beam_size_x, bot_beam_size_y, beam_width, agent_current_action, bot_current_action, character_size

    agent_current_action = agent_action; bot_current_action = bot_action
    reward = 0; cont = True; successful = False; winner = ""
    if 1 <= bot_action <= 4:
        bot_beam_fire = True
        if bot_action == 1:
            bot_beam_x = bot_x + character_size/2 - beam_width/2; bot_beam_y = disp_y/2 - arena_y/2
            bot_beam_size_x = beam_width; bot_beam_size_y = bot_y - disp_y/2 + arena_y/2
        elif bot_action == 2:
            bot_beam_x = bot_x + character_size; bot_beam_y = bot_y + character_size/2 - beam_width/2
            bot_beam_size_x = disp_x/2 + arena_x/2 - bot_x - character_size; bot_beam_size_y = beam_width
        elif bot_action == 3:
            bot_beam_x = bot_x + character_size/2 - beam_width/2; bot_beam_y = bot_y + character_size
            bot_beam_size_x = beam_width; bot_beam_size_y = disp_y/2 + arena_y/2 - bot_y - character_size
        elif bot_action == 4:
            bot_beam_x = disp_x/2 - arena_x/2; bot_beam_y = bot_y + character_size/2 - beam_width/2
            bot_beam_size_x = bot_x - disp_x/2 + arena_x/2; bot_beam_size_y = beam_width

    elif 5 <= bot_action <= 8:
        if bot_action == 5:
            bot_y -= character_move_speed
            if bot_y <= disp_y/2 - arena_y/2:
                bot_y = disp_y/2 - arena_y/2
            elif agent_y <= bot_y <= agent_y + character_size:
                bot_y = agent_y + character_size
        elif bot_action == 6:
            bot_x += character_move_speed
            if bot_x >= disp_x/2 + arena_x/2 - character_size:
                bot_x = disp_x/2 + arena_x/2 - character_size
            elif agent_x <= bot_x + character_size <= agent_x + character_size:
                bot_x = agent_x - character_size
        elif bot_action == 7:
            bot_y += character_move_speed
            if bot_y + character_size >= disp_y/2 + arena_y/2:
                bot_y = disp_y/2 + arena_y/2 - character_size
            elif agent_y <= bot_y + character_size <= agent_y + character_size:
                bot_y = agent_y - character_size
        elif bot_action == 8:
            bot_x -= character_move_speed
            if bot_x <= disp_x/2 - arena_x/2:
                bot_x = disp_x/2 - arena_x/2
            elif agent_x <= bot_x <= agent_x + character_size:
                bot_x = agent_x + character_size

    if bot_beam_fire == True:
        if beam_hit_detector("bot"):
            #print "Agent Got Hit!"
            agent_hp -= beam_damage
            reward += -50
            bot_beam_size_x = bot_beam_size_y = 0
            bot_beam_x = bot_beam_y = beam_ob
            if agent_hp <= 0:
                cont = False
                winner = "Bot"

    if 1 <= agent_action <= 4:
        agent_beam_fire = True
        if agent_action == 1:
            if agent_y > disp_y/2 - arena_y/2:
                agent_beam_x = agent_x - beam_width/2; agent_beam_y = disp_y/2 - arena_y/2
                agent_beam_size_x = beam_width; agent_beam_size_y = agent_y - disp_y/2 + arena_y/2
            else:
                reward += -25
        elif agent_action == 2:
            if agent_x + character_size < disp_x/2 + arena_x/2:
                agent_beam_x = agent_x + character_size; agent_beam_y = agent_y + character_size/2 - beam_width/2
                agent_beam_size_x = disp_x/2 + arena_x/2 - agent_x - character_size; agent_beam_size_y = beam_width
            else:
                reward += -25
        elif agent_action == 3:
            if agent_y + character_size < disp_y/2 + arena_y/2:
                agent_beam_x = agent_x + character_size/2 - beam_width/2; agent_beam_y = agent_y + character_size
                agent_beam_size_x = beam_width; agent_beam_size_y = disp_y/2 + arena_y/2 - agent_y - character_size
            else:
                reward += -25
        elif agent_action == 4:
            if agent_x > disp_x/2 - arena_x/2:
                agent_beam_x = disp_x/2 - arena_x/2; agent_beam_y = agent_y + character_size/2 - beam_width/2
                agent_beam_size_x = agent_x - disp_x/2 + arena_x/2; agent_beam_size_y = beam_width
            else:
                reward += -25

    elif 5 <= agent_action <= 8:
        if agent_action == 5:
            agent_y -= character_move_speed
            if agent_y <= disp_y/2 - arena_y/2:
                agent_y = disp_y/2 - arena_y/2
                reward += -5
            elif bot_y <= agent_y <= bot_y + character_size and bot_x <= agent_x <= bot_x + character_size:
                agent_y = bot_y + character_size
                reward += -2
        elif agent_action == 6:
            agent_x += character_move_speed
            if agent_x + character_size >= disp_x/2 + arena_x/2:
                agent_x = disp_x/2 + arena_x/2 - character_size
                reward += -5
            elif bot_x <= agent_x + character_size <= bot_x + character_size and bot_y <= agent_y <= bot_y + character_size:
                agent_x = bot_x - character_size
                reward += -2
        elif agent_action == 7:
            agent_y += character_move_speed
            if agent_y + character_size >= disp_y/2 + arena_y/2:
                agent_y = disp_y/2 + arena_y/2 - character_size
                reward += -5
            elif bot_y <= agent_y + character_size <= bot_y + character_size and bot_x <= agent_x <= bot_x + character_size:
                agent_y = bot_y - character_size
                reward += -2
        elif agent_action == 8:
            agent_x -= character_move_speed
            if agent_x <= disp_x/2 - arena_x/2:
                agent_x = disp_x/2 - arena_x/2
                reward += -5
            elif bot_x <= agent_x <= bot_x + character_size and bot_y <= agent_y <= bot_y + character_size:
                agent_x = bot_x + character_size
                reward += -2
    if agent_beam_fire == True:
        if beam_hit_detector("agent"):
            #print "Bot Got Hit!"
            bot_hp -= beam_damage
            reward += 50
            agent_beam_size_x = agent_beam_size_y = 0
            agent_beam_x = agent_beam_y = beam_ob
            if bot_hp <= 0:
                successful = True
                cont = False
                winner = "Agent"
    return reward, cont, successful, winner

def bot_beam_dir_detector():
    global bot_current_action
    if bot_current_action == 1:
        bot_beam_dir = 2
    elif bot_current_action == 2:
        bot_beam_dir = 4
    elif bot_current_action == 3:
        bot_beam_dir = 3
    elif bot_current_action == 4:
        bot_beam_dir = 1
    else:
        bot_beam_dir = 0
    return bot_beam_dir

#Parameters
y = 0.75
e = 0.3
num_episodes = 10000
batch_size = 10
complexity = 100
with tf.Session() as sess:
    sess.run(initialize)
    success = 0
    for i in tqdm(range(1, num_episodes)):
        #print "Episode #", i
        rAll = 0; d = False; c = True; j = 0
        param_init()
        samples = []
        while c == True:
            j += 1
            current_state = np.array([[mapping(complexity, float(agent_x) / float(arena_x)),
                                        mapping(complexity, float(agent_y) / float(arena_y)),
                                        mapping(complexity, float(bot_x) / float(arena_x)),
                                        mapping(complexity, float(bot_y) / float(arena_y)),
                                        #mapping(complexity, float(agent_hp) / float(character_init_health)),
                                        #mapping(complexity, float(bot_hp) / float(character_init_health)),
                                        mapping(complexity, float(agent_x - bot_x) / float(arena_x)),
                                        mapping(complexity, float(agent_y - bot_y) / float(arena_y)),
                                        bot_beam_dir
                                        ]])
            b = bot_take_action()
            if np.random.rand(1) < e or i <= 5:
                a = random.randint(0, 8)
            else:
                a, _ = sess.run([predict, Q],feed_dict={input_layer : current_state})
            r, c, d, winner = action(a + 1, b)
            bot_beam_dir = bot_beam_dir_detector()
            next_state = np.array([[mapping(complexity, float(agent_x) / float(arena_x)),
                                        mapping(complexity, float(agent_y) / float(arena_y)),
                                        mapping(complexity, float(bot_x) / float(arena_x)),
                                        mapping(complexity, float(bot_y) / float(arena_y)),
                                        #mapping(complexity, float(agent_hp) / float(character_init_health)),
                                        #mapping(complexity, float(bot_hp) / float(character_init_health)),
                                        mapping(complexity, float(agent_x - bot_x) / float(arena_x)),
                                        mapping(complexity, float(agent_y - bot_y) / float(arena_y)),
                                        bot_beam_dir
                                        ]])
            samples.append([current_state, a, r, next_state])
            if len(samples) > 10:
                for count in xrange(batch_size):
                    [batch_current_state, action_taken, reward, batch_next_state] = samples[random.randint(0, len(samples) - 1)]
                    batch_allQ = sess.run(Q, feed_dict={input_layer : batch_current_state})
                    batch_Q1 = sess.run(Q, feed_dict = {input_layer : batch_next_state})
                    batch_maxQ1 = np.max(batch_Q1)
                    batch_targetQ = batch_allQ
                    batch_targetQ[0][a] = reward + y * batch_maxQ1
                    sess.run([updateModel], feed_dict={input_layer : batch_current_state, next_Q : batch_targetQ})
            rAll += r
            screen_blit()
            if d == True:
                e = 1. / ((i / 50) + 10)
                success += 1
                break
            #print agent_hp, bot_hp
            display.update()

        jList.append(j)
        rList.append(rAll)
        print winner

Ich bin mir ziemlich sicher, dass Sie, wenn Sie Pygame, Tensorflow und Matplotlib in einer Python-Umgebung installiert haben, die Animationen des Bots und des Agenten "kämpfen" sehen sollten.

Ich habe das Update abgeschweift, aber es wäre großartig, wenn jemand neben dem ursprünglichen allgemeinen Problem auch mein spezifisches Problem ansprechen könnte.

Vielen Dank!

Update Nr. 2 am 18. August 2017:

Basierend auf den Ratschlägen von @NeilSlater habe ich die Wiedergabe von Erfahrungen in mein Modell implementiert. Der Algorithmus hat sich verbessert, aber ich werde nach besseren Verbesserungsoptionen suchen, die Konvergenz bieten.

Update Nr. 3 am 22. August 2017:

Ich habe festgestellt, dass, wenn der Agent den Bot in einer Runde mit einer Kugel trifft und die Aktion, die der Bot in dieser Runde ausgeführt hat, nicht "eine Kugel abfeuert", die falschen Aktionen gutgeschrieben werden. Daher habe ich die Kugeln in Strahlen verwandelt, damit der Bot / Agent in der Runde, in der der Strahl abgefeuert wird, Schaden nimmt.

— IronEdward
quelle

Verwenden Sie Erfahrungswiedergabe- und Bootstrapping-Werte aus einer "eingefrorenen" Kopie des letzten Netzwerks? Dies sind Ansätze, die in DQN verwendet werden - sie sind nicht garantiert, obwohl sie für die Stabilität erforderlich sein können. Verwenden Sie ein Q (

λ

$\lambda$ ) Algorithmus oder nur einstufiges Q-Learning? Können Sie einen Hinweis darauf geben, wie Ihre Umgebung und Ihr Belohnungsschema aussehen? Einzelschritt-Q-Learning funktioniert schlecht, wenn die Belohnungen gering sind, z. B. die endgültige Belohnung von +1 oder -1 am Ende einer langen Episode.

— Neil Slater

OK, nach Ihrem Update schlage ich sofort vor, dass Sie Erfahrung mit der Wiedergabe und wahrscheinlich auch mit alternierenden Netzwerken für das Bootstrapping benötigen , da dies die Einflüsse auf das Verstärkungslernen mit nichtlinearen Approximatoren stabilisiert. Gerne spreche ich das ausführlich durch und schaue mir Ihren Projektcode an, um ein Beispiel zu zeigen. Es kann jedoch ein oder zwei Tage dauern, bis ich mit dieser Detailgenauigkeit auf Sie zurückkomme.

— Neil Slater

Ich habe den Code ausgeführt und wenn ich ihn richtig verstehe, können die Kugeln durch die Agentenauswahl aus den Aktionen 1 bis 4 in jeder Runde "gesteuert" werden, dh die Kugel kann in jede Richtung bewegt werden, während der Agent still bleibt. Ist das beabsichtigt? Der Bot tut dies nicht, weil er nur feuert, wenn er im Raster auf den Agenten ausgerichtet ist, und in diesem Fall immer die gleiche Richtung wählt.

— Neil Slater

Fast richtig, aber Sie speichern den Bootstrap-Wert nicht, sondern berechnen ihn neu, wenn der Schritt später abgetastet wird. Für jede durchgeführte Aktion speichern Sie die vier Dinge: Status, Aktion, Nächster Status, Belohnung. Dann nehmen Sie einen kleinen Mini-Batch (1 pro Schritt ist in Ordnung, aber mehr, z. B. 10 ist typisch) aus dieser Liste und berechnen für das Q-Learning die neue maximale Aktion und ihren Wert, um den überwachten Lern-Mini-Batch (auch als "Batch" bezeichnet) zu erstellen TD-Ziel ).

— Neil Slater

Das sollte "eingefrorene Kopie des Approximators (dh des neuronalen Netzwerks" sein) (wenn das Zitat aus einem meiner Kommentare oder Antworten stammt, zeigen Sie mich bitte darauf und ich werde es korrigieren. Es ist sehr einfach - behalten Sie einfach zwei Kopien des Gewichts params

w

$\mathbf{w}$ , das "Live", das Sie aktualisieren, und ein "aktuelles altes", das Sie alle paar hundert Updates aus dem "Live" kopieren. Wenn Sie das TD-Ziel berechnen, z

R + γ {max}_{a^{'}} \hat{q} (S^{'}, a^{'}, w)

$R + \gamma \text{max}_{a'} \hat{q}(S',a',\mathbf{w})$ Verwenden Sie dann die "alte" Kopie zum Berechnen

\hat{q}

$\hat{q}$ , aber dann trainiere den "lebenden" mit diesen Werten.

— Neil Slater

Wenn Ihre Gewichte voneinander abweichen, verhalten sich Ihr Optimierer oder Ihre Farbverläufe nicht gut. Ein häufiger Grund für unterschiedliche Gewichte sind explodierende Farbverläufe , die sich ergeben können aus:

zu viele Schichten oder
Zu viele wiederkehrende Zyklen, wenn Sie eine RNN verwenden.

Sie können wie folgt überprüfen, ob Sie explodierende Verläufe haben:

grad_magnitude = tf.reduce_sum([tf.reduce_sum(g**2)
                                for g in tf.gradients(loss, weights_list)])**0.5

Einige Ansätze zur Lösung des Problems explodierender Gradienten sind:

Verwenden Sie RELU- oder ELU- Aktivierungen
Verwenden Sie die Xavier-Initialisierung
Verwenden Sie eine Deep Residual-Architektur . Dadurch wird verhindert, dass die Farbverläufe durch nachfolgende Schichten gequetscht werden.

— Standardbild
quelle

Wenn Sie eine Fixpunktiteration verwenden, um Bellman zu lösen, ist diese möglicherweise nicht nur entartet, sondern weist auch Attraktoren im Unendlichen oder in Umlaufbahnen auf. Erforschen Sie das Problem, das Sie lösen, und verstehen Sie es genau. Schauen Sie sich die Steuerungstheorie an. RL-Leute neigen dazu, nicht so viel darüber zu schreiben.

— Mathtick
quelle