Performance Evaluation of Low-Cost Machine Vision Cameras for Image-Based Grasp Verification

03/23/2020
by   Deebul Nair, et al.
Hochschule Bonn-Rhein-Sieg
0

Grasp verification is advantageous for autonomous manipulation robots as they provide the feedback required for higher level planning components about successful task completion. However, a major obstacle in doing grasp verification is sensor selection. In this paper, we propose a vision based grasp verification system using machine vision cameras, with the verification problem formulated as an image classification task. Machine vision cameras consist of a camera and a processing unit capable of on-board deep learning inference. The inference in these low-power hardware are done near the data source, reducing the robot's dependence on a centralized server, leading to reduced latency, and improved reliability. Machine vision cameras provide the deep learning inference capabilities using different neural accelerators. Although, it is not clear from the documentation of these cameras what is the effect of these neural accelerators on performance metrics such as latency and throughput. To systematically benchmark these machine vision cameras, we propose a parameterized model generator that generates end to end models of Convolutional Neural Networks(CNN). Using these generated models we benchmark latency and throughput of two machine vision cameras, JeVois A33 and Sipeed Maix Bit. Our experiments demonstrate that the selected machine vision camera and the deep learning models can robustly verify grasp with 97 accuracy.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 5

page 6

02/26/2020

Graphcore C2 Card performance for image-based deep learning application: A Report

Recently, Graphcore has introduced an IPU Processor for accelerating mac...
04/15/2020

Neuromorphic Eye-in-Hand Visual Servoing

Robotic vision plays a major role in factory automation to service robot...
09/18/2020

6-DoF Grasp Planning using Fast 3D Reconstruction and Grasp Quality CNN

Recent consumer demand for home robots has accelerated performance of ro...
07/01/2020

Robust navigation with tinyML for autonomous mini-vehicles

Autonomous navigation vehicles have rapidly improved thanks to the break...
07/16/2020

Camera Bias in a Fine Grained Classification Task

We show that correlations between the camera used to acquire an image an...
11/01/2017

Openmv: A Python powered, extensible machine vision camera

Advances in semiconductor manufacturing processes and large scale integr...
02/24/2019

Vision Based Picking System for Automatic Express Package Dispatching

This paper presents a vision based robotic system to handle the picking ...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

I Introduction

Grasp verification is a necessitate for autonomous robots to determine the state of the grasp while performing object manipulation. Normally robots need to perform a series of operations that depend on each other. If a task is not done correctly then the robot should re-build the operation sequence based on the occurred failure. So the robot needs to verify its action to update its knowledge about the current state. Grasp verification in robots, generally, are done using sensor’s in the gripper but this becomes challenging in the new flexible grippers. For example, in the KUKA youBot(see fig 1) we have added a parallel adaptive gripper fingers by Festo. The adaptive nature of the gripper finger makes it difficult for placing traditional sensors and to robustly determine the state of the grasp. In this paper, we propose a machine vision camera sensor based grasp verification that works by capturing images of the gripper and verifying if the grasp is successful using deep learning inference.

Fig. 1: youBot gripper with machine vision camera JeVois A33 along with the camera view.

A machine vision camera consists of an image sensor, a processor and a neural processing unit, this makes it possible to perform edge computing on the captured image. Performing inference near the data source reduces the load to transfer and process images on the centralized server. This helps in reducing the latency in processing the data and improves reliability of the overall system. Recently, deep neural networks had great improvements in solving image classification problems. This was achieved by the advent of convolutional neural networks (CNNs). Successful CNN approaches are able to solve image classification problems with an accuracy near to human [canziani2017evaluation]. However, CNNs need considerable resources of computation and memory. The idea of executing a deep learning algorithm into an embedded device has been discussed widely and solutions such as compression are provided [alizadeh2018empirical, howard2017mobilenets]. In this paper, we formulate the grasp verification problem as deep learning based image classification task. However, the two main challenges with performing deep learning inference in machine vision cameras are (i) lack of literature on the performance of these cameras and (ii) establishing a deep learning architecture that is capable to fulfill the visual classification task with satisfying accuracy reckoning the limitations of the embedded device.

In this paper, we benchmark the performance of machine vision cameras by creating a parameterized model generator which generates CNN models of varying parameters, executing them and recording performance metrics. Based on the hardware-software limitation of the machine vision cameras, the benchmarking results and the grasp verification task we select corresponding deep learning models. Finally all the grasp verification system is integrated which includes dataset collection, training and deployment of machine vision camera compatible deep learning models. To summarize, the main contributions of the paper are the performance evaluation of low-cost machine vision cameras and integration of machine vision camera with a real world robot for grasp verification tasks. We hope that the performance evaluation will drive the robotic community to apply machine vision cameras in other robotics applications.

Ii Related Work

Several researchers have studied autonomous grasping and vision based grasping. They all have pointed the importance of grasp verification in terms of the demand for autonomous capabilities and for adapting manipulation in dynamic environments. The method presented in [stansfield1991robotic] is a general-purpose robotic grasping system that is designed to work in unstructured environments. Motions of the arm and fingers are automatically generated and validated by extracting a set of features from the environment. Visual information is obtained by scanning the target object from different views. Obtained visual perceptions are processed to generate and execute the grasping task. The visual processing is also used to detect the valid grasp which is done passively.

Machine learning methods and deep learning methods were also explored. Applying deep learning methods for grasp detection is widely used in [caldera2018review]. However, deploying visual learning approaches particularly for grasp verification is not considered. A grasp system for under-actuated robotic hands is presented in [yao2009analysis]. The method outputs a grasp strategy for each object which is based on the analyses of human knowledge. Valid grasps are detected and used to control the robotic hand. This examination is done by using a well-trained neural network. The attribute parameters of the object are extracted and applied as inputs to the neural network. The result of the network is then compared with the grasp strategy decision. The approach presented in [seredynski2015grasp] is a grasp planning procedure that extracts a sequence of desired poses from the object as well as expected external forces applied to the object during the task execution. The control system presented in this work contains a grasp verification step that checks the stability of the grasp after the task execution. The approach presented in [kulkarni2019low] uses proximity sensors for grasp detection where the gripper is equipped with flexible fingers. Proximity sensors are used to measure deformation of flexible fingers due to external force and is used to detect a grasp.

Iii Machine Vision Cameras

The machine vision cameras studied in this work are Sipeed Maix Bit, JeVois A33, and OpenMV H7. Hardware aspects define capabilities on computation power, response speed, and communication capabilities. Software aspects define capabilities on which types of neural network layers and activation functions they can accept.

Fig. 2: Machine vision cameras. From left to right: Sipeed Maix Bit, JeVois A33, OpenMV H7

Iii-a JeVois A33

JeVois runs linux OS that is flashed on the micro SD memory. The firmware contains libraries such as OpenCV 4.0, TensorFlow Lite, Darknet deep neural networks, DLib, etc. JeVois can run codes written in C++ and Python. Running the 1.3 GHz CPU requires a large current flow in a smaller footprint which causes overheat issues and consequently, the need for the cooling fan. Thus, this camera consumes more power than others. The supported file format for CNN models is

tflite and all layers, activation types of TensorFlow Lite are supported.

Iii-B Sipeed Maix Bit

Sipeed Maix Bit supports MaixPy programming language which is the MicroPython language that is ported to the K210 processor. Frequently-used standard libraries plus some custom libraries, are available in MaixPy. It executes a specific format model file called kmodel. A neural network compiler called nncase111https://github.com/kendryte/nncase

converts TFLite and caffe models to corresponding kmodel format. The accelerator currently only has support for a restricted group of CNN layers and activation functions also the size of the

kmodel is limited to 5.9MiB 222https://maixpy.sipeed.com/en/libs/Maix/kpu.html.

Iii-C OpenMV H7

OpenMV camera supports MicroPython, a compact implementation of Python 3.4. OpenMV supports only a group of Python functions and class libraries. This camera accepts only model files with a special file format (.network). This type of file can be created by converting CNN models that are created by Caffe framework. The main drawback of this device arises when trying to execute custom deep learning models. After modifying the CNN architecture the conversion procedure fails as its currently not supported.

Iii-D Comparison

Even though all these cameras have capability to perform visual computing and execute deep learning models they also have differences such as processor speed, memory, power consumption, and most importantly,the neural accelerators and their capability to do deep learning inference. Table I displays general specifications of the studied machine vision cameras.

Parameter JeVois Sipeed OpenMV
Processor ARM Cortex A7 Kendryte K210 Arm Cortex-M7
41.3 GHz 400 MHz 400 MHz
32 Bit 64 Bit 32 Bit
Options GPU KPU FPU
RAM 256MB 8MB 1MB
Comm. Serial over USB USB to TTL USB Streaming
Micro Serial JTAG, ISP SPI, I2C, UART
Size [mm] 40 x 32 x 21 54 x 26 x 13 45 x 36 x 30
Power 5V, 800 mA 5V, 600 mA 3.3V, 170 mA
Image Size

Dual core Mali-400, Kendryte Processing Unit (NN Processing Unit), Floating-point Processing Unit

TABLE I: Hardware specifications of the cameras
Parameter JeVois Sipeed OpenMV
Firmware Linux MicroPython Micropython
Language Python, C++ MaixPy MicroPython
File format .tflite .kmodel .network
Accept CNNs
Accept custom CNNs
large model size
TABLE II: Software specifications of the cameras

Table II compares parameters that are essential for the task of CNN model inference. Based on the hardware software comparison, JeVois and Sipeed camera were selected for performance analysis. OpenMV camera was dropped because of the software limitation to convert custom deep learning models required for the performance analysis.

Iv Performance Analysis

We benchmark the cameras by executing different custom CNN models and standardized of-the-shelf deep learning architecture. In the first benchmark, we use a CNN model generator which generates a range of CNN models with varying number of parameters while in the second benchmark we use two standardized deep learning models MobileNet[howard2017mobilenets] and YOLO[redmon2017yolo9000]. For each experiment, the models perform inference on-board and two different performance metrics are recorded: latency and throughput. Fig 3 shows the distribution of all individual experiments with respect to the number of parameters.

Latency is computed as the 95th percentile of each inference’s timing window, or the time taken for one inference to complete and Throughput is the average inference performance computed by the total number of inferences performed within the sum of all timing windows in our case the number of inference performed per second 333https://github.com/eembc/mlmark.

Fig. 3: Distribution of number of parameters of the benchmarked models

Iv-a CNN Model Generator

CNN model generator, generates a range of CNN models by iterating through specified ranges of hyper-parameters. The resulted models vary in size, number of trainable parameters, and attributes. Two groups of CNN models are created for this experiment: one with Conv2D layers and the other with DepthwiseConv2D layers. Each model is described by the number of blocks, number of filters (only for Conv2D models), number of inputs (image size), and number of outputs. Different combinations of these hyper-parameters result in a range of models that are created and used for the experiment. Table III and IV shows the range of hyper-parameters used.

Parameter Start End Increment
Blocks 2 6 1
Filters 34 42 4
Images 16 224 52
Outputs 2 10 4
TABLE III: Hyper-parameters for Conv2D models
Parameter Start End Increment
Blocks 1 5 1
Images 64 224 32
Outputs 2 82 16
TABLE IV: Hyper-parameters for DepthwiseConv2D models

To choose these values, constraints of the devices are taken into consideration. Besides, ranges are selected such that resulting models cover a complete set with various file sizes and specifications. The first constraint is about the resulting file size that is imposed by Sipeed camera. The second constraint is that Sipeed cannot accept layer outputs that are lower than in size. Since the number of outputs decreases as layers are added to a CNN architecture, equation 1 defines a relation between hyper-parameters of input size and number of blocks.

(1)

Where is input size (images) and is the number of blocks. Another constraint is the maximum size of the input image that is again imposed by Sipeed. Based on the experiments, it can only handle models with an input image size of pixels or less. In order to achieve more comparable values, experiments on JeVois camera are done on the two processor frequencies of 1344 MHz and 408 MHz.

Fig 4 compares the latency with respect to different hyper-parameters. Image size has direct correlation on latency for both cameras. While the block size has inverse correlation for Sipeed camera. So its better to have large blocks for best performance.

Fig. 4: Latency comparison of two cameras, running Conv2D models(first row) and DepthwiseConv2D(second row).

Fig 5 and fig 6 compares throughput values with respect to the number of parameters. Throughput is inversely related to the number of parameters for Sipeed camera. In case of JeVois camera, even though there exists an inverse relation some smaller models perform bad as compared to larger size models.

Fig. 5: Throughput comparison of two cameras, running Conv2D models
Fig. 6: Throughput comparison of two cameras, running DepthwiseConv2D models

Iv-B Standard Architectures

For second set of benchmark, we selected 2 popular embedded deep learning architecture MobilNets and YOLO for performance analysis. MobileNet [howard2017mobilenets]

is a CNN architecture designed for mobile and embedded based vision applications where there is a lack of computing power. It provides high accuracy while the size of the network is relatively small. This architecture is based on depthwise separable convolutions, making it proper for building small models that can be matched to mobile and embedded vision applications. YOLO is a real-time object detection architecture designed for real-time processing. It uses a multi-scale training method to detect objects. It divides the image into a grid with bounding boxes, which are drawn around images. Predicted probabilities for each region are then calculated based on the weights that are associated with the probabilities

[redmon2017yolo9000].

Table V reports the latency and throughput values for both cameras when running MobileNet and YOLO. MobileNet deployed is of version 1 with 0.75x channel count, input image size, and quantized weights while YOLO consist of 20 classes detector with input image size pixels and quantized weights. As results show, Sipeed performs better than JeVois for both the models with respect to latency. While when comparing throughput Sipeed has higher throughput for MobileNet architecture but JeVois has higher throughput for YOLO architecture. This occurs because the last layer of YOLO is a convolution layer which increases the time taken to process the results from the final layer.

Architecture Camera Latency [ms] Throughput [fps]
MobileNet JeVois (408MHz) 397 3.3
JeVois (1344MHz) 125 7.6
Sipeed 38 26.2
YOLO JeVois (408MHz) 3275 113
JeVois (1344MHz) 1320 140
Sipeed 24 21
TABLE V: Results of standard architectures experiment

Iv-C Analysis

Based on the performance analysis, we can conclude the following (i) Latency and throughput in both the cameras are directly related to the number of parameters. (ii) Sipeed performs better in terms of latency and throughput than JeVois, this because of the dedicated CNN accelerator but can only support limited architectures, (iii) JeVois on the contrary can execute a wide range of deep learning models with comparable performance.

V Grasp Verification

Grasp verification task is formulated as an image classification problem where the camera perceives the gripper and it has to classify between 2 states ”grasped” and ”not grasped”. For this purpose the JeVois camera is mounted on the youBot gripper (see Fig

7), a custom dataset is collected, image classification is performed by using different CNN architectures, and the results are evaluated. The dataset contains more than 4000 images and sufficiently generalizes various grasping conditions.

Fig. 7: youBot gripper with mounted Jevois camera

V-a System Design

The limitations enforced by the hardware leads to a size limit on the deep learning models which in turn limits their learning capacity. This limitation of the model is compensated in the integration of the machine vision camera. The different factors considered during the integration are (i) Field of view of the camera (ii) Force to be applied on the object being grasped and (iii) Lighting condition of the environment. Field of view (FOV) of camera has a substantial impact on the complexity of the vision problem. A larger FOV causes information overload making it difficult to learn while a smaller FOV will cause loss of information required for the task. Since the major information of the grasp is in the gripper the camera is placed in such a way that the grippers are always visible during the grasp action. Force applied by the gripper has an impact on the bending of the gripper and is a good source of visual confirmation of a tight grasp therefore during the experiments the objects are grasped with the required force. Lighting conditions also affect the vision capabilities, therefore for our experiments normal industrial lighting conditions are assumed with illuminance ranging from 50 to 500 lux.

V-B Training and Evaluation

The architectures selected for evaluation are MobileNet, single block ResNet, and a custom CNN architecture based on the insights from the benchmarking experiment. Tensorflow was used to model the architectures and the training was performed offline on an Intel CPU.

V-B1 MobileNet

Fine-tuned MobileNet model is created by modifying a MobileNet model with 0.5x channel count that is pre-trained on ImageNet dataset. The last 6 layers of the model is removed, then the last 12 layers are trained on the collected dataset. The final model contains 830,562 parameters with 401,922 trainable parameters.

V-B2 Single Block ResNet

ResNet architecture follows a framework called deep residual learning that is designed to solve the problem of degradation. To turn a plain network into a residual network, shortcut connections are inserted between groups of layers [he2016deep]. For this experiment, the model is reduced to a single block ResNet architecture. Final model contains total 87,170 parameters with 85,762 trainable parameters.

V-B3 Custom CNN Models

Here two CNN models that were introduced in benchmarking are trained. These models are constructed from simple CNN blocks, they are small when compared with MobileNet or ResNet architectures. The model with Conv2D layers contains 66,194 parameters, and model with DepthwiseConv2D layers contains 248 parameters, all trainable.

(a) Grasped
(b) Not Grasped
Fig. 8: Saliency Map of MobileNet trained model, darker pixels contribute more towards prediction.
Architecture Parameter Train Validate
MobileNet Accuracy 0.98 0.97
Loss 0.03 0.12
ResNet Accuracy 0.94 0.97
Loss 0.13 0.08
Conv2D Accuracy 0.98 1.00
Loss 0.03 0.01
DepthwiseConv2D Accuracy 0.83 0.95
Loss 0.39 0.21
TABLE VI: Summary of model training
Architecture Latency [ms] Throughput [fps] Parameters
MobileNet 75 12 830,562
ResNet 140 6.9 87,170
Conv2D 160 5.8 66,194
DepthwiseConv2D 17 43 248
TABLE VII: Summary of models performance
Fig. 9: youBot performing pick action, along with the inferred grasp verification status. First row: from observer’s view, second row: from camera’s view.

MobileNet achieves 98% accuracy in training and 97% accuracy in validation. Even with larger number of parameters it has the lowest latency and throughput as compared to ResNet or Conv2D. On analysis of the saliency map as show in fig 8, we observe that the gripper curvature and gripper tip are the most important features contributing towards the decision.

V-C Evaluation of Integrated System

To investigate the performance of the trained model on the overall integrated setup, we selected several objects with varying shape, weight and texture. For each object, three distinct grasp variations were tested (i) grasping with different forces (ii) grasping with different backgrounds and (iii) grasping in varying lighting conditions. In each of these variations, the robot picks each object from different picking positions, lifts it and then verifies if the grasp was successful. Fig 9 provides an overview of a single run of the integrated system experiment. Based on the training accuracy we selected MobileNet architecture to run inference on the JeVois camera. The integrated system was able to verify the grasp for all the objects with 97% per frame accuracy and 100% per run accuracy.

Vi Conclusions and Future Work

This paper provides a vision based deep learning solution for grasp verification using machine vision cameras. We comprehensively benchmarked deep learning inference capable machine vision cameras. Based on the benchmarking results, the JeVois camera was integrated to the KUKA youBot gripper for grasp verification. The dataset collected from the integrated setup was then used to evaluate the performance of four deep learning architectures. Finally, the trained MobileNet-based grasp detection was deployed and evaluated with different test objects, in which it achieves 97% per frame accuracy and 100% per run accuracy. The dataset, generated models and other benchmarking results are openly available 444https://github.com/amirhpd/grasp_verification. One future work is to increase the capability of the network to detect other semantic information, such as grasp quality and slippage by redefining the model architecture considering the benchmarking results of the cameras.

Acknowledgment

The authors gratefully acknowledge the on-going support of the Bonn-Aachen International Center for Information Technology.

References