How to Build a Neural Network in TensorFlow

What is 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.

Setting up TensorFlow

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

1. 64-bit operating system
2. Python version 3.7 or later
3. Windows 7 or later
4. macOS 10.12.6 (Sierra) or later (no GPU support)
5. Ubuntu 16.04 or later

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

Developing a TensorFlow neural network

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):

1. 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.
2. The convolutional layer is added to the architecture to extract useful features of image input.
3. 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.
4. 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.
5. 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.
6. 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.

Step 1: Importing necessary libraries

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 2: Downloading and preparing the dataset

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

tfds.list_builders()

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.

This is implemented as follows:

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 3: Verifying and visualizing the data

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

The following will be the output:

['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 4: Adding convolutional layers

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.summary()

The following is the output:

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 5: Adding neural network layers on top

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.

Here’s the implementation in Python:

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:

model.summary()

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

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
_________________________________________________________________

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 6: Training the model

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.

Conclusion

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.