Zeitreihen - LSTM-Modell

Jetzt sind wir mit der statistischen Modellierung von Zeitreihen vertraut, aber maschinelles Lernen ist derzeit der letzte Schrei. Daher ist es wichtig, auch mit einigen Modellen des maschinellen Lernens vertraut zu sein. Wir beginnen mit dem beliebtesten Modell im Zeitreihenbereich - dem Langzeit-Kurzzeitgedächtnismodell.

LSTM ist eine Klasse von wiederkehrenden neuronalen Netzen. Bevor wir zu LSTM springen können, ist es wichtig, neuronale Netze und wiederkehrende neuronale Netze zu verstehen.

Neuronale Netze

Ein künstliches neuronales Netzwerk ist eine Schichtstruktur verbundener Neuronen, die von biologischen neuronalen Netzwerken inspiriert ist. Es ist nicht ein Algorithmus, sondern eine Kombination verschiedener Algorithmen, die es uns ermöglicht, komplexe Operationen an Daten durchzuführen.

Wiederkehrende neuronale Netze

Es ist eine Klasse neuronaler Netze, die auf zeitliche Daten zugeschnitten sind. Die Neuronen von RNN haben einen Zellzustand / Speicher, und die Eingabe wird gemäß diesem internen Zustand verarbeitet, der mit Hilfe von Schleifen im neuronalen Netzwerk erreicht wird. Es gibt wiederkehrende Module von 'tanh'-Schichten in RNNs, mit denen sie Informationen speichern können. Allerdings nicht lange, weshalb wir LSTM-Modelle brauchen.

LSTM

Es ist eine spezielle Art von wiederkehrendem neuronalen Netzwerk, das in der Lage ist, langfristige Abhängigkeiten in Daten zu lernen. Dies wird erreicht, weil das wiederkehrende Modul des Modells eine Kombination von vier Schichten aufweist, die miteinander interagieren.

Das obige Bild zeigt vier neuronale Netzwerkschichten in gelben Kästchen, punktweise Operatoren in grünen Kreisen, Eingaben in gelben Kreisen und Zellzustände in blauen Kreisen. Ein LSTM-Modul hat einen Zellenzustand und drei Gatter, die es ihnen ermöglichen, Informationen von jeder der Einheiten selektiv zu lernen, zu verlernen oder zu speichern. Der Zellzustand in LSTM hilft, dass die Informationen durch die Einheiten fließen, ohne verändert zu werden, indem nur wenige lineare Wechselwirkungen zugelassen werden. Jede Einheit verfügt über einen Eingang, einen Ausgang und ein Vergessensgatter, mit dem die Informationen zum Zellenzustand hinzugefügt oder daraus entfernt werden können. Das Vergessensgatter entscheidet, welche Informationen aus dem vorherigen Zellenzustand vergessen werden sollen, für die es eine Sigmoidfunktion verwendet. Das Eingangsgatter steuert den Informationsfluss zum aktuellen Zellenzustand unter Verwendung einer punktweisen Multiplikationsoperation von 'sigmoid' bzw. 'tanh'. Schließlich entscheidet das Ausgangsgatter, welche Informationen an den nächsten verborgenen Zustand weitergegeben werden sollen

Nachdem wir die interne Funktionsweise des LSTM-Modells verstanden haben, lassen Sie es uns implementieren. Um die Implementierung von LSTM zu verstehen, beginnen wir mit einem einfachen Beispiel - einer geraden Linie. Lassen Sie uns sehen, ob LSTM die Beziehung einer geraden Linie lernen und vorhersagen kann.

Lassen Sie uns zunächst den Datensatz erstellen, der eine gerade Linie darstellt.

In [402]:

x = numpy.arange (1,500,1)
y = 0.4 * x + 30
plt.plot(x,y)

Out [402]:

[<matplotlib.lines.Line2D at 0x1eab9d3ee10>]

In [403]:

trainx, testx = x[0:int(0.8*(len(x)))], x[int(0.8*(len(x))):]
trainy, testy = y[0:int(0.8*(len(y)))], y[int(0.8*(len(y))):]
train = numpy.array(list(zip(trainx,trainy)))
test = numpy.array(list(zip(trainx,trainy)))

Nachdem die Daten erstellt und in Zug und Test aufgeteilt wurden. Konvertieren wir die Zeitreihendaten in die Form von überwachten Lerndaten gemäß dem Wert der Rückblickperiode, der im Wesentlichen der Anzahl der Verzögerungen entspricht, die den Wert zum Zeitpunkt 't' vorhersagen.

Also eine Zeitreihe wie diese -

time variable_x
t1  x1
t2  x2
 :   :
 :   :
T   xT

Wenn der Rückblickzeitraum 1 ist, wird in - konvertiert

x1   x2
x2   x3
 :    :
 :    :
xT-1 xT

In [404]:

def create_dataset(n_X, look_back):
   dataX, dataY = [], []
   for i in range(len(n_X)-look_back):
      a = n_X[i:(i+look_back), ]
      dataX.append(a)
      dataY.append(n_X[i + look_back, ])
   return numpy.array(dataX), numpy.array(dataY)

In [405]:

look_back = 1
trainx,trainy = create_dataset(train, look_back)
testx,testy = create_dataset(test, look_back)

trainx = numpy.reshape(trainx, (trainx.shape[0], 1, 2))
testx = numpy.reshape(testx, (testx.shape[0], 1, 2))

Jetzt werden wir unser Modell trainieren.

Kleine Stapel von Trainingsdaten werden dem Netzwerk angezeigt. Ein Durchlauf, bei dem dem Modell die gesamten Trainingsdaten in Stapeln angezeigt werden und der Fehler berechnet wird, wird als Epoche bezeichnet. Die Epochen sollen bis zu dem Zeitpunkt ausgeführt werden, an dem sich der Fehler verringert.

Im [ ]:

from keras.models import Sequential
from keras.layers import LSTM, Dense

model = Sequential()
model.add(LSTM(256, return_sequences = True, input_shape = (trainx.shape[1], 2)))
model.add(LSTM(128,input_shape = (trainx.shape[1], 2)))
model.add(Dense(2))
model.compile(loss = 'mean_squared_error', optimizer = 'adam')
model.fit(trainx, trainy, epochs = 2000, batch_size = 10, verbose = 2, shuffle = False)
model.save_weights('LSTMBasic1.h5')

In [407]:

model.load_weights('LSTMBasic1.h5')
predict = model.predict(testx)

Nun wollen wir sehen, wie unsere Vorhersagen aussehen.

In [408]:

plt.plot(testx.reshape(398,2)[:,0:1], testx.reshape(398,2)[:,1:2])
plt.plot(predict[:,0:1], predict[:,1:2])

Out [408]:

[<matplotlib.lines.Line2D at 0x1eac792f048>]

Nun sollten wir versuchen, eine Sinus- oder Cosinuswelle auf ähnliche Weise zu modellieren. Sie können den unten angegebenen Code ausführen und mit den Modellparametern spielen, um zu sehen, wie sich die Ergebnisse ändern.

In [409]:

x = numpy.arange (1,500,1)
y = numpy.sin(x)
plt.plot(x,y)

Out [409]:

[<matplotlib.lines.Line2D at 0x1eac7a0b3c8>]

In [410]:

trainx, testx = x[0:int(0.8*(len(x)))], x[int(0.8*(len(x))):]
trainy, testy = y[0:int(0.8*(len(y)))], y[int(0.8*(len(y))):]
train = numpy.array(list(zip(trainx,trainy)))
test = numpy.array(list(zip(trainx,trainy)))

In [411]:

look_back = 1
trainx,trainy = create_dataset(train, look_back)
testx,testy = create_dataset(test, look_back)
trainx = numpy.reshape(trainx, (trainx.shape[0], 1, 2))
testx = numpy.reshape(testx, (testx.shape[0], 1, 2))

Im [ ]:

model = Sequential()
model.add(LSTM(512, return_sequences = True, input_shape = (trainx.shape[1], 2)))
model.add(LSTM(256,input_shape = (trainx.shape[1], 2)))
model.add(Dense(2))
model.compile(loss = 'mean_squared_error', optimizer = 'adam')
model.fit(trainx, trainy, epochs = 2000, batch_size = 10, verbose = 2, shuffle = False)
model.save_weights('LSTMBasic2.h5')

In [413]:

model.load_weights('LSTMBasic2.h5')
predict = model.predict(testx)

In [415]:

plt.plot(trainx.reshape(398,2)[:,0:1], trainx.reshape(398,2)[:,1:2])
plt.plot(predict[:,0:1], predict[:,1:2])

Out [415]:

[<matplotlib.lines.Line2D at 0x1eac7a1f550>]

Jetzt können Sie mit jedem Datensatz fortfahren.