🔬 🤶🏼 👩‍🔬 Verbesserung des aktienbasierten Q-Learning-Agenten durch Hinzufügen von Wiederholungen und Belohnungen 💘 👨🏻‍🏫 💼

Erinnerung

Hallo Habr! Ich mache Sie auf eine weitere Übersetzung meines neuen Artikels aus dem Medium aufmerksam .

Beim letzten Mal ( erster Artikel ) ( Habr ) haben wir einen Agenten mit Q-Learning-Technologie erstellt, der Transaktionen mit simulierten und realen Austauschzeitreihen durchführt, und versucht zu prüfen, ob dieser Aufgabenbereich für verstärktes Lernen geeignet ist.

Dieses Mal werden wir eine LSTM-Ebene hinzufügen, um Zeitabhängigkeiten innerhalb der Trajektorie zu berücksichtigen und das Belohnungs-Shaping-Engineering basierend auf Präsentationen durchzuführen.

Bild

Ich möchte Sie daran erinnern, dass wir zur Überprüfung des Konzepts die folgenden synthetischen Daten verwendet haben:

Bild

Synthetische Daten: Sinus mit weißem Rauschen.

Die Sinusfunktion war der erste Ausgangspunkt. Zwei Kurven simulieren den Kauf- und Verkaufspreis eines Vermögenswerts, wobei der Spread die minimalen Transaktionskosten darstellt.

Dieses Mal möchten wir diese einfache Aufgabe jedoch komplizieren, indem wir den Kreditzuweisungspfad erweitern:

Bild

Synthetische Daten: Sinus mit weißem Rauschen.

Die Sinusphase wurde verdoppelt.

Dies bedeutet, dass sich die spärlichen Belohnungen, die wir verwenden, über längere Flugbahnen erstrecken müssen. Darüber hinaus verringern wir die Wahrscheinlichkeit, eine positive Belohnung zu erhalten, erheblich, da der Agent eine Folge korrekter Aktionen zweimal länger ausführen musste, um die Transaktionskosten zu überwinden. Beide Faktoren erschweren die Aufgabe für RL selbst unter so einfachen Bedingungen wie einer Sinuswelle erheblich.

Darüber hinaus erinnern wir uns, dass wir diese neuronale Netzwerkarchitektur verwendet haben:

Bild

Was wurde hinzugefügt und warum

Lstm

Zunächst wollten wir dem Agenten ein besseres Verständnis für die Dynamik von Änderungen innerhalb der Flugbahn vermitteln. Einfach ausgedrückt, der Agent sollte sein eigenes Verhalten besser verstehen: Was er jetzt und seit einiger Zeit in der Vergangenheit getan hat und wie sich die Verteilung der staatlichen Aktionen sowie die erhaltenen Belohnungen entwickelt haben. Die Verwendung einer Wiederholungsebene kann genau dieses Problem lösen. Willkommen zu der neuen Architektur, mit der neue Experimente gestartet wurden:

Bild

Bitte beachten Sie, dass ich die Beschreibung leicht verbessert habe. Der einzige Unterschied zum alten NN besteht in der ersten verborgenen LSTM-Schicht anstelle einer vollständig gebundenen.

Bitte beachten Sie, dass wir mit LSTM in Arbeit die Auswahl von Beispielen für die Reproduktion von Erfahrungen für das Training ändern müssen: Jetzt benötigen wir Übergangssequenzen anstelle von separaten Beispielen. So funktioniert es (dies ist einer der Algorithmen). Wir haben zuvor Punktstichproben verwendet:

Bild

Das fiktive Schema des Wiedergabepuffers.

Wir verwenden dieses Schema mit LSTM:

Bild

Nun werden Sequenzen ausgewählt (deren Länge wir empirisch angeben).

Nach wie vor und jetzt wird die Stichprobe durch einen Prioritätsalgorithmus reguliert, der auf Fehlern des zeitlich-zeitlichen Lernens basiert.

Das LSTM-Wiederholungsniveau ermöglicht die direkte Verbreitung von Informationen aus Zeitreihen, um ein zusätzliches Signal abzufangen, das in früheren Verzögerungen verborgen ist. Unsere Zeitreihe ist ein zweidimensionaler Tensor mit Größe: die Länge der Sequenz auf der Darstellung unserer Zustandsaktion.

Präsentationen

Das preisgekrönte Engineering Potential Based Reward Shaping (PBRS), basierend auf Potenzial, ist ein leistungsstarkes Tool, um die Geschwindigkeit und Stabilität zu erhöhen und nicht die Optimalität des Richtliniensuchprozesses zur Lösung unserer Umgebung zu verletzen. Ich empfehle, mindestens dieses Originaldokument zum Thema zu lesen:

people.eecs.berkeley.edu/~russell/papers/ml99-shaping.ps

Das Potenzial bestimmt, wie gut unser aktueller Status im Verhältnis zum Zielstatus ist, in den wir eintreten möchten. Eine schematische Ansicht, wie dies funktioniert:

Bild

Es gibt Optionen und Schwierigkeiten, die Sie nach Versuch und Irrtum verstehen könnten, und wir lassen diese Details weg, sodass Sie Ihre Hausaufgaben machen können.

Es ist noch eine weitere Sache zu erwähnen, nämlich dass PBRS durch Präsentationen gerechtfertigt werden kann, die eine Form von Expertenwissen (oder simuliertem Wissen) über das nahezu optimale Verhalten des Agenten in der Umgebung darstellen. Es gibt eine Möglichkeit, solche Präsentationen für unsere Aufgabe mithilfe von Optimierungsschemata zu finden. Wir lassen die Details der Suche weg.

Die potenzielle Belohnung hat folgende Form (Gleichung 1):

r '= r + gamma * F (s') - F (s)

Dabei ist F das Potenzial des Staates und r die anfängliche Belohnung. Gamma ist der Abzinsungsfaktor (0: 1).

Mit diesen Gedanken fahren wir mit der Codierung fort.

Implementierung in R.
Hier ist der neuronale Netzwerkcode, der auf der Keras-API basiert:

Code

# configure critic NN — — — — — — library('keras') library('R6') state_names_length <- 12 # just for example lstm_seq_length <- 4 learning_rate <- 1e-3 a_CustomLayer <- R6::R6Class( “CustomLayer” , inherit = KerasLayer , public = list( call = function(x, mask = NULL) { x — k_mean(x, axis = 2, keepdims = T) } ) ) a_normalize_layer <- function(object) { create_layer(a_CustomLayer, object, list(name = 'a_normalize_layer')) } v_CustomLayer <- R6::R6Class( “CustomLayer” , inherit = KerasLayer , public = list( call = function(x, mask = NULL) { k_concatenate(list(x, x, x), axis = 2) } , compute_output_shape = function(input_shape) { output_shape = input_shape output_shape[[2]] <- input_shape[[2]] * 3L output_shape } ) ) v_normalize_layer <- function(object) { create_layer(v_CustomLayer, object, list(name = 'v_normalize_layer')) } noise_CustomLayer <- R6::R6Class( “CustomLayer” , inherit = KerasLayer , lock_objects = FALSE , public = list( initialize = function(output_dim) { self$output_dim <- output_dim } , build = function(input_shape) { self$input_dim <- input_shape[[2]] sqr_inputs <- self$input_dim ** (1/2) self$sigma_initializer <- initializer_constant(.5 / sqr_inputs) self$mu_initializer <- initializer_random_uniform(minval = (-1 / sqr_inputs), maxval = (1 / sqr_inputs)) self$mu_weight <- self$add_weight( name = 'mu_weight', shape = list(self$input_dim, self$output_dim), initializer = self$mu_initializer, trainable = TRUE ) self$sigma_weight <- self$add_weight( name = 'sigma_weight', shape = list(self$input_dim, self$output_dim), initializer = self$sigma_initializer, trainable = TRUE ) self$mu_bias <- self$add_weight( name = 'mu_bias', shape = list(self$output_dim), initializer = self$mu_initializer, trainable = TRUE ) self$sigma_bias <- self$add_weight( name = 'sigma_bias', shape = list(self$output_dim), initializer = self$sigma_initializer, trainable = TRUE ) } , call = function(x, mask = NULL) { #sample from noise distribution e_i = k_random_normal(shape = list(self$input_dim, self$output_dim)) e_j = k_random_normal(shape = list(self$output_dim)) #We use the factorized Gaussian noise variant from Section 3 of Fortunato et al. eW = k_sign(e_i) * (k_sqrt(k_abs(e_i))) * k_sign(e_j) * (k_sqrt(k_abs(e_j))) eB = k_sign(e_j) * (k_abs(e_j) ** (1/2)) #See section 3 of Fortunato et al. noise_injected_weights = k_dot(x, self$mu_weight + (self$sigma_weight * eW)) noise_injected_bias = self$mu_bias + (self$sigma_bias * eB) output = k_bias_add(noise_injected_weights, noise_injected_bias) output } , compute_output_shape = function(input_shape) { output_shape <- input_shape output_shape[[2]] <- self$output_dim output_shape } ) ) noise_add_layer <- function(object, output_dim) { create_layer( noise_CustomLayer , object , list( name = 'noise_add_layer' , output_dim = as.integer(output_dim) , trainable = T ) ) } critic_input <- layer_input( shape = list(NULL, as.integer(state_names_length)) , name = 'critic_input' ) common_lstm_layer <- layer_lstm( units = 20 , activation = “tanh” , recurrent_activation = “hard_sigmoid” , use_bias = T , return_sequences = F , stateful = F , name = 'lstm1' ) critic_layer_dense_v_1 <- layer_dense( units = 10 , activation = “tanh” ) critic_layer_dense_v_2 <- layer_dense( units = 5 , activation = “tanh” ) critic_layer_dense_v_3 <- layer_dense( units = 1 , name = 'critic_layer_dense_v_3' ) critic_layer_dense_a_1 <- layer_dense( units = 10 , activation = “tanh” ) # critic_layer_dense_a_2 <- layer_dense( # units = 5 # , activation = “tanh” # ) critic_layer_dense_a_3 <- layer_dense( units = length(actions) , name = 'critic_layer_dense_a_3' ) critic_model_v <- critic_input %>% common_lstm_layer %>% critic_layer_dense_v_1 %>% critic_layer_dense_v_2 %>% critic_layer_dense_v_3 %>% v_normalize_layer critic_model_a <- critic_input %>% common_lstm_layer %>% critic_layer_dense_a_1 %>% #critic_layer_dense_a_2 %>% noise_add_layer(output_dim = 5) %>% critic_layer_dense_a_3 %>% a_normalize_layer critic_output <- layer_add( list( critic_model_v , critic_model_a ) , name = 'critic_output' ) critic_model_1 <- keras_model( inputs = critic_input , outputs = critic_output ) critic_optimizer = optimizer_adam(lr = learning_rate) keras::compile( critic_model_1 , optimizer = critic_optimizer , loss = 'mse' , metrics = 'mse' ) train.x <- array_reshape(rnorm(10 * lstm_seq_length * state_names_length) , dim = c(10, lstm_seq_length, state_names_length) , order = 'C') predict(critic_model_1, train.x) layer_name <- 'noise_add_layer' intermediate_layer_model <- keras_model(inputs = critic_model_1$input, outputs = get_layer(critic_model_1, layer_name)$output) predict(intermediate_layer_model, train.x)[1,] critic_model_2 <- critic_model_1

Debuggen Sie Ihre Entscheidung auf Ihr Gewissen ...

Ergebnisse und Vergleich

Lassen Sie uns gleich auf die Endergebnisse eingehen. Hinweis: Alle Ergebnisse sind Punktschätzungen und können bei mehreren Läufen mit unterschiedlichen zufälligen Startseiten unterschiedlich sein.

Der Vergleich beinhaltet:

vorherige Version ohne LSTM und Präsentationen
einfaches 2-Element-LSTM
4-Element-LSTM
4-Zellen-LSTM mit generierten PBRS-Belohnungen

Die durchschnittliche Rendite pro Folge betrug durchschnittlich über 1000 Folgen.

Bild

Die gesamte Folge kehrt zurück.

Diagramme für den erfolgreichsten Agenten:

Bild

Agentenleistung.

Nun, es ist ziemlich offensichtlich, dass der Agent in Form von PBRS im Vergleich zu früheren Versuchen so schnell und stabil konvergiert, dass er als signifikantes Ergebnis akzeptiert werden kann. Die Geschwindigkeit ist etwa 4-5 mal höher als ohne Präsentationen. Stabilität ist wunderbar.

Bei der Verwendung von LSTM zeigten 4 Zellen eine bessere Leistung als 2 Zellen. Ein 2-Zellen-LSTM schnitt besser ab als eine Nicht-LSTM-Version (dies ist jedoch möglicherweise eine Illusion eines einzelnen Experiments).

Letzte Worte

Wir haben gesehen, dass Wiederholungen und Kapazitätsaufbau helfen. Mir hat besonders gut gefallen, wie gut das PBRS abschneidet.

Glauben Sie niemandem, der mich dazu bringt zu sagen, dass es einfach ist, einen gut konvergierenden RL-Agenten zu erstellen, da dies eine Lüge ist. Jede neue Komponente, die dem System hinzugefügt wird, macht es möglicherweise weniger stabil und erfordert viel Konfiguration und Debugging.

Es gibt jedoch eindeutige Hinweise darauf, dass die Lösung des Problems einfach durch Verbesserung der verwendeten Methoden verbessert werden kann (die Daten blieben erhalten). Es ist eine Tatsache, dass für jede Aufgabe ein bestimmter Bereich von Parametern besser funktioniert als andere. In diesem Sinne beschreiten Sie einen erfolgreichen Lernpfad.

Vielen Dank.