Ich entschied mich für RNN für die Analyse von Zeitreihendaten, implementierte es einfach und verwendete es als Zeitreihendaten. Die meisten von ihnen sind die folgenden Imitationen, also bitte mögen Sie sie. Sin Wave Prediction unter Verwendung von RNN in der Deep Learning Library Keras Sinuswellen mit LSTM vorhersagen

Bibliothek

from keras.models import Sequential
from keras.layers.core import Dense, Activation
from keras.layers.recurrent import LSTM
from keras.optimizers import Adam
from keras.callbacks import EarlyStopping
import numpy as np
import matplotlib.pyplot as plt

Um LSTM zu erstellen, importieren Sie dieses Mal LSTM aus wiederkehrenden Frühes Stoppen wird auch importiert, um Ressourcen wie Lernzeit zu sparen.

Daten erstellen

Sinuswellenerzeugung

Zunächst wird eine Sinuswelle erzeugt.

def sin(x, T=100):
    return np.sin(2.0 * np.pi * x / T)

#Fügen Sie den Sinuswellen Rauschen hinzu
def toy_problem(T=100, ampl=0.05):
    x = np.arange(0, 2 * T + 1)
    noise = ampl * np.random.uniform(low=-1.0, high=1.0, size=len(x))
    return sin(x) + noise

f = toy_problem()

In eine Form geformt, um Sin-Wellen durch RNN zu leiten

Wie unten gezeigt, werden Trainingsdaten durch 25 Etikettendaten pro 25 Schritte als Trainingsdaten ausgedrückt.

def make_dataset(low_data, n_prev=100):

    data, target = [], []
    maxlen = 25

    for i in range(len(low_data)-maxlen):
        data.append(low_data[i:i + maxlen])
        target.append(low_data[i + maxlen])

    re_data = np.array(data).reshape(len(data), maxlen, 1)
    re_target = np.array(target).reshape(len(data), 1)

    return re_data, re_target
  

#g ->Trainingsdaten, h->Lernetikett
g, h = make_dataset(f)

Modellgenerierung

Erstellen Sie ein einfaches LSTM-Lernmodell. Das Konzept von LSTM ist wie folgt sehr einfach zu verstehen. [Übersicht über das LSTM-Netzwerk](http://qiita.com/KojiOhki/items/89cd7b69a8a6239d67ca#lstm Network)

#Modellbau

#Anzahl der Schritte einer Trainingsdaten(Diesmal 25)
length_of_sequence = g.shape[1]	
in_out_neurons = 1
n_hidden = 300

model = Sequential()
model.add(LSTM(n_hidden, batch_input_shape=(None, length_of_sequence, in_out_neurons), return_sequences=False))
model.add(Dense(in_out_neurons))
model.add(Activation("linear"))
optimizer = Adam(lr=0.001)
model.compile(loss="mean_squared_error", optimizer=optimizer)

n_hidden: Versteckte Ebenen-> Je höher die Zahl, desto komplexer das Trainingsmodell
batch_input_shape: Geben Sie die Form der Daten an, die in LSTM eingegeben werden sollen (geben Sie [Stapelgröße, Anzahl der Schritte, Anzahl der Feature-Dimensionen] an)
Dicht reguliert nur die Anzahl der Neuronen. Da diesmal der y-Achsenwert der Sinuswelle zum Zeitpunkt t die Ausgabe ist, wird die Anzahl der Knoten auf 1 gesetzt.
Eine lineare Aktivierungsfunktion wird verwendet.
Definiert für die Verwendung der Fehlerfunktion: minimaler quadratischer Fehler, Optimierungsmethode: Adam beim Kompilieren

Lernen

Das Training wird anhand der generierten Trainingsdaten und des definierten Modells durchgeführt. Dieses Mal wurden 10% der Trainingsdaten zur Validierung verwendet und in 100 Epochen trainiert. Durch Definieren von Early_stopping in der ersten Zeile mit Rückrufen wird das Lernen automatisch beendet, wenn festgestellt wird, dass die Änderung des Validierungsfehlerwerts (val_loss) konvergiert hat. Durch Einstellen des Modus auf Auto wird die Konvergenz automatisch beurteilt. Geduld lernt die Epoche für den Wert der Geduld aus dem Urteilswert und beurteilt, dass sie endet, wenn sich nichts ändert. Wenn also Geduld = 0 ist, endet das Lernen in dem Moment, in dem val_loss steigt.

early_stopping = EarlyStopping(monitor='val_loss', mode='auto', patience=20)
model.fit(g, h,
          batch_size=300,
          epochs=100,
          validation_split=0.1,
          callbacks=[early_stopping]
          )

Prognose

Vorhersage mit Trainingsdaten

Sagen Sie die Trainingsdaten voraus und prüfen Sie, ob die Sinuswelle reproduziert werden kann.

#Prognose
predicted = model.predict(g)

Jetzt können wir die Sinuswelle nach t = 25 vorhersagen lassen. Lassen Sie uns tatsächlich planen.

plt.figure()
plt.plot(range(25,len(predicted)+25),predicted, color="r", label="predict_data")
plt.plot(range(0, len(f)), f, color="b", label="row_data")
plt.legend()
plt.show()

Vorhersage Die Sinuswelle kann nahezu ohne Einfluss von Rauschen vorhergesagt werden.

Vorhersage der Zukunft

Unter Verwendung des erzeugten Trainingsmodells werden die Koordinaten der Sinuswelle zum Zeitpunkt nach den Trainingsdaten vorhergesagt.

#Zeitdauer für eine Trainingsdaten-> 25
time_length = future_test.shape[1]
#Variablen, die zukünftige Prognosedaten speichern
future_result = np.empty((1))

#Zukunftsprognose
for step2 in range(400):

    test_data = np.reshape(future_test, (1, time_length, 1))
    batch_predict = model.predict(test_data)

    future_test = np.delete(future_test, 0)
    future_test = np.append(future_test, batch_predict)

    future_result = np.append(future_result, batch_predict)
    

#Plot Sin Wave
plt.figure()
plt.plot(range(25,len(predicted)+25),predicted, color="r", label="predict_data")
plt.plot(range(0, len(f)), f, color="b", label="row_data")
plt.plot(range(0+len(f), len(future_result)+len(f)), future_result, color="g", label="future_predict")
plt.legend()
plt.show()

Die Amplitude ist nach und nach kleiner geworden ... Vielleicht ist die Länge einer Trainingsdaten mit 25 Schritten kurz? ?? Das nächste Mal werde ich versuchen, in etwa 40 Schritten vorherzusagen.

Source Code https://github.com/sasayabaku/Machine-Learning/blob/master/Example_RNN/SineWave_Prediction.ipynb

[PYTHON] Anfänger RNN (LSTM) | Versuchen Sie es mit Keras