Category Archives: Keras

Data Augmentation with Keras ImageDataGenerator

One of the methods to prevent overfitting is to have more data. By this, our model will be exposed to more aspects of data and thus will generalize better. To get more data, either you manually collect data or generate data from the existing data by applying some transformations. The latter method is known as Data Augmentation.

In this blog, we will learn how we can perform data augmentation using Keras ImageDataGenerator class. First, we will discuss keras image augmentation API and then we will learn how to use this.

Keras API

ImageDataGenerator(featurewise_center=False, samplewise_center=False, featurewise_std_normalization=False, samplewise_std_normalization=False, zca_whitening=False, zca_epsilon=1e-06, rotation_range=0, width_shift_range=0.0, height_shift_range=0.0, brightness_range=None, shear_range=0.0, zoom_range=0.0, channel_shift_range=0.0, fill_mode='nearest', cval=0.0, horizontal_flip=False, vertical_flip=False, rescale=None, preprocessing_function=None, data_format=None, validation_split=0.0, dtype=None)

ImageDataGenerator(featurewise_center=False, samplewise_center=False, featurewise_std_normalization=False, samplewise_std_normalization=False, zca_whitening=False, zca_epsilon=1e-06, rotation_range=0, width_shift_range=0.0, height_shift_range=0.0, brightness_range=None, shear_range=0.0, zoom_range=0.0, channel_shift_range=0.0, fill_mode='nearest', cval=0.0, horizontal_flip=False, vertical_flip=False, rescale=None, preprocessing_function=None, data_format=None, validation_split=0.0, dtype=None)

Let’s understand each of its arguments in detail using the following image

featurewise_center: Feature-wise means of the entire dataset. So, in this, we first calculate the mean over the entire dataset and then subtract this mean from each image. So, this results in shifting the mean of the distribution close to zero. To calculate the mean, you need to fit the data generator to the training data as

datagen = ImageDataGenerator(featurewise_center=True)
datagen.fit(x_train)

1 2	datagen = ImageDataGenerator(featurewise_center=True) datagen.fit(x_train)

For this, you have to load the entire training dataset which may significantly kill your memory if the dataset is large. To prevent this, one can calculate the mean from a smaller sample.

featurewise_std_normalization: In this, we divide each image by the standard deviation of the entire dataset. Thus, featurewise center and std_normalization together known as standardization tends to make the mean of the data to be 0 and std. deviation of 1 or in short Gaussian Distribution.

samplewise_center: Sample-wise means of a single image. So, in this, we set the mean pixel value of each image to be zero. Since the image mean is a local statistic that can be calculated from the image itself, there is no need for calling the fit method.

samplewise_std_normalization: In this, we divide each input image by its standard deviation.

zca_whitening: This is a preprocessing method which tries to remove the redundancy from the data while keeping its structure intact, unlike PCA. In short, this strengthens the high-frequency components in the image. For maths behind this, refer to this StackOverflow question. You need to fit the training data to calculate the principal components. This should be used with featurewise_center=True, otherwise, this will give you a warning and automatically set featurewise_center=True.

Note: For featurewise_center, featurewise_std_normalization, zca_whitening, one must fit the data to calculate the mean, standard deviation, and principal components.

rotation_range: This rotates each image up to the angle specified. Below figure shows the rotations by 45 degrees

width_shift_range: This results in shifting the image in the horizontal direction.

If it is a float less than 1, then this shifts the image by that fraction of width. For instance, 0.2 means shift horizontally by 20% of the image width.
If it is integer >=1, then this shifts the image horizontally by pixels in the range [-num, num]. For instance, 3 means shift horizontally by the pixels selected from the range [-2,-1,0,1,2]. So, the image may be shifted by 2 or 1 or 0 pixels.
Similarly for a 1D array.

height_shift_range: Similar to width_shift_range but in the vertical direction.

brightness_range: This produces images similar to as taken with different lighting conditions. In this, you pass the min and the max range based on which the image will be darkened or brightened. Values <1 darkens the image, >1 brightens the image and =1 means no change. For example, below line darkens the image as shown

datagen = ImageDataGenerator(brightness_range=[0.2,0.8])

1	datagen = ImageDataGenerator(brightness_range=[0.2,0.8])

rescale: This is to normalize the pixel values to a specific range. For 8-bit image, we generally rescale by 1/255 so as to have pixel values in the range 0 and 1.

shear_range: This is the shear angle in the counter-clockwise direction in degrees.

zoom_range: This zooms the image. If passed as float then [lower, upper] = [1-zoom_range, 1+zoom_range]. For instance, 0.2 means zoom in the range [0.8, 1.2]. Can also be passed a list directly.

channel_shift_range: This randomly shifts the values of the channels by the values specified. The below code sums up what this actually does.

[np.clip(x_channel + np.random.uniform(-value, value), min_img, max_img) for x_channel in img]

1	[np.clip(x_channel + np.random.uniform(-value, value), min_img, max_img) for x_channel in img]

Add random values to channel and then clipping depending on the max and min of the image.

horizontal_flip and vertical flip: Randomly flips the input image in the horizontal and vertical directions respectively.

data_format: Either channels_first or channels_last (default).

preprocessing_function: This function is applied to each input after the augmentation step. Below is an example of one such function where images are blurred

def blur(img):
    return (cv2.blur(img,(5,5)))

datagen = ImageDataGenerator(preprocessing_function= blur)

def blur(img):

return (cv2.blur(img,(5,5)))

datagen = ImageDataGenerator(preprocessing_function= blur)

How to use this?

Below is the code using which I have generated the above images

import numpy as np
import matplotlib.pyplot as plt
import keras
from keras.preprocessing.image import load_img, ImageDataGenerator, img_to_array

# Load the image and change it into an array and expand the dimensions
img = load_img('D:/downloads/opencv_logo.PNG')
img = img_to_array(img)
img1 = np.expand_dims(img, axis=0)

# create an instance of the class with the desired operation
datagen = ImageDataGenerator(horizontal_flip=True)

# Depending on the augmentation method you may need to call
# fit method to calculate the global statistics
data_generator = datagen.flow(img1,batch_size=1)

# Display some augmented samples
plt.figure(figsize=(10,5))
for i in range(6):
    plt.subplot(2,3,i+1)
    for x in data_generator:
        plt.imshow(x[0]/255.)
        plt.xticks([])
        plt.yticks([])
        break
plt.tight_layout()
plt.show()

import numpy as np

import matplotlib.pyplot as plt

import keras

from keras.preprocessing.image import load_img, ImageDataGenerator, img_to_array

# Load the image and change it into an array and expand the dimensions

img = load_img('D:/downloads/opencv_logo.PNG')

img = img_to_array(img)

img1 = np.expand_dims(img, axis=0)

# create an instance of the class with the desired operation

datagen = ImageDataGenerator(horizontal_flip=True)

# Depending on the augmentation method you may need to call

# fit method to calculate the global statistics

data_generator = datagen.flow(img1,batch_size=1)

# Display some augmented samples

plt.figure(figsize=(10,5))

for i in range(6):

plt.subplot(2,3,i+1)

for x in data_generator:

plt.imshow(x[0]/255.)

plt.xticks([])

plt.yticks([])

break

plt.tight_layout()

plt.show()

This way you can create augmented examples. In the next blog, we will discuss how to generate batches of augmented data using the flow method.

Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

Monitoring Training in Keras: Callbacks

Leave a reply

Keras is a high level API, can run on top of Tensorflow, CNTK and Theano. Keras is preferable because it is easy and fast to learn. In this blog we will learn a set of functions named as callbacks, used during training in Keras.

Callbacks provides some advantages over normal training in keras. Here I will explain the important ones.

Callback can terminate a training when a Nan loss occurs.
Callback can save the model after every epoch, also you can save the best model.
Early Stopping: Callback can stop training when accuracy stops improving.

Terminate the training when Nan loss occurs

Let’s see the code how to terminate when Nan loss occurs while training:

keras.callbacks.TerminateOnNaN()

1	keras.callbacks.TerminateOnNaN()

Saving Model using Callbacks

To save model after every epoch in keras, we need to import ModelCheckpoint from keras.callbacks. Let’s see the below code which will save the model if validation loss decreases.

from keras.callbacks import ModelCheckpoint

filepath="weights-{epoch:02d}-{val_acc:.2f}.hdf5"
checkpoint = ModelCheckpoint(filepath=filepath, monitor='val_acc', verbose=1, save_best_only=True, mode='max')
callbacks_list = [checkpoint]

model.compile(optimizer = 'sgd', loss = 'binary_crossentropy')
model.fit(train_data, train_label, epochs = 10, batch_size = 64, callbacks = callbacks_list)

from keras.callbacks import ModelCheckpoint

filepath="weights-{epoch:02d}-{val_acc:.2f}.hdf5"

checkpoint = ModelCheckpoint(filepath=filepath, monitor='val_acc', verbose=1, save_best_only=True, mode='max')

callbacks_list = [checkpoint]

model.compile(optimizer = 'sgd', loss = 'binary_crossentropy')

model.fit(train_data, train_label, epochs = 10, batch_size = 64, callbacks = callbacks_list)

In the above code first we have created a ModelCheckpoint object by passing its required parameters.

“filepath” defines the path where all checkpoints will be saved. If you want to save only the best model, then directly pass filepath with name “best_model.hdf5” which will overwrite the previous saved checkpoints.
“monitor” will decide which quantity you want to monitor while training.
“save_best_only” only saves if validation loss decreases.
mode with {auto, min, max} when chosen max, will stop training when monitored quantity stops increasing.

Then finally make a callback list and pass it into model.fit() with parameter callbacks.

Early Stopping

Callbacks can stop training when a monitored quantity has stopped improving. Lets see how:

keras.callbacks.EarlyStopping(monitor='val_loss', min_delta=0, patience=0, verbose=0, mode='auto', baseline=None, restore_best_weights=False)

1	keras.callbacks.EarlyStopping(monitor='val_loss', min_delta=0, patience=0, verbose=0, mode='auto', baseline=None, restore_best_weights=False)

min_delta: It is the minimum quantity which will be taken for improvement to be conceded.
patience: after this number of epochs if training does not improve, it will stop.
mode: in auto mode, the direction will be decided by monitored quantity.
“baseline” the baseline value over which no improvement will stop the training.

Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

Multi Input and Multi Output Models in Keras

4 Replies

The Keras functional API is used to define complex models in deep learning . On of its good use case is to use multiple input and output in a model. In this blog we will learn how to define a keras model which takes more than one input and output.

Multi Output Model

Let say you are using MNIST dataset (handwritten digits images) for creating an autoencoder and classification problem both. In that case, you will be having single input but multiple outputs (predicted class and the generated image). Let take a look into the code.

from keras.layers import Dense, Input
from keras.models import Model

# creating model
inputs = Input(shape = (784,))
dense1 = Dense(512, activation = 'relu')(inputs)
dense2 = Dense(128, activation = 'relu')(dense1)
dense3 = Dense(32, activation = 'relu')(dense2)

# create classification output
classification_output = Dense(10, activation = 'softmax')(dense3)

# use output from dense layer 3 to create autoencder output
up_dense1 = Dense(128, activation = 'relu')(dense3)
up_dense2 = Dense(512, activation = 'relu')(up_dense1)
decoded_outputs = Dense(784)(up_dense2)

from keras.layers import Dense, Input

from keras.models import Model

# creating model

inputs = Input(shape = (784,))

dense1 = Dense(512, activation = 'relu')(inputs)

dense2 = Dense(128, activation = 'relu')(dense1)

dense3 = Dense(32, activation = 'relu')(dense2)

# create classification output

classification_output = Dense(10, activation = 'softmax')(dense3)

# use output from dense layer 3 to create autoencder output

up_dense1 = Dense(128, activation = 'relu')(dense3)

up_dense2 = Dense(512, activation = 'relu')(up_dense1)

decoded_outputs = Dense(784)(up_dense2)

In the above code we have used a single input layer and two output layers as ‘classification_output’ and ‘decoder_output’. Let’s see how to create model with these input and outputs.

model = Model(inputs, [classification_output,decoded_outputs])
model.summary()

1 2	model = Model(inputs, [classification_output,decoded_outputs]) model.summary()

Now we have created the model, the next thing is to compile this model. Here we will define two loss functions for both outputs. Also we can assign weights for both losses. See code.

m = 256
n_epoch = 25
model.compile(optimizer='adam', loss=['categorical_crossentropy', 'mse'], loss_weights = [1.0, 0.5], metrics = ['accuracy'])
model.fit(output_X_train,[Y_train, output_X_train], epochs=n_epoch, batch_size=m, shuffle=True)

m = 256

n_epoch = 25

model.compile(optimizer='adam', loss=['categorical_crossentropy', 'mse'], loss_weights = [1.0, 0.5], metrics = ['accuracy'])

model.fit(output_X_train,[Y_train, output_X_train], epochs=n_epoch, batch_size=m, shuffle=True)

Multi Input Model

Let’s take an example where you need to take two inputs: one grayscale image and another RGB image. Using these two images you want to do an image classification. To perform this, we will use Keras functional API. Let’s see code.

# feature extraction from gray scale image
inputs = Input(shape = (28,28,1))

conv1 = Conv2D(16, (3,3), activation = 'relu', padding = "SAME")(inputs)
pool1 = MaxPooling2D(pool_size = (2,2), strides = 2)(conv1)
conv2 = Conv2D(32, (3,3), activation = 'relu', padding = "SAME")(pool1)
pool2 = MaxPooling2D(pool_size = (2,2), strides = 2)(conv2)
flat_1 = Flatten()(pool2)

# feature extraction from RGB image
inputs_2 = Input(shape = (28,28,3))

conv1_2 = Conv2D(16, (3,3), activation = 'relu', padding = "SAME")(inputs_2)
pool1_2 = MaxPooling2D(pool_size = (2,2), strides = 2)(conv1_2)
conv2_2 = Conv2D(32, (3,3), activation = 'relu', padding = "SAME")(pool1_2)
pool2_2 = MaxPooling2D(pool_size = (2,2), strides = 2)(conv2_2)
flat_2 = Flatten()(pool2_2)

# concatenate both feature layers and define output layer after some dense layers
concat = concatenate([flat_1,flat_2])
dense1 = Dense(512, activation = 'relu')(concat)
dense2 = Dense(128, activation = 'relu')(dense1)
dense3 = Dense(32, activation = 'relu')(dense2)
output = Dense(10, activation = 'softmax')(dense3)

# create model with two inputs
model = Model([inputs,inputs_2], dense1)

# feature extraction from gray scale image

inputs = Input(shape = (28,28,1))

conv1 = Conv2D(16, (3,3), activation = 'relu', padding = "SAME")(inputs)

pool1 = MaxPooling2D(pool_size = (2,2), strides = 2)(conv1)

conv2 = Conv2D(32, (3,3), activation = 'relu', padding = "SAME")(pool1)

pool2 = MaxPooling2D(pool_size = (2,2), strides = 2)(conv2)

flat_1 = Flatten()(pool2)

# feature extraction from RGB image

inputs_2 = Input(shape = (28,28,3))

conv1_2 = Conv2D(16, (3,3), activation = 'relu', padding = "SAME")(inputs_2)

pool1_2 = MaxPooling2D(pool_size = (2,2), strides = 2)(conv1_2)

conv2_2 = Conv2D(32, (3,3), activation = 'relu', padding = "SAME")(pool1_2)

pool2_2 = MaxPooling2D(pool_size = (2,2), strides = 2)(conv2_2)

flat_2 = Flatten()(pool2_2)

# concatenate both feature layers and define output layer after some dense layers

concat = concatenate([flat_1,flat_2])

dense1 = Dense(512, activation = 'relu')(concat)

dense2 = Dense(128, activation = 'relu')(dense1)

dense3 = Dense(32, activation = 'relu')(dense2)

output = Dense(10, activation = 'softmax')(dense3)

# create model with two inputs

model = Model([inputs,inputs_2], dense1)

In the above code, we have extracted two different feature layers from both inputs and then concatenated both to create output layer. And created model with two inputs and one output.

A nice example where you can you use both multi input and multi output is capsule network. If you want to take a look into this, refer this blog.

Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

Feeding output of a given intermediate layer in Keras as the input to another network

Leave a reply

Keras is a high level neural network library used for fast experimentation, user friendliness and easy extensibility. It is highly recommended library for a beginner in neural networks. In this blog we will learn how to use an intermediate layer of a neural network as input to another network.

Sometimes you might get stuck while using an output of an intermediate layer with the errors like ‘graph disconnected‘. Lets see how we can solve this through the code.

First, Lets create an autoencoder model. If you are not aware of what is an autoencoder, you can follow this blog.

# creating autoencoder model
encoder_inputs = Input(shape = (28,28,1))

conv1 = Conv2D(16, (3,3), activation = 'relu', padding = "SAME")(encoder_inputs)
pool1 = MaxPooling2D(pool_size = (2,2), strides = 2)(conv1)
conv2 = Conv2D(32, (3,3), activation = 'relu', padding = "SAME")(pool1)
pool2 = MaxPooling2D(pool_size = (2,2), strides = 2)(conv2)
flat = Flatten()(pool2)
encoder_outputs = Dense(32, activation = 'relu')(flat)

dense_layer_d = Dense(7*7*32, activation = 'relu')(encoder_outputs)
output_from_d = Reshape((7,7,32))(dense_layer_d)
conv1_1 = Conv2D(32, (3,3), activation = 'relu', padding = "SAME")(output_from_d)
upsampling_1 = Conv2DTranspose(32, 3, padding='same', activation='relu', strides=(2, 2))(conv1_1)
upsampling_2 = Conv2DTranspose(16, 3, padding='same', activation='relu', strides=(2, 2))(upsampling_1)
decoded_outputs = Conv2DTranspose(1, 3, padding='same', activation='relu')(upsampling_2)

autoencoder = Model(encoder_inputs, decoded_outputs)

# creating autoencoder model

encoder_inputs = Input(shape = (28,28,1))

conv1 = Conv2D(16, (3,3), activation = 'relu', padding = "SAME")(encoder_inputs)

pool1 = MaxPooling2D(pool_size = (2,2), strides = 2)(conv1)

conv2 = Conv2D(32, (3,3), activation = 'relu', padding = "SAME")(pool1)

pool2 = MaxPooling2D(pool_size = (2,2), strides = 2)(conv2)

flat = Flatten()(pool2)

encoder_outputs = Dense(32, activation = 'relu')(flat)

dense_layer_d = Dense(7*7*32, activation = 'relu')(encoder_outputs)

output_from_d = Reshape((7,7,32))(dense_layer_d)

conv1_1 = Conv2D(32, (3,3), activation = 'relu', padding = "SAME")(output_from_d)

upsampling_1 = Conv2DTranspose(32, 3, padding='same', activation='relu', strides=(2, 2))(conv1_1)

upsampling_2 = Conv2DTranspose(16, 3, padding='same', activation='relu', strides=(2, 2))(upsampling_1)

decoded_outputs = Conv2DTranspose(1, 3, padding='same', activation='relu')(upsampling_2)

autoencoder = Model(encoder_inputs, decoded_outputs)

In the above code we have created an autoencoder model. At line 9, we have generated encoder outputs. Now if you want to create decoder network from this model with encoder_outputs layer as it input, what should you do? A beginner will do something like this:

decoder_network = Model(dense_layer_d, decoded_outputs)

1	decoder_network = Model(dense_layer_d, decoded_outputs)

But this will throw an error ‘graph disconnected’. This is because dense_layer_d layer is connected to another previous layer and you have disconnected it to directly take this layer as input. To solve this problem you can do something like this:

decoder_input = Input(shape = (32,))
next_layer = decoder_input
for layer in autoencoder.layers[-6:]:
    next_layer = layer(next_layer)

decoder = Model(decoder_input, next_layer)

decoder_input = Input(shape = (32,))

next_layer = decoder_input

for layer in autoencoder.layers[-6:]:

next_layer = layer(next_layer)

decoder = Model(decoder_input, next_layer)

Earlier we have created a model autoencoder. Now if you want to get its intermediate layer, use following steps:

Find index of the input layer to decoder( in the given autoencoder model it is the 6th layer from last so -6)
Use autoencoder.layers to get that layer.
Iterate through the following layers in the autoencoder model, till the decoder_output layer.
Then create model using decoder_input and last iterated layer.

This will successfully create a decoder model which will take the output of an intermediate layer ‘encoder_outputs’ as its input. And that’s it!!

Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

Custom Layers in Keras

Leave a reply

A model in Keras is composed of layers. There are in-built layers present in Keras which you can directly import like Conv2D, Pool, Flatten, Reshape, etc. But sometimes you need to add your own custom layer. In this blog, we will learn how to add a custom layer in Keras.

There are basically two types of custom layers that you can add in Keras.

Lambda Layer

Lambda layer is useful whenever you need to do some operation on previous layer and do not want to add any trainable weights to it.

Let say you want to add your own activation function (which is not built-in Keras) to a layer. Then you first need to define a function which will take the output from the previous layer as input and apply custom activation function to it. We then pass this function to lambda layer.

from keras.layers import Lambda
from keras import backend as K

# defining a custom non linear function
def activation_relu(inputs):
    return K.maximum(0.,inputs)

# call function using lambda layer
squashed_output = Lambda(activation_relu)(inputs) # where inputs are output from previous layer

from keras.layers import Lambda

from keras import backend as K

# defining a custom non linear function

def activation_relu(inputs):

return K.maximum(0.,inputs)

# call function using lambda layer

squashed_output = Lambda(activation_relu)(inputs) # where inputs are output from previous layer

Custom Class Layer

Sometimes you want to create your own layer with trainable weights which is not in-built in Keras. In that case you need to create a custom class layer where you need to define following methods.

__init__ method to initialize class variable and super class variables
build method to define weights.
call method where you will perform all your operations.
compute_output_shape method to define output shape of this custom layer

Lets see an example of a custom layer class. Here you only need to focus on the architecture of the class.


     class MyLayer(Layer):

    def __init__(self, output_dim, **kwargs):
        self.output_dim = output_dim
        super(MyLayer, self).__init__(**kwargs)

    def build(self, input_shape):
        # Create a trainable weight variable for this layer.
        self.W= self.add_weight(name='kernel', 
                                      shape=(input_shape[1], self.output_dim),
                                      initializer='uniform',
                                      trainable=True)
        self.built = True 

    def call(self, x):
        return K.dot(x, self.W)

    def compute_output_shape(self, input_shape):
        return (input_shape[0], self.output_dim)

class MyLayer(Layer):

def __init__(self, output_dim, **kwargs):

self.output_dim = output_dim

super(MyLayer, self).__init__(**kwargs)

def build(self, input_shape):

# Create a trainable weight variable for this layer.

self.W= self.add_weight(name='kernel',

shape=(input_shape[1], self.output_dim),

initializer='uniform',

trainable=True)

self.built = True

def call(self, x):

return K.dot(x, self.W)

def compute_output_shape(self, input_shape):

return (input_shape[0], self.output_dim)

In the build method defining self.built = True is necessary. Also, you can see that all logic is written inside call(self, inputs) method. comput_output_shape will define the output shape of the layer.

You can also pass multiple input tensor to this custom layer. The only thing you need to do is, pass multiple inputs using a list.

Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

Saving and Loading models in Keras

1 Reply

Generally, a deep learning model takes a large amount of time to train, so its better to know how to save trained model. In this blog we will learn about how to save whole keras model i.e. its architecture, weights and optimizer state.

Lets first create a model in Keras. This is a simple autoencoder model. If you need to know more about autoencoders please refer this blog.

from keras.models import Model
from keras.layers import Dense, Input
import matplotlib.pyplot as plt
import numpy as np

# creating an autoencoder model
input_shape = Input(shape = (784,))
dense1 = Dense(512, activation = 'relu')(input_shape)
dense2 = Dense(256, activation = 'relu')(dense1)
encoded = Dense(32, activation = 'relu')(dense2)

dense3 = Dense(256, activation = 'relu')(encoded)
dense4 = Dense(512, activation = 'relu')(dense3)
decoded = Dense(784, activation = 'relu')(dense4)

autoencoder = Model(input_shape, decoded)

m = 256
n_epoch = 25
autoencoder.compile(optimizer='adam', loss='mse')
autoencoder.fit(output_X_train,output_X_train, epochs=n_epoch, batch_size=m, shuffle=True)

from keras.models import Model

from keras.layers import Dense, Input

import matplotlib.pyplot as plt

import numpy as np

# creating an autoencoder model

input_shape = Input(shape = (784,))

dense1 = Dense(512, activation = 'relu')(input_shape)

dense2 = Dense(256, activation = 'relu')(dense1)

encoded = Dense(32, activation = 'relu')(dense2)

dense3 = Dense(256, activation = 'relu')(encoded)

dense4 = Dense(512, activation = 'relu')(dense3)

decoded = Dense(784, activation = 'relu')(dense4)

autoencoder = Model(input_shape, decoded)

m = 256

n_epoch = 25

autoencoder.compile(optimizer='adam', loss='mse')

autoencoder.fit(output_X_train,output_X_train, epochs=n_epoch, batch_size=m, shuffle=True)

Above we have created a Keras model named as “autoencoder“. Now lets see how to save this model.

Saving and loading only architecture of a model

In keras, you can save and load architecture of a model in two formats: JSON or YAML Models generated in these two format are human readable and can be edited if needed.

# saving and loading model architecture in json format

# saving in json format
json_model = autoencoder.to_json()
json_file = open('autoencoder_json.json', 'w')
json_file.write(json_model)

# loading model architecture from json file
from keras.models import model_from_json
json_file = open('autoencoder_json.json', 'r')
json_model = model_from_json(json_file.read())

# saving and loading model architecture in json format

# saving in json format

json_model = autoencoder.to_json()

json_file = open('autoencoder_json.json', 'w')

json_file.write(json_model)

# loading model architecture from json file

from keras.models import model_from_json

json_file = open('autoencoder_json.json', 'r')

json_model = model_from_json(json_file.read())

# saving and loading model architecture in yaml format

# saving in yaml format
yaml_model = autoencoder.to_yaml()
yaml_file = open('autoencoder_yaml.yaml', 'w')
yaml_file.write(yaml_model)

# loading model architecture from yaml file
from keras.models import model_from_yaml
yaml_file = open('autoencoder_yaml.yaml', 'r')
yaml_model = model_from_yaml(yaml_file.read())

# saving and loading model architecture in yaml format

# saving in yaml format

yaml_model = autoencoder.to_yaml()

yaml_file = open('autoencoder_yaml.yaml', 'w')

yaml_file.write(yaml_model)

# loading model architecture from yaml file

from keras.models import model_from_yaml

yaml_file = open('autoencoder_yaml.yaml', 'r')

yaml_model = model_from_yaml(yaml_file.read())

Saving and Loading Weights of a Keras Model

With model architecture you will also need model weights to predict output from trained model.

# saving model weights
autoencoder.save_weights('autoencoder_weights.h5')

# loading weights of a keras model
json_model.load_weights('autoencoder_weights.h5')

# saving model weights

autoencoder.save_weights('autoencoder_weights.h5')

# loading weights of a keras model

json_model.load_weights('autoencoder_weights.h5')

Saving and Loading Both Architecture and Weights in one File

# saving whole model
autoencoder.save('autoencoder_model.h5')

# loading whole model
from keras.models import load_model
model1 = load_model('autoencoder_model.h5')

# saving whole model

autoencoder.save('autoencoder_model.h5')

# loading whole model

from keras.models import load_model

model1 = load_model('autoencoder_model.h5')

This will save following four parameters in “autoencoder_model.h5” file:

Model Architecture
Model Weights
Loss and Optimizer
State of the optimizer allowing to resume training where you left.

Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

TheAILearner

Mastering Artificial Intelligence

Category Archives: Keras

Data Augmentation with Keras ImageDataGenerator

Keras API

How to use this?

Monitoring Training in Keras: Callbacks

Terminate the training when Nan loss occurs

Saving Model using Callbacks

Early Stopping

Multi Input and Multi Output Models in Keras

Multi Output Model

Multi Input Model

Feeding output of a given intermediate layer in Keras as the input to another network

Custom Layers in Keras

Lambda Layer

Custom Class Layer

Saving and Loading models in Keras