CarRacing DQN: Deep Q-Learning zum Training selbstfahrender Autos

Einführung

Im Bereich Reinforcement Learning ist die Ausbildung eines CarRacing 2D-Agenten zum autonomen Fahren eine faszinierende Herausforderung. In diesem Blog befassen wir uns mit dem Code für Deep Q Learning (DQN), der mit TensorFlow und Keras implementiert wurde, um ein Modell zu trainieren, das in der Lage ist, auf der virtuellen Rennstrecke von CarRacing zu navigieren.

Prinzip des DQN-Algorithmus

Q-Werte und die Bellman-Gleichung

Der Q-Wert (die erwartete kumulative Belohnung für ein Zustands-Aktionspaar) wird durch die Bellman-Gleichung definiert:
[ Q(s,a) = r(s,a) + \gamma \max Q(s', A) ]

• (s) ist der aktuelle Zustand
• (a) ist die durchgeführte Aktion
• (r(s,a)) ist die Belohnung nach Durchführung der Aktion (a) im Zustand (s)
• (s') ist der nächste Zustand
• (A) ist der Aktionsraum
• (\gamma) ist der Abzinsungssatz, der zur Messung der Bedeutung zukünftiger Belohnungen verwendet wird

DQN-Struktur

DQN kombiniert Q-Learning mit Deep Learning und ersetzt die Q-Tabelle durch ein neuronales Netzwerk. Der Aufbau des Modells ist wie folgt:

model = Sequential()
model.add(Conv2D(filters=6, kernel_size=(7, 7), strides=3, activation='relu', input_shape=(96, 96, self.frame_stack_num)))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(filters=12, kernel_size=(4, 4), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(216, activation='relu'))
model.add(Dense(len(self.action_space), activation=None))
model.compile(loss='mean_squared_error', optimizer=Adam(lr=self.learning_rate, epsilon=1e-7))

• Die Eingabe besteht aus drei aufeinanderfolgenden Draufsichtbildern mit jeweils 96 x 96 Pixeln
• Zur Erfassung von Bildmerkmalen werden Faltungsschichten und Max-Pooling-Schichten verwendet
• Die vollständig verbundene Schicht gibt den Q-Wert jeder Aktion aus

Gestaltung von Schulungsprozessen

Erleben Sie Wiederholung

Um die zeitliche Korrelation zwischen Daten zu unterbrechen, wird die Erfahrungswiedergabe verwendet, um frühere Erfahrungen im Erfahrungspool zu speichern und daraus zufällige Stichproben für das Training zu ziehen.

def memorize(self, state, action, reward, next_state, done):
    self.memory.append((state, self.action_space.index(action), reward, next_state, done))

Zielnetzwerk

Führen Sie das Zielnetzwerk ein, um die Änderung des Ziels zu verlangsamen und die Stabilität des Trainings zu verbessern.

def update_target_model(self):
    self.target_model.set_weights(self.model.get_weights())

Trainingsschleife

def replay(self, batch_size):
    minibatch = random.sample(self.memory, batch_size)
    train_state = []
    train_target = []
    for state, action_index, reward, next_state, done in minibatch:
        target = self.model.predict(np.expand_dims(state, axis=0))[0]
        if done:
            target[action_index] = reward
        else:
            t = self.target_model.predict(np.expand_dims(next_state, axis=0))[0]
            target[action_index] = reward + self.gamma * np.amax(t)
        train_state.append(state)
        train_target.append(target)
    self.model.fit(np.array(train_state), np.array(train_target), epochs=1, verbose=0)

In jedem Trainingszyklus wird ein Datenstapel zufällig aus dem Erfahrungspool ausgewählt, der Ziel-Q-Wert berechnet und die Modellgewichte aktualisiert.

Trainingsergebnisse und Modellentwicklung

Durch Training beobachten wir, dass das Modell nach und nach lernt, auf der Strecke zu navigieren:

Nach 400 Trainingsrunden

Das Modell hatte beim Lernen Schwierigkeiten, scharfe Kurven zu fahren, und kam gelegentlich von der Spur ab.

Nach 500 Trainingsrunden

Das Modell wird leistungsfähiger, macht weniger Fehler und fährt flüssiger.

Nach 600 Trainingsrunden

Das Modell wurde in seiner Gier nach Belohnungen rücksichtslos und kam in scharfen Kurven von der Strecke ab.

Zusammenfassen

Dieser Blog bietet eine detaillierte Analyse des Prozesses der Schulung selbstfahrender Agenten mithilfe des DQN-Algorithmus. Durch Erfahrungswiedergabe und die Anwendung von Zielnetzwerken lernt das Modell nach und nach, den Q-Wert zu optimieren, um bessere Navigationsstrategien zu erreichen. Deep Q-Learning bietet eine leistungsstarke und flexible Methode zur Lösung von Entscheidungsproblemen in komplexen Umgebungen und liefert neue Ideen für Forschung und Anwendungen im Bereich des autonomen Fahrens.