3/24/22, 10:24 PM Deep Learning With Python: A Guide | Built In

FOR EMPLOYERS

Implementing Python in Deep

Learning: An In-Depth Guide
Imitating the human brain using one of the most popular programming
languages, Python.

Vihar Kurama
May 30, 2019
Updated: March 11, 2022

T he main idea behind deep learning is that artificial intelligence should draw
inspiration from the brain. This perspective gave rise to the "neural network”
terminology. The brain contains billions of neurons with tens of thousands of
connections between them. Deep learning algorithms resemble the brain in many
conditions, as both the brain and deep learning models involve a vast number of
computation units (neurons) that are not extraordinarily intelligent in isolation but
become intelligent when they interact with each other.

I think people need to understand that deep learning is making a lot of things,
behind-the-scenes, much better. Deep learning is already working in Google
search, and in image search; it allows you to image search a term like “hug.”—
Geoffrey Hinton
Post Share

Neurons
https://builtin.com/data-science/deep-learning-python 1/21
3/24/22, 10:24 PM Deep Learning With Python: A Guide | Built In

FOR which
The basic building block for neural networks is artificial neurons, EMPLOYERS
imitate
human brain neurons. These are simple, powerful computational units that have
weighted input signals and produce an output signal using an activation function.
These neurons are spread across several layers in the neural network.

Below is the image of how a neuron is imitated in a neural network. The neuron takes
in a input and has a particular weight with which they are connected with other
neurons. Using the Activation function the nonlinearities are removed and are put
into particular regions where the output is estimated. 

How Do Artificial Neural Network Works?

Deep learning consists of artificial neural networks that are modeled on similar
networks present in the human brain. As data travels through this artificial mesh,
each layer processes an aspect of the data, filters outliers, spots familiar entities, and
produces the final output.

Post Share

https://builtin.com/data-science/deep-learning-python 2/21
3/24/22, 10:24 PM Deep Learning With Python: A Guide | Built In

FOR EMPLOYERS

Input layer : This layer consists of the neurons that do nothing than receiving the
inputs and pass it on to the other layers. The number of layers in the input layer
should be equal to the attributes or features in the dataset.

Output Layer:The output layer is the predicted feature, it basically depends on the
type of model you’re building.

Hidden Layer: In between input and output layer there will be hidden layers based on
the type of model. Hidden layers contain vast number of neurons. The neurons in the
hidden layer apply transformations to the inputs and before passing them. As the
network is trained the weights get updated, to be more predictive.

NEURON WEIGHTS

Weights refer to the strength or Post

amplitude of a connection
Sharebetween two neurons, if
you are familiar with linear regression you can compare weights on inputs like

https://builtin.com/data-science/deep-learning-python 3/21
3/24/22, 10:24 PM Deep Learning With Python: A Guide | Built In

coefficients we use in a regression equation.Weights are often initialized to small

random values, such as values in the range 0 to 1. FOR EMPLOYERS

FEEDFORWARD DEEP NETWORKS

Feedforward supervised neural networks were among the first and most successful
learning algorithms. They are also called deep networks, multi-layer Perceptron
(MLP), or simply neural networks and the vanilla architecture with a single hidden
layer is illustrated. Each Neuron is associated with another neuron with some weight,

The network processes the input upward activating neurons as it goes to finally

produce an output value. This is called a forward pass on the network.

The image below depicts how data passes through the series of layers.

ACTIVATION FUNCTION Post Share

https://builtin.com/data-science/deep-learning-python 4/21
3/24/22, 10:24 PM Deep Learning With Python: A Guide | Built In

An activation function is a mapping of summed weighted input to the output of the

neuron. It is called an activation/ transfer function because itFOR
governs the inception
EMPLOYERS
at which the neuron is activated and the strength of the output signal.

Mathematically,

There are several activation functions that are used for different use cases. The most
commonly used activation functions are relu, tanh, softmax. The cheat sheet for
activation functions is given below.

CREDITS

Post Share

https://builtin.com/data-science/deep-learning-python 5/21
3/24/22, 10:24 PM Deep Learning With Python: A Guide | Built In

BACKPROPAGATION
FOR EMPLOYERS
The predicted value of the network is compared to the expected output, and an error
is calculated using a function. This error is then propagated back within the whole
network, one layer at a time, and the weights are updated according to the value that
they contributed to the error. This clever bit of math is called the backpropagation
algorithm. The process is repeated for all of the examples in your training data. One
round of updating the network for the entire training dataset is called an epoch. A
network may be trained for tens, hundreds or many thousands of epochs.

COST FUNCTION AND GRADIENT DESCENT

The cost function is the measure of “how good” a neural network did for its given
training input and the expected output. It also may depend on attributes such as
weights and biases.

A cost function is single-valued, not a vector because it rates how well the neural
network performed as a whole. Using the gradient descent optimization algorithm,
the weights are updated incrementally after each epoch.

Compatible Cost Function:

Post Share
Mathematically,

https://builtin.com/data-science/deep-learning-python 6/21
3/24/22, 10:24 PM Deep Learning With Python: A Guide | Built In

Sum of squared errors (SSE)

FOR EMPLOYERS

The magnitude and direction of the weight update are computed by taking a step in
the opposite direction of the cost gradient.

where η is the learning rate.

where Δw is a vector that contains the weight updates of each weight coefficient w,
which are computed as follows:

Graphically, considering cost function with single coefficient

We calculate the gradient descent until the derivative reaches the minimum error,
and each step is determined by the steepness of the slope (gradient).

Post Share

https://builtin.com/data-science/deep-learning-python 7/21
3/24/22, 10:24 PM Deep Learning With Python: A Guide | Built In

FOR EMPLOYERS

MULTILAYER PERCEPTRONS (FORWARD PROPAGATION)

This class of networks consists of multiple layers of neurons, usually interconnected

in a feed-forward way (moving in a forward direction). Each neuron in one layer has
direct connections to the neurons of the subsequent layer. In many applications, the
units of these networks apply a sigmoid or relu (Rectified Linear Activation) function
as an activation function.

Now consider a problem to find the number of transactions, given accounts and
family members as input. To solve this first, we need to start with creating a forward
propagation neural network.

Our Input layer will be the number of family members and accounts, the number of
hidden layers is one, and the output layer will be the number of transactions. Given
weights as shown in the figure from the input layer to the hidden layer with the
number of family members 2 and number of accounts 3 as inputs. Now the values of
the hidden layer (i, j) and output layer (k) will be calculated using forward propagation
Post Share
by the following steps.

https://builtin.com/data-science/deep-learning-python 8/21
3/24/22, 10:24 PM Deep Learning With Python: A Guide | Built In

Process
FOR EMPLOYERS

1. Multiply — add process.
2. Dot product (Inputs * Weights).
3. Forward propagation for one data point at a time.
4. Output is the prediction for that data point.

Value of i will be calculated from input value and the weights corresponding to the
neuron connected.

i = (2 * 1) + (3 * 1)

→i=5

Similarly,

j = (2 * -1) + (3 * 1)

→j=1

K = (5 * 2) + (1 * -1) Post Share

→k=9

https://builtin.com/data-science/deep-learning-python 9/21
3/24/22, 10:24 PM Deep Learning With Python: A Guide | Built In

FOR EMPLOYERS

SOLVING THE MULTI LAYER PERCEPTRON PROBLEM IN PYTHON

Now that we have seen how the inputs are passed through the layers of the neural
network, let’s now implement an neural network completely from scratch using a
Python library called NumPy.

```

# Loading the Libraries

dl_multilayer_perceptron.py via GitHub

Post Share

https://builtin.com/data-science/deep-learning-python 10/21
3/24/22, 10:24 PM Deep Learning With Python: A Guide | Built In

import numpy as np

FOR EMPLOYERS

print("Enter the two values for input layers")

print('a = ')

a = int(input())

# 2

print('b = ')

b = int(input())

# 3

input_data = np.array([a, b])

weights = {

'node_0': np.array([1, 1]),

'node_1': np.array([-1, 1]),

'output_node': np.array([2, -1])

node_0_value = (input_data * weights['node_0']).sum()

# 2 * 1 +3 * 1 = 5

print('node 0_hidden: {}'.format(node_0_value))

node_1_value = (input_data * weights['node_1']).sum()

# 2 * -1 + 3 * 1 = 1

print('node_1_hidden: {}'.format(node_1_value))

hidden_layer_values = np.array([node_0_value, node_1_value])

output_layer = (hidden_layer_values * weights['output_node']).sum()

print("output layer : {}".format(output_layer))

view raw

Post Share

https://builtin.com/data-science/deep-learning-python 11/21
3/24/22, 10:24 PM Deep Learning With Python: A Guide | Built In

$python dl_multilayer_perceptron.py

Enter the two values for input layers

FOR EMPLOYERS

a =

b =

node 0_hidden: 7

node_1_hidden: 1

output layer : 13

USING ACTIVATION FUNCTION

For neural Network to achieve their maximum predictive power we need to apply an
activation function for the hidden layers.It is used to capture the non-linearities. We
apply them to the input layers, hidden layers with some equation on the values.

Here we use Rectified Linear Activation (ReLU)

In the previous code snippet, we have seen how the output is generated using a
simple feed-forward neural network, now in the code snippet below, we add an
activation function where the sum of the product of inputs and weights are passed
into the activation function.

dl_fp_activation.py via GitHub 

Post Share

https://builtin.com/data-science/deep-learning-python 12/21
3/24/22, 10:24 PM Deep Learning With Python: A Guide | Built In

import numpy as np

FOR EMPLOYERS

print("Enter the two values for input layers")

print('a = ')

a = int(input())

# 2

print('b = ')

b = int(input())

weights = {

'node_0': np.array([2, 4]),

'node_1': np.array([[4, -5]]),

'output_node': np.array([2, 7])

input_data = np.array([a, b])

def relu(input):

# Rectified Linear Activation

output = max(input, 0)

return(output)

node_0_input = (input_data * weights['node_0']).sum()

node_0_output = relu(node_0_input)

node_1_input = (input_data * weights['node_1']).sum()

node_1_output = relu(node_1_input)

hidden_layer_outputs = np.array([node_0_output, node_1_output])

model_output = (hidden_layer_outputs * weights['output_node']).sum()

print(model_output)

Post Share

https://builtin.com/data-science/deep-learning-python 13/21
3/24/22, 10:24 PM Deep Learning With Python: A Guide | Built In

$python dl_fp_activation.py

Enter the two values for input layers

FOR EMPLOYERS

a =

b =

44

DEVELOPING FIRST NEURAL NETWORK WITH KERAS

About Keras:

Keras is a high-level neural networks API, written in Python and capable of running
on top of TensorFlow, CNTK, or Theano.

It is one of the most popular frameworks for coding neural networks. Recently, Keras
has been merged into tensorflow repository, boosting up more API's and allowing
multiple system usage.

To install keras on your machine using PIP, run the following command.

sudo pip install keras

STEPS TO IMPLEMENT YOUR DEEP LEARNING PROGRAM

IN KERAS

1. Load Data.
2. Define Model.
3. Compile Model.
4. Fit Model.
Post Share
5. Evaluate Model.
6. Tie It All Together.
https://builtin.com/data-science/deep-learning-python 14/21
3/24/22, 10:24 PM Deep Learning With Python: A Guide | Built In

FOR EMPLOYERS

DEVELOPING YOUR KERAS MODEL

Fully connected layers are described using the Dense class. We can specify the
number of neurons in the layer as the first argument, the initialisation method as the
second argument as init and determine the activation function using the activation
argument. Now that the model is defined, we can compile it. Compiling the model
uses the efficient numerical libraries under the covers (the so-called backend) such
as Theano or TensorFlow. So far we have defined our model and compiled it set for
efficient computation. Now it is time to run the model on the PIMA data. We can train
or fit our model on our data by calling the fit() function on the model.

Let’s get started with our program in KERAS: keras_pima.py via GitHub

Post Share

https://builtin.com/data-science/deep-learning-python 15/21
3/24/22, 10:24 PM Deep Learning With Python: A Guide | Built In

# Importing Keras Sequential Model

from keras.models import Sequential

FOR EMPLOYERS

from keras.layers import Dense

import numpy

# Initializing the seed value to a integer.

seed = 7

numpy.random.seed(seed)

# Loading the data set (PIMA Diabetes Dataset)

dataset = numpy.loadtxt('datasets/pima-indians-diabetes.csv', delimiter=",")

# Loading the input values to X and Label values Y using slicing.

X = dataset[:, 0:8]

Y = dataset[:, 8]

# Initializing the Sequential model from KERAS.

model = Sequential()

# Creating a 16 neuron hidden layer with Linear Rectified activation function.

model.add(Dense(16, input_dim=8, init='uniform', activation='relu'))

# Creating a 8 neuron hidden layer.

model.add(Dense(8, init='uniform', activation='relu'))

# Adding a output layer.

model.add(Dense(1, init='uniform', activation='sigmoid'))

# Compiling the model

model.compile(loss='binary_crossentropy',

optimizer='adam', metrics=['accuracy'])

# Fitting the model

model.fit(X, Y, nb_epoch=150, batch_size=10)

scores = model.evaluate(X, Y)

print("%s: %.2f%%" % (model.metrics_names[1],

Post scores[1] * 100))
Share

https://builtin.com/data-science/deep-learning-python 16/21
3/24/22, 10:24 PM Deep Learning With Python: A Guide | Built In

$python keras_pima.py

768/768 [==============================] - 0s - loss: 0.6776 -FOR EMPLOYERS

acc: 0.6510

Epoch 2/150

768/768 [==============================] - 0s - loss: 0.6535 - acc: 0.6510

Epoch 3/150

768/768 [==============================] - 0s - loss: 0.6378 - acc: 0.6510

Epoch 149/150

768/768 [==============================] - 0s - loss: 0.4666 - acc: 0.7786

Epoch 150/150

768/768 [==============================] - 0s - loss: 0.4634 - acc: 0.773432/768

[>.............................] - ETA: 0sacc: 77.73%

The neural network trains until 150 epochs and returns the accuracy value. The
model can be used for predictions which can be achieved by the method model.

ENDING NOTES

Deep Learning is cutting edge technology widely used and implemented in several

industries. It’s also one of the heavily researched areas in computer science. There
are several neural network architectures implemented for different data types, out of
these architectures, convolutional neural networks had achieved the state of the art
performance in the fields of image processing techniques.

Few other architectures like Recurrent Neural Networks are applied widely for
text/voice processing use cases. These neural networks, when applied to large
datasets, need huge computation power and hardware acceleration, achieved by
configuring Graphic Processing Units.

If you are new to using GPUs you can find free configured settings online
PostCollab Notebooks.
through Kaggle Notebooks/ Google Share
To achieve an efficient model,
one must iterate over network architecture which needs a lot of experimenting and
experience. Therefore, a lot of coding practice is strongly recommended. 
https://builtin.com/data-science/deep-learning-python 17/21
3/24/22, 10:24 PM Deep Learning With Python: A Guide | Built In

RELATED

Read More Data Science Stories FOR EMPLOYERS

RECENT DATA SCIENCE ARTICLES

Grad School or Certification: Which Is Better for a Data Science Career?

5 Questions to Expect in Your Data Science Job Interview

Data Science Versus Machine Learning: What’s the Difference?

Data Science
Post Share

https://builtin.com/data-science/deep-learning-python 18/21
3/24/22, 10:24 PM Deep Learning With Python: A Guide | Built In

Great Companies Need Great People. That's WhereFOR

WeEMPLOYERS
Come In.

RECRUIT WITH US

Built In is the online community for startups and tech companies. Find startup jobs, tech news and
events.

About
Our Story

Careers

Our Staff Writers

Content Descriptions

Company News

Get Involved
Recruit With Built In

Become an Expert Contributor

Send Us a News Tip

Post Share

Resources
https://builtin.com/data-science/deep-learning-python 19/21
3/24/22, 10:24 PM Deep Learning With Python: A Guide | Built In

Customer Support
FOR EMPLOYERS
Share Feedback

Report a Bug

Remote Jobs in Atlanta

Remote Jobs in Dallas

Remote Jobs in DC

Browse Jobs

Tech Hubs
Built In Austin

Built In Boston

Built In Chicago

Built In Colorado

Built In LA

Built In NYC

Built In San Francisco

Built In Seattle

See All Tech Hubs

© Built In 2022

Accessibility Statement

Copyright Policy

Privacy Policy
Post Share
Terms of Use

Do Not Sell My Personal Info

https://builtin.com/data-science/deep-learning-python 20/21
3/24/22, 10:24 PM Deep Learning With Python: A Guide | Built In

CA Notice of Collection

FOR EMPLOYERS

Post Share

https://builtin.com/data-science/deep-learning-python 21/21