Realtime Object and Face Detection in Android using Tensorflow Object Detection API

Artificial Intelligence is one of the breakthrough tech in computer science milestones among all their achievements. Image Recognition was a challenging part for the machine to detect objects. In this century, many computing resources and intelligent algorithms make it easy. But the feature will be only for those who have specifically configured machines to detect objects. After the release of Tensorflow Lite on Nov 14th, 2017 which made it easy to develop and deploy Tensorflow models in mobile and embedded devices - in this blog we provide steps to a develop android applications which can detect custom objects using Tensorflow Object Detection API.

Requirements

• Android Studio Installing Android Studio in your System (SDK Version >=27 and NDK Version >=16)
• Tensorflow Installing Tensorflow
• CPU (Intel i7,8GB RAM)or GPU (if you cannot prefer this configuration, try Google Cloud Platform of free $300 credits) to train the model.
• Labelimg (To annotate the image by boundary box)

Before You Get Started

Since the project is full of work with Python codes, libraries and API it’s a good methodology to work in a Python virtual environment and we use pip to install Python package make sure you installed it.

PIP installation:

• To install pip, securely download get-pip.py
• Then run the following: python get-pip.py
• Check you have correctly installed pip by checking its version: pip --version

Python Virtual Environment installation:

• Install virtualenv via pip: $ pip install virtualenv

• Test your installation: $ virtualenv --version

• Create a virtual environment for a project: $ virtualenv tensor_android

• Activating the Environment:

  $ cd tensor_android $ source bin/activate

• To deactivate: $ deactivate

If you completed all the steps mentioned above you have to see the ouput like this in your terminal or command prompt:

To know more about python virtual environment feel free to visit this link .

Step 1 - Collect Data:

In this project, we are going to work with custom images so I’m collecting images of Steve jobs and Elon Musk for it. After collecting all the images, annotate or box the object which you have to detect in the image using Labelimg and save both the .jpeg and .xml file of it in the image folder.

After creating a boundary box of an object, we get .xml file of it, it’s called as annotation file which will be used to specify the region where the classifier should focus on and it will be looking like this. The boundary box notation will be xmin,ymin,xmax,ymax.

1
<annotation>
2
        <folder>steve_jobs</folder>
3
        <filename>14_steve-jobs.jpg</filename>
4
        <path>"path of the image"</path>
5
        <source>
6
                <database>Unknown</database>
7
        </source>
8
        <size>
9
                <width>1024</width>
10
                <height>768</height>
11
                <depth>3</depth>
12
        </size>
13
        <segmented>0</segmented>
14
        <object>
15
                <name>steve jobs</name>
16
                <pose>Unspecified</pose>
17
                <truncated>0</truncated>
18
                <difficult>0</difficult>
19
                <bndbox>
20
                        <xmin>270</xmin>
21
                        <ymin>9</ymin>
22
                        <xmax>753</xmax>
23
                        <ymax>642</ymax>
24
                </bndbox>
25
        </object>
26
</annotation>

We successfully collected the required data and annotated it. Now we have to convert the images from xml file to a single csv file, because the file conversion is in this manner .jpeg >.xml > .csv > .record. So we have to convert it, I provided the code to convert the xml’s below.

1
import os
2
import glob
3
import pandas as pd
4
import xml.etree.ElementTree as ET
5

6

7
def xml_to_csv(path):
8
    xml_list:[]
9
    for xml_file in glob.glob(path + '/*.xml'):
10
        tree:ET.parse(xml_file)
11
        root:tree.getroot()
12
        for member in root.findall('object'):
13
            value:(root.find('filename').text,
14
                     int(root.find('size')[0].text),
15
                     int(root.find('size')[1].text),
16
                     member[0].text,
17
                     int(member[4][0].text),
18
                     int(member[4][1].text),
19
                     int(member[4][2].text),
20
                     int(member[4][3].text)
21
                     )
22
            xml_list.append(value)
23
    column_name:['filename', 'width', 'height', 'class', 'xmin', 'ymin', 'xmax', 'ymax']
24
    xml_df:pd.DataFrame(xml_list, columns=column_name)
25
    return xml_df
26

27

28
def main():
29
    for directory in ['train','test']:
30
        image_path:os.path.join(os.getcwd(), 'images/{}'.format(directory))
31
        xml_df:xml_to_csv(image_path)
32
        #Storing the csv file into the data directory.
33
        xml_df.to_csv('data/{}.csv'.format(directory), index=None)
34
        print('Successfully converted xml to csv.')
35

36
main()

To save the data file create another data directory in your project file, so its normally easy to organize otherwise save as you wish. But when you create the data directory, create an empty train.csv and test.csv into it. Next step is to convert the csv file to tfrecord file because Tensorflow have many functions when we use our data file in a tfrecord format. I’ve given the code below to convert the .csv to .record or .tfrecord.

1
import os
2
import io
3
import pandas as pd
4
import tensorflow as tf
5

6
from PIL import Image
7
from object_detection.utils import dataset_util
8
from collections import namedtuple, OrderedDict
9

10
flags:tf.app.flags
11
flags.DEFINE_string('csv_input', '', 'Path to the CSV input')
12
flags.DEFINE_string('output_path', '', 'Path to output TFRecord')
13
FLAGS:flags.FLAGS
14

15
def class_text_to_int(row_label):
16
    #if you working with your own classes chenge the label
17
    if row_label == 'steve jobs':
18
        return 1
19
    elif row_label == 'elon musk':
20
        return 2
21
    else:
22
        return None
23

24
def split(df, group):
25
    data:namedtuple('data', ['filename', 'object'])
26
    gb:df.groupby(group)
27
    return [data(filename, gb.get_group(x)) for filename, x in zip(gb.groups.keys(), gb.groups)]
28

29

30
def create_tf_example(group, path):
31
    with tf.gfile.GFile(os.path.join(path, '{}'.format(group.filename)), 'rb') as fid:
32
        encoded_jpg:fid.read()
33
    encoded_jpg_io:io.BytesIO(encoded_jpg)
34
    image:Image.open(encoded_jpg_io)
35
    width, height:image.size
36

37
    filename:group.filename.encode('utf8')
38
    image_format:b'jpg'
39
    xmins:[]
40
    xmaxs:[]
41
    ymins:[]
42
    ymaxs:[]
43
    classes_text:[]
44
    classes:[]
45

46
    for index, row in group.object.iterrows():
47
        xmins.append(row['xmin'] / width)
48
        xmaxs.append(row['xmax'] / width)
49
        ymins.append(row['ymin'] / height)
50
        ymaxs.append(row['ymax'] / height)
51
        classes_text.append(row['class'].encode('utf8'))
52
        classes.append(class_text_to_int(row['class']))
53

54
    tf_example:tf.train.Example(features=tf.train.Features(feature={
55
        'image/height': dataset_util.int64_feature(height),
56
        'image/width': dataset_util.int64_feature(width),
57
        'image/filename': dataset_util.bytes_feature(filename),
58
        'image/source_id': dataset_util.bytes_feature(filename),
59
        'image/encoded': dataset_util.bytes_feature(encoded_jpg),
60
        'image/format': dataset_util.bytes_feature(image_format),
61
        'image/object/bbox/xmin': dataset_util.float_list_feature(xmins),
62
        'image/object/bbox/xmax': dataset_util.float_list_feature(xmaxs),
63
        'image/object/bbox/ymin': dataset_util.float_list_feature(ymins),
64
        'image/object/bbox/ymax': dataset_util.float_list_feature(ymaxs),
65
        'image/object/class/text': dataset_util.bytes_list_feature(classes_text),
66
        'image/object/class/label': dataset_util.int64_list_feature(classes),
67
    }))
68
    return tf_example
69

70

71
def main(_):
72
    writer:tf.python_io.TFRecordWriter(FLAGS.output_path)
73
    path:os.path.join(os.getcwd(), 'images')
74
    examples:pd.read_csv(FLAGS.csv_input)
75
    grouped:split(examples, 'filename')
76
    for group in grouped:
77
        tf_example:create_tf_example(group, path)
78
        writer.write(tf_example.SerializeToString())
79

80
    writer.close()
81
    output_path:os.path.join(os.getcwd(), FLAGS.output_path)
82
    print('Successfully created the TFRecords: {}'.format(output_path))
83

84
if __name__ == '__main__':
85
    tf.app.run()

That’s great we completed the data processing! Now you need to have two files in your data folder train.record and test.record as your final output of this step.

Second Step - Creating and Training your model:

It’s a tedious process to create a convolutional net, feed your data and train it and also we cannot achieve a good accuracy when we develop the net on our own. So we are going to use Google pre-trained model called ssd_mobilenet_v1_coco. We use the model and config file of it in our project.

Link to download the files:

• ssd_mobilenet_v1_coco
• config file

Create a training folder in your project, move the config file into it. Then create another file in training folder called object_label.pbtxt which defines the labels of the class during testing the model. The object_label should contain:

1
item
2
{
3
  id: 1
4
  name: 'Steve Jobs'
5
}
6
item
7
{
8
  id: 2
9
  name: 'Elon Musk'
10
}

When you extract the ssd_mobilenet file you get all the pre-trained models. Now we have to make some changes of the config file. But in this config file I already changed it. If you want make changes for your images follow this step.

• This part in the config file describes how many classes we are going to use, since we used Steve and Elon so it’s 2; rest all remains the same.

1
sd
2
{
3
num_classes: 2
4
box_coder {
5
  faster_rcnn_box_coder {
6
    y_scale: 10.0
7
    x_scale: 10.0
8
    height_scale: 5.0
9
    width_scale: 5.0
10
  }
11
}
12
}

• Change some values in this part of config file to reduce the complexity because ssd_mobilenet is trained for 90 classes and it has high configuration values so we need not use that much value so change it.

  batch_size:15

  num_steps:300

  But remember the more you train more you get accuracy - 300 is enough for us to train .

1
train_config: {
2
  batch_size: 15 #Change the Batch size
3
  optimizer {
4
    rms_prop_optimizer: {
5
      learning_rate: {
6
        exponential_decay_learning_rate {
7
          initial_learning_rate: 0.001
8
          decay_steps: 800720
9
          decay_factor: 0.95
10
        }
11
      }
12
      momentum_optimizer_value: 0.9
13
      decay: 0.9
14
      epsilon: 1.0
15
    }
16
  }
17
  fine_tune_checkpoint: "ssd_mobilenet_v1_coco_11_06_2017/model.ckpt"
18
  from_detection_checkpoint: true
19
  # Note: The below line limits the training process to 200K steps, which we
20
  # empirically found to be sufficient enough to train the pets dataset. This
21
  # effectively bypasses the learning rate schedule (the learning rate will
22
  # never decay). Remove the below line to train indefinitely.
23
  num_steps: 300 #Number of steps to train
24
  data_augmentation_options {
25
    random_horizontal_flip {
26
    }
27
  }
28
  data_augmentation_options {
29
    ssd_random_crop {
30
    }
31
  }
32
}

• Make some path changes in this part if you require, otherwise leave it as is for this project.

1
train_input_reader: {
2
  tf_record_input_reader {
3
    input_path: "data/train.record" #path of our train record
4
  }
5
  label_map_path: "training/object_detection.pbtxt"
6
}
7

8
eval_config: {
9
  num_examples: 2000
10
  # Note: The below line limits the evaluation process to 10 evaluations.
11
  # Remove the below line to evaluate indefinitely.
12
  max_evals: 10
13
}
14

15
eval_input_reader: {
16
  tf_record_input_reader {
17
    input_path: "data/test.record" #path of our test record
18
  }
19
  label_map_path: "training/object_detection.pbtxt"
20
  shuffle: false
21
  num_readers: 1
22
}

Great! Now we made all our configuration for the project. We have to download the Tensorflow object detection API ( TensorFlow Object Detection API ) as we need only their object models, I have downloaded and it will be available at this link . Now extract the models zip file and store it in your project folder.

• Installing the model in your system: Navigate to the models directory $ cd image_android/models

Run, $ python setup.py install

Now you get all the required properties installed to run the API in your system.

• Copy the folder which I selected in the project folder and move it to the object_detection folder inside models folder.

• Then do some quiet steps for configuring protobuf and installing all necessary Library:

Note: You should be in your python virtual environment while executing these command

$ cd “PATH TO THE MODELS FOLDER” $ sudo apt-get install protobuf-compiler python-pil python-lxml $ sudo pip install pillow $ sudo pip install lxml $ sudo pip install jupyter $ sudo pip install matplotlib $ protoc object_detection/protos/*.proto —python_out=. $ export PYTHONPATH=$PYTHONPATH:pwd:pwd/slim

• All set, ready to Train your model.

$ python train.py —logtostderr —train_dir=training/ —pipeline_config_path=training/ssd_mobilenet_v1_pets.config

where, logtostderr - it defines that to store the log data

• After successful training, you can view your model reports in Tensorboard. From models/object_detection, via terminal, you start TensorBoard with: $ tensorboard --logdir='training'

Step 3 - Testing and Exporting the model:

Now we created a model which detects Steve or Elon in the image, but we didn’t see our output Here comes the testing. Before testing we should create an inference graph.

• Go to models/object_detection directory, there is a script that does this for us: export_inference_graph.py

• Run the code in your terminal:

1
python export_inference_graph.py
2
--input_type image_tensor
3
--pipeline_config_path training/ssd_mobilenet_v1_pets.config
4
--trained_checkpoint_prefix training/model.ckpt-10856
5
--output_directory steve_elon

where,

—trained_checkpoint_prefix is the latest ckpt in the training folder

—output__directory defines the directory where the inference graph should be saved

• If you get an error about no module named 'nets', go to models/,then you need to re run:

  $ protoc object_detection/protos/*.proto —python_out=. $ export PYTHONPATH=$PYTHONPATH:pwd:pwd/slim

• Now collect some images for testing, in my case I gathered about 4 images of Elon and Steve and saved in models/object_detection/test_images folder and renamed them to image1, image2 etc. iteratively.

• Run the jupyter Notebook, $ jupyter notebook

• Navigate to project models/object_detection open object_detection_tutorial.ipynb

• Make some changes in it ,the edited one is available in this link

• Run all the cell ,the final output look like this:

Cool ,at last we created a successful model now our job is to deploy in a android app.

Last Step, Deploying in Android:

Explanations:

Few important pointers that we should know:

• The core of the TensorFlow is written in c++.
• In order to build for Android, we have to use JNI(Java Native Interface) to call the c++ functions like loadModel, getPredictions, etc.
• We will have a .so(shared object) file which is a c++ compiled file and a jar file which will consist of JAVA API that will be calling the native c++. And then, we will be calling the JAVA API to get things done easily.
• So, we need the jar(Java API) and a .so(c++ compiled) file.
• We must have the pre-trained model file and a label file for the classification

Procedures:

• First clone the tensorflow android repo from this link and store in your project folder:

  git clone —recurse-submodules https://github.com/tensorflow/tensorflow.git

• Get installed Android Studio

• Download the latest version of the NDK

• Install Bazel from here . Bazel is the primary build system for TensorFlow.

• Change the version of SDK and NDK in tensorflow workspace file. The workspace file will be available in the tensorflow directory.

1
# Uncomment and update the paths in these entries to build the Android demo.
2
#android_sdk_repository(
3
#    name: "androidsdk",
4
#    api_level:23,
5
#    build_tools_version: "25.0.1",
6
#    # Replace with path to Android SDK on your system
7
#    path: "<PATH_TO_SDK>",
8
#)
9
#
10
#android_ndk_repository(
11
#    name="androidndk",
12
#    path="<PATH_TO_NDK>",
13
#    api_level=14)

Example: For SDK,

1
android_sdk_repository(
2
  name: "androidsdk",
3
  api_level:23,
4
  build_tools_version: "27.0.1",
5
  # Replace with path to Android SDK on your system
6
  path: "/Users/robinreni/Android/SDK",
7
)

For NDK,

1
android_ndk_repository(
2
  (name = 'androidndk'),
3
  (path = '/Users/robinreni/Downloads/android-ndk-r15/'),
4
  (api_level = 15)
5
)

• Create a temp_folder and create a object_label.txt and type :

Unknown Steve Jobs Elon Musk

• Copy the frozen_inference_graph.pb in steve_elon folder and move it to the temp_folder and rename it as steve_elon.pb
• Build the .so file using bazel through this command:

$ bazel build -c opt //tensorflow/contrib/android:libtensorflow_inference.so —crosstool_top=//external:android/crosstool —host_crosstool_top=@bazel_tools//tools/cpp:toolchain —cpu=armeabi-v7a

• The library will be located at:

bazel-bin/tensorflow/contrib/android/libtensorflow_inference.so Move the libtensorflow_inference.so file to the temp_folder

• Build the Java counterpart:

$ bazel build //tensorflow/contrib/android:android_tensorflow_inference_java

• You can find the JAR File at:

bazel-bin/tensorflow/contrib/android/libandroid_tensorflow_inference_java.jar Move the libandroid_tensorflow_inference_java.jar file to the temp_folder

• Now you should these file in your temp_folder:

• You have collected all your necessary resource files for your android implementation.Now open your Android Studio and Click open the existing project and navigate to : tensorflow/tensorflow/example/android and open it.You have the pre-built Tensorflow demo modues applied in the android application .

• Create an assets folder under your app project and move your steve_elon.pb(model file) and object_label.txt (label file) to it.

• Next step move your libtensorflow_inference.so and libandroid_tensorflow_inference_java.jar into your app project folder

• Click the libandroid_tensorflow_inference_java.jar and choose “Add As Library”

• Click the libtensorflow_inference.so and choose Link C++ Project with Gradle . Then a CMake dialog box opens give the path of the CMake.txt .Refer the below image

Now the .so file is built with your project. Let’s change some configurations

• Select your build.gradle file and change def nativeBuildSystem:‘none’

• Give your model path and label path to your project.Go to src>DetectorActivity.java in your project and change the path as if in the image below

• Great, thats it! Let’s check if our android app detect Elon or Steve from the image. So Click the Run option .

FINAL OUTPUT:

https://youtu.bedhGU4acR3m0

Finally you must get the result like this. If not check your code or your model.

As soon as this feature hits production, start developing this cool stuff in your mobile. If you’re stuck at any point and need help, comment in the section below and we’ll get back to you. Happy Coding! 🙂