Keras LSTM z szeregami czasowymi 1D

Uczę się, jak korzystać z Keras i osiągnąłem znaczny sukces z moim oznaczonym zestawem danych, korzystając z przykładów z głębokiego uczenia się dla Pythona przez Cholleta . Zestaw danych to ~ 1000 szeregów czasowych o długości 3125 z 3 potencjalnymi klasami.

Chciałbym wyjść poza podstawowe warstwy Dense, które dają mi około 70% predykcji, a książka omawia warstwy LSTM i RNN.

Wydaje się, że wszystkie przykłady wykorzystują zestawy danych z wieloma funkcjami dla każdego szeregu czasowego i staram się wypracować, w jaki sposób zaimplementować moje dane.

Jeśli na przykład mam szereg czasowy 1000x3125, w jaki sposób mogę wprowadzić to do czegoś takiego jak warstwa SimpleRNN lub LSTM? Czy brakuje mi podstawowej wiedzy na temat tego, co robią te warstwy?

Aktualny kod:

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()

Warstwy LSTM wymagają danych o innym kształcie.

Z twojego opisu rozumiem, że początkowy zestaw danych ma 3125 wierszy i 1000 kolumn, przy czym każdy wiersz ma jeden krok. Zmienna docelowa powinna wówczas mieć 3125 wierszy i 1 kolumnę, gdzie każda wartość może być jedną z trzech możliwych wartości. Wygląda na to, że masz problem z klasyfikacją. Aby to sprawdzić w kodzie, zrobiłbym:

>>> X.shape
(3125, 1000)

>>> y.shape
(1000,)

Klasa LSTM wymaga, aby każda pojedyncza próbka składała się z „bloku” czasu. Powiedzmy, że chcesz mieć blok 100 kroków czasowych. Oznacza to, że X[0:100]jest to pojedyncza próbka wejściowa, która odpowiada zmiennej docelowej o wartości y[100]. oznacza to, że rozmiar twojego okna (czyli liczba kroków czasowych lub liczba opóźnień) jest równa 100. Jak wspomniano powyżej, masz 3125 próbek, więc N = 3125. Aby utworzyć pierwszy blok, musimy niestety odrzucić pierwsze 100 próbek y, ponieważ nie możemy utworzyć całego bloku 100 z dostępnych danych (wcześniej potrzebowalibyśmy punktów danych X[0]).

Biorąc to wszystko pod uwagę, LSTM wymaga dostarczenia partii kształtu (N - window_size, window_size, num_features), co przekłada się na (3125 - 100, 100, 1000)== (3025, 100, 1000).

Tworzenie tych bloków czasowych jest trochę kłopotliwe, ale stwórz dobrą funkcję raz, a następnie zapisz ją :)

Jest więcej do zrobienia, może wyglądać na bardziej w przykładach głębokość mojego wyjaśnienia powyżej tutaj ... albo mieć odczytu z dokumentacją LSTM (lub jeszcze lepiej, kod źródłowy! ).

Ostateczny model byłby wtedy dość prosty (na podstawie twojego kodu):

#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'])

Zajrzyj do dokumentacji dotyczącej kształtu wejściowego dla Sequentialmodelu . Mówi w zasadzie, że nie musimy określać liczby partii w ramach input_shape. Można tego dokonać np. batch_size=50Jeśli potrzebujesz, aby był to stały numer.

Wiem, że input_shapeargumentu nie ma w dokumentacji LSTM, ale sama klasa dziedziczy po nim RNN, co z kolei dziedziczy po Layer- więc będzie mógł użyć podanych informacji.

Ostatnia wskazówka: jeśli planujesz dodać kilka warstw LSTM („układając je” w stosy), musisz dodać jeszcze jeden argument do wszystkich oprócz ostatniej LSTM , a mianowicie return_sequences=True.