# Prototypical quadruplet for few-shot class incremental learning

Sanchar Palit Biplab Banerjee Subhasis Chaudhuri
Indian Institute of Technology Bombay

###### Abstract

Many modern computer vision algorithms suffer from two major bottlenecks:
scarcity of data and learning new tasks incrementally. While training the
model with new batches of data the model looses it’s ability to classify the
previous data judiciously which is termed as catastrophic forgetting.
Conventional methods have tried to mitigate catastrophic forgetting of the
previously learned data while the training at the current session has been
compromised. The state-of-the-art generative replay based approaches use
complicated structures such as generative adversarial network (GAN) to deal
with catastrophic forgetting. Additionally, training a GAN with few samples
may lead to instability. In this work, we present a novel method to deal with
these two major hurdles. Our method identifies a better embedding space with
an improved contrasting loss to make classification more robust. Moreover, our
approach is able to retain previously acquired knowledge in the embedding
space even when trained with new classes. We update previous session class
prototypes while training in such a way that it is able to represent the true
class mean. This is of prime importance as our classification rule is based on
the nearest class mean classification strategy. We have demonstrated our
results by showing that the embedding space remains intact after training the
model with new classes. We showed that our method preformed better than the
existing state-of-the-art algorithms in terms of accuracy across different
sessions.

##  I Introduction

Conventional deep learning models require a large number of labeled datasets
to learn meaningful features from the data. These meaningful features are used
to do different tasks in Computer vision such as object classification, object
detection, etc. In absence of a proper dataset, the model might not be able to
learn proper representation which may lead to overfitting of the network which
leads to underperformance of the given network. In a few shot learning setting
the model is trained to combat overfitting. This requires us to have the
training dataset divided into support and query sets. The few-shot learning
model is trained in such a way that it can learn features of a particular
problem with less amount of data.

Another aspect of the deep learning model is that it needs to learn
meaningfull features of the data at a single training step. But in a real-life
scenario, our full dataset might not be available initially and it might
change based on application. In such cases, the model will tend to
underperform as the features of the data changes in time. The incremental
learning framework trains the model incrementally in such a fashion that the
previously learned knowledge is preserved. To tackle these two problems
several works have been proposed to train the model incrementally.

In this work, we address the problem of few shot class incremental
learning(FSCIL) to achieve good performance in the presence of sparse and
diverse data. If we train the model with less amount of data then it might not
be able to faithfully perform well on test data. Again while training with
less amount of data at the current session might hamper the previously learned
attributes since we don’t have access to the past dataset which will lead to
catastrophic forgetting. So addressing both issues simultaneously makes FSCIL
harder and more interesting.

Few shot class incremental learning have been addressed recently. An FSCIL
framework TOPIC [37] that uses a neural gas (NG) network to learn feature
space topologies for knowledge representation. The NG network keeps growing at
each incremental session to learn the feature of the new class. This
implementation requires one to maintain a separate knowledge base which might
be cumbersome in some applications. Few-shot lifelong Learning [8] have chosen
a few session trainable parameters to train and retained previously trained
parameters to mitigate catastrophic forgetting. During the train session, FSLL
has decoupled the Feature extractor and the final classification layer which
is problematic. Because along with the feature extractor, all weights at the
final classification must be updated to maintain synchronization. Otherwise,
the network outputs will change uncontrollably, which is equivalent to
forgetting some parameters.

These works have tried to focus on retaining knowledge of the past while
disregarding the current session parameter learning. In this work,

  * •

We have preserved the knowledge along with assigning enough focus on updating
the current session parameter. We train the model by dividing the parameters
in two parts (details later on). Our model is able to distinguish the samples
from, $(a)$ previous session class samples and $(b)$ samples of other classes
of current session very efficiently by means of quadruplet loss.

  * •

We also emphasize our focus on improved contrastive learning at the current
session (see Figure 1). We developed a methodology to get a better embedding
in the feature space using the quadruplet loss. The newly sampled data is very
similar to the sample mean of the class that it belongs to. Hence we also
penalize the distance between the sample and its class mean with a
prototypical loss function.

  * •

In addition to that, we retain the previous knowledge by maintaining the
invariability of the previously seen class means. The previously learned class
prototypes are refreshed and updated at every session in such a way that those
are able to represnt the true class means although the network parameter keeps
changing from time to time.

Figure 1: Our contrastive loss learns the current session parameters
faithfully while retaining the knowledge of the past. Red upper arrow
indicates forgetting while learning new classes the network parameters have
changed and the previously learned class clusters have overlapped. On the
other hand in our method (blue lower arrow) the newly learned class cluster is
far apart from the previously formed class clusters and the previously formed
clusters retains their inter class distance indicates retaining knowledge of
the past.

##  II Related Work

The problem setting is combination of two different direction of machine
Learning viz. few shot learning and class incremental learning. First we focus
on few shot learning setting.

  * •

Few-shot Learning: Few-shot learning has been tackled by several
approaches[3]. Prototypical network [1] addresses the problem by addressing
the key issue of overfitting. Prototypical network classifies the newly
sampled image to the closest class prototype in the embedding space. Low shot
learning with imaginary data [13] creates an augmented training set from the
initial training set by adding a set of generated examples. Then the model is
trained end-to-end along with the classification algorithm, which is a
composition of the inference and learning algorithms. In MAML [14] the
parameters of the model are explicitly trained such that a small number of
gradient steps with a small amount of training data from a new task will
produce good generalization performance on that task.

  * •

Continual Learning: Continual/Incremental learning deals with the situation of
machine learning where the data is distributed in time and the data is
encountered gradually to perceive meaningful knowledge and retain it for
learning in future [18]. Incremental learning has been solved by several
techniques where the main focus is to minimize catastrophic forgetting which
indicates the degradation in performance on a previously acquired knowledge
over time as new novel specimens (e.g. tasks, domains) are introduced.
Different methods have been explored, such as decreasing characterization
intersection [19], [20], [21], [22], [31], storing samples and generating
samples from the past [23] or adding additional architecture [24], [25], [26].
However, the major drawback is the resource restrictions over time which
forces these works to assume very few examples and facile models. Many works
have also tried to explore the theoretical concepts to combat catastrophic
forgetting [27], [28], [29], [30].

  * •

Few-shot class incremental Learning: Class incremental learning can be thought
of as a special case of task incremental Learning. In task-incremental
learning, we can have different settings[32]. In a class incremental learning
setting, we consider a single task i.e. classification and we assume that the
classes at each incremental session will be new. Few-shot incremental learning
is more challenging than incremental learning and few-shot learning. This is
because we have to deal with sparse data in an incremental fashion which
incurs the challenges of few-shot learning and incremental learning
altogether. To tackle class incremental Learning [33] have used replay-based
strategy, i.e. storing some exemplar images to retain previous knowledge along
with distillation loss to prevent forgetting. The set of exemplars are chosen
based on the herding process and during each training session, they update the
representation. [34] have used retrospection along with distillation where
retrospection allows the model to revisit a small subset of data for old
tasks. [35] uses the adverse effects caused by the imbalance between old and
new classes to tackle catastrophic forgetting. They used three types of loss
in the incremental session viz. cross-entropy loss computed on all classes,
less-forget constraint, a novel distillation loss computed on the features,
and inter-class separation, a variant of margin ranking loss to separate the
old and new classes.

##  III Problem Definition

In FSCIL setting we receive sequentially set of examples
$\mathcal{D}^{(1)},\mathcal{D}^{(2)},..,\mathcal{D}^{(i)},..,\mathcal{D}^{(S)}$
where $\mathcal{D}^{(i)}=(X_{i},y_{i})$ and
$X_{i}=\\{x_{i,j}\\}_{j=1}^{|\mathcal{D}^{(i)}|}$ are input samples and
$y_{i}=\\{y_{i,j}\\}_{j=1}^{|\mathcal{D}^{(i)}|}$ are output classes such that
each $y_{i,j}$ is assigned to the input $x_{i,j}\in\mathbb{R}^{D}$. The labels
$y_{i}\in\mathcal{N}^{(i)}$ are mutually exclusive i.e for any two steps
$\forall k\neq l,\mathcal{N}^{(k)}\cap\mathcal{N}^{(l)}=\phi$. At this point
we should note that at the very first step we have more number of classes and
we refer to this step as “base training” step. At each subsequent step we have
equal number of classes distributed across all step which we refer as
“incremental training” step. As a model we consider a deep neural network with
it’s final hidden layer providing the feature vector
$\phi(x;\theta)\in\mathbb{R}^{K}$ where $x$ is the input image and $\theta$
are the model parameters. This representation is shared across sessions and
$\theta$ is a session-shared parameter. To classify a specific class at $i$-th
session we additionally construct an output layer
$f_{i}(x;w_{i})=w_{i}^{T}\phi(x;\theta)$ with a log softmax. The final
classification rule for a fully connected neural network or convolutional
neural network is
$y_{i,j}^{\star}=\underset{\\{y_{i,j}\\}_{j=1}^{|\mathcal{D}_{i}|}}{\arg\max}f_{i}(x_{i,j};w_{i})$.
The network’s classification method is equivalent to the use of a linear fully
connected layers with weight vectors $w_{1},...,w_{i}$ with non-linear feature
vector obtained by some non-linear mapping. In this process non-linear feature
map extractor is differentiated from the final linear fully connected layers
during training. So we use the nearest class prototype rule [39] which does
not differentiate the weight vectors of the fully connected layers. The class
prototypes changes in coherence with the non linear feature map change and the
final fully connected layer change. This makes the classifier robust whenever
there is a change in non-linear feature map or the feature extractor.

##  IV Prototypical Quadruplet network

The base training session contains $\simeq 50\%$ of the classes. This is
because we need to train our initial model competitively as the performance of
the model in incremental sessions will be highly dependent on the initial
model parameters. Subsequently, At each session, we choose a few samples from
3 different classes, e.g. one positive and two negative samples. Prototypical
Quadruplet network is trained on Cross-Entropy loss at the base training step.
At each subsequent step, it is trained on the Prototypical Quadruplet loss
along with the updated prototypes of previously seen classes which is
described later. Prototypical Quadruplet network classifies the newly coming
samples to the nearest prototype of a class at each step. At each incremental
training session $i$ we are given a small support set [3] of
$N(=|\mathcal{D}_{i}|)$ labeled examples
$S_{k}^{i}=\\{(x_{i,1},y_{i,1}),...,(x_{i,N},y_{i,N})\\}$ where each
$x_{i,j}\in R^{D}$ is the $D$-dimensional feature vector of an example and
$y_{i,j}\in\\{1,...,k\\}$ is the corresponding label. $S_{k}^{i}$ denotes the
set of examples labeled with class $k\in\\{1,...,K_{i}\\}$ which is specific
to session $i$. $K_{1}$ (or $|\mathcal{N}_{1}|$) denotes the number of classes
in the base step and $K_{i>1}$ (or $|\mathcal{N}_{i>1}|$) denotes the number
of classes in the incremental training session. This support set is then
augmented to create a positive support set ($S_{kp}$) and two negative support
sets ($S_{kn}$ and $S_{knn}$). The positive class and the query sample class
[3] are the same. The two different negative classes are different from the
query class and also from each other. Next query samples ($x_{q}$) are chosen
from the query support set and for each query sample, positive samples
($x_{j}$) and two different negative samples ($x_{m}$ and $x_{l}$) are chosen.
The input quadruplet ($x_{q},x_{j},x_{l}$ and $x_{m}$) are then passed through
a non-linear mapping function $f_{\phi}:R^{D}\rightarrow R^{M}$. The
prototypes are the mean vector of the embedded feature points belonging to the
class that it has seen so far.

$\mathbf{c_{k}}=\frac{1}{\mid S_{k}^{i}\mid}\sum_{(x_{i,j},y_{i,j})\in
S_{k}^{i}}f_{\phi}(x_{i,j})$ (1)

Algorithm 1 Support set index selection and prototype construction at each
incremental training session. $N$ is the number of examples in the training
set, $K$ is the number of classes in the training set i.e
$|\mathcal{N}^{(i)}|$, $N_{C}\leq K$ is the number of classes per episode,
$N_{S}$ is the number of support examples per class, $N_{Q}$ is the number of
query examples per class. $Randomsample(S,N)$ denotes a set of $N$ elements
chosen uniformly at random from set $S$, without replacement.

Input:Training set
$\mathcal{D}_{i}=\\{(x_{i,1},y_{i,1}),...,(x_{i,|\mathcal{D}_{i}|},y_{i,|\mathcal{D}_{i}|})\\}$,
where labels $y_{i}\in\mathcal{N}^{(i)}=\\{1,...,K\\}$. $\mathcal{D}_{i,k}$
denotes the subset of $\mathcal{D}_{i}$ containing all elements
$(X_{i},y_{i})$ such that $y_{i,j}=k$.

Output: Positive class and negative class prototype

$V\leftarrow Randomsample([1,...,K],N_{C})$ $\triangleright$ Select class
indices

for $k\in\\{1,...,N_{C}\\}$ do

$S_{kp}\leftarrow Randomsample(\mathcal{D}_{i,V_{k}},N_{S}).$

$Q_{k}\leftarrow Randomsample(\mathcal{D}_{i,V_{k}}\char 92\relax
S_{kp},N_{Q})$

$k^{\prime}\leftarrow Randomsample(\\{1,...,N_{C}\\}\char 92\relax k,1).$

$k^{\prime\prime}\leftarrow Randomsample(\\{1,...,N_{C}\\}\char 92\relax
k\char 92\relax k^{\prime},1)$

$\mathbf{c_{kp}}\leftarrow\frac{1}{N_{S}}\sum_{(x_{i},y_{i})\in
S_{kp}}f_{\phi}(x_{i}).$ $\triangleright$ $positive$ prototype

if $k^{\prime},k^{\prime\prime}\in\mathcal{N}^{(t)}$ then $\triangleright$
$negative$ proto from current

$S_{kn}\leftarrow Randomsample(\mathcal{D}_{i,V_{k}^{\prime}},N_{S}).$

$S_{knn}\leftarrow Randomsample(\mathcal{D}_{i,V_{k}^{\prime\prime}},N_{S}).$

$\mathbf{c_{kn}}\leftarrow\frac{1}{N_{S}}\sum_{(x_{i},y_{i})\in
S_{kn}}f_{\phi}(x_{i}).$

$\mathbf{c_{knn}}\leftarrow\frac{1}{N_{S}}\sum_{(x_{i},y_{i})\in
S_{knn}}f_{\phi}(x_{i}).$

else$\triangleright$ $negative$ proto from past

if
$k^{\prime},k^{\prime\prime}\in\mathcal{N}^{(1)}\cup\mathcal{N}^{(2)}\cup..\cup\mathcal{N}^{(t-1)}$
then

$\mathbf{c_{kn}}\leftarrow Randomsample(\mathcal{C}^{(k-1)},1)$

$\mathbf{c_{knn}}\leftarrow Randomsample(\mathcal{C}^{(k-1)},1)$

end if

end if

end for

Figure 2:  Prototypical Quadruplet loss update at each incremental training
step

In accordance with Algorithm 1 we create three prototypes i.e. positive class
$\mathbf{c_{kp}}$ and two negative class prototypes $\mathbf{c_{kn}}$ and
$\mathbf{c_{knn}}$. Given the prototypes $\mathbf{c_{kp}}$, $\mathbf{c_{kn}}$
and $\mathbf{c_{knn}}$ the prototypical quadruplet computes the embedding loss
function $\mathcal{L}_{e}$ for each query sample as,

$\begin{split}\mathcal{L}_{e}=g(f_{\phi}(x_{q}),k)=\sum_{x_{q}\in
Query}[d_{euc}(f_{\phi}(x_{q}),\mathbf{c_{kp}})-d_{euc}(f_{\phi}(x_{q}),\mathbf{c_{kn}})\\\
+\alpha_{1}]+\sum_{x_{q}\in
Query}[d_{euc}(f_{\phi}(x_{q}),\mathbf{c_{kp}})-d_{euc}(\mathbf{c_{kn}},\mathbf{c_{knn}})+\alpha_{2}]\end{split}$
(2)

where $x_{q}=x_{j},x_{q}\neq x_{m},x_{q}\neq x_{l},x_{l}\neq x_{m}$, and
$\mathbf{c_{kp}}$ is constructed with samples $x_{j}$, $\mathbf{c_{kn}}$ is
constructed with samples $x_{l}$ and $\mathbf{c_{knn}}$ is constructed with
samples $x_{m}$. $d_{euc}(a,b)$ denotes the distance between tensors $a,b$ in
feature space and $\alpha_{1},\alpha_{2}$ are the loss margins. Given an
embedding loss function $g:R_{M}\rightarrow[0,+\infty)$, prototypical
quadruplet networks produce a distribution over classes for a query point x
based on a softmax over distances to the prototypes in the embedding space:

$p_{\phi}(y=k\mid
x_{q})=\frac{exp(-g(f_{\phi}(x_{q}),k))}{\sum_{k^{\prime}}exp(-g(f_{\phi}(x_{q}),k^{\prime}))}$

This is shown in Figure 2

Hence the negative log-likelihood loss is given as,

$\begin{split}\mathcal{L_{PQ}}=-\log p_{\phi}(y=k\mid
x_{q})=[g(f_{\phi}(x),k))+\\\
\log\sum_{k^{\prime}}exp(-g(f_{\phi}(x),k^{\prime}))]\end{split}$ (3)

###  IV-A Parameter Selection

To prevent catastrophic forgetting we use the knowledge of the prototypes of
the previously seen classes. The prototypes at the base training session get
updated at different steps starting from the base training step. Next in the
incremental training session to prevent drastic change of network parameters
we should retain those parameters which contributed significantly to the
creation of the previously seen class prototypes. To retain the knowledge we
freeze [8] a certain portion of the network parameters which contributed most
to the prototype creation i.e. whose values are above a certain threshold.
High absolute values of network weight indicates that this portion contributed
significantly in the creation of the tensor in latent space of the previously
seen classes. Network can be thought of as a combination of different filters
and the filtering process is quasi-linear. Hence we can consider that the
network as combination of some filters and the image can be thought of as a
quasi-linear combination of filter tensors. The latent space is composed of
the coefficients constituted by the filter. Hence when some component of
filter coefficient or the corresponding dimension in latent space is small in
absolute magnitude then that means that the corresponding component of the
filter is contributing less. Similarly, if some component is high in absolute
value then that indicates that the corresponding component of the filter is
contributing significantly. Hence we retain those filter components as those
are important in producing the latent vector corresponding to an image. Filter
component which are below the threshold value are chosen for training at the
current session. At the next session when a new mutually exclusive classes are
encountered for training, the entire model is not trained on it since the
number of samples in the new classes is very low, and the entire feature
extractor will be prone to overfitting to these examples. Instead, only a
fraction of the parameters of the feature extractor is trained on these newly
encountered classes to get rid of the overfitting problem. The new parameters
are chosen at each incremental session.

###  IV-B Prototype Update

In an incremental learning setting, we can not store the previously seen class
means as those would be outdated as the network gets updated at each
incremental session. We can not approximate the true class mean with the
current network parameters. In this few shot incremental setting we are using
small support set sizes and the previously stored class mean is likely to be a
poor approximation of the real mean. Again at the current training session
previously seen classes are not present, as the labels two different sessions
are mutually exclusive. Hence ad-hoc modifications to the prototypes is
required. In addition to that we want to improve the inter-class separability
of the newly coming class with the previous prototypes. Hence to update the
previous means we introduce an additional prototype distribution smoothing
[52] which performs distribution smoothing in the feature space to get most
appropriate class prototypes from the previous prototypes. This procedure aids
to adjust the likely skewed approximation of prototype for underrepresented,
highly imbalanced target values in training data. In order to do that we keep
track of the $\mathcal{B}$ previously stored class prototypes. With the
prototype statistics, we apply a symmetric kernel
$k(\mathbf{c_{b}},\mathbf{c_{b^{\prime}}})$ flatten the distribution of the
prototype and covariance over the past $\mathcal{B}$ set of prototypes. Here
we should note that we will not have $\mathcal{B}$ copies of all the previous
class prototypes. When we are at the $k$-th step, classes
$\mathcal{N}^{(1)},\mathcal{N}^{(2)},..,\mathcal{N}^{(k-\mathcal{B})}$ will
have $\mathcal{B}$ copies. Again classes $\mathcal{N}^{(t-\mathcal{B}+1)}$ are
smoothened over $(\mathcal{B}-1)$ copies, classes
$\mathcal{N}^{(t-\mathcal{B}+2)}$ are smoothened over $(\mathcal{B}-2)$ copies
and so on.

To keep track of the deviation of the prototypes we maintain additional mean
and covariance matrix $(\mu_{b},\Sigma_{b})$ which keeps track of the
deviation of the prototype of past $\mathcal{B}$ timesteps. The mean and
covariance matrix is given as,

$\mu_{b}=\frac{1}{\mathcal{B}}\sum_{b\in\mathcal{B}}c_{b}$
$\mathbf{\Sigma_{b}}=\frac{1}{\mathcal{B}}\sum_{b\in\mathcal{B}}(c_{b}-\mu_{b})(c_{b}-\mu_{b})^{T}$

Next we apply the kernel $k(\mathbf{c_{b}},\mathbf{c_{b^{\prime}}})$ on the
prototype mean and covariance over the set $\mathcal{B}$. This gives us a
flattened statistics:

$\tilde{\mu}_{b}=\sum_{\mathbf{b}\in\mathcal{B}}k(y_{b},y_{b^{\prime}})\mu_{b},$
$\tilde{\Sigma}_{b}=\sum_{\mathbf{b}\in\mathcal{B}}{k(y_{b},y_{b^{\prime}})\Sigma_{b}}$

Next to adjust the prototype samples we use the standard whitening and re-
coloring procedure [53] with $\\{\mu_{b},\Sigma_{b}\\}$ and corresponding
flattened versio $\\{\tilde{\mu}_{b},\tilde{\Sigma}_{b}\\}$:

$\tilde{\mathbf{c}}_{b}=\tilde{\Sigma}_{b}^{\frac{1}{2}}\tilde{\Sigma}_{b}^{-\frac{1}{2}}(c_{b}-\mu_{b})+\tilde{\mu}_{b}$

Newly constructed
$\tilde{\mathcal{C}}^{(k)}=({\tilde{\mathbf{c}}_{1}},{\tilde{\mathbf{c}}_{2}},...,\tilde{\mathbf{c}}_{|\mathcal{N}^{k}|})$
is then appended to the previous $\mathcal{B}$ copies of prototypes and the
oldest copy is removed. Similarly $\\{\tilde{\mu}_{b},\tilde{\Sigma}_{b}\\}$
is appended to the mean end covariance set and the oldest copy is removed.
While training the model across each epoch we implement a momentum update of
the running statistics $\\{\mu_{b},\Sigma_{b}\\}$. Correspondingly, the
smoothed statistics $\\{\tilde{\mu}_{b},\tilde{\Sigma}_{b}\\}$ are modified at
different epochs but stable within each training epoch. To get more solid and
precise estimate of the prototypes we employ the momentum update which deploys
an exponential moving average.

The inter-class separability of the updated prototype is maximized by
minimizing the cross correlation between the updated prototypes:

$\mathcal{L_{COR}}(\mathcal{C}^{(k)})=\sum_{i,j=1,i\neq
j}^{|\tilde{\mathcal{N}}^{k}|}\sigma(\cos{(\tanh{(\tilde{\mathbf{c}}_{i}^{(k)})},\tanh{(\tilde{\mathbf{c}}_{j}^{(k)}}))})$
(4)

The other objective is that we need to keep the updated prototypes as close as
possible to the previous prototypes. In order to do that we keep track of the
initial prototypes in a vector $\mathcal{C}^{(0)}$ which is the mean of
vectors in set $\mathcal{B}$. To keep the similarity we introduce an
additional cosine similarity loss as follows:

$\mathcal{L_{CS}}(\mathcal{C}^{(k)},\mathcal{C}^{(0)})=\sum_{i=1}^{|\tilde{\mathcal{N}}^{k}|}\cos{(\tanh{\mathbf{c}_{i}^{(k)}},\tanh{\mathbf{c}_{i}^{(0)}})}$
(5)

The $\tanh$ is used in addition to the cosine similarity loss because it is
sensitive to small deviations. Hence the prototypes are updated at each
iteration whereby one update is given as,

$\mathcal{C}^{(k+1)}=\mathcal{C}^{(k)}-\lambda\frac{\partial(\mathcal{L_{COR}}(\mathcal{C}^{(k)}))+(\mathcal{L_{CS}}(\mathcal{C}^{(k)},\mathcal{C}^{(0)}))}{\partial\mathcal{C}^{(k)}}$

The prototype update is illustrated in Figure:2.

Algorithm 2 Loss update at each incremental training session

Input:Training set
$\mathcal{D}_{i}=\\{(x_{i,1},y_{i,1}),...,(x_{i,|\mathcal{D}_{i}|},y_{i,|\mathcal{D}_{i}|})\\}$,
where labels $y_{i}\in\mathcal{N}^{(i)}$. $N_{C}\leq K$ is the number of
classes per episode.

Output: The loss $\mathcal{L}$ for a randomly generated training episode

$\mathcal{L}\leftarrow 0$ $\triangleright$ Initialize loss

for $k\in\\{1,...,N_{C}\\}$ do

for $(x,y)\in Q_{k}$ do

$d_{1}\leftarrow
d_{euc}(f_{\phi}(x),\mathbf{c_{kp}})-d_{euc}(f_{\phi}(x),\mathbf{c_{kn}})+\alpha_{1}$

$d_{2}\leftarrow
d_{euc}(f_{\phi}(x),\mathbf{c_{kp}})-d_{euc}(\mathbf{c_{knn}},\mathbf{c_{kn}})+\alpha_{2}$

$g\leftarrow d_{1}+d_{2}$

$\mathcal{L}\leftarrow\mathcal{L}+\frac{1}{N_{C}N_{Q}}\mathcal{L_{PQ}}$

end for

end for

###  IV-C Resource usage

In an online setting, prototypical quadruplet does not know about the classes
that are going to come next and how many classes are going appear in future.
At any timestamp during its run time, its memory budget is of the size of the
prototype set $\mathcal{B}$ times the number of classes seen so far times the
size of the class prototypes. Same number of $\\{\mu_{b},\Sigma_{b}\\}$ pair
is stored. The prototype database i.e.
$\mathcal{C}^{(k)}=\bigcup_{i=1}^{k}{\tilde{\mathcal{C}}^{(k)}}$ consists of
$\mathcal{K}=(\mathcal{B}|\mathcal{N}_{1}|+\mathcal{B}|\mathcal{N}_{2}|+...+2|\mathcal{N}_{|\tilde{\mathcal{N}}^{k}|-2}|+|\mathcal{N}_{|\tilde{\mathcal{N}}^{k}|-1}|+|\mathcal{N}_{|\tilde{\mathcal{N}}^{k}|}|)$
number of $D$-dimensional vectors i.e,
$\mathcal{C}^{(k)}\in\mathbb{R}^{D\times{\mathcal{K}}}$ where
$|\tilde{\mathcal{N}}^{k}|$ denotes the number of classes seen so far i. e
$|\tilde{\mathcal{N}}^{k}|=\bigcup_{i=1}^{k}{|\mathcal{N}}^{(i)}|$. According
to this information we can assign different memory budget for different
applications. If we have a rough idea about the number of classes that we are
going to see next, we can simply allot space for the weight vectors initially
and then store $\mathcal{B}$ copies of prototypes in the remaining memory. If
we do not have an estimate, we can increase the number of prototypes
incrementally with newly added classes and reduce the prototype set
$\mathcal{B}$ accordingly. Eventually, one copy of prototype of each
encountered class need to be stored to prevent complete forgetting of the
learned class. So in practice this performs best with a finite number of
classes distinct classes. Additionally we can learn more number of distinct
classes if we have the prospect of adding more resources throughout the
duration of the algorithm.

As shown in algorithm 1 we have divided our training process into two
different sections. One is the base training session and the other is the
incremental training session. Subsequently, At each session, we choose a few
samples from 3 different classes, e.g. one positive and two negative samples.
Then the quadruplet network extracts the feature of all the support samples of
these classes along with the relevant query class. Next, the loss to minimize
is expressed as $d_{qp}-d_{qn}$ and $d_{qp}-d_{nn}$ where $d_{qp}$ is the
distance between the query and the positive class prototype, $d_{qn}$ is the
distance between the query and the negative class prototype and $d_{nn}$ is
the distance between the negative class and another negative class prototype.
The choice of two negative samples ensures that the inter class separation of
previous session prototypes and current session other class is maintained.
Next, we use log softmax to classify the query sample to the correct class.
The network is shown in Figure 2

###  IV-D Classification

Prototypical quadruplet uses a nearest class prototype classification strategy
during test. As mentioned earlier the model has a set of prototype vector
stored in the memory for each previously encountered classes
$\mathbf{c}_{1},...,\mathbf{c}_{|\tilde{\mathcal{N}}^{(k)}|},$. Next, to get a
class label during inference, $y^{\star}$, for a input sample, $x$ it gets the
distance of the feature vector of the input sample with the prototypes all
encountered classes and specifies the class label with the closest class
prototype:

$y^{\star}=\underset{i=1,...,{|\tilde{\mathcal{N}}^{(k)}|}}{\mathbf{\arg\min}}||\phi(x)-\mathbf{c}_{i}||$
(6)

##  V Experiments

We adhere to the standard convention for evaluating the FSCIL method that is
suggested in the iCARL[7]. For the given FSCIL problem, initially the classes
are permuted randomly and then in two parts for base training set and
incremental training respectively. Then for incremental training session those
then divided in different set. Next at each session the model is trained
distinctly with the training data that is available at current session. After
training the model on the currently available dataset, the trained model then
is checked on the test data of the current session set, and also on the test
data of all those set that have already been encountered. Here one can notice
that the test data of previous session is used repeatedly and those are sparse
in nature. Still this does not harm our model since the update on the test
data does not change the actual model. The classification accuracies consists
of the accuracy on current session dataset and also on the previous session
dataset . Finally we compute the average of these accuracies which is the
final few-shot class incremental accuracy.

###  V-A Datasets

We use three image classification datasets CIFAR-100 [44], miniImageNet [11]
and CUB200 [45] to check the performance of our method.

The CIFAR-100 dataset and miniImageNet dataset is divided into two parts. We
choose 60 classes for base training and 40 classes for incremental session
training. Now to divide our data in one base training and 8 incremental
training, we use standard (5, 5) setting. Here $(a,b)$ refers to $a$-way
$b$-shot i.e., during few-shot training there are $a$ classes and each class
have $b$ training samples . The CUB-200 dataset is divided into equal portions
with 100 classes each for the base and new incremental training sessions. Now
to divide our data in one base training and 10 incremental training, we use
standard (10, 5) setting. The samples are chosen uniformly at random for each
incremental training step. The test set is comprised of randomly selected test
examples which come from all the previously encountered classes.

TABLE I: Results on CUB-200 dataset on the (10, 5) FSCIL setting. At any
session we compute accuracy over all the the classes encountered till that
session. Final accuracy at 11-th session is reported here.

Method | Session | Relative
---|---|---
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | Improvements
Ft-CNN | 68.68 | 44.81 | 32.26 | 25.83 | 25.62 | 25.22 | 20.84 | 16.77 | 18.82 | 18.25 | 17.18 | 40.21
Joint-CNN | 68.68 | 62.43 | 57.23 | 52.80 | 49.50 | 46.10 | 42.80 | 40.10 | 38.70 | 37.10 | 35.60 | 21.79
iCARL | 68.68 | 52.65 | 48.61 | 44.16 | 36.62 | 29.52 | 27.83 | 26.26 | 24.01 | 23.89 | 21.16 | 36.23
EEIL | 68.68 | 53.63 | 47.91 | 44.20 | 36.30 | 27.46 | 25.93 | 24.70 | 23.95 | 24.13 | 22.11 | 35.28
NCM | 68.68 | 57.12 | 44.21 | 28.78 | 26.71 | 25.66 | 24.62 | 21.52 | 20.12 | 20.06 | 19.87 | 37.52
TOPIC | 68.68 | 62.49 | 54.81 | 49.99 | 45.25 | 41.40 | 38.35 | 35.36 | 32.22 | 28.31 | 26.28 | 31.11
FSLL | 75.63 | 71.81 | 68.16 | 64.32 | 62.61 | 60.10 | 58.82 | 58.70 | 56.45 | 56.41 | 55.82 | 1.57
Proto-quad | 76.68 | 72.20 | 69.33 | 67.44 | 65.26 | 63.47 | 62.23 | 61.36 | 60.66 | 59.15 | 57.39 | -

TABLE II: Results on CIFAR-100 dataset on the (5, 5) FSCIL setting. At any
session we compute accuracy over all the the classes encountered till that
session. Final accuracy at 9-th session is reported here.

Method | Session | Relative
---|---|---
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | Improvements
Ft-CNNa | 64.10 | 38.34 | 15.23 | 10.78 | 8.67 | 5.23 | 5.11 | 3.68 | 2.19 | 44.98
Joint-CNNa | 64.10 | 60.15 | 56.42 | 51.43 | 48.87 | 46.10 | 42.80 | 40.10 | 39.70 | 7.47
iCARL | 64.10 | 53.28 | 41.69 | 34.13 | 27.93 | 25.06 | 20.41 | 15.48 | 13.73 | 33.44
EEIL | 64.10 | 53.11 | 43.71 | 35.15 | 28.96 | 24.98 | 21.01 | 17.26 | 15.85 | 31.32
NCM | 64.10 | 53.05 | 43.96 | 36.97 | 31.61 | 26.73 | 21.23 | 16.78 | 13.54 | 33.63
TOPIC | 64.10 | 55.88 | 47.07 | 45.16 | 40.11 | 36.38 | 33.96 | 31.55 | 29.37 | 17.8
FSLL | 64.10 | 55.85 | 51.71 | 48.59 | 45.34 | 43.25 | 41.52 | 39.81 | 38.16 | 9.01
Proto-quad | 71.10 | 65.23 | 60.10 | 58.34 | 55.67 | 52.65 | 51.19 | 49.53 | 47.17 | -
aOur implementation |  |  |  |  |  |  |

###  V-B Implementation Details

For CIFAR-100 we use a 32-layers ResNet [41] feature extractor, and an
additional memory to store the prototype set of 100 class. During the base
session the model is trained for 200 epochs and at each incremental session
the model is trained for 60 epochs and 10 episodes. At the incremental session
initially we set the learning rate as 2.0 and is reduced to $1/5$-th after
training for 45 and 57 epochs (3/4 and 19/20 of all epochs). For CUB-200
dataset we need to have prototype set for 200 classes and we use the 18-layers
ResNet [41]. The base training step consists of 200 epochs and each
incremental training step consists of 70 epochs. Initially at each incremental
training session we set the learning rate as 2.0 and is reduced to $1/5$-th
after 25, 35, 45, and 55 epochs (5/12, 7/12, 3/4, and 11/12 of all epochs).
During base training session, the model is trained using standard gradient
computation and loss update with batches of size 1024 and The weight decay
parameter is set to be 0.00001. Here one may notice that the learning rates
are large, but they are they are reasonable with quadruplet loss in the
network layer.

The features are extracted by a backbone network $\phi$. Initially
$\phi^{(1)}$ and W are trained on the base training set
$\mathcal{D}_{train}^{(1)}$. The model is trained on
$\mathcal{D}_{train}^{(1)}$ for a total of 200 epochs at the base training
set. Next, only a small portion of the feature extractor is updated at each
incremental training session on each of the sparse training samples
$\mathcal{D}_{train}^{(t>1)}$ for 60 epochs. The threshold values for each
layer is set to only select $\simeq 10\%$ of $\phi$ as the parameters to be
updated of the feature extractor for the each incremental training sessions.
Since the few-shot training sets are very sparse in nature, each episode has
only 5 examples from the 10 classes. The feature extractor $\phi_{t}$ is
tested on the cumulative test samples of all the previously encountered
classes after finetuning it on the data $\mathcal{D}_{test}^{(t)}$. At any
session $t$ we compute accuracy over the the test set of current session
classes and the classes that are seen at all previous sessions i.e.
$(\mathcal{D}_{test}^{(1)},\mathcal{D}_{test}^{(2)},...\mathcal{D}_{test}^{(t)})$
which refers to session $t$ accuracy. As the number of samples is very few,
standard random scaling and rotating for data augmentation [41], [42] is
performed for all incremental sessions. In addition while updating the feature
extractor parameters on $\mathcal{D}^{(t>1)}$ the batch-normalization of each
layers is done using the batch-normalization statistics computed on base
training $\mathcal{D}^{(1)}$ as done in [37]. We have run these experiments 10
times and the result consists of the average test accuracy over all previous
session classes to validate the adaptability and it is seen that standard
deviations of the test results are less than 0.5% for all the experiments.

###  V-C Baselines and Compared Methods

For comparative experiments, we run the representative CIL methods in our
FSCIL setting, namely iCARL [33], EEIL [40], NCM [35], FSCIL [37] and compare
our method with them. Additionally, the Ft-CNN (described in [37]) and Joint-
CNN (also described in [37] method) are also compared with our method. Ft-CNN
directly updates the model on the sparse samples of $\mathcal{D}^{(t>1)}$ and
the Joint-CNN updates on the combined samples of
$\mathcal{D}_{1}\cup\mathcal{D}^{(t>1)}$ i.e base session samples and
incremental session samples.

####  V-C1 CUB-200 Results

Our method shows better results than the Ft-CNN model on CUB-200 as indicated
by Table I. Similarly, our approach surpasses the results of Joint-CNN by a
significant margin. The reason is that as the number of few-shot classes is
100 in this setting, the Joint-CNN model losses information over incremental
sparse classes cumulatively.Moreover, our approach performs better than the
FSLL method in terms of accuracy. Our method shows good accuracy on each
incremental training session and the base training session.

Figure 3: Results on miniImagenet on the (5, 5) FSCIL setting.

####  V-C2 CIFAR-100 Results

As shown in Table II our method performs better than the popular FSLL method
by a significant amount on CIFAR-100 dataset. Table II also indicates that our
model performs better than other existing methods by a significant amount.

####  V-C3 miniImageNet Results

As shown in Figure 3 our method outperforms the state-of-the-art FSLL model,
by a significant amount on miniImagenet dataset. Figure 3 also indicates that
our model performs better than other existing methods by a significant amount.

(a)

(b)

(c)

(d)

Figure 5: t-SNE plot of CUB-200 with prototypical quadruplet network and with
(a) $\simeq 10\%$ of the parameters trained, (b) $\simeq 12.5\%$ of the
parameters trained, (c) $\simeq 14\%$ of the parameters trained, (d) $\simeq
15\%$ of the parameters trained. All clusters corresponds to different class.
Past learned prototypes gets deformed due to network weight update which is
crucial in forming the latent space.

###  V-D Ablation Experiments

Several ablation experiments are done to validate our method with different
variables.

##### Session Trainable Parameters usage

The selection of session trainable parameters is of prime importance in our
experiment. The threshold is directly proportional the number of parameters to
be updated. Hence Setting a very high threshold will result in updating a high
portion of important knowledge preserving parameters which will result in
catastrophic forgetting and vice-versa. Similar to [8] prototypical quadruplet
performance suffers in such a case. Prototypical quadruplet shows the best
performance when we update $\simeq 10\%$ parameters of the feature extractor
at each incremental session. This is depicted in Figure:5. Choosing more
number of session trainable parameters results in deformation of the
previously learned clusters. For the base step knowledge retention, we
decrease the proportion of session trainable parameters and in subsequent
steps, the performance of the model improves if we use $\simeq 10\%$ of the
feature extractor as session trainable parameters. If we update less than 10%
parameters of the feature extractor, the model starts to show poor performance
as it does not have enough parameters to acquire knowledge at current session.

##### Significance of Quadruplet loss margin

$\alpha_{1}$ is the margin when we consider the distance between the query and
the negative class prototypes along with the query and the positive class
prototype. Similarly, $\alpha_{2}$ is the margin when we consider the distance
between the negative class prototype and another negative class prototype. The
threshold margin $\alpha_{1}$ is imposed between positive and negative
samples. It applies an extra border on top of the relative distances between
positive and negative class samples w.r.t the same probe negative class
sample. The second term enforces new restriction which reviews the orders of
positive and negative sample pair with different probe negative class samples.
With this restriction, the minimum inter-class separation needs to be more
than the maximum intra-class separation notwithstanding of what the pair
contains [43]. We performed ablations to verify the significance of these two
margins. We observe that in the absence of these two margins, the session 11
model performance $(S_{11})$ for the CUB-200 dataset drops significantly.
Table III shows the result with the optimal value of other hyperparameters.

TABLE III: Session 11($S_{11}$) accuracy results on CUB-200 on the (10, 5)
FSCIL setting for different values for the margin hyperparameter $\alpha$
values.

Margin | Accuracy at session 11
---|---
| 23.19 | 25.46 | 30.38 | 27.76 | 29.88 | 36.39 | 32.39 | 31.39 | 30.45
$\alpha_{1}$ | 0.5 | 0.75 | 0.7 | 0.8 | 0.9 | 1.0 | 1.0 | 1.2 | 1.3
$\alpha_{2}$ | 1.0 | 0.9 | 0.8 | 0.75 | 0.6 | 0.5 | 0.3 | 0.2 | 0.1

We have used quadruplet loss to have a better feature representation in the
embedding space because of its relative improvement over the contrastive loss
and the triplet loss. Contrastive loss such as Siamese twins pair [4] tries to
balance between the loss which is composed of a partial loss function for a
genuine pair, the partial loss function for an imposter pair. The triplet loss
purely examines the error of the comparative separation between positive and
negative sample pairs. In contrast the first expression of the contrastive
loss gives precedence to the absolute separation of positive sample pairs when
the error of the comparative separation is not big enough. It would make the
contrastive loss to have a small positive separation with the possibility of
subsisting errors in the comparative separation between positive sample and
negative sample pairs. Triplet loss is similar to quadruplet loss but in the
absence the second expression in equation 2. The second expression provides
insight from the point of view of sequence with different probe samples. It
amplifies the inter-class dissimilarity and refines the execution on the
testing data. Hence, we can see that quadruplet loss enfolds the flaws of the
triplet loss noticeably and uses its power in few-shot class incremental
learning which is able to achieve competitive performance.

## Conclusion

We have proposed a novel approach to overcome catastrophic forgetting few-shot
class incremental learning setting by addressing the problem of overfitting
with the help of a prototypical network along with quadruplet loss which helps
in forming a better embedding space. Extensive experiments on benchmark
datasets show that our model can effectively mitigate catastrophic forgetting
and adapt to new classes. In our method one needs to intelligently decide
$\mathcal{B}$ set to get a robust learning. For future work one can update the
stored prototypes in such a way that those become relevant in the current
session and tune the model accordingly during incremental learning sessions,
where previous techniques such as elastic weight consolidation (EWC) [46] can
be used to constraint the model parameters.

## References

  * [1] Snell, J.; Swersky, K.; and Zemel, R. 2017. Prototypical networks for few-shot learning. In Advances in Neural Information Processing Systems.
  * [2] Zenke, F.; Poole, B.; and Ganguli, S. 2017. Continual learning through synaptic intelligence. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, 3987–3995. JMLR. org.
  * [3] Wei-Yu Chen; Yen-Cheng Liu; Zsolt Kira, Yu-Chiang Frank Wang, Jia-Bin Huang 2019. A Closer Look at Few-Shot Classification, International Conference on Learning Representations.
  * [4] Sumit Chopra; Raia Hadsell; Yann LeCun; Learning a Similarity Metric Discriminatively, with Application to Face Verification. 2005 IEEE Computer Society Conference on Computer Vision and Pattern Recognition.
  * [5] Gregory Koch; Richard Zemel; Ruslan Salakhutdinov; Siamese Neural Networks for One-shot Image Recognition 2015. International Conference on Machine Learning.
  * [6] Serra, J.; Suris, D.; Miron, M.; and Karatzoglou, A. 2018. ‘Overcoming catastrophic forgetting with hard attention to the task. arXiv preprint arXiv:1801.01423 .
  * [7] Sylvestre-Alvise Rebuffi; Alexander Kolesnikov; Georg Sperl; Christoph H. Lampert; iCaRL: Incremental Classifier and Representation Learning 2017. Computer Vision and Pattern Recognition.
  * [8] Pratik Mazumder, Pravendra Singh, Piyush Rai; Few-Shot Lifelong Learning 2021. Association for the Advancement of Artificial Intelligence.
  * [9] Adam Santoro; David Raposo; David G.T. Barrett; Mateusz Malinowski; Razvan Pascanu; Peter Battaglia; Timothy Lillicrap; A simple neural network module for relational reasoning, 2017. Neural Information Processing Systems.
  * [10] Flood Sung, Yongxin Yang, Li Zhang, Tao Xiang, Philip H.S. Torr, Timothy M. Hospedales; Learning to Compare: Relation Network for Few-Shot Learning, 2018. Computer Vision and Pattern Recognition.
  * [11] Oriol Vinyals, Charles Blundell, Timothy Lillicrap, Koray Kavukcuoglu, Daan Wierstra; Matching Networks for One Shot Learning, 2016. Neural Information Processing Systems.
  * [12] Antreas Antoniou, Amos Storkey, Harrison Edwards; Data Augmentation Generative Adversarial Networks, 2018. International Conference on Learning Representations.
  * [13] Yu-Xiong Wang, Ross Girshick, Martial Hebert, Bharath Hariharan; Low-Shot Learning from Imaginary Data, 2018. Computer Vision and Pattern Recognition.
  * [14] Chelsea Finn, Pieter Abbeel, Sergey Levine; Model-Agnostic Meta-Learning for Fast Adaptation of Deep Networks, 2017. International Conference on Machine Learning.
  * [15] Antreas Antoniou, Harrison Edwards, Amos Storkey; How To Train your MAML; 2019. International Conference on Learning Representations.
  * [16] Taesup Kim, Jaesik Yoon, Ousmane Dia, Sungwoong Kim, Yoshua Bengio, Sungjin Ahn; Bayesian Model-Agnostic Meta-Learning, 2018. Advances in Neural Information Processing Systems.
  * [17] Massimiliano Patacchiola, Jack Turner, Elliot J. Crowley, Michael O’Boyle, Amos Storkey; Bayesian Meta-Learning for the Few-Shot Setting via Deep Kernels, 2020. Advances in Neural Information Processing Systems.
  * [18] Z. Chen and B. Liu; ”Lifelong machine learning,” Synthesis Lectures on Artificial Intelligence and Machine Learning, vol. 12, no. 3, pp. 1–207, 2018.
  * [19] R. M. French, “Semi-distributed representations and catastrophic forgetting in connectionist networks,” Connection Science, vol. 4, no. 3-4, pp. 365–377, 1992.
  * [20] J. K. Kruschke, “Alcove: an exemplar-based connectionist model of category learning.” Psychological review, vol. 99, no. 1, p. 22, 1992.
  * [21] “Human category learning: Implications for backpropagation models,” Connection Science, vol. 5, no. 1, pp. 3–36, 1993.
  * [22] S. A. Sloman and D. E. Rumelhart, “Reducing interference in distributed memories through episodic gating,” Essays in honor of WK Estes, vol. 1, pp. 227–248, 1992.
  * [23] A. Robins, “Catastrophic forgetting, rehearsal and pseudorehearsal,” Connection Science, vol. 7, no. 2, pp. 123–146, 1995.
  * [24] R. M. French, “Pseudo-recurrent connectionist networks: An approach to the’sensitivity-stability’dilemma,” Connection Science, vol. 9, no. 4, pp. 353–380, 1997.
  * [25] J. Rueckl, “Jumpnet: A multiple-memory connectionist architecture,” CogSci, no. 24, pp. 866–871, 1993.
  * [26] B. Ans and S. Rousset, “Avoiding catastrophic forgetting by coupling two reverberating neural networks,” Comptes Rendus de l’Acad´emie des Sciences-Series III-Sciences de la Vie, vol. 320, no. 12, pp. 989–997, 1997.
  * [27] A. Pentina and C. H. Lampert, “A pac-bayesian bound for lifelong learning.” in ICML, 2014, pp. 991–999.
  * [28] P. Alquier, T. T. Mai, and M. Pontil, “Regret bounds for lifelong learning,” arXiv preprint arXiv:1610.08628, 2016.
  * [29] A. Pentina and C. H. Lampert, “Lifelong learning with non-iid tasks,” in NeurIPS, 2015, pp. 1540–1548.
  * [30] M.-F. Balcan, A. Blum, and S. Vempala, “Efficient representations for lifelong learning and autoencoding,” in Conference on Learning Theory, 2015, pp. 191–210.
  * [31] “Dynamically constraining connectionist networks to produce distributed, orthogonal representations to reduce catastrophic interference,” network, vol. 1111, p. 00001, 1994.
  * [32] Task Agnostic Continual Learning Using Online Variational Bayes Chen Zeno, Itay Golan, Elad Hoffer, Daniel Soudry
  * [33] Rebuffi, S.-A.; Kolesnikov, A.; Sperl, G.; and Lampert, C. H. 2017. icarl: Incremental classifier and representation learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2001–2010.
  * [34] Saihui, H.; Xinyu, P.; Chen Change, L.; Zilei, W.; and Dahua, L. 2018. Lifelong learning via progressive distillation and retrospection. In Proceedings of the European Conference on Computer Vision (ECCV).
  * [35] Hou, S.; Pan, X.; Loy, C. C.; Wang, Z.; and Lin, D. 2019. Learning a Unified Classifier Incrementally via Rebalancing. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 831–839.
  * [36] Castro, F. M.; Mar´ın-Jimenez, M. J.; Guil, N.; Schmid, C.; ´and Alahari, K. 2018. End-to-end incremental learning. In Proceedings of the European Conference on Computer Vision (ECCV), 233–248.
  * [37] Tao, X.; Hong, X.; Chang, X.; Dong, S.; Wei, X.; and Gong, Y. 2020. Few-Shot Class-Incremental Learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 12183–12192.
  * [38] Fritzke, B. 1995. A Growing Neural Gas Network Learns Topologies. Advances in Neural Information Processing Systems 7.
  * [39] Deep Nearest Class Mean Classifiers ; Samantha Guerriero, Barbara Caputo, Thomas Mensink.
  * [40] End-to-End Incremental Learning, Francisco M. Castro, Manuel J Marin Jimenez, Nicolas Guil, Cordelia Schmid, Karteek Alahari.
  * [41] Deep Residual Learning for Image Recognition, Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun
  * [42] Hou, S.; Pan, X.; Loy, C. C.; Wang, Z.; and Lin, D. 2019. Learning a Unified Classifier Incrementally via Rebalancing. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 831–839.
  * [43] Beyond triplet loss: a deep quadruplet network for person re-identification,
  * [44] Krizhevsky, A.; and Hinton, G. 2009. Learning multiple layers of features from tiny images. Technical report, Citeseer.
  * [45] Wah, C.; Branson, S.; Welinder, P.; Perona, P.; and Belongie, S. 2011. The Caltech-UCSD Birds-200-2011 Dataset. Technical Report CNS-TR-2011-001, California Institute of Technology.
  * [46] Overcoming catastrophic forgetting in neural networks ; James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A. Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, Demis Hassabis, Claudia Clopath, Dharshan Kumaran, and Raia Hadsell
  * [47] A simple neural network module for relational reasoning; Adam Santoro, David Raposo, David G.T. Barrett, Mateusz Malinowski, Razvan Pascanu, Peter Battaglia, Timothy Lillicrap.
  * [48] Prudencio Tossou, Basile Dura, Mario Marchand, François Laviolette, Alexandre Lacoste; Adaptive Deep Kernel Learning, 2019. arXiv:1905.12131.
  * [49] Weihua Chen, Xiaotang Chen, Jianguo Zhang, Kaiqi Huang; Beyond triplet loss: a deep quadruplet network for person re-identification, 2017. Computer Vision and Pattern Recognition.
  * [50] X. Wang, X. Zeng, Y. Lyu, K. Chen, Y. Zhang and D. Li, ”A Deep Quadruplet Network for Local Descriptor Learning,” in IEEE Access, vol. 8, pp. 16807-16815, 2020, doi: 10.1109/ACCESS.2019.2962624.
  * [51] Xingping Dong, X. Dong, J. Shen, D. Wu, K. Guo, X. Jin and F. Porikli, ”Quadruplet Network With One-Shot Learning for Fast Visual Object Tracking,” in IEEE Transactions on Image Processing, vol. 28, no. 7, pp. 3516-3527, July 2019, doi: 10.1109/TIP.2019.2898567.
  * [52] Yuzhe Yang, Kaiwen Zha, Ying-Cong Chen, Hao Wang, Dina Katabi, ”Delving into Deep Imbalanced Regression”, 2021, International Conference on Machine Learning.
  * [53] Sun, B., Feng, J., and Saenko, K. Return of frustratingly easy domain adaptation. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 30, 2016.