{"id":1563,"date":"2019-03-08T02:54:47","date_gmt":"2019-03-08T02:54:47","guid":{"rendered":"http:\/\/kusuaks7\/?p=1168"},"modified":"2023-06-28T12:13:42","modified_gmt":"2023-06-28T12:13:42","slug":"deep-learning-for-beginners-practical-guide-with-python-and-keras","status":"publish","type":"post","link":"https:\/\/www.experfy.com\/blog\/ai-ml\/deep-learning-for-beginners-practical-guide-with-python-and-keras\/","title":{"rendered":"Deep Learning for Beginners – Practical Guide with Python and Keras"},"content":{"rendered":"

This post will show how the example of digits recognition, presented in a previous post<\/a>\u00a0(I strongly recommend reading it previously), is encoded with Keras to offer the reader a first practical contact with Deep Learning using this Python library.<\/p>\n

\n

Environment set\u00a0up<\/h3>\n

Why Keras?<\/h4>\n

Keras<\/a>\u00a0is the recommended library for beginners, since its learning curve is very smooth compared to others, and at the moment it is one of the popular middleware to implement neural networks. Keras is a Python library that provides, in a simple way, the creation of a wide range of Deep Learning models using as backend other libraries such as TensorFlow, Theano or CNTK. It was developed and maintained by\u00a0Fran\u00e7ois Chollet<\/a>, an engineer from Google, and his code has been released under the permissive license of MIT. Also an important thing is that Keras is included in\u00a0TensorFlow as a API<\/a>. Although Keras is currently included in Tensorflow package, but can also be used as a Python library. To start in the subject I consider that this second option is the most appropriate.<\/p>\n

The code in this post is available in the form of Jupyter notebooks in the GitHub (\u00a0https:\/\/github.com\/JordiTorresBCN\/DEEP-LEARNING-practical-introduction-with-Keras<\/a>), although this can be run as a normal program in Python if the reader so wishes.<\/p>\n

Colaboratory environment<\/h4>\n

In this post, we will use the\u00a0Colaboratory<\/em><\/a>\u00a0<\/em>offered by Google.<\/em><\/p>\n

<\/canvas><\/figure>\n

It is a Google research project created to help to disseminate Machine Learning education and research. It is a Jupyter notebook environment that requires no configuration and runs completely in the Cloud allowing the use of Keras, TensorFlow and PyTorch. The most important feature that distinguishes Colab from other free cloud services is; Colab provides GPU and is totally free. Detailed information about the service can be found on the\u00a0faq page<\/a>.<\/p>\n

Notebooks are stored in Google Drive and can be shared as you would do with Google Docs. This environment is free to use, which only requires a Google account. In addition, the environment allows the use of an NVIDIA K80 GPU free of charge.<\/p>\n

When entering for the first time you will see a window like the one shown below. In this window you should select the GITHUB tab and fill in the URL field with \u201cJordiTorresBCN\u201d and the Repository field with \u201cjorditorresBCN \/ DEEP-LEARNING-practical-introduction-with-Keras\u201d.<\/p>\n

<\/canvas><\/figure>\n

To load a notebook, click on the button that appears on their right (open notebook in new tab):<\/p>\n

<\/canvas><\/figure>\n

By default, Colab notebooks run on CPU. You can switch your notebook to run with GPU. In order to obtain access to one GPU we need to choose the tab Runtime\u00a0<\/em>and then select \u201cChange runtime type\u201d as shown in the following figure:<\/p>\n

<\/canvas><\/figure>\n

When a pop-up window appears select GPU. Ensure \u201cHardware accelerator\u201d is set to GPU (the default is CPU).<\/p>\n

A warning may appear indicating that the code is not created by Google. I hope that you trust my code and run it anyway!\u00a0\ud83d\ude09<\/p><\/blockquote>\n

Afterwards, ensure that you are connected to the runtime (there is a green check next to \u201cconnected\u201d in the menu ribbon):<\/p>\n

<\/canvas><\/figure>\n

Now you are able to run GitHub repo in Google Colab. Enjoy!<\/p>\n

Data to feed a neural\u00a0network<\/h3>\n

Dataset for training, validation and\u00a0testing<\/h4>\n

Before presenting the implementation in Keras of the previous example, let\u2019s review how we should distribute the available data in order to configure and evaluate the model correctly.<\/p>\n

For the configuration and evaluation of a model in Machine Learning, and therefore Deep Learning, the available data are usually divided into three sets: training data, validation data, and test data. The training data are those used for the learning algorithm to obtain the parameters of the model with the iterative method that we have already mentioned.<\/p>\n

If the model does not completely adapt to the input data (for example, if it presented overfitting), in this case, we would modify the value of certain hyperparameters and after training it again with the training data we would evaluate it again with the validation ones. We can make these adjustments of the hyperparameters guided by the validation data until we obtain validation results that we consider correct. If we have followed this procedure, we must be aware that, in fact, the validation data have influenced the model so that it also fits the validation data. For this reason, we always reserve a set of test data for final evaluation of the model that will only be used at the end of the whole process, when we consider that the model is already fine-tuned and we will no longer modify any of its hyperparameters.<\/p>\n

Given the introductory nature of this post and that we will not go into detail of tuning the hyperparameters, in the examples we will ignore the validation data and only use the training and test data.<\/p>\n

Preloaded data in\u00a0Keras<\/h4>\n

In Keras the MNIST dataset is preloaded in the form of four Numpy arrays and can be obtained with the following code:<\/p>\n

import <\/span>keras<\/span><\/p>\n

from <\/span>keras<\/span>.datasets import <\/span>mnist<\/span>
\n(x_train, y_train), (x_test, y_test) =mnist.load_data()<\/span><\/p>\n

x_train<\/em>\u00a0and\u00a0y_train<\/em>\u00a0contain the training set, while\u00a0x_test<\/em>\u00a0and\u00a0y_test<\/em>\u00a0contain the test data. The images are encoded as Numpy arrays and their corresponding labels ranging from 0 to 9. Following the strategy of the post to gradually introduce the concepts of the subject, as we have indicated, we will not see yet how to separate a part of the training data to use them as Validation data. We will only take into account the training and test data.<\/p>\n

If we want to check what values we have loaded, we can choose any of the images of the MNIST set, for example image 8, and using the following Python code:<\/p>\n

import matplotlib.pyplot as <\/span>plt<\/span>
\nplt<\/span>.imshow(x_train[8], cmap=plt.cm.binary)<\/span><\/p>\n

We get the following image:<\/p>\n

<\/canvas><\/figure>\n

And if we want to see its corresponding label we can do it through:<\/p>\n

print(y_train[8])<\/pre>\n
1<\/pre>\n
That, as we see, it returns the value of \u201c1\u201d, as expected.<\/p>\n
Data representation in\u00a0Keras<\/h4>\n
Keras, which as we have seen uses a multidimensional array of Numpy as a basic data structure, calls this data structure a\u00a0tensor<\/em>. In short, we could say that a tensor has three main attributes:<\/p>\n