1. Vorbereitung von Zeitreihendaten
import numpy as np
# Beispiel-Zeitreihendaten
data = np.arange(100)
# Funktion zum Erstellen von Datenpaaren für die Zeitreihenanalyse
def create_dataset(data, time_step=1):
X, Y = [], []
for i in range(len(data) - time_step - 1):
a = data[i:(i + time_step)]
X.append(a)
Y.append(data[i + time_step])
return np.array(X), np.array(Y)
time_step = 3
X, Y = create_dataset(data, time_step)
print("Eingabedaten (X):", X[:5])
print("Zielwerte (Y):", Y[:5])
Ausgabe:
Eingabedaten (X): [[ 0 1 2]
[ 1 2 3]
[ 2 3 4]
[ 3 4 5]
[ 4 5 6]]
Zielwerte (Y): [3 4 5 6 7]
In diesem Beispiel werden Zeitreihendaten so vorbereitet, dass jedes Datenpaar (X, Y) die letzten time_step Werte als Eingabewerte und den nächsten Wert in der Sequenz als Zielwert enthält.
2. Aufbau von Vorhersagemodellen für Zeitreihen
Für die Vorhersage von Zeitreihen werden häufig neuronale Netzwerke verwendet, insbesondere Recurrent Neural Networks (RNNs). Diese Modelle können die zeitlichen Abhängigkeiten in den Daten erfassen.
Beispiel:
from keras.models import Sequential
from keras.layers import Dense, LSTM
# Neustrukturierung der Eingabedaten für RNNs
X = X.reshape((X.shape[0], X.shape[1], 1))
# Erstellen eines einfachen LSTM-Modells
model = Sequential()
model.add(LSTM(50, return_sequences=True, input_shape=(time_step, 1)))
model.add(LSTM(50, return_sequences=False))
model.add(Dense(1))
# Kompilieren des Modells
model.compile(optimizer='adam', loss='mean_squared_error')
# Training des Modells
model.fit(X, Y, epochs=100, batch_size=1, verbose=2)
# Ausgabe der Modellzusammenfassung
print(model.summary())
Ausgabe:
Epoch 1/100
95/95 - 1s - loss: 0.0410
...
Epoch 100/100
95/95 - 0s - loss: 0.0015
Model: "sequential"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
lstm (LSTM) (None, 3, 50) 10400
_________________________________________________________________
lstm_1 (LSTM) (None, 50) 20200
_________________________________________________________________
dense (Dense) (None, 1) 51
=================================================================
Total params: 30,651
Trainable params: 30,651
Non-trainable params: 0
_________________________________________________________________
In diesem Beispiel erstellen wir ein einfaches LSTM-Modell zur Vorhersage von Zeitreihendaten. Das Modell besteht aus zwei LSTM-Schichten und einer dichten Ausgabeschicht.
3. Verwendung von LSTM und GRU für Zeitreihen
LSTM (Long Short-Term Memory) und GRU (Gated Recurrent Unit) sind spezielle Arten von RNNs, die entwickelt wurden, um das Problem des vanishing gradient zu lösen und langfristige Abhängigkeiten in den Daten zu erfassen.
Beispiel: Verwendung von LSTM
from keras.models import Sequential
from keras.layers import LSTM, Dense
# Erstellen eines LSTM-Modells
model = Sequential()
model.add(LSTM(50, input_shape=(time_step, 1)))
model.add(Dense(1))
# Kompilieren des Modells
model.compile(optimizer='adam', loss='mean_squared_error')
# Training des Modells
model.fit(X, Y, epochs=50, batch_size=1, verbose=2)
# Ausgabe der Modellzusammenfassung
print(model.summary())
Ausgabe:
Epoch 1/50
95/95 - 1s - loss: 0.0385
...
Epoch 50/50
95/95 - 0s - loss: 0.0021
Model: "sequential_1"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
lstm_2 (LSTM) (None, 50) 10400
_________________________________________________________________
dense_1 (Dense) (None, 1) 51
=================================================================
Total params: 10,451
Trainable params: 10,451
Non-trainable params: 0
_________________________________________________________________
Beispiel: Verwendung von GRU:
from keras.models import Sequential
from keras.layers import GRU, Dense
# Erstellen eines GRU-Modells
model = Sequential()
model.add(GRU(50, input_shape=(time_step, 1)))
model.add(Dense(1))
# Kompilieren des Modells
model.compile(optimizer='adam', loss='mean_squared_error')
# Training des Modells
model.fit(X, Y, epochs=50, batch_size=1, verbose=2)
# Ausgabe der Modellzusammenfassung
print(model.summary())
Ausgabe:
Epoch 1/50
95/95 - 1s - loss: 0.0385
...
Epoch 50/50
95/95 - 0s - loss: 0.0020
Model: "sequential_2"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
gru (GRU) (None, 50) 7950
_________________________________________________________________
dense_2 (Dense) (None, 1) 51
=================================================================
Total params: 8,001
Trainable params: 8,001
Non-trainable params: 0
_________________________________________________________________
In diesen Beispielen verwenden wir LSTM- und GRU-Schichten, um Zeitreihenvorhersagemodelle zu erstellen. Beide Modelle bestehen aus einer einzigen rekurrenten Schicht (LSTM oder GRU) und einer dichten Ausgabeschicht.
Diese detaillierten Erklärungen und Beispiele sollten Ihnen helfen, die verschiedenen Aspekte der Zeitreihenanalyse mit Keras zu verstehen und in Ihren eigenen Projekten anzuwenden.
