DQN-Algorithmus (Deep Q-Network) für verstärkendes Lernen

1. Einleitung

DQNDer Algorithmus ist eines der ersten algorithmischen Modelle, das beim Reinforcement Learning im Bereich Deep Learning weit verbreitet ist. Es wurde 2013 vom DeepMind-Forschungsteam vorgeschlagen. Durch die Kombination des tiefen neuronalen Netzwerks mit dem klassischen Reinforcement-Learning-Algorithmus Q-learningrealisiert es die Verarbeitung hochdimensionaler und kontinuierlicher Zustandsräume und verfügt über die Fähigkeit zum Lernen und Planen.

2. Geschichte

Bevor DQNder Algorithmus vorgeschlagen wurde, waren die klassischen Algorithmen beim Reinforcement Learning hauptsächlich tabellenbasierte Q学习Algorithmen. Diese Algorithmen zeichnen sich bei einfachen niedrigdimensionalen Problemen aus, aber die Speicher- und Rechenkomplexität der tabellarischen Darstellung wächst exponentiell mit zunehmenden Zustands- und Aktionsräumen. Um dieses Problem zu lösen, begannen Forscher, die Verwendung der Funktionsnäherung zu untersuchen, d. h. die Verwendung parametrisierter Funktionen anstelle von Tabellen.

Danach wurde nach und nach eine Reihe von Algorithmen entwickelt, die Deep Learning auf Reinforcement Learning anwendeten. Der DQN-Algorithmus ist einer davon. Er wurde 2013 von Alex Krizhevsky et al. vorgeschlagen und ist der erste Algorithmus, der Deep Learning mit Reinforcement Learning kombiniert. Der DQN-Algorithmus führt weitere Technologien 经验回放ein 固定Q目标网络, die die Leistung tiefer neuronaler Netze beim Reinforcement Learning erheblich verbessern. Anschließend erzielte der DQN-Algorithmus in Atari-Spielen bessere Ergebnisse als menschliche Spieler, was umfangreiche Aufmerksamkeit und Forschung erregte.

Q-Learning: Q-Learning ist ein klassischer Algorithmus des Reinforcement Learning, der 1989 von Watkins et al. vorgeschlagen wurde. Es verwendet eine Q-Tabelle, um den Wert von Zuständen und Aktionen zu speichern, und erlernt durch kontinuierliche Aktualisierung und Erkundung die optimale Richtlinie. Der Q-Learning-Algorithmus kann jedoch nicht skaliert werden, wenn er mit großen Zustandsräumen konfrontiert wird.

Deep Q-Network (DQN): Der DQN-Algorithmus wurde 2013 vom DeepMind-Team vorgeschlagen. Er löst das Problem eines großen Zustandsraums, indem er ein tiefes neuronales Netzwerk verwendet, um den Wert der Q-Funktion anzunähern. Der Algorithmus nutzt zwei Schlüsseltechnologien: Experience Replay und Fixed-Q Target Network.

经验回放: Die Erfahrungswiedergabe ist eine der Kernideen des DQN-Algorithmus. Sein Grundprinzip besteht darin, die Erfahrung des Agenten in einem Wiedergabespeicher zu speichern, daraus dann zufällig Stichproben zu machen und diese Erfahrungen zur Aktualisierung des Modells zu verwenden. Dies hat den Vorteil, dass Korrelationen zwischen Stichproben vermieden und die Stabilität und Konvergenzgeschwindigkeit des Modells verbessert werden.

固定Q目标网络: Der DQN-Algorithmus verwendet zwei neuronale Netzwerke, eines ist das Hauptnetzwerk (Online-Netzwerk), das zur Auswahl von Aktionen und zur Durchführung von Modellaktualisierungen verwendet wird; das andere ist das Zielnetzwerk (Zielnetzwerk), das zur Berechnung des Ziel-Q-Werts verwendet wird . Die Parameter des Zielnetzwerks werden für einen bestimmten Zeitraum festgelegt, wodurch die Schwankung des Ziels verringert und die Stabilität des Modells verbessert werden kann.

3. Algorithmusformel

Natur:Q-learning+深度神经网络 = DQN

3.1 Formel des Q-Learning-Algorithmus

Q-learningDer Algorithmus lernt die optimale Strategie, indem er den Q-Wert kontinuierlich aktualisiert. Die Aktualisierungsformel lautet wie folgt:

3.2 Formel des DQN-Algorithmus:

DQNDer Algorithmus aktualisiert das Modell, indem er den mittleren quadratischen Fehlerverlust der Q-Funktion minimiert. Die Aktualisierungsformel lautet wie folgt:

4. Algorithmusprinzip

Das Prinzip des DQN-Algorithmus besteht darin, die Verarbeitung eines hochdimensionalen und kontinuierlichen Zustandsraums mithilfe eines tiefen neuronalen Netzwerks zu realisieren, um den Wert der Q-Funktion anzunähern. Seine Kernidee besteht darin, die optimale Strategie zu erlernen, indem die Parameter des neuronalen Netzwerks ständig aktualisiert werden, sodass der Ausgabe-Q-Wert nahe am tatsächlichen Q-Wert liegt.

Der DQN-Algorithmus funktioniert wie folgt:

Initialisierung: Initialisieren Sie die Parameter des Hauptnetzwerks und des Zielnetzwerks.

Wählen Sie eine Aktion aus: Verwenden Sie entsprechend dem aktuellen Status s die ε-Greedy-Strategie, um eine Aktion a auszuwählen.

Führen Sie Aktionen aus und beobachten Sie Belohnungen: Ergreifen Sie Aktion a, interagieren Sie mit der Umgebung, beobachten Sie den nächsten Zustand s' und belohnen Sie sofort r.

Erfahrung speichern: Speichern Sie (s, a, r, s') in der Speicherbank für die Erlebniswiedergabe.

Zufällige Stichprobe aus der Erfahrungswiederholungsspeicherbank: Stichprobenweise eine Reihe von Erfahrungen aus der Speicherbank.

Berechnen Sie den Ziel-Q-Wert: Verwenden Sie das Zielnetzwerk, um den Ziel-Q-Wert zu berechnen, d. h. max(Q(s', a, θ-)).

Aktualisieren Sie das Hauptnetzwerk: Aktualisieren Sie die Modellparameter gemäß der Verlustfunktion L (θ).

Zielnetzwerk aktualisieren: Aktualisieren Sie regelmäßig die Parameter des Zielnetzwerks.

Wiederholen Sie die Schritte 2–8, bis die Beendigungsbedingung erfüllt ist.

5. Algorithmusfunktion

DQNDer Algorithmus hat folgende Funktionen:

Umgang mit hochdimensionalen, kontinuierlichen Zustandsräumen: Durch die Approximationsfähigkeiten tiefer neuronaler Netze können Probleme in hochdimensionalen, kontinuierlichen Zustandsräumen behandelt werden.

Lern- und Planungsfähigkeit: Durch Interaktion mit der Umgebung und kontinuierliches Ausprobieren kann der DQN-Algorithmus die optimale Strategie erlernen und über eine gewisse Planungsfähigkeit verfügen.

Hohe Stabilität und Konvergenzgeschwindigkeit: Der DQN-Algorithmus verbessert die Stabilität und Konvergenzgeschwindigkeit des Modells durch Technologien wie Erlebniswiedergabe und festes Q-Zielnetzwerk.

6. Beispielcode

Das Folgende ist ein Beispielcode, der den DQN-Algorithmus verwendet, um das klassische CartPole-Problem zu lösen:

# -*- coding: utf-8 -*-
import gym
import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.optimizers import Adam

env = gym.make('CartPole-v0')
n_actions = env.action_space.n
n_states = env.observation_space.shape[0]

def create_dqn_model():
    model = Sequential()
    model.add(Dense(32, input_shape=(n_states,), activation='relu'))
    model.add(Dense(32, activation='relu'))
    model.add(Dense(n_actions, activation='linear'))
    model.compile(loss='mse', optimizer=Adam(lr=0.001))
    return model

def choose_action(state, epsilon):
    if np.random.rand() < epsilon:
        return np.random.choice(n_actions)
    else:
        q_values = model.predict(state)
        return np.argmax(q_values[0])

def train_dqn():
    epsilon = 1.0
    epsilon_min = 0.01
    epsilon_decay = 0.995
    batch_size = 32
    replay_memory = []
    for episode in range(500):
        state = env.reset()
        state = np.reshape(state, [1, n_states])
        done = False
        steps = 0

        while not done:
            env.render()
            action = choose_action(state, epsilon)
            next_state, reward, done, _ = env.step(action)
            next_state = np.reshape(next_state, [1, n_states])
            replay_memory.append((state, action, reward, next_state, done))
            state = next_state
            steps += 1

            if done:
                print("Episode: %d, Steps: %d" % (episode, steps))
                break
            if len(replay_memory) > batch_size:
                minibatch = np.random.choice(replay_memory, batch_size, replace=False)
                states_mb = np.concatenate([mb[0] for mb in minibatch])
                actions_mb = np.array([mb[1] for mb in minibatch])
                rewards_mb = np.array([mb[2] for mb in minibatch])
                next_states_mb = np.concatenate([mb[3] for mb in minibatch])
                dones_mb = np.array([mb[4] for mb in minibatch])

                targets = rewards_mb + 0.99 * (np.amax(model.predict_on_batch(next_states_mb), axis=1)) * (1 - dones_mb)
                targets_full = model.predict_on_batch(states_mb)
                ind = np.array([i for i in range(batch_size)])
                targets_full[[ind], [actions_mb]] = targets

                model.fit(states_mb, targets_full, epochs=1, verbose=0)

            if epsilon > epsilon_min:
                epsilon *= epsilon_decay

    env.close()

if __name__ == '__main__':

    model = create_dqn_model()

    train_dqn()

Referenz:

https://www.ngui.cc/el/2433927.html?action=onClick
https://blog.csdn.net/Zhang_0702_China/article/details/123423637
https://www.jb51.net/article/231665. htm
http://lihuaxi.xjx100.cn/news/1290031.html?action=onClick