Keras LSTM avec série temporelle 1D

J'apprends à utiliser Keras et j'ai eu un succès raisonnable avec mon ensemble de données étiqueté en utilisant les exemples de Deep Learning pour Python de Chollet . L'ensemble de données est ~ 1000 séries temporelles de longueur 3125 avec 3 classes potentielles.

Je voudrais aller au-delà des couches denses de base qui me donnent un taux de prédiction d'environ 70% et le livre continue pour discuter des couches LSTM et RNN.

Tous les exemples semblent utiliser des ensembles de données avec plusieurs fonctionnalités pour chaque série temporelle et j'ai du mal à trouver comment implémenter mes données en conséquence.

Si, par exemple, j'ai des séries temporelles de 1 000 x 3 125, comment puis-je les alimenter dans quelque chose comme la couche SimpleRNN ou LSTM? Me manque-t-il une connaissance fondamentale de ce que font ces couches?

Code actuel:

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

Les couches LSTM nécessitent des données de forme différente.

D'après votre description, je comprends que l'ensemble de données de départ comporte 3125 lignes et 1000 colonnes, où chaque ligne correspond à un pas de temps. La variable cible doit alors avoir 3125 lignes et 1 colonne, chaque valeur pouvant être l'une des trois valeurs possibles. Il semble donc que vous ayez un problème de classification. Pour vérifier cela dans le code, je ferais:

>>> X.shape
(3125, 1000)

>>> y.shape
(1000,)

La classe LSTM exige que chaque échantillon unique soit constitué d'un «bloc» de temps. Disons que vous voulez avoir un bloc de 100 pas de temps. Cela signifie qu'il X[0:100]s'agit d'un échantillon d'entrée unique, qui correspond à la variable cible à y[100]. cela signifie que la taille de votre fenêtre (c'est-à-dire le nombre de pas de temps ou le nombre de retards) est égale à 100. Comme indiqué ci-dessus, vous avez donc 3125 échantillons N = 3125. Pour former le premier bloc, nous devons malheureusement jeter les 100 premiers échantillons y, car nous ne pouvons pas former un bloc entier de 100 à partir des données disponibles (nous finirions par avoir besoin des points de données avant X[0]).

Compte tenu de tout cela, un LSTM vous oblige à fournir des lots de formes (N - window_size, window_size, num_features), ce qui se traduit par (3125 - 100, 100, 1000)== (3025, 100, 1000).

La création de ces blocs de temps est un peu compliquée, mais créez une bonne fonction une fois, puis enregistrez-la :)

Il y a plus de travail à faire, peut-être regardez des exemples plus approfondis de mon explication ci-dessus ici ... ou lisez la documentation LSTM , (ou mieux encore, le code source! ).

Le modèle final serait alors assez simple (basé sur votre 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'])

Jetez un œil à la documentation concernant la forme d'entrée du Sequentialmodèle . Il dit essentiellement que nous n'avons pas besoin de spécifier le nombre de lots à l'intérieur input_shape. Cela peut être fait avec, par exemple batch_size=50, si vous souhaitez que ce soit un nombre fixe.

Je sais que l' input_shapeargument n'est pas dans la documentation de LSTM, mais la classe elle-même hérite de RNN, qui à son tour hérite de Layer- elle pourra donc utiliser les informations que vous fournissez.

Un dernier conseil: si vous prévoyez d'ajouter plusieurs couches LSTM (en les «empilant»), vous devrez ajouter un argument de plus à tous sauf le dernier LSTM , à savoir le return_sequences=True.