Image Recognition Using TensorFlow And Raspberry Pi

Introduction 

 

This article demonstrates how to install TensorFlow and recognize images using Raspberry Pi.

 

Prerequisite

• Raspberry Pi
• TensorFlow
• Putty or VNC View  

About TensorFlow 

• TensorFlow is a free and open-source software library for dataflow
• It is a symbolic math library.
• TensorFlow is a computational framework for building machine learning models.

TensorFlow has two components

• a graph protocol buffer
• a runtime that executes the (distributed) graph

 

Types of an image

• BINARY IMAGE
• BLACK AND WHITE IMAG
• 8-bit COLOR FORMAT
• 16-bit COLOR FORMAT

A 16-bit color format is divided into three different colors which are Red, Green, and Blue (RGB).

 

Step 1

 

Let's go to install the raspbian stretch operating system and also get the latest version of Python, so open the Linux terminal to update Python.

 

 

sudo apt-get update
python --version
python3 --version

Installing TensorFlow needs some library file, so Libatlas library is required by the TensorFlow package installation. Once the library file is installed, then install the TensorFlow package.

 

Before installing TensorFlow, install the Atlas library.

sudo apt install libatlas-base-dev

Once that is finished install TensorFlow via pip3

pip3 install --user tensorflow

Nowwe've  successfully installed TensorFlowTensorFlow version-1-9-0. 

 

Step 2

 

Once we install the TensorFlow we're ready to test the basic TensorFlow script provided by the TensorFlow site and first, you can test the Hello World program. Now, I create a  new Python file like tftest.py,

sudo nano tftest.py

Next, you have to import the TensorFlow library. 

import tensorflow as tf
hello = tf.constant('Hello, TensorFlow')
sess = tf.Session()
print (sess.run(hello))

Just run the code. You can see the hello TensorFlow program is successfully printed.

 

Run the code from the terminal:

python3 tftest.py

 

 

Step 3

 

Clone the TensorFlow classification script.

git clone https://github.com/tensorflow/models.git

This is a panda image for reference:

 

 

 

Once the script is running the panda image will be recognized.

cd models/tutorials/image/imagenet
python3 classify_image.py

Source Code

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import argparse
import os.path
import re
import sys
import tarfile

import numpy as np
from six.moves import urllib
import tensorflow as tf

FLAGS = None


DATA_URL = 'http://download.tensorflow.org/models/image/imagenet/inception-2015-12-05.tgz'

class NodeLookup(object):

  def __init__(self,
               label_lookup_path=None,
               uid_lookup_path=None):
    if not label_lookup_path:
      label_lookup_path = os.path.join(
          FLAGS.model_dir, 'imagenet_2012_challenge_label_map_proto.pbtxt')
    if not uid_lookup_path:
      uid_lookup_path = os.path.join(
          FLAGS.model_dir, 'imagenet_synset_to_human_label_map.txt')
    self.node_lookup = self.load(label_lookup_path, uid_lookup_path)

  def load(self, label_lookup_path, uid_lookup_path):
    if not tf.gfile.Exists(uid_lookup_path):
      tf.logging.fatal('File does not exist %s', uid_lookup_path)
    if not tf.gfile.Exists(label_lookup_path):
      tf.logging.fatal('File does not exist %s', label_lookup_path)

    proto_as_ascii_lines = tf.gfile.GFile(uid_lookup_path).readlines()
    uid_to_human = {}
    p = re.compile(r'[n\d]*[ \S,]*')
    for line in proto_as_ascii_lines:
      parsed_items = p.findall(line)
      uid = parsed_items[0]
      human_string = parsed_items[2]
      uid_to_human[uid] = human_string
    node_id_to_uid = {}
    proto_as_ascii = tf.gfile.GFile(label_lookup_path).readlines()
    for line in proto_as_ascii:
      if line.startswith('  target_class:'):
        target_class = int(line.split(': ')[1])
      if line.startswith('  target_class_string:'):
        target_class_string = line.split(': ')[1]
        node_id_to_uid[target_class] = target_class_string[1:-2]
    node_id_to_name = {}
    for key, val in node_id_to_uid.items():
      if val not in uid_to_human:
        tf.logging.fatal('Failed to locate: %s', val)
      name = uid_to_human[val]
      node_id_to_name[key] = name
    return node_id_to_name
  def id_to_string(self, node_id):
    if node_id not in self.node_lookup:
      return ''
    return self.node_lookup[node_id]
def create_graph():
  with tf.gfile.FastGFile(os.path.join(
      FLAGS.model_dir, 'classify_image_graph_def.pb'), 'rb') as f:
    graph_def = tf.GraphDef()
    graph_def.ParseFromString(f.read())
    _ = tf.import_graph_def(graph_def, name='')
def run_inference_on_image(image):
  if not tf.gfile.Exists(image):
    tf.logging.fatal('File does not exist %s', image)
  image_data = tf.gfile.FastGFile(image, 'rb').read()

  create_graph()
  with tf.Session() as sess:

    softmax_tensor = sess.graph.get_tensor_by_name('softmax:0')
    predictions = sess.run(softmax_tensor,
                           {'DecodeJpeg/contents:0': image_data})
    predictions = np.squeeze(predictions)
 .  node_lookup = NodeLookup()
    top_k = predictions.argsort()[-FLAGS.num_top_predictions:][::-1]
    for node_id in top_k:
      human_string = node_lookup.id_to_string(node_id)
      score = predictions[node_id]
      print('%s (score = %.5f)' % (human_string, score))

def maybe_download_and_extract():
  dest_directory = FLAGS.model_dir
  if not os.path.exists(dest_directory):
    os.makedirs(dest_directory)
  filename = DATA_URL.split('/')[-1]
  filepath = os.path.join(dest_directory, filename)
  if not os.path.exists(filepath):
    def _progress(count, block_size, total_size):
      sys.stdout.write('\r>> Downloading %s %.1f%%' % (
          filename, float(count * block_size) / float(total_size) * 100.0))
      sys.stdout.flush()
    filepath, _ = urllib.request.urlretrieve(DATA_URL, filepath, _progress)
    print()
    statinfo = os.stat(filepath)
    print('Successfully downloaded', filename, statinfo.st_size, 'bytes.')
  tarfile.open(filepath, 'r:gz').extractall(dest_directory)

def main(_):
  maybe_download_and_extract()
  image = (FLAGS.image_file if FLAGS.image_file else
           os.path.join(FLAGS.model_dir, 'cropped_panda.jpg'))
  run_inference_on_image(image)

if __name__ == '__main__':
  parser = argparse.ArgumentParser()
  parser.add_argument(
      '--model_dir',
      type=str,
      default='/tmp/imagenet',
      help="""\

  )
  parser.add_argument(
      '--image_file',
      type=str,
      default='',
      help='Absolute path to image file.'
  )
  parser.add_argument(
      '--num_top_predictions',
      type=int,
      default=5,
      help='Display this many predictions.'
  )
  FLAGS, unparsed = parser.parse_known_args()
  tf.app.run(main=main, argv=[sys.argv[0]] + unparsed)

OUTPUT 

 

 

The same method is used to classify the external images like the following terminal command.

python3 classify_image.py --image_file=/PATH/

This is the very beginning of the TensorFlow Raspberry pi, just install the TensorFlow and Classify the image.

 

Summary

 

In this article, you learned how to install TensorFlow and do image recognition using TensorFlow and Raspberry Pi.

 

If you have any questions/ feedback/ issues, please write in the comment box.