Xuan Son Nguyen

Luc Brun

Olivier Lezoray

Sébastien Bougleux

Skeleton-Based Hand Gesture Recognition by Learning SPD Matrices with Neural Networks

In this paper, we propose a new hand gesture recognition method based on skeletal data by learning SPD matrices with neural networks. We model the hand skeleton as a graph and introduce a neural network for SPD matrix learning, taking as input the 3D coordinates of hand joints. The proposed network is based on two newly designed layers that transform a set of SPD matrices into a SPD matrix. For gesture recognition, we train a linear SVM classifier using features extracted from our network. Experimental results on a challenging dataset (Dynamic Hand Gesture dataset from the SHREC 2017 3D Shape Retrieval Contest) show that the proposed method outperforms state-of-the-art methods.

I. INTRODUCTION

Hand gesture recognition is one of the main tasks in video understanding. This task has received increasing attention from the computer vision community, as it has many potential applications in human-robot interaction, sign language interpretation, and smart home control interface. Existing vision-based approaches for hand gesture recognition use generally three data modalities, i.e. RGB and depth (RGB-D) images, and skeletal data. Most of these approaches are mainly based on RGB-D images since they can be directly acquired from vision sensors, while skeletal data must be estimated by a tracking algorithm and is thus more difficult to obtain and less reliable than RGB-D images.

The introduction of depth cameras like Intel Realsense and Microsoft Kinect enables effective hand gesture recognition using skeletal data [START_REF] Smedt | Skeleton-Based Dynamic Hand Gesture Recognition[END_REF], [START_REF] Smedt | 3D Hand Gesture Recognition Using a Depth and Skeletal Dataset[END_REF]. Compared to RGB-D images, skeletal data offers several advantages. First, view-invariant gesture recognition can be achieved using skeletal data. Second, features extracted from skeletal data are generally lowdimensional and fast to compute compared to those extracted from RGB-D images. Figure 1(a) shows the hand joint positions estimated by an Intel Realsense camera. Motivated by the recent success of graph convolutional networks for action recognition [START_REF] Li | Spatio-Temporal Graph Convolution for Skeleton Based Action Recognition[END_REF], [START_REF] Yan | Spatial Temporal Graph Convolutional Networks for Skeleton-Based Action Recognition[END_REF], we propose to model the hand skeleton as a graph for hand gesture recognition. Figure 1(b) shows the graph at one frame corresponding to the hand skeleton in Fig. 1(a). To obtain gesture representations, we rely on first-and second-order statistics. These statistics are combined using Gaussian distributions [START_REF] Li | Local Log-Euclidean Multivariate Gaussian Descriptor and Its Application to Image Classification[END_REF], [START_REF] Wang | G2DeNet: Global Gaussian Distribution Embedding Network and Its Application to Visual Recognition[END_REF], forming Symmetric Positive Definite (SPD) matrices. Since SPD matrices are known to lie on a Riemannian manifold, we develop a neural network for SPD matrix learning [START_REF] Dong | Deep Manifold Learning of Symmetric Positive Definite Matrices with Application to Face Recognition[END_REF], [START_REF] Huang | A Riemannian Network for SPD Matrix Learning[END_REF],

This material is based upon work supported by the European Union and the Region Normandie under the project IGIL. [START_REF] Ionescu | Matrix Backpropagation for Deep Networks with Structured Layers[END_REF], [START_REF] Li | Is Second-order Information Helpful for Large-scale Visual Recognition?[END_REF], [START_REF] Wang | G2DeNet: Global Gaussian Distribution Embedding Network and Its Application to Visual Recognition[END_REF]. To this end, we propose two new types of layers that transform a set of SPD matrices into a SPD matrix. Despite the simplicity of our network, it outperforms state-of-the-art methods on the challenging Dynamic Hand Gesture (DHG) dataset [START_REF] Smedt | 3D Hand Gesture Recognition Using a Depth and Skeletal Dataset[END_REF] from the SHREC 2017 3D Shape Retrieval Contest.

II. RELATED WORKS

A. Skeleton-Based Hand Gesture and Action Recognition

Ioenescu et al. [START_REF] Ionescu | Dynamic Hand Gesture Recognition Using the Skeleton of the Hand[END_REF] extracted the hand region skeleton and a dynamic signature of the gesture was then computed as the superposition of all the skeletons of the hand region. Wang and Chan [START_REF] Wang | A New Hand Gesture Recognition Algorithm Based on Joint Color-depth Superpixel Earth Mover's Distance[END_REF] segmented the hand region and used a superpixel representation to capture the hand shape and texture information. De Smedt et al. [START_REF] Smedt | Skeleton-Based Dynamic Hand Gesture Recognition[END_REF] proposed two kinds of features based on hand shapes and movements. The shapebased features were computed using Fisher vector, and the movement-based features were computed from histogram of hand directions and histogram of wrist rotations. Nunez et al. [START_REF] Nez | Convolutional Neural Networks and Long Short-Term Memory for Skeleton-based Human Activity and Hand Gesture Recognition[END_REF] trained a combination of a Convolutional Neural Network (CNN) [START_REF] Krizhevsky | ImageNet Classification with Deep Convolutional Neural Networks[END_REF] and a Long Short-Term Memory (LSTM) [START_REF] Hochreiter | Long Short-Term Memory[END_REF] using two stages. In the first stage, the CNN was connected to a fully-connected multi-layer perceptron of two hidden layers. In the second stage, the output of the pretrained CNN was connected to the LSTM. Devineau et al. [START_REF] Devineau | Deep Learning for Hand Gesture Recognition on Skeletal Data[END_REF] separated a gesture sequence into 1D sequences and fed each of them to a multi-channel CNN consisting of three parallel branches. The first branch was a residual network, while the two other branches were designed for feature extraction.

For skeleton-based action recognition, two categories of features have also been investigated, e.g. hand-crafted features and deep-learned features. In hand-crafted featurebased approaches, the 3D joint positions of the human body were used to compute skeletal quad [START_REF] Evangelidis | Skeletal Quads: Human Action Recognition Using Joint Quadruples[END_REF], points in a Lie group [START_REF] Vemulapalli | Human Action Recognition by Representing 3D Skeletons as Points in a Lie Group[END_REF], Actionlet Ensemble [START_REF] Wang | Mining Actionlet Ensemble for Action Recognition with Depth Cameras[END_REF], EigenJoints [START_REF] Yang | EigenJoints-based Action Recognition Using Naive-Bayes-Nearest-Neighbor[END_REF]. In deep learning based-approaches, various architectures based on CNN, Recurrent Neural Network [START_REF] Du | Hierarchical Recurrent Neural Network for Skeleton Based Action Recognition[END_REF], LSTM [START_REF] Liu | Global Context-Aware Attention LSTM Networks for 3D Action Recognition[END_REF], [START_REF] Shahroudy | NTU RGB+D: A Large Scale Dataset for 3D Human Activity Analysis[END_REF] were introduced to learn action representations. Very recently, geometric deep learning which extends classical operations like convolution to non-Euclidean domains, e.g. manifolds and graphs, has also been applied to skeletonbased action recognition. Manifold learning approaches operated on different manifolds, e.g. SPD manifolds [START_REF] Huang | A Riemannian Network for SPD Matrix Learning[END_REF], Lie groups [START_REF] Huang | Deep Learning on Lie Groups for Skeleton-Based Action Recognition[END_REF], and Grassmann manifolds [START_REF] Huang | Building Deep Networks on Grassmann Manifolds[END_REF]. Graph learning approaches [START_REF] Shi | Adaptive Spectral Graph Convolutional Networks for Skeleton-Based Action Recognition[END_REF], [START_REF] Yan | Spatial Temporal Graph Convolutional Networks for Skeleton-Based Action Recognition[END_REF] were based on graph convolution filters and Deep Residual Networks [START_REF] He | Deep Residual Learning for Image Recognition[END_REF] which have shown very promising results on large scale datasets.

B. Deep Learning on Graphs

Deep learning on graphs, as mentioned previously, has received increasing attention in recent years. While various approaches have been proposed and proven effective in different tasks [START_REF] Defferrard | Convolutional Neural Networks on Graphs with Fast Localized Spectral Filtering[END_REF], [START_REF] Simonovsky | Dynamic Edge-Conditioned Filters in Convolutional Neural Networks on Graphs[END_REF], [START_REF] Verma | FeaStNet: Feature-Steered Graph Convolutions for 3D Shape Analysis[END_REF], very few approaches have been developed so far for action and hand gesture recognition. Yan et al. [START_REF] Yan | Spatial Temporal Graph Convolutional Networks for Skeleton-Based Action Recognition[END_REF] introduced a Spatial Temporal Graph CNN operating on a graph constructed from body joints and physical connections between them. Their network was designed and trained based on the mechanism of Deep Residual Networks [START_REF] He | Deep Residual Learning for Image Recognition[END_REF]. Shi et al. [START_REF] Shi | Adaptive Spectral Graph Convolutional Networks for Skeleton-Based Action Recognition[END_REF] improved [START_REF] Yan | Spatial Temporal Graph Convolutional Networks for Skeleton-Based Action Recognition[END_REF] by automatically learning the graph structure at each layer, while Zhang et al. [START_REF] Zhang | Graph Edge Convolutional Neural Networks for Skeleton Based Action Recognition[END_REF] improved [START_REF] Yan | Spatial Temporal Graph Convolutional Networks for Skeleton-Based Action Recognition[END_REF] by defining an equivalent convolution operator on graph edges. Similarly to [START_REF] Yan | Spatial Temporal Graph Convolutional Networks for Skeleton-Based Action Recognition[END_REF], Li et al. [START_REF] Li | Spatio-Temporal Graph Convolution for Skeleton Based Action Recognition[END_REF] constructed a graph to represent the human body skeleton. A polynomial approximation of the Graph Fourier Transform was then used to design multi-scale convolutional filters, which were then combined with autoregressive moving average to build a spatio-temporal graphical convolutional model.

C. Deep Learning of SPD Matrices

Ionescu et al. [START_REF] Ionescu | Matrix Backpropagation for Deep Networks with Structured Layers[END_REF] introduced the theory and practical techniques for matrix backpropagation in the deep learning framework. They also proposed DeepO2P, a network for region classification, and an algorithm for backpropagation of logarithm of SPD matrices. Based on [START_REF] Ionescu | Matrix Backpropagation for Deep Networks with Structured Layers[END_REF], several methods for SPD matrix learning have been proposed. Dong et al. [START_REF] Dong | Deep Manifold Learning of Symmetric Positive Definite Matrices with Application to Face Recognition[END_REF] introduced a 2D fully connected layer and a symmetrically clean layer for dimensionality reduction and non-linear transformation of SPD matrices. Huang and Gool [START_REF] Huang | A Riemannian Network for SPD Matrix Learning[END_REF] mapped a high dimensional SPD matrix into a lower dimensional one via Bimap, a layer having a similar form as the 2D fully connected layer proposed in [START_REF] Dong | Deep Manifold Learning of Symmetric Positive Definite Matrices with Application to Face Recognition[END_REF]. Kernel matrices were also used to design non-linear activation functions [START_REF] Engin | DeepKSPD: Learning Kernel-matrix-based SPD Representation for Fine-grained Image Recognition[END_REF]. Li et al. [START_REF] Li | Is Second-order Information Helpful for Large-scale Visual Recognition?[END_REF] and Wang et al. [START_REF] Wang | G2DeNet: Global Gaussian Distribution Embedding Network and Its Application to Visual Recognition[END_REF] combined parametric probability distributions modeling into CNNs, which requires backpropagation of a square-rooted SPD matrix.

III. PROPOSED NETWORK

A. Overview

Given a hand skeleton sequence, we construct a graph for each frame as illustrated in Fig. 1(b). The features at a node provide a 3-dimensional vector formed from the x, y, and z coordinates of the corresponding hand joint. We design a simple 2D convolutional layer which is applied to the input data to take into account the correlation between neighboring nodes. A sub-sequence of a specific finger is extracted from the sequence and processed by a branch of the network. Two layers referred to as GaussAgg and SPDTempAgg are then used to learn joint features for each branch. The outputs of all branches of the network are combined using a layer referred to as SPDSpatAgg, resulting in a SPD matrix. Since the obtained SPD matrix lies on a Riemannian manifold, it is mapped to Euclidean spaces for classification. The proposed network architecture is illustrated in Fig. 2.

In the next two sections, we denote by n k L the number of input SPD matrices of the k th layer, by d k-1 and d k the dimensions of input and output SPD matrices of the k th layer, respectively, by X i k-1 , i = 1, . . . , n k L the input SPD matrices of the k th layer, and by X k the output SPD matrix of the k th layer.

B. SPD Spatial Aggregation

The SPDSpatAgg layer (step (k) of Fig. 2) computes X k by a mapping f sa as:

X k = f (k) sa ((X 1 k-1 , . . . , X n k L k-1 ); W 1 k , . . . , W n k L k ) = n k L i=1 W i k X i k-1 (W i k ) T , (1)
where

W i k ∈ R d k ×d k-1
are the transformation matrices. To guarantee that X k is SPD, one can use the same assumption as [START_REF] Huang | A Riemannian Network for SPD Matrix Learning[END_REF], i.e. each transformation matrix W i k is a full row rank matrix. In this case, each term in the right-hand side of Eq. ( 1) is SPD, so their sum is also SPD. Then optimal solutions of the transformation matrices are achieved by additionally assuming that each transformation matrix W i k resides on a compact Stiefel manifold St(d k , d k-1 ) 1 . Note that this assumption imposes a constraint on the dimension of X k , i.e. d k ≤ d k-1 . The backpropagation procedure of this layer is based on the optimization framework of [START_REF] Huang | A Riemannian Network for SPD Matrix Learning[END_REF].

C. SPD Temporal Aggregation

The SPDTempAgg layer is decomposed into three sublayers as illustrated at steps (g), (h) and (i) of Fig. 2. The first sub-layer computes the matrix logarithm Y i k-1 from X i k-1 , for i = 1, . . . , n k L as:

Y i k-1 = log(X i k-1 ) = U log(V)U T , (2)
where UVU T is the eigen-decomposition of X i k-1 . This layer can be implemented similarly to the LogEig layer [START_REF] Huang | A Riemannian Network for SPD Matrix Learning[END_REF]. The second sub-layer, referred to as HalfVec layer, vectorizes the upper triangle of Y i k-1 for i = 1, . . . , n k L as:

1 A compact Stiefel manifold St(d k , d k-1 ) is the set of d k -dimensional orthonormal matrices of R d k-1 .
z i =[Y i k-1 (1, 1), √ 2Y i k-1 (1, 2), . . . , √ 2Y i k-1 (1, d k-1 ), Y i k-1 (2, 2), √ 2Y i k-1 (2, 3), . . . , Y i k-1 (d k-1 , d k-1 )] T (3)
where Y i k-1 (u, v) denotes the element at the u th row and v th column of Y i k-1 . The third sub-layer, referred to as GaussAgg layer, aggregates the z i , for i = 1, . . . , n k L , based on their Gaussian distributions [START_REF] Wang | G2DeNet: Global Gaussian Distribution Embedding Network and Its Application to Visual Recognition[END_REF] to obtain the output of SPDTempAgg:

X k = f (k) ta ((X 1 k-1 , . . . , X n k L k-1 )) = Σ Σ Σ + µ µ µµ µ µ T µ µ µ µ µ µ T 1 (4)
where

µ µ µ = 1 n k L n k L i=1 z i and Σ Σ Σ = 1 n k L n k L i=1 (z i -µ µ µ)(z i -µ µ µ) T .
The backpropagation procedure of this layer is based on the framework of [START_REF] Ionescu | Matrix Backpropagation for Deep Networks with Structured Layers[END_REF].

D. The Network in Detail

Let n J , n F be the number of hand joints and the length of the gesture sequence, respectively. The input of our network (Fig. 2) is a sequence of hand poses denoted by p t 0,i ∈ R 3 , i = 1, . . . , n J , t = 1, . . . , n F , where p t 0,i corresponds to the 3D coordinates of joint i at frame t. Let d 1 be the number of channels of output features in the first layer. Denote by p t 1,i ∈ R d1 , i = 3, . . . , n J , t = 1, . . . , n F the output of the first layer, by p t 1,i,c the value of the c th channel of p t 1,i , c = 1, . . . , d 1 , i.e. p t 1,i = [p t 1,i,1 , . . . , p t 1,i,d1 ] T . At the first layer, the value for the c th channel of the feature vector on node i is given by:

p t 1,i,c = j∈Ni w T l(j,i),c p t 0,j . (5)
where N i is the set of neighbors of node i, w l(j,i),c ∈ R 3 is the filter weight vector for the c th channel, and l(j, i) is defined as:

l(j, i) =    1 if j -i = 0 2 if j -i = 1 3 if j -i = -1 (6)
At step (d) of Fig. 2, we partition the set of hand joints into 5 subsets of joints, each of them contains all joints of a finger. For example, the 5 subsets of joints corresponding to the hand skeleton illustrated in Fig. 1 are given by: J 1 = {3, 4, 5, 6}, J 2 = {7, 8, 9, 10}, J 3 = {11, 12, 13, 14}, J 4 = {15, 16, 17, 18}, J 5 = {19, 20, 21, 22}. Then 5 sequences associated with those 5 subsets are constructed from the output of the first layer. For each J s , with s = 1, . . . , 5, the GaussAgg layer produces SPD matrices given by:

X s,t 2 = Σ Σ Σ s,t + µ µ µ s,t (µ µ µ s,t ) T µ µ µ s,t (µ µ µ s,t ) T 1 (7)
where µ µ µ s,t = 1 4 i∈Js p t 1,i , and

Σ Σ Σ s,t = 1 3 i∈Js (p t 1,i - µ µ µ s,t )(p t
1,i -µ µ µ s,t ) T . The next step uses the ReEig layer [START_REF] Huang | A Riemannian Network for SPD Matrix Learning[END_REF] to perform nonlinear transformations of SPD matrices given by:

X s,t 3 = f (3) r (X s,t 2 ) = U max( I, V)U T , (8)
where X s,t 3 , for s = 1, . . . , 5, t = 1, . . . , n F are the output SPD matrices, UVU T is the eigen-decomposition of X s,t 2 , is a rectification threshold, I is an identity matrix, and max( I, V) is a diagonal matrix defined as:

(max( I, V))(i, i) = V(i, i) if V(i, i) > if V(i, i) ≤ . (9)
Next, a multi-level representation is constructed for the sequence associated with J s for s = 1, . . . , 5. The sequence is evenly subdivided into i sub-sequences at the i th level, i = 1, . . . , n T , with n T the total number of levels. This creates n Q = n T (n T +1)/2 sub-sequences for each J s . Then the SPDTempAgg layer (Sec. III-C) is applied for each subsequence to generate SPD matrices X s,q 4 , using Eq. ( 4) for s = 1, . . . , 5 and q = 1, . . . , n Q :

X s,q 4 = f (4) ta ((X s,t q b 3 , . . . , X s,t q e 3 )), (10)
where t q b and t q e are the beginning and ending frame indices of the q th sub-sequence (X s,t

3 ) for t = t q b , . . . , t q e . Finally, the SPD matrices X s,q 4 are transformed into a SPD matrix by the SPDSpatAgg layer presented in Sec. III-B. The new matrix is transformed to its matrix logarithm via a LogEig layer before being fed into a fully connected (FC) layer, followed by a softmax layer.

E. Gesture Representation

The final representation of a gesture sequence is generated by extracting features from the output of the SPDSpatAgg layer. The obtained matrix is then transformed to its matrix logarithm and finally vectorized. Let B ∈ R d be the output matrix of the SPDSpatAgg layer, then the final representation of the gesture sequence is given as

v = [b 1,1 , √ 2b 1,2 , √ 2b

IV. EXPERIMENTS

We conduct experiments using the DHG dataset [START_REF] Smedt | 3D Hand Gesture Recognition Using a Depth and Skeletal Dataset[END_REF]. The dataset contains 14 gestures performed in two ways: using one finger, and using the whole hand. Each gesture is executed several times by 28 participants. The gestures are subdivided into categories of fine and coarse : Grab (fine), Tap (coarse), Expand (fine), Pinch (fine), Rotation Clockwise (Rot-CW, fine), Rotation Counterclockwise (Rot-CCW, fine), Swipe Right (Swipe-R, coarse), Swipe Left (Swipe-L, coarse), Swipe Up (Swipe-U, coarse), Swipe Down (Swipe-D, coarse), Swipe X (Swipe-X, coarse), Swipe V (Swipe-V, coarse), Swipe + (Swipe-+, coarse), Shake (coarse). The dataset provides the 3D coordinates of 22 hand joints as illustrated in Fig. 1(a).

Experimental settings: The dimension of an output feature vector of the first layer is set to 9. The dimensions of the transformation matrices of the SPDSpatAgg layer are set to 56 × 56. The number of levels used for the SPDTempAgg layer is set to 3. The batch size and the learning rate are set to 30 and 0.01, respectively. The rectification threshold Fig. 3: Confusion matrix for the proposed method on the DHG dataset (best viewed in color).

14 classes 28 classes Huang et al. [START_REF] Huang | A Riemannian Network for SPD Matrix Learning[END_REF] 75.24 69.64 Oreifej and Liu [START_REF] Oreifej | HON4D: Histogram of Oriented 4D Normals for Activity Recognition from Depth Sequences[END_REF] 78.53 74.03 Devanne et al. [START_REF] Devanne | 3-D Human Action Recognition by Shape Analysis of Motion Trajectories on Riemannian Manifold[END_REF] 79.61 62.00 Ohn-Bar and Trivedi [START_REF] Ohn-Bar | Joint Angles Similarities and HOG2 for Action Recognition[END_REF] 83.85 76.53 Chen et al. [START_REF] Chen | Motion Feature Augmented Recurrent Neural Network for Skeleton-based Dynamic Hand Gesture Recognition[END_REF] 84 used for the ReEig layer is set to 0.0001 [START_REF] Huang | Deep Learning on Lie Groups for Skeleton-Based Action Recognition[END_REF]. For gesture classification, we use the LIBLINEAR library [START_REF] He | Deep Residual Learning for Image Recognition[END_REF] with L2regularized L2-loss (dual) to train the classifier and use the default parameter settings in LIBLINEAR (C is set to 1, the tolerance of termination criterion is set to 0.1 and no bias term is added). Following [START_REF] Smedt | 3D Hand Gesture Recognition Using a Depth and Skeletal Dataset[END_REF], we split the dataset into 1960 train sequences (70% of the dataset) and 840 test sequences (30% test sequences). All sequences of the dataset are normalized to have the same length as the longest sequence, which is 171. Since a gesture is performed in two ways, the number of gesture classes can be 14 or 28 [START_REF] Smedt | 3D Hand Gesture Recognition Using a Depth and Skeletal Dataset[END_REF]. We consider both cases in our experiments. The network trained at epoch 20 is used to extract features (Sec. III-E).

Results: Figure 3 shows the confusion matrix of our method on the DHG dataset. The recognition errors concentrate on highly similar actions, e.g. Grap to Pinch. Our method achieves 100% accuracy in recognizing actions Swipe-+, Swipe-V, and more than 90% accuracy in recognizing actions Grap, Rot-CW, Rot-CCW, Swipe-R, Swipe-L, Swipe-X, Shake. The comparison of our method and stateof-the-art methods on the DHG dataset is given in Tab. I. Our method outperforms the second best method [START_REF] Devineau | Deep Learning for Hand Gesture Recognition on Skeletal Data[END_REF] by 1.1 and 1.96 percent points for experiments with 14 and 28 gestures, respectively. It worth mentioning that our network is much simpler than [START_REF] Devineau | Deep Learning for Hand Gesture Recognition on Skeletal Data[END_REF].

V. CONCLUSIONS

We have presented a new hand gesture recognition method based on a neural network for SPD matrix learning. Our method learns a discriminative SPD matrix encoding the first-order and second-order statistics of local features. We have provided the experimental evaluation on a benchmark dataset showing the effectiveness of the proposed method.

Fig. 1 :

 1 Fig. 1: (a) Hand joints estimated by a Intel RealSense camera (b) graph of hand skeleton and the weights associated with the neighbors of node 12 in the convolutional layer.

Fig. 2 :

 2 Fig. 2: (Best viewed in color) The proposed network. (a) A hand skeleton sequence. (b) The convolutional layer for the graph of hand joints. (c) The output of this layer. (d) Construction of different sub-sequences, each of them is associated with a specific finger. Two sub-sequences associated with the thumb and the index are shown here. Each sub-sequence is processed by a branch of the network (from (e) to (j)). (k) The SPD matrices at step (j) are transformed into a SPD matrix.

1 , 3

 13 , . . . , √ 2b 1,d+1 , b 2,2 , √ 2b 2,3 , . . . , b d,d ] T , where b i,i , i = 1, . . . , d are the diagonal entries of log(B) and b i,j , i < j, i, j = 1, . . . , d are the off-diagonal entries at the i th row and j th column of log(B).

82 3.27 9.8 1.72 85.24 7.27 1.96 1.81 1.72 4.41 4.91 1.36 1.63 83.63 1.47 1.72 1.63 84.31 8.19 1.44 3.27 1.96 96.36 1.61 3.27 1.44 5.47 1.72 3.63 1.96 1.81 96.55 1.47 1.81 98.38 3.7 94.44 1.63 3.63 89.7 1.63 1.47 81.96

	Rot-CW Rot-CCW Swipe-R Swipe-L Swipe-U Swipe-D Swipe X	94.1.72	1.85	94.2
	Swipe +		1.63	100.0
	Swipe V			1.44	100.0
	Shake	1.63	1.47	1.44	93.15

TABLE I :

 I Recognition accuracy comparison on the DHG dataset (best results in bold).