The goal of developing an LSTM model is a final model that you can use on your sequence prediction problem.
In this post, you will discover how to finalize your model and use it to make predictions on new data.
After completing this post, you will know:
Let’s get started.
How to Make Predictions with Long Short-Term Memory Models with Keras
Photo by damon jah , some rights reserved.
A final LSTM model is one that you use to make predictions on new data.
That is, given new examples of input data, you want to use the model to predict the expected output. This may be a classification (assign a label) or a regression (a real value).
The goal of your sequence prediction project is to arrive at a final model that performs the best, where “best” is defined by:
In your project, you gather the data, spend the time you have, and discover the data preparation procedures, algorithm to use, and how to configure it.
The final model is the pinnacle of this process, the end you seek in order to start actually making predictions.
There is no such thing as a perfect model. There is only the best model that you were able to discover.
You finalize a model by applying the chosen LSTM architecture and configuration on all of your data.
There is no train and test split and no cross-validation folds. Put all of the data back together into one large training dataset and fit your model.
With the finalized model, you can:
For more on training a final model, see the post:
Take my free 7-day email course and discover 6 different LSTM architectures (with sample code).
Click to sign-up and also get a free PDF Ebook version of the course.
Keras provides an API to allow you to save your model to file.
The model is saved in HDF5 file format that efficiently stores large arrays of numbers on disk. You will need to confirm that you have the h5py Python library installed. It can be installed as follows:
sudo pip install h5py
You can save a fit Keras model to file using the save() function on the model.
# define model model = Sequential() model.add(LSTM(...)) # compile model model.compile(...) # fit model model.fit(...) # save model to single file model.save('lstm_model.h5')
This single file will contain the model architecture and weights. It also includes the specification of the chosen loss and optimization algorithm so that you can resume training.
The model can be loaded again (from a different script in a different Python session) using the load_model() function.
from keras.models import load_model # load model from single file model = load_model('lstm_model.h5') # make predictions yhat = model.predict(X, verbose=0) print(yhat)
Below is a complete example of fitting an LSTM model, saving it to a single file and later loading it again. Although the loading of the model is in the same script, this section may be run from another script in another Python session. Running the example saves the model to the file lstm_model.h5.
from keras.models import Sequential from keras.layers import Dense from keras.layers import LSTM from numpy import array from keras.models import load_model # return training data def get_train(): seq = [[0.0, 0.1], [0.1, 0.2], [0.2, 0.3], [0.3, 0.4], [0.4, 0.5]] seq = array(seq) X, y = seq[:, 0], seq[:, 1] X = X.reshape((len(X), 1, 1)) return X, y # define model model = Sequential() model.add(LSTM(10, input_shape=(1,1))) model.add(Dense(1, activation='linear')) # compile model model.compile(loss='mse', optimizer='adam') # fit model X,y = get_train() model.fit(X, y, epochs=300, shuffle=False, verbose=0) # save model to single file model.save('lstm_model.h5') # snip... # later, perhaps run from another script # load model from single file model = load_model('lstm_model.h5') # make predictions yhat = model.predict(X, verbose=0) print(yhat)
For more on saving and loading your Keras model, see the post:
After you have finalized your model and saved it to file, you can load it and use it to make predictions.
Or it may be any other variation based on the specifics of your sequence prediction problem. You would like an outcome from your model (yhat) given an input sequence (X) where the true outcome for the sequence (y) is currently unknown.
You may be interested in making predictions in a production environment, as the backend to an interface, or manually. It really depends on the goals of your project.
Any data preparation performed on your training data prior to fitting your final model must also be applied to any new data prior to making predictions.
Predicting is the easy part.
It involves taking the prepared input data (X) and calling one of the Keras prediction methods on the loaded model.
Remember that the input for making a prediction (X) is only comprised of the input sequence data required to make a prediction, not all prior training data. In the case of predicting the next value in one sequence, the input sequence would be 1 sample with the fixed number of time steps and features used when you defined and fit your model.
For example, a raw prediction in the shape and scale of the activation function of the output layer can be made by calling the predict() function on the model:
X = ... model = ... yhat = model.predict(X)
The prediction of a class index can be made by calling the predict_classes() function on the model.
X = ... model = ... yhat = model.predict_classes(X)
The prediction of probabilities can be made by calling the predict_proba() function on the model.
X = ... model = ... yhat = model.predict_proba(X)
For more on the life-cycle of your Keras model, see the post:
This section provides more resources on the topic if you are looking go deeper.
In this post, you discovered how to finalize your model and use it to make predictions on new data.
Specifically, you learned:
Do you have any questions?
Ask your questions in the comments below and I will do my best to answer.
…with just a few lines of python code
Discover how in my new Ebook:Long Short-Term Memory Networks with Python
It provides self-study tutorials on topics like:
CNN LSTMs, Encoder-Decoder LSTMs, generative models, data preparation, making predictions and much more…
Finally Bring LSTM Recurrent Neural Networks to
Your Sequence Predictions Projects
Skip the Academics. Just Results.