Exploiting Event-Driven Cameras for Spatio-Temporal Prediction of Fast-Changing Trajectories

by   Marco Monforte, et al.

This paper investigates solutions to trajectory prediction problems for artificial intelligence in robotics, to improve moving target interception, such as catching a bouncing ball. Unexpected, highly-non-linear trajectories cannot easily be solved with regression-based prediction, and as such, we look to learning methods. In addition, fast-moving targets are better sensed using recent event cameras, which produce an asynchronous output triggered by spatial change, rather than a fixed time period as with traditional cameras. We investigate how LSTM models can be adapted for event camera data, and in particular look at the benefit of using asynchronous data compared to synchronous sampling methods.



There are no comments yet.


page 1


Exploiting Event Cameras for Spatio-Temporal Prediction of Fast-Changing Trajectories

This paper investigates trajectory prediction for robotics, to improve t...

Event-based Asynchronous Sparse Convolutional Networks

Event cameras are bio-inspired sensors that respond to per-pixel brightn...

End-to-end Learning of Object Motion Estimation from Retinal Events for Event-based Object Tracking

Event cameras, which are asynchronous bio-inspired vision sensors, have ...

Continuous-Time Visual-Inertial Trajectory Estimation with Event Cameras

In contrast to traditional cameras, which output images at a fixed rate,...

Event-Based Angular Velocity Regression with Spiking Networks

Spiking Neural Networks (SNNs) are bio-inspired networks that process in...

FA-Harris: A Fast and Asynchronous Corner Detector for Event Cameras

Recently, the emerging bio-inspired event cameras have demonstrated pote...

Feedback control of event cameras

Dynamic vision sensor event cameras produce a variable data rate stream ...
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

Predictive capabilities can massively improve the safety and reliability of robots as they interact with the environment. Humans make use of predictive estimates daily, and almost in an unconscious manner, for instance when driving, playing sports or interacting with other people. A similar capability in robots could further allow them to be integrated amongst humans, and be utilised for a wider range of tasks. In addition, forecasting information about the surrounding environment can allow a robot to plan actions in advance, and in a way to compensate for insufficiency in their actuation and movement capabilities. As such, high performance robots will not be limited to robots with high-quality, highly-precise, but costly, actuators and parts.

However, the motions of many things in the environment are not easily predictable with simple extrapolation, as, for example, biological motion can be highly non-linear and sporadic. Patterns still exist in the data, but for which a simple model may not be sufficient. On the other hand, an artificial intelligence may learn such models given enough data and the correct learning tools. Training neural networks to learn to predict trajectories has been successful in gait stability for fall-risk monitoring 

[gait-stability-prediction], as well as for robot manipulator control [collaborative-hr-handover-lstm] and path planning [lstm-path-planning].

Fig. 1: The trajectory of a bouncing ball comparing the sample points for (a) a traditional camera that samples at a fixed-rate in time, and (b) an event-camera that samples with a fixed spatial-delta. The event-camera output is shown with all the pixel-wise events (in purple) as well as the output of the trajectory tracker (in blue).

To extend beyond what already exists in the field, we propose the use of event-driven cameras [ATIS]

for such kind of task. In particular, in this paper we analyse possible advantages in combining a classical deep learning strategy for sequence prediction with these new sensors. Event-driven cameras are a novel paradigm in machine vision that output a single

event for each pixel, but only when there occurs a change in the intensity of light falling on the pixel. This occurs when an object is moving in front of the camera, or at points of high contrast (e.g. edges of structure, edges of objects) when the camera itself moves. Such a technology allows a highly-compressed and low-latency (15  [ATIS]) visual trajectory of a moving target. Perhaps the biggest conceptual difference when compared to a traditional camera, is that an event-driven camera samples a target trajectory based on its change in spatial value, i.e. the sampling of the vision signal is driven by the change in position. We therefore achieve a trajectory with samples at a pixel, or sub-pixel, resolution, independently of the speed of the target. A comparison to a traditional camera, which samples at a fixed time period, is shown in Fig. 1.

Event-cameras are suited for dynamic tasks, such as camera pose estimation 

[6d0f_camera_relocalization, visual_inertial_odometry], object tracking [arren_tracker], and action recognition [ed_gesture_recog]. Visual learning has also been performed with event-data for classification [event-cnn1, event-cnn2], ego-motion computation [event-driven_ego-motion], depth estimation [event-driven_depth], and vehicle steering prediction [event-driven_steering-angle1, ed_steering_prediction]

. However, the majority of these works use convolutional neural networks (CNN) that don’t inherently represent time, which is a very informative signal for event-driven cameras.

Instead, Recurrent Neural Networks (RNN) are designed to handle and learn patterns in sequential data. One of the most important RNN was introduced in 1990 by Elman 

[elman], but as cited in [LSTM]

, the work suffered from vanishing, exploding gradients. Instead they proposed the Long Short-Term Memory networks (LSTM) 

[LSTM] to overcome this problem and become the state-of-the-art in the field of RNNs. The Encoder-Decoder - or Sequence-to-Sequence - model [seq2seq-text_transl]

achieve state of the art results in several fields like Natural Language Processing 

[seq2seq-text_transl, seq2seq-speech_recog, seq2seq-image_capt] since it can map input sequences to output ones with different length. Likewise, an Encoder-Decoder network has been combined also with a beam search algorithm for predicting vehicle trajectories [seq2seq-vehicle_trajs] towards self-driving cars. Investigating the potential for deep-learning using event cameras and LSTM models is a potentially rewarding and unexplored area of research.

In this paper we investigate the integration of event-driven data with the LSTM architecture for learning to predict the trajectory of a bouncing ball. In particular, this study investigates the affect of different sampling strategies when combined with the learning architecture: fixed-rate sampling, as performed in traditional cameras, compared with spatial-delta sampling, as is associated with event cameras. Experiments are performed using the neuromorphic iCub robot [Bartolozzi2011] equipped with the ATIS [ATIS] event camera. The ball is bounced on a table in-front of the robot and the robot, using the past ball positions, predicts the future trajectory for a given sequence.

Ii Methodology

The system is comprised of three major components:

  • The ATIS [ATIS] event camera on the iCub robot.

  • A simple trajectory tracker that converts raw pixel events to the trajectory itself.

  • The LSTM network, trained with either fixed-rate, or spatial-delta sampling.

The ATIS camera

Event-cameras have a number of interesting properties that make them an intriguing option for pushing the visual systems of artificial intelligence, but here we want to focus on the difference in the sampling strategies between standard cameras and event cameras.

Traditional cameras use a fixed-rate sampling strategy in which all the pixels are queried for the light intensity at fixed intervals (e.g. 30 Hz). Therefore the trajectory of a target viewed with a traditional camera will have different spatial positions at known time intervals, which leads to a trajectory such as in 0(a). For fast moving objects, a fixed-rate sampling strategy can lead to gaps in the trajectory as it is under-sampled.

The ATIS [ATIS] is a novel visual sensor with a resolution of pixels. Pixels produce an event when the amount of light changes beyond a threshold. Each pixel produces independent events with the following information: , where is the pixel position on the sensor, is the time the event occurred with resolution, and is the polarity (whether an increase or decrease in light occurred).

Therefore each pixel is not bound by the time it takes to read the entire array. Instead neighbouring pixels can “fire” with a very short interval between them. The effect is that a moving target will trigger each and every pixel, consecutively, that observe its trajectory. The positions of target observation are triggered by a spatial-delta, and the time at which a new observation occurs is asynchronous.

Trajectory tracking

To simplify the input to the prediction system, the raw data from the ATIS is processed to extract the mean position of the target at any point in time. The trajectory tracking is designed to reduced complications due to noise that could occur if the visual data is directly fed into the learning system, and focus on the affect of sampling strategies on the prediction.

In this work we implement a simple tracker that assumes a single moving target, see Fig. 0(b). The tracker accumulates events within a region-of-interest (ROI) of size , and then updates the position of the ROI based on the average position of events within it. As the events move along the trajectory, so to does their mean position, and therefore also the centre of the ROI. The tracker position is taken as the centre of the ROI and is output from the tracker along with the timestamp: . Initialisation is performed by setting the ROI size equal to the entire image plane on the first update, and using the standard value thereafter.

Fig. 2: Spatial and temporal error component of the sequence-to-sequence error for a pair of prediction and ground truth.

The LSTM network

The model used in this work is a Sequence-to-Sequence LSTM architecture [seq2seq-text_transl]

and consists of two separate sub-networks. The Encoder takes the input data and encodes the information in a summary vector, represented by the state of the network after the input as been fed. This output becomes the initial state vector of the Decoder, that is queried to extract the information and produce the output sequence. The decoupling between the two stages allows to input sequences with a length

different from the desired output sequence length . This can be particularly useful in tasks like machine translation or where the input and output physical domains differ, possibly requiring different representations.

Our goal in this work is to analyse how this architecture can be combined with event-based cameras for predicting the upcoming trajectory of a tracked object in an asynchronous fashion. Commonly, RNNs are queried synchronously, limited by the working rate of devices like frame-based cameras. In our case, thanks to the event-driven camera nature, the network can be queried asynchronously every time a new event is produced by the tracker. In such a way, not only it is exploited the information coming from previous queries, particularity of the RNNs family, but also the temporal information contained within the events themselves. To do so, the network is fed with a sequence comprising the spatial coordinates of the trajectory in the camera space and the time interval between the events in the sequence itself. The final outcome of the network is a prediction of the next points in space and time, which is continuously updated by querying the network for each new point produced by the tracker. The prediction consists of future spatial coordinates and, for each point, its estimated time of arrival from the current instant. We believe this spatio-temporal trajectory output to be helpful in the robotics context as it could allow the iCub to accurately plan its action, considering both space and time for planning optimal movements to make.

The Encoder architecture considered has an input layer with 3 neurons, in order to accomodate the

spatial coordinates and the temporal interval occurred from the previous input, and an output layer of 25 neurons. The Decoder architecture, on the contrary, consists of an input layer of 25 neurons to be initialised with the final Encoder state vector, and an output layer of 3 neurons outputting the future spatial position and its time of arrival.

It is fundamental to highlight that the Sequence-to-Sequence model is first fed with the whole input sequence of points and, only then, the output sequence of point is generated at the same time.

Iii Experiments and Results

Fig. 3: Complete example of a ball trajectory (in blue) with pairs of input (in green) and prediction (in purple) at different time instants.

A dataset was collected with 250 individual trajectories of the ball thrown in front of the camera and bouncing 2 or 3 times. The output of the tracker module was recorded. For independence to the direction of the trajectory, all datasets were flipped along the x-axis resulting in a total of 500 trajectories. The dataset was split into 470 training trajectories, 20 validation trajectories and 10 test trajectories. An example dataset is shown in space-time in Fig. 3.

The raw tracker data is asynchronous, but with an average frequency of over 300 Hz. To compare the effect of sampling strategies several models were trained with different strategies. Spatial-delta sub-sampling was performed by taking the first sample after pixels, according to Table I, while a fixed-rate sub-sampling was performed by taking each sample after milliseconds from the previous one. The Adam optimization algorithm [adam]

was used with a learning rate of 0.01. Dealing with a regression problem, the Mean Squared Error (MSE) was adopted as loss function. No dropout was used and the networks were trained for 200 epochs on batches of size 128.

Spatial-delta D (pxl) Mean+STD rate [Hz]
30 143
20 204
15 275
10 399
5 7518
3 12230
2 18245
- 35788

Spatial-delta sampling values with corresponding computational rate (mean and standard deviation).

Iii-a Sequence-to-Sequence Characterisation

To initially characterise some parameters of the LSTM, the prediction root-mean-square error (RMSE) error was calculated for prediction trajectories, according to trajectory spatial error and temporal error reported in to Fig. 2. The RMSE is the mean error along the entire predicted length, and not only the final position.

The error increases linearly with the output window length , meant as number of points predicted in a single network interrogation, for both the spatial error and the temporal error, see Fig. 3(b). As the network tried to predict further ahead the accuracy at which it can do so decreases. As the relationship is linear, there is no optimal point at which the network operates. The choice is therefore application specific, trading off the amount of time ahead that is needed, compared to the highest acceptable error.

The spatial error decreases the more data in the past is used, , however, after a small number of points, it starts increasing again. The temporal error instead decreases again, but at the cost of doubling the number of input points, see Fig. 3(a). In this case, a systematic operating point could be chosen to achieve the lowest error.

Considering both window analysis, the output window length was set to be 35 and the input window length was set to 10 for the following analysis.

Iii-B Sampling Strategy Comparison

Fig. 4: Spatial and Temporal RMSE for different (a) values assuming and (b) values assuming .
Fig. 5: The (a) spatial RMSE for fixed-rate and spatial-delta sampling, in which the mean sample rate of time is used to place the spatial-delta sampling, and (b) the sample rate for spatial-delta sampling over time for an example trajectory.

Secondly, a comparison between sampling strategies was made with respect to the prediction accuracy. Considering an input window of and an output window of defined by the previous windows length choice, we aim at comparing the performance of the two sub-sampling strategies on the same time intervals.

Fig. 4(a) shows the error for both sampling strategies. In order to perform a comparison, the mean sampling rate of the spatial-delta was calculated (after sampling) and used as a comparison point to the fixed-rate sampling. Fixed-rate sampling showed an inverse relationship to error. A low rate results in a high error, and as the rate increases, the error decreases. However, the benefit of increased sample rate beyond 67 Hz is minimal.

Spatial-delta sampling instead shows a more linear decrease in error with respect to sampling rate, for sample rates lower than 20 pixels. The error reaches a minimum value of 3.35 pixels for a spatial-delta of 2 pixels, compared to a value of 5.16 pixels when using a fixed 200 Hz sampling rate. Importantly, the lower error is also achieved with less processing requirements as the average rate (and hence the total number of calculations) is lower for the 2 pixel spatial-delta sampling.

The reason that the spatial-delta can give a lower error for an identical mean sampling rate, is that the spatial-delta gives a varying sample rate in time, over the length of the dataset. In periods of fast and non-linear motion, where fine detail is required to correctly trace the motion, the sample rate increases also enabling a more accurate prediction. On the other hand, when the target is moving slowly, the sample rate decreases and processing savings can be achieved. Fig. 4(b) shows an example sample rate (in time) for the spatial-delta sampling, and it can be seen that for larger spatial-deltas the sample rate becomes more constant across the dataset (a flatter profile). Indeed, for sample rates without much variation, the error is much closer to that of fixed-rate sampling, see Fig. 4(a).

Iv Conclusions

We showed that LSTM networks could be adapted for event-based data, integrating the temporal component as an input to deal with asynchronous data. The network was characterised for the ball tracking task, and it was shown that only a small input window is required to achieve a low error. On the other hand, the output window can be extended for as long as necessary, with the trade-off that the error linearly increases.

Asynchronous, spatial-delta, outperformed fixed-rate sampling when using a low spatial-step (2 or 3 pixels), which we contribute mostly to the variation in the sampling points over the course of a single trajectory.

Event cameras were the enabling technology to achieve trajectory sampling at high rates and asynchronously. Indeed, fixed-rate sampling was also only able to be performed on the event camera data, as traditional cameras can suffer from motion blur at high target speeds, leading to problems and errors in visual target tracking, see Fig. 1.

The gradient of the linear increase in error was high enough such that predicting for very long periods in front of the ball was not practical. For example in Fig. 3, it was not possible to predict the full trajectory from the initially observed points. Instead, depending on the exact constraints of the task, it could be possible to have the network learn only the final position and time of a single trajectory, rather than the full path of the trajectory. Such a network would allow the robot to intercept the ball with the correct motion timing, but not intercept the ball during the trajectory. Alternatively, directly learning to control the arm of the robot from the visual input [collaborative-hr-handover-lstm], could also be an interesting direction with event cameras.

We hope the novel contribution of combining event cameras and LSTM networks for asynchronous computation lead to further investigation for fast vision tasks in artificial intelligence and robotics.