1 Introduction↩︎

Visual search or retrieval systems [1], [2] are widely used in many real-world applications such as face recognition [3]–[7], person re-identification [8]–[10], car re-identification [11] and image retrieval [12], [13]. To obtain steady improvement, models would be occasionally upgraded by training on larger or cleaner datasets, adopting more powerful network structures and training losses, or applying techniques like network architecture search [14], [15], knowledge distillation [16] and network pruning [17], [18]. However, to harvest the benefits of new models, a process known as “backfilling” or “re-indexing” [19] is indispensable to re-encode all images in the gallery set to recreate clusters. This process could be impractical to execute when there are limited computational resources for re-encoding, or original images are legally forbidden to be preserved without user authorization. Model compatibility techniques, which can heavily reduce costs of or even bypass the process, therefore are of great practical values.

Because of the multiplicity of application scenarios in visual search/retrieval fields, as well as compatibility directions to implement, model compatibility has never been employed via a general, unified set of patterns. Viewing in the perspective of application scenarios, there are two types of model compatibility methods. The first type is called cross model compatibility (CMC) whose goal is to find compatible mappings between the previous and upgraded models, where the upgraded models already exist. As model performance may degrade if compatibility is considered, CMC serves well for the scenarios that model performances are more valuable than compatibility. The second type is compatible training (CT) which aims at upgrading models with compatibility constraints. When bringing up against the scenarios where frequent iterations for online models are required, CT possesses an inherent feasibility to take charge.

The perspective of compatible directions categorizes model compatibility into three types: backward, forward and direct compatible methods (Fig. 1a). Direct compatible methods compare new features with old gallery sets directly, which is the most efficient as it completely prevents “backfilling” processes. Backward compatible methods endow a backward transformation that maps new features into old feature spaces, and they are capable of waiving re-encoding large gallery sets. Lightweight improvement for cumbersome model architectures is another potential scenario for backward compatible methods since old models spawn more separable feature spaces than new models in the circumstances. Forward compatible methods utilize a forward transformation that maps old features into new feature spaces, which is aimed at upgrading small gallery sets, especially when new models have much better performances than old ones.

Despite its great practical values, model compatibility is a relatively unexplored research area. Few efforts, R\(^3\)AN [20], RBT [21] (for CMC) and BCT [19] (for CT), are proposed and reach comparable results. However, these three works are only appropriate for limited application scenarios or compatible directions. Moreover, their model performances and compatibility are still arduous to be guaranteed, not only because of the further intensified nature of incompatibility for two different feature spaces when upgraded models dramatically changing training factors (, backbones, losses, training datasets, or even settings of optimizers), but also as a result of the point-wise losses they utilize, which align each feature pair and therefore prevent learning of more discriminative features.

To address the above issues, we propose a general framework called LCE for model compatibility as shown in Fig. 1. Model 1 represents the target compatible model. Model 2 is pre-existed for CMC while trained for CT. Transformations \(T^1, T^2\) map features to another spaces and enable direct/backward/forward compatibility. Our compatibility is achieved by aligning feature classes across models and restricting the mapped features to be distributed within the original boundaries (, more compact intra-class distributions). By this means, the mapped feature \(f^{2\rightarrow 1}\) is distributed inside the correct class in the original feature space and that makes features comparable.

Besides the compatibility, our framework also benefits the learning of more discriminative features in the following aspects: (a) Our method works in a point-to-set manner instead of employing point-wise constraints. As shown in Fig. 1b, features from same instance are not restricted to be distributed closely. (b) By the restriction of the original boundary, intra-class distributions are more compact compared to those from the old model. (c) The introduced transformation \(T\) relaxes the requirement for consistent inter-class distributions, as inter-class distributions may vary a lot across models (, ResNet100 [22] can separate features more easily than MobileFace [23]). Overall, we make the following contributions:

• Compared to previous methods which work in a point-wise manner, we reformulate the model compatibility from the aspect of classes and highly decouple models. Specifically, we align feature classes across models and restrict the new-to-old mapped features to be distributed within the original boundaries. With the proposed point-to-set constraints and transformations, we achieve model compatibility with marginal sacrifices of accuracies.

• We unify the two model compatibility problems (, CMC and CT) into a unified training framework called LCE, which can work in direct/backward/forward manners. Extensive experiments and ablation study are conducted on both problems with various factors such as network structures and losses. The proposed method achieves noteworthy results compared to current state-of-the-arts.

2 Related Works↩︎

Model compatibility is essentially transferring knowledge across models. This section reviews related works in fields of transfer learning, knowledge distillation and model compatibility, from the perspective of feature embeddings.

2.1 Feature Representation Transfer Learning↩︎

Feature representation transfer learning aims at transforming each original feature into a new feature representation for knowledge transfer [24]. Pan  [25] propose to learn a low-dimensional latent feature space where the distributions between the source and target domain data are the same or close to each other. JDA [26] jointly adapts both the marginal distribution and conditional distribution and constructs new feature representation for substantial distribution difference. JDA is further extended by utilizing the label and structure information [27], clustering information [28], various statistical and geometrical information [29] and balanced distributions [30], . Feature augmentation based methods [31]–[34] transfer the original features by feature replication to augment datasets for target domain. Even though is related to model compatibility, feature representation transfer learning focuses on transferring the knowledge contained in source domains to target domains instead of achieving comparable features.

2.2 Knowledge Distillation↩︎

Knowledge distillation (KD), which aims at transferring knowledge acquired in a teacher model to a student model, was first proposed by Hinton  [16]. There exists a great amount of knowledge sources and knowledge types in this field (see [35], [36] for recent reviews). Various knowledge sources are adopted in literature such as classification logits [16], [37], [38], hint layers [39]–[42] and multi-layer groups [43]–[45]. Knowledge types can be categorized into feature embeddings [39], [41], feature maps [42] and instance relationships [46], [47], . Despite the diverse categories, most works adopt KL-divergence or \(l_2\) distance as the loss to transfer knowledge. For example, both DarkRank [48] and Mirzadeh  [38] learn to match softened logits between teacher model and student model using KL-divergence. PKT [49] proposes to align probability distributions in the feature spaces for representation/metric learning tasks. RKD [46] introduces distance-wise and angle-wise distillation losses that mimic structural differences in relations. CCKD [47] combines the two losses to ensure congruence between teacher and student models, in both instance-level and group-level. Their experiments are conducted on classification tasks and metric learning tasks and achieve promising results.

2.3 Model Compatibility↩︎

Model compatibility is to make features comparable across models and is of great practical values for visual retrieval systems. This technique can heavily reduce computational costs of re-encoding gallery sets which is large-volume in modern applications but less studied in literatures. For CMC whose goal is to find mappings between models, R\(^3\)AN [20] learns feature transformation by a process of reconstruction, representation and regression for face recognition. RBT [21] designs a light-weight residual bottleneck transformation module following the split-transform-merge strategy and achieves remarkable improvements compared to R\(^3\)AN in their experiments. Their module is trained by a classification loss, an \(l_2\) similarity loss between feature embeddings and a KL-divergence loss between logits in classifiers. For CT, BCT [19] introduces an influence loss and trains new features on both new and old classifiers, which is essentially aligning the logits. As sharing the same high-level idea of transferring knowledge in KD, RBT [21] and BCT [19] both utilize similar ideas and losses to achieve their compatibility.

The main differences between KD and model compatibility mainly lie in two aspects. The first difference is that the old model in KD is a teacher model and normally performs better than the student model. For model compatibility, performances of upgraded models may decrease in some special cases such as light-weight structures or small feature dimensions introduced. However, in most scenarios, the upgrade models have potentially better performances with more data involved and technological advances. Directly distilling the exact logits or locations between each pair of old and new features, usually adopted by previous works, is too strict and could inherit bad inter-class distributions from old models to new ones. For example, class C and D in the old feature space are overlapped in Fig. 2a. Directly aligning features prevents the new model from learning more discriminative features.

Another difference is that traditional losses used in KD cannot fully guarantee model compatibility, as intra-class boundaries are difficult to be constrained by traditional KD losses. As shown in Fig. 2a, \(f^1, f^2\) have similar logits and a small \(l_2\) distance during training because of the absence of class B. Therefore, the conventional losses in KD perform weak penalties. While during the testing phase, \(f^2\) belongs to cluster B and thus is not compatible with the original feature \(f^1\).

Our proposed LCE framework is capable of alleviating the vulnerabilities of traditional KD losses. As Fig. 2b depicts, our method not only forces more compact intra-class distributions (class A, C, D), but also renders more discriminative inter-class distributions (class C, D are separable with new features) for the new model.

3 Methodology↩︎

Our LCE framework is developed following three rules: (1) Compatibility should be ensured and the issues presented in Fig. 2a are expected to be prevented whenever possible. (2) The new model should be decoupled from the previous one as much as possible to reduce performance drops. (3) The method should fit both CMC and CT problems.

3.1 Criterions for Compatibility↩︎

Suppose there are \(N\) samples \(\{x_i, y_i\}_{i=1}^N\) of \(n\) classes and their embeddings from two models are \(\{f_i^1, f_i^2\}_{i=1}^N\), respectively. For \(\forall i_1, \forall i_2 \in \{1, 2, \cdots N\}\) and \(i_1 \neq i_2\), the point-wise compatibility criterion (, BCT [19]) is defined as \[\label{eq:method95bctcompat} \small \text{(Point-wise) \quad } \begin{align} d(f_{i_1}^2, f_{i_2}^1) \geq d(f_{i_1}^1, f_{i_2}^1),&\text{ if } y_{i_1}\neq y_{i_2} ,\\ d(f_{i_1}^2, f_{i_2}^1) \leq d(f_{i_1}^1, f_{i_2}^1),&\text{ if } y_{i_1} = y_{i_2}. \end{align}\tag{1}\] Here \(d\) measures the distances. This criterion is too strict as it adds constraints to all pairs of samples (, \(N^2-N\) constraints) and leads to excluded solutions especially if models are trained with different networks/losses.

Our compatibility is defined differently. To start with, we first map features to another feature space, which relaxes the requirement for direct comparisons. We call the mapped features as \(f_i^{1\rightarrow2}, f_i^{2\rightarrow 1}\). Denote features of class \(j\) from model 1 are distributed in a feature region \(C_{j}^1\). Our criterion for compatibility is simply defined as \(f^{2\rightarrow 1}_i\in C_{y_i}^1\) for all \(i\), which is from the perspective of point-to-set comparison. Specifically, we restrict the \(f_i^{2\rightarrow 1}\) to be distributed inside the corresponding original boundary as indicated in Fig. 2b. By this means, the new feature space regulates more constrictive intra-class boundaries and more diacritical inter-class distributions.

As the real feature region is unavailable (, a feature region contains an infinity number of features while the estimated features are of a limited number), we estimate the set \(C_{y_i}^1\) by the class center \(w_{y_i}^1\) and its boundary \(b_{y_i}^1\) (as shown in Fig. 3, boundary loss). Then the criterion is re-formulated by \[\label{eq:method95compat95new} \small \text{(Point-to-set) \quad } \begin{align} \theta(f^{2\rightarrow 1}_i, w_{y_i}^1) \leq b_{y_i}^1 \quad \forall i \in \{1,2, \cdots, N\}. \end{align}\tag{2}\] Here \(\theta(w, f) = \arccos(\frac{w^Tf}{\|w\|\|f\|})\) which measures the angle between vectors \(w\) and \(f\).

3.2 Transformation Module↩︎

Besides the point-to-set compatibility, we further decouple models by transformations \(T_1^2, T_2^1\) which relieve gaps between feature spaces preferred by various models. The transformations \(T_1^2, T_2^1\) map features/class centers from one feature space to another and mapped embeddings are denoted by superscripts \(1\rightarrow 2, 2\rightarrow 1\). Specifically, we have \[\label{eq:method95map} \small \begin{align} f^{2\rightarrow 1}_i = T_2^1(f_i^2), \; f^{1\rightarrow 2}_i = T_1^2(f_i^1), \quad \forall j \in \{1, 2, \cdots, N\} \\ w^{2\rightarrow 1}_j = T_2^1(w_j^2), \; w^{1\rightarrow 2}_j = T_1^2(w_j^1), \quad \forall j \in \{1, 2, \cdots, n\} \\ \end{align}\tag{3}\] With the transformations, we can map new features to the old feature space, map old features to the new feature space or direct compare features. These correspond to backward, forward and direct compatibility respectively. The structure of our used transformation module is presented in top left of Fig. 3. The module is modified from the residual bottleneck transformation module introduced in RBT [21]. Note that original module requires same feature dimension for input and output. Thus, we append one additional fully connected layer if dimension changes. Besides, the number of sub-modules \(K=4\) for backward and forward compatibility. For direct compatibility, \(K=0\) and therefore \(T_1^2, T_2^1\) degrades to identity mappings.

To train the transformations, we define four types of class regions \(C_j^1, C_j^2, C_j^{1\rightarrow 2}, C_j^{2\rightarrow 1}\). Our transformations are estimated by aligning locations of class regions \(\{ C_j^1, C_j^{2\rightarrow 1}\}\) and \(\{C_j^2, C_j^{1\rightarrow 2}\}\). In the end, the module is learned by enforcing the consistency between class centers (, \(w_j^1 = w_j^{2\rightarrow 1}\) and \(w_j^2 = w_j^{1\rightarrow 2}\)).

3.3 The General Framework↩︎

Fig. 3 illustrates the details of our method. As a general framework, our method can fit both CMC and CT problems. Specifically, model 1 is the compatible target model and therefore its weights are always fixed. For CMC, model 2 is also fixed and the purpose is to find mappings between feature spaces of two models. For CT, we aim at training the model 2 while keeping compatible with model 1.

Pre-processing. Before training, we first pre-compute normalized feature \(f_i^1\) of training sample \(\{x_i, y_i\}\) from model 1. For each class \(j \in \{1, 2, \cdots, n\}\) with \(N_j\) samples, we calculate the class center \(w_j^1\) by taking the average of the features. After that, we calculate \(N_j\) angles between the class center and corresponding samples and denote them as \(\{\theta^1_i\}_{i=1}^{N_j}\). Then the original boundary for class \(j\) in the old feature space \(b_j^1\) is estimated by \[\small \label{eq:boundary} b_j^1 = \max\{\mathcal{I}(\theta^1_1)\cdot \theta^1_1, \mathcal{I}(\theta^1_2)\cdot \theta^1_2, \cdots, \mathcal{I}(\theta^1_{N_j})\cdot \theta^1_{N_j}\}.\tag{4}\] Here \(\mathcal{I}(\theta)\) is 0 if \(\theta\) is estimated as an outlier and 1 otherwise. The outliers are identified by the 1.5IQR rule which is a common method in statistical analysis [50].

\(\{w_j^2\}_{j=1}^n\) is also pre-computed for the CMC problem. For CT, \(\{w_j^2\}_{j=1}^n\) are weights in the classifier and are learned from data. As mentioned before, our compatibility is achieved by aligning class centers between new and old models via the transformation module, and force the new-learned features to be more compact than the old ones. That corresponds to the alignment loss \(L_a\) and boundary loss \(L_b\) in the framework. A classification loss \(L_{cls}\) is further introduced to guarantee model performances.

Alignment loss. Define function \(d(\cdot)\) as a measurement of cosine distances. Our alignment loss is used to align class locations between two models and defined as \[\small \begin{align} L_a &= \sum_{j=1}^n \left(d(w_j^{1\rightarrow 2}, w_j^2) + d(w_j^{2\rightarrow 1}, w_j^1)\right ). \end{align}\]

Boundary loss. The boundary loss constrains the new features to be more centralized to class centers than the old models and is defined as \[\small \begin{align} L_b & = \sum_{i=1}^N\max\left(0, \theta(f_i^{2\rightarrow 1}, w_{y_i}^1) - b^1_{y_i}\right). \end{align}\]

It not only contributes to the compatibility, but also leads to smaller intra-class variations and helps learns more discriminative embeddings.

Classification loss. The general format of a classification loss for sample \(i\) is \[\label{eq:softmax} \small L_{cls}(w, f_i) = -\log \frac{e^{s\cdot \mu(w_{y_i}, f_i)}}{e^{s\cdot \mu(w_{y_i}, f_i)} + \overset{n}{\underset{ j=1, j\neq y_i }{\sum}} e^{s\cdot \nu(w_{j}, f_i)}}.\tag{5}\]

\(\mu, \nu\) generate similarity scores and are in various formats for different losses. For example, \(\mu(w, f)=\nu(w,f)=\frac{w^Tf}{\|w^Tf\|}\) for NormFace [51] while \(\mu(w, f)=\frac{w^Tf}{\|w^Tf\|}-m, \nu(w,f)=\frac{w^Tf}{\|w^Tf\|}\) for CosFace [52].

For CMC, as \(f_i^1, f_i^2\) are already well-trained for classification, we compute the classification loss on \(f_i^{1\rightarrow 2}\) and precalculated class centers for model 2 (, \(L_c = L_{cls}(w^2, f_i^{1\rightarrow 2})\)). For CT, the loss is \(L_c = L_{cls}(w, f_i^2)\) where \(w\) are learned during training.

The whole loss. In the end, the loss for the framework is

\[\small \label{eq:lce} L_{LCE} = \lambda_aL_{a} + \lambda_bL_{b} + L_{c}\tag{6}\] Here \(\lambda_a, \lambda_b\) are two hyperparameters.

4 Experiments↩︎

In our experiments, we begin describing implementation details in Sec. 4.1 and evaluation metrics in Sec. 4.2. Sec. 4.3 is the ablation study which examines effects of the components in LCE. Then we evaluate our proposed method on CMC in Sec. 4.4. For the CT problem, only direct compatibility is studied for fair comparisons with baselines. Sec. 4.5 presents the results on CT with different training dataset, loss functions and network architectures, while experiments on different feature dimensions and sequential compatibility are in Sec. A (in the supplementary).

4.1 Implementation Details↩︎

Datasets. The original MS-Celeb-1M dataset [53] contains about 10 million images of 100k identities. However, it consists of a great many noisy face images. Instead, MS1Mv2 [54] (5.8M images, 85k identities) is adpoted as our training dataset. For change of training datasets, we also collect faces from the first 50% of identities from MS1Mv2 and call the dataset as MS1Mv2(1/2). For evaluation, we adopt a top challenging benchmark called IJB-C [55], which covers about 3,500 identities with a total of 31,334 images and 117,542 unconstrained video frames. We calculate the TARs at FAR=1e-4 in the 1:1 verification on IJB-C benchmark, where 19k positive and 15M negative matches are involved. All the images are aligned to \(112\times 112\) following the setting in ArcFace [54].

Training. All the models are trained on 8 1080Tis by stochastic gradient descent. For CMC, we train the transformations for 20 epochs, with learning rate initialized at 0.1 and divided by 10 at epoch 5, 10, 15. For CT, we initialize the learning rate by 0.1 and divide it by 10 at 10, 18, 22 epochs. The training stops at the 25th epoch. The weight decay is set to 5e-4 and the momentum is 0.9. The recommended hyper-parameters are used for classification losses from the original papers (, \(m=0.5, s=64\) for ArcFace [54]). We only augment training samples by random horizontal flipping and empirically set \(\lambda_a = 100, \lambda_b = 0.1\) for LCE.

Baselines. In our experiments, the main baselines are RBT [21] for CMC and BCT [19] for CT, which are current state-of-the-arts in the corresponding fields. For RBT, we use the recommended hyper-parameters in their paper. For BCT, the recommended weight for their influence loss are not provided. We tried several values and found 0.5 is the best value in our implementation. Therefore, 0.5 is used for all BCT experiments.

4.2 Evaluation Metrics↩︎

Model performance and compatibility performance. We evaluate model performance by 1v1 verification accuracy (abbreviated as Ver. Acc. in all tables) on the IJB-C benchmark. To measure the compatibility performance between the old model \(\phi^{1}\) and the new model \(\phi^{2}\), we use \(\phi^{1}\) to extract the feature embedding for the first template in the pair and \(\phi^{2}\) for the second, and report the cross verification accuracy (abbreviated as Cross Veri. Acc. in all tables).

Performance gain. For the scenario of CT, the performance of the upgraded model is also vital to the whole system besides the compatibility. Therefore, we report the relative performance improvement from \(\phi^{1}\) to \(\phi^{2}\) by

\[\label{eq:pergain} \mathcal{G}_{per.} = \frac{M(\phi^{2}) - M(\phi^{1})}{|M(\phi^{2}_{upper}) - M(\phi^{1})|}.\tag{7}\]

Here \(M(\phi)\) measures the recognition performance of model \(\phi\). Compared to \(\phi^{2}\), \(\phi^{2}_{upper}\) is trained without compatibility purpose and therefore serves as the upper bound for the new model. We add the absolute symbol to the denominator as it can be negative (, \(M(\phi^{2}_{upper}) < M(\phi^{1})\)). For example, the previous deployed model has a high latency and the new model is of a light-weight structure. In this case, the model performance will degrade.

Upgrade gain. The upgrade gain is similarly defined in BCT [19]. We revise their definition by taking the absolute value of the denominator to handle the model degradation and define our upgrade gain as \[\label{eq:upgain} \mathcal{G}_{upgrade} = \frac{M(\phi^{2}, \phi^{1}) - M(\phi^{1})}{|M(\phi^{2}_{upper}) - M(\phi^{1})|}.\tag{8}\] Here \(M(\phi^{2}, \phi^{1})\) measures the cross-model recognition performances between \(\phi^{2}\) and \(\phi^{1}\) (, compatibility performances). If using transformations, upgrade gain is the better result of backward and forward compatibility.

4.3 Ablation Study↩︎

In this part, we conduct several ablation studies to investigate the effects of different components in our method. ResNet50 [22] is adopted as the backbone network, and we use the full version of MS1Mv2 as the training data. The classification loss used in the old model is NormFace [51] and that used in new models is ArcFace [54].

Effects of components in LCE. We train the new models with different combinations of alignment loss, boundary loss as well as the transformation module as shown in Tab. ¿tbl:table:ablation952?. Note that \(\phi^{2}_{upper}\) is trained directly without additional losses and therefore serves as the upper bound of the recognition performances for new models. The performance gain is 84.28% and the upgrade gain is 60.82% with only alignment loss used. If introducing boundary loss, the performance gain is 89.07% and upgrade gain increases evidently with the number of 7.52%. The transformation module can significantly increase the model performance as it loose the constraints of directly aligning class locations. Performance gains of \(\phi^{2}_{a\_t}\) and \(\phi^{2}_{a\_b\_t}\) are all over 96%, which is close to the upper bound. Also, the transformation module offers the choices of whether to transform features forward and backward. As the full version of LCE, \(\phi^{2}_{a\_b\_t}\) achieves a verification accuracy of 91.92% when transforming new features to the original feature space, and 93.11% in the opposite direction. In addition, \(\phi^{2}_{a\_b\_t}\) achieves the best performance gain of 99.32% and upgrade gain of 72.44%, which demonstrates the efficacy of our proposed method.

Visualization. To reveal the effects of the proposed method, we sample 8 classes from MS1Mv2 and visualize deep features in Fig. 4. Here model 1 is \(\phi^{1}\) and model 2 is \(\phi^{2}_{a\_b\_t}\) from Tab. ¿tbl:table:ablation952?. Model 2\(\rightarrow\)​1 produces features by mapping those from model 2 to the feature space of model 1 by the learned transformations. T-SNE is chosen to map high-dimensional features into top 2 dimensions. The figure demonstrates that the mapped features are well-aligned with the original features and have more compact intra-class distributions than original ones.

We further pick class 6 and visualize feature pairs of its first 10 samples to show their pair-wise relationships. Features of the same image from two models can be either close to or far away from each other, as shown in the figure, which reveals our compatibility works in a point-to-set instead of strict point-wise manner.

Tab. ¿tbl:table:ablation953? presents the intra-class and inter-class distances of three types of features. The average intra-class distance is calculated by \(\frac{1}{N} \sum_{i=1}^N (\frac{f_i}{\|f_i\|} - \frac{w_{y_i}}{\|w_{y_i}\|})^2\) and the average inter-class distance is calculated by \(\frac{1}{n(n-1)}\sum_{i}^n\sum_{j=i+1}^n(\frac{w_i}{\|w_i\|} - \frac{w_j}{\|w_j\|})^2\). Because of the proposed alignment and boundary loss, model 2\(\rightarrow\)​1 shrinks the distribution of each class and therefore its features have much smaller intra-class distances than the original model 1 (0.283 ). The transformations further add flexibility of class locations and helps model to learn more separated inter-class distributions. The average inter-class distance increases from 1.767 to 1.827 in this case.

4.4 Cross Model Compatibility↩︎

For CMC, we adopt three pretrained models provided by the InsightFace project¹, which are of different network architectures and trained on different version of MS1M datasets as well as different losses. Details of the models and their abbreviations can be found in Tab. ¿tbl:table:exp95b1?. We select NormFace [51] and ArcFace [54] as the classification loss to train the transformations and present the experimental results in Tab. ¿tbl:table:exp1951?.

RBT maps features from two models to a third feature space. In contrast, our LCE maps feature forward or backward and therefore has two cross verification accuracies in each experiment. In all results, \((\phi_a^*, \phi_c^*)\) always have the best cross verification accuracies than other two combinations. That indicates compatibility performances are also influenced by performances of source models. When using ArcFace, both methods achieve similar compatibility performances. While using NormFace, the performances of RBT drop dramatically with more than 1% for all cases. That is because RBT compare features in the third feature space and therefore the performance is heavily relied on the goodness of that feature space. In contrast, our method is robust to changes of classification losses and achieves consistent high cross verification accuracies. Besides the robustness, the computational costs of LCE are only half of RBT. Our method is also more flexible in real-world applications as one can choose to either re-encode the feature in gallery sets or map new feature to the old feature space.

4.5 Compatible Training↩︎

In this section and Sec. A in the supplementary, we explore the scenario of CT. The new models are upgraded from a compatible target model with the change of different training datasets, classification losses, network architectures as well as the feature dimensions. We adopt two baselines: (1) a naive KD baseline which uses \(l^2\)-distance and (2) BCT [19]. For fair comparison with BCT [19], we set \(K=0\) in the transformation module and only consider direct compatibility. We call the old model as \(\phi^{1}\), the new model without compatibility losses as \(\phi^{2}_{upper}\) and with \(l_2\) baseline, BCT, LCE as \(\phi^{2}_{l2}, \phi^{2}_{bct}, \phi^{2}_{lce}\), respectively. In all the experiments below, cross verification accuracies between \(\phi^{1}\) and \(\phi^{2}_{upper}\) are all near 0, which demonstrates that model compatibility cannot be directly achieved without usage of compatibility methods.

Unless stated otherwise, the default setting is to employ MS1Mv2 as the training dataset, ResNet50 [22] as the backbone network, ArcFace as the classification loss and feature dimension as 512. Below we present results with one factor changed each time while others are set to default. Note that \(\phi^{1}\) in different tables may refer to different models.

Changes of training datasets. The old model \(\phi^{1}\) is trained on MS1Mv2(1/2) and all the new models are trained with the full version of MS1Mv2. Tab. ¿tbl:table:lce95dataset? presents the results. \(\phi^{2}_{l_2}\) directly matches features and therefore has a performance similar to the previous one. \(\phi^{2}_{bct}\) has a performance gain of 47.06% but its upgrade gain is close to \(\phi^{2}_{l_2}\) (both around 23%). A possible reason is that the old model is trained on a reduced dataset and therefore cannot clearly separate classes in the full data. The point-wise compatibility constraints used in baselines prevent simultaneous improving recognition performances and achieving model compatibility. In contrast, we use a point-to-set constraint and that makes our \(\phi^{2}_{lce}\) achieve much better results. The gains are 84.31% and 81.37% respectively in our implementation.

Changes of classification losses. With old model trained on ArcFace, we train new models on different classification losses. We pick NormFace [51], CosFace [52] and report the results in Tab. ¿tbl:table:lce95loss?. The old model is trained on the best classification loss and therefore can separate classes well. \(\phi^{2}_{l2}\) trained by the naive approach performs poorly in this scenario. Our \(\phi^{2}_{lce}\) still achieve better results especially for the model compatibility. In particular, the upgrade gains are 27.69% and 12.76% higher than those from \(\phi^{2}_{bct}\) when training with CosFace.

Another interesting phenomenon is that the verification performances of \(\phi^{2}_{lce}, \phi^{2}_{bct}\) are higher than the \(\phi^{2}_{upper}\). This is probably because the old model performs better than \(\phi^{2}_{upper}\), the compatibility losses in \(\phi^{2}_{lce}, \phi^{2}_{bct}\) help transferring good knowledge to new models. In Tab. ¿tbl:table:lce95backbone?, the old model is also better than \(\phi^{2}_{upper}\) with ResNet50 when new models have structures of ResNet18 or MobileFace. However, we do not observe similar phenomenon. We guess the reason is that compared to losses, knowledge is hard to transfer across models with different network architectures.

Changes of network architectures. In this part, we study the model compatibility across different network architectures. The old model is trained with ResNet50 while the new models are trained with ResNet100, ResNet18 [22] or MobileFaceNet [23]. Results are presented in Tab. ¿tbl:table:lce95backbone?. In all cases, \(\phi^{2}_{l2}\) has good performance gains while poor upgrade gains. The gains of \(\phi^{2}_{bct}\) are in completely opposite patterns. In contrast, our \(\phi^{2}_{lce}\) achieves remarkable results for both recognition and compatibility performance, which demonstrates the superiority of the proposed method.

5 Conclusion↩︎

In this paper, we design a general framework called LCE for model compatibility. Our compatibility works in a point-to-set manner which is realized by aligning the class centers between models and restricting more compact intra-class distributions for the new model. The adequate experimental results demonstrate that our method can achieve model compatibility in various scenarios while with marginal sacrifices of accuracies. As a general framework, our method can be applied to different combinations of scenarios (CMC/CT) and compatible directions (direct/forward/backward). Moreover, it can be potentially extended to benefit other tasks such as person/car re-identification and image retrieval.

6 Compatible Training↩︎

Changes of feature dimensions.

Changes of feature dimensions can be applied on increasing or decreasing feature dimensions from the old to the new model. For the scenario of increasing feature dimensions, 256 and 512 are used as the feature dimensions for the old and the new model, respectively. We reverse the feature dimensions of the old and the new model when experimenting decreasing feature dimensions. Tab. ¿tbl:table:lce95featdim? represents the results of dimension increasing, where our proposed LCE framework \(\phi^2_{lce}\) is compared with \(\phi^2_{bct}\) and \({\phi^2_{l2}}\). \(\phi^2_{l2}\) acts negatively on performance and upgrade gains, and \(\phi^2_{bct}\) performs even worse on both criterions. Compared to them, our approach \(\phi^2_{lce}\) earns a much higher upgrade gain while persisting a positive performance gain.

Similar results are represented in Tab. ¿tbl:table:lce95featdimdec? for dimension decreasing. \(\phi^2_{l2}\) ends up with catastrophic scores on performance and upgrade gains. In contrast, \(\phi^2_{lce}\) presents considerable superiority on both criterions. Since \(\phi^2_{bct}\) is not capable of dimension decreasing, results of \(\phi^2_{bct}\) are excluded in Tab. ¿tbl:table:lce95featdimdec?. This further emphasizes the flexibility of our LCE framework that is capable of both dimension increasing and decreasing scenarios.

Multi-model and sequential compatibility.

Multi-model and sequential compatibility is utilized to where three or more different models are required to be compatible with each other, which is commonly exists in industrial scenarios such as performing sequential model upgrades. To verify sequential compatibility, three versions of models \(\phi^1\), \(\phi^2\), \(\phi^3\) are trained with 25%, 50%, 100% identities from MS1Mv2 [54] dataset, respectively. \(\phi^1\) is viewed as the initial version and thus trained without compatibility constraints. We endow \(\phi^2\) with LCE constraints that guarantee compatibility with \(\phi^1\), and \(\phi^3\) with LCE constraints that guarantee compatibility with \(\phi^2\). Self-verifications are implemented on \(\phi^1\), \(\phi^2\) and \(\phi^3\) themselves, whose results are considered as lower/upper bound for cross-model verifications. Cross-model verifications are performed between all possible permutations of model pairs from \(\phi^1\), \(\phi^2\) and \(\phi^3\). Results are represented in Tab. ¿tbl:table:lce95seqcom?. Each TAR of cross-model stays between the lower and upper bound from its model pair, which indicates that \(\phi^1\), \(\phi^2\) and \(\phi^3\) are compatible with each other.

Transformation module and compatible directions.

In this section we extend Tab. 7 of Sec. 4 with transformation module introduced during LCE training, aiming at verifying the effectiveness of the transformation module as well as model compatibility for each compatible direction. Upgraded models trained with both LCE constraints and the transformation module are noted as \(\phi^2_{lce\_t}\). Results of introducing transformation module are summarized in Tab. ¿tbl:table:lce95trans? where the performance gain of each \(\phi^2_{lce\_t}\) witnesses an increment of about 20% compared with \(\phi^2_{lce}\), which infers a positive impact.

Tab. ¿tbl:table:lce95trans? also reveals model compatibility achievements of direct, backward and forward compatible directions. Observed from each backbone, cross verification accuracy of the backward direction performs slightly worse than the direct compatible method but is still considerable, while the forward compatible method has a competitive (or even better) cross verification accuracy compared with the direct manner. This indicates that our framework guarantees model compatibility for each compatible direction.

7 Experiments on Person Re-Identification↩︎

Besides the face recognition, we also conduct experiments on person re-identification to further reveal the generalization of our method. Our implementation is based on a public repository² provided by authors of Gu  [57]. We use the market-1501 dataset [58] consisting of 1501 identities and 32217 images. Following the protocol in Zheng  [58], 751 identities are reserved for training and the remaining 750 identities are used for testing. We use the first half of identities to train the old model and the full dataset to train the new model. The results are reported in Tab. 1.

The old model \(\phi^1\) achieves a mAP of 76.9% and the upper bound model gets 86.2%. If using LCE, the performance degrades an acceptable value of 0.1%. For the compatibility, our model achieves 77.4%, which is 7.4% better than the model trained without compatibility constraints. The results have demonstrated the efficacy of our method.

8 Visualization↩︎

To further study the effects of our LCE constraints, we sample 8 classes from MS1Mv2 [54] and visualize one of the classes in Fig. 5. Models used to extract those features are chosen from Tab. 5 of Sec. 4.5 where LCE is conducted in the direct compatible method. For Fig. 5 (a), the new model is \(\phi^2_{l_2}\) and serves as a baseline. For Fig. 5 (b), we use \(\phi^2_{lce}\) as the new model. \(\phi^1\) is the old model for both two figures. Average intra-class distances are calculated upon the 8 classes as Sec. 4.3 mentioned. Tab. ¿tbl:table:vis951? represents the intra-class distances of three types of features where \(\phi^2_{lce}\) produces a smaller intra-class distance than \(\phi^2_{l2}\) and the original old model \(\phi^1\), and this shows the capability of our LCE framework to shrink distributions of features in the same class.

A new metric called average pair-wise distance \(d_{pw}(\cdot)\) is introduced to measure the expected distance between each feature pair of the 8 classes by calculating \(d_{pw}(\phi^1,\phi^2)=\frac{1}{N}\sum_{i=1}^N (\frac{f^1_i}{\|f^1_i\|}-\frac{f^2_i}{\|f^2_i\|})^2\), where \(f^1_i\), \(f^2_i\) represents the \(i^{th}\) feature pair from model \(\phi^1\), \(\phi^2\) respectively. Fig. 5 presents the average pair-wise distances of two types of feature pairs where \(d_{pw}(\phi^2_{lce},\phi^1)\) has a greater value than \(d_{pw}(\phi^2_{l2},\phi^1)\). The results indicate that our method works in a point-to-set scheme that provides flexibility for feature locations.

References↩︎