Débutant RNN (LSTM) | Essayer avec Keras

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.

rnn_label.png

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)

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

predict_data.png

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

future_predict.png

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

Recommended Posts

Débutant RNN (LSTM) | Essayer avec Keras
LSTM multivarié avec Keras
Essayez TensorFlow MNIST avec RNN
Implémenter Keras LSTM feed forward avec numpy
Essayez d'implémenter XOR avec l'API fonctionnelle Keras
Essayez TensorFlow RNN avec un modèle de base
Prédire FX avec LSTM à l'aide de Keras + Tensorflow Partie 2 (Calculer avec GPU)
Essayez de résoudre le problème du fizzbuzz avec Keras
Essayez de prédire FX avec LSTM en utilisant Keras + Tensorflow Partie 3 (essayez d'atteindre tous les paramètres)
Reconnaissance d'image avec keras
Apprenez Zundokokiyoshi en utilisant LSTM
Créez un tweet idole avec Keras LSTM (génération de phrases)
Essayez MNIST avec VAT (Virtual Adversarial Training) avec Keras
Tutoriel CIFAR-10 avec Keras
Essayez SNN avec BindsNET
Essayez la régression avec TensorFlow
Implémenter LSTM AutoEncoder avec Keras
Essayez de défier le sol par récursif
Essayez l'optimisation des fonctions avec Optuna
Essayez l'apprentissage en profondeur avec TensorFlow
Essayez d'utiliser PythonTex avec Texpad.
Installation de Keras (utilisée par Anaconda)
Essayez la détection des bords avec OpenCV
Essayez d'implémenter RBM avec chainer.
Analyse de régression multiple avec Keras
Essayez Google Mock avec C
Essayez d'utiliser matplotlib avec PyCharm
Essayez de programmer avec un shell!
Essayez la programmation GUI avec Hy
Essayez Auto Encoder avec Pytorch
Essayez la sortie Python avec Haxe 3.2
Essayez l'opération matricielle avec NumPy
Notes AutoEncodder avec Keras
Implémentation de word2vec avec Theano + Keras
Essayez d'implémenter XOR avec PyTorch
Essayez d'exécuter CNN avec ChainerRL
Génération de phrases avec GRU (keras)
Essayez différentes choses avec PhantomJS
Réglage des paramètres Keras avec Keras Tuner
Essayez le Deep Learning avec FPGA
Essayez d'exécuter Python avec Try Jupyter
Essayez d'implémenter le parfum avec Go
Implémentation d'un GAN efficace avec keras
Essayez Selenium Grid avec Docker
Essayez la reconnaissance faciale avec Python
Essayez OpenCV avec Google Colaboratory
Web scraping débutant avec python
Essayez le machine learning à la légère avec Kaggle
Essayez de créer Jupyter Hub avec Docker
Essayez d'utiliser le folium avec anaconda
Reconnaissance d'image avec Keras + OpenCV
[Version améliorée] Essayez MNIST avec VAT (Virtual Adversarial Training) sur Keras