Deep Metric Learning and Image Classification with Nearest Neighbour Gaussian Kernels

TL;DR

This paper introduces a Gaussian kernel loss function for deep neural networks that enhances both metric learning and image classification by creating well-structured embedding spaces, scalable through approximate nearest neighbor search.

Contribution

It proposes a novel Gaussian kernel loss and training algorithm that unifies metric learning and classification, improving scalability and embedding quality.

Findings

Outperforms state-of-the-art deep metric learning methods.

Achieves better classification accuracy than traditional softmax.

Creates semantically meaningful embedding spaces.

Abstract

We present a Gaussian kernel loss function and training algorithm for convolutional neural networks that can be directly applied to both distance metric learning and image classification problems. Our method treats all training features from a deep neural network as Gaussian kernel centres and computes loss by summing the influence of a feature's nearby centres in the feature embedding space. Our approach is made scalable by treating it as an approximate nearest neighbour search problem. We show how to make end-to-end learning feasible, resulting in a well formed embedding space, in which semantically related instances are likely to be located near one another, regardless of whether or not the network was trained on those classes. Our approach outperforms state-of-the-art deep metric learning approaches on embedding learning challenges, as well as conventional softmax classification on several datasets.

Tables

Table 1. Table 1 : Embedding results on Cars196.

	Dims	R@1	R@2	R@4	R@8	NMI
Semi-hard [11]	64	51.54	63.78	73.52	82.41	53.35
LiftStruct [12]	64	52.98	65.70	76.01	84.27	56.88
N-pairs [2]	64	53.90	66.76	77.75	86.35	57.79
Tripl/Gbl [16]	64	61.41	72.51	81.75	88.39	58.20
Cluster [15]	64	58.11	70.64	80.27	87.81	59.04
SmrtMine [13]	64	64.65	76.20	84.23	90.19	59.50
Ours	64	71.05	80.74	88.06	92.79	62.15
Ours	128	73.52	83.37	89.80	93.76	63.35
Ours	256	77.35	85.49	91.10	94.81	63.76
Ours	512	78.39	86.91	92.06	95.52	64.68
Ours	1024	79.65	87.33	92.36	95.65	65.30

Table 2. Table 2 : Embedding results on Birds200.

	Dims	R@1	R@2	R@4	R@8	NMI
Semi-hard [11]	64	42.59	55.03	66.44	77.23	55.38
LiftStruct [12]	64	43.57	56.55	68.59	79.63	56.50
N-pairs [2]	64	45.37	58.41	69.51	79.49	57.24
Tripl/Gbl [16]	64	49.04	60.97	72.33	81.85	58.61
Cluster [15]	64	48.18	61.44	71.83	81.92	59.23
SmrtMine [13]	64	49.78	62.34	74.05	83.31	59.90
Ours	64	51.15	64.64	75.57	84.72	61.26
Ours	128	52.08	64.69	76.05	84.86	61.72
Ours	256	54.74	67.18	77.53	86.09	62.18
Ours	512	55.91	68.26	78.63	86.38	63.50
Ours	1024	57.22	68.75	79.12	87.14	63.95

Table 3. Table 3 : Birds200 test set accuracy with various architectures.

Base Network	Softmax	Ours
AlexNet	62.41	66.95
VGG16	75.37	78.63
ResNet50	78.05	78.98

Table 4. Table 4 : Test accuracy on fine-grained classification datasets.

Dataset	Softmax	Ours
Oxford 102 Flowers	82.79	86.26
Stanford Cars196	85.67	86.52
Leafsnap Field	73.80	75.96

Table 5. Table 5 : Ablation study for classification on Birds200.

Initial Network Weights	Tune $\sigma$	Learn RBF Weights	Fine-tune Network Weights	Test Accuracy
Random	Yes	No	No	1.35
ImageNet	Yes	No	No	47.32
ImageNet	Yes	Yes	No	49.22
ImageNet	Yes	No	Yes	77.94
ImageNet	Yes	Yes	Yes	78.63

Equations

$$f(\mathbf{x},\mathbf{c})=\exp \left(\frac{-\Vert \mathbf{x}-\mathbf{c}{\Vert }^2}{2{\sigma }^2}\right),$$

$$Pr(\mathbf{x}\in \text{mbox}classQ)=\frac{{\sum }_{i\in Q}{w}_{i}f(\mathbf{x},{\mathbf{c}}_{\mathbf{i}})}{{\sum }_{j=1}^m{w}_{j}f(\mathbf{x},{\mathbf{c}}_{\mathbf{j}})},$$

$$Pr(\mathbf{x}\in \text{mbox}classQ)=\frac{{\sum }_{i\in Q\cap \mathcal{N}}{w}_{i}f(\mathbf{x},{\mathbf{c}}_{\mathbf{i}})}{{\sum }_{j\in \mathcal{N}}{w}_{j}f(\mathbf{x},{\mathbf{c}}_{\mathbf{j}})},$$

Full text

**Index Terms— ** Metric Learning, Deep Learning, Transfer Learning, Image Classification, Gaussian Kernel

1 Introduction

Metric learning aims to learn a transformation from the image space to a feature embedding space, in which distance is a measure of semantic similarity. Feature embeddings from semantically similar images will be located nearby, while those of semantically dissimilar images will be located far apart. Applications for such effective feature embeddings include transfer learning, retrieval, zero- and few-shot learning, clustering and weakly or self supervised learning. Image classification is the task of categorising an image into one of a set of classes. Applications include object and scene recognition.

Classification and metric learning are generally treated as separate problems. As such, metric learning approaches have struggled to reach the classification performance of state-of-the-art classifiers. Likewise, classification approaches fail to learn feature spaces that represent inter- and intra-class similarities to the standard of metric learning approaches. Outside of zero- and few-shot learning, some metric learning algorithms have been applied to classification [1, 2], although approaches that perform well in both domains remain uncommon.

We propose a novel loss function and training algorithm for convolutional neural networks that can be applied to both metric learning and image classification problems, outperforming conventional approaches in both domains. Our approach defines training set feature embeddings as Gaussian kernel centres, which are used to push or pull features in a local neighbourhood, depending on the labels of the associated training examples. Fast approximate nearest neighbour search is used to provide an efficient and scalable solution. Our approach differs from kernel or radial basis function neurons [3, 4], as our kernel centres are not learned network parameters, but are defined to be the locations of the training set features in the embedding space. Additionally, we use kernels only in the loss function and classifier, not as activation functions throughout the network. Beyond activation functions, kernels have also been used in neural network classifiers as support vector machines [5, 6, 7]. Our approach is related to NCA [8, 9], but introduces per exemplar weights, makes training feasible through the introduction of periodic asynchronous updates of the kernel centres, and is made scalable for a large number of training examples and a high embedding dimension. Additionally, we explore the importance of the embedding space dimensionality.

The best success on embedding learning tasks has been achieved by deep metric learning methods [10, 11, 12, 2, 13], which make use of deep neural networks. The majority of these approaches use or generalise a triplet architecture with hinge loss [14], although including global loss terms can also be beneficial [15, 16, 13]. Triplet networks take a trio of inputs; an anchor image, an image of the same class as the anchor and an image of a different class. Triplet approaches aim to map the anchor nearer the positive example than the negative example, in the feature space. Such approaches may indiscriminately pull examples of the same class together, regardless of the local structure of the space. In other words, these methods aim to form a single cluster per class, limiting the intra- and inter-class similarities that can be represented. In contrast, our approach considers only the local neighbourhood of a feature, allowing multiple clusters to form for a single class, if that is appropriate. Our approach outperforms state-of-the-art deep metric learning approaches on embedding learning challenges.

The most common approach to image classification is a convolutional neural network trained with softmax loss, which transforms activations into a distribution across class labels [17, 18, 19, 20]. However, softmax is inflexible as classes must be axis-aligned and the number of classes is baked into the network. Our approach is free to position clusters such that the intrinsic structure of the data can be better represented. Our metric learning approach to classification outperforms softmax on several datasets, while simultaneously representing the intra- and inter-class similarities sought by metric learning approaches. Metric learning also allows for new classes to be added on-the-fly, with no updates to the network weights required to obtain reasonable results.

The advantages of our approach are as follows:

• •

Training is made feasible by introducing periodic asynchronous updates of the kernel centres (Section 2.3).

• •

End-to-end learning can be made scalable by leveraging fast approximate nearest neighbour search (Section 2.2).

• •

Our approach can be applied to two separate problems; image classification and metric learning.

• •

Our approach outperforms state-of-the-art deep metric learning algorithms on the Stanford Cars196 and CUB Birds200 2011 datasets (Section 3.1).

• •

Finally, our approach outperforms a conventional softmax classifier on the fine-grained classification datasets CUB Birds200 2011, Stanford Cars196, Oxford 102 Flowers and Leafsnap (Section 3.2).

2 Approach

A Gaussian kernel returns a value that depends only on the distance between a point $\mathbf{x}$ and the Gaussian centre $\mathbf{c}$. The Gaussian kernel $f$ is calculated as:

[TABLE]

where $\sigma$ sets the kernel width. We define the feature embeddings of each training set example as Gaussian kernel centres. Specifically, in a deep neural network we take the layer immediately before the loss function or classifier as the embedding layer. For example, in a VGG architecture, this may be FC7 (fully connected layer 7), forming a 4096 dimension embedding. In general, however, the embedding may be of any size. An overview of this approach is seen in Figure 1.

2.1 Classifier and Loss Function

A classifier is formed by the weighted sum of the kernel distance calculations between a feature embedding and the centres. Classification of an example is achieved by passing the input through the network, resulting in a feature embedding in the same space as the centres. A probability distribution over class labels is found by summing the influence of each centre and normalising. A centre contributes only to the class of the training example coupled to that centre. For example, the probability that feature embedding $\mathbf{x}$ has class label $Q$ is:

[TABLE]

where $f$ is the kernel, $i\in Q$ are the centres with label $Q$, $m$ is the number of training examples and $w_{i}$ is a weight for centre $i$, which is learned end-to-end with the network weights. Note that a global $\sigma$ value is shared by all kernels. If an example is in the training set, the distance calculation to itself is omitted during the computation of the classification distribution, the loss function and the derivatives.

The loss function used is the summed negative logarithm of the probabilities of the true class labels. For example, the loss for example $\mathbf{x}$ with ground truth label $R$ is $-\ln\left(Pr(\mathbf{x}\in\mbox{class }R)\right)$. The same loss function is used for both classification and metric learning problems.

2.2 Nearest Neighbour Gaussian Kernels

Equation 2 is calculated by summing over all kernels. However, since the centres are attached to training examples, of which there can be any large number, computing that sum is both intractable and unnecessary. Most kernel values for a given example will be effectively zero, as the feature will lie only within a subset of the Gaussian windows. As such, we consider only the local neighbourhood of a feature embedding. Considering the nearest Gaussian centres to a feature ensures that most of the distance computations are pertinent to the loss calculation. The classifier equation becomes:

[TABLE]

where $\mathcal{N}$ is the set of approximate nearest neighbours for example $\mathbf{x}$ and $i\in Q\cap\mathcal{N}$ is the set of approximate nearest neighbours that have label $Q$. Again, training set examples exclude their own centre from their nearest neighbour list.

In the interest of providing a scalable solution, we use approximate nearest neighbour search to obtain candidate nearest neighbour lists. This allows for a trade off between precision and computational efficiency. Specifically, we use a Fast Approximate Nearest Neighbour Graph (FANNG) [21], as it provides the most efficiency when needing a high probability of finding the true nearest neighbours of a query point. Importantly, FANNG provides scalability in terms of the number of dimensions and the number of training examples.

2.3 Training the Network

The Gaussian centre locations change as the network weights are updated each training iteration. Although required to compute the derivatives, it is intractable to find the true locations of each example’s neighbouring centres online during training. However, we find that it is not necessary for the centres to be up to date at all times in order for the model to converge. We store a bank of the Gaussian centres and perform periodic asynchronous updates of all centres at a fixed interval.

As the centres change, the nearest neighbours also change. Again, it is intractable to compute the correct nearest neighbours each time the network weights are updated. This is remedied by considering a larger number of nearest neighbours than would be required if all centres and neighbour lists were up-to-date at all times. The embedding space changes slowly enough that it is highly likely many of the previously neighbouring centres will remain relevant. Since the Gaussian kernel decays to zero as the distance between the points becomes large, it does not matter if a centre that is no longer near the example remains a candidate nearest neighbour.

We call the interval at which the Gaussian centres are updated and the nearest neighbours computed during training the update interval. This interval is training set dependant and we find intervals between 1 and 10 epochs work well in our experiments. Note that the stored Gaussian centres do not have dropout [22] applied, but the current training embeddings may.

3 Experiments

3.1 Distance Metric Learning

We evaluate our approach on Stanford Cars196 (16,185 images of 196 car models) [23] and CUB Birds200 2011 (11,788 images of 200 bird species) [24]. In this problem, the network is trained and evaluated on different sets of classes. Following the set-up in [12, 2, 15, 13], we train on the first half of classes and evaluate on the remaining classes. Stochastic gradient descent optimisation is used. Images are resized to 256x256 and data is augmented by random cropping and horizontal mirroring. The object bounding boxes are not used. GoogLeNet [19] with ImageNet [25] pre-trained weights is used as the model. We use 100 nearest neighbours, an update interval of 10 epochs, batch size of 20, base learning of 0.00001 and weight decay of 0.0002. The Gaussian $\sigma$ used depends on the number of dimensions of the feature embedding; values between 10 and 30 work well for this task. We evaluate on two metrics. The first, Normalised Mutual Information (NMI) [26], is a clustering metric that finds the ratio of mutual information and average entropy of a set of clusters and labels. The second, Recall@K (R@K), defines a true positive as an example feature embedding that has at least one out of its true K nearest neighbours with the same class as itself.

We first investigate the importance of the feature embedding dimension, which is set by the output dimensionality of a final fully connected layer. A similar study in [12] suggests that the number of dimensions is not important for triplet networks, in fact, increasing the number of dimensions can be detrimental to performance. We compare our method with increasing dimension size against triplet loss [14, 11] and lifted structured embedding [12], both taken from the study in [12]. Figures 2(a) and 2(b) show the effect of the embedding size on NMI score. While increasing the number of dimensions does not necessarily improve performance for triplet-based networks, higher dimensionality can be utilised by our approach, as the NMI score improves as the dimensionality increases. Similar behaviour is seen in Figures 2(c) and 2(d), which show the Recall@K metric for our approach. Again, this shows that our approach can take advantage of a higher dimensionality.

Our approach is compared to the state-of-the-art in Tables 1 and 2, with the compared results taken from [15] and [13]. Since, as discussed above, the dimensionality does not have much impact on the other approaches, all results in [15] and [13] are reported using 64 dimensions. For fair comparison, we report our results at 64 dimensions, but also at the better performing higher dimensions. Our approach outperforms the other methods in both the NMI and Recall@K measures, at all embedding sizes presented. Our approach is able to produce better compact embeddings than existing methods, but can also take advantage of a larger embedding space.

3.2 Image Classification

We compare classification performance with conventional softmax loss. Images are resized to 256x256 and random cropping and horizontal mirroring is used for data augmentation. Unlike in Section 3.1, we crop Birds200 and Cars196 images using the provided bounding boxes before resizing. The same classes are used for training and testing. All datasets are split into training, validation and test sets. For all approaches, we select hyperparameters that minimise the validation loss. For our approach with a VGG [18] or AlexNet [17] architecture, the FC7 layer (4096 dimensions), with dropout and without a ReLU, is used as the embedding layer. For a ResNet architecture [20], we use the final pooling layer (2048 dimensions). We find that following the ResNet embedding layer with a dropout layer results in a small performance gain for both our approach and softmax. A batch size of 20, update interval of 10 epochs and base learning rate of 0.00001 are used for our approach. We use stochastic gradient descent optimisation. A Gaussian $\sigma$ of around 100 is found to be suitable for the 4096 dimension VGG16 embeddings on Birds200. Networks are initialised with ImageNet [25] pre-trained weights.

We first evaluate on the Birds200 dataset. Since there is no standard validation set for this dataset, we take 20% of the training data as validation data. In Table 3, we evaluate with three network architectures; AlexNet [17], VGG16 [18] and ResNet50 [20]. Additionally, the effect of the number of training examples per class is shown in Figure 3. Our approach outperforms softmax loss at all numbers of training images, with a particularly large gain when training data is scarce. Further, we investigate the importance of the per kernel weights, e.g. $w_{i}$ from Equation 3, and find that learning the weights end-to-end with the network results in a 0.69% increase in accuracy, compared with fixing the weights at a value of one.

We further evaluate our approach on three other fine-grained classification datasets; Oxford 102 Flowers [27], Stanford Cars196 [23] and Leafsnap [28]. We use the standard training, validation and test splits for Oxford 102 Flowers. For Stanford Cars196, we take 30% of the training set as validation data. We use the challenging field images from Leafsnap, which are taken in uncontrolled conditions. The dataset contains 185 classes of leaf species and we split the data into 50%, 20% and 30% for training, validation and testing, respectively. Results are shown in Table 4.

4 Conclusion

Our novel nearest neighbour Gaussian kernel approach to deep metric learning outperforms state-of-the-art metric learning approaches on embedding learning problems. Additionally, our approach is able to outperform conventional softmax loss when applied to classification problems. Importantly, the same loss function and training algorithm is used for both of these target domains.

5 Supplementary Material

In this section we provide supplementary qualitative and quantitative results to further evaluate our proposed approach.

5.1 Ablation Study

Table 5 shows an ablation study for our proposed approach. For each of the five arrangements of settings, the value of the Gaussian kernel $\sigma$ is first tuned to minimise validation loss. The impact of learning the Gaussian kernel weights and fine-tuning network weights is shown.

5.2 Neighbourhood Size

Figure 4(a) shows the impact of the number of nearest neighbours used for each example during training. There is a clear lower bound required for good performance. This is because, as discussed in Section 2.3, the network weights are constantly being updated, but the stored kernel centres are not. As such, we need to consider a larger number of neighbours than if the centres were always up-to-date. Figure 4(b) shows the average distance from each training example to its 200 nearest Gaussian kernel centres, at different points during training. Similarly, Figure 4(c) shows the average Gaussian kernel value (from Equation 1) between training examples and their 200 nearest centres. These experiments use a VGG16 architecture.

5.3 Embedding Space Visualisation

A t-SNE [29] visualisation of the learned embedding space for the Birds200 dataset is shown in Figure 5. Similarly, Figure 6 shows a visualisation for the Cars196 dataset. The visualised embeddings are the test set examples from the transfer learning task in Section 3.1. The classes shown in the visualisations are withheld and unseen by the network during training. Despite belonging to novel classes, examples are still well clustered based on class and attributes.