A Start-to-Finish Guide to Building Deep Neural Networks in Keras

Learning deep learning is daunting; so libraries like Keras that make it easy are helpful. In this article, I outline, explain, and provide code for 7 steps in building an image recognition deep convolutional neural network in Keras.

---

1 | Loading Image Data and Basic Preprocessing

Images will (most of the time) be in a .png or .jpg format. They can be loaded using the cv2 library with image = cv2.imread(file_directory).

The cv2 library has handy exporting from a cv2 image to a numpy array, done through img = cv2.cvtColor(image, cv2.COLOR_BGR2RGB). This will yield an array of dimensions (m, n, 3), where m and n are the dimensions of the image. 3 is representative of the depth, or the amount of red, green, and blue to incorporate for the final pixel color.

Extracting the numerical data from an image.

Finally, the data should be scaled, or put on a scale from between 0 to 1. This improves model performance (mathematically, neural networks operate better on a 0-to-1 scale). This can be done with x /= 255.

When all the data is collected, it should be in a array of dimension (x, m, n, 3) where x is the number of samples in your dataset.

If the y value is categorical, it can be easily one-hot encoded with Keras’ to_categorical:

from keras.utils import to_categorical
y = to_categorical(y)

---

2 | Splitting into training and testing

For this step, we’ll use sklearn’s tool for splitting the data into training and testing sets. You can substitute the test_size with whatever size you want to use — this is a balance between not having enough training data to properly train on against not having enough testing data to properly evaluate the model’s performance on new data.

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

#machine-learning #ai #keras #data analysis

What is GEEK

Buddha Community

Ultimate Guide for Deep Learning with Neural Network in 2021

In deep learning with Keras, you don’t have to code a lot, but there are a few steps on which you need to step over slowly so that in the near future, you can create your models. The flow of modelling is to load data, define the Keras model, compile the Keras model, fit the Keras model, evaluate it, tie everything together, and make the predictions out of it.

But at times, you might find it confusing because of not having a good hold on the fundamentals of deep learning. Before starting your new deep learning with Keras project, make sure to go through this ultimate guide which will help you in revising the fundamentals of deep learning with Keras.

In the field of Artificial Intelligence, deep learning has become a buzzword which always finds its way in various conversations. When it comes to imparting intelligence to the machines, it has been since many years that we used Machine Learning (ML).

But, considering the current period, due to its supremacy in predictions, deep learning with Keras has become more liked and famous as compared to the old and traditional ML techniques.

Deep Learning

Machine learning has a subset in which the Artificial Neural Networks (ANN) is trained with a large amount of data. This subset is nothing but deep learning. Since a deep learning algorithm learns from experience, it performs the task repeatedly; every time it tweaks it a little intending to improve the outcome.

It is termed as ‘deep learning’ because the neural networks have many deep layers which enables learning. Deep learning can solve any problem in which thinking is required to figure out the problem.

**Keras **

There are many APIs, frameworks, and libraries available to get started with deep learning. But here’s why deep learning with Keras is beneficial. Keras is a high-level neural network application programming interface (API) which runs on the top of TensorFlow – which is an end-to-end machine learning platform and is an open-source. Not just Tensorflow, but also CNTK, Theano, PlaidML, etc.

It helps in commoditizing artificial intelligence (AI) and deep learning. The coding in Keras is portable, it means that using Keras you can implement a neural network while using Theano as a backend and then subsequently run it on Tensorflow by specifying the backend. Also further, it is not mandatory rather, not needed at all to change the code.

If you are wondering why deep learning is an important term in Artificial Intelligence or if you are lagging motivation to start learning deep learning with Keras, this google trends snap shows how people’s interest in deep learning has been growing steadily worldwide for the last few years.

#deep learning #deep learning with neural network #neural network

Beginner’s guide to building Artificial Neural Networks

Why Keras, not Tensorflow?

If you are asking, “Should I use keras OR tensorflow?”, you are asking the wrong question.

When I first started my deep-learning journey, I kept thinking these two are completely separate entities. Well, as of mid-2017, they are not! Keras, a neural network API, is now fully integrated within TensorFlow. What does that mean?

It means you have a choice between using the high-level Keras API, or the low-level TensorFlow API. High-level APIs provide more functionality within a single command and are easier to use (in comparison with low-level APIs), which makes them usable even for non-tech people. The low-level APIs allow the advanced programmer to manipulate functions within a module at a very granular level, thus allowing custom implementation for novel solutions.

Note: For the purpose of this tutorial, we will be using Keras only!

Let’s dive right into the coding

We begin by installing Keras onto our machine. As I said before, Keras is integrated within TensorFlow, so all you have to do is pip install tensorflow in your terminal (for Mac OS) to access Keras in your Jupyter notebook.

Dataset

We will be working with a loan-application dataset. It has two predictor features, a continuous variable - age, and a categorical variable - area (rural vs. urban), and one binary outcome variable application_outcome, which can take values 0 (approved) or 1(rejected).

#neural-networks #keras #python #deep-learning #deep learning

Keras Tutorial - Ultimate Guide to Deep Learning - DataFlair

Welcome to DataFlair Keras Tutorial. This tutorial will introduce you to everything you need to know to get started with Keras. You will discover the characteristics, features, and various other properties of Keras. This article also explains the different neural network layers and the pre-trained models available in Keras. You will get the idea of how Keras makes it easier to try and experiment with new architectures in neural networks. And how Keras empowers new ideas and its implementation in a faster, efficient way.

Introduction to Keras

Keras is an open-source deep learning framework developed in python. Developers favor Keras because it is user-friendly, modular, and extensible. Keras allows developers for fast experimentation with neural networks.

Keras is a high-level API and uses Tensorflow, Theano, or CNTK as its backend. It provides a very clean and easy way to create deep learning models.

Characteristics of Keras

Keras has the following characteristics:

• It is simple to use and consistent. Since we describe models in python, it is easy to code, compact, and easy to debug.
• Keras is based on minimal substructure, it tries to minimize the user actions for common use cases.
• Keras allows us to use multiple backends, provides GPU support on CUDA, and allows us to train models on multiple GPUs.
• It offers a consistent API that provides necessary feedback when an error occurs.
• Using Keras, you can customize the functionalities of your code up to a great extent. Even small customization makes a big change because these functionalities are deeply integrated with the low-level backend.

Benefits of using Keras

The following major benefits of using Keras over other deep learning frameworks are:

• The simple API structure of Keras is designed for both new developers and experts.
• The Keras interface is very user friendly and is pretty optimized for general use cases.
• In Keras, you can write custom blocks to extend it.
• Keras is the second most popular deep learning framework after TensorFlow.
• Tensorflow also provides Keras implementation using its tf.keras module. You can access all the functionalities of Keras in TensorFlow using tf.keras.

Keras Installation

Before installing TensorFlow, you should have one of its backends. We prefer you to install Tensorflow. Install Tensorflow and Keras using pip python package installer.

Starting with Keras

The basic data structure of Keras is model, it defines how to organize layers. A simple type of model is the Sequential model, a sequential way of adding layers. For more flexible architecture, Keras provides a Functional API. Functional API allows you to take multiple inputs and produce outputs.

Keras Sequential model

Keras Functional API

It allows you to define more complex models.

#keras tutorials #introduction to keras #keras models #keras tutorial #layers in keras #why learn keras

Introduction to Neural Networks

There has been hype about artificial intelligence, machine learning, and neural networks for quite a while now. I have been working on these things for over a year now so I would like to share some of my knowledge and give my point of view on Neural networks. This will not be a math-heavy introduction because I just want to build the idea here.

I will start from the neural network and then I will explain every component of a neural network. If you feel like something is not right or need any help with any of this, Feel free to contact me, I will be happy to help.

---

When to use the Neural Network?

Let’s assume we want to solve a problem where you are given some set of images and you have to build an automated system that can categories each of those images to its correct label.

The problem looks simple but how do we come with some logic using raw pixel values and target labels. We can try comparing pixels and edges but we won’t be able to come with some idea which can do this task effectively or say the accuracy of 90% or more.

When we have this kind of problem where we have high dimensional data like Images and we don’t know the relationship between Input(Images) and the Output(Labels), In this kind of scenario we should use Neural Networks.ư

What is the Neural network?

Artificial neural networks, usually simply called neural networks, are computing systems vaguely inspired by the biological neural networks that constitute animal brains. An ANN is based on a collection of connected units or nodes called artificial neurons, which loosely model the neurons in a biological brain

#artificial-intelligence #gradient-descent #artificial-neural-network #deep-learning #neural-networks #deep learning

Neural networks forward propagation deep dive 102

Forward propagation is an important part of neural networks. Its not as hard as it sounds ;-)

This is part 2 in my series on neural networks. You are welcome to start at part 1 or skip to part 5 if you just want the code.

So, to perform gradient descent or cost optimisation, we need to write a cost function which performs:

1. Forward propagation
2. Backward propagation
3. Calculate cost & gradient

In this article, we are dealing with (1) forward propagation.

In figure 1, we can see our network diagram with much of the details removed. We will focus on one unit in level 2 and one unit in level 3. This understanding can then be copied to all units. (ps. one unit is one of the circles below)

Our goal in forward prop is to calculate A1, Z2, A2, Z3 & A3

Just so we can visualise the X features, see figure 2 and for some more info on the data, see part 1.

Initial weights (thetas)

As it turns out, this is quite an important topic for gradient descent. If you have not dealt with gradient descent, then check this article first. We can see above that we need 2 sets of weights. (signified by ø). We often still calls these weights theta and they mean the same thing.

We need one set of thetas for level 2 and a 2nd set for level 3. Each theta is a matrix and is size(L) * size(L-1). Thus for above:

• Theta1 = 6x4 matrix

• Theta2 = 7x7 matrix

We have to now guess at which initial thetas should be our starting point. Here, epsilon comes to the rescue and below is the matlab code to easily generate some random small numbers for our initial weights.

function weights = initializeWeights(inSize, outSize)
  epsilon = 0.12;
  weights = rand(outSize, 1 + inSize) * 2 * epsilon - epsilon;
end

After running above function with our sizes for each theta as mentioned above, we will get some good small random initial values as in figure 3

. For figure 1 above, the weights we mention would refer to rows 1 in below matrix’s.

Now, that we have our initial weights, we can go ahead and run gradient descent. However, this needs a cost function to help calculate the cost and gradients as it goes along. Before we can calculate the costs, we need to perform forward propagation to calculate our A1, Z2, A2, Z3 and A3 as per figure 1.

#machine-learning #machine-intelligence #neural-network-algorithm #neural-networks #networks