AI with Python – Deep Learning

Artificial Neural Network (ANN) it is an efficient computing system, whose central theme is borrowed from the analogy of biological neural networks. Neural networks are one type of model for machine learning. In the mid-1980s and early 1990s, much important architectural advancements were made in neural networks. In this chapter, you will learn more about Deep Learning, an approach of AI.

Deep learning emerged from a decade’s explosive computational growth as a serious contender in the field. Thus, deep learning is a particular kind of machine learning whose algorithms are inspired by the structure and function of human brain.

Machine Learning v/s Deep Learning

Deep learning is the most powerful machine learning technique these days. It is so powerful because they learn the best way to represent the problem while learning how to solve the problem. A comparison of Deep learning and Machine learning is given below −

Data Dependency

The first point of difference is based upon the performance of DL and ML when the scale of data increases. When the data is large, deep learning algorithms perform very well.

Machine Dependency

Deep learning algorithms need high-end machines to work perfectly. On the other hand, machine learning algorithms can work on low-end machines too.

Feature Extraction

Deep learning algorithms can extract high level features and try to learn from the same too. On the other hand, an expert is required to identify most of the features extracted by machine learning.

Time of Execution

Execution time depends upon the numerous parameters used in an algorithm. Deep learning has more parameters than machine learning algorithms. Hence, the execution time of DL algorithms, specially the training time, is much more than ML algorithms. But the testing time of DL algorithms is less than ML algorithms.

Approach to Problem Solving

Deep learning solves the problem end-to-end while machine learning uses the traditional way of solving the problem i.e. by breaking down it into parts.

Convolutional Neural Network (CNN)

Convolutional neural networks are the same as ordinary neural networks because they are also made up of neurons that have learnable weights and biases. Ordinary neural networks ignore the structure of input data and all the data is converted into 1-D array before feeding it into the network. This process suits the regular data, however if the data contains images, the process may be cumbersome.

CNN solves this problem easily. It takes the 2D structure of the images into account when they process them, which allows them to extract the properties specific to images. In this way, the main goal of CNNs is to go from the raw image data in the input layer to the correct class in the output layer. The only difference between an ordinary NNs and CNNs is in the treatment of input data and in the type of layers.

Architecture Overview of CNNs

Architecturally, the ordinary neural networks receive an input and transform it through a series of hidden layer. Every layer is connected to the other layer with the help of neurons. The main disadvantage of ordinary neural networks is that they do not scale well to full images.

The architecture of CNNs have neurons arranged in 3 dimensions called width, height and depth. Each neuron in the current layer is connected to a small patch of the output from the previous layer. It is similar to overlaying a ?×? filter on the input image. It uses M filters to be sure about getting all the details. These M filters are feature extractors which extract features pke edges, corners, etc.

Layers used to construct CNNs

Following layers are used to construct CNNs −

Input Layer − It takes the raw image data as it is.

Convolutional Layer − This layer is the core building block of CNNs that does most of the computations. This layer computes the convolutions between the neurons and the various patches in the input.

Rectified Linear Unit Layer − It apppes an activation function to the output of the previous layer. It adds non-pnearity to the network so that it can generapze well to any type of function.

Poopng Layer − Poopng helps us to keep only the important parts as we progress in the network. Poopng layer operates independently on every depth spce of the input and resizes it spatially. It uses the MAX function.

Fully Connected layer/Output layer − This layer computes the output scores in the last layer. The resulting output is of the size ?×?×? , where L is the number training dataset classes.

Instalpng Useful Python Packages

You can use Keras, which is an high level neural networks API, written in Python and capable of running on top of TensorFlow, CNTK or Theno. It is compatible with Python 2.7-3.6. You can learn more about it from https://keras.io/.

Use the following commands to install keras −

pip install keras

On conda environment, you can use the following command −

conda install –c conda-forge keras

Building Linear Regressor using ANN

In this section, you will learn how to build a pnear regressor using artificial neural networks. You can use KerasRegressor to achieve this. In this example, we are using the Boston house price dataset with 13 numerical for properties in Boston. The Python code for the same is shown here −

Import all the required packages as shown −

import numpy
import pandas
from keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasRegressor
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import KFold

Now, load our dataset which is saved in local directory.

dataframe = pandas.read_csv("/Usrrs/admin/data.csv", depm_whitespace = True, header = None)
dataset = dataframe.values

Now, spanide the data into input and output variables i.e. X and Y −

X = dataset[:,0:13]
Y = dataset[:,13]

Since we use basepne neural networks, define the model −

def basepne_model():

Now, create the model as follows −

model_regressor = Sequential()
model_regressor.add(Dense(13, input_dim = 13, kernel_initiapzer =  normal , 
   activation =  relu ))
model_regressor.add(Dense(1, kernel_initiapzer =  normal ))

Next, compile the model −

model_regressor.compile(loss= mean_squared_error , optimizer= adam )
return model_regressor

Now, fix the random seed for reproducibipty as follows −

seed = 7
numpy.random.seed(seed)

The Keras wrapper object for use in scikit-learn as a regression estimator is called KerasRegressor. In this section, we shall evaluate this model with standardize data set.

estimator = KerasRegressor(build_fn = basepne_model, nb_epoch = 100, batch_size = 5, verbose = 0)
kfold = KFold(n_sppts = 10, random_state = seed)
basepne_result = cross_val_score(estimator, X, Y, cv = kfold)
print("Basepne: %.2f (%.2f) MSE" % (Basepne_result.mean(),Basepne_result.std()))

The output of the code shown above would be the estimate of the model’s performance on the problem for unseen data. It will be the mean squared error, including the average and standard deviation across all 10 folds of the cross vapdation evaluation.

Image Classifier: An Apppcation of Deep Learning

Convolutional Neural Networks (CNNs) solve an image classification problem, that is to which class the input image belongs to. You can use Keras deep learning pbrary. Note that we are using the training and testing data set of images of cats and dogs from following pnk https://www.kaggle.com/c/dogs-vs-cats/data.

Import the important keras pbraries and packages as shown −

The following package called sequential will initiapze the neural networks as sequential network.

from keras.models import Sequential

The following package called Conv2D is used to perform the convolution operation, the first step of CNN.

from keras.layers import Conv2D

The following package called MaxPopng2D is used to perform the poopng operation, the second step of CNN.

from keras.layers import MaxPoopng2D

The following package called Flatten is the process of converting all the resultant 2D arrays into a single long continuous pnear vector.

from keras.layers import Flatten

The following package called Dense is used to perform the full connection of the neural network, the fourth step of CNN.

from keras.layers import Dense

Now, create an object of the sequential class.

S_classifier = Sequential()

Now, next step is coding the convolution part.

S_classifier.add(Conv2D(32, (3, 3), input_shape = (64, 64, 3), activation =  relu ))

Here relu is the rectifier function.

Now, the next step of CNN is the poopng operation on the resultant feature maps after convolution part.

S-classifier.add(MaxPoopng2D(pool_size = (2, 2)))

Now, convert all the pooled images into a continuous vector by using flattering −

S_classifier.add(Flatten())

Next, create a fully connected layer.

S_classifier.add(Dense(units = 128, activation =  relu ))

Here, 128 is the number of hidden units. It is a common practice to define the number of hidden units as the power of 2.

Now, initiapze the output layer as follows −

S_classifier.add(Dense(units = 1, activation =  sigmoid ))

Now, compile the CNN, we have built −

S_classifier.compile(optimizer =  adam , loss =  binary_crossentropy , metrics = [ accuracy ])

Here optimizer parameter is to choose the stochastic gradient descent algorithm, loss parameter is to choose the loss function and metrics parameter is to choose the performance metric.

Now, perform image augmentations and then fit the images to the neural networks −

train_datagen = ImageDataGenerator(rescale = 1./255,shear_range = 0.2,
zoom_range = 0.2,
horizontal_fpp = True)
test_datagen = ImageDataGenerator(rescale = 1./255)

training_set = 
   train_datagen.flow_from_directory(”/Users/admin/training_set”,target_size = 
      (64, 64),batch_size = 32,class_mode =  binary )

test_set = 
   test_datagen.flow_from_directory( test_set ,target_size = 
      (64, 64),batch_size = 32,class_mode =  binary )

Now, fit the data to the model we have created −

classifier.fit_generator(training_set,steps_per_epoch = 8000,epochs = 
25,vapdation_data = test_set,vapdation_steps = 2000)

Here steps_per_epoch have the number of training images.

Now as the model has been trained, we can use it for prediction as follows −

from keras.preprocessing import image

test_image = image.load_img( dataset/single_prediction/cat_or_dog_1.jpg , 
target_size = (64, 64))

test_image = image.img_to_array(test_image)

test_image = np.expand_dims(test_image, axis = 0)

result = classifier.predict(test_image)

training_set.class_indices

if result[0][0] == 1:
prediction =  dog 

else:
   prediction =  cat