1. Zuallererst

Hallo. Es ist ungefähr drei Monate her, seit ich angefangen habe, maschinelles Lernen zu lernen, und es scheint, dass sich mein Verständnis allmählich vertieft hat. Dieses Mal möchte ich das bisher Gelernte nutzen, um den Strombedarf vorherzusagen. Insbesondere möchte ich Vorhersagen mit GRU treffen, einer Art Deep-Learning-Modell, das Zeitreihendaten verarbeiten kann.

2. Entwicklungsumgebung

OS : Windows 10 Python-Ausführungsumgebung: Google Colaboratory

Wenn Sie Google Colaboratory verwenden, können Sie entwickeln, ohne eine Umgebung zu erstellen. Die GPU wird auch von Google bereitgestellt (mit zeitlicher Begrenzung).

3. Über GRU

Bei einem normalen RNN besteht das Problem, dass der Gradient beim Umgang mit Langzeitzeitreihendaten verschwindet / explodiert und das Lernen nicht gut durchgeführt werden kann. Daher wird in LSRM das Konzept von Zellen und drei Gattern (Eingangsgatter, Ausgangsgatter und Vergessenheitsgatter) übernommen, um den Zustand aufrechtzuerhalten, und es ist ein Modell, das langfristiges Abhängigkeitslernen ermöglicht. Grob gesagt ist GRU ein einfaches Modell von LSTM, und es wird allgemein gesagt, dass der Rechenaufwand geringer ist als der von LSTM.

4. Modul verwendet

Dieses Mal möchte ich eine Vorhersage unter Verwendung der zuvor erwähnten GRU machen.

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import math
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Activation
from keras.layers import GRU
from keras.layers import Dropout
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error

5. Verwendete Daten und deren Vorverarbeitung

● Verwendete Daten

Dieses Mal habe ich die offenen Daten von Kaggle verwendet (https://www.kaggle.com/manualrg/spanish-electricity-market-demand-gen-price). Die Daten der täglichen Bedarfsleistung werden im Datenrahmenformat gelesen. Und da das ursprüngliche Format Zeitinformationen enthält, wird es so geändert, dass es auf dem neuesten Stand ist. Die Daten von 2014 bis 2017 werden für Schulungen und die Daten für 2018 für Tests aufgeteilt.

data = pd.read_csv("/content/drive/My Drive/data/spain_energy_market.csv", sep=",", parse_dates=["datetime"])
data = data[data["name"]=="Demanda programada PBF total"]#.set_index("datetime")
data["date"] = data["datetime"].dt.date
data.set_index("date", inplace=True)
data = data[["value"]]
data = data.asfreq("D")
data = data.rename(columns={"value": "energy"})
train_series = data.loc["2014":"2017"].values
test_series  = data.loc["2018"].values

Wenn Sie die Daten zeichnen, erhalten Sie eine solche Wellenform.

● Datenverarbeitung

Als nächstes normalisieren wir jeden Datensatz basierend auf der Verteilung in den Trainingsdaten.


scaler = MinMaxScaler(feature_range=(0, 1))
scaler_train = scaler.fit(train_series)
train = scaler_train.transform(train_series)
test = scaler_train.transform(test_series)

Als nächstes werden wir dieses Mal 20 Datenpunkte verwenden, um die Daten in einem Zeitraum vorherzusagen, also zu diesem Zweck die letzten 20 Punkte (20 Punkte hinter dem Vorhersagepunkt) und ihre Etikettendaten ( Wir werden es in (Daten eine Periode vor) aufteilen.

def create_dataset(dataset, look_back):
    data_X, data_Y = [], []
    for i in range(look_back, len(dataset)):
        data_X.append(dataset[i-look_back:i, 0])
        data_Y.append(dataset[i, 0])
    return np.array(data_X), np.array(data_Y)

Formatieren Sie abschließend die Daten, die dem GRU-Modell hinzugefügt werden sollen.

train_X = train_X.reshape(train_X.shape[0], train_X.shape[1], 1)
test_X = test_X.reshape(test_X.shape[0], test_X.shape[1], 1)

6. Modelldefinition

Dieses Mal werden wir ein GRU-Modell unter Verwendung der maschinellen Lernbibliothek "Keras" erstellen. Der Modellbau ist wie folgt.

#Erstellen eines GRU-Modells
model = Sequential()
model.add(GRU(40, return_sequences=False, batch_input_shape=(None, look_back, 1)))
model.add(Dropout(0.25))
model.add(Dense(1))
model.add(Activation("linear"))
model.compile(loss='mean_squared_error', optimizer='adam')

7. Daten Trainings- und Vorhersageergebnisse

● Lernen und Vorhersagen

Sie können das Modell mit model.fit () trainieren. Da es sich hier um eine Epoche handelt, wird es 20 Mal iterativ verarbeitet und es wird gelernt.

history = model.fit(train_X, train_Y, epochs=20, batch_size=1, verbose=1)

Die Vorhersage im Modell kann mit model.predict () erfolgen. Durch Übergeben der Testdaten als Eingabe wird die Vorhersage einer vorausgehenden Periode getroffen.

train_predict = model.predict(train_X)
test_predict = model.predict(test_X)

● Vorhersageergebnisse

Der Lernverlust führte zu folgenden Ergebnissen: Es scheint, dass der Wert der Verlustfunktion klein gehalten werden könnte. Als nächstes sind die Ergebnisse der Ein-Term-Voraussage unter Verwendung der Testdaten wie folgt. Es scheint einen rauen Fluss zu geben, aber das Ergebnis war an einigen Stellen eine große Abweichung. Sie können gute Ergebnisse erzielen, indem Sie die Hyperparameter usw. zurücksetzen und lernen. Es schien verschiedene Punkte zu geben, die im Vorbehandlungsprozess verbessert werden mussten.

7. Zusammenfassung

Dieses Mal haben wir den Strombedarf mithilfe des GRU-Modells vorhergesagt, das eine Variante des RNN-Modells ist. Infolgedessen wurden keine guten Ergebnisse erhalten. In Zukunft werde ich die Datenvorverarbeitungsmethode überprüfen und das Modell rekonstruieren, damit eine gute Genauigkeit erzielt werden kann.

[PYTHON] Strombedarfsprognose der GRU