Keras LSTM mit 1D-Zeitreihen

Ich lerne, wie man Keras verwendet, und ich habe mit meinem beschrifteten Datensatz anhand der Beispiele in Chollets Deep Learning für Python vernünftigen Erfolg gehabt . Der Datensatz ist ~ 1000 Zeitreihen mit einer Länge von 3125 mit 3 möglichen Klassen.

Ich möchte über die grundlegenden dichten Schichten hinausgehen, die mir eine Vorhersagerate von etwa 70% geben, und das Buch geht weiter auf LSTM- und RNN-Schichten ein.

Alle Beispiele scheinen Datensätze mit mehreren Funktionen für jede Zeitreihe zu verwenden, und ich habe Schwierigkeiten, herauszufinden, wie ich meine Daten als Ergebnis implementieren kann.

Wenn ich zum Beispiel 1000x3125-Zeitreihen habe, wie kann ich diese in so etwas wie die SimpleRNN- oder LSTM-Ebene einspeisen? Fehlt mir ein grundlegendes Wissen darüber, was diese Schichten tun?

Aktueller Code:

import pandas as pd
import numpy as np
import os
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM, Dropout, SimpleRNN, Embedding, Reshape
from keras.utils import to_categorical
from keras import regularizers
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt

def readData():
    # Get labels from the labels.txt file
    labels = pd.read_csv('labels.txt', header = None)
    labels = labels.values
    labels = labels-1
    print('One Hot Encoding Data...')
    labels = to_categorical(labels)

    data = pd.read_csv('ts.txt', header = None)

    return data, labels

print('Reading data...')
data, labels = readData()

print('Splitting Data')
data_train, data_test, labels_train, labels_test = train_test_split(data, labels)

print('Building Model...')
#Create model
model = Sequential()
## LSTM / RNN goes here ##
model.add(Dense(3, activation='softmax'))

model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

print('Training NN...')
history = model.fit(data_train, labels_train, epochs=1000, batch_size=50,
    validation_split=0.25,verbose=2)

results = model.evaluate(data_test, labels_test)

predictions = model.predict(data_test)

print(predictions[0].shape)
print(np.sum(predictions[0]))
print(np.argmax(predictions[0]))

print(results)

acc = history.history['acc']
val_acc = history.history['val_acc']
epochs = range(1, len(acc) + 1)

plt.plot(epochs, acc, 'bo', label='Training acc')
plt.plot(epochs, val_acc, 'b', label='Validation acc')
plt.title('Training and Validation Accuracy')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.show()

LSTM-Schichten erfordern Daten mit einer anderen Form.

Aus Ihrer Beschreibung geht hervor, dass der Startdatensatz 3125 Zeilen und 1000 Spalten enthält, wobei jede Zeile einen Zeitschritt darstellt. Die Zielvariable sollte dann 3125 Zeilen und 1 Spalte haben, wobei jeder Wert einer von drei möglichen Werten sein kann. Es hört sich also so an, als ob Sie ein Klassifizierungsproblem haben. Um dies im Code zu überprüfen, würde ich tun:

>>> X.shape
(3125, 1000)

>>> y.shape
(1000,)

Die LSTM-Klasse erfordert, dass jede einzelne Stichprobe aus einem Zeitblock besteht. Angenommen, Sie möchten einen Block mit 100 Zeitschritten haben. Dies bedeutet, dass X[0:100]es sich um eine einzelne Eingabestichprobe handelt, die der Zielvariablen bei entspricht y[100]. Dies bedeutet, dass Ihre Fenstergröße (auch bekannt als Anzahl der Zeitschritte oder Anzahl der Verzögerungen) gleich 100 ist. Wie oben angegeben, haben Sie also 3125 Beispiele N = 3125. Um den ersten Block zu bilden, müssen wir leider die ersten 100 Stichproben von verwerfen y, da wir aus den verfügbaren Daten keinen ganzen Block von 100 bilden können (wir würden am Ende vorher die Datenpunkte benötigen X[0]).

In Anbetracht dessen erfordert ein LSTM, dass Sie Formstapel liefern (N - window_size, window_size, num_features), was sich in (3125 - 100, 100, 1000)== übersetzt (3025, 100, 1000).

Das Erstellen dieser Zeitblöcke ist ein bisschen mühsam, aber erstellen Sie einmal eine gute Funktion und speichern Sie sie dann :)

Es gibt noch mehr zu tun, vielleicht sehen Sie sich hier die ausführlicheren Beispiele meiner Erklärung an ... oder lesen Sie die LSTM-Dokumentation (oder noch besser den Quellcode! ).

Das endgültige Modell wäre dann einfach genug (basierend auf Ihrem Code):

#Create model
model = Sequential()
model.add(LSTM(units=32, activation='relu',
               input_shape=(100, 1000))    # the batch size is neglected!
model.add(Dense(3, activation='softmax'))

model.compile(loss='categorical_crossentropy', optimizer='adam',
              metrics=['accuracy'])

Schauen Sie sich die Dokumentation zur Eingabeform für das SequentialModell an . Grundsätzlich heißt es, dass wir die Anzahl der darin enthaltenen Chargen nicht angeben müssen input_shape. Dies kann z. B. erfolgen batch_size=50, wenn Sie eine feste Nummer benötigen.

Ich weiß, dass das input_shapeArgument nicht in der Dokumentation für enthalten ist LSTM, aber die Klasse selbst erbt von RNN, was wiederum von erbt Layer- damit sie die von Ihnen angegebenen Informationen verwenden kann.

Ein letzter Tipp: Wenn Sie mehrere LSTM-Ebenen hinzufügen möchten ("stapeln"), müssen Sie allen außer dem letzten ein weiteres Argument hinzufügen LSTM, nämlich das return_sequences=True.