Keras Deep Learning in Python [With Example]

By /
Python Keras Api

Keras is a powerful and easy-to-use open-source Deep Learning library for Python. It allows you to easily build and train neural networks and deep learning models. Keras is also one of the most popular Deep Learning frameworks among researchers and developers. Keras was developed and is maintained by a team of experienced developers and contributors. Keras is also backed by a large community of users and developers.

In this article, we will cover the following topics:

  1. What is Keras?
  2. Features of Keras
  3. Keras Contributors
  4. Keras Models
  5. How to use Keras?
  6. and more…

So let’s get started.

What is Keras?

Keras is a very popular deep learning framework and a neural network API that runs on top of TensorFlow, Theano, or CNTK.

Major features of Keras

Keras is an open-source library for creating deep-learning models. It is written in Python and can run on top of TensorFlow, Microsoft CNTK, or Theano. Keras is a high-level API that allows developers to easily create deep learning models. Keras is actively developed by contributors across the world and is widely adopted in the industry.

Keras is a high-performance API that allows for the easy creation of differentiable programs. It is focused on user experience and has great adoption in the industry. Keras provides fast prototyping and runs seamlessly on CPU and GPU. It supports NVIDeA and AMD. Keras allows for the freedom to design any architecture and is easy to get started with. Keras also provides easy production ways for models.

Contributors of Keras

Keras has nearly 48+ contributors at its initial stage.

Now it is nearly 250,000 developers or contributors. Every year it is growing by a rate of 2x. Some of the top companies responsible for the development of the Keras framework are Microsoft, Google, NVIDIA, and AWS. Some popular platforms that use the Keras framework are Netflix, Uber, Google, Instamert, and Huawei.

User Experiences on Keras

  • User-friendly API
    • Keras is an API designed for humans.
    • It follows best practices to reduce cognitive loads.
    • It follows consistency and simple APIs.
  • Not designed for machines
    • Keras provides clear feedback on any errors created by the users.
    • This minimizes the number of user actions required to required for common use cases.
  • Easy to learn and easy to use
    • It is highly productive.
    • It provides more ideas rather than you think.
    • It helps to win consistently and to provide the best support t win the competition.
  • High Flexibility
    • It provides higher flexibility to all the developers by integrating with other deep learning languages like TensorFlow and Theranos.
    • You can implement anything which was made by basic language.

Multi-backend and multi-platform Strategy

Keras provides multi-backend, as well as multi-platform Strategies to work on, such that codes, can get together and work on the same task.

  • We can develop Keras in python as well as in R also.
  • We can run the code with the following backend engines:
    • TensorFlow
    • Theano
  • It provides flexibility to deploy the network computations to multiple CPU and GPU servers.
  • It produces the models using the following ways:
    • TF-Services
    • GPU Acceleration
    • Android (TF, TF lite)
    • iOS (Native coreML)
    • Raspberry Pi

What are Keras Models?

Kers is used to build different machine-learning models. Keras’s model offers some simple methodologies to work on as well. Basically, We are going to discuss two different Keras models as well.

  • Sequential Model
  • Functional Model

1. Sequential Model

Sequential Model
Sequential Model

Features of Keras sequential API Model

  • It works like a linear stack of layers.
  • It is useful for creating sample models like:
    • Simple Classification of network
    • Encoder-Decoder model
  • This model treats each layer as an object that feeds the next layer in the same model.
  • This system is referred to as the sequential model.

2. Functional model

Functional Model
Functional Model

Features of Functional API model

  • This model has multi-input, multi-output, and arbitrary static graph topologies.
  • It provides complex models which fork into 2 or more branches or shared layers.
  • The concept used in the functional domain is called Domain Adaptation.

Execution in Keras API framework

There are two different types of executions possible for models created in the Keras API framework as follows:

  • Symbolic Execution
    • In this type of execution, We build a computational graph first.
    • Then the compiled graph was executed later.
    • It has value in python code.
  • Eager (imperative ) Execution
    • In this type of execution process, the python runtime is the execution runtime.
    • It is similar to execution with NumPy.
    • It is not having a value in python code.
    • with eager execution, value-dependent dynamic topologies(tree-RNNs) can be used.

Practical Example of Using Keras

We are going to learn how to use Keras API followed by a Sample program. Follow along with the code snippets. First of all, let us Install our Keras library using the Pip installer on our command prompt.

#installing keras using pip installer
pip install keras

   Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/
   Requirement already satisfied: keras in /usr/local/lib/python3.7/dist-packages (2.9.0)

In our sample program, we are going to load a preloaded dataset, the MNIST dataset of the Keras API, and print it using Keras methods. We will then normalize the input data in the dataset using Keras utilities.

Some other preloaded datasets available in the Keras API are the Boston Housing dataset, the CIFAR10 (classification of 10 image labels) dataset, and the IMDB Movie Reviews dataset. The MNIST dataset is a preloaded dataset in the Keras API.

In the dataset we have taken, there are 10 pieces of data. Rather than working on all the data, we are taking only two pieces of data and printing the same, and working on them. It can be obtained with the following code.

from keras.datasets import mnist
#loading datas in variables
(x_train, y_train), (x_test, y_test) = mnist.load_data()

#we will print 1st two datas from the dataset using the following code
from matplotlib import pyplot
for i in range(2):  
 pyplot.imshow(x_train[i], cmap=pyplot.get_cmap('gray'))
 pyplot.show()

We can normalize the data in the datasets by scaling the input values from type unit8 to float32 using an interval of [0,1]. This will allow for the probability of any value falling within the range of 0 to 1.

x_train = x_train.astype(‘float32’)
x_test = x_test.astype(‘float32’)
x_train /= 255
x_test /= 255

As we are going the scale the data from a 2-D array to a single vector, We need to convert every image of the MNIST dataset of 28*28 array to a vector with 784(28 * 28 = 784) components using the following code snippet:

x_train = x_train.reshape(60000, 784)
x_test = x_test.reshape(10000, 784)

For each image in our dataset, there is a level between 0 and 9 corresponding to the image. We need to represent this information with a vector of 10 positions, with a 1 in the position corresponding to the digit that represents the image, and 0 in all other positions. We can achieve this using the to_categorical() method from keras.util.

from keras.utils import to_categorical

y_train = to_categorical(y_train, num_classes=10)
y_test = to_categorical(y_test, num_classes=10)

#Now printing our final normalized data from our datasets

print(y_test[4])
print(y_train[5])
print(y_train.shape)
print(y_test.shape)

Hence we got the normalized value for the data(images) in our datasets. We printed the same in our last line and got our output as follows.

[[0. 0. 0. ... 1. 0. 0.]
 [0. 0. 1. ... 0. 0. 0.]
 [0. 1. 0. ... 0. 0. 0.]
 ...
 [0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]]
[[0. 0. 0. ... 0. 0. 0.]
 [1. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]
 ...
 [0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 1. 0.]]
(60000, 10)
(10000, 10)

This way we used the preloaded dataset in the Keras data frame and used the same for normalization for all input data(images) in our dataset.

Conclusion

Today we learned about the Keras API framework and its different characteristics. Although it was mostly theoretical, we hope you enjoyed it. We’ll visit again soon with more exciting topics.