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.
Images will (most of the time) be in a
.jpg format. They can be loaded using the
cv2 library with
image = cv2.imread(file_directory).
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 (
n, 3), where
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 (
n, 3) where
x is the number of samples in your dataset.
y value is categorical, it can be easily one-hot encoded with Keras’
from keras.utils import to_categorical y = to_categorical(y)
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
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.
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.
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
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!
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.
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
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.
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.
Keras has the following characteristics:
The following major benefits of using Keras over other deep learning frameworks are:
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.
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.
It allows you to define more complex models.
#keras tutorials #introduction to keras #keras models #keras tutorial #layers in keras #why learn keras
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.
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.ư
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
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:
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.
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