J'ai décidé d'utiliser RNN pour l'analyse des données chronologiques, je l'ai implémenté simplement et je l'ai utilisé comme données chronologiques. La plupart d'entre eux sont les imitations suivantes, alors veuillez les aimer. Prédiction de l'onde sinusoïdale utilisant RNN dans la bibliothèque d'apprentissage en profondeur Keras Prédire les ondes sinusoïdales avec LSTM

Bibliothèque

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

Cette fois, pour construire LSTM, importez LSTM à partir de L'arrêt anticipé est également importé pour économiser des ressources telles que le temps d'apprentissage.

Créer des données

Génération d'onde de péché

Tout d'abord, une onde de péché est générée.

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

#Ajouter du bruit aux ondes de péché
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()

Moulé dans une forme pour faire passer les ondes Sin à travers RNN

Comme indiqué ci-dessous, une donnée d'entraînement est exprimée par une donnée d'étiquette toutes les 25 étapes en tant que données d'entraînement.

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 ->Données d'entraînement, h->Étiquette d'apprentissage
g, h = make_dataset(f)

Génération de modèle

Créez un modèle d'apprentissage LSTM simple. Le concept de LSTM est très facile à comprendre comme suit. [Présentation du réseau LSTM](http://qiita.com/KojiOhki/items/89cd7b69a8a6239d67ca#lstm Network)

#Construction de modèles

#Nombre d'étapes d'une donnée d'entraînement(Cette fois 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: Calques cachés-> Plus le nombre est élevé, plus le modèle d'apprentissage est complexe
batch_input_shape: Spécifiez la forme des données à entrer dans LSTM (spécifiez [taille du lot, nombre d'étapes, nombre de dimensions de la fonction])
Dense ne régule que le nombre de neurones. Cette fois, puisque la valeur de l'axe y de l'onde sinus au temps t est la sortie, le nombre de nœuds est mis à 1.
Une fonction d'activation linéaire est utilisée.
Défini pour utiliser la fonction d'erreur: erreur quadratique minimale, méthode d'optimisation: Adam en compilation

Apprentissage

L'entraînement est effectué à l'aide des données d'entraînement générées et du modèle défini. Cette fois, 10% des données de formation ont été utilisées pour la validation et formées à 100 époques. En définissant early_stopping sur la première ligne avec des rappels, l'apprentissage est automatiquement terminé lorsqu'il est déterminé que le changement de la valeur d'erreur de validation (val_loss) a convergé. En réglant le mode sur auto, la convergence est automatiquement déterminée. la patience apprend l'époque pour la valeur de la patience à partir de la valeur de jugement, et juge qu'elle se termine s'il n'y a pas de changement. Par conséquent, si patience = 0, l'apprentissage se terminera au moment où val_loss augmente.

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]
          )

Prévoir

Prédiction avec données d'entraînement

Prédisez les données d'entraînement et vérifiez si l'onde sinueuse peut être reproduite.

#Prévoir
predicted = model.predict(g)

Nous pouvons maintenant faire prédire l'onde de péché après t = 25. Tracons réellement.

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()

Prédiction L'onde sinueuse peut être prédite sans presque aucune influence du bruit.

Prédiction du futur

En utilisant le modèle d'apprentissage généré, les coordonnées de l'onde sinusoïdale au moment après les données d'entraînement sont prédites.

#Durée d'une donnée d'entraînement-> 25
time_length = future_test.shape[1]
#Variables qui stockent les futures données de prévision
future_result = np.empty((1))

#Prévisions futures
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)
    

#Tracer l'onde de péché
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()

L'amplitude est devenue peu à peu plus petite ... Peut-être que la longueur d'une donnée d'entraînement est courte à 25 étapes? ?? La prochaine fois, j'essaierai de prédire en 40 étapes environ.

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

[PYTHON] Débutant RNN (LSTM) | Essayer avec Keras