Preparation of Papers for IEEE CSS Sponsored Conferences & Symposia

Preparation of Papers for IEEE CSS Sponsored Conferences & Symposia

Cloud Chaser: Real Time Deep Learning Computer Vision on Low Computing Power Devices

Zhengyi Luo, Austin Small, Liam Dugan, Stephen Lane
Department of Computer and Information Science, University of Pennsylvania

Abstract

Internet of Things(IoT) devices, mobile phones, and robotic systems are often denied the power of deep learning algorithms due to their limited computing power. However, to provide time critical services such as emergency response, home assistance, surveillance, etc, these devices often need real time analysis of their camera data. This paper strives to offer a viable approach to integrate high-performance deep learning based computer vision algorithms with low-resource and low-power devices by leveraging the computing power of the cloud. By offloading the computation work to the cloud, no dedicated hardware is needed to enable deep neural networks on existing low computing power devices. A Raspberry Pi based robot, Cloud Chaser, is built to demonstrate the power of using cloud computing to perform real time vision tasks. Furthermore, to reduce latency and improve real time performance, compression algorithms are proposed and evaluated for streaming real-time video frames to the cloud.

Keywords: Deep Learning, Computer Vision, real-time computing, Cloud Computing, Mobile Computing

I Introduction

With the growing success of deep learning in the field of computer vision, it is natural for developers and researchers alike to be interested in deploying these new vision algorithms in devices such as smart home cameras, robots, drones, etc. However, popular computer vision algorithms that leverage deep neural nets often require high end GPUs (Graphics Processing Units) to achieve desired performance. This constraint heavily limits the number of algorithms researchers can experiment with. To overcome this problem, researchers have tried different approaches, such as designing more efficient deep learning networks like MobileNet [1], making computing add-on modules like Intel Movidius [2], or creating dedicated chips and processors such as NeuPro by CEVA [3]

The idea of using Cloud infrastructure to aid low resource devices, is first introduced by James Kuffner [4], has inspired a number of research projects [5] [6]. As more and more Cloud Computing services provide deep learning frameworks, deep learning algorithms are becoming more accessible, especially when GPU enabled cloud machines provided by Amazon AWS, Google Cloud, Paperspace etc. are offering substantial computing power at affordable prices. Moreover, these cloud machines tend to have relatively high-bandwidth networks, making them suitable for real-time applications. For instance, the Nvidia Gaming as a Service (GaaS)[7] offers players who do not have access to high-end GPUs the opportunity to run their games in the cloud and render them on their personal devices. In this paper, we are interested in using these resources to enable low resource devices to run computationally intensive real-time computer vision algorithms. Specifically, object detection is chosen as the task for investigation.

As more and more internet of things, robotics, and mobile devices become equipped with cameras, object detection will be increasingly important as it is the foundation on which higher level tasks such as navigation, planning, and surveillance can be built. State of the art object detection algorithms all heavily rely on powerful GPUs to achieve a desirable accuracy and frame-rate. In order to achieve similar performance in low computing power devices, we offload the computing tasks to a GPU enabled cloud instance.

This paper makes the following contributions:

  • Proposing a software architecture to allow resource constrained devices to run state of the art deep learning object detection algorithms that require a GPU to achieve real time performance.

  • Utilizing multi-thread and asynchronous programming to coordinate real-time video streaming and object detection between cloud and local devices.

  • Designing and evaluating compression algorithms to reduce latency induced by offloading computing work to the cloud.

The paper is organized as follows: section II reviews the current research in the field of deep learning for object detection and other efforts in running deep neural nets on low resource devices. Section III describes the research objective and problem formulations. Section IV gives the system architecture, and Section V will describe our technical approach and methodology. System experiments and performance analysis will be in section VI, while section VII concludes the paper.

Ii Related Works

Ii-a Deep Learning Object Detection

Object Detection, different from image classification, is the task of detecting possible objects in the current image frame, as well as producing a bounding box that indicates the location of the object. State of the art object detection algorithms consists of two main approaches: region Based, such Regional-based convolutional network (R-CNN)[8] and Fast-RCNNs [9], and single-shot based You only look once (YOLO) [10] and Single shot multibox Detector (SSD) [11]. For regional proposal based approaches, they often consist of two steps: regional proposal and object classification. At first, the potential objects’ locations (bounding box) in the current scene are formulated, then a deep neural network such as a Convolutional Neural Network (CNN) are used to predict the objects’ classes. R-CNN, [8] was the first model to adopt this procedure for object detection. Fast R-CNN [9] speeds up the R-CNN model by using a single network for the whole image rather than dedicating a separate one to each region. Faster R-CNN [12] brings in near real-time performance at 5 FPS frame rate on a GPU. However, the separation of the object detection problem into both a regional proposal stage and classification stage results in complicated pipelines that significantly slow down the algorithm.

YOLO, a state of the art object detection algorithm that was introduced in 2015, pioneered the approach to unify the steps of regional proposal and object classification [13]. Due to its simple and effective architecture, YOLO can achieve comparable accuracy at more than 30 FPS. Since YOLO was first released, several improvements in speed and accuracy have since been realized in YoloV3 [14].

The advent of these real time object detection algorithms has encouraged numerous researchers to attempt to integrate them into real-time systems. However, all of these algorithms rely on powerful GPUs to achieve real-time performance. For instance, to achieve real time performance, the YOLO algorithm requires 4 GB of GPU Random-access memory (RAM), which is only available on higher gaming PCs and Laptops. On typical resource constraint devices such as mobile phones and IoT devices, most of the time discrete GPU is unavailable.

Ii-B Real Time Computer Vision On Resource Constraint Devices

Several Neural Network based approaches have been devised to cater towards real time object detection on resource constrained platforms. Many of these approaches either compress a pre-trained network like [15] or directly train a small network such as [16]. For instance, MobileNet proposes the use of depth-wise separable convolutions in order to reduce computation and model size by reducing the complexity of the convolution operation [1]. While these works do reduce space and computational complexity, a significant trade off in accuracy is present.

Though there are a few online machine learning service provider like [17] [18] [19], existing services focus on image analysis and object detection for business purposes. These services mainly depends on deriving business insight derived from image analysis, so they do not provide object detection in a desired frame rate that is suitable for real time tasks.

With state of the art object detection unable to run in real time on low resource platforms without compromising on accuracy, an opportunity exists to offload the computing workload to the cloud. Existing work attempts to measure and contrast the performance of state of the art object detection algorithms as it pertains to real time object tracking with aerial drones [20]. While this work can act as a proof of concept, practical concerns such as selection of communication protocols, image compression, and threading of tasks on the mobile platform to minimize communication latency all require significant investigation before cloud computing becomes a viable mainstream solution for real time object detection.

Iii Research Objective and Problem Formulation

To enable deep learning based computer vision on resource constrained devices, we leverage the computing power of the cloud. Using the cloud as a secondary computing unit has many advantages. First of all, cloud computing allows any device with basic WiFi capabilities to run computationally intensive deep learning neural networks. This is especially useful as popular high performance vision libraries often need a significant amount of GPU power to produce satisfying results. Another advantage is the fact that incorporating a cloud computing component requires minimal additional setup but can drastically improve the device’s capabilities. The only hardware requirement for using cloud computing in an existing device will be a reliable WiFi module.

Thus, our goal is to provide a way to integrate deep learning computer vision algorithms into low resource devices with minimal effort using cloud technologies. We are assuming the constraint of a computing unit that has the capability of communicating through WiFi but has limited bandwidth and little to no on-board computing power with which to run highly parallel deep learning algorithms. To offload real time computer vision tasks to the cloud, a low-latency communication architecture is designed, implemented, and tested. In order to test the performance of the system, we have selected object detection tasks as the main objective for this work.

Iv System Architecture

Fig. 1: System Architecture

To enable offloading the heavy computation tasks to the cloud, a novel architecture is proposed, as shown in Fig. 1. The architecture consists of two main parts: the client side, which resides on the mobile device and handles the image data transmission, and the server side, which runs on the cloud instance and executes the object detection algorithms.

Server Side

The server side is made of three main components, the Asyncio Server, the Local Asyncio Rebroadcast Server, and the Deep Learning Object Detector.

  • Asyncio Server: runs two separate websocket servers for communicating with the client. The first server receives the incoming JPEG stream from the device, while the second server reads the results from the object detector and sends data to the client device.

  • Local Asyncio Rebroadcast Server: receives the JPEG stream from the Asyncio Server and rebroadcasts the images using MJPEG protocol.

  • Deep Learning Object Detector: analyzes the rebroadcast MJPEG frames, and uses YOLO-based deep learning object detection algorithms to recognize objects in the current frame.

Client Side

The client side is made of four main components, the OpenCV Camera Capture component, the on device image compression component (Local Compression), the Asyncio Client component, and the device Action component.

  • OpenCV Camera Capture: uses OpenCV CvCapture library to capture image output from the device camera.

  • Local Compression: processes raw image data from camera and compresses it to reduce file size, then encodes the raw image data into JPEG images.

  • Asyncio Client: runs two separate websocket clients and communicates with the server. The first client sends the image data to the server continuously, and the second receives object detection data from the server.

  • Action: reacts to the detected object in the scene.

Pipeline Workflow Overview

Our proposed pipeline contains the above components and uses multiple threads to ensure parallel execution. Each image frame captured by OpenCV Camera Capture from the device camera is compressed by Local Compression. Then the compressed image is encoded in JPEG format and sent to the server by the websocket through the Asyncio Client. After the cloud Asyncio Server receives the image frame, it shares the image with Local Asyncio Rebroadcast Server for rebroadcasting the frame as a MJPEG stream. The Deep Learning Object Detector accepts the image frames and detect the objects in it. After detection is finished, the cloud Asyncio Server reads it from the object detection algorithm, and sends the detection as a string through websocket to the client. The device Asyncio Client receives the object information and sends it to the Action component for reaction.

V Technical Approach

V-a Real Time Video Streaming and Compression

To stream real time video frames to the cloud from a local device to the cloud for analysis, we propose the following approaches to the corresponding challenges:

Communication Protocol

To enable real-time performance, the communication protocol needs to be low level enough that it introduces minimal latency. Specifically, we chose websocket as our main communication protocol. Another option to ensure the lowest possible network latency is raw TCP, but the direct use of TCP has limited speed advantage. Websocket allows multiple connections to a single server, and is easy to use in an existing web framework like the python aiohttp library. Since websocket ensures easy interfacing with the rest of the application, while also providing a more secure interface for the streamed video frames (WSS protocol encrypts streams using HTTPS) it was the best choice for our use case.

Network Address Translation

In order to stream a MJPEG video stream through the network, existing programs usually set up a HTTP web server on local devices and access the video stream through the device’s assigned IP address. However, for security reasons, Internet of Things devices and mobile devices are often assigned private IP addresses that are unreachable from outside of the private network. Naturally, a cloud machine is outside of the local network, thus making traditional streaming schemes unusable for our purposes.

Some users with administrative privileges on their routers can circumvent this problem through enabling port forwarding, which is a router setting that allows a user to open up specific ports on their routers to allow public access. However, this approach is not possible on public networks where common users do not have administrative privileges. Additionally, some routers do not support port forwarding.

To make the device’s video stream accessible from the cloud machine, as well as to avoid running a separate MJPEG server on our device, our system proposes the following solutions: instead of setting up a MJPEG server directly on the device, camera frames captured from the device are sent to the server via an established websocket connection between server and device. Local devices, though not accessible from public networks, can establish bi-directional websocket connections with the server. Thus, the client can send video frames through the websocket directly to the server, and the server can then rebroadcast the frames using the MJPEG protocol, which is then consumed by object detection algorithms.

Network Latency and Compression

Due to the limited bandwidth of WiFi networks, we propose several compression approaches in order to reduce the size of the data transmitted and reduce latency.

  • Camera resolution: by reducing the camera capturing resolution from 960 * 540 to 480 * 270, we cut down the number of pixels transmitted by a factor of 4.

  • Blurring the image: by applying a blur effect on the image, we improve the JPEG compression algorithm’s efficiency, and effectively cut down the data size transmitted.

  • Blacking out: by using the temporal data from the previously processed frame, we are able to identify known objects and black out all regions of the image which do not contain objects. This approach assumes that objects do not change their relative position drastically between frames, and by leaving a buffer region on the object bounding box (15px margin), the detection algorithm can still identify the existing objects in the new frame. To detect new objects that may appear in the current scene, a complete, not blacked out frame is periodically sent for detecting new objects. File size reduction and latency reduction from the above approaches are outlined in the experiment section.

V-B Asynchronous and Multi-threaded Computing

In our architecture, the local device needs to send a video stream continuously while receiving detection results from previous frames. The cloud service also receives and rebroadcasts each frame to localhost for deep learning object detection algorithms. On top of that, the cloud needs to start the object detection process on demand and read results from the process. To achieve these goals, asynchronous programming and multi-threading are heavily utilized in our system.

On the cloud/server side, three different threads run in parallel. One thread runs a websocket server for receiving the video stream. Within this thread, the rebroadcast server asynchronously broadcasts the video stream, exposing it as a MJPEG stream on localhost. These two processes communicate through shared variables. A second thread runs a websocket server which starts the deep learning object detector as the third thread. This websocket server then reads the output from the deep learning object detector, and sends it back to the client.

On the client/device side, three different threads are also initiated to ensure parallel computing. The first thread runs a websocket client dedicated to capturing, compressing, and sending a continuous real-time video stream to the server. The second thread also hosts a websocket client that receives the object detection result from the server in a non-ending loop. Finally, a third thread reads the information from the second websocket thread, and reacts to the results from the cloud object detector.

V-C Deep Learning Object Detection

Deep learning based object detection algorithms have gained significant traction due to their rapidly improving performance on some of the most well-known image classification datasets such as ImageNet and COCO. For this work, we mainly focus on adapting the YOLO[13] object detection algorithm to a cloud computing friendly configuration, which is shown as the Deep Learning Object Detector in Fig. 1.

Taking an input frame from the MJPEG stream provided by the Local Asyncio Rebroadcast Server as shown in Fig. 1, the image frame will first be resized to fit the network parameters, and then go through the following calculations to predict the current objects and their location in the scene. The problem formulation is as follows.

  • An image is broken up into an SxS grid of cells (S = 7 in our case), where each cell is responsible for producing B (B = 5) bounding boxes. A bounding box represents a potential object in the scene. If the center of an object lies within a cell, that cell is responsible for generating the object’s bounding box.

  • Each cell predicts the conditional probability which represents the probability that the object in a grid cell is of , given that an object is present in the cell.

  • For each bounding box, five predictions, (x, y, w, h, c) are produced, where (x, y) represents the center of the predicted bounding box of an object, (w, h) represents the width and height of the bounding box, and c represents the confidence. The confidence score c is calculated as formula (1), where c represents object class specific confidence in a bounding box, meaning how likely a bounding box is to contain class i as well as how well the bounding box fits the object.

    (1)

    where IOU stands for Intersection over Union, which is the area of overlap divided by the area of union between the detected bounding box and the ground truth bounding box.

An image frame goes through a Convolutional Neural Network (CNN) shown in Fig. 2 to predict the (x, y, w, h, c) as formulated above. The neural network contains 24 convolutional layers and then 2 fully connected layers. This network was inspired by GoogleLeNet model for image classification [21]. Unlike GoogLeNet, reduction layers followed by convolutional layers are used. The output of the CNN is then fed into to the Asyncio Server, where it will be transferred to the client.

Fig. 2: Neural Network Architecture for Deep Learning Object Detector

For our application, the Deep Learning Object Detector is trained on the Microsoft COCO dataset, which contains pictures of 80 objects. The object detector is run as a subprocess of the server side program, as shown in Fig. 2, and the output of the detector is framed as (x, y, c, w, h). The confidence threshold is set at 50. Essentially, for each detected object in each frame that has a confidence greater than 50, the subprocess will output a text line giving its prediction.

The advantage of using this construction lies in its speed and accuracy. By unifying the step of regional proposal and object classification, the final classification can be computed by one pass of the network, making the algorithm applicable to real-time applications with state of the art accuracy. Combining the high performance of YOLO with our cloud computing system, resource constrained devices can make use of this object detection system with minimal additional setup or hardware.

Vi Experiments

Cloud Chaser [22], shown in Fig. 3. was built to demonstrate the viability of our approach. It is our custom Raspberry Pi based robot capable of following voice commands, recognizing 80 different kinds of common objects in real time, and tracking these objects in real-time (thus the name ”Cloud Chaser”).

Using Cloud Chaser, three sets of experiment are conducted to demonstrate the viability of our approach. First, the communication latency introduced by offloading critical computation to the cloud is timed and calculated. Further, we timed the compression algorithms that are intended to reduce communication latency. Three compression algorithms are considered: averaging the captured image without reducing resolution, reducing captured image resolution, and blacking out parts of the image that are considered ”uninteresting”. Last but not least, to demonstrate the adaptability of our platform, an iOS app is developed to showcase our architecture running on different devices.

Vi-a Experiment Settings

Our cloud instance is configured as follows

  • Oct Core Intel(R) Xeon(R) CPU E5-2623 v4 @ 2.60GHz, 32 GB RAM, Ubuntu 16.04.4 LTS

  • Paperspace Network

  • Nvidia Quadro P4000, 8GB Dedicated Video RAM

Cloud Chaser, our custom built robot shown in Fig. 3, has the following specs:

  • Quad Core 1.2GHz Broadcom BCM2837 64bit CPU, 1GB RAM, Raspbian GNU/Linux 9.4 (stretch)

  • BCM43438 wireless LAN

  • CSI camera port for connecting a Raspberry Pi camera

Vi-B Real-Time Communication Latency

The latency induced by enabling our program can be broken into three parts: latency introduced by traveling through physical space when sending packets, latency introduced by limited bandwidth when sending data to cloud instance and sending back prediction, and the time it took for YOLO to process the image and produce prediction. We tested these latencies separately and in combination.

Fig. 3: Cloud Chaser and cloud based real time object detection. The right image showcases a screenshot of real time objects being recognized from the Paperspace cloud instance.
{tabu}

to 0.8 — X[c] — X[c] — X[c] —  Timing Difference & Sunnyvale to San Francisco (41.5 mi) & Sunnyvale to New York (2,937.8 mi)
TCP & 0:00:00.023089 & 0:00:00.092086
Websocket & 0:00:00.024619 & 0:00:00.094308

TABLE I: Time for round trip websocket communication, data size 26 bytes, taking the average of 2000 round trips
{tabu}

to 0.8 — X[c] — X[c] — X[c] —  Timing Difference & Sunnyvale to San Francisco (41.5 mi) & Sunnyvale to New York (2,937.8 mi)
Websocket & 0:00:00.076612 & 0:00:00.210735

TABLE II: Time for round trip websocket communication, data size 13500 bytes, taking the average of 2000 round trips
{tabu}

to 0.8 — X[c] — X[c] — X[c] — X[c] —  Time & Total Delay & Time & Total Delay
8:00 AM & 0:00:00.562203 & 6:00 PM & 0:00:00.651300
11:00 AM & 0:00:00.687919 & 9:00 PM & 0:00:00.756316
3:00 PM & 0:00:00.585435 & 12:00 AM & 0:00:00.494050

TABLE III: Time between frame of person showing up and detection
Fig. 4: Prediction By Different Compression Approaches
{tabu}

to 0.8 — X[c] — X[c] — X[c] —  & Compressed (averaging) & Original
Latency & 0:00:00.522536 & 0:00:00.651300
Average File Size & 14989 & 17740

TABLE IV: Image resolution 480 * 270, file size in bytes

Table I makes clear the time for a small packet to be sent from the local device (Raspberry Pi) to the server by calculating the round trip delay. From the data we conclude that using websocket against TCP introduces negligible additional delay(1ms) compared to the delay introduced by YOLO running at 15 FPS (60ms).

To time the latency introduced by limited bandwidth, we encoded a string of length 13500 bytes, which is the average size of a 480 * 270 byte JPEG image. The delay introduced by sending this data packet through the network is shown in Table II.

To time the combined latency of object detection and network communication, a picture of a person shown in Fig. 4(a). is used as a token. First the camera is facing a black plane where no object is detected in the scene. After a few seconds the program swaps out the camera feed for the JPEG picture which is read from memory (counting the time to recompress the picture into JPEG format) and sent for detection. This effectively simulates the procedure of capturing, sending, and detecting a person in the current scene. The time when YOLO first detects the presence of a person is recorded. The results from five different times of day are shown in Table III. While YOLO can run at an average frame rate of 15 FPS on our machine, the additional delay time between the picture event occurring on the local machine and cloud detection is caused by the following factors: 1) Network Congestion, where the cloud instance can not process the image frames sent from local devices as quickly as the local devices can send them, and 2) The video compression and decompression time taken by OpenCV on both the cloud instance and local device. Overall, by offloading the object detection from the local device, less than half of a second delay is introduced on the original performance of the object detection algorithm. Equipped with better GPU enabled cloud instance, the latency can be reduced even further.

Vi-C Compression Algorithms Evaluation

In order to reduce the bottle-neck of transmission, we tried a few different compression schemes to reduce the amount of data that needed to be transmitted.

Averaging

Applying an averaging filter to the picture has the effect of reducing the sharpness of the picture, as shown in Fig.4(b). The effect on file size and latency reduction of applying an averaging filter with each pixel weighted by 0.04 and averaging every 5 by 5 grids is shown in Table IV. Even though the image remains the same resolution after averaging, a blurred image will benefit more from JPEG compression and will thus take less data to transmit.

As a side effect of blurring this image we observe a reduction in accuracy on the our object detector. Our experiment showed that blurring using this kernel will reduce the mAP (Mean Average Precision) for YOLOv3 from 0.7465 to 0.6426 on the 2007 Pascal VOC dataset.

{tabu}

to 0.8 — X[c] — X[c] — X[c] —  & 960 * 540 & 480 * 270
Latency & 0:00:00.522536 & 0:00:00.651300
Average File Size & 73198 & 17740

TABLE V: Image resolution 960 * 540 vs 480 * 270, file size in bytes
{tabu}

to 0.8 — X[c] — X[c] — X[c] —  & Original & Blacked Out
Latency & 0:00:00.651300 & 0:00:00.651300
Average File Size & 17740 & 14418

TABLE VI: Image size original vs blacked out 480 * 270, file size in bytes

Reduction on Resolution

Reducing the resolution from 960 * 540 to 480 * 270 results in both a file size reduction and latency reduction as shown in Table V. The affect of this reduction is shown in Fig.4(c).

Blacking out

The size reduction effect of blacking out an image is shown in Table VI. As shown in Fig. 4(d), blacking out the uninteresting part of the image still results in the correct detection of the object in the current frame, assuming the location of objects do not change drastically between frames.

Vi-D Platform Adaption

To test the viability of this approach on other platforms, an iOS app is developed. Combined with the spacial mapping capability of the ARkit, the app demonstrates the ability to identify and label objects in a scene in real time. To demonstrate the real time object localization capability of the app, please refer to our short video [23].

Through these experiments, we have demonstrated that using the GPU-enabled cloud machines to carry out the deep learning object detection tasks is a viable, easy to setup, and easy to adapt approach. A variety of devices and platforms will be able to implement this architecture and make use of state of the art deep leaning object detection algorithms in real time.

Vii Conclusion and Future Work

In this work, we present a novel architecture to integrate existing deep learning computer vision algorithm to resource constraint devices. As opposed to designing a new neural network that can be run on resource constraint devices, this approach runs the existing state of the art neural networks in the cloud and utilizes the wireless networking capabilities of the device to ensure real time performance. Since the full neural network is run in the cloud, there is little compromise on accuracy. Also, by utilizing multi-threading and asynchronous computing, coupled with compression algorithms for image size reduction, the latency introduced by streaming data to the cloud is reduced to minimum. Finally, as demonstrated in our experiment, devices with camera and WiFi capability can be easily adapted to use our approach for deep learning computer vision, allowing rapid prototyping for researchers and developers alike.

In the future, we hope to develop a more robust communication scheme for streaming camera data from the device to the cloud. Also, we look forward to adapting more deep learning algorithms to this system, allowing resource constrained devices to utilize real time deep learning for a greater range of tasks.

References

  1. Andrew G. Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. CoRR, abs/1704.04861, 2017.
  2. Intel Movidius: cutting edge solutions for deploying deep learning and computer vision algorithms right on-device at ultra-low power. https://www.movidius.com. Accessed: 2018-06-02.
  3. CEVA NeuPro: a family of ai processors for deep learning at the edge. https://www.ceva-dsp.com/product/ceva-neupro/. Accessed: 2018-06-02.
  4. James Kuffner, Cloud Robotics, The Google, Kiva Systems, Steve Cousins, Willow Garage, Online Robots, Networked Robots, Mechanical Turk, The Cloud, World Wide Web, The Roboearth, and Industrial Internet. Cloud Robotics and Automation. pages 1–9, 2012.
  5. Guoqiang Hu, Wee Peng Tay, and Yonggang Wen. Cloud robotics: Architecture, challenges and applications. IEEE Network, 26(3):21–28, 2012.
  6. Ken Goldberg and Ben Kehoe. Cloud robotics and automation: A survey of related work. Technical Report UCB/EECS-2013-5, EECS Department, University of California, Berkeley, Jan 2013.
  7. Nvidia Cloud Gaming: cloud gaming – gaming as a service (gaas). http://www.nvidia.com/object/cloud-gaming.html. Accessed: 2018-06-02.
  8. Ross B. Girshick, Jeff Donahue, Trevor Darrell, and Jitendra Malik. Rich feature hierarchies for accurate object detection and semantic segmentation. CoRR, abs/1311.2524, 2013.
  9. Ross B. Girshick. Fast R-CNN. CoRR, abs/1504.08083, 2015.
  10. Joseph Redmon, Santosh Divvala, Ross Girshick, and Ali Farhadi. You Only Look Once: Unified, Real-Time Object Detection. 2015.
  11. Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, Scott Reed, Cheng Yang Fu, and Alexander C. Berg. SSD: Single shot multibox detector. Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), 9905 LNCS:21–37, 2016.
  12. Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun. Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks. IEEE Transactions on Pattern Analysis and Machine Intelligence, 39(6):1137–1149, 2017.
  13. Joseph Redmon, Santosh Kumar Divvala, Ross B. Girshick, and Ali Farhadi. You only look once: Unified, real-time object detection. CoRR, abs/1506.02640, 2015.
  14. Joseph Redmon and Ali Farhadi. Yolov3: An incremental improvement. CoRR, abs/1804.02767, 2018.
  15. Min Wang, Baoyuan Liu, and Hassan Foroosh. Factorized convolutional neural networks. 2017 IEEE International Conference on Computer Vision Workshops (ICCVW), pages 545–553, 2017.
  16. Forrest N. Iandola, Matthew W. Moskewicz, Khalid Ashraf, Song Han, William J. Dally, and Kurt Keutzer. Squeezenet: Alexnet-level accuracy with 50x fewer parameters and <1mb model size. CoRR, abs/1602.07360, 2016.
  17. Google Vision API : cloud vision api provides a comprehensive set of capabilities including object detection, ocr, explicit content, face, logo, and landmark detection. https://cloud.google.com/vision/. Accessed: 2018-06-02.
  18. Amazon Rekognition – Video and Image - AWS: amazon rekognition makes it easy to add image and video analysis to your applications. aws.amazon.com/rekognition. Accessed: 2018-06-02.
  19. Clarifai : drive revenue with computer vision ai. www.clarifai.com/. Accessed: 2018-06-02.
  20. Jangwon Lee, Jingya Wang, David J. Crandall, Selma Sabanovic, and Geoffrey C. Fox. Real-time, cloud-based object detection for unmanned aerial vehicles. 2017 First IEEE International Conference on Robotic Computing (IRC), pages 36–43, 2017.
  21. Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. Proceedings of the IEEE Computer Society Conference on Computer Vision and Pattern Recognition, 07-12-June-2015:1–9, 2015.
  22. Cloud Chaser: cloudchaser is a custom built, cloud-based robot that uses computer vision to target and chase user-specified objects. https://devpost.com/software/cloudchaser. Accessed: 2018-06-02.
  23. Cloud Chaser iOS: object detection + localization through deep learning + arkit. https://youtu.be/hB1dj2lU5Tk. Accessed: 2018-06-02.
Comments 0
Request Comment
You are adding the first comment!
How to quickly get a good reply:
  • Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
  • Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
  • Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
""
The feedback must be of minimum 40 characters and the title a minimum of 5 characters
   
Add comment
Cancel
Loading ...
297501
This is a comment super asjknd jkasnjk adsnkj
Upvote
Downvote
""
The feedback must be of minumum 40 characters
The feedback must be of minumum 40 characters
Submit
Cancel

You are asking your first question!
How to quickly get a good answer:
  • Keep your question short and to the point
  • Check for grammar or spelling errors.
  • Phrase it like a question
Test
Test description