Need help with LSTMs for Sequence Prediction?

Step 2. Save Your Final Model

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:

You can save a fit Keras model to file using the save() function on the model.

For example:

# 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.

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

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

returnX,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:

Step 3. Make Predictions on New Data

After you have finalized your model and saved it to file, you can load it and use it to make predictions.

For example:

On a sequence regression problem, this may be the prediction of the real value at the next time step.

On a sequence classification problem, this may be a class outcome for a given input sequence.

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:

Further Reading

This section provides more resources on the topic if you are looking go deeper.

Posts

API

Summary

In this post, you discovered how to finalize your model and use it to make predictions on new data.

Specifically, you learned:

How to train a final LSTM model.

How to save your final LSTM model, and later load it again.

How to make predictions on new data.

Do you have any questions?Ask your questions in the comments below and I will do my best to answer.

Develop LSTMs for Sequence Prediction Today!

Develop Your Own LSTM models in Minutes

…with just a few lines of python code

Discover how in my new Ebook:Long Short-Term Memory Networks with Python