Using Convolutional Neural Networks for Image Classification

Convolutional neural networks (CNNs) are widely used in pattern- and image-recognition problems as they have a number of advantages compared to other techniques. This white paper covers the basics of CNNs including a description of the various layers used. Using traffic sign recognition as an example, we discuss the challenges of the general problem and introduce algorithms and implementation software developed by Cadence that can trade off computational burden and energy for a modest degradation in sign recognition rates. We outline the challenges of using CNNs in embedded systems and introduce the key characteristics of the digital signal processor (DSP) for Imaging and Computer Vision and software that make it so suitable for CNN applications across many imaging and related recognition tasks

What is image recognition technology?

Image recognition is the identification of objects and logos within an image. When using image recognition technology, images are passed through detection servers where objects and logos can be identified which generates various insights.

What Is a CNN?

A neural network is a system of interconnected artificial “neurons” that exchange messages between each other. The connections have numeric weights that are tuned during the training process, so that a properly trained network will respond correctly when presented with an image or pattern to recognize. The network consists of multiple layers of feature-detecting “neurons”. Each layer has many neurons that respond to different combinations of inputs from the previous layers. As shown in Figure 1, the layers are built up so that the first layer detects a set of primitive patterns in the input, the second layer detects patterns of patterns, the third layer detects patterns of those patterns, and so on. Typical CNNs use 5 to 25 distinct layers of pattern recognition

A typical CNN for recognizing traffic signs is shown in Figure 4. Each feature of a layer receives inputs from a set of features located in a small neighborhood in the previous layer called a local receptive field. With local receptive fields, features can extract elementary visual features, such as oriented edges, end-points, corners, etc., which are then combined by the higher layers.

In the traditional model of pattern/image recognition, a hand-designed feature extractor gathers relevant information from the input and eliminates irrelevant variabilities. The extractor is followed by a trainable classifier, a standard neural network that classifies feature vectors into classes.

In a CNN, convolution layers play the role of feature extractor. But they are not hand designed. Convolution filter kernel weights are decided on as part of the training process. Convolutional layers are able to extract the local features because they restrict the receptive fields of the hidden layers to be local. 

CNNs are used in variety of areas, including image and pattern recognition, speech recognition, natural language processing, and video analysis. There are a number of reasons that convolutional neural networks are becoming important. In traditional models for pattern recognition, feature extractors are hand designed. In CNNs, the weights of the convolutional layer being used for feature extraction as well as the fully connected layer being used for classification are determined during the training process. The improved network structures of CNNs lead to savings in memory requirements and computation complexity requirements and, at the same time, give better performance for applications where the input has local correlation (e.g., image and speech). 

Figure 5 shows a typical vision algorithm pipeline, which consists of four stages: pre-processing the image, detecting regions of interest (ROI) that contain likely objects, object recognition, and vision decision making. The pre-processing step is usually dependent on the details of the input, especially the camera system, and is often implemented in a hardwired unit outside the vision subsystem. The decision making at the end of pipeline typically www.cadence.com 3 Using Convolutional Neural Networks for Image Recognition operates on recognized objects—It may make complex decisions, but it operates on much less data, so these decisions are not usually computationally hard or memory-intensive problems. The big challenge is in the object detection and recognition stages, where CNNs are now having a wide impact.

Solution :

data_dir = './data'

# FloydHub - Use with data ID "R5KrjnANiKVhLWAkpXhNBe"

#data_dir = '/input'

import helper

helper.download_extract('mnist', data_dir)

helper.download_extract('celeba', data_dir)

show_n_images = 25

%matplotlib inline

import os

from glob import glob

from matplotlib import pyplot

mnist_images = helper.get_batch(glob(os.path.join(data_dir, 'mnist/*.jpg'))[:show_n_images], 28, 28, 'L')

pyplot.imshow(helper.images_square_grid(mnist_images, 'L'), cmap='gray')

from distutils.version import LooseVersion

import warnings

import tensorflow as tf

# Check TensorFlow Version

assert LooseVersion(tf.__version__) >= LooseVersion('1.0'), 'Please use TensorFlow version 1.0 or newer. You are using {}'.format(tf.__version__)

print('TensorFlow Version: {}'.format(tf.__version__))

# Check for a GPU

if not tf.test.gpu_device_name():

  warnings.warn('No GPU found. Please use a GPU to train your neural network.')

else:

  print('Default GPU Device: {}'.format(tf.test.gpu_device_name()))

import problem_unittests as tests

def model_inputs(image_width, image_height, image_channels, z_dim):

  """

  Create the model inputs

  :param image_width: The input image width

  :param image_height: The input image height

  :param image_channels: The number of image channels

  :param z_dim: The dimension of Z

  :return: Tuple of (tensor of real input images, tensor of z data, learning rate)

  """

  Implement Function

  return None, None, None

tests.test_model_inputs(model_inputs)

def discriminator(images, reuse=False):

  """

  Create the discriminator network

  :param images: Tensor of input image(s)

  :param reuse: Boolean if the weights should be reused

  :return: Tuple of (tensor output of the discriminator, tensor logits of the discriminator)

  """

  Implement Function

  return None, None

tests.test_discriminator(discriminator, tf)

def generator(z, out_channel_dim, is_train=True):

  """

  Create the generator network

  :param z: Input z

  :param out_channel_dim: The number of channels in the output image

  :param is_train: Boolean if generator is being used for training

  :return: The tensor output of the generator

  """

  Implement Function

   

  return None

tests.test_generator(generator, tf)

def model_opt(d_loss, g_loss, l