Aerobic activity monitoring: towards a long-term approach

Abstract

With recent progress in wearable sensing, it becomes reasonable for individuals to wear different sensors all day, and thus, global activity monitoring is establishing. The goals in global activity monitoring systems are among others to tell the type of activity that was performed, the duration and the intensity. With the information obtained this way, the individual’s daily routine can be described in detail. One of the strong motivations to achieve these goals comes from healthcare: To be able to tell if individuals were performing enough physical activity to maintain or even promote their health. This work focuses on the monitoring of aerobic activities and targets two main goals: To estimate the intensity of activities, and to identify basic/recommended physical activities and postures. For these purposes, a dataset with 8 subjects and 14 different activities was recorded, including the basic activities and postures, but also examples of household (ironing, vacuum cleaning), sports (playing soccer, rope jumping), and everyday activities (ascending and descending stairs). Data from 3 accelerometers—placed on lower arm, chest, and foot—and a heart rate monitor were analyzed. This paper presents the entire data processing chain, analyses and compares different classification techniques, concerning also their feasibility for portable online activity monitoring applications. Results are presented with different combinations of the sensors. For the intensity estimation task, using the sensor setup composed of the chest accelerometer and the HR-monitor is considered the most efficient, achieving a performance of 94.37 %. The overall performance on the activity recognition task, using all available sensors, is 90.65 % with boosted decision trees—the classifier achieving the best classification results within this work.

Appendix: an overview of the base- and meta-level classifiers used within this work

For the training and evaluation of all classifiers—except of the custom decision tree classifier—within this work, the Weka toolkit was used. Weka (Waikato Environment for Knowledge Analysis) is a free machine learning software written in Java. It provides tools for analyzing and understanding data, including the implementation of a huge amount of data mining algorithms, and a graphical user interface for easy data manipulation and visualization. A great description of the Weka toolkit, along with a thorough grounding in the machine learning concepts the toolkit uses, and practical advice for using the different tools and algorithms, can be found in [38].

From the various base-level classifiers the Weka tool- kit offers the following 4 are evaluated in this work: decision tree, kNN, SVM, and Naive Bayes classifier. A detailed introduction into decision tree classification can be found in [34]. C4.5 is a widely used algorithm to generate decision tree classifiers and is implemented in the Weka toolkit. A practical description of choices and settable parameters of this algorithm is given in [38]. The k-nearest neighbor algorithm (kNN) belongs to the instance-based learning methods. In kNN, a new feature vector is classified based on the k closest training examples in the feature space. Support vector machine (SVM) classifiers select a small number of critical boundary instances called support vectors from each class and build a linear discriminant function that separates them as widely as possible [38]. SVM is a useful and popular classification technique not only because it constructs a maximum margin separator, but also because—by using different kernel functions—it is possible to form nonlinear decision boundaries with it. The Weka toolkit uses the libsvm library, and practical advice for using this tool can be found in [17]. Finally, the Naive Bayes classifier is a simple probabilistic classifier, probably the most common Bayesian network model used in machine learning. The model assumes that the features are conditionally independent of each other, given the class. The Naive Bayes model works surprisingly well in practice, even when the conditional independence assumption is not true. A great overview on probabilistic learning, Bayesian classifiers amd learning Bayesian models, is given in [34].

From the various metalearning algorithms in Weka, two ensemble learning methods are selected and evaluated in this work: bagging and boosting. The idea behind these methods is to iteratively learn weak classifiers by manipulating the training dataset, and then combine the weak classifiers into a final strong classifier. For briefly describing bagging and boosting, assume that the training dataset contains N instances: $({\underline{x}}_i, y_i) i=1{\ldots}N$ (${\underline{x}}_i$ is the feature vector, y _i is the annotated class in $1{\ldots}C$ of the instance), and $t=1{\ldots}T$ iterations are performed with the weak classifier $f({\underline{x}})$. In bagging, from the instances of the trainig dataset, N instances are randomly, with replacement, sampled in each t iteration. The learning algorithm (the weak classifier) is applied on this sample, and the resulting model is stored. After learning, when classifying a new instance, a class is predicted with each of the T stored models. The final decision is the class that has been predicted most often.

The difference in boosting is that the training dataset is reweighted after each iteration, and the single learning models are also weighted for constructing the final strong classifier. There are many variants based on the idea of boosting. One of the most widely used is called AdaBoost (this is implemented in Weka, and is the variant of boosting used in this work):

• 1. Assign equal weight to each training instance: $w_i=\frac{1}{N},i=1{\ldots}N$

• 2. Repeat for $t=1{\ldots}T$:

  • (a) Apply learning algorithm to the weigthed dataset, and store resulting model: $f_{t}({\underline{x}})$.

  • (b) Compute error e _t of model on weighted dataset (sum of misclassified instances’ weights):

    $$ e_{t}=\displaystyle\sum\limits_{i:y_{i}\neq f_{t}({\underline{x}}_i)}w_i $$

  • (c) If e _t  = 0 or e _t  ≥ 0.5:

    Terminate model generation.

  • (d) Repeat for $i=1{\ldots}N$ instance in dataset:

    • If $y_{i}=f_{t}({\underline{x}}_i)$, thus the instance is classified correctly by the model: set $w_{i}\leftarrow w_{i}\cdot \frac{e_t}{1-e_t}$

  • (e) Renormalize the weight of all instances, so that $\displaystyle\sum\nolimits_{i}w_{i}=1$ again.

After learning, when classifying a new instance $({\underline{x}}_n)$:

• 1. $\mu _{j}=0,\,j=1{\ldots}C$ (set zero weight to all classes).

• 2. Repeat for $t=1{\ldots}T$ (or less) models: $c=f_{t}({\underline{x}}_n)$ predict class with the model, then set $\mu _{c} \leftarrow \mu _{c} - \log \frac{{e_{t} }}{{1 - e_{t} }}.$.

• 3. Return class with highest μ _j (from $j=1{\ldots}C$).

As can be seen from the above algorithm, the weak classifiers built in the consequent iterations focus on classifying the hard instances correctly. Moreover, when constructing the final classifier, more influence is given to the more successful models. Both bagging and boosting use the same learning algorithm (the same type of weak classifier) in each iteration, for example, a decision tree classifier, and combine these T decision trees into the final strong classifier. In this work, all 4 base-level classifiers introduced above are used and evaluated as learning algorithms for both bagging and boosting. Detailed information on ensemble learning can be found in [34] and in [38]. Moreover, the relation of boosting to additive models, and different variants based on the idea of boosting, is presented in [12].