Suddenly something has happened…

I started seeing colours in my black and white life. I have waited so long, and now I know that it was all worth it.

If I may compare you,

I would compare you to the moon for your soothing brightness.

I would compare you to the stars for completing all my wishes.

I would compare you to the sea for the depths you have in your eyes.

I would compare you to sunflowers for your calming smile.

I would compare you to Lotuses for your piousness.

I would compare you to the penance of a sage for the hardships I endured.

And I know you will always win.

Would you believe if I say,

I have seen depth of ocean in her eyes,

that I have died and reborn in the moment.

Would you believe if I say,

I was hypnotized or maybe I am,

that she can do magic with her eyes.

I have seen her dancing under moon,

In a cursed night.

Would you believe if I say,

she can do a lot with her eyes.

For her, it was a moment,

…

And I lived another life.

This has happened so many times; why do love and pain always rhyme?
Build a wall around,
Make sure not to hear a sound.
Hide your emotions deep down,
Trusting people will always get you drowned.
When will I see the light?
Will anyone ever be right?
Don’t get too close,
I could only trust to lose.
Once loved unconditionally.
Now, I have lost my smile.

The Power of Poetry

A stone hitting the surface of calm water,
I am filled with ripples.
What have you done to me?

A dying knight on a war ground,
I am filled with a sense of Pride.
What have you done to me?

An Oasis in the middle of a desert.
I am filled with thirst.
What have you done to me?

The way the Earth craves rain,
I feel insatiable.
What have you done to me?

Rising from ashes of wrath,
I burn myself like a Pheonix.
What have you done to me?

The unsatisfied urge,
I am filled with greed.
What have you done to me?

A lazy river or a soothing breeze,
I am at ease.
I feel all the sins,
What have you done to me?

The Power of Poetry

Why building a model for defect detection?
Some would say that because after all, we can see it with our own eyes.

Let me guide you through “Why”.
Here are the reasons:

1. Not everything goes through the inspector's eye.
2. Saving consumption of power on wasted material.
3. Add a middle layer of quality inspection.
4. Store the defect data for further analysis.

It can be implemented as an IoT application for Marble Industry. A lot of industries have been started adopting IoT services.

So, without delay let’s get started. Here are the contents of the article.

Content:

1. About data
2. Imports
3. Data Generators and Augmentation
4. Model Architecture
5. Evaluation
6. Prediction

About Dataset

The dataset folder has two folders train and test. In train and test folders there are 4 classes namely: crack, dot, good and joint.
There are a total of 2249 files in the train folder and 688 files in the test folder. The images are 256 x 256 in dimension.
The images are cropped from the original dataset. There is no overlapping among the cropped images and the aspect ratio is maintained while generating the crops. Download the dataset here. Please upvote their work.

Data Import

We will start by importing the required libraries and the main directory paths.

import tensorflow as tf
import cv2
import numpy as np # linear algebra
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import matplotlib.pyplot as plt
import os

Here’s the path to the train and test directory. In your case choose the path directed to your notebook.

train_dir = "marble/train/"
test_dir = "marble/test/"

Visualizing Images

Let’s create functions to visualize images. For example to fetch an image through a given path. Just to check the size.

def get_image(path):
    img = cv2.imread(path)
    print(img.shape)
    plt.imshow(img)

Output:

Image Data Generator

It generates batches of tensor image data with real-time data augmentation. There several parameters to pass in according to your need. Please check the documentation presented here.

Now, we will build our Image Data Generator which will be used to generate train and valid tests directly from the main directory by using Flow From Directory. We will also apply some image augmentation to our generator. Rotation range of 20 degrees — rotates images randomly, set Horizontal and Vertical flip to be True, shifts in width and height, and the fill mode to be nearest. After initializing the generator, we will set the target size of each image to be 48x48(WxH). Each image is required in color so we will set the color mode to be ‘RGB’. Batch size is the number of extractions from each subfolder. We will fit this generator for both sets i.e. train and valid.

traingen = datapreprocessing(train_dir,20)
validgen = datapreprocessing(test_dir,20)

Output:

Found 2249 images belonging to 4 classes.
Found 688 images belonging to 4 classes.

Let’s create a dictionary that contains labels for each class and keys for them. Later it will be used to fetch class names.

labelnames = traingen.class_indices
labelnames

Now, we will build a data frame that contains an absolute path to each image and its label.

#Create Train Dataframe as repository of paths and labels.
valid = getdata(test_dir)

Visualizing Images

Let’s create a function to visualize images. For example to fetch n number of images of good marble from data frame.

This will be used later to visualize if the predictions are correct or not.

To visualize images from the generator, we will create another function.

visualize_gen(traingen)

Images look like this:

#Get the shape of images
input_shape = traingen.image_shape
input_shape

Model Architecture

The model will contain:

1. Two Conv2d layers
2. Two Dense Layers
3. Two MaxPoolinig and Dropout Layers

Conv2d layers will extract features from the images in pieces, Dense layer will tune up the weights for them. MaxPooling2D layer will reduce the dimensionality for easier computation and Dropout layers will avoid the overfitting of the model.

The model summary is given below:

Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
layer1 (Conv2D)              (None, 48, 48, 8)         224       
_________________________________________________________________
max_pooling2d (MaxPooling2D) (None, 24, 24, 8)         0         
_________________________________________________________________
dropout (Dropout)            (None, 24, 24, 8)         0         
_________________________________________________________________
layer2 (Conv2D)              (None, 24, 24, 8)         584       
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 12, 12, 8)         0         
_________________________________________________________________
flatten (Flatten)            (None, 1152)              0         
_________________________________________________________________
layer5 (Dense)               (None, 128)               147584    
_________________________________________________________________
dropout_1 (Dropout)          (None, 128)               0         
_________________________________________________________________
output (Dense)               (None, 4)                 516       
=================================================================
Total params: 148,908
Trainable params: 148,908
Non-trainable params: 0

Use the below code for building architecture.

model01 = imageclf2(input_shape)

Compile and Evaluate

To compile the model, we will use :

loss = categorical_crossentropy
optimizer = Adam
metrics = accuracy
callback = Earlystopping

Categorical cross-entropy as loss function because the task is multi-class classification. We will also use EarlyStopping callback to call the function back if it doesn’t improve after some epochs. We will do this by passing patience as a parameter to the callback.

Here’s the full code

Compile and evaluate the model on the validation dataset.

model_com01 = compiler2(model01,traingen,validgen,100)

Output:

Restoring model weights from the end of the best epoch.
113/113 [==============================] - 5s 42ms/step - loss: 0.6710 - accuracy: 0.7617 - val_loss: 0.6584 - val_accuracy: 0.7791

Get Prediction and visualize the output.

Let’s try to predict any image available in the validation data set.

Pass in n any number between 0–19 because there are 20 images from each folder since we specified 20 as batch size during Image Generator initialization.

get_predictions(11)

Output:

array([2])

Let's check if other good images are like this or not.

#Visualise Predictions
get_n_images(6,valid,"good")

• The model has predicted that there is no deformation which is true.

Save the model!

# save the model to disk
model = model_com01[0]
model.save('saved_models/MarbleModel.tf')

Thankyou! for reading my story. Don't forget to try different hyperparameters and see if the score can be improved.

Classifying different types of flowers based on their images drawn from different datasets. Some classes are very narrow, containing only a particular sub-type of flower (e.g. pink primroses) while other classes contain many sub-types (e.g. wild roses).

Task

Classification of flowers is a difficult task because there are flowers that look almost the same and flowers that are the same but look different, mainly because of their colors. Consider a rose for the example, it comes in 3 different colors commonly. So, the model has to be perfect in predicting color as well as shape.

For our purpose, let’s build a flower classifier from scratch using Sequential API available in Keras-Tensorflow. Import the required libraries.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import csv
import imageio
import os, shutil
from tensorflow import keras

Dataset

You can download the flower dataset from here, it contains 102 types of different flowers. We will select the first 10 labels for the classification. Since data is already present inside the subfolders named as labels, you can use Flow-From-Directory and specify the main directory path to it. I have used Flow From DataFrame because it will help you fetching images with absolute path.

First, let’s take a look at the image from the training data set. The below code lists absolute paths of images available in the training dataset.

#lists dirs for train folder
label_1 = "flower_data/flower_data/train/1"
dirs_label_1 =  os.listdir(label_1)

Then, we create a function that can fetch us a single image of any image absolute path.

#visualise a flower
def get_image(path):    
    flower = imageio.imread(path)
    print(flower.shape)
    plt.figure(figsize=(5,5))
    plt.imshow(flower)

Now to fetch the image, we need to concatenate the folder path with the image name and then pass it to the get_image function.

img = 'image_06736.jpg'
label_path = label_1+'/'+img
label_path

Here’s how the path will look.

'flower_data/flower_data/train/1/image_06736.jpg'

Extract Image:

get_image(label_path)

Output Image:

Dataset also contains a .jason file from where you can get the dictionary of flowers and index. Just copy paste and create a Dictionary.

Remember that we are going to use only 20 of them, let’s select the first 20.

#select first 10
few_flowers = {}
for i in range(1,11):
    few_flowers[str(i)]=flower_names[str(i)]
few_flowers

To store the image abs path and labels, we create a function that will first create an empty data frame with absolute pathnames and image labels columns. And then populates it.

To get train data, specify the path. The path should look like this.

path = "flower_data/flower_data/train"
num_folders = 10

The number of subfolders is 10 because we want only 10 of the labels. If you want to build with a complete dataset then use flower_names as a dictionary and 102 as num_folders.

We have train and valid sets:

train = getdata(folder_path=path,num_subfolders=num_folders)
valid = getdata(folder_path=valid_path,num_subfolders=num_folders)

Visualize Images

To get n number of images from the data frame we have created and visualize it.

get_n_images(10,train,"english marigold")

Outputs:

Images are having different sizes which we need to take care of during building the Image Generator.

Let's check the proportion of flowers available to us.

The above function takes in a data frame and a dictionary of flowers to build the horizontal bar graph.

plotHbar(train,few_flowers) 

It seems the proportion of the labels are almost the same. Train data is not highly skewed and can be used without any sampling techniques.

Valid Set:

plotHbar(valid,few_flowers)

The valid set will be used for validation and not training, proportion doesn't matter here. The model will train on the train set get experienced over it and then evaluate on the basis of the validation set.

Data Preprocessing

In this section, we will define a function that can take data frame and batch size as input and build the Image Data Generator through the flow_from_dataframe method. Image Generator takes in different parameters and on the basis of that it generates Images. Parameters are rescaling, flips, rotations, shear range, etc. Check Keras Image Data Generator documentation for more details.

We will use ImageDataGenerator.flow_from_dataframe() for our purpose. It will take some parameters like:

x_col="filename"    #independent variable
y_col="class"       #dependent/target variable
target_size=(150, 150)    #Normalise the size
color_mode="rgb"          #Color Mode to red green blue
class_mode="categorical"  #Multiclass classification
batch_size=1              #Images to fetch from each folder
shuffle=True              # Shuffle images in the dataframe

Also, set the rescaling in ImageDataGenerator to normalize values.

Generate sets:

train_generated = datapreprocessing(train,bsize=1) 
valid_generated = datapreprocessing(valid,bsize=1)

The below code visualizes the images generated by Generator.

Classifier Model

Our model will have 10 layers i.e. 4 Conv2D each followed by MaxPooling2D and 2 Fully Connected Dense Layers. You can check the parameters required by Conv2D and Dense layer in the documentation.
We will build the model with:

Model: "sequential_2"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
layer1 (Conv2D)              (None, 75, 75, 16)        1744      
_________________________________________________________________
max_pooling2d (MaxPooling2D) (None, 37, 37, 16)        0         
_________________________________________________________________
layer2 (Conv2D)              (None, 37, 37, 32)        4640      
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 18, 18, 32)        0         
_________________________________________________________________
layer3 (Conv2D)              (None, 18, 18, 64)        18496     
_________________________________________________________________
max_pooling2d_2 (MaxPooling2 (None, 9, 9, 64)          0         
_________________________________________________________________
layer4 (Conv2D)              (None, 9, 9, 64)          36928     
_________________________________________________________________
max_pooling2d_3 (MaxPooling2 (None, 4, 4, 64)          0         
_________________________________________________________________
flatten_2 (Flatten)          (None, 1024)              0         
_________________________________________________________________
layer5 (Dense)               (None, 128)               131200    
_________________________________________________________________
output (Dense)               (None, 10)                1290      
=================================================================
Total params: 194,298
Trainable params: 194,298
Non-trainable params: 0
_________________________________________________________________

Kernel size and Strides for layers are given in the code for the model architecture below. Padding is ‘same’ throughout the Conv layers. Strides indicate the steps of conversion during filtering and Padding is the padded area to be considered or not.

Stride Visualisation:

Let’s build the classifier.

To compile the model, use Adam as Optimiser with learning_rate = 0.0001, loss = categorical_crossentropy, and accuracy as metrics. I have used Callbacks to save computing time but it is optional and depends on your rig. The function will return compiled model and history associated with it. It will also plot the accuracy curves.

Model Fit & Evaluation

Model is built using the build function described above and compiled through compileModel. The input shape of the data is (150,150,3) representing height, width, and channel. The model is being evaluated on the validation set.

model = imageclf2(input_shape=input_shape)

model_compiled = compiler2(model02,train_generated,
                           valid_generated,50,32)

Save your model.

# save the model to disk
model = model_compiled[0]
model.save('saved_models/flowerModel')

Endnote.

I have used Keras Auto Tuner to find the best hyperparameters. You can refer to Auto Tuner for details.

Thank you for reading my work.

Classifying Flower through Sequential-API-Deep Learning. was originally published in Analytics Vidhya on Medium, where people are continuing the conversation by highlighting and responding to this story.

Let’s build a classifier for classifying Insects e.g. Butterfly, Dragonfly, Mosquito, Grasshopper, and Ladybug using Keras Tensorflow Module.

Here are the steps we will follow:

1. Data Import
2. Visualizing Images
3. Building Image Generators
4. Model Architecture
5. Prediction

About Dataset:

The dataset contains images of insects from different websites and there are 5 directories in this dataset for different kinds of insects. Each directory contains almost ~1000 images of the particular insect type. Data has been scraped from Google and iStock.

Data Import

We will start by importing the required libraries and the main directory path.

import tensorflow as tf
import cv2
import numpy as np # linear algebra
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import matplotlib.pyplot as plt
import os

Here’s the path to the main directory. In your case choose the path directed to your notebook. I have chosen ‘insects’ as my directory because that is the folder directed to my notebook. I have also created a variable representing the number of subfolders available (5 folders for 5 classes).

# Directory where images are present
main_dir = 'insects'
num_fldrs = 5

Let’s create a dictionary that contains labels for each class and keys for them. Later it will be used to fetch class names.

# dictionary of labels
insect_names = {'1':"Butterfly",'2':"Dragonfly",
               '3':"Grasshopper",'4':"Ladybird",
               '5':"Mosquito"}

Now, we will build a data frame that contains an absolute path to each image and its label.

train = getdata(main_dir,num_fldrs)

The above function will return a data frame for main directory images.

Visualizing Images

Let’s create functions to visualize images. For example to fetch n number of images of Dragonfly from dataframe. Just to know if they are of the same size or not.

# A function to fetch single images based on path given
def get_image(path):
    img = cv2.imread(path,0)
    plt.imshow(img,cmap='gray')

The output will look like this:

get_n_images(10,train,"Dragonfly")

Images are not of the same size we will take care of that in Image Generator. The proportion of insects available in the data set is given below.

Image Data Generator

It generates batches of tensor image data with real-time data augmentation. There several parameters to pass in according to your need. Please check the documentation presented here.

Now, we will build our Image Data Generator which will be used to generate train and valid tests directly from the main directory by using Flow From Directory. We will also apply some image augmentation to our generator. Rotation range of 40 degrees — rotates images randomly, set Horizontal flip to be True and fill mode to be nearest. After initializing the generator, we will set the target size of each image to be 150x150 (WxH). Each image is required in color so we will set the color mode to be ‘rgb’. Batch size is the number of extractions from each subfolder. We will do this for both sets i.e. train and valid.

# Build train and validation sets
traingen,validgen = datapreprocessing(main_dir,20)

Output:

Found 3116 images belonging to 5 classes.
Found 1333 images belonging to 5 classes.

Let’s look at what is happening inside the generator.

visualize_gen(traingen)

Output:

We have dealt with the size problem of the images. Images have also been augmented using rotation and horizontal flip.

Now we have our data set fully prepared. Let’s build the model.

Model Architecture

We will build our model as per the below summary.

Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
layer1 (Conv2D)              (None, 148, 148, 16)      448       
_________________________________________________________________
max_pooling2d (MaxPooling2D) (None, 37, 37, 16)        0         
_________________________________________________________________
dropout (Dropout)            (None, 37, 37, 16)        0         
_________________________________________________________________
layer2 (Conv2D)              (None, 35, 35, 32)        4640      
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 17, 17, 32)        0         
_________________________________________________________________
dropout_1 (Dropout)          (None, 17, 17, 32)        0         
_________________________________________________________________
layer3 (Conv2D)              (None, 15, 15, 64)        18496     
_________________________________________________________________
max_pooling2d_2 (MaxPooling2 (None, 7, 7, 64)          0         
_________________________________________________________________
dropout_2 (Dropout)          (None, 7, 7, 64)          0         
_________________________________________________________________
layer4 (Conv2D)              (None, 5, 5, 128)         73856     
_________________________________________________________________
max_pooling2d_3 (MaxPooling2 (None, 2, 2, 128)         0         
_________________________________________________________________
dropout_3 (Dropout)          (None, 2, 2, 128)         0         
_________________________________________________________________
flatten (Flatten)            (None, 512)               0         
_________________________________________________________________
layer7 (Dense)               (None, 128)               65664     
_________________________________________________________________
dropout_4 (Dropout)          (None, 128)               0         
_________________________________________________________________
layer8 (Dense)               (None, 128)               16512     
_________________________________________________________________
dropout_5 (Dropout)          (None, 128)               0         
_________________________________________________________________
output (Dense)               (None, 5)                 645       
=================================================================
Total params: 180,261
Trainable params: 180,261
Non-trainable params: 0

To understand any of the above-mentioned layers, you can refer here.

We will proceed to our architecture by defining a builder function.

Build a model with the input_shape as the shape of the images.

# Get input shape
input_shape = traingen.image_shape
#Build Model
model01 = insectclf(input_shape)

Compile

To compile everything we will use :

loss = categorical_crossentropy
optimizer = Adam
metrics = accuracy
callback = Earlystopping

Here’s the full code

Let’s fit the model with epoch = 100, batch size = 32, and learning rate = 0.001. I have reached to these parameters after a lot of iterations but you are free to choose whatever you find fit.

model01 = compiler(model01,traingen,validgen,100,bsize=32,lr=0.001)

After running for 100 Epochs model will plot a curve and restore the best weights available.

Get Prediction

Let's try to predict any image available in the validation data set.

Pass in n any number between 0–19 because there 20 images from each folder.

get_predictions(13)

Output:

'Butterfly'

Save the model for later use.

model01[0].save(filepath='Dataset/saved_models/Model01.tf',save_format="tf")

Congrats! you have built your first insect classifier model using Keras TensorFlow.

Thank you for reading my story.

Insect Classification was originally published in Analytics Vidhya on Medium, where people are continuing the conversation by highlighting and responding to this story.

If you are interested in building an algorithm that can predict a stock’s price trend this might be the page for you.

This article talks about an approach to stock price prediction using deep learning techniques like Recurrent Neural Network and Long Short Term Memory.

We will go through each step of building a deep learning model using RNN and LSTM and check which is more suitable for predicting trends. Anyone with basic
knowledge of deep neural networks can relate to this article easily.

A Deep Learning Approach on Stock’s Share Price Prediction.

Before proceeding to steps, let’s first understand the concept of RNN and LSTM.

RNN:

Recurrent neural networks (RNN) are a class of neural networks that is powerful for modeling sequence data such as time series or natural language. I have used it in predicting stock prices. The logic behind this is that it will remember the price after a particular sequence and the model will gain experience based on that pattern. Schematically, RNN layer uses a for loop to iterate over the timesteps of a sequence, while maintaining an internal state that encodes information about the timesteps it has seen so far. RNN can retain sequence patterns only for a short time thus, we move to LSTM that can remember patterns in Long and Short Term memory.

LSTM:

LSTM is an artificial recurrent neural network architecture used in the field of deep learning. It is preferred over feedforward neural networks because it can memorize the data points over a longer period and hence the name Long Short Term Memory. LSTM network consists of cell, input gate, output gate and a forget gate.
Cell is like a memory that holds values over arbitrary time and three gates regulate that information in and out of the cell.

To get a detailed view of RNN and LSTM, click on the image below:

Data Collection & Preprocessing:

The first thing that we need to do is install yfinance. If you haven’t already installed it yet.

pip install yfinance

Import the yfinance module for collecting data of a particular stock. For our case, we will use Escorts Ltd.

#importing yfinance
import yfinance as yf

#Collecting data
data = yf.download('ESCORTS.NS',period='5y',interval='1d')

Parameters required for yfinance.download() are ticker which is the symbol for your stock; period: total duration for which you want data to be extracted, and interval: which refers to the consecutive records e.g. for 1 day put ‘1d’. This will extract the stock’s data of 5 years for each day excluding the holidays.

Import the following libraries:

import pandas as pd
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
%matplotlib inline

Now that we have collected the data, we need to select the column which is required. Data contains stock’s historical data on Open, Close, Low, High, Volume, and Adjusted Close. We will be using adjusted close for pattern detection and prediction. Also, split the data into train and test set so that we can evaluate our model later.

data_target = data.iloc[:1182,4]
data_test = data.iloc[1132:,4]
steps = 7

#return numpy representation of data
data = data.loc[:,["Adj Close"]].values
test = data[len(data) - len(data_test) - steps:]

#4 the column is Adj Close

Let’s check the trend by visualizing it.

plot = data_target.plot()

Before, proceeding further we need to define some functions for Scaling Down data and converting data into a set of patterns followed for a particular price.

For scaling down, we will use MinMaxScaler available under ScikitLearn.

#Scaling Dataset
def scaledata(data_target):

    #Import scaler and initialise it
    from sklearn.preprocessing import MinMaxScaler
    scaler = MinMaxScaler(feature_range=(0,1))
    #transform by converting it to array and shape of (-1,1)
    data_target_scaled = scaler.fit_transform(np.array(data_target).reshape(-1,1))
    #plot the scaled version of data
    plot_scaled = pd.DataFrame(data_target_scaled).plot()
    print(data_target.shape)

    #returns scaled data
    return data_target_scaled, scaler

Before proceeding to the next function, let’s understand why is it required. By now, we know that RNN retains the pattern for example if you wear red on Sunday, blue on Monday, and green on Tuesday and then repeats it, RNN can retain that pattern for a short time. It can predict that you will wear blue tomorrow if you wear a red t-shirt today. Thus, data must have a pattern to be recognized.

Now, we will build a function that will convert the data into patterns of prices, and the target price achieved after that pattern follows. This way, our model can learn the response of the price patterns.

#Create pattern and end price set
def createPatternSet(data_target_scaled,steps=7):   
    x_patern = []  #Independent Variable
    y_price = []   #Dependent Variable

    for day in range(steps,data_target_scaled.shape[0]):
        row = data_target_scaled[day-steps:day,0]
        #print(len(row))
        x_patern.append(row)
        y = data_target_scaled[day,0]
        #print(y)
        y_price.append(y)
    
    x_patern,y_price = np.array(x_patern),np.array(y_price)
    #RNN and LSTM takes 3D inputs, we need to change the shape of array to 3 dimensional.

    x_patern = x_patern.reshape(x_patern.shape[0],x_patern.shape[1],1)

    #returns independent and dependent variable sets
    return x_patern,y_price

The above function takes data to be converted and the number of steps as steps. By default, we set steps equal to 7 which means that the 7-day pattern and the Price after that will be recorded as independent and dependent variables respectively.

#Scale Down Target
data_target_scaled = scaledata(data_target)[0]
scaler = scaledata(data_target)[1]
#prepare test data
test = data[len(data) - len(data_test) - steps:]
test = scaler.transform(test)

Train and Test Set:

We will use our function to process and build x_train and y_train.

#Overwrite steps to 50. it doesnt really matter here because we will be doing a lot of iterations with it (Take anyhthing less than 100).
train_pattern = createPatternSet(data_target_scaled,steps=50)
x_train = train_pattern[0]
y_train = train_pattern[1]

#Input Shape needs to be 3D.
x_train.shape
>>> (1132, 50, 1)

We finished building our train set and we will build the test set.

#create pattern and price for test set.
test_pattern = createPatternSet(test,steps=50)
x_test = test_pattern[0]
y_test = test_pattern[1]

#Dont forget to check the shape of x_test (3D reuired).
x_test.shape

Test data will be used for the model’s evaluation. We will predict the values based on the x_test and then compare them to the original y_test value.

So, far we have completed data preprocessing, and now the interesting part.

Model Architecture:

We will define a class with methods that can build the architecture, compile it, and fit it on given data. The class will also have methods to set parameters like the number of neurons, batch_size, and epoch. The reason to build this class is that we can run a for loop with the different parameters passed and analyze the result. This will help the readers in trying other combinations of hyperparameters.

Later on, we can also inherit from this class for LSTM and overwrite the architecture building method. There are other options available for hyper tuning the model but we stick to this for the most basic understanding.

Build the Class for RNN:

By default the model’s architecture contains the following layers:

Layer (type)                 Output Shape              Param #   
=================================================================
simple_rnn_44 (SimpleRNN)    (None, 50, 50)            2600      
_________________________________________________________________
dropout_32 (Dropout)         (None, 50, 50)            0         
_________________________________________________________________
simple_rnn_45 (SimpleRNN)    (None, 50, 50)            5050      
_________________________________________________________________
dropout_33 (Dropout)         (None, 50, 50)            0         
_________________________________________________________________
simple_rnn_46 (SimpleRNN)    (None, 50, 50)            5050      
_________________________________________________________________
dropout_34 (Dropout)         (None, 50, 50)            0         
_________________________________________________________________
simple_rnn_47 (SimpleRNN)    (None, 50)                5050      
_________________________________________________________________
dropout_35 (Dropout)         (None, 50)                0         
_________________________________________________________________
dense_19 (Dense)             (None, 1)                 51        
=================================================================
Total params: 17,801
Trainable params: 17,801
Non-trainable params: 0

For compilation, I have used Adam and for loss function Mean Squared Error.

Build the Class for LSTM:

Inherit the previous class’ attribute and overwrite the architecture.

class LstmModel(StocksPriceRNN):
    StocksPriceRNN.model = tf.keras.Sequential()
    def __init__(self,x_train,y_train,epoch):
        super().__init__(x_train,y_train,epoch)
    
    def buildArchitecture(self,dense=1):
        StocksPriceRNN.model = tf.keras.Sequential()
        StocksPriceRNN.model.add(tf.keras.layers.LSTM(
                                 StocksPriceRNN.neurons,
                                 input_shape=(None,1)))
        #Output
        StocksPriceRNN.model.add(tf.keras.layers.Dense(units=1))
        return StocksPriceRNN.model.summary()

Visualization:
Next, we build a function to plot the validation curves.

def plotting(org_vals,output):
    plt.figure(figsize=(10,5), dpi=80, facecolor='w', edgecolor='k')
    plt.plot(org_vals,color="Green",label="Org value")
    plt.plot(output,color="Yellow",label="Predicted")
    plt.legend()
    plt.xlabel("Days")
    plt.ylabel("Price")
    plt.grid(True)
    plt.show()

That was a lot of work but we have built the pieces of our algorithm and the only thing left is to put them together.

Iterations & Evaluations:

First, we will iterate on RNN and then on LSTM. The best output of both will be compared for the evaluation.

Build a For-Loop statement for passing different epochs and batch sizes. Run the model on the data and visualize the output:

for steps in [7,30,90]:
    for epoch in [20,30,50]:
        #prepare train data
        train_pattern = createPatternSet(data_target_scaled,steps=steps)
        #prepare test data
        test = data[len(data) - len(data_test) - steps:]
        test = scaler.transform(test)

        test_pattern = createPatternSet(inputs,steps=steps)
        x_test = test_pattern[0]
        y_test = test_pattern[1]
        #Build Model
        RNN1 = StocksPriceRNN(x_train,y_train,epoch)
        RNN1.buildArchitecture(2,0)
        RNN1.compiler()
        #fit model
        history = RNN1.modelfit()
        #Predict Values
        pred = RNN1.model.predict(x=x_test)
        output = scaler.inverse_transform(pred)
        org_vals = scaler.inverse_transform(y_test)
        #visualise
        print("Plotting for Steps {} and Epoch {}".format(steps,epoch))
        plotting(org_vals,output)

This will output in 9 iterations. After comparing the iterations, I found that RNN gives sloppy but comparatively best results on a combination of 90–30 and 90–50 (steps-epoch).

Here is the Output:

Not much difference between 30–50 epoch but accuracy can increase on the increase of epochs.

Similarly, we run iterations for LSTM:
Please note that there will be some warnings related to “out of calls” and this is natural as we have split the test data with 100 records only. To avoid this, Make sure that experimental_relax_shapes=True, an option that relaxes argument shapes that can avoid unnecessary retracing (not necessarily required).

# for different epochs, batch size, and neurons/units. 
for epch in [60,100,200]:
    for batch in [2,4,6]:
        for neurons in [8,10,12]:
            LSTM2 = LstmModel(x_train,y_train,epoch=epch)
            LSTM2.changeBatchSize(batch)
            LSTM2.changeNeurons(neurons)

            LSTM2.buildArchitecture()
            LSTM2.compiler()
            history = LSTM2.modelfit()

            pred = LSTM2.model.predict(x_test)
            pred = scaler.inverse_transform(pred)
            #org = scaler.inverse_transform(y_test)

            print("For epch {}, neurons {} and batch {}".format(epch,neurons,batch))
            plotting(org,pred)

The output will contain 27 iterations.

Analyzing the output of LSTM, it is clear that LSTM performs better on the dataset than the RNN. LSTM gave better results at batch_size = 2, units = 10 and epoch = 200.

Here is the output:

EndNote:
The model that we have built is capable of a lot more iterations. We have only tried a few of them and still managed to get closer to the original price curve. Go ahead! and try other hyperparameters on your own, since we have built a class instance we can do a lot of modifications without writing the whole code or making changes to the same one.

Here’s the complete code:
https://www.kaggle.com/rishirajak/share-price-prediciton-using-lstm-and-rnn

Thank you for reading my work.

As a token of appreciation 😄 and if you are into books 📚, please visit and follow @musings_of_bibliophile

Share Price Prediction using RNN and LSTM was originally published in Analytics Vidhya on Medium, where people are continuing the conversation by highlighting and responding to this story.