Unterschied zwischen einem LSTM mit einer Einheit und einem neuronalen LSTM-Netzwerk mit drei Einheiten

Das LSTM im folgenden Keras-Code

input_t = Input((4, 1))
output_t = LSTM(1)(input_t)
model = Model(inputs=input_t, outputs=output_t)
print(model.summary())

kann dargestellt werden als

Ich verstehe, dass, wenn wir model.predict(np.array([[[1],[2],[3],[4]]]))die (einzige) LSTM-Einheit aufrufen , zuerst der Vektor [1], dann [2] plus die Rückmeldung von der vorherigen Eingabe usw. bis zum Vektor [4] verarbeitet wird. Mit anderen Worten .$x_1 = [1], x_2 = [2], x_3 = [3], x_4 = [4]$

Ich verstehe nicht, wie das folgende neuronale Netzwerk dieselbe Eingabesequenz verarbeiten würde [1],[2],[3],[4]

 input_t = Input((4, 1))
 output_t = LSTM(3)(input_t)
 model = Model(inputs=input_t, outputs=output_t)
 print(model.summary())

In diesem NN haben wir drei LSTM-Einheiten. Wie verarbeiten sie die Sequenz [1],[2],[3],[4]? Sind sie miteinander verbunden? Verarbeiten sie die Eingabesequenz parallel oder verarbeitet eine Einheit die Eingabesequenz und später wird ihre Eingabe der zweiten LSTM-Einheit zugeführt und so weiter? Könnte jemand, der dieses Bild schematisch verwendet, den gesamten Prozess erklären?

In Keras LSTM(n)bedeutet "Erstellen einer LSTM-Schicht, die aus LSTM-Einheiten besteht". Das folgende Bild zeigt, was Schicht und Einheit (oder Neuron) sind, und das Bild ganz rechts zeigt die interne Struktur einer einzelnen LSTM-Einheit.

Das folgende Bild zeigt, wie die gesamte LSTM-Schicht funktioniert.

Wie wir wissen, verarbeitet eine LSTM-Schicht eine Sequenz, dh . Bei jedem Schritt die Schicht (jedes Neuron) die Eingabe , die Ausgabe aus dem vorherigen Schritt und die Vorspannung und gibt einen Vektor . Die Koordinaten von sind Ausgaben der Neuronen / Einheiten, und daher ist die Größe des Vektors gleich der Anzahl der Einheiten / Neuronen. Dieser Vorgang wird bis fortgesetzt . t x t H t - 1 b H t H t H t x$\mathbb{x}_1, \dots, \mathbb{x}_N$$t$$\mathbb{x_t}$$\mathbb{h_{t-1}}$$b$$\mathbb{h_t}$$\mathbb{h_t}$$\mathbb{h_t}$$\mathbb{x}_N$

Berechnen wir nun die Anzahl der Parameter für LSTM(1)und LSTM(3)und vergleichen sie mit dem, was Keras beim Aufruf anzeigt model.summary().

Sei die Größe des Vektors und die Größe des Vektors (dies ist auch die Anzahl der Neuronen / Einheiten). Jedes Neuron / jede Einheit nimmt einen Eingabevektor, eine Ausgabe aus dem vorherigen Schritt und eine Vorspannung, die Parameter (Gewichte) . Aber wir haben Anzahl von Neuronen und so haben wir Parameter. Schließlich hat jede Einheit 4 Gewichte (siehe Bild ganz rechts, gelbe Kästchen) und wir haben die folgende Formel für die Anzahl der Parameter: x t o u t h t i n p + o u t + 1 O u t o u t × ( i n p + o u t + 1 ) 4 O u t ( i n p + o u t + 1 $inp$$\mathbb{x_t}$$out$$\mathbb{h_t}$$inp + out + 1$$out$$out\times(inp + out + 1)$

$$4out(inp + out + 1)$$

Vergleichen wir mit den Keras-Ausgaben.

Beispiel 1.

 t1 = Input(shape=(1, 1))
 t2 = LSTM(1)(t1)
 model = Model(inputs=t1, outputs=t2)
 print(model.summary())

  Layer (type)                 Output Shape              Param #   
  =================================================================
  input_2 (InputLayer)         (None, 1, 1)              0         
  _________________________________________________________________
  lstm_2 (LSTM)                (None, 1)                 12        
  =================================================================
  Total params: 12
  Trainable params: 12
  Non-trainable params: 0
  _________________________________________________________________

$4\times 1 \times (1 + 1 + 1) = 12$

Beispiel 2.

  input_t = Input((4, 2))
  output_t = LSTM(3)(input_t)
  model = Model(inputs=input_t, outputs=output_t)
  print(model.summary())

    _________________________________________________________________
    Layer (type)                 Output Shape              Param #   
    =================================================================
    input_6 (InputLayer)         (None, 4, 2)              0         
    _________________________________________________________________
    lstm_6 (LSTM)                (None, 3)                 72        
    =================================================================
    Total params: 72
    Trainable params: 72
    Non-trainable params: 0

$4\times 3 \times (2 + 3 +1) = 72$

Normalerweise arbeite ich mit Tensorflow, aber wie ich in der Dokumentation sehen konnte, ähnelt es Keras.

Wenn Sie anrufen LSTM(3), erstellen Sie LSTM NICHT wie in diesem Bild 1 übereinander . Dies ist ein ganz anderes Problem.

Beim Erstellen erstellen LSTM(3)Sie jedoch ein LSTM mit 3 versteckten Einheiten oder versteckten Zellen . In Ihrem Code ist 3 die Dimension der inneren Zellen in LSTM. Was bedeutet das? Dies bedeutet, dass die Dimensionalität des verborgenen Zustands und die Dimensionalität des Ausgabezustands mit Ihrem Parameter der verborgenen Einheiten übereinstimmen.

Anstatt sich ein LSTM als etwas vorzustellen, das eine Folge von Skalaren erhält und Skalar gibt und ausgibt, stellen Sie sich Folgendes vor: Sie haben eine Folge von T-Länge mit 512 Werten pro T, also [Batchsize, T, 512]. Beim ersten Zeitstempel T = 1 werden Sie das LSTM sofort mit diesen 512 Werten versorgen, und dies ist den versteckten Einheiten zu verdanken.

Ich füge Ihnen einige Referenzen und Links bei, wenn meine Erklärung nicht sehr klar ist. Q Referenz , S Referenz .