Automated Generation of Power-Efficient Detection Hierarchies for Wearable Sensors
The availability of miniature low-cost sensors has allowed for the capture of rich, multimodal
data streams in compact embedded sensor nodes. These devices have the capacity to
radically improve the quality and amount of data available in such diverse applications as
detecting degenerative diseases, monitoring remote regions, and tracking the state of smart
assets as they traverse the supply chain. However, current implementations of these applications
suffer from short lifespans due to high sensor energy use and limited battery size.
By concentrating our design efforts on the sensors themselves, it is possible to construct
embedded systems that achieve their goal(s) while drawing significantly less power. This
will increase their lifespan, allowing many more applications to make the transition from
laboratory to marketplace and thereby benefit a much wider population.
The main goal of this work is the reduction of energy usage in embedded sensor systems
through the creation and demonstration of new tools and algorithms for their design and
construction. We will first consider the general form of our solution and the details thereof.
The problem space was limited to the sensing of human activity to reduce the scope of
possible solutions as well as to allow the incorporation of constraints arising from a fundamental
knowledge of human physiology. The design of the device hardware, the software
and its instantiation are then discussed. The section concludes with a short discussion of
some of the limitations imposed by this solution. We note that this solution centres
around sensor usage, is independent of any power reduction techniques based on reducing
RF transmissions or processor usage and can be used in conjunction with them.
The general design for our system is shown above. This system is centred around the
concept of what we term “groggy”, or tiered, wake up. This stands in contrast to the more
common binary wake up systems, which have only two modes: fully active, collecting all
possible data and drawing maximal power, or fully asleep, collecting no data and drawing virtually no power. Instead, we envision a system with a number of different levels of
activity and associated power usages. Each level comprises the currently active sensors
for state determination and their sampling rate, together with algorithms to describe the
level transitions. Execution is straight-forward. From a given initial state at power up, the
system will begin to collect and analyse the sampled data and will switch activity levels
accordingly. At each time step, the current level will specify how to use as little energy as
possible to collect the data to determine the current state and whether a level transition is
necessary. Specific responses, such as data capture and storage, can be associated with the
individual states and are executed next. Once this is completed, the system powers down
until the next time step.
Given a desired application, the design process proceeds as follows. First, hardware for the
individual application is configured. In the initial deployment for testing and sample data
collection, it is assumed that the system will include any sensors that could possibly be of
value for state determination. A training data stream is collected with this hardware, and
is annotated by the application designer. These annotated examples are used to construct a
classifier that will determine the current system state. The sensor set used by the classifier
allows the final, possibly pared down, form of the hardware to be built and the data collection
to be implemented on it. Each of these tasks are briefly described and commented
The modular sensor platform described here was used for prototyping and data collection.
The core of this framework is a decision tree classifier that dynamically orders the activation and adjusts the sampling rate of the sensors, such that only the data necessary to determine the system state is collected at any given time. This classifier can be tuned to trade-off accuracy and power in a structured fashion.
A sample decision tree is shown above for
evaluating whether a patient is diabetic. Values of plasma glucose below a certain threshold
suggest that the patient is not diabetic, while those above another threshold suggest that
they are. For patients with middling values, the body mass index is used to differentiate. Note that classification is hierarchical - that the value of the body mass index need not be collected unless it is needed for the final node in the tree.We see that it may be possible to make decisions using only a small subset of the available information, depending on the state.
The standard decision tree construction algorithms were modified by adding a weighting factor relative to the cost of each of the available tests - in this case, the energy necessary to measure sensor values. This weighting can be adjusted, allowing the construction of a population of trees which range from not taking energy use into account to making it the most important criterion when building the tree.
The real-time operation of the hardware for this design is fairly straight-forward and is
given by the current activity level. A reloading timer is set for the current update rate and
the processor is put to sleep. The processor is awakened by the timer overflowing and turns
on the desired sensors. As each sensor completes its wake up cycle, it is sampled and then
turned off. Once all the sensors have been sampled, the data analysis is done and the state
is determined. In the interesting states, the system responds as chosen by the designer, e.g.
by making a notation of the occurrence, collecting data, or cuing the user. Actions can also
be taken in the uninteresting states, though these responses would have to be identical for
all possibilities. Once these actions are complete, the processor returns to sleep mode.
An application based on a wearable gait monitor provides quantitative support for this framework. This application uses the same hardware as the GaitShoe but without the insole. A data stream was collected which contained a wide variety of different ambulatory
activities. The set of activities chosen was: normal level gait, walking uphill, walking downhill,
ascending stairs and descending stairs. A shuffling motion was also recorded, where
the user specifically attempted to mimic the shuffling motion of a patient with Parkinson’s
Disease. This data set allows us to create classifiers which attempt to separate a single (complex) ambulatory activity from the rest. It is often the case that only one of
these motions is of interest for a given patient. Further, this requires far more complex and richer classifiers than
those used to simply separate ambulatory from non-ambulatory (roughly: still) states.
Classifiers were constructed for the six different cases of one of the ambulatory motions
being the positive class and the others being grouped together as the negative class. Each
classifier will therefore attempt to separate a single type of motion from the other five. A 64/16/20 split of the data for growing/pruning/testing. A population of decision trees for various value of the weighting parameter described above were built. Support vector machines (SVM) were trained for the same tasks as above to act as a point of
to calculate the power/accuracy trade-off of the SVMs, classifiers will be trained for all possible combinations of active sensors run at the maximum sampling rate.
A thumbnail of the power/accuracy curves for these classifiers is shown above (click to expand). It was shown that, in general, the decision tree classifiers designed achieve roughly identical detection accuracies to those obtained using support vector machines while drawing three to nine times less power.
Each classifier was tested on a continuous data stream set aside for this purpose. Two concerns arise when using the static trees grown as part of this framework in a realtime
system. The first is the effect of the latency inherent in activating sensors and whether
this will lead to missed detections. The second is the issue of the generalizability of the
classifier itself - i.e. did it overtrain to the sample set.
The series of plots below shows four different interpretations of the operation of
the classifier and each is denoted with the ground truth - the hand annotation marking when
the motion of interest is taking place. The first plot, with the mint green background, is
the state output of the static classifier (for which all of the sensors are always active). This
is a point of comparison for the real-time classifier, which cannot, by definition, respond
more quickly. The second plot shows the state output for the real-time classifier. The third plot is the activation level of the classifier, defined as the number of sensors active (i.e.
available for use) at any given point. Finally, the last plot shows the power consumption,
which includes not only the sensors which are active but those which are waking up (i.e.
for which enough data has not yet been collected for features to be calculated). Just as the
state output of the real-time classifier is a subset of the state output of the static classifier,
it is also a subset of the activation level, which is a subset of the power usage.
The tree and the plot above (click to expand) are for the case of separating stair descent from the other motions. The stair descent classifier stands out as drawing far less power than expected in the realtime
simulation. The reason for this lies in the structure of the decision tree.
While there are positive states at two different activation levels, only the less costly one
is ever reached due to latency issues. Therefore, while the static classifier often activates
three sensors, the real-time classifier only uses two. Output smoothing repairs
the slight defects such that they are not noticeable in the final state determination.
Overall, the simulation of the real-time operation of the classifiers demonstrated that our multi-tiered classifier determines states as accurately as a single-trigger (binary) wakeup system while drawing half as much power, with only a negligible increase in latency.
Copyright issues, both at the Media Lab and with Mathworks, currently prevent the release of the source code for this project. We are actively investigating these issues and should be able to post the files soon.