Tell me what this is: Few-Shot Incremental Object Learning by a Robot

More recent incremental learning methods rely on storing a fraction of old class data when learning a set of new classes [3, 4]. iCaRL [3] is one of the first methods proposed for incremental learning that combines knowledge distillation [8] and NCM (Nearest Class Mean) classifier for incremental learning. Knowledge distillation uses a distillation loss term that forces the labels of the training data of previously learned classes to remain the same when learning new classes. iCaRL uses the old class data while learning a representation for new classes and uses the NCM classifier for classification of the old and new classes. EEIL [4] improves iCaRL with an end-to-end learning approach. The main issue with these prior approaches is the need to store old class data which is not practical when the memory budget is limited. To avoid storage of real samples, some approaches use generative-memory and regenerate samples of old classes using GANs or autoencoders [9, 10, 11], however the performance of these approaches is generally inferior to approaches that store real images. Moreover, one issue with all these prior incremental learning approaches is that they require a large amount of training data. Hence using these methods for a few-shot incremental learning problem results in extremely poor accuracy.

Incremental learning of novel object classes by a robot has been attempted in the past. Ude et al. uses handcrafted visual features to represent objects that are placed in a robot’s hands to get different views of the objects [14]. This approach, however, uses the feature vectors of all new and old classes for training, hence storing old training data and then further evaluates the success of their system on the training data. Valipour et al. presented a method to incrementally learn objects on a robot from interaction with a human [15]. They train a portion of a pre-trained CNN when learning new classes of objects from examples provided by a human teacher. Turkoglu et al. offer another deep learning approach for learning objects incrementally using mobile robots [16]. They also use prior class data when learning new classes which limits the usefulness of this approach for realistic applications. Another deep learning approach [17] uses random forests to incrementally learn object classes but they do not test their approach on a real robot. Further, their approach requires the complete training set of each class and cannot be applied for few-shot incremental learning. An extension of [15] is presented in [18] for incremental object learning for a robot using a combination of a pre-trained feature extractor and NCM classifier which has been shown to be significantly inferior to other incremental learning approaches [3, 5].

The problems with these prior methods are: 1) That the incremental learning algorithms ([16, 18]) are not compared to other state-of-the-art methods ([3, 4]) or on benchmark datasets ; 2) Most of these approaches train the robot on an object class and then use the same object that was used for training in the test phase, which positively skews the results and limits real world applicability ([15, 18]); 3) Most of the approaches incrementally learn a very small number of new object classes (10 or fewer) using a robot, which, because of the small number of classes, does not exhibit catastrophic forgetting [15, 16, 18] (as shown in Section IV). The real challenge of incremental learning arises when learning a larger set of classes and when there is no overlap between the test and training sets. Moreover, the robotics community would benefit from an evaluation that provides quantitative metrics for comparison with future systems.

Figure 2 depicts the architecture for CBCL. It is composed of three modules: 1) a feature extractor, 2) Agg-Var clustering, and 3) a weighted voting scheme for classification of unlabeled images. In the learning phase, once the human provides the robot with the training examples for a new class, the first step in CBCL is the generation of feature vectors from the images of the new class using a fixed feature extractor. In this paper, we use ResNet-50 [1] pre-trained on ImageNet [19] as the feature extractor.

Next, for each new image class $1\leq y\leq N$, CBCL clusters all of the training images in the class provided by the human. Agg-Var clustering begins by creating one centroid from the first image in the training set of class $y$. Next, for each image in the training set of the class, feature vector $x_{i}^{y}$ (for the $i$the image) is generated and compared using the euclidean distance to all the centroids for the class $y$. If the distance of $x_{i}^{y}$ to the closest centroid is below a pre-defined distance threshold $D$, the closest centroid is updated by calculating a weighted mean of the centroid and the feature vector $x_{i}^{y}$. If the distance between the $i$th image and the closest centroid is greater than the distance threshold $D$, a new centroid is created for class $y$ and equated to the feature vector $x_{i}^{y}$ of the $i$th image.

The result of this process is a collection containing a set of centroids for the class $y$, $C^{y}=\{c_{1}^{y},...,c_{N^{*}_{y}}^{y}\}$, where $N^{*}_{y}$ is the number of centroids for class $y$. This process is applied to the sample set $X^{y}$ of each class incrementally once they become available to get a collection of centroids $C=C^{1},C^{2},...,C^{N}$ for all $N$ classes in a dataset. It should also be noted that Agg-Var calculates the centroids for each class separately. Thus, CBCL’s performance is not strongly impacted when the classes are presented incrementally.

During the testing phase, to predict the label $y^{*}$ of a test image, CBCL uses the feature extractor to generate a feature vector $x$. Next, Euclidean distance is calculated between $x$ and the centroids of all the classes observed so far. Based on the calculated distances, the $n$ closest centroids to the unlabeled image are selected. The contribution of each of the $n$ closest centroids to the determination of the test image’s class is a conditional summation:

The first experiment compares our method for few-shot incremental learning to Few-shot Learning Baseline (FLB) and Fine-Tuning (FT) which were trained for 100 epochs in each increment using a fixed learning rate of 0.001 and cross-entropy loss with minibatches of size 8 optimized using stochastic gradient descent. For CBCL, for each batch of new classes, the hyper-parameters $D$ (distance threshold) and $n$ (number of closest centroids used for classification) were tuned using cross-validation. Only the previously learned centroids and the training data for the new classes were used for hyper-parameter tuning.

A total of 22 object classes were used for this experiment. Common household items were chosen. Figure 3 shows some examples of the object classes toothpaste and hair clip. For each object class, 15 different representative objects were purchased. Two different poses were used for each of the 15 objects per class, hence for each object class we had a total of 30 images. The robot was trained on one or two different randomly chosen classes per increment. During training, at each increment the robot was presented with 2 images of 15 objects for 2 classes; we also test with one class per increment. For 5-shot and 10-shot incremental learning settings, 5 and 10 images (out of the 30) were used as training images, respectively, and the rest were used as test images. As shown in Figure 3, the training and test images are realistic and not idealized. The background of the objects is not perfect since the table has several discolorations and some of the object sizes are rather small. Moreover, the lighting conditions are not ideal and some objects are transparent.

CBCL was compared to two other methods: Fine-Tuning (FT) and a Few-shot Learning Baseline (FLB). The features from the pre-trained ResNet-50 neural network were used for both methods. For both of the methods, ResNet features were passed to a linear layer which was trained using a softmax loss (Figure 5). This procedure follows the prior few-shot learning research [22]. FT simply uses the linear layer trained on the previous classes and adapts it to the incoming classes from the new increment. FLB trains the final linear layer using softmax loss on the complete training set of all the new and old classes in each increment. In other words, FLB does not learn incrementally. Rather, it represents the upper bound for the classification accuracy at each increment. This experiment was conducted over ten rounds in which the ordering of the classes presented to the robot during each increment was random. The selection of the training and test images for each class was also randomized. Average accuracies over all ten rounds are presented as results.

Figure 4 compares CBCL against the two methods for the 5-shot and 10-shot incremental learning experiments with 1 and 2 classes per increment. For the first increment there is no catastophic forgetting so all the methods perform the same. For the rest of the increments, CBCL outperforms FT by significant margins and the difference in classification accuracy between the two methods increases as the number of classes increase for 5-shot and 10-shot cases with both 1 and 2 classes per increment. For FT, catastrophic forgetting (described in the introduction) causes the dramatic decrease in accuracy. Furthermore, as expected, catastrophic forgetting for FT is greater when learning 1 class per increment than when learning 2 classes per increment.

FLB, as a theoretical upperbound, generates the best results at each increment for all cases because it uses the training data of all the classes. In terms of average incremental accuracy, CBCL is only 0.28% and 1.0% lower than the FLB (the theoretical upper bound) for 5-shot and 10-shot incremental learning with one class per increment. For 2 classes per increment, for the first 5 increments CBCL and FLB have the same performance for both 5-shot and 10-shot incremental learning (Figure 4 (c) and (d)). For the next 6 increments CBCL’s accuracy is only slightly lower than the baseline (within 1%) for both 5-shot and 10-shot incremental learning. In terms of average incremental accuracy, CBCL is only 0.61% and 1.09% lower than FLB for 5-shot and 10-shot incremental learning experiments, respectively.

The results indicate that our method’s performance is almost as good as a neural network baseline trained with all of the classes’ training data in one batch. CBCL’s performance is closer to the FLB upperbound when using one class per increment. Moreover, CBCL’s performance is also closer to the upperbound for 5-shot incremental learning. This may suggest that CBCL is best suited for incremental learning situations where data is scarce.

During the teaching phase, the time required to collect a single object image by the robot takes only $\sim 2$ seconds and the time required to extract features for the image takes about 10 seconds. In the learning phase, the time required to learn a set of centroids for a new batch of classes takes around 1 second. During prediction phase, time required to extract the features and predict the label of a test image takes 11 seconds (10 seconds for feature extraction and 1 second for prediction).

This experiment was performed a total of 10 times after learning all 22 object classes incrementally with 2 classes per increment in a 5-shot incremental learning setting. In each of the 10 runs of this experiment we asked the robot to move different object classes. For each run, there are a total of 6 objects present on the table in front of the robot with two objects belonging to the object class to be moved.

Three different kinds of errors can cause the robot to fail in completing this task. The first is a detection error in which the object localization module fails to detect and draw a bounding box around the desired object. The second is the classification error in which the robot fails to predict the correct class of the detected object. The last type of error is a movement error in which the object is correctly detected and recognized, yet the robot fails to pick and move it to the desired place.

Table I reports the average values of these three errors for the 10 runs of the experiment. The highest error rate (detection errors) was 20%. The classification error rate was in accordance with the prior results reported in Figure 4(c). Since, the suction gripper was used to pick and place objects, the robot picked and moved all the objects successfully.

For this experiment, the object localization module takes approximately 30 seconds to find the bounding boxes of the objects in the image, classification of each of the bounding boxes takes about 11 seconds when all 22 classes are learned. Finally, moving each object from the table to a pre-defined place requires approximately 10 seconds. The total time necessary to identify and clean an object is 51 seconds.

For each object arrangement, the robot was presented with a single example. It used the localization and classification modules (5-shot) to get the object locations and labels. The robot stored these relations in the form of 990$\times$1 feature vector (centroid) mentioned above. In the test phase the robot was presented with 20 different object arrangements, 10 of which contained a missing object and the other 10 contained an incorrect object in comparison with the 5 object arrangements learned by the robot. During the test phase, we assumed that the newly presented arrangements were a type of a previously learned arrangement. Hence, by comparing the test arrangement with the earlier learned arrangements it was possible to recognize incorrect arrangements.

The object examples used in the test samples were different from the ones in the training images. For each test sample, the robot first created a 990$\times$1 feature vector and then found the closest centroid using Euclidean distance. Using the closest centroid, the robot then predicted which of the objects were either missing or wrong in the test feature vector. In case of a wrong object, the robot further predicted the correct object in its place using the closest centroid. It should be noted that there can be two centroids at an equal distance from the test feature vector, in that case the robot predicts two possible objects that can replace the missing or wrong object in the test feature vector.

For each of the 20 test scenarios, there was only one object that was missing or wrong but because of classification and detection errors there were cases when the robot had to make predictions about more than one object as missing or wrong. Of the 20 cases, 9 cases required the robot to make two predictions and 11 cases required only one prediction. In these cases where the robot must predict two objects rather than one, the accuracy was (5/9$\times$100) 56%. For cases in which there was no detection error and the robot only had to predict one object the accuracy was 100%. The overall accuracy for all 20 test cases was 16/20$\times$100=80%.