Keras

Keras is a high-level neural networks API, written in Python and capable of running on top of TensorFlow, CNTK,
or Theano. It was developed with a focus on enabling fast experimentation. Being able to go from idea to result
with the least possible delay is key to doing good research.

What is Keras ?

Deep neural network library in Python

High-level neural networks API
Modular – Building model is just stacking layers and connecting computational graphs
Runs on top of either TensorFlow or Theano or CNTK
Why use Keras ?
Useful for fast prototyping, ignoring the details of implementing backprop or writing optimization
procedure
Supports Convolution, Recurrent layer and combination of both.
Runs seamlessly on CPU and GPU
Almost any architecture can be designed using this framework
Open Source code – Large community support

Working principle - Backend

Computational Graphs
Expressing complex expressions as a combination of simple operations
Useful for calculating derivatives during backpropagation
Easier to implement distributed computation
Just specify the inputs, outputs and make sure the graph is connected

General pipeline for implementing an ANN

Design and define the neural network architecture

Select the optimizer that performs optimization
Select the loss function and train it
Select the appropriate evaluation metric for the given problem

Implementing a neural network in Keras

Five major steps

Preparing the input and specify the input dimension (size)
Define the model architecture and build the computational graph
Specify the optimizer and configure the learning process
Specify the Inputs, Outputs of the computational graph (model) and the Loss function
Train and test the model on the dataset
Note: Gradient calculations are taken care by Auto – Differentiation and parameter updates are done
automatically in the backend
Build A Linear Regression Framework

We have already built a similar model with TensorFlow. Now we will build the same model with Keras to show you
how easy and intuitive it is.

In [1]: import numpy as np

import pandas as pd
from keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasRegressor
import warnings
warnings.filterwarnings("ignore")

Using TensorFlow backend.

In [2]: n=4
p=2
npX = np.array([1, 2, 3, 4, 4, 2, 4, 3])
npX = np.reshape(npX, newshape=(n,p), order='F')

npy = np.array([5, 4, 7, 7])

npy = np.reshape(npy, (n,1))

The following is the summary of the model

The model consists of two sequential layers, one for the input layer and another for the output layer.
The input dimension is 2 for this example. The activation function is linear since it is a linear regression
problem.
The loss function or cost function that is to minimize is the mean of squared errors. Here error is the difference
between actual values and predicted values.
Stochastic gradient descent optimization is used to minimize the loss function.

In [3]: def baseline_model():

# create model
model = Sequential()
model.add(Dense(p, input_dim=p, use_bias=True, init='uniform', act
ivation='linear'))
model.add(Dense(1, init='uniform', activation='linear'))
# Compile model
model.compile(loss='mean_squared_error', optimizer='sgd')
return model

In [6]: # evaluate model with standardized dataset

estimator = KerasRegressor(build_fn=baseline_model, epochs=1000, batch_siz
e=5, verbose=0)
estimator.fit(npX, npy)
y_hat = estimator.predict(npX)

Let us check how close the actuals and predictions are.

In [5]: pd.DataFrame({"Actual":np.reshape(npy, (n,)), "Predicted":y_hat})

Out[5]:
Actual Predicted

0 5 5.005006

1 4 4.065510

2 7 6.968617

3 7 6.989771