Talking With Your Hands: Scaling Hand Gestures and Recognition With CNNs

TL;DR

This paper introduces a CNN-based framework for recognizing scaled hand gestures formed by gesture-phonemes, enabling exponential growth in gesture vocabulary, supported by a new benchmark dataset and achieving high accuracy.

Contribution

It proposes a novel methodology to scale hand gestures using gesture-phonemes and introduces the SHGD dataset for training and evaluation.

Findings

Achieved 98.47% accuracy on 15-class gestures

Achieved 94.69% accuracy on 810-class gestures

Demonstrated exponential scaling of gesture vocabulary

Abstract

The use of hand gestures provides a natural alternative to cumbersome interface devices for Human-Computer Interaction (HCI) systems. As the technology advances and communication between humans and machines becomes more complex, HCI systems should also be scaled accordingly in order to accommodate the introduced complexities. In this paper, we propose a methodology to scale hand gestures by forming them with predefined gesture-phonemes, and a convolutional neural network (CNN) based framework to recognize hand gestures by learning only their constituents of gesture-phonemes. The total number of possible hand gestures can be increased exponentially by increasing the number of used gesture-phonemes. For this objective, we introduce a new benchmark dataset named Scaled Hand Gestures Dataset (SHGD) with only gesture-phonemes in its training set and 3-tuples gestures in the test set. In our experimental analysis, we achieve to recognize hand gestures containing one and three gesture-phonemes with an accuracy of 98.47% (in 15 classes) and 94.69% (in 810 classes), respectively. Our dataset, code and pretrained models are publicly available.

Figures

Tables

Table 1. Table 1: 15 single gesture classes in Scaled Hand Gesture Dataset (SHGD). ∗ marks the dynamic gestures which are not included as gesture-phonemes.

Label	Gesture	Label	Gesture	Label	Gesture
1	Fist	6	Two Fingers	11	Swipe Left∗
2	Flat Hand	7	Five Fingers	12	Swipe Right∗
3	Thumb Up	8	Stop Sign	13	Pull Hand In∗
4	Thumb Left	9	Check	14	Move Hand Up∗
5	Thumb Right	10	Zero	15	Move Hand Down∗

Table 2. Table 2: 3D-SqueezeNet architecture. Fire block is depicted in Fig. 4 (a).

Layer / Stride	Filter size	Output size
Input clip		$c$$\times$8$\times$112$\times$112
Conv1/s(1,2,2)	3$\times$3$\times$3	64$\times$8$\times$56$\times$56
MaxPool/s(1,2,2)	3$\times$3$\times$3	64$\times$8$\times$28$\times$28
Fire2		128$\times$8$\times$28$\times$28
Fire3		128$\times$8$\times$28$\times$28
MaxPool/s(2,2,2)	3$\times$3$\times$3	128$\times$4$\times$14$\times$14
Fire4		256$\times$4$\times$14$\times$14
Fire5		256$\times$4$\times$14$\times$14
MaxPool/s(2,2,2)	3$\times$3$\times$3	256$\times$2$\times$7$\times$7
Fire6		384$\times$2$\times$7$\times$7
Fire7		384$\times$2$\times$7$\times$7
MaxPool/s(2,2,2)	3$\times$3$\times$3	384$\times$1$\times$4$\times$4
Fire8		512$\times$1$\times$4$\times$4
Fire9		512$\times$1$\times$4$\times$4
Conv10/s(1,1,1)	1$\times$1$\times$1	NumCls$\times$1$\times$4$\times$4
AvgPool/s(1,1,1)	1$\times$4$\times$4	NumCls

Table 3. Table 3: 3D-MobileNetV2 architecture. Block is inverted residual block whose details are given in Fig. 4 (b) and (c). Expansion factor of 6 is applied except for the initial Block where expansion factor of 1 is applied.

Layer / Stride	Repeat	Output size
Input clip		$c$$\times$8$\times$112$\times$112
Conv1(3$\times$3$\times$3)/s(1,2,2)	1	32$\times$8$\times$56$\times$56
Block/s(1,1,1)	1	16$\times$8$\times$56$\times$56
Block/s(1,2,2)	2	24$\times$8$\times$28$\times$28
Block/s(2,2,2)	3	32$\times$4$\times$14$\times$14
Block/s(2,2,2)	4	64$\times$2$\times$7$\times$7
Block/s(1,1,1)	3	96$\times$2$\times$7$\times$7
Block/s(2,2,2)	3	160$\times$1$\times$1$\times$1
Block/s(1,1,1)	1	320$\times$1$\times$1$\times$1
Conv(1$\times$1$\times$1)/s(1,1,1)	1	1280$\times$1$\times$1$\times$1
Linear(1280$\times$NumCls)	1	NumCls

Table 4. Table 4: Results of different models on the validation set of Jester dataset. For 2D CNNs, FLOPs are calculated for extracting one frames features and final fc layers.

Model	Params	MFLOPs	Acc.(%)
2D-SqueezeNet	0.89M	310	87.40
2D-MobileNetV2	2.41M	366	91.35
3D-SqueezeNet	1.85M	686	87.74
3D-MobileNetV2	2.39M	344	93.33

Table 5. Table 5: Results of different models with different modalities on the test sets of SHGD-15 and SHGD-13.

	Model	Accuracy (%)
		SHGD-15	SHGD-13
IR	2D-SqueezeNet	98.13	92.56
	2D-MobileNetV2	97.36	93.11
	3D-SqueezeNet	92.99	95.87
	3D-MobileNetV2	92.85	94.62
Depth	2D-SqueezeNet	98.13	95.02
	2D-MobileNetV2	98.13	95.64
	3D-SqueezeNet	89.93	95.87
	3D-MobileNetV2	92.78	95.85
IR+D	2D-SqueezeNet	98.47	93.94
	2D-MobileNetV2	97.92	95.06
	3D-SqueezeNet	92.64	95.59
	3D-MobileNetV2	94.31	96.06

Table 6. Table 6: Performance for the tuple detection. Det, Tup and Sin refer to the number of detector, tuple and single phoneme errors out of 1620 test samples.

	Model	Error			Acc.(%)
		Det	Tup	Sin
IR	2D-SqueezeNet	191	54	126	84.88
	2D-MobileNetV2	116	103	248	86.60
	3D-SqueezeNet	11	159	375	89.51
	3D-MobileNetV2	10	209	492	86.48
Depth	2D-SqueezeNet	73	127	275	87.65
	2D-MobileNetV2	77	111	259	88.40
	3D-SqueezeNet	68	200	261	83.46
	3D-MobileNetV2	82	169	271	84.51
IR+D	2D-SqueezeNet	125	79	184	87.41
	2D-MobileNetV2	41	71	165	93.09
	3D-SqueezeNet	7	103	228	93.21
	3D-MobileNetV2	3	83	171	94.69

Equations

$$N=m(m-1{)}^{(s-1)}$$

$$P=\left[\begin{matrix}\bigm{|}&\cdots&\bigm{|}&\cdots&\bigm{|}\\ P_{0}&\cdots&P_{t}&\cdots&P_{T-1}\\ \bigm{|}&\cdots&\bigm{|}&\cdots&\bigm{|}\\ \end{matrix}\right],\hskip 2.84544ptP_{t}=\left[\begin{matrix}p_{t,0}\\ p_{t,1}\\ \vdots\\ p_{t,N-1}\end{matrix}\right]$$

$$m_{t,i}=\left[{\pi }_{t,i},s_{t,i},k_{t,i}\right],0\le i<\gamma ,0\le t<T$$

$$s_{t+1,i}=s_{t,i}+p_{t+1,i}+\delta ,\delta =\{\begin{array}{ll}-0.2,& \text{if}{n}_{t+1,i}\ne {\pi }_{t,i}^{last}\\ & \text{and}{k}_{t,i}<K\\ 0,& \text{otherwise}\end{array}$$

$${\pi }_{t+1,i}=\{\begin{array}{ll}{\pi }_{t,i}\cup n_{t+1,i},& \text{if}{n}_{t+1,i}\ne {\pi }_{t,i}^{last}\text{and}{k}_{t,i}<K\\ {\pi }_{t,i},& \text{otherwise}\end{array}$$

$$k_{t+1,i}=\{\begin{array}{ll}{k}_{t,i}+1,& \text{if}{n}_{t+1,i}\ne {\pi }_{t,i}^{last}\text{and}{k}_{t,i}<K\\ k_{t,i},& \text{otherwise}\end{array}$$

$$Acc=(1-\frac{Er{r}_{det}+Er{r}_{tup}}{N_{samples}})\%$$

Full text

1 Introduction

Computers have become an indispensable part of human life. Therefore, facilitating natural human-computer interaction (HCI) contains utmost importance to bridge human-computer barrier. Gestures have long been considered as an interaction technique delivering natural and intuitive experience while communicating with computers. This is a driving force in the research community to work on gesture representations, recognition techniques and frameworks.

As technology keeps advancing, the use of computers in our lives increases as well with additional new devices such as smart phones, watches, TVs, headphones, autonomous cars etc. Therefore, the communication between humans and machines gradually becomes more complex, requiring HCI systems to accommodate the introduced complexities.

In this work, we propose an approach to scale hand gestures by composing each gesture with multiple gesture-phonemes. The main inspiration comes from the phonology and morphology of the spoken languages. Fig. 1 (top) shows the morphological and phonological analysis of the sentence “give her the post”. Each word in this sentence is composed of a sequence of phonemes. Similarly, we create hand gestures using one or multiple gesture-phonemes sequentially, as shown in Fig. 1 (bottom). So, our motivation is first to learn the gesture-phonemes successfully, then to recognize hand gestures, which contains multiple gesture-phonemes, with only this knowledge.

Structuring hand gestures with this approach enables to scale hand gestures without requiring to collect additional training data. For a given number of gesture-phonemes, the number of all possible hand gestures is exponentially proportional to the number of gesture-phonemes each gesture contains. For the proposed gesture scaling approach, we present a convolutional neural network (CNN) based framework using sliding-window approach together with Viterbi-like [29] decoder algorithm. For the CNN model, we have used 2-dimensional (2D) and 3-dimensional (3D) SqueezeNet and MobileNetV2 models.

This paper presents the following contributions:

1. (i)

Our major contribution is creating hand gesture recognition framework, which is “scalable” according to the complexity of the desired HCI system. To the best of our knowledge, this is the first work that address the scalability of hand gestures. The CNN model is only trained with 10 gesture phonemes and 3 signaling classes (preparation, retraction and no-gesture), and the framework can recognize scaled gesture tuples with 3 gesture phonemes (as in this paper) or more. Assumed that a HCI system with the recognition capability of 810 different gestures needs to be implemented. With the old fashioned way, you need to define 810 different hand gestures, collect enough training samples (400 training samples for each class), train an architecture to get desired accuracy (remember that for ChaLearn IsoGD [30], the state-of-the-art accuracy is around 80% for 249 classes). With this framework, you just need to train with 10 gesture phonemes and 3 signaling classes, then for 810 classes (3-tuple gestures) you can achieve around 95% accuracy. Consider the situation when you need 65610 different gestures (5-tuple gestures). Approximately 25 million training samples are needed for the old fashioned way. 2. (ii)

The second contribution is the benchmark dataset named Scaled Hand Gestures Dataset (SHGD), which will be made publicly available. The videos are collected using a Time-of-Flight (ToF) based 3D Image Sensor, which is shown in Fig. 2. The dataset contains only gesture-phonemes in its training set. For the test set, SHGD contains gesture-phonemes and 3-tuple gestures. 3. (iii)

The third contribution of the paper is that with the designed Viterbi-like decoder, the performed 3-tuple gestures are recognized only once. This contains utmost importance for online HCI systems. Moreover, designed Viterbi-like decoder is very lightweight as HCI systems should be designed considering the memory and power budget of the HCI system.

2 Related Work

Ever since AlexNet [17], deep CNNs have dominated nearly all computer vision tasks. At first, CNNs have infiltrated to the image-based tasks due to the availability of only large scale image datasets such as ImageNet [3]. Afterwards, CNNs are also applied for video analysis tasks. However, as the first video datasets were comparatively small such as UCF-101 [28] and HMDB [18], all initial video analysis architectures are based on 2D CNNs which utilize transfer learning from ImageNet, such as [27, 14, 31, 4]. With the availability of large-scale video datasets like Sports-1M [14], Kinetics [1], Jester [7], this problem was solved and successful 3D CNNs could be trained from scratch without overfitting [9].

Since gestures provide a natural, creative and intuitive interaction experience for communication with computers, hand gesture recognition is one of the most popular video analysis tasks. Although there have been many approaches using hand-crafted features like orientation of histograms [5], histogram of oriented gradients (HOG) [25] or bag-of-features [2], the state of the art hand gesture recognition architectures are based on CNNs [16, 22, 21, 23, 15], similar to other computer vision tasks.

Until recently, the primary trend has been to make CNNs deeper and more complicated [12, 10] in order to achieve higher classification performance. But the pursue of lightweight networks with high accuracy is now growing, as in many real-time applications like autonomous driving and robotics, where the computation capability of the platform is always limited. Therefore, there has been several resource efficient CNN architectures such as SqueezeNet[13], MobileNet [11], MobileNetV2 [26], ShuffleNet [32] and ShuffleNetV2 [19], which aim to reduce computational cost but still keep the accuracy high. In our work, we have used the 2D and 3D versions of SqueezeNet and MobileNetV2 since we want a lightweight framework.

Fusion of different modalities is another strategy that helps CNNs to improve recognition performance. However, fusion also introduces extra computational cost especially at decision [27] and feature [20] level. On the other hand, [16] proposes a data level fusion strategy, Motion Fused Frames (MFFs), where different modalities can be fused with very little modification to the network and computational cost. Since we have infrared (IR) and depth modalities in our dataset, we have adapted data level fusion strategy.

Although there have been many gesture recognition approaches, the idea of scaling hand gestures is very new but also very important in order to create complex HCI systems. To the best of our knowledge, this is the first work that scales hand gestures. More importantly, besides scaling, we achieve very similar recognition performance for gesture-tuples (94.69% accuracy for 810 classes) compared to single gestures (98.47% accuracy for 15 classes).

3 Methodology

In this section, we fist describe the collected dataset. Afterwards, we explain the details of the experimented framework with its 2D and 3D CNN architectures and Viterbi-like decoder. Finally, we give the training details.

3.1 Scaled Hand Gestures Dataset (SHGD)

SHGD contains 15 single hand gestures, each recorded for infrared (IR) and depth modalities using Infineon® IRS1125C REAL3TM 3D Image Sensor. Each recording contains 15 gesture samples (one sample per class). There are in total 324 recordings from 27 distinct subjects in the dataset. Recordings of 8 subjects are reserved for testing, which makes 30% of the dataset. Every subject makes 12 video recordings using two hands under 6 different environments, which are designed for increasing the network robustness against different lightning conditions and background disturbances. These environments are (1) indoors under normal daylight, (2) indoors under daylight and with an extra person in the background, (3) indoors at night under artificial lighting, (4) indoors in total darkness, (5) outdoors under intense sunlight and (6) outdoors under normal sunlight. We have simulated outdoor environments using two bright lights: Two lights for “intense sunlight” and one light for “normal sunlight”.

Fig. 2 shows data collection setup, used camera and data samples. Subjects performed gestures while observing the computer screen, where the gestures were prompted in a random order. Videos are recorded at 45 frames per second (fps) with spatial resolution of 352$\times$287 pixels. Each recording lasts around 33 seconds.

3.1.1 Single Gestures

In its training set, SHGD contains only single gestures under 15 classes, which are given in Table 1. Recordings in the dataset are continuous video streams meaning that each recording contains no-gesture and gesture parts. Moreover, each gesture contains preparation, nucleus and retraction phases [24, 6, 8], which are critical for real-time gesture recognition.

Among the single gesture classes listed in Table 1, static gestures are selected as gesture-phonemes since it is more convenient to perform different static gestures sequentially. For the rest of the paper, we will use the term phoneme instead of gesture-phoneme for the sake of easiness.

3.1.2 Gesture Tuples

Gesture tuple refers to hand gestures which contain sequentially performed phonemes. There are in total 10 different phonemes. When constructing gesture tuples, we leave out the consecutive same phonemes to avoid sequence length confusion. Therefore, the total number of different tuples can be calculated by the following equation:

[TABLE]

where $m$ is the number different phonemes and $s$ is the number of phonemes that the gesture tuple contains.

Besides the test set for single gestures, SHGD also has a test set for gesture tuples containing 3 phonemes. 5 subjects perform gesture tuples under 5 different lightning conditions (excluding the environment of (2)). There are in total $10\times(10-1)^{(3-1)}=810$ permutations meaning different classes for 3-tuple gestures. Recordings are not segmented for this case. Therefore, one recording contains no-gesture, 3-tuple gesture and no-gesture without exact location of 3-tuple gesture.

Since gestures are performed at different speeds in the real-life scenarios, we have also collected 3-tuple gestures at three different speeds: Slow, medium and fast. The subjects should finish 3-tuple gestures within 300 frames (6.7 sec), 240 frames (5.3 sec) and 180 frames (4 sec) for slow, medium and fast speed, respectively.

3.1.3 SHGD-15 and SHGD-13

SHGD-15 refers to the standard dataset where all single gestures in Table 1 are included. On the other hand, SHGD-13 is specifically designed for 3-tuple gesture recognition. Besides 10 phonemes, SHGD-13 also contains preparation (raising hand), retraction (lowering hand) and no-gesture classes. As there is no indication when a gesture starts and ends in the video, we use preparation and retraction classes to detect Start-of-Gesture (SoG) and End-of-Gesture (EoG). We use no-gesture class to reduce the number false alarms since most of the time, “no gesture” is performed in real-time gesture recognition applications [15].

SHGD-15 is a balanced dataset with 96 samples in each class. However, SHGD-13 is an imbalanced dataset, where preparation and retraction classes contain 10 times more samples than phonemes, whereas no-gesture contains around 20 times more samples than phonemes. Therefore, training of SHGD-13 requires special attention.

3.2 Network Architecture

The general workflow of the proposed architecture is depicted in Fig. 3. A sliding window goes through the video stream with a queue size of 8 frames and stride s of 1. The frames in the input queue is passed to a 2D/3D CNN which is pretrained on SHGD-13. The classification results are then post-processed by averaging with non-overlapping window size of 5. In this way, we can filter out some fluctuations due to the ambiguous states while changing the phonemes. Next, the post-processed outputs are fed into a detector queue, which tries to detect SoG and EoG. When the sum of class scores for preparation is higher than the threshold, we set SoG flag on, activate the classifier queue and start storing the post-processed scores. Then, the detector queue is responsible for detecting EoG in a similar manner. After EoG flag is received, we deactivate the classifier queue and run the Viterbi-like decoder which recognizes the 3-tuple gesture. In the next parts, we explain the details for the main building blocks in the proposed architecture.

3.2.1 2D and 3D CNN Classifiers

CNN classifier is the most critical part of the proposed architecture. The properties of the deployed CNNs determine the detection and classification performance, memory usage and the speed of the overall architecture. In order to fulfill the resource constrained conditions and run as a real time application, two lightweight models are preferred selecting SqueezeNet [13] and MobileNetV2 [26] as classifiers in our architecture. In our analyses, we have deployed the 2D and 3D versions of these models.

The input to the CNN classifier is always 8 frames. Using these 8 frames, CNN classifier should recognize static phonemes together with dynamic preperation and retraction classes successfully. 3D CNNs can capture this dynamic motion information inherently due to their 3D convolutional kernels. However, 2D CNNs requires an extra spatiotemporal modeling in order to reason the relations between different frames.

Fig. 5 depicts the applied spatiotemporal modeling approach used for 2D CNN models. Features of each 8 frames are extracted using the same 2D CNN and concatenated keeping their order intact. Afterwards, two levels of fully connected (fc) layers are applied in order to get class-conditional probability scores. The reason behind is that fc layers can organically infer the temporal relations, without knowing it is a sequence at all. The size of features 2D CNNs extracts is 64 for each frame. With the first fc layer, feature dimension is reduced from 64$\times$8=512 to 256. With the second fc layer, dimension is reduced to the number of classes.

On the other hand, 3D CNNs contains spatiotemporal modeling intrinsically and does not require an extra mechanism. We have inflated SqueezeNet and MobileNetV2 such that they accept 8 frames as input. The details of the 3D-SqueezeNet and 3D-MobileNetV2 are given in Table 2 and Table 3, respectively. Their main building blocks are also depicted in Fig. 4.

3D-SqueezeNet is deployed with simple bypass, as it achieves better results in the original architecture. However, we have not used simple bypass for its 2D version, as 2D-SqueezeNet pretrained on ImageNet is only available without bypass. For MobileNetV2, we have used $width\_multiplier$ of 1 for both 2D and 3D versions.

The spatial size of the inputs are 224 and 112 for 2D and 3D CNNs, respectively. The number of input channels $c$ depends on the experimented input data modality. Besides IR and depth, we have also applied data level fusion to IR and Depth (IR+D) in our experiments. We have used RGB modality only in pretrainings. Accordingly, the number of input channels are 3, 2, 1, 1 for RGB, IR+D, IR, depth modalities, respectively. The final size of inputs are c$$\times224$\times$224 for 2D CNNs, and c$$\times8$\times$112$\times$112 for 3D CNNs.

3.2.2 Viterbi-like Decoder

Viterbi decoding was invented by Andrew Viterbi [29] and is now widely used in decoding convolutional codes. It is an elegant and efficient way to find out the optimal path with minimal error. In this paper, we have adapted it and used a Viterbi-like decoder to find out the phoneme sequences in 3-tuple gestures with maximal probability. Same as conventional Viterbi algorithm, we narrow down the optional paths systematically for each new input in the classifier queue.

For the Viterbi-like decoder, we introduced a couple of terms for better comprehensibility: K is the number of allowed state transitions in the output sequence, which is 2 as we use 3-tuple gestures. The state refers to a phoneme in a path for the given time instant. P refers to class-conditional probability scores for phonemes stored in Classifier Queue, which is shown in (2), whose columns $P_{t}$ are the average probability scores of each phoneme for five consecutive time instants. $P_{t}$ values are softmaxed before putting in P. T is the length of P (i.e. number of columns), and N is the number of phoneme classes, which is $10$ in our case. Therefore, the size of P is T$\times$N.

[TABLE]

The probability of a path is the sum of the probability scores of all the states that this path goes through. Besides the number of allowed transitions K, we introduce another constraint, transition cost $\delta$, in order to prevent false state transitions in the path. A path metric M holds the paths $m_{t,i}$ with their sequence record $\pi_{t,i}$, path score $s_{t,i}$ and the transition times $k_{t,i}$. The path $m_{t,i}$ is shown as following:

[TABLE]

The state of path $m_{t,i}$ at time instant $t$ is denoted as $n_{t,i}$, and the last state in $\pi_{t,i}$ is also denoted as $\pi^{last}_{t,i}$. The transition cost is set to -0.2. The path scores s, transition record $k$ and sequence record $\pi$ are updated with every new $P_{t}$ as following:

[TABLE]

[TABLE]

[TABLE]

In order to reduce computation, we limit the number of paths in M to $\gamma$, which is set to 300. The working mechanism of the proposed Viterbi-like decoder is given in algorithm 1. Fig. 6 depicts the illustration of our Viterbi-like decoder. Our decoder can inherently deal with the ambiguities at phoneme transitions as it naturally makes use of temporal ensembling.

3.3 Training Details

In the trainings, we have used Stochastic Gradient Descent (SGD) with standard categorical cross-entropy loss. While we have used 5$\times$10*-4* and 1$\times$10*-3* weight decay for 2D and 3D CNNs, respectively, the momentum is kept same as 0.9 for all the trainings. As Jester is the largest available hand gesture dataset [7], we have pretrained all models on Jester dataset before fine tuning on SHGD-15 and SHGD-13. For 2D CNN models, before Jester pretraining, we also have used models pretrained with ImageNet as starting point. The learning rate for 2D CNNs is initialized at 0.001 and reduced with a factor of 0.1 at 25th, 35th and 45th epochs. For trainings of 3D CNNs on Jester dataset, learning rate is initialized with 0.1 and reduced twice with a factor of 0.1 at 30th and 45th epochs. All trainings are completed at $60^{th}$ epoch for Jester and SHGD.

For fine tuning of SHGD-15 and SHGD-13, the pretrained parameters are loaded except for the first convolutional layer and the last fully connected layer. The number of input channels for the first convolutional layer is modified from 3 (RGB) to 2 for IR+D and 1 for IR and Depth modalities. In the last fully connected layer, the number of output features is set to the number of classes in SHGD. For SHGD-13, we have deployed weighted categorical cross-entropy loss as it is an unbalanced dataset.

We have deployed several data augmentation techniques such as random rotation ($\pm 10^{\circ}$), random resizing and random spatial cropping. Apart from spatial augmentations, we also applied temporal augmentations. Input clips are selected from random temporal positions given the bounds of each class. Moreover, at pretraining of 2D CNNs on Jester dataset, frames are selected randomly within each segment of videos as in Temporal Segment Network (TSN) [31], which introduces extra variation in the trainings.

4 Experiments

4.1 Results using Jester dataset

Jester is currently the largest available hand gesture dataset. There are in total 148.092 video samples collected for 27 different classes. As the labels of the test set are not publicly available, we have experimented on the validation set of the dataset. Table 4 summarizes the achieved results for our models. Besides the classification accuracy, the computational complexity in terms of floating point operations (FLOPs) and number of parameters are also given in Table 4 in order to highlight the resource efficiency of our models. The best result is achieved by 3D-MobileNetV2 with accuracy of 93.33%.

4.2 Results using SHGD-15 and SHGD-13

The performance of our models for SHGD-15 and SHGD-13 using different modalities are given in Table 5. The best results are achieved by 2D-SqueezeNet (98.47%) and 3D-MobileNetV2 (96.06%) for SHGD-15 and SHGD-13, respectively, both at IR+D modality.

For SHGD-15, 2D CNNs always achieve better results than 3D CNNs for all modalities. This is because of the fact that around 66.67% of samples in SHGD-15 are static gestures, and 2D CNNs captures static content better than 3D CNNs. On the other hand, around 20% of samples in SHGD-13 are static gestures resulting 3D CNNs to perform better. In order to highlight this situation, we have plotted the receiver operating characteristics (ROC) curves for static phoneme classes; and dynamic preparation and retraction classes in SHGD-13, which can be seen in Fig. 7, where the same results can be observed.

Different models are sensitive to different data modalities. For instance, 2D-MobileNetV2 performs better at depth modality, whereas 3D-MobileNetV2 performs best at IR+D modality. However, fusion of different modalities (IR+D) results in better performance most of the time.

4.3 Results for 3-tuple gesture recognition

In this section, we evaluate the performance of our models for 3-tuple gesture recognition. Test set for this objective contains 1620 samples from 810 different permutations (i.e. classes). In order to evaluate the performance, three different errors and the total accuracy are defined as following:

• •

Detector error: The number of the gesture tuples, in which SoG or EoG is not successfully detected. It includes the flags detected at the wrong time and flags not detected at all.

• •

Tuple error: The number of the gesture tuples, whose predicted sequence does not match to the ground truth.

• •

Single error: The number of the single phonemes which are recognized mistakenly inside the tuple error. For instance, if the ground truth is [6,8,10] and the recognized tuple is [6,10,12], then the single error is 2.

• •

Total accuracy: The percentage of the correctly predicted tuples in the whole test set, where $N_{samples}$ is equal to 1620. It is calculated as following:

[TABLE]

For this task, models are trained with SHGD-13. Table 6 gives the performance of experimented models on different modalities for 3-tuple gesture recognition. For the detection threshold of detector, 5 and 6 are used for 2D and 3D CNNs, respectively. Similar to previous results, 3D CNNs capture dynamic classes better and make less detector errors. On the other hands, 2D CNNs make less tuple and single error as they consist of static classes.

3D-MobileNetV2 achieves the best performance with an accuracy of 94.69% for recognizing 810 different gesture tuples. 3D CNNs surpass 2D CNNs in this task generally, except for depth modality. We assume that this is due to the noise pixels appearing in depth modality from time to time. Therefore, 3D CNNs fail to capture the temporal relations between noisy frames.

5 Conclusion and Outlook

In this paper, we propose a novel approach for scaling hand gestures such that CNNs can recognize without requiring an enormous quantity of training data or extra training effort. For this objective, we create and share a benchmark dataset, Scaled Hand Gestures Dataset (SHGD), which contains gesture tuples having a sequence of gesture phonemes. Moreover, we have proposed a network architecture for recognition of gesture tuples using a novel Viterbi-like decoder. In our experiments, we have used the 2D and 3D versions of the SqueezeNet and MobileNetV2 models. We achieve a classification accuracy of 98.47% for 15 single gesture classes, and we achieve an accuracy of 94.69% for recognition of 810 different 3-tuple gesture classes.

The proposed approach contains utmost importance in order to meet the needs of applications requiring more complex HCI systems. We can easily scale hand gestures exponentially by increasing the number of gesture phonemes in multi-tuple gestures.

Similar to Rotokas language (spoken on the island of Bougainville), which contains 11 phonemes, we plan to create a hand language by using multi-tuple gestures and start talking with our hands.

Acknowledgements

We gratefully acknowledge the support of NVIDIA Corporation with the donation of the Titan Xp GPU, and Infineon Technologies with the donation of Pico Monstar ToF camera used for this research.