comment utiliser le modèle Keras pour prévoir des dates ou des événements futurs?
Voici mon code pour former le modèle complet et le sauver.:
num_units = 2
activation_function = 'sigmoid'
optimizer = 'adam'
loss_function = 'mean_squared_error'
batch_size = 10
num_epochs = 100
# Initialize the RNN
regressor = Sequential()
# Adding the input layer and the LSTM layer
regressor.add(LSTM(units = num_units, activation = activation_function, input_shape=(None, 1)))
# Adding the output layer
regressor.add(Dense(units = 1))
# Compiling the RNN
regressor.compile(optimizer = optimizer, loss = loss_function)
# Using the training set to train the model
regressor.fit(x_train, y_train, batch_size = batch_size, epochs = num_epochs)
regressor.save('model.h5')
après que j'ai vu que la plupart du temps les gens notre suggérant l'ensemble de données de test pour vérifier la prédiction que j'ai essayé aussi bien et obtenu un bon résultat.
Mais le problème est dans l'utilisation du modèle que j'ai créé. Je veux avoir une prévision pour les 30 prochains jours ou chaque minute que ce soit. Maintenant j'ai le modèle formé mais je suis ne pas obtenir ce que je peux faire ou quel code dois-je utiliser pour utiliser le modèle et prévoir les prix pour les 30 prochains jours ou une minute.
s'il vous plaît, suggérez-moi la sortie. Je suis coincé à ce problème depuis une semaine et pas en mesure de faire toute les tentatives réussies.
voici le lien du dépôt où l'on peut trouver le code exécutable complet, le modèle et l'ensemble de données.: Mon lien référentiel
1 réponses
Eh bien, vous avez besoin d'un modèle stateful=True , de sorte que vous pouvez l'alimenter une prédiction après l'autre pour obtenir la prochaine et garder le modèle pensant que chaque entrée n'est pas une nouvelle séquence, mais une suite à la précédente.
fixation du code et de la formation
je vois dans le code qu'il y a une tentative de faire de votre y un shifte x (une bonne option pour prédire les prochaines étapes). Mais il est aussi un grand problème dans le prétraitement ici:
training_set = df_train.values
training_set = min_max_scaler.fit_transform(training_set)
x_train = training_set[0:len(training_set)-1]
y_train = training_set[1:len(training_set)]
x_train = np.reshape(x_train, (len(x_train), 1, 1))
données pour LSTM les couches doivent avoir la forme de (number_of_sequences, number_of_steps,features) .
donc, vous créez clairement des séquences d'une seule étape, ce qui signifie que votre LSTM n'est pas en train d'apprendre des séquences. (Il n'y a pas de séquence comportant une seule étape).
en supposant que vos données sont une séquence unique avec une caractéristique, il devrait certainement être en forme de (1, len(x_train), 1) .
naturellement, y_train devrait aussi avoir la même forme.
cela, à son tour, exigera que vos couches LSTM soit return_sequences=True - la seule façon de faire y avoir une longueur par pas. Aussi, pour avoir une bonne prédiction, vous pouvez avoir besoin d'un modèle plus complexe (parce que maintenant, ce sera vraiment de l'apprentissage).
Cela fait, vous formez votre modèle jusqu'à ce que vous obtenez un résultat satisfaisant.
prédire l'avenir
pour prédire l'avenir, vous aurez besoin de couches stateful=True LSTM.
avant tout, vous réinitialisez les États du modèle: model.reset_states() - nécessaire chaque fois que vous entrez une nouvelle séquence dans un modèle stateful.
ensuite, vous prédisez d'abord la totalité du X_train (ceci est nécessaire pour que le modèle comprenne à quel point de la séquence il est, en mots techniques: pour créer un état).
predictions = model.predict(`X_train`) #this creates states
Et, enfin, vous créez une boucle où vous commencez avec la dernière étape de la prédiction précédente:
future = []
currentStep = predictions[:,-1:,:] #last step from the previous prediction
for i in range(future_pred_count):
currentStep = model.predict(currentStep) #get the next step
future.append(currentStep) #store the future steps
#after processing a sequence, reset the states for safety
model.reset_states()
exemple
ce code fait ceci avec une séquence de 2-Caractéristique, une prédiction d'étape future décalée, et une méthode qui est un peu différente de cette réponse, mais basée sur le même principe.
j'ai créé deux modèles (l'un stateful=False , pour la formation sans avoir besoin de réinitialiser les États à chaque fois - n'oubliez jamais de réinitialiser les États lorsque vous démarrez une nouvelle séquence - et l'autre stateful=True , la copie des poids du modèle formé, pour prédire l'avenir)
https://github.com/danmoller/TestRepo/blob/master/TestBookLSTM.ipynb