1.Tout d'abord

Bonjour. Cela fait environ trois mois que j'ai commencé à apprendre le machine learning, et il semble que ma compréhension s'est progressivement approfondie. Cette fois, j'aimerais utiliser ce que j'ai appris jusqu'à présent pour prédire la demande d'électricité. Plus précisément, j'aimerais faire des prédictions à l'aide de GRU, qui est un type de modèle d'apprentissage en profondeur capable de gérer des données de séries chronologiques.

2. Environnement de développement

OS : Windows 10 environnement d'exécution python: Google colaboratory

Si vous utilisez Google colaboratory, vous pouvez développer sans créer d'environnement. En outre, le GPU est fourni par Google (avec limite de temps)

3. À propos de GRU

Avec un RNN normal, il y a un problème que le gradient disparaît / explose lors de la manipulation de données de séries chronologiques à long terme, et l'apprentissage ne peut pas être effectué correctement. Par conséquent, dans le LSRM, le concept de cellules et de trois portes (porte d'entrée, porte de sortie et porte d'oubli) est adopté pour maintenir l'état, et c'est un modèle qui permet l'apprentissage des dépendances à long terme. En gros, GRU est un modèle simple de LSTM, et on dit généralement que la quantité de calcul est inférieure à celle de LSTM.

4. Module utilisé

Cette fois, je voudrais faire une prédiction en utilisant le GRU mentionné précédemment.

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. Données utilisées et leur prétraitement

● Données utilisées

Cette fois, j'ai utilisé les données ouvertes de Kaggle (https://www.kaggle.com/manualrg/spanish-electricity-market-demand-gen-price). Les données de la puissance de demande quotidienne sont lues au format de trame de données. Et comme le format d'origine comprend des informations d'heure, il est modifié pour s'afficher à la date. Les données de 2014 à 2017 sont divisées pour la formation et les données pour 2018 sont divisées pour les tests.

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

Si vous tracez les données, vous obtiendrez une forme d'onde comme celle-ci.

● Traitement des données

Ensuite, nous normaliserons chaque ensemble de données en fonction de la distribution dans les données d'entraînement.


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

Ensuite, cette fois, nous utiliserons 20 points de données pour prédire les données une période à l'avance, donc à cette fin, les 20 derniers points (20 points en retard par rapport au point de prédiction) et leurs données d'étiquette ( Nous allons le diviser en (données une période à l'avance).

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)

Enfin, formatez les données à ajouter au modèle GRU.

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. Définition du modèle

Cette fois, nous allons construire un modèle GRU en utilisant la bibliothèque d'apprentissage automatique "Keras". La construction du modèle est la suivante.

#Créer un modèle GRU
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. Formation sur les données et résultats des prévisions

● Apprentissage et prédiction

Vous pouvez entraîner le modèle avec model.fit (). Puisqu'il s'agit d'une époque ici, il est traité de manière itérative 20 fois et l'apprentissage est effectué.

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

Et la prédiction dans le modèle peut être effectuée avec model.predict (). En transmettant les données de test en entrée, la prédiction pour la période suivante est effectuée.

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

● Résultats des prévisions

La perte d'apprentissage a entraîné ce qui suit: Il semble que la valeur de la fonction de perte puisse être maintenue faible. Ensuite, les résultats de la prédiction anticipée à un terme utilisant les données de test sont les suivants. Il semble y avoir un flux irrégulier, mais le résultat a été un grand écart à certains endroits. Vous pouvez obtenir de bons résultats en réinitialisant les hyper paramètres, etc. et en apprenant. Il semble y avoir plusieurs points à améliorer dans le processus de prétraitement.

7. Résumé

Cette fois, nous avons prédit la demande de puissance à l'aide du modèle GRU, qui est une variante du modèle RNN. En conséquence, nous n'avons pas obtenu de bons résultats. À l'avenir, je passerai en revue la méthode de prétraitement des données et reconstruirai le modèle afin d'obtenir une bonne précision.

[PYTHON] Prévision de la demande d'électricité par GRU