How to make a prediction on a RNN without training it every time

Question

I am new to Neural networks and I have successfully trained an RNN but it takes a while to train the data. It would not be feasible for me to train the data every time I want to make a prediction. So the question is, how do I make the training data persistent in that the RNN does not have to train every time every time I make a prediction?

This is the code I am using...

 from sklearn import preprocessing
 from sklearn.model_selection import train_test_split
 from keras.models import Sequential
 from keras.layers import Dense
 from keras.utils.data_utils import pad_sequences


 class Predict:

TrainingData    = None
XScale          = None


def __init__(self,PredData,TrainingData):


    PreparedData = self.PrepareData(PredData,TrainingData)

    #set the training data

    self.Train(PreparedData)

    #split all of the training data into their respective variables


    X_train, X_val_and_test, Y_train, Y_val_and_test    = train_test_split(self.XScale, self.Y, test_size = 0.6)
    X_val, X_test, Y_val, Y_test                        = train_test_split(X_val_and_test, Y_val_and_test, test_size = 0.6)

    #define the model
    self.DefineModel(X_train, Y_train, X_val, Y_val)

    #do the prediction
    return self.predict(PredData)


def PrepareData(self, PredData,TrainingData):

    LNumber = 0

    for I in TrainingData:

        if(len(I) > LNumber):
            LNumber = len(I)


    PadData = pad_sequences(TrainingData, maxlen = LNumber, padding = 'post', truncating = 'post')



    return PadData

def Train(self,TrainData):

    min_max_scaler = preprocessing.MinMaxScaler()

    self.X = TrainData[0:10]
    self.Y = TrainData[-10:]





    self.XScale = min_max_scaler.fit_transform(self.X)

def DefineModel(self,X_train, T_train, X_val, Y_val):

    self.model = Sequential([
                                Dense(32, activation = 'relu', input_shape = (10,)),
                                Dense(32, activation = 'relu'),
                                Dense(1, activation  = 'sigmoid'),
                            ])

    self.model.compile(     optimizer   = 'sgd',
                            loss        = 'binary_crossentropy',
                            metrics     = ['accuracy']
                            )

    self.model.fit(         X_train, Y_train,
                            batch_size = 32, epochs = 100,
                            validation_data = (X_val, Y_val))


def predict(self,PredData):

    Self.Prediction = model.predict(PredData)

See tensorflow's [Checkpoint](https://www.tensorflow.org/guide/checkpoint) and [SavedModel](https://www.tensorflow.org/guide/saved_model) APIs. — o-90, Aug 25 '22 at 01:26

score 1 · Accepted Answer · answered Aug 25 '22 at 07:04

As suggested in the comments you can use SavedModel to save your entire architecture + weights. I suggest you having a look at this page on how to Save and load Keras models.

Basically you just need to save like this:

self.model.save('path/to/location')

And to restore later on:

from tensorflow import keras
model = keras.models.load_model('path/to/location')

Also if your training is quite long, you can also think about saving checkpoints of the best model so far, using the callback tf.keras.callbacks.ModelCheckpoint. You create the callback and add it to your fit:

checkpoint_filepath = '/tmp/checkpoint'
model_checkpoint_callback = tf.keras.callbacks.ModelCheckpoint(
    filepath=checkpoint_filepath,
    save_weights_only=True,
    monitor='val_accuracy',
    mode='max',
    save_best_only=True)

# Model weights are saved at the end of every epoch, if it's the best seen so far.
model.fit(X_train, Y_train, batch_size=32, epochs=100,
          validation_data=(X_val, Y_val), callbacks=[model_checkpoint_callback])

If your train crashes or got interrupted you can re-load the best weights like this:

# The model weights (that are considered the best) are loaded into the model.
model.load_weights(checkpoint_filepath)

Note that if you are re-starting your script you will have to re-create the model object: load_weights does not re-create the architecture for you like it does load_model. But it is just a matter, in your case, of doing first:

self.model = Sequential([
       Dense(32, activation = 'relu', input_shape = (10,)),
       Dense(32, activation = 'relu'),
       Dense(1, activation  = 'sigmoid'),
])

How to make a prediction on a RNN without training it every time

1 Answers1