Application-level Studies of Cellular Neural Network-based Hardware Accelerators

TL;DR

This paper evaluates cellular neural network (CeNN)-based hardware accelerators at the application level, demonstrating significant energy-delay improvements while maintaining accuracy comparable to traditional algorithms.

Contribution

It introduces an evaluation framework for CeNN-based accelerators and provides a case study comparing CeNN and von Neumann algorithms at the application level.

Findings

CeNN-based approach matches the accuracy of the von Neumann algorithm.

CeNN offers approximately 1000x improvements in energy-delay product.

The study quantifies energy, delay, and accuracy metrics for CeNN hardware.

Abstract

As cost and performance benefits associated with Moore's Law scaling slow, researchers are studying alternative architectures (e.g., based on analog and/or spiking circuits) and/or computational models (e.g., convolutional and recurrent neural networks) to perform application-level tasks faster, more energy efficiently, and/or more accurately. We investigate cellular neural network (CeNN)-based co-processors at the application-level for these metrics. While it is well-known that CeNNs can be well-suited for spatio-temporal information processing, few (if any) studies have quantified the energy/delay/accuracy of a CeNN-friendly algorithm and compared the CeNN-based approach to the best von Neumann algorithm at the application level. We present an evaluation framework for such studies. As a case study, a CeNN-friendly target-tracking algorithm was developed and mapped to an array architecture developed in conjunction with the algorithm. We compare the energy, delay, and accuracy of our architecture/algorithm (assuming all overheads) to the most accurate von Neumann algorithm (Struck). Von Neumann CPU data is measured on an Intel i5 chip. The CeNN approach is capable of matching the accuracy of Struck, and can offer approximately 1000x improvements in energy-delay product.

Figures

Tables

Table 1. TABLE I: Time and energy for CeNN in each step

Operations	Time/frame ($\mu$s)	OTA power ($\mu$W)	Total power ($\mu$W)	Energy per frame ($\mu$J)
Init	$7.5$	$1.5$	$1.58$	$0.0081$
DIFFUS1	$7.5$	$1.5$	$1.58$	$0.0081$
Init	$7.5$	$1.5$	$1.58$	$0.0081$
DIFFUS2	$7.5$	$1.5$	$1.58$	$0.0081$
SUB	$7.5$	$3.0$	$3.08$	$0.0158$
DIFFUS3	$25$	$1.5$	$1.58$	$0.027$
Init	$0.3$	$1.5$	$1.58$	$0.0324$
THRES	$0.3$	$3.0$	$3.08$	$0.0781$
LOGAND	$0.3$	$6.0$	$6.08$	$0.154$
RECALL	$35.2$	$21.8$	$21.8$	$64.9$
SHADOWL	$35.2$	$9.0$	$9.08$	$27$
Init	$0.3$	$1.50$	$1.58$	$0.00324$
SHADOWD	$24$	$9.0$	$1.58$	$18.4$
DILATION	$1.6$	$13.5$	$13.6$	$1.84$
Total/frame	$160$		$76.9$	$112$
Total (all frames)	$0.306$s			$0.216J$

Equations

$$C\frac{d{x}_{ij}\left(t\right)}{dt}$$

$$+\sum _{C_{kl}\in N_r\left(i,j\right)}{b}_{ij,kl}{u}_{kl}+Z$$

Full text

I Introduction

As Moore’s Law-based device scaling/accompanying performance scaling trends slow, there is continued interest in new technologies and computational models to perform a given task faster and more energy efficiently [1, 2]. Furthermore, there is growing evidence that, with respect to traditional Boolean circuits, it will be challenging for emerging devices to compete with CMOS technology. [1, 2, 3].

Researchers are increasingly looking for new ways to exploit the unique characteristics of emerging devices (e.g., non-volatility) as well as architectural paradigms that transcend the energy efficiency wall. In this regard, cellular neural networks (CeNNs) are now under investigation via the Semiconductor Research Corporation’s benchmarking activities [3, 4] as (i) they can solve a broad set of problems [5] (e.g,. image processing, associative memories, etc.), and (ii) can exploit the unique properties of both spin- and charge- based devices [2, 6]. However, we must consider what application spaces/computational models might benefit from CeNNs, and if CeNNs outperform other alternative architectures/models, for the same problem, at the application-level.

We have developed a framework for evaluating CeNN co-processors to quantitatively assess CeNNs at the application-level. (i) We begin with algorithm development where processing tasks are mapped to CeNNs or more conventional CPUs/GPUs (e.g., for image recognition, CeNNs can be highly efficient for feature extraction tasks given the architecture’s parallel nature; for more mathematical operations, CPUs may be more efficient.) (ii) Next, given the analog nature of a CeNN, and the inherent nature of inference applications, algorithmic accuracy must be evaluated at multiple levels (e.g., we must address overall algorithmic quality, and any impact on algorithmic quality due to lower precision hardware.) Algorithmic refinement may be needed. (iii) Algorithms must then be mapped to a suitable hardware architecture (e.g., parallel CeNNs vs. a CeNN that is used serially). Again, algorithm refinement may be necessary. (iv) Finally, we must compare energy, delay, and accuracy projections to the best von Neumann algorithm for the same application-level problem.

As a case study, we have developed a CeNN-based target tracking algorithm to complete an application-level case study. Target tracking is a fundamental component of many computer vision applications [7]. We have also developed a CeNN array architecture for our algorithm with analog CeNN circuitry, analog-to-digital (ADC) and digital-to-analog (DAC) converters, and an 8-bit register. We compare our approach to the best reported von Neumann algorithm in terms of energy, delay, and accuracy. Per [7], we have identified the best von Neumann algorithm (Struck [8]) for images sequences in the VisualTracking.net benchmark suite [9]. Our CeNN-based approach (with ADC/DAC overheads, etc.) is competitive with Struck in terms of accuracy, and improvements in energy-delay products (EDP) can be $>$1000X. Finally, we show how our algorithm can be tuned such that a CeNN approach becomes competitive for sequences where Struck has superior accuracy.

II Background

We review CeNNs and prior work with tracking algorithms.

II-A Cellular Neural Networks

A spatially invariant CeNN architecture [5] is an $M\times N$ array of identical cells (Fig. 1a). Each cell, $C_{ij}$, $(i,j)\in\{1,...,M\}\times\{1,...,N\}$, has identical connections with adjacent cells in a predefined neighborhood, $N_{r}(i,j)$ of radius $r$. The size of the neighborhood is $m=(2r+1)^{2}$, where $r$ is a positive integer. A conventional analog CeNN cell consists of one resistor, one capacitor, $2m$ linear VCCSs, one fixed current source, and one specific type of non-linear voltage controlled voltage source (Fig. 1b). The input, state, and output of a given cell $C_{ij}$, correspond to the nodal voltages, $u_{ij}$, $x_{ij}$, and $y_{ij}$ respectively. VCCSs controlled by the input and output voltages of each neighbor deliver feedback and feedforward currents to a given cell. The dynamics of a CeNN are captured by a system of $M\times N$ ordinary differential equations, each of which is simply the Kirchhoff’s Current Law (KCL) at the state nodes of the corresponding cells per Eq. 1.

[TABLE]

CeNN cells typically employ a non-linear sigmoid-like transfer function [10] at the output to ensure fixed binary output levels.

The parameters $a_{ij,kl}$, and $b_{ij,kl}$ serve as weights for the feedback and feedforward currents from cell $C_{kl}$ to cell $C_{ij}$. $a_{ij,kl}$, and $b_{ij,kl}$ are space invariant and are denoted by two $(2r+1)\times(2r+1)$ matrices. (If $r=1$, they are captured by $3\times 3$ matrices.) The matrices of $a$ and $b$ parameters are typically referred to as the feedback template ($A$) and the feedforward template ($B$) respectively. Design flexibility is further enhanced by the fixed bias current $Z$ that provides a means to adjust total current flowing into a cell. A CeNN can solve a wide range of image processing problems by carefully selecting the values of the $A$ and $B$ templates (as well as $Z$).

Various circuits including inverters, Gilbert multipliers, operational transconductance amplifiers (OTAs), etc [11, 12] can be used to realize VCCSs. We use the OTA design from [13]. OTAs provide a large linear range for voltage to current conversion, and can implement a wide range of transconductances allowing for different CeNN templates.

II-B Target Tracking

Given the initial position/size of a target object in a frame, a tracking algorithm should determine the position/size of the object in subsequent frames. Many studies have been performed to track objects in different scenarios [14, 15] (e.g., occlusion, illumination variation, etc. [7]). Target tracking remains a challenging problem in computer vision as varying scene dynamics need to be reconciled in a single algorithm.

Work in [16, 17] initially considered CeNN-based trackers where CeNNs performed pixel-level computation, and a digital signal processor processed remaining information. However, [16, 17] do not present a thorough energy/delay study. Moreover, [16, 17] use a predefined sequence of kernels, and object tracking is based primarily on motion and change detection. While this may be useful if an object is moving continuously before a fixed background, these methods are not as general if used as a learning system. As we will show in Sec. IV, our approach can select the optimal template sequences from a larger set in runtime based on the features of the tracked object, and the features of the background.

When considering algorithms for von Neumann machines, convolution neural networks have been proposed to learn discriminative features or to help in the extraction of the discriminative saliency map [15, 18]. The outputs from a hidden layer can be used as feature descriptors. The Struck algorithm [8] that we compare to is an adaptive tracking-by-detection methods for single target tasks. This is fundamentally an object recognition problem that places significant constraints on training/learning an object model. A tracker is initialized with a single bounding box provided as a ground truth for the starting frame of a video sequence. After initialization, the tracker maps each input frame to an output bounding box containing the predicted location of the object in that frame. Struck uses a kernelized, structured, output support vector machine to provide adaptive tracking. It is well suited for drastic appearance changes for a tracked image in a given image sequence, and has the highest reported accuracy for the dataset that we use to evaluate our CeNN-based approach [7].

To quantify accuracy, in this paper, we use a success plot to evaluate the bounding box overlap [7]. Given a tracked bounding box $r_{t}$ and the ground truth bounding box $r_{a}$, the success plot is defined as $S=\frac{|r_{t}\cap r_{a}|}{|r_{t}\cup r_{a}|}$, where $\cap$ and $\cup$ represent the intersection and union of two regions, respectively.

III Cellular neural network system

Here, we discuss our CeNN-based co-processor and a framework for mapping a problem to such a co-processor.

III-A A CeNN-based co-processor

The architecture and the processing unit schematics for our CeNN-based system are shown in Fig. 2. Analog input signals (e.g., from sensors) are provided to the CeNN based co-processor. The CPU calls the co-processor to execute a given task/template by asserting a control signal. After processing, the CeNN based hardware accelerator generates an analog output which can either be converted to a N-bit digital signal and communicated with the CPU, or can be reused as an analog input to itself for further processing. Since each cell might need to send/receive data to/from the CPU, some mechanism is required to schedule the data movement. Each processing unit consists of a N-bit analog-to-digital converter, an analog CeNN cell, an analog multiplexer, and a N-bit register. The analog multiplexer selects a signal either from the external environment, or the analog CeNN cell itself. The analog CeNN cell is as described in Sec. II-A.

III-B A framework for evaluation

We now discuss an evaluation framework (see Fig. 3) to quantify the benefits of a CeNN co-processor. We must first develop an algorithm that: (i) is suitable for CeNN hardware, and (ii) achieves the same functionality as a traditional von-Neumann algorithm at application-level. As CeNN arrays process information via template operations on local data, we first identify the global problem and describe it by local operations and descriptors. For target tracking, we must identify local features (e.g., orientation, movement direction, etc.), and the positions of detected features can be used to estimate the position of the target. For example, in the CeNN paradigm, the position of local features can be detected by shadow templates that can identify the vertical and horizontal bounding box sides of local features. (Per Sec. IV, the local kernels used for feature extraction are selected via machine learning. A varying number of kernels can be selected which give a sparse and strong response on many images.)

After the algorithm is defined, its functional steps must be mapped on to suitable portions of the system. The algorithm is designed to maximize the use of CeNN hardware. However, portions of the algorithm might still require numerical operations on a CPU. Computation steps that involve parallel, independent processing of signals are mapped on to CeNN co-processors, e.g., feature extraction, classification at the pixel level, etc. Computations requiring precise floating point operations are mapped on to the CPU. The N-bit register within each processing unit of the CeNN architecture can facilitate any required data communication to and from the CPU.

The accuracy of the algorithm’s output must also be evaluated, and the algorithm may need to be refined to achieve suitable accuracy. Inaccuracies can be sourced from both the quality of the algorithm, and the analog nature of the hardware platform, and accuracy should be evaluated at multiple levels.

Finally, the algorithm and architecture must be evaluated to quantify the power, energy, and delays required for computation, and compared to the best von Neumann algorithm for the same problem. Analysis at this stage can lead to further modification of both the algorithm and architecture to maintain desired power-density of the co-processor, frame processing rates of the system (e.g., to enable real time tracking), etc.

IV CeNN based target tracking algorithm

We now provide a detailed description of our CeNN-based target tracking algorithm. The algorithm can be divided into two parts, training and tracking. (While we evaluate the tracking portion – i.e., to make an ”apples-to-apples” comparison to Struck – we also discuss the training portion for completeness. Other approaches in the literature also consider image recognition with off-line training, and then report energy-delay-accuracy per classification –e.g., [19] for MNIST.)

IV-A Training

In the training process, we select a set of Difference of Gaussians (DoG) kernels from a feature pool, assign weight to each kernel, and select a threshold to profile the interest area. The selected parameters above can be used on subsequent images to identify the target.

Training is currently done off-line with a CPU. A set of features are selected that best match the target object and separates it from the features of the background and surrounding objects. The feature pool is generated by running a number of DoG kernels for features extraction on an image and pooling the results. A DoG kernel performs two isotropic or directional Gaussian diffusions along with a subtraction operation. Each DoG operation is followed by a pooling step, which also leverages fast-running CeNN templates. The most descriptive threshold is selected from a series of thresholds at different levels, and the binary result is diffused with an isotropic template. The result of this sequence of operations corresponds to different feature responses. This approach is similar to the operation used in deep learning.

From this image set, a subset of descriptor images can be selected to create a globally sparse and high-response area corresponding to the estimated object position, given as a bounding box. A user-specified number of features is selected from the pool based on response strength within the bounding box. The features are then weighted by a genetic algorithm. After the genetic algorithm produces optimal linear weights, the linear sum of the descriptors is thresholded at a value to highlight the interest area.

IV-B Tracking

Our CeNN-based tracking algorithm/information processing flow is shown in Fig. 4. (The remaining part is Kalman filter-based processing which is computed by the CPU.)

The predefined DoG kernels, running by CeNN, are used in tracking to profile the object of interest. Each DoG kernel is weighted by a generic algorithm; the normalization and weighted sum of the image after DoG, performed by a CPU, would be the featured image. The runtime for each DoG operation is less than the settling time of a CeNN, so extra circuitry would be needed to control the timing of operation. Then, tracking is performed by taking the centroid of the local response area of the current frame and resizing the bounding box according to the dimensions of the response area relative to the response area of the first frame. After the image is constructed, several CeNN operations follow. A THRESHOLD operation can be performed to further highlight the object of interest. A following AND operation with the ground truth image can extract the object of interest. Once the extracted features are obtained, two SHADOW operations project the object vertically and horizontally. The width and height of the bounding box of the object can be easily calculated from said projections. A DILATION operation is used to augment the possible location of the tracked object, to ensure the object moves only a limited number of pixels between two consecutive frames. In the second part, the CPU applies two Kalman filters [20]. Weak Kalman filtering is also utilized to estimate the motion of the object, while a Strong Kalman filter is used to resize the bounding box, which is more prone to fluctuation. Once the position estimation is known the second part of the algorithm is executed on the next frames iteratively.

V Target tracking alogrithm evaluation

We now present our simulation/measurement setup and energy/delay/accuracy projections for the two algorithms.

V-A Image sequences to benchmark

To quantitatively evaluate energy, delay, and accuracy for both algorithms, we selected 24 video sequences from [9]. These test sequences are categorized into three sets (with 8 sequences per set). Dataset 1 consists of image sequences where we expect good overlap per a success plot. These sequences exhibit the following characteristics: (i) the motion of the object to be tracked is either in one direction or very slow, (ii) the object is easy to identify from the background, and (iii) the shape of the object does not change significantly. In Dataset 2, typically one of the three aforementioned characteristics of scene dynamics is not satisfied. Finally, in Dataset 3, most/all of the aforementioned conditions are not satisfied.

V-B Simulation setup

Some portions of our CeNN-based algorithm are run on a CPU, while all code for the Struck algorithm is run on a CPU. We use source code for Struck from [21]. Any CPU code needed for our CeNN approach was written in C. All CPU code was then executed on an Intel Core i5-5675C, 16GB DDR3, with Ubuntu 15.04 64-bit. We use a setup like that described in [22] to measure the energy usage of the CPU. The CPU is powered by a dedicated 12V cable. We use a current clamp to monitor the current changes on the cable at a speed of 10,000 samples per second. A data acquisition system records the current data when the CPU executes code for a respective algorithm. We start the timer after the CPU reads the image, and synchronize the execution time. Thus, we only compute the delay/energy of the CPU. Memory overhead is not considered as most program data is stored in registers for both architectures. For the CeNN based algorithm, we also set the timer at the beginning and end of CPU operations to eliminate other overheads. We then use current, voltage and time data to compute CPU energy.

V-C Delay and energy analysis

Here, we present energy/delay data for image sequences in Dataset 1. (Metrics for other datasets were also collected, but projected gains in EDP were similar to Dataset 1.) For the CeNN algorithm, we report data for the CPU as well as the CeNN hardware accelerator. For the hardware accelerator, we assume 14 nm CMOS, the same technology node as the CPU.

Per Fig. 4, a portion of the tracking algorithm is mapped to the CeNN co-processor, while the rest is mapped to the CPU. We first consider the steps that leverage the CeNN accelerator, and summarize energy and delay in Table I, (using the RedTeam image sequence from Dataset 1 as an example). Time and energy is dominated by some image augmentation and shadow steps (e.g., RECALL and SHADOWL). As these are propagating type of templates, the run-time of these steps need to be long enough for signals to propagate through the whole image. The initialization reflects the data movement from other components to the hardware accelerator. In this process, the state voltage should be pre-charged before running the CeNN operation. In the initialization step, the data either comes from the CPU through a DAC, or from a photo sensor. The run-time for the initialization includes the the settling time for the CeNN cell, and the run-time of the DAC (if data comes from a CPU).

The settling time for a single cell is computed by [23]. The power for OTAs (which can dominate CeNN cells and is computed per [23]) is constant in operation, and proportional to the $G_{m}$ of the OTA [23]. $G_{m}$ is proportional to the template value, which is specified in [24]. We designed an OTA for a specific template value, (i.e., template values are 1), measured its power via SPICE, and scaled the power based on numerical values of given template values. In this way, we obtain the power of all OTAs in a CeNN cell for one operation and ultimately the power for the analog CeNN co-processor. We iteratively follow the previous step to obtain the power for each step, and use the measured delay to obtain energy data.

Note that we assume the run-time of the DAC is the same as ADC [25]. The energy for the ADC is calculated per [25]. The frequency of the ADC is determined by the number of ADC accesses dividing the total run-time of analog CeNN component. The frequency of the register is the same as the frequency of the ADC to ensure data synchronization. The bit length for the ADC, register, and DAC is assumed to be 8 which provides enough ($256$) shades of grays for image processing.

Delay, energy, and EDP for the CeNN-based system is depicted by the stacked bars in Fig. 5(a)-(c) respectively. (The dotted bars represent the CeNN-based co-processor, while the bars with diagonal lines represent computations mapped to the CPU.) The rightmost solid bar represents the Struck algorithm. Here, computations mapped to the CPU in the CeNN based algorithm generally have higher delay and energy when compared to information processing operations performed on the CeNN.

To fully appreciate the benefit of CeNNs, we have run a version of the CeNN-based algorithm implemented in Matlab on a CPU. Run times are on the order of a few hours for a given image sequence. Given that the corresponding C code for CeNN algorithm runs 100X faster, the Matlab-based approach is still orders of magnitude slower than the system containing a CeNN accelerator. Furthermore, our software implementation indicates that 99% of the computation time is attributed to CeNN operations. Hence, the CeNN co-processor has a substantial, positive impact on the CeNN-based system.

Finally, for the Struck algorithm, energies and delays for various sequences are directly obtained from measured CPU data per Sec. V-B. For the different image sequences in Fig. 5, EDPs are largely 1000X to 10000X better for our CeNN-based approach versus Struck.

V-D Accuracy analysis

Given the potential for energy/delay improvements, we now consider tracker accuracy. In Fig. 6, we show representative results for accuracy for the RedTeam and Vase image sequences from Dataset 1. Per the inset, the solid box represents the ground truth, while the dashed box represents the position established by the tracker. The overlap threshold is the intersection of the two boxes over the union of the two boxes. After collecting this data for every image in the sequence, we can plot success rate (i.e., the percentage of time a given overlap threshold was achieved). For a perfect tracker, this plot would simply be a horizontal line at ’1’ on the y-axis. To represent accuracy as a single number, we calculate the area under the curve (AUC) for a given image sequence and algorithm.

AUC scores were calculated for the 24 sequences for both Struck and our CeNN-based approach. For Struck, the algorithm can be tuned such that energy, accuracy, or run-time may vary (e.g., leveraging more kernels, changing the search radius etc.). We set these parameters to obtain the highest possible accuracy as per Sec. V-C, our CeNN-based approach can be superior to a von Neumann approach in terms of energy and delay. As such, we consider these metrics as we approach iso-accuracy. To obtain AUC data for our CeNN-based approach, we used a Matlab-based CeNN simulator [26]. While both the Matlab simulator and Struck algorithm run on a 64-bit machine, the image quality is 8-bits. Thus, CeNN hardware should be sufficient to process these video sequences.

The accuracy results (AUC scores for all 24 benchmarks) are shown in Fig. 7. For dataset 1, the average AUC for our algorithm and Struck are 0.438 and 0.402, respectively (see Fig. 7a). As scene dynamics change such that an object becomes more difficult to track, the AUC scores for both algorithms decrease. However, for Datasets 2 and 3 (Figs. 7b, c) the Struck-based approach is approximately 2X better than the CeNN algorithm for the AUC benchmark. That said, there are exceptions. Among the most challenging image sequences (i.e., Ironman and Bolt), the CeNN approach is either similar or superior to Struck (see highlighted sequences in Fig. 7c). While we will consider this more at the algorithm-level in future work, we briefly discuss our initial hypothesis as to why this is the case. Using the Bolt dataset as an example – where there are several athletes running – the CeNN algorithm can focus more on local features with an object moving only a limited number of pixels in two consecutive frames.

Additionally, accuracy projections for the CeNN-based algorithm currently only consider basic configurations of the CeNN-based algorithm, which can be further improved. As examples, the number of kernels can be increased to capture more detailed features. CeNN connectivity can also be increased to expand local feature area. Gabor kernels will increase sensitivity to spatial frequencies and the orientation of edges and enhance feature extraction. To quantitatively address this hypothesis, we considered the Car4 benchmark (see highlighted sequence in Fig. 7b) from Dataset 2 with initial AUC score of 0.186. When we increase the number of kernels from 25 to 50, and CeNN connectivities from $3\times 3$ to $5\times 5$, AUC increases to 0.200. If we employ CPU-based Gabor kernels the AUC score improves to 0.378. While this will likely increase energy and delay, per Sec. V-C, a substantial margin exists. (Gabor kernels can also be efficiently realized with CeNNs [27]). This will be studied in future work.

VI Conclusion

We have presented a framework for evaluating CeNN-based co-processors. As a case study, we developed a CeNN-based target tracking algorithm for a CeNN-based co-processor, and compared its energy/delay/accuracy to a highly accurate, von Neumann tracker. Our CeNN-based tracker is as accurate as the Struck algorithm for many image sequences, and can offer orders of magnitude improvements in EDP. When Struck is superior, we have outlined paths to algorithmic improvement that makes our approach competitive. In future work, we will (i) accelerate the training process with CeNNs, (ii) evaluate energy/delay with algorithmic refinements, and (iii) study the impact of other emerging technologies (e.g., which may enable highly efficient/compact diffusion networks [28]).