The Keras deep learning library provides three different methods to train deep learning models. All these model training methods have their own specialized property to train the deep neural network model.
- .fit
- .fit_generator
- .train_on_batch
All these three model training methods used to achieve the same work to train the deep learning model, but they work in a very different way.
In this tutorial, we will learn about all these model training functions with example. And also get to know about the differences between them and when to use a particular training method.
Let’s explore the different behaviour of all these model training methods with an example and see when they use in particular scenarios.
Keras.fit() method
fit(x=train_x, y=train_y, batch_size=64, epochs=20)
This method train the model on input data train_x as features and train_y as the target variable. Once you hit this method, the entire input train dataset load into RAM and start to train the model.
This is one of the easiest solution to train the neural network model using .fit method. However, it is not a feasible solution when you are working with the huge dataset. For large training data, it requires lots of resources to fit the entire training data into RAM. Hence, it’s not quite good to use in real-life problems where the amount of data is large enough.
Keras’ .fit method works like a static function. Once you feed the data, you are not allowed to manipulating the training data during training using data augmentation. Please refer to this tutorial to learn about data augmentation.
The main two primary premises of Keras.fit is:
- While training the model, our entire training data will fit into RAM
- not allows performing real-time data augmentation on images
The Keras.fit() has various parameters:
fit(x=None, y=None, batch_size=None, epochs=1, verbose=1, callbacks=None, validation_split=0.0, validation_data=None, shuffle=True, class_weight=None, sample_weight=None, initial_epoch=0, steps_per_epoch=None, validation_steps=None, validation_freq=1, max_queue_size=10, workers=1, use_multiprocessing=False)
Keras.fit_generator()
It is perfectly fine to use Keras.fit() function when you are train model on a small and simplest dataset. But, real-life problems have a huge amount of data that are unable to load into memory. It also required to perform data augmentation to avoid overfitting to make the model more generalized. In these situations, we should use Keras’ fit_generator() function to train the model. The .fit_generator doesn’t accept the X and Y directly, need to pass through the generator.
The Keras.fit_generator() train the model on data generated batch-by-batch by a Python generator. Keras’ fit_generator method is a dynamic method that takes the input training data from Python generator function.
This generator function applies random data augmentation such as rotation, flipping, resizing, etc on training data during the training phase. Data augmentation make the model stronger and generalized. The generator function returns the batches of the data as defined by the batch size parameter.
Let’s define the generator function using Keras’ ImageDataGenerator class. Please refer to this tutorial to understand the various methods of Keras’ ImageDataGenerator class.
train_datagen = ImageDataGenerator(rotation_range=30, zoom_range=0.15,
width_shift_range=0.2, height_shift_range=0.2,
shear_range=0.15, horizontal_flip=True,
fill_mode="nearest")
In the next step, we need to feed the generator method to Keras.fit_generator method. On each iteration .fit_generator function get the batch of data from the generator and perform forward and back-propagation operation on it. It is called training the model.
To feed the Keras’ ImageDataGenerator class to .fit_generator method, three methods exist such as
batch_size = 32 train_generator = train_datagen.flow(trainX, trainY, batch_size=batch_size)
Here, the generator function runs forever. we forcefully need to terminate it. So, to control over it steps_per_epoch parameter is used.
The steps_per_epoch parameter equal to the ceil(num_samples / Batch_size). An epoch is considered to finish when steps_per_epoch batches have been seen by the model.
steps_per_epoch = len(trainX) // batch_size fit_generator(train_generator, steps_per_epoch=steps_per_epoch, epochs=10, verbose=1)
Keras.train_on_batch
Keras’ train_on_batch function accepts a single batch of data, perform backpropagation on it and then update the model parameters. The batch of data can be any size- doesn’t require to define explicitly.
When you want to train the model with your own custom rule and want to take the entire control over model training, you can use Keras.train_on_batch() function.
train_on_batch(x, y, sample_weight=None, class_weight=None, reset_metrics=True)
If you want to perform some custom changes after each batch training, Keras.train_on_batch() is best choice to use. However, it’s quite a complex method than traditional model training.
Summary
In this tutorial, you have discover the Keras’s different model training function such as .fit, .fit_generator and .train_on_batch. You have also got to know about the difference between all these functions and when to use the particular training method.
. . .