it-swarm.com.de

Viele zu eins und viele zu viele LSTM-Beispiele in Keras

Ich versuche, LSTMs zu verstehen und wie man sie mit Keras erstellt. Ich habe herausgefunden, dass es hauptsächlich die 4 Modi gibt, um eine RNN auszuführen (die 4 richtigen im Bild)

enter image description here Bildquelle: Andrej Karpathy

Nun frage ich mich, wie ein minimalistischer Codeausschnitt für jeden von ihnen in Keras aussehen würde. Also sowas wie

model = Sequential()
model.add(LSTM(128, input_shape=(timesteps, data_dim)))
model.add(Dense(1))

für jede der 4 aufgaben vielleicht mit ein wenig erklärung.

83
Luca Thiede

Damit:

  1. Eins-zu-eins: Sie können eine Dense -Ebene verwenden, da Sie keine Sequenzen verarbeiten:
    model.add(Dense(output_size, input_shape=input_shape))

2. Eins-zu-viele: Diese Option wird nicht gut unterstützt, da das Verketten von Modellen in Keras nicht sehr einfach ist. Daher ist die folgende Version die einfachste:

    model.add(RepeatVector(number_of_times, input_shape=input_shape))
    model.add(LSTM(output_size, return_sequences=True))
  1. Many-to-One: Ihr Code-Snippet ist (fast) ein Beispiel für diesen Ansatz:
    model = Sequential()
    model.add(LSTM(1, input_shape=(timesteps, data_dim)))
  1. Viele-zu-Viele: Dies ist der einfachste Ausschnitt, wenn die Länge der Ein- und Ausgabe mit der Anzahl der wiederkehrenden Schritte übereinstimmt:
    model = Sequential()
    model.add(LSTM(1, input_shape=(timesteps, data_dim), return_sequences=True))
  1. Viele-zu-viele, wenn die Anzahl der Schritte von der Eingabe-/Ausgabelänge abweicht: Dies ist in Keras verrückt. Es gibt keine einfachen Code-Schnipsel, um das zu codieren.

EDIT: Ad 5

In einer meiner letzten Anwendungen haben wir etwas implementiert, das vielen zu vielen aus dem 4. Image ähneln könnte. Falls Sie ein Netzwerk mit der folgenden Architektur haben möchten (wenn eine Eingabe länger als die Ausgabe ist):

                                        O O O
                                        | | |
                                  O O O O O O
                                  | | | | | | 
                                  O O O O O O

Sie können dies auf folgende Weise erreichen:

    model = Sequential()
    model.add(LSTM(1, input_shape=(timesteps, data_dim), return_sequences=True))
    model.add(Lambda(lambda x: x[:, -N:, :]

Wobei N die Anzahl der letzten Schritte ist, die Sie abdecken möchten (auf Bild N = 3).

Von diesem Punkt an:

                                        O O O
                                        | | |
                                  O O O O O O
                                  | | | 
                                  O O O 

ist so einfach wie eine künstliche Polstersequenz der Länge N unter Verwendung von z.B. mit 0 Vektoren, um es auf eine geeignete Größe einzustellen.

85
Marcin Możejko

Tolle Antwort von @Marcin Możejko

Ich würde füge folgendes zu NR.5 hinz (viele zu viele mit unterschiedlicher Ein-/Aus-Länge):

A) als Vanille LSTM

model = Sequential()
model.add(LSTM(N_BLOCKS, input_shape=(N_INPUTS, N_FEATURES)))
model.add(Dense(N_OUTPUTS))

B) als Encoder-Decoder LSTM

model.add(LSTM(N_BLOCKS, input_shape=(N_INPUTS, N_FEATURES))  
model.add(RepeatVector(N_OUTPUTS))
model.add(LSTM(N_BLOCKS, return_sequences=True))  
model.add(TimeDistributed(Dense(1)))
model.add(Activation('linear')) 
0
gustavz