A neural network comprises several nodes in each layer of the neural network architecture...

TensorFlow has many features that make it a sound choice for deep learning applications. Learn how to build a TensorFlow neural network with this quick guide.

A Quick Guide to Building a Neural Network in TensorFlow

How to Build a Neural Network in TensorFlow

TensorFlow is an open-source library developed in Python for the implementation of machine learning and artificial intelligence. It was initially developed for the Python language but the support has now extended to other languages like Java, C++, and JavaScript. The library was built by Google Brain with focus on implementing deep neural networks.

Some of the important features of TensorFlow are:

1. Automatic differentiation: A process that calculates the gradient vector of each of the parameters in the model that help in optimizing the performance of the model, such as backpropagation.

2. Eager execution: A mode that directly executes the code rather than adding to a computational graph that executes the code at a later stage.

3. Distribute: An API that distributes the computation of models on various devices which results in speeding up the computation process.

4. Losses: Functions that are required for assessing a trained model. They compare the model’s output with the expected output and compute the error loss. A few popular loss functions are binary cross entropy and mean squared error.

What is TensorFlow?

To install the latest version of TensorFlow, the following system requirements must be met:

macOS 10.12.6 (Sierra) or later (no GPU support)

The TensorFlow library can be installed using the following commands:

# Ugrade pip to latest version
pip install --upgrade pip

#Installation using pip command
pip install tensorflow

There is another way of using TensorFlow too: with Docker. The only requirement is that the docker should be installed on the PC. You can run the following command in the terminal:

docker pull tensorflow/tensorflow:latest  # Download latest stable image
docker run -it -p 8888:8888 tensorflow/tensorflow:latest-jupyter  # Start Jupyter server

Setting up TensorFlow

This section of the article will discuss some basic steps for developing a neural network using TensorFlow. Before this, we will look at basic terminologies related to convolutional neural networks (CNNs):

CNNs are a type of artificial neural network (ANN) which are very popular among machine learning practitioners. They consist of several layers, such as the convolutional layer, pooling layer, and output layer.

The convolutional layer is added to the architecture to extract useful features of image input.

The feature extraction in the previous step is achieved with the help of kernels. Kernels are N x N matrices that slide over the entire input image to extract the important features of an input image.

Pooling is required to reduce the dimensionality of the feature matrix. Sometimes, the feature matrix obtained after the convolutional layer results in a large number of features that need to be reduced so that it becomes computationally less expensive.

Padding is another type of layer present within CNN architecture. Here, additional zeroes are included to the edges of the matrix in order to read the edges precisely or get the output image similar to the one that was passed as the input image.

Once the matrix has been flattened by the pooling layer, the flattened vector is passed on to the fully connected layer. This layer is a neural network where weights are adjusted.

We now move on to the implementation of a TensorFlow neural network.

Developing a TensorFlow neural network

import tensorflow as tf
import cv2
from tensorflow.keras import datasets, layers, models
import numpy as np
import pandas as pd 
import matplotlib.pyplot as plt

Here, 5 libraries have been loaded: TensorFlow, cv2 (for computer vision), Matplotlib for plotting graphs, NumPy, and Pandas.

In case the libraries are not installed, the following code can be written:

pip install matplotlib
pip install cv2
pip install numpy
pip install pandas

Step 1: Importing necessary libraries

We can import the existing dataset from the TensorFlow library. The following command will list all the available datasets:

Here, we will load the 'caltech_birds2011' dataset which contains bird species data. It comprises 200 categories of bird species with approximately 11000 images. It includes annotations that are either bounding boxes or segmentation labels.

ds = tfds.load('caltech_birds2011', split='train', shuffle_files=True)
assert isinstance(ds, tf.data.Dataset)
print(ds)

The above code will result in downloading the dataset from:

Downloading and preparing dataset 1.11 GiB (download: 1.11 GiB, generated:
 1.11 GiB, total: 2.22 GiB) to
 ~/tensorflow_datasets/caltech_birds2011/0.1.1...

Dl Completed...: 100%
1/1 [00:32<00:00, 32.30s/ url]
Dl Size...: 100%
1097/1097 [00:32<00:00, 49.60 MiB/s]
Dl Completed...: 100%
2/2 [00:34<00:00, 18.55s/ url]
Dl Size...: 100%
1150585376/1150585376 [00:34<00:00, 37273288.86 MiB/s]
Extraction completed...: 100%
2/2 [00:34<00:00, 17.39s/ file]
Dataset caltech_birds2011 downloaded and prepared to 
~/tensorflow_datasets/caltech_birds2011/0.1.1. Subsequent calls will reuse
 this data.
<PrefetchDataset element_spec={'bbox': TensorSpec(shape=(4,),
 dtype=tf.float32, name=None), 'image': TensorSpec(shape=(None, None, 3),
 dtype=tf.uint8, name=None), 'image/filename': TensorSpec(shape=(), 
dtype=tf.string, name=None), 'label': TensorSpec(shape=(), dtype=tf.int64,
 name=None), 'label_name': TensorSpec(shape=(), dtype=tf.string, name=None),
 'segmentation_mask': TensorSpec(shape=(None, None, 1), dtype=tf.uint8, 
name=None)}>

Step 2: Downloading and preparing the dataset

In this step, we will visualize the data and verify the dataset. This will tell us what kind of images are present inside the data pertaining to each class. The following code illustrates the implementation:

dataset_instance = ds.take(5)  
for example in dataset_instance:  
  print(list(example.keys()))
  img = example["image"]
  category = example["label"]
  print(img.shape, categor

['bbox', 'image', 'image/filename', 'label', 'label_name', 'segmentation_mask']
(472, 470, 3) tf.Tensor(77, shape=(), dtype=int64)
['bbox', 'image', 'image/filename', 'label', 'label_name', 'segmentation_mask']
(349, 500, 3) tf.Tensor(159, shape=(), dtype=int64)
['bbox', 'image', 'image/filename', 'label', 'label_name', 'segmentation_mask']
(368, 500, 3) tf.Tensor(128, shape=(), dtype=int64)
['bbox', 'image', 'image/filename', 'label', 'label_name', 'segmentation_mask']
(370, 500, 3) tf.Tensor(171, shape=(), dtype=int64)
['bbox', 'image', 'image/filename', 'label', 'label_name', 'segmentation_mask']
(500, 375, 3) tf.Tensor(76, shape=(), dtype=int64)

Step 3: Verifying and visualizing the data

Here, we will add a few convolutional layers that will be used to extract features from the image. We will also add a few max pooling layers for dimensionality reduction. As an input, CNN takes the image in the form of a tensor of size (n,m,3), where 3 represents the three channels, i.e., R, G, B. This is illustrated below:

model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='sigmoid', input_shape=(32, 32, 3)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(32, (3, 3), activation='sigmoid'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(32, (3, 3), activation='sigmoid'))
model.add(layers.MaxPooling2D((1, 1)))
model.add(layers.Conv2D(32, (3, 3), activation='sigmoid'))

Now, we will visualize the architecture of the model created above:

Model: "sequential_5"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 conv2d_17 (Conv2D)          (None, 30, 30, 32)        896       
                                                                 
 max_pooling2d_12 (MaxPoolin  (None, 15, 15, 32)       0         
 g2D)                                                            
                                                                 
 conv2d_18 (Conv2D)          (None, 13, 13, 32)        9248      
                                                                 
 max_pooling2d_13 (MaxPoolin  (None, 6, 6, 32)         0         
 g2D)                                                            
                                                                 
 conv2d_19 (Conv2D)          (None, 4, 4, 32)          9248      
                                                                 
 max_pooling2d_14 (MaxPoolin  (None, 4, 4, 32)         0         
 g2D)                                                            
                                                                 
 conv2d_20 (Conv2D)          (None, 2, 2, 32)          9248      
                                                                 
 flatten_2 (Flatten)         (None, 128)               0         
                                                                 
 dense_4 (Dense)             (None, 64)                8256      
                                                                 
 dense_5 (Dense)             (None, 20)                1300      
                                                                 
=================================================================
Total params: 38,196
Trainable params: 38,196
Non-trainable params: 0
_________________________________________________________________

Step 4: Adding convolutional layers

We will add a dense layer or a neural network layer where weights are fine-tuned. This layer is responsible for learning the features that are unique and adjusting the weights accordingly.

model.add(layers.Flatten())
model.add(layers.Dense(64, activation='sigmoid'))
model.add(layers.Dense(20))

In the above code, we have used ‘sigmoid’ as the activation function. It can be replaced by other activation functions as well.

Now, let’s look at the complete architecture of the deep learning model:

The above code will result in the following set of statements:

From the output, it can be seen that there were 4 x 4 x 64 outputs (1024 in total) that were flattened before they were passed to dense layers.

Step 5: Adding neural network layers on top

This is an important step where weights are adjusted according to the dataset.

model.compile(optimizer='adam',
             loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

history = model.fit(train_images, train_labels, epochs=10,
                    validation_data=(test_images, test_labels))

The above code will result in the following output:

The above output shows that as the training progresses, there is a decrease in the validation loss and, hence, an increase in the accuracy.

Step 6: Training the model

In this article, we discussed the basic architecture of neural networks and how to construct a TensorFlow neural network. The architecture consists of various layers like the convolutional layer, max pooling layer, and dense layer. Each has their own significance. TensorFlow itself is a popular open-source library developed to construct neural networks. It has some unique features like automatic differentiation, eager execution, distributing computation of models, and providing various loss functions.

Conclusion

A neural network comprises several nodes in each layer of the neural network architecture which are interconnected. They are important for learning new features from instances of the data. Thus, they prove to be more accurate than most machine learning algorithms like logistic regression, support vector machine, etc. They can be used for processing images and identifying the objects within them. There are many other use cases of neural networks where they have proved to be very accurate. In this article, we’ll be focusing on TensorFlow neural networks and how to build them.

The number of layers depends upon the architecture of the algorithm. There are three types of layers: convolutional, max pooling, and dense layers.

This is done to reduce the computations when training the model.

The various loss functions include sigmoid, linear, and ReLu.

Frequently Asked Questions

What’s up with Turing?
Get the latest news about us here.

Press

Know more about remote work.
Checkout our blog here.

Blog

Have any questions?
We’d love to hear from you.

FOR DEVELOPERS

How to Build a Neural Network in TensorFlow

Author

Turing

What Is the Necessity of Bias in Neural Networks?

Installation Guide of TensorFlow Through Pip and Conda

How to Make a Simplified Multilayer Perceptron in TensorFlow

How Does a Recommendation Engine Work With Predicting Likes?

How Siamese Neural Networks Work With Image Processing

Frequently Asked Questions

Press

Blog

Contact

Hire remote developers