# Hyperparameter Selection in Continual Learning

Thomas L. Lee<EMAIL_ADDRESS>
School of Informatics
University of Edinburgh Sigrid Passano Hellan<EMAIL_ADDRESS>
School of Informatics
University of Edinburgh Linus Ericsson<EMAIL_ADDRESS>
School of Engineering
University of Edinburgh Elliot J. Crowley<EMAIL_ADDRESS>
School of Engineering
University of Edinburgh Amos Storkey<EMAIL_ADDRESS>
School of Informatics
University of Edinburgh

###### Abstract

In continual learning (CL)—where a learner trains on a stream of data—standard
hyperparameter optimisation (HPO) cannot be applied, as a learner does not
have access to all of the data at the same time. This has prompted the
development of CL-specific HPO frameworks. The most popular way to tune
hyperparameters in CL is to repeatedly train over the whole data stream with
different hyperparameter settings. However, this _end-of-training_ HPO is
unrealistic as in practice a learner can only see the stream once. Hence,
there is an open question: _what HPO framework should a practitioner use for a
CL problem in reality?_ This paper answers this question by evaluating several
realistic HPO frameworks. We find that all the HPO frameworks considered,
including end-of-training HPO, perform similarly. We therefore advocate using
the realistic and most computationally efficient method: fitting the
hyperparameters on the first task and then fixing them throughout training.

##  1 Introduction

Sequentially updating deep learning systems on a non-stationary data stream is
a challenging problem which  _continual learning_ (CL) methods aim to address.
The standard CL setup is when a learner sees a sequence of tasks one-by-one
and at the end of learning is evaluated on how well it performs across all
tasks. There have been many methods (Delange et al., 2021; Parisi et al.,
2019; Wang et al., 2023) designed for this problem and CL scenarios proposed
(Hsu et al., 2018; Antoniou et al., 2020; van de Ven & Tolias, 2019). A key
decision when using a CL method is selecting hyperparameter settings—learning
rates, regularisation coefficients, etc. (Feurer & Hutter, 2019; Delange et
al., 2021; Wistuba et al., 2023). The most common way to fit hyperparameters
for CL is _end-of-training_ hyperparameter optimisation (HPO) (Delange et al.,
2021; Buzzega et al., 2020)—shown in Figure 1. This is when the
hyperparameters are fit by training over the whole data stream with each
hyperparameter configuration and then selecting the configuration that has the
best end-of-training performance on a held-out validation set. However, end-
of-training HPO is unrealistic as in the real world a learner can only train
over the data stream once and must select hyperparameters only using the data
it can currently access. Therefore, it is currently unclear what is the best
_realistic_ way to perform HPO for CL.

In this work we address the problem of deciding what HPO framework to use in
CL. We benchmark a variety of approaches for performing HPO in CL across
different CL methodologies (ER (Chaudhry et al., 2020), ER-ACE (Caccia et al.,
2021), iCaRL (Rebuffi et al., 2017), ESMER (Sarfraz et al., 2023) and DER++
(Buzzega et al., 2020)). We investigate both fixed HPO frameworks where the
hyperparameters are kept constant throughout training and dynamic HPO
frameworks where hyperparameters are adapted throughout learning. For fixed
HPO we examine (i)  _end-of-training_ HPO as well as (ii) a  _first-task_ HPO
framework where we fit the hyperparameters only using data from the first task
(see Figure 1), a realistic and computationally efficient method. For dynamic
HPO, we consider (i) using data from the current task, (ii) using data stored
in memory, and (iii) using validation sets from previous tasks to perform HPO
for each new task. By comparing these different HPO frameworks we shed light
on what validation signal is sufficient to fit hyperparameters in CL and
whether hyperparameters need to be adapted during training.

Our experiments show that all the HPO frameworks tested perform similarly in
terms of predictive performance; no one method is consistently better than the
others. This could be because in standard CL benchmarks each task is very
homogeneous, being of the same size and difficulty. Hence, there might be no
reason to change hyperparameters per task or to use more than the first task
to select hyperparameters. We therefore also evaluate the performance of each
HPO framework on more heterogeneous data streams where the tasks are of
varying difficulty and have different numbers of data points associated with
them. However, even in this case all HPO frameworks perform similarly. Given
these results we advocate the realistic and most computationally efficient
method, _first-task_ HPO, to practitioners for performing HPO in CL.

Figure 1: Depiction of end-of-training and first-task HPO frameworks, which
fix the hyperparameters (HPs) throughout training. _End-of-training_ HPO is
the most common HPO framework for CL and works by training over the whole data
stream for each HP configuration and then uses a validation set consisting of
data from each task to select the best HPs. End-of-training HPO is unrealistic
as it assumes you have access to all of the data stream from the start of
training. While, _first-task_ HPO selects HPs by repeatedly training and
validating performance on the first task, which is more realistic and
efficient.

The main contributions of this work are:

  * •

We benchmark a suite of realistic CL HPO frameworks against the commonly used
but unrealistic end-of-training HPO.

  * •

We show that all HPO frameworks we compare perform similarly, including both
methods which dynamically change hyperparameters throughout training and those
which do not.

  * •

We provide evidence that first-task HPO is a good method for performing HPO in
CL, as it performs similarly to other approaches while being more
computationally efficient.

##  2 Preliminaries and related work

CL is a large research area where many different settings have been looked at.
In this work we look at the most common CL setting which is known as standard
CL, or sometimes offline CL (Prabhu et al., 2020). In _Standard CL_ , the
learner sees a non-stationary sequence of data chunks called _tasks_ one-by-
one, such that it only has access to one chunk at a time and cannot access
previously seen or future chunks. Each task consists of examples which are
data instance and label pairs (e.g. pairs of images and their class) sampled
from a subset of the classes. For example, the first task might be examples of
cows and sheep and the second task could be formed of examples of dogs and
cats. The goal of the learner is to classify new examples accurately after
training on the whole data stream. There are two common ways to evaluate a CL
learner, task and class incremental learning. _Task-incremental_ learning is
when, at test-time, the learner knows which task a data instance comes from
and so only needs to distinguish between classes within that task. While,
_class-incremental_ learning is when the learner is not given what task a data
instance belongs to at test time and must distinguish between all classes from
all the tasks.

There have been many methods proposed for CL (Delange et al., 2021; Parisi et
al., 2019; Wang et al., 2023). One of the most popular and performant
approaches to standard CL are replay methods (Wang et al., 2023). This is
especially true for class-incremental learning, where they are commonly the
best performing methods (van de Ven & Tolias, 2019; Wu et al., 2022; Mirzadeh
et al., 2020; Lee & Storkey, 2024). _Replay_ methods use a memory buffer to
store a set of examples from previous tasks to regularise the updates on new
tasks such that the learner does not forget previous task knowledge. For
example, the stereotypical replay method is _experience replay_ (ER) (Chaudhry
et al., 2020; 2019b; Aljundi et al., 2019a) which for each learning step
appends a sample of data from the replay buffer to the batch of current task
data to be trained on. More complex replay methods often use a form of
knowledge distillation on a sample of data from the replay buffer. For
example, DER++ (Buzzega et al., 2020), ESMER (Sarfraz et al., 2023) and iCaRL
(Rebuffi et al., 2017) are replay methods which use a method-specific
knowledge distillation term. For each of these methods the most common
hyperparameters that are tuned are the learning rate and regularisation
coefficients, which need to be tuned to get good performance (see Appendix B).
While other potential hyperparameters are often not tuned in CL, e.g. momentum
(Buzzega et al., 2020).

While the most common HPO framework used in standard CL is end-of-task HPO,
there have been several other HPO frameworks suggested (Kilickaya &
Vanschoren, 2023; Parisi et al., 2019). For example, Delange et al. (2021)
propose a dynamic HPO framework. The method adapts the hyperparameters for
each task by first training with the hyperparameter configuration which is
assumed to have the least impact on previous task performance. Then the method
incrementally changes hyperparameter values to improve performance on the
current task to a prespecified value, while decreasing performance on previous
tasks. However, this method assumes that the direction to change
hyperparameters to increase performance on the current task is known and that
the interaction between different hyperparameters is understood. In this work
we look at a similar HPO framework, current-task HPO, which does not need the
above assumptions. Also, for the online CL scenario—which is different to
standard CL—another HPO framework has been proposed whereby end-of-training
HPO is used on the first (or first $k$) tasks and then the hyperparameters are
fixed after that (Chaudhry et al., 2019a). To the best of our knowledge, this
HPO framework has been rarely used in standard CL up to this point. Here, we
look at it in the form of the first-task HPO framework and examine how it
performs in the commonly used standard CL setting. There has also been work on
making dynamic HPO frameworks more efficient by sampling fewer HPO
configurations, for example using bandit methods (Liu et al., 2023) and
analysis of variance techniques (Semola et al., 2024). However, for
simplicity, we only look at the more expensive dynamic HPO frameworks which
are an upper bound to the performance of these more efficient methods. In this
work we have aimed to have tested the main proposed HPO frameworks to see
which performs the best and note that to the best of our knowledge no previous
works have comprehensively compared the different HPO frameworks for CL to
each other.

##  3 Standard CL

While the setting we look at, standard CL, is mentioned above, we describe it
more formally here. In _standard CL_ a learner sees a sequence of tasks,
$D_{1},\ldots,D_{T}$, where each task consists of a chunk of data. The chunks
of data consist of a set of examples, where an example is a pair formed of a
data instance ${\mathbf{x}}\in X$ and label $y\in C$. Each task only contains
examples from a given subset of the classes, in other words for all
$({\mathbf{x}},y)\in D_{i}$ we have that $y\in C_{i}$ and $C_{i}\subseteq C$
is the subset of classes the examples of that task can belong to. In this work
we look at the most common setting, where no two tasks have examples from the
same class. This means that for any two task $i$ and $j$ we have that
$C_{i}\cap C_{j}=\varnothing$. Additionally, learners can have a memory buffer
of previous examples which consists at task $i$ of the set $M_{i}$. Training
consists of the learner sequentially seeing each task in order and it cannot
access the data from previous or future tasks. For each task, its data chunk
is split into training and validations sets, $\text{Train}_{i}\subseteq D_{i}$
and $\text{Val}_{i}\subseteq D_{i}$, to enable the use of HPO frameworks. Then
after fitting the hyperparameters the learner usually retrains on the
combination of the training and validation sets,
$D_{i}=\text{Train}_{i}\cup\text{Val}_{i}$. After training the learner is
tested by evaluating its performance on a held-out set of data which consists
of an equal number of examples from all the classes. We look at two evaluation
scenarios, task-incremental learning and class-incremental learning. _Task-
incremental_ learning is where the learner receives with each test data
instance the task it belongs to and therefore the subset of classes that the
data instance can belong to. While for _class-incremental_ learning, no
indication is given of what task a test data instance belongs to.

Table 1: Advantages and disadvantages of different HPO frameworks. Where, for time complexity, $K$ refers to the number of hyperparameter configurations looked at and $T$ is the number of tasks in the data stream. The asterisk (*) for seen-tasks HPO (Val) denotes that, while it does not require knowledge of future tasks like end-of-training HPO, it does require additional storage compared to other methods. The additional memory is needed to store the validation sets of previous tasks. HPO Framework | Realistic? | Efficient? (Time Complexity)
---|---|---
End-of-training HPO | ✗ | ✗ ($\mathcal{O}(T\times K)$)
First-task HPO | ✓ | ✓ ($\mathcal{O}(T+K)$)
Current-task HPO | ✓ | ✗ ($\mathcal{O}(T\times K)$)
Seen-tasks HPO (Val) | ✓* | ✗ ($\mathcal{O}(T\times K)$)
Seen-tasks HPO (Mem) | ✓ | ✗ ($\mathcal{O}(T\times K)$)

##  4 HPO frameworks for CL

Figure 2: Depiction of current-task, seen-tasks (Mem) and seen-tasks (Val) HPO
frameworks, which dynamically adapt hyperparameters (HPs) for each task. Each
methods splits the data of the current task into train and validation sets.
Then, current-task HPO uses this validation set to fit the HPs for the current
task. While, seen-tasks (Mem) and seen-tasks (Val) use a combination of this
validation set and either a sample of data from previous tasks stored in
memory or validation sets of previous tasks, respectively. Then current-task
and seen-tasks (Mem) HPO retrain on the combined validation and train sets to
complete the learning process on that task. Seen-tasks (Val) does not retrain,
instead it takes the model fitted using the best found hyperparameters as the
final model for the current task. This is to ensure that the current task’s
validation set has not been trained on when fitting hyperparameters for future
tasks.

In this work, we examine several HPO frameworks for CL to see which should be
the preferred choice to use in CL. We look both at fixed HPO frameworks which
keep the values of hyperparameters constant throughout training and dynamic
HPO which adapts the hyperparameters per task. The fixed HPO frameworks we
look at are end-of-task HPO and first-task HPO and the dynamic HPO frameworks
we look at are current-task HPO, seen-tasks HPO (Mem) and seen-tasks HPO
(Val). Each of these frameworks are described in turn below and we present an
overview of their advantages and disadvantages in Table 1.

End-of-task HPO is the most common HPO framework for CL (shown in Figure 1).
It selects hyperparameters by first training each hyperparameter configuration
on the _whole data stream_. Second, it evaluates the final model fitted using
each hyperparameter configuration on a validation set formed of each task’s
held-out validation set, and selects the configuration with the highest
validation performance. Last, it retrains using the selected configuration on
the whole data stream where the validation data for each task is added to the
training data. The model fitted at the end of this training run is the final
model to be evaluated. This HPO framework is expensive as it needs to perform
a training run over all the data stream for each hyperparameter configuration
looked at. Additionally, it is unrealistic as it requires running through the
data stream multiple times, which is not possible in many real-world settings.

First-task HPO is a fixed HPO framework which is illustrated in Figure 1. It
selects hyperparameters by training each hyperparameter configuration on the
_first task_. Next, it measures the performance of each configuration on the
held-out validation set of the first task. The configuration with the highest
validation accuracy is then used to retrain on the first task using both the
training and validation data and thereafter for all of the future tasks.
First-task HPO is computationally efficient as it trains using each
hyperparameter configuration solely on the first task and then only trains
using one configuration for the rest of the tasks. This is much less costly
than end-of-task HPO, which for all tasks must train using each hyperparameter
configuration. Additionally, first-task HPO can be used in real-world settings
as it only assumes access to data available at the start of training, the
first task, and not future tasks like end-of-task HPO.

Current-task HPO is a dynamic HPO framework which selects hyperparameters for
each task using the validation set of the _current task_ (shown in Figure 2).
This is a greedy strategy, selecting the hyperparameters that maximise the
validation performance of the current task. It is roughly as computationally
expensive as end-of-task HPO, as it has to validate each hyperparameter
configuration for each task. However, it is more realistic than end-of-task
HPO as it only needs access to the current task’s data.

Seen-tasks HPO (Mem) and seen-tasks HPO (Val) are dynamic HPO frameworks
(shown in Figure 2). They select hyperparameters for each task by a validation
set formed of current task validation data along with some historic data from
the stream. We consider two ways to integrate historic task data. Seen-tasks
HPO (Mem) uses a sample of data from the current memory buffer. Seen-tasks HPO
(Val) uses the validation sets of previous tasks. So, unlike current-task HPO,
the hyperparameters are fit using both current and previous task data. This
should aid the HPO procedure in selecting hyperparameters that ensure previous
tasks are not forgotten. Like current task HPO, both seen-tasks HPO (Mem) and
seen-tasks HPO (Val) are as computationally expensive as end-of-task HPO.
Seen-tasks HPO (Val) assumes it is possible to access the validation sets of
previous tasks which makes it less realistic than current or first task HPO.
This is unlike seen-tasks HPO (Mem) which does not assume this as it uses data
stored in the memory buffer to measure performance on the previous tasks. But,
this comes at the cost of biasing its validation performance as the data in
the memory buffer has been trained on in previous tasks.

For seen-tasks HPO (Mem), three additional details are important to mention.
First, to ensure we are not training on validation data, the sample from
memory used in the validation set is not trained on for the current task.
Second, as the memory buffer contains different amounts of data for each task,
we sample the same proportion of examples from each task to add to the
validation set. Last, unlike for the other HPO frameworks, the validation set
combined with the sample from memory might be class imbalanced. Therefore,
unlike other methods which use validation accuracy as the performance metric,
for seen-tasks HPO (Mem) we use the median of per class accuracies to reduce
the impact of class imbalance.

##  5 Experiments

Benchmarks  In our experiments we look at two settings, the commonly used
split task setting (Buzzega et al., 2020; Delange et al., 2021) and the
heterogeneous task setting. We look at these settings using the datasets
CIFAR-10, CIFAR-100 and Tiny ImageNet (Krizhevsky, 2009; Wu et al., 2015). In
the split task setting, each task has the same number of classes associated
with it and no two tasks share a class. For CIFAR-10, the dataset is split
into five tasks, each containing the data from two of the classes. For
CIFAR-100 and Tiny ImageNet, the datasets are split into ten tasks, where each
task contains the data of 10 or 20 classes, respectively. In the heterogeneous
task setting, instead of each task having the same number of classes
associated with it they have a varying amount, from two to ten, but still no
two tasks share a class (see Appendix A for more details). This is to make the
tasks have differing amounts of data and difficulty. We only look at CIFAR-100
and Tiny ImageNet for the heterogeneous task setting as CIFAR-10 contains a
small number of classes, making it impossible to vary the number of classes by
a large degree. Additionally, for the heterogeneous task setting we divide the
datasets into twenty tasks to test how HPO frameworks perform on longer task
sequences. For both settings, if required by the HPO framework, we split the
data of the task into train and validations sets, where the validation set
contains $10\%$ of the task’s data evenly sampled from each class associated
with the task.

We evaluate the methods at the end of training using a standard performance
metric for CL, average accuracy (Chaudhry et al., 2019a). The average accuracy
of a method is the mean accuracy over each task on a held-out test set which
contains an equal amount of data from each task. For class-incremental
learning, the learner must classify between all classes at test time as it is
not told what task a test data instance comes from. For task-incremental
learning, the learner knows what task each test data instance comes from,
meaning only classes from that task will be predicted.

CL methods  To evaluate how well each HPO framework performs we look at
applying them to fit the hyperparameters of several common and well performing
CL methods. More specifically, we utilise the CL methods: ER (Chaudhry et al.,
2020), ER-ACE (Caccia et al., 2021), iCaRL (Rebuffi et al., 2017), ESMER
(Sarfraz et al., 2023) and DER++ (Buzzega et al., 2020). For these methods we
fit the learning rate and any regularisation coefficients they have using each
HPO framework. While all HPO frameworks looked at can be used with any
underlying sampler/selector of hyperparameter configurations, for simplicity
and to be consistent with common practice in CL (Buzzega et al., 2020;
Boschini et al., 2022; Sarfraz et al., 2023) we use grid search. We look at
the combination of ten different learning rate values and for each
regularisation coefficient three different values. This means for DER++ we
search over 90 different hyperparameter configurations (learning rate and two
regularisation coefficients) and for ESMER we search over 30 different
configurations (learning rate and the loss margin coefficient). While, for ER,
iCaRL and ER-ACE we look at 10 different configurations as they have no
regularisation coefficients to fit. The hyperparameter grid used is very
similar to the ones looked at in several popular works on CL (Buzzega et al.,
2020; Boschini et al., 2022) and is given in full in Appendix A. Moreover, for
each method we use: a ResNet18 (He et al., 2016) as the underlying backbone
network; random crop and horizontal flip data augmentations when training; and
a memory buffer of size $5120$, as in common with previous work (Buzzega et
al., 2020).

Table 2: Results of using different HPO frameworks for ER, iCaRL, ER-ACE, ESMER and DER++ on standard CL benchmarks, i.e. the split task setting. We report mean average accuracy over three runs with their standard errors and bold results which are greater by $+0.5\%$ average accuracy than any other for that CL method. The table shows that all HPO frameworks perform similarly and that the simplest and least computationally expensive method, first-task HPO, performs as well as the rest.  |  | CIFAR-10 | CIFAR-100 | TinyImageNet
---|---|---|---|---
CL Method | HPO Framework | Class-IL. | Task-IL. | Class-IL. | Task-IL. | Class-IL. | Task-IL.
ER | End-of-training HPO | $83.55_{\pm 0.44}$ | $97.18_{\pm 0.14}$ | $51.03_{\pm 0.43}$ | $85.68_{\pm 0.29}$ | $28.01_{\pm 0.09}$ | $68.17_{\pm 0.06}$
First-task HPO | $\mathbf{84.38}_{\pm 0.45}$ | $96.82_{\pm 0.17}$ | $49.61_{\pm 0.34}$ | $84.97_{\pm 0.19}$ | $28.51_{\pm 0.18}$ | $\mathbf{68.72}_{\pm 0.13}$
Current-task HPO | $82.10_{\pm 2.21}$ | $96.39_{\pm 0.50}$ | $50.64_{\pm 0.40}$ | $85.47_{\pm 0.18}$ | $25.79_{\pm 0.21}$ | $66.96_{\pm 0.15}$
Seen-tasks HPO (Val) | $83.67_{\pm 0.73}$ | $96.84_{\pm 0.21}$ | $51.46_{\pm 0.36}$ | $85.65_{\pm 0.06}$ | $28.45_{\pm 0.28}$ | $68.16_{\pm 0.26}$
Seen-tasks HPO (Mem) | $79.49_{\pm 0.63}$ | $95.93_{\pm 0.09}$ | $47.39_{\pm 0.24}$ | $84.83_{\pm 0.22}$ | $\mathbf{29.58}_{\pm 0.25}$ | $68.02_{\pm 0.14}$
iCaRL | End-of-training HPO | $77.79_{\pm 0.23}$ | $\mathbf{98.52}_{\pm 0.03}$ | $54.30_{\pm 0.36}$ | $85.74_{\pm 0.45}$ | $37.09_{\pm 0.27}$ | $70.37_{\pm 0.36}$
First-task HPO | $77.83_{\pm 0.22}$ | $95.31_{\pm 0.12}$ | $52.56_{\pm 0.10}$ | $84.60_{\pm 0.09}$ | $36.42_{\pm 0.22}$ | $70.11_{\pm 0.13}$
Current-task HPO | $76.15_{\pm 0.75}$ | $93.29_{\pm 0.61}$ | $54.26_{\pm 0.02}$ | $85.74_{\pm 0.06}$ | $37.17_{\pm 0.28}$ | $70.67_{\pm 0.03}$
Seen-tasks HPO (Val) | $77.58_{\pm 0.49}$ | $94.32_{\pm 1.01}$ | $51.89_{\pm 0.39}$ | $84.02_{\pm 0.68}$ | $34.81_{\pm 0.42}$ | $68.42_{\pm 0.41}$
Seen-tasks HPO (Mem) | $76.67_{\pm 0.44}$ | $95.41_{\pm 0.28}$ | $49.16_{\pm 0.23}$ | $82.43_{\pm 0.23}$ | $36.79_{\pm 0.13}$ | $70.46_{\pm 0.08}$
ER-ACE | End-of-training HPO | $82.34_{\pm 0.30}$ | $96.74_{\pm 0.01}$ | $55.58_{\pm 0.39}$ | $85.73_{\pm 0.09}$ | $\mathbf{38.94}_{\pm 0.47}$ | $\mathbf{70.18}_{\pm 0.23}$
First-task HPO | $83.20_{\pm 0.79}$ | $96.67_{\pm 0.18}$ | $56.36_{\pm 0.29}$ | $86.11_{\pm 0.154}$ | $36.94_{\pm 0.67}$ | $68.16_{\pm 0.30}$
Current-task HPO | $\mathbf{83.99}_{\pm 0.22}$ | $96.58_{\pm 0.15}$ | $56.46_{\pm 0.36}$ | $86.35_{\pm 0.02}$ | $37.63_{\pm 0.38}$ | $68.25_{\pm 0.41}$
Seen-tasks HPO (Val) | $81.94_{\pm 1.55}$ | $95.90_{\pm 0.51}$ | $54.37_{\pm 0.25}$ | $85.02_{\pm 0.14}$ | $36.06_{\pm 0.37}$ | $67.69_{\pm 0.26}$
Seen-tasks HPO (Mem) | $81.61_{\pm 0.15}$ | $96.40_{\pm 0.13}$ | $53.76_{\pm 0.21}$ | $84.56_{\pm 0.31}$ | $32.37_{\pm 0.34}$ | $64.37_{\pm 0.47}$
ESMER | End-of-training HPO | $80.73_{\pm 0.15}$ | $96.50_{\pm 0.01}$ | $56.16_{\pm 0.54}$ | $88.69_{\pm 0.35}$ | $\mathbf{47.33}_{\pm 0.30}$ | $76.18_{\pm 0.22}$
First-task HPO | $77.89_{\pm 0.46}$ | $96.15_{\pm 0.12}$ | $56.61_{\pm 0.20}$ | $89.05_{\pm 0.10}$ | $46.69_{\pm 0.56}$ | $75.72_{\pm 0.24}$
Current-task HPO | $81.69_{\pm 0.25}$ | $96.03_{\pm 0.05}$ | $55.11_{\pm 0.13}$ | $88.96_{\pm 0.08}$ | $45.20_{\pm 0.53}$ | $74.93_{\pm 0.29}$
Seen-tasks HPO (Val) | $81.29_{\pm 0.03}$ | $96.46_{\pm 0.06}$ | $53.81_{\pm 0.44}$ | $87.26_{\pm 0.13}$ | $44.82_{\pm 0.16}$ | $74.27_{\pm 0.11}$
Seen-tasks HPO (Mem) | $70.95_{\pm 0.94}$ | $95.79_{\pm 0.14}$ | $\mathbf{57.50}_{\pm 0.14}$ | $89.27_{\pm 0.16}$ | $44.26_{\pm 0.20}$ | $74.54_{\pm 0.31}$
DER++ | End-of-training HPO | $84.40_{\pm 0.94}$ | $95.75_{\pm 0.33}$ | $56.04_{\pm 3.67}$ | $83.13_{\pm 2.69}$ | $\mathbf{39.89}_{\pm 0.27}$ | $\mathbf{70.41}_{\pm 0.17}$
First-task HPO | $85.22_{\pm 0.08}$ | $96.14_{\pm 0.10}$ | $55.20_{\pm 0.78}$ | $81.68_{\pm 0.66}$ | $35.98_{\pm 0.63}$ | $65.86_{\pm 0.37}$
Current-task HPO | $84.90_{\pm 0.11}$ | $95.92_{\pm 0.11}$ | $55.00_{\pm 1.21}$ | $83.14_{\pm 0.76}$ | $36.64_{\pm 0.33}$ | $66.43_{\pm 0.49}$
Seen-tasks HPO (Val) | $85.44_{\pm 0.38}$ | $96.22_{\pm 0.15}$ | $56.59_{\pm 0.64}$ | $83.61_{\pm 0.42}$ | $31.88_{\pm 5.36}$ | $64.20_{\pm 3.00}$
Seen-tasks HPO (Mem) | $82.18_{\pm 0.26}$ | $94.75_{\pm 0.28}$ | $56.94_{\pm 0.66}$ | $83.08_{\pm 0.21}$ | $33.54_{\pm 0.13}$ | $63.68_{\pm 0.17}$

###  5.1 Results

Table 3: Results of using different HPO frameworks for ER, iCaRL, ER-ACE, ESMER and DER++ on heterogeneous task benchmarks. We report mean average accuracy over three runs with their standard errors and bold the results which are greater by $+0.5\%$ accuracy than any other for that CL method. The table shows that the simplest and least computationally expensive method, first-task HPO, performs similarly to the other HPO frameworks and that no HPO framework is consistently better than the rest. |  | Hetero-CIFAR-100 | Hetero-TinyImg
---|---|---|---
CL Method | HPO Framework | Class-IL. | Class-IL.
ER | End-of-training HPO | $50.41_{\pm 0.21}$ | $39.41_{\pm 0.57}$
First-task HPO | $50.33_{\pm 0.50}$ | $40.77_{\pm 0.34}$
Current-task HPO | $49.77_{\pm 0.21}$ | $40.65_{\pm 0.97}$
Seen-tasks HPO (Val) | $\mathbf{51.70}_{\pm 0.23}$ | $40.55_{\pm 0.22}$
Seen-tasks HPO (Mem) | $45.52_{\pm 0.41}$ | $\mathbf{44.62}_{\pm 0.18}$
iCaRL | End-of-training HPO | $51.54_{\pm 0.38}$ | $37.17_{\pm 0.48}$
First-task HPO | $49.81_{\pm 0.10}$ | $37.47_{\pm 0.26}$
Current-task HPO | $51.34_{\pm 0.32}$ | $37.07_{\pm 0.07}$
Seen-tasks HPO (Val) | $48.15_{\pm 0.09}$ | $35.70_{\pm 0.23}$
Seen-tasks HPO (Mem) | $47.87_{\pm 0.15}$ | $35.27_{\pm 1.12}$
ER-ACE | End-of-training HPO | $51.96_{\pm 0.60}$ | $\mathbf{45.47}_{\pm 0.42}$
First-task HPO | $51.37_{\pm 0.16}$ | $43.62_{\pm 1.09}$
Current-task HPO | $51.78_{\pm 0.30}$ | $43.87_{\pm 0.20}$
Seen-tasks HPO (Val) | $51.94_{\pm 0.12}$ | $43.15_{\pm 0.63}$
Seen-tasks HPO (Mem) | $48.15_{\pm 0.28}$ | $42.19_{\pm 0.84}$
ESMER | End-of-training HPO | $50.54_{\pm 0.16}$ | $44.87_{\pm 0.26}$
First-task HPO | $50.43_{\pm 0.34}$ | $45.84_{\pm 0.50}$
Current-task HPO | $50.68_{\pm 0.31}$ | $44.50_{\pm 0.31}$
Seen-tasks HPO (Val) | $47.96_{\pm 0.61}$ | $42.18_{\pm 0.22}$
Seen-tasks HPO (Mem) | $50.56_{\pm 0.40}$ | $46.00_{\pm 0.43}$
DER++ | End-of-training HPO | $54.12_{\pm 0.70}$ | $46.41_{\pm 0.77}$
First-task HPO | $54.87_{\pm 0.39}$ | $43.45_{\pm 3.55}$
Current-task HPO | $55.10_{\pm 0.52}$ | $45.95_{\pm 0.93}$
Seen-tasks HPO (Val) | $54.67_{\pm 0.57}$ | $46.51_{\pm 0.49}$
Seen-tasks HPO (Mem) | $49.06_{\pm 3.90}$ | $25.78_{\pm 7.40}$

For the split task setting, the results of our experiments show that none of
the HPO frameworks looked at perform much better than the rest. The results
are presented in Table 2 and we have bolded the results which are better by
$+0.5\%$ than any of the other HPO frameworks results for a given CL method.
As can be seen, there are not many bolded numbers and for those that exist,
the HPO framework which achieves it varies. This shows that no HPO framework
performs consistently better than the rest. For instance, on CIFAR-100, no HPO
framework improves accuracy over the other methods by more than $+0.5\%$ for
all CL methods but ESMER in class-incremental learning. This suggest that for
the split task setting there is no general advantage in using one HPO
framework over another in terms of predictive performance.

In the heterogeneous task setting we also see that none of the HPO frameworks
perform consistently better than the rest. The results for this setting are
presented in Table 3 and we have again bolded the results which are better by
$+0.5\%$ than any of the other HPO frameworks for a given CL method. Like the
results for the split task setting, there are many columns for each CL method
which have no bolded result and for the three which do the HPO framework which
achieves it is different. Therefore, we conclude that in the heterogeneous
task setting it is also the case that there is no one best HPO framework. We
also note that the reason we look at the heterogeneous task setting is because
we expected a greater benefit from adapting hyperparameters per task, given
that unlike the split task setting each task is quite different. However, our
results show that this is not the case and that it is possible to use the same
hyperparameters across all the tasks and still perform well.

Performance of first-task HPO Our results show that all of the HPO frameworks
tested perform similarly. Therefore, we conclude that first-task HPO is a good
method to use as it is the most computationally efficient. We describe here in
more detail its relative performance compared to the other HPO frameworks
tested. In the split tasks setting, we see from Table 2, that for ER some of
its results are bolded. Thus, first-task HPO sometimes achieves the best
performance. Additionally, for the spilt task setting, there is an average
performance difference from end-of-training HPO to first-task HPO of $-0.42\%$
in class-incremental learning and $-0.84\%$ in task-incremental learning.
While, for the heterogeneous tasks setting there is an average performance
difference from end-of-training HPO to first-task HPO of $-0.39\%$. End-of-
training HPO is currently the most used HPO framework in CL but is unrealistic
and computationally expensive. Hence, our results indicate that by using
first-task framework it is possible to perform realistic HPO for much less
computation with only a small expected cost to performance.

(a)  (b)  (c)  (d)

(e)

Figure 3: Histograms of the validation accuracy at the end of training for
each hyperparameter setting searched over for DER++. We look at standard CL
benchmarks and heterogeneous task benchmarks, which are identified by having a
‘Hetero’ in their name. The histograms show that different hyperparameter
settings give a varying range of performances and only a few achieve near to
the top performance.

One of the potential reasons that the performance is similar between HPO
frameworks is that there is little variation between the performance of
different hyperparameter configurations. To see whether this is the case, we
have plotted in Figure 3 histograms of the performance of using different
fixed HPO configurations for DER++. The histograms show that hyperparameter
configurations achieve a wide range of average accuracies. Therefore, the
performance of different HPO configurations is _not_ the reason why the HPO
frameworks have similar results. Additionally, in Appendix B, we examine
whether using default hyperparameters performs as well as selecting
hyperparameters using HPO. We found that using default hyperparameters in most
cases performed worse than using a HPO framework. Hence, our results suggest
that HPO is necessary but that out of the HPO frameworks tested there is no
one best performing method.

##  6 Conclusions

In this paper we have benchmarked several hyperparameter optimisation (HPO)
frameworks for CL which are more realistic than the currently commonly used
end-of-task HPO framework. We benchmarked both fixed HPO frameworks, which fix
the hyperparameters throughout training, and dynamic HPO frameworks that
continually adapt the hyperparameters. Our results show that all the HPO
frameworks achieve similar performances and none consistently outperforms the
others. Because of this, we recommend that the preferred HPO framework for
future work in continual learning should be the much more computationally
efficient _first-task_ HPO.

## References

  * Aljundi et al. (2019a) Rahaf Aljundi, Lucas Caccia, Eugene Belilovsky, Massimo Caccia, Min Lin, Laurent Charlin, and Tinne Tuytelaars.  Online Continual Learning with Maximal Interfered Retrieval.  In _Proceedings of the 33rd Conference on the Advances in Neural Information Processing Systems_ , pp. 11849–11860, 2019a.
  * Aljundi et al. (2019b) Rahaf Aljundi, Min Lin, Baptiste Goujaud, and Yoshua Bengio.  Gradient Based Sample Selection for Online Continual Learning.  In _Proceedings of the 33rd Conference on the Advances in Neural Information Processing Systems_ , pp. 11816–11825, 2019b.
  * Antoniou et al. (2020) Antreas Antoniou, Massimiliano Patacchiola, Mateusz Ochal, and Amos Storkey.  Defining Benchmarks for Continual Few-shot Learning.  _arXiv preprint arXiv:2004.11967_ , 2020.
  * Bergstra et al. (2011) James Bergstra, Rémi Bardenet, Yoshua Bengio, and Balázs Kégl.  Algorithms for Hyper-Parameter Optimization.  In _Proceeding of the 25th Conference on the Advances in Neural Information Processing Systems_ , 2011.
  * Boschini et al. (2022) Matteo Boschini, Lorenzo Bonicelli, Pietro Buzzega, Angelo Porrello, and Simone Calderara.  Class-Incremental Continual Learning into the Extended DER-verse.  _IEEE Transactions on Pattern Analysis and Machine Intelligence_ , 45(5):5497–5512, 2022.
  * Buzzega et al. (2020) Pietro Buzzega, Matteo Boschini, Angelo Porrello, Davide Abati, and Simone Calderara.  Dark Experience for General Continual Learning: a Strong, Simple Baseline.  In _Proceedings of the 33rd Conference on the Advances in Neural Information Processing Systems_ , pp. 15920–15930, 2020.
  * Caccia et al. (2021) Lucas Caccia, Rahaf Aljundi, Nader Asadi, Tinne Tuytelaars, Joelle Pineau, and Eugene Belilovsky.  New Insights on Reducing Abrupt Representation Change in Online Continual Learning.  In _Proceedings of the 10th International Conference on Learning Representations_ , 2021.
  * Chaudhry et al. (2019a) Arslan Chaudhry, Marc’Aurelio Ranzato, Marcus Rohrbach, and Mohamed Elhoseiny.  Efficient Lifelong Learning with A-GEM.  In _Proceedings of the 7th International Conference on Learning Representations_ , 2019a.
  * Chaudhry et al. (2019b) Arslan Chaudhry, Marcus Rohrbach, Mohamed Elhoseiny, Thalaiyasingam Ajanthan, Puneet K Dokania, Philip HS Torr, and Marc’Aurelio Ranzato.  On Tiny Episodic Memories in Continual Learning.  _arXiv preprint arXiv:1902.10486_ , 2019b.
  * Chaudhry et al. (2020) Arslan Chaudhry, Naeemullah Khan, Puneet Dokania, and Philip Torr.  Continual Learning in Low-rank Orthogonal Subspaces.  In _Proceeding of the 34th Conference on the Advances in Neural Information Processing Systems_ , pp. 9900–9911, 2020.
  * Delange et al. (2021) Matthias Delange, Rahaf Aljundi, Marc Masana, Sarah Parisot, Xu Jia, Ales Leonardis, Greg Slabaugh, and Tinne Tuytelaars.  A Continual Learning Survey: Defying Forgetting in Classification Tasks.  _IEEE Transactions on Pattern Analysis and Machine Intelligence_ , 44(7):3366–3385, 2021.
  * Feurer & Hutter (2019) Matthias Feurer and Frank Hutter.  Hyperparameter Optimization.  _Automated machine learning: Methods, systems, challenges_ , pp. 3–33, 2019.
  * He et al. (2016) Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun.  Deep Residual Learning for Image Recognition.  In _Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition_ , pp. 770–778, 2016.
  * Hellan et al. (2023) Sigrid Passano Hellan, Huibin Shen, François-Xavier Aubet, David Salinas, and Aaron Klein.  Obeying the Order: Introducing Ordered Transfer Hyperparameter Optimisation.  _arXiv preprint arXiv:2306.16916_ , 2023.
  * Hsu et al. (2018) Yen-Chang Hsu, Yen-Cheng Liu, Anita Ramasamy, and Zsolt Kira.  Re-evaluating Continual Learning Scenarios: A Categorization and Case for Strong Baselines.  In _Proceedings of the 3rd Continual Learning Workshop, at the 32nd Conference on the Advances in Neural Information Processing Systems_ , 2018.
  * Kilickaya & Vanschoren (2023) Mert Kilickaya and Joaquin Vanschoren.  What can AutoML do for Continual Learning?  _arXiv preprint arXiv:2311.11963_ , 2023.
  * Krizhevsky (2009) Alex Krizhevsky.  Learning Multiple Layers of Features from Tiny Images.  _Preprint_ , 2009.
  * Lee & Storkey (2023) Thomas L Lee and Amos Storkey.  Chunking: Forgetting Matters in Continual Learning even without Changing Tasks.  _arXiv preprint arXiv:2310.02206_ , 2023.
  * Lee & Storkey (2024) Thomas L Lee and Amos Storkey.  Approximate Bayesian Class-Conditional Models under Continuous Representation Shift.  In _Proceedings of the 27th International Conference on Artificial Intelligence and Statistics_ , 2024.
  * Liu et al. (2023) Yaoyao Liu, Yingying Li, Bernt Schiele, and Qianru Sun.  Online hyperparameter optimization for class-incremental learning.  In _Proceedings of the 37th AAAI Conference on Artificial Intelligence_ , pp. 8906–8913, 2023.
  * Mirzadeh et al. (2020) Seyed Iman Mirzadeh, Mehrdad Farajtabar, Razvan Pascanu, and Hassan Ghasemzadeh.  Understanding the Role of Training Regimes in Continual Learning.  In _Proceedings of the 33rd conference on the Advances in Neural Information Processing Systems_ , pp. 7308–7320, 2020.
  * Parisi et al. (2019) German I. Parisi, Ronald Kemker, Jose L. Part, Christopher Kanan, and Stefan Wermter.  Continual Lifelong Learning with Neural Networks: A review.  _Neural Networks_ , 113:54 – 71, 2019.
  * Prabhu et al. (2020) Ameya Prabhu, Philip HS Torr, and Puneet K Dokania.  GDumb: A Simple Approach that Questions our Progress in Continual Learning.  In _Procceding of the 16th European Conference on Computer Vision_ , pp. 524–540, 2020.
  * Rebuffi et al. (2017) Sylvestre-Alvise Rebuffi, Alexander Kolesnikov, Georg Sperl, and Christoph H Lampert.  ICARL: Incremental Classifier and Representation Learning.  In _Proceedings of the IEEE conference on Computer Vision and Pattern Recognition_ , pp. 2001–2010, 2017.
  * Sarfraz et al. (2023) Fahad Sarfraz, Elahe Arani, and Bahram Zonooz.  Error Sensitivity Modulation based Experience Replay: Mitigating Abrupt Representation Drift in Continual Learning.  In _Proceedings of the Eleventh International Conference on Learning Representations_ , 2023.
  * Semola et al. (2024) Rudy Semola, Julio Hurtado, Vincenzo Lomonaco, and Davide Bacciu.  Adaptive Hyperparameter Optimization for Continual Learning Scenarios.  _arXiv preprint arXiv:2403.07015_ , 2024.
  * Snoek et al. (2012) Jasper Snoek, Hugo Larochelle, and Ryan P Adams.  Practical Bayesian Optimization of Machine Learning Algorithms.  In _Proceeding of the 26th Conference on the Advances in Neural Information Processing Systems_ , 2012.
  * van de Ven & Tolias (2019) Gido M van de Ven and Andreas S Tolias.  Three Scenarios for Continual Learning.  _arXiv preprint arXiv:1904.07734_ , 2019.
  * Wang et al. (2023) Liyuan Wang, Xingxing Zhang, Hang Su, and Jun Zhu.  A Comprehensive Survey of Continual Learning: Theory, Method and Application.  _arXiv preprint arXiv:2302.00487_ , 2023.
  * Wistuba et al. (2023) Martin Wistuba, Martin Ferianc, Lukas Balles, Cédric Archambeau, and Giovanni Zappella.  Renate: A Library for Real-World Continual Learning.  _arXiv preprint arXiv:2304.12067_ , 2023.
  * Wu et al. (2015) Jiayu Wu, Qixiang Zhang, and Guoxi Xu.  Tiny Imagenet Challenge (cs231n), http://tiny-imagenet.herokuapp.com/.  Technical report, Stanford, 2015.
  * Wu et al. (2022) Tongtong Wu, Massimo Caccia, Zhuang Li, Yuan-Fang Li, Guilin Qi, and Gholamreza Haffari.  Pretrained Language Models in Continual Learning: A Comparative Study.  In _Proceedings of the 10th International Conference on Learning Representations_ , 2022.

##  Appendix A Additional experimental details

While we have aimed to include all the main experimental details in the main
paper there are a few others to mention here. First, we mostly follow the
experimental setup of Buzzega et al. (2020) and Boschini et al. (2022) and use
the Mammoth library produced by those works as the base of our code. Second,
we use as our optimiser SGD with no momentum or weigh decay, as is done in
other works (Aljundi et al., 2019b; Buzzega et al., 2020; Chaudhry et al.,
2019a; Lee & Storkey, 2023). Third, in the heterogeneous tasks setting we look
at tasks sequences where each task in order has the following number of
classes associated with it $[9,2,7,3,4,9,8,3,3,7,4,4,5,9,4,5,2,8,2,2]$ and all
the data of a class is contained in the task associated with it. For Tiny
ImageNet we only use the first 100 classes in the heterogeneous tasks setting
to reduce runtime and to make it more comparable to CIFAR-100 in that setting.
In the heterogeneous tasks setting each task has a variable amount of data.
For example, using CIFAR-100, the first task contains nine classes and so it
will contain in total $4500$ examples ($500$ examples per task) while the
second task contains two classes so will only contain $1000$ examples. Also,
as in each task the learner needs to discriminate between a varying number of
classes the difficultly should vary between tasks. Additionally, in the
heterogeneous tasks setting we only look at class-incremental learning.

We record here the hyperparameter grid that we sample over when performing
HPO. We look at learning rates in the set
$\\{0.2,0.15,0.1,0.075,0.05,0.03,0.01,0.0075,0.005,0.0025\\}$. For DER++, we
perform HPO over both regularisation coefficients where we sample $\alpha$ in
the set $\\{0.2,0.5,1.0\\}$ and $\beta$ in the set $\\{0.2,0.5,1.0\\}$. For
ESMER, we perform HPO over the loss margin coefficient where we sample over
the set $\\{1.5,1.2,1.0\\}$. We sample all possible combinations of learning
rates and regularisation coefficients in each of our HPO frameworks. This grid
contains the ones used in the popular works Buzzega et al. (2020), Boschini et
al. (2022) and Sarfraz et al. (2023), where we add additional learning rate
settings and, for some datasets, regularisation coefficients settings. We note
here that while we use grid search in this paper to align with common practice
in CL (Buzzega et al., 2020; Delange et al., 2021), any hyperparameter
sampling/selecting method can be used with each of the HPO frameworks looked
at. For example, tree-structured Parzen estimators are a common Bayesian HPO
method to sample hyperparameter configurations for neural networks (Bergstra
et al., 2011). Additionally, Gaussian process based HPO methods are also
commonly used (Snoek et al., 2012) and have been looked at in settings related
to online learning (Hellan et al., 2023).

##  Appendix B Experiments using default hyperparameter values

Table 4: Comparison of using default hyperparameters versus using a HPO framework on standard CL benchmarks, where we only present the most common HPO framework (End-of-training HPO) and the most efficient (First-task HPO) for readability. We report mean average accuracies over three runs with their standard errors. The table shows that using default HPs leads to worse performance than using HPO for standard CL benchmarks. |  | CIFAR-10 | CIFAR-100 | TinyImageNet
---|---|---|---|---
CL Method | HPO Framework | Class-IL. | Task-IL. | Class-IL. | Task-IL. | Class-IL. | Task-IL.
ER | End-of-training HPO | $83.55_{\pm 0.44}$ | $97.18_{\pm 0.14}$ | $51.03_{\pm 0.43}$ | $85.68_{\pm 0.29}$ | $28.01_{\pm 0.09}$ | $68.17_{\pm 0.06}$
First-task HPO | $84.38_{\pm 0.45}$ | $96.82_{\pm 0.17}$ | $49.61_{\pm 0.34}$ | $84.97_{\pm 0.19}$ | $28.51_{\pm 0.18}$ | $68.72_{\pm 0.13}$
Default HPs | $74.60_{\pm 0.79}$ | $94.53_{\pm 0.13}$ | $35.39_{\pm 0.36}$ | $72.83_{\pm 0.24}$ | $16.27_{\pm 0.20}$ | $50.99_{\pm 0.41}$
iCaRL | End-of-training HPO | $77.79_{\pm 0.23}$ | $98.52_{\pm 0.03}$ | $54.30_{\pm 0.36}$ | $85.74_{\pm 0.45}$ | $37.09_{\pm 0.27}$ | $70.37_{\pm 0.36}$
First-task HPO | $77.83_{\pm 0.22}$ | $95.31_{\pm 0.12}$ | $52.56_{\pm 0.10}$ | $84.60_{\pm 0.09}$ | $36.42_{\pm 0.22}$ | $70.11_{\pm 0.13}$
Default HPs | $68.34_{\pm 0.49}$ | $92.98_{\pm 0.21}$ | $11.54_{\pm 0.25}$ | $41.66_{\pm 0.54}$ | $5.30_{\pm 0.03}$ | $23.97_{\pm 0.10}$
ER-ACE | End-of-training HPO | $82.34_{\pm 0.30}$ | $96.74_{\pm 0.01}$ | $55.58_{\pm 0.39}$ | $85.73_{\pm 0.09}$ | $38.94_{\pm 0.47}$ | $70.18_{\pm 0.23}$
First-task HPO | $83.20_{\pm 0.79}$ | $96.67_{\pm 0.18}$ | $56.36_{\pm 0.29}$ | $86.11_{\pm 0.154}$ | $36.94_{\pm 0.67}$ | $68.16_{\pm 0.30}$
Default HPs | $75.46_{\pm 0.21}$ | $94.71_{\pm 0.06}$ | $42.65_{\pm 0.57}$ | $76.28_{\pm 0.19}$ | $25.84_{\pm 0.26}$ | $56.25_{\pm 0.13}$
ESMER | End-of-training HPO | $80.73_{\pm 0.15}$ | $96.50_{\pm 0.01}$ | $56.16_{\pm 0.54}$ | $88.69_{\pm 0.35}$ | $47.33_{\pm 0.30}$ | $76.18_{\pm 0.22}$
First-task HPO | $77.89_{\pm 0.46}$ | $96.15_{\pm 0.12}$ | $56.61_{\pm 0.20}$ | $89.05_{\pm 0.10}$ | $46.69_{\pm 0.56}$ | $75.72_{\pm 0.24}$
Default HPs | $68.86_{\pm 1.06}$ | $93.54_{\pm 0.20}$ | $42.94_{\pm 0.61}$ | $79.64_{\pm 0.36}$ | $33.11_{\pm 0.39}$ | $63.15_{\pm 0.17}$
DER++ | End-of-training HPO | $84.40_{\pm 0.94}$ | $95.75_{\pm 0.33}$ | $56.04_{\pm 3.67}$ | $83.13_{\pm 2.69}$ | $39.89_{\pm 0.27}$ | $70.41_{\pm 0.17}$
First-task HPO | $85.22_{\pm 0.08}$ | $96.14_{\pm 0.10}$ | $55.20_{\pm 0.78}$ | $81.68_{\pm 0.66}$ | $35.98_{\pm 0.63}$ | $65.86_{\pm 0.37}$
Default HPs | $77.59_{\pm 0.45}$ | $93.83_{\pm 0.40}$ | $46.11_{\pm 1.16}$ | $78.14_{\pm 1.28}$ | $25.66_{\pm 0.16}$ | $59.14_{\pm 0.51}$
Table 5: Comparison of using default hyperparameters versus using a HPO framework on heterogeneous task benchmarks, where we only present the most common HPO framework (End-of-training HPO) and the most efficient (First-task HPO) for readability. We report mean average accuracies over three runs with their standard errors. The table shows that using default HPs leads to worse performance than using HPO for heterogeneous task benchmarks. |  | Hetero-CIFAR-100 | Hetero-TinyImg
---|---|---|---
CL Method | HPO Framework | Class-IL. | Class-IL.
ER | End-of-training HPO | $50.41_{\pm 0.21}$ | $39.41_{\pm 0.57}$
First-task HPO | $50.33_{\pm 0.50}$ | $40.77_{\pm 0.34}$
Default HPs | $33.76_{\pm 0.78}$ | $26.88_{\pm 0.45}$
iCaRL | End-of-training HPO | $51.54_{\pm 0.38}$ | $37.17_{\pm 0.48}$
First-task HPO | $49.81_{\pm 0.10}$ | $37.47_{\pm 0.26}$
Default HPs | $12.23_{\pm 0.19}$ | $10.6_{\pm 0.26}$
ER-ACE | End-of-training HPO | $51.96_{\pm 0.60}$ | $45.47_{\pm 0.42}$
First-task HPO | $51.37_{\pm 0.16}$ | $43.62_{\pm 1.09}$
Default HPs | $38.11_{\pm 0.80}$ | $32.37_{\pm 0.53}$
ESMER | End-of-training HPO | $50.54_{\pm 0.16}$ | $44.87_{\pm 0.26}$
First-task HPO | $50.43_{\pm 0.34}$ | $45.84_{\pm 0.50}$
Default HPs | $37.92_{\pm 0.30}$ | $34.22_{\pm 0.41}$
DER++ | End-of-training HPO | $54.12_{\pm 0.70}$ | $46.41_{\pm 0.77}$
First-task HPO | $54.87_{\pm 0.39}$ | $43.45_{\pm 3.55}$
Default HPs | $44.43_{\pm 0.51}$ | $30.21_{\pm 1.53}$

To test whether HPO is needed in CL and if instead using default
hyperparameters is sufficient, we perform experiments using default
hyperparameters. The experimental setup is the same as the main paper and we
use for the default learning rate the default given by PyTorch, $0.001$, and
use $1.0$ as the default for regularisation coefficients. The results are
presented in Tables 4 and 5. The tables show that using default
hyperparameters leads to worse performance than using HPO. Additionally, for
some dataset and CL method combinations the default hyperparameters perform
very badly showing the need to adapt hyperparameters to the dataset and CL
method used.


# Integrability and dark states of the XX spin-1 central spin model in a
transverse field

Eric De Nadai111E.D.N and N.M have contributed equally to this work., Nathan
Maestracci∗, Alexandre Faribault  Université de Lorraine, CNRS, LPCT, F-54000
Nancy, France

###### Abstract

It was recently shown that, for central spin-1/2 and central spin-1, the XX
central spin model is integrable in the presence of a magnetic field oriented
perpendicular to the XY plane in which the coupling exists. In the spin-1/2
case, it was also shown, through an appropriate limit of the non-skew
symmetric XXZ Richardson-Gaudin models, that it remained integrable even when
the magnetic field is tilted to contain an in-plane component.

Although the model has not yet been shown to explicitly belong to a known
class of Richardson-Gaudin models, we show, in this work, that the spin-1 case
also remains integrable in a titled magnetic field. We do so by writing
explicitly the complete set of conserved charges, then showing that these
operators obey polynomial relations. It is finally demonstrated numerically
that dark states, for which the central spin is completely unentangled with
the bath, can emerge at strong enough coupling just as they do in the central
spin-1/2 model in an arbitrarily oriented magnetic field.

##  I Introduction

Central spin models describe the interaction of a given specific spin
$\vec{S}_{0}$ with an external magnetic field and a bath of $N$ environmental
spins $\vec{S}_{j}\ \ \forall\ j=1,\dots N$ which do not interact amongst
themselves. They have been widely used to describe the coupling of a qubit
based on the spin of a single trapped carrier loss  with the bath of
environmental spins, coupling which ultimately leads to decoherence and to the
loss of quantum information deco1 ; deco2 ; deco3 . In the XX limit of the
model, which this work is interested in, the couplings to the spins of the
bath are restricted to the XY-plane in which they are isotropic so that the
hamiltonian reads:

$\displaystyle\hat{H}=\vec{B}\cdot\vec{\hat{S}}_{0}+\sum^{N}_{k=1}2g_{k}\left(\hat{S}^{x}_{0}\hat{S}^{x}_{k}+\hat{S}^{y}_{0}\hat{S}^{y}_{k}\right).$
(1)

where the three magnetic field components $B^{\alpha}$ and the various
couplings $g_{k}$ are all arbitrary real numbers. For a magnetic field
oriented along the z-axis, $B^{x}=B^{y}=0$, the model is rotationally
invariant around the z-axis. In this U(1)-symmetric case, it was shownXXdark
that, when the central spin is chosen to be a spin$-\frac{1}{2}$, the model is
integrable and supports dark eigenstates in which the central spin is in the
pure state $\left|\uparrow_{0}\right>$ or $\left|\downarrow_{0}\right>$, i.e.
the eigenstates of the $\hat{S}_{0}^{z}$ operator. The resulting tensor
product eigenstates
$\left|\uparrow_{0}\right>\otimes\left|\phi_{\mathrm{bath}}\right>$ (or
$\left|\downarrow_{0}\right>\otimes\left|\phi_{\mathrm{bath}}\right>$)
therefore have absolutely no entanglement between the central spin and the
bath whose various possible states $\left|\phi_{\mathrm{bath}}\right>$ can be
found through solutions of a set of Bethe equations XXdark ; XXBethe . Dark
states (and dark subspaces of the Hilbert space) can be remarkably desirable
since they could provide protected long lived quantum states control0 ;
control1 ; control2  in nitrogen-vacancy centers in diamond laraouinv ;
dobrovnv ; hallnv  or in semiconductor quantum dots ramsaysemi ; hansonsemi ;
schliemannsemi  for example.

Building on the U(1)-symmetric caseXXdark , it was shown that dark states can
be stable against integrability breaking perturbations XXperturb . It was then
also demonstrated that, for central spin$-\frac{1}{2}$ the XX-model remains
integrable when the applied magnetic field points in an arbitrary direction
dimodark  therefore breaking U(1)-symmetry. The proof is simple since it only
relies on taking the appropriate limit $\epsilon_{0}\to-j_{z}$ (with
$j_{x}=j_{y}$) of the non-skew symmetric elliptic Richardson-Gaudin (R-G)
models defined by the set of $N+1$ commuting conserved charges:

$\displaystyle\hat{R}_{j}=\vec{B}_{j}\cdot\vec{\hat{S}}_{j}+\sum_{\alpha\in\left\\{x,y,z\right\\}}\left(\sum_{i=0(\neq
j)}^{N}\Gamma^{\alpha}_{i,j}\hat{S}^{\alpha}_{i}\hat{S}^{\alpha}_{j}+\Gamma^{\alpha}_{j,j}\hat{S}^{\alpha}_{j}\hat{S}^{\alpha}_{j}\right).$
(2)

Their mutual commutation and the resulting integrability of the model requires
that the various terms be parametrised as skrypnykquad :

$\displaystyle B^{\alpha}_{j}$ $\displaystyle=$
$\displaystyle\frac{B_{\alpha}}{\sqrt{\epsilon_{j}+j_{\alpha}}}$
$\displaystyle\Gamma^{\alpha}_{i,j}$ $\displaystyle=$
$\displaystyle\frac{\sqrt{\epsilon_{j}+j_{\alpha}}\sqrt{\epsilon_{i}+j_{\beta}}\sqrt{\epsilon_{i}+j_{\gamma}}}{\epsilon_{i}-\epsilon_{j}}$
$\displaystyle\Gamma^{\alpha}_{j,j}$ $\displaystyle=$
$\displaystyle\frac{(\epsilon_{j}+j_{\alpha})(2\epsilon_{j}+j_{\beta}+j_{\gamma})-(\epsilon_{j}+j_{\beta})(\epsilon_{j}+j_{\gamma})}{\sqrt{\epsilon_{j}+j_{\alpha}}\sqrt{\epsilon_{j}+j_{\beta}}\sqrt{\epsilon_{j}+j_{\gamma}}}$
(3)

where $\gamma\neq\beta\neq\alpha$ form the three distinct direction indices,
while $B_{\alpha}$, $j_{\alpha}$ and $\epsilon_{k}$ ($\forall k=0,1\dots N)$
are $N+7$ arbitrary free parameters chosen real to insure hermiticity.
Restricting oneself to the XXZ case ($j_{x}=j_{y}$) and taking the limit
$j_{z}\to-\epsilon_{0}$ (while keeping $B^{z}_{0}$ finite through a diverging
$B_{z}$ ), the resulting conserved charge $R_{0}$ does become the XX-
hamiltonian (1). However, it exclusively does so for a spin$-\frac{1}{2}$
realisation of the central spin. Indeed, when $S_{0}=\frac{1}{2}$, the "self-
coupling terms" $\propto S^{\alpha}_{0}S^{\alpha}_{0}$ present in $R_{0}$
reduces to a constant which can simply be ignored by shifting the zero-energy
point. However, for any higher spin representation this term remains non-
trivial and does not vanish when performing the same limit. For higher spins,
the desired XX model (1) can simply not be obtained as a limit of an elliptic
model (2), due to the presence of this additional "self-coupling" term.

Nonetheless, by constructing the commuting conserved charges and, via a Bethe
Ansatz, the explicit eigenstates it was recently shown xxspin1  that the U(1)
symmetric XX central spin model :

$\displaystyle\hat{H}=B^{z}_{0}\hat{S}^{z}_{0}+\sum^{N-1}_{k=1}2g_{k}\left(\hat{S}^{x}_{0}\hat{S}^{x}_{k}+\hat{S}^{y}_{0}\hat{S}^{y}_{k}\right)$
(4)

is actually integrable when the central spin is a spin-$1$. The spin$-1$ model
also supports, for arbitrary coupling strengths, dark states such that the
central spin is in either its lowest or highest weight state of the spin$-1$
representation $\left|S_{0}=1,m_{z}=\pm 1\right>$ having maximal or minimal
eigenvalues $\pm 1$ of the $\hat{S}^{z}_{0}$ operator.

Since the spin$-1$ model has not currently been shown to directly belong to a
known class of R-G models, the question of whether it stays integrable or not
in the presence of an in-plane magnetic field is worth investigating. Not only
is that question relevant by itself, it can also circumscribe the candidates
in the search for an explicit connection to R-G models. Indeed, it is known
that most XXZ R-G models are exclusively integrable in the presence of a
z-oriented magnetic field, and only those which correspond to limits of the
non-skew symmetric elliptic model support an in-plane component skrypnyk .

In this work, we first construct, in the next section, the conserved charges
of the central spin$-1$ model in an arbitrarily oriented magnetic field,
therefore proving its integrability. In the following section, polynomial
relations between the conserved charges are built. In section IV, we then
demonstrate numerically that, in the spin$-1$ case, dark states reemerge at
strong coupling just as they do for central spin$-\frac{1}{2}$.

##  II Conserved charges

In order to construct conserved charges which commute with one another and
with the hamiltonian (1), we first choose to write it in terms of spin
raising/lowering operators as:

$\displaystyle\hat{H}$ $\displaystyle=$
$\displaystyle\vec{B}\cdot\vec{\hat{S}}_{0}+\sum^{N}_{k=1}g_{k}\left(\hat{S}^{+}_{0}\hat{S}^{-}_{k}+\hat{S}^{-}_{0}\hat{S}^{+}_{k}\right)$
(5) $\displaystyle=$
$\displaystyle\vec{B}\cdot\vec{\hat{S}}_{0}+\left(\hat{S}^{+}_{0}\hat{G}^{-}+\hat{S}^{-}_{0}\hat{G}^{+}\right),$

using the pair of hermitian conjugate operators:

$\displaystyle\hat{G}^{-}\equiv\sum^{N}_{k=1}g_{k}\hat{S}^{-}_{k}\ \ \ \ \
\hat{G}^{+}\equiv\sum^{N}_{k=1}g_{k}\hat{S}^{+}_{k}.$ (6)

Using the explicit $3\times 3$ matrix representation, using the central spin’s
canonical basis of the three eigenstates of the $\hat{S}^{z}_{0}$ operator:
$\left|S=1,m_{z}=1\right>,\left|S=1,m_{z}=0\right>\left|S=1,m_{z}=-1\right>$
which was also used in xxspin1 , one can write it conveniently as:

$\displaystyle\hat{H}=\left(\begin{array}[]{ccc}B_{z}&\sqrt{2}\hat{\mathcal{G}}^{-}&0\\\
\sqrt{2}\hat{\mathcal{G}}^{+}&0&\sqrt{2}\hat{\mathcal{G}}^{-}\\\
0&\sqrt{2}\hat{\mathcal{G}}^{+}&-B_{z}\end{array}\right).$ (10) (11)

where we defined:

$\displaystyle\hat{\mathcal{G}}^{-}$ $\displaystyle\equiv$
$\displaystyle\hat{G}^{-}+\frac{B_{x}-iB_{y}}{2}$
$\displaystyle\hat{\mathcal{G}}^{+}$ $\displaystyle\equiv$
$\displaystyle\hat{G}^{+}+\frac{B_{x}+iB_{y}}{2}.$ (12)

Using the same $3\times 3$ representation, one can build the following $N$
operators $\hat{R}_{j}\ \ \ \forall j=1,2\dots N$:

$\displaystyle\hat{R}_{j}=\left(\begin{array}[]{ccc}B_{z}\left(\hat{\mathcal{Q}}_{j}-\hat{S}_{j}^{z}\right)&\sqrt{2}\hat{\mathcal{G}}^{-}\hat{\mathcal{Q}}_{j}&0\\\
\sqrt{2}\hat{\mathcal{Q}}_{j}\hat{\mathcal{G}}^{+}&B_{z}\hat{S}_{j}^{z}&\sqrt{2}\hat{\mathcal{Q}}_{j}\hat{\mathcal{G}}^{-}\\\
0&\sqrt{2}\hat{\mathcal{G}}^{+}\hat{\mathcal{Q}}_{j}&-B_{z}\left(\hat{\mathcal{Q}}_{j}+\hat{S}_{j}^{z}\right)\end{array}\right).$
(16) (17)

where:

$\displaystyle\hat{\mathcal{Q}}_{j}$ $\displaystyle\equiv$
$\displaystyle\hat{Q}_{j}+\frac{B_{x}\hat{S}^{x}_{j}+B_{y}\hat{S}^{y}_{j}}{g_{j}}$
(18)

and

$\displaystyle\hat{Q}_{j}=\frac{\hat{S}^{+}_{j}\hat{S}^{-}_{j}+\hat{S}^{-}_{j}\hat{S}^{+}_{j}}{2}$
$\displaystyle+\sum_{k=1(\neq
j)}^{N}\left[\frac{g_{j}g_{k}}{g_{j}^{2}-g_{k}^{2}}\left(\hat{S}^{+}_{j}\hat{S}^{-}_{k}+\hat{S}^{-}_{j}\hat{S}^{+}_{k}\right)+\frac{2g_{k}}{g_{j}^{2}-g_{k}^{2}}\hat{S}^{z}_{j}\hat{S}^{z}_{k}\right].$

The operators (17) precisely correspond to the form of the conserved charges
found without an in-plane field xxspin1 , but modified by the substitutions
$\hat{Q}_{j}\to\hat{\mathcal{Q}}_{j}$ and
$\hat{G}^{\pm}\to\hat{\mathcal{G}}^{\pm}$. In order to compute the required
commutators, one can first show, using the factlukya  that
$[\hat{Q}_{i},\hat{Q}_{j}]=0$, that
$[\hat{\mathcal{Q}}_{i},\hat{\mathcal{Q}}_{j}]=0$ commute with one another.
One can then prove that the relation
$\left[\hat{\mathcal{G}}^{\pm},\hat{Q}_{j}\right]=\pm\left\\{\hat{S}^{z}_{j},\hat{\mathcal{G}}^{\pm}\right\\}\pm\left(B_{x}\pm
iB_{y}\right)\ \hat{S}^{z}_{j}$ holds. It is then relatively straightforward,
but tedious, to show that the conserved charges all commute with the
Hamiltoninan $\left[\hat{R}_{j},\hat{H}\right]=0$. Showing that they also
commute with one another $\left[\hat{R}_{j},\hat{R}_{k}\right]=0$ is also
easily achieved through direct calculation.

These operators therefore form a set of conserved charges whose existence are
sufficient mossel  to conclude that the XX spin-1 central spin model remains
integrable in the presence of an arbitrarily oriented magnetic field. This can
certainly have an important impact on the way the model could relate to known
classes of R-G models since, as mentioned in the introduction, only a limited
class of models remain integrable in the presence of transverse magnetic field
components.

##  III Polynomial relations

The set of conserved charges (17) proposed in this work and the hamiltonian
(11), also obey a set of $N+1$ polynomial equations relating the various
operators. The construction is similar to the quadratic equations one finds
for the typical R-G systems built out of only spin-$\frac{1}{2}$ realisations
dimoquad ; skrypnykquad . However for a central spin$-1$, one finds the cubic
relation:

$\displaystyle\hat{H}^{3}=\sum_{j=1}^{N}4g_{j}^{2}\hat{R}_{j}+\left|B\right|^{2}\hat{H}.$
(20)

Once again it can be proven, by direct calculation using the $3\times 3$
matrix representation specific to the central spin$-1$ problem. A useful
intermediate result for this proof is to first show that
$\left(\hat{\mathcal{G}}^{+}\hat{\mathcal{G}}^{-}+\hat{\mathcal{G}}^{-}\hat{\mathcal{G}}^{+}\right)-\frac{(B_{0}^{x})^{2}+(B_{0}^{y})^{2}}{2}\hat{\mathbb{1}}=2\displaystyle\sum_{i=1}^{N}g_{i}^{2}\hat{\mathcal{Q}}_{i}$.
As was the case for the conserved charges, the proof of this cubic relation
(20) relies exclusively on the $SU(2)$ commutation relations
$\left[\hat{S}^{\alpha}_{j},\hat{S}^{\beta}_{k}\right]=i\delta_{jk}\epsilon_{\alpha,\beta,\gamma}\hat{S}^{\gamma}_{j}$
for the bath spins. It, therefore, is valid for arbitrary representations of
the various environmental spins (i.e. be they, individually,
spin$-\frac{1}{2},\ -1,\ -\frac{3}{2},\dots$).

In order to form a complete set of $N+1$ polynomial relations, we now choose,
for simplicity, the bath spins to all be spins-$\frac{1}{2}$. In doing so the
$N$ remaining polynomial relations are simply quadratic and are explicitly
given by:

$\displaystyle\hat{R}_{j}^{2}=\frac{B_{z}^{2}}{4}\hat{\mathbb{1}}+\hat{H}\hat{R}_{j}+\sum_{k\neq
j}^{N}\left(\frac{g_{k}^{2}}{g_{j}^{2}-g_{k}^{2}}\right)\hat{H}\hat{R}_{k}$
$\displaystyle\ \ \
-\left(\frac{1}{4}-\frac{B_{x}^{2}+B_{y}^{2}}{4g_{j}^{2}}-\sum_{k\neq
j}^{N}\left[\frac{3}{4}\frac{g_{k}^{4}}{\left(g_{j}^{2}-g_{k}^{2}\right)^{2}}\right]\right)\hat{H}^{2},$

once again a result which is provable by direct calculation of the square and
product of the involved operators. To do so one can first compute the square
of the $\hat{\mathcal{Q}}_{i}$ operator and use the specificities of
spin$-\frac{1}{2}$ Pauli matrices (such as $\left(S^{\pm}\right)^{2}=0$) to
prove the equality.

Polynomial relations between conserved operators have formed the basis of the
so-called eigenvalue-based approach to R-G models. Here, one can expect, as it
is the case with the usual R-G models, to be able to write $R_{j}^{2S_{j}+1}$
in terms of lower/equal powers of the other conserved charges: a cubic
relation for spin-$1$, a quartic one for spin-$\frac{3}{2}$, etc. In linkstalk
one can find an explicit example for the XXX spin-1 model, while for higher-
spin XXX models one can infer such relations using known results for
polynomial constructions linking eigenvalues and their derivatives araby .
However, only the specific case of a bath of spins-$\frac{1}{2}$, shown in the
previous equation, will be explicitly constructed in this work.

Since all these operators are diagonal in the basis formed by their common
eigenstates:

$\displaystyle\hat{H}\left|\psi_{n}\right>=E^{n}_{0}\left|\psi_{n}\right>\ \ \
\ \ \hat{R}_{j}\left|\psi_{n}\right>=E^{n}_{j}\left|\psi_{n}\right>,$ (22)

the same polynomial relations are also valid for the set of eigenvalues
associated to any eigenstate $\left|\psi_{n}\right>$:

$\displaystyle\left(E^{n}_{0}\right)^{3}=\sum_{j=1}^{N}4g_{j}^{2}E^{n}_{j}+\left|B\right|^{2}E^{n}_{0}$
$\displaystyle\left(E^{n}_{j}\right)^{2}=\frac{B_{z}^{2}}{4}+E^{n}_{0}E^{n}_{j}+\sum_{k\neq
j}^{N}\left(\frac{g_{k}^{2}}{g_{j}^{2}-g_{k}^{2}}\right)E^{n}_{0}E^{n}_{k}$
$\displaystyle\ \ \
-\left(\frac{1}{4}-\frac{B_{x}^{2}+B_{y}^{2}}{4g_{j}^{2}}-\sum_{k\neq
j}^{N}\left[\frac{3}{4}\frac{g_{k}^{4}}{\left(g_{j}^{2}-g_{k}^{2}\right)^{2}}\right]\right)\left(E^{n}_{0}\right)^{2}.$
(23)

One can therefore circumvent the Bethe Ansatz and avoid looking for rapidities
(Bethe roots) which are solution to Bethe equations. One can instead, find the
solutions to the previous polynomial equations directly giving the eigenvalues
$(E^{n}_{0},E^{n}_{1},E^{n}_{2}\dots E^{n}_{N})$ associated to any given
eigenstate $\left|\psi_{n}\right>$. In many R-G models, it then becomes
possible to build determinants expressions which can give access to scalar
products and matrix elements of various local operators directly in terms of
these eigenvalues faridet ; claeysdet ; claeysdet2 ; johnsondet . However, in
the specific case at hand we will simply use the Hellmann-Feynman theorem in
order to study, in the next section, the physical properties of the central
spin, in various eigenstates, as a function of the intensity of the coupling.

##  IV Dark states

As mentioned in the introduction, the existence of dark states is a defining
feature of both the spin-$\frac{1}{2}$ model XXdark  and the spin-$1$
modelxxspin1  in the $U(1)$ symmetric case, i.e.: with a z-oriented magnetic
field. In both cases it was shown that there exists a class of eigenstates,
for which the central spin is in a pure state completely unentangled with the
bath. In both cases, they occur for a central spin in either of the highest or
lowest weight state of the representation, namely
$\left|S_{0}=\frac{1}{2},m_{z}=\pm\frac{1}{2}\right>$ or
$\left|S_{0}=1,m_{z}=\pm 1\right>$. These dark states exist for arbitrary
couplings and stay unentangled when the overall coupling strength is raised or
lowered. One can easily get an intuitive physical picture justifying the
existence of such states:

$\displaystyle\left|\psi_{\mathrm{dark}}\right>=\left|S_{0},m_{z}=\pm
S_{0}\right>\otimes\left|\psi_{\mathrm{bath}}\right>.$ (24)

In the highest and lowest weight states, the central spin is perfectly aligned
with the $z$ axis and therefore with the magnetic field making it an
eigenstate of the magnetic part of the hamiltonian $B_{0}^{z}\hat{S}^{z}_{0}$.
Considering that the coupling term only involves the XY components of the
central spin, it then seems perfectly reasonable that a z-axis aligned central
spin can stay completely unentangled with the bath since it points in a
direction along which it does not couple to the bath at all.

In light of this simple picture, it is somehow surprising that, in the central
spin-$\frac{1}{2}$ case it was shown that dark states can also emergedimodark
. However, they do so through the reorganisation of the bath spins, and appear
exclusively when the overall coupling strength becomes strong enough dimodark
. The strong coupling emergence of dark states was understood as the result of
the Overhauser effective magnetic field due to the bath:
$\sum_{j=1}^{N}g_{j}\left<\vec{S}_{j}\right>$, exactly cancelling the external
in-plane magnetic field components and effectively bringing the problem back
to the U(1) symmetric case. Since the resulting effective field is
proportional to the overall coupling strength, this cancellation does require
a strong enough coupling to occur.

For spin-$\frac{1}{2}$ the question of whether the central spin is in a pure
state or not was easily addressed. Since the condition
$\left<S^{z}_{0}\right>^{2}+\left<S^{y}_{0}\right>^{2}+\left<S^{x}_{0}\right>^{2}=\frac{1}{4}$
is equivalent to having the reduced density matrix of the central spin
$\rho_{0}=\frac{1}{2}+\vec{n}\cdot\vec{\sigma}$ defined by a vector $\vec{n}$
with norm $1$ and therefore on the surface of the Bloch sphere, it is
completely sufficient to signal a pure state. Any mixed state would be
represented by a vector of smaller norm, lying inside the Bloch sphere, and
characterised by
$\left<S^{z}_{0}\right>^{2}+\left<S^{y}_{0}\right>^{2}+\left<S^{x}_{0}\right>^{2}<\frac{1}{4}$
. The generalisation to spin-$1$ is much more complicated since a general
density matrix is then defined by the Gell-Mann matrices and an 8-dimensional
vector for which two conditions have to be met to define a pure state (one on
the norm and one on the so-called star product) blochspin1 . In this work, a
complete verification of whether a given eigenstate is on, or close to, the
generalized Bloch sphere is therefore a much more complicated task. It would,
at least, require an explicit construction of the eigenstates using a Bethe
Ansatz which, for the time being, has not yet been built for the specific
problem of the XX model in a generic magnetic field. Nonetheless, considering
the way spin-$\frac{1}{2}$ dark states emerged at strong coupling with an in-
plane field, one can here simply look at the average of the $S^{z}_{0}$
component. If its average is $\pm 1$, the state of the central spin will then
assuredly be the pure state $\left|S=1,m=\pm 1\right>$ insuring that it has no
entanglement with the bath. Indeed, for any state where the reduced density
matrix of the central spin is in a mixed state, the expectation value
$\left<S^{z}_{0}\right>$ will have a norm which is lower that 1. Evidently, it
would still be possible for the central spin to be in a pure state without
having $\left<S^{z}_{0}\right>=\pm 1$ but metting this condition is sufficient
to show that the central spin is in a pure state and that therefore the system
is in an unentangled dark state.

Computing $\left<S^{z}_{0}\right>$ numerically is very simple for any
eigenstate of the system since one will use the system of polynomial equations
(23) to explicitely find one (or many) solution giving the ensemble of
$E^{n}_{j}$ eigenvalues which define a particular eigenstate. The derivatives
of the polynomial system, with respect to any parameter, provides a set of
linear equations, for the derivatives of the eigenvalues, whose coefficients
are known when the ensemble of eigenvalues is known. Through the Hellmann-
Feynman theorem, these derivatives can be directly related to quantum
expectation values of operators in that particular eigenstate. In the case at
hand:

$\displaystyle\left<\psi_{n}\right|\hat{S}^{z}_{0}\left|\psi_{n}\right>=\left<\psi_{n}\right|\frac{\partial\hat{H}}{\partial
B_{z}}\left|\psi_{n}\right>=\frac{\partial E^{n}_{0}}{\partial B_{z}}.$ (25)

which, using the compact notation $E^{\prime n}_{j}\equiv\frac{\partial
E^{n}_{j}}{\partial B_{z}}$, can be computed by solving the linear system
found by deriving (23) with respect to $B_{z}$:

$\displaystyle 3\left(E^{n}_{0}\right)^{2}E^{\prime
n}_{0}=\sum_{j=1}^{N}4g_{j}^{2}E^{\prime n}_{j}+\left|B\right|^{2}E^{\prime
n}_{0}+2B_{z}E^{n}_{0}$ $\displaystyle 2\left(E^{n}_{j}\right)E^{\prime
n}_{j}=\frac{B_{z}}{2}+E^{\prime n}_{0}E^{n}_{j}+E^{n}_{0}E^{\prime n}_{j}$
$\displaystyle\ +\sum_{k\neq
j}^{N}\left(\frac{g_{k}^{2}}{g_{j}^{2}-g_{k}^{2}}\right)\left(E^{\prime
n}_{0}E^{n}_{k}+E^{n}_{0}E^{\prime n}_{k}\right)$ $\displaystyle\
-2E^{n}_{0}E^{\prime
n}_{0}\left(\frac{1}{4}-\frac{B_{x}^{2}+B_{y}^{2}}{4g_{j}^{2}}-\sum_{k\neq
j}^{N}\left[\frac{3}{4}\frac{g_{k}^{4}}{\left(g_{j}^{2}-g_{k}^{2}\right)^{2}}\right]\right).$
(26)

In a way which has become standard practice araby ; solver ; dimoclaeys ;
johnson , we will find individual solutions, one by one, by deforming one of
the known solutions at zero-coupling. Defining $g_{k}=g\epsilon_{k}$, $g$ will
be varied continuously from zero to the large coupling limit. In the non-
interacting limit $g\to 0$ the first equation of (23) reduces to:

$\displaystyle\left(E^{n}_{0}\right)^{3}=\left|B\right|^{2}E^{n}_{0}$ (27)

and therefore to three, massively degenerate, eigenvalues:

$\displaystyle E^{n}_{0}(g=0)$ $\displaystyle\in$
$\displaystyle\\{-\left|B\right|,0,\left|B\right|\\}.$ (28)

In the two cases, where $E^{n}_{0}\neq 0$, the other equations of (23) reduce
to:

$\displaystyle\left(gE^{n}_{j}\right)^{2}=\frac{B_{x}^{2}+B_{y}^{2}}{4\epsilon_{j}}\left(E^{n}_{0}\right)^{2}.$

leading to the set of $g=0$ solutions given by

$\displaystyle E^{n}_{0}(g=0)$ $\displaystyle=$
$\displaystyle\pm\left|B\right|\ ;\
\tilde{E}^{n}_{j}(g=0)=\pm\frac{\sqrt{B_{x}^{2}+B_{y}^{2}}}{2\epsilon_{j}}\left|B\right|$

with $\tilde{E}^{n}_{j}\equiv gE^{n}_{j}$. The remaining solutions are found
for $E^{n}_{0}(g=0)=0$ and, since one can easily show that $E^{n}_{0}(g\to
0)\propto g^{2}$, the last equations simply become
$E^{n}_{j}(g=0)=\frac{B_{z}^{2}}{4}$. We therefore have:

$\displaystyle E^{n}_{0}(g=0)$ $\displaystyle=$ $\displaystyle 0\ ;\
E^{n}_{j}(g=0)=\pm\frac{B_{z}}{2},$ (31)

which completes the list of possible $g=0$ solutions. Starting from any of
these solutions, one can then simply use the Newton-Raphson method to solve
the system at a small finite $\delta g$ using the $g=0$ as the starting point
of the iterative process. Repeating the process by using the solution at the
current $g$, or a better approximation built using the Taylor series araby ;
solver , as the starting point for solving at $g+\delta g$ ultimately allows
one to deform any $g=0$ solution into one unique solution over a chosen range
of coupling intensities.

In Fig. 1, we plot the expectation of $S^{z}_{0}$ for the complete set of
eigenstates of a small $N=3$ system, as a function of the overall coupling
strength $g$, after renormalising it to
$\displaystyle\tilde{g}=\frac{\sum_{k=1}^{N}g\epsilon_{k}}{\left|B\right|}$.

Figure 1: Central spin’s z-projection expectation value as a function of the
renormalised coupling
$\displaystyle\tilde{g}=\frac{\sum_{k=1}^{N}g\epsilon_{k}}{\left|B\right|}$
for the full Hilbert space with $N=3$ bath spins. The parameters are chosen as
$\epsilon_{k}=k$. The orientation of the field is chosen so that
$B_{x}=2B_{z}$.

It is clear that a fraction of the states ( 6 out the 24 states in this
specific case) become, at strong enough coupling, dark states. Indeed, the two
set of 3 states for which the central spins is either pointing "fully up" or
"fully down" ($\left<S^{z}_{0}\right>=\pm 1$) along the z axis are unavoidably
such that the central spin is the pure state: $\left|S=1,m_{z}=\pm 1\right>$.
It is essential to notice that the renormalised coupling at which the
entanglement disappear is such that the total coupling and magnetic field are
of the same order of magnitude. It therefore occurs far from the point at
which the coupling would be sufficiently strong to completely neglect the
external magnetic field. This indicates that, as was the case for a central
spin$-\frac{1}{2}$, it is the effective magnetic field created by the
arrangement of the bath spins which allows dark states to reemerge at such
coupling strengths where $\frac{1}{|B|}$ is completely non-perturbative.

Going to a larger system of $N=20$ bath spins, we choose to look at one
specific eigenstate which results from the deformation of the $g=0$
configuration with $E_{0}=-\left|B\right|$,
$E_{i}=-\frac{\sqrt{B_{x}^{2}+B_{y}^{2}}}{2\epsilon_{j}}\left|B\right|$ for
$i=1,3,6,8$ and
$+\frac{\sqrt{B_{x}^{2}+B_{y}^{2}}}{2\epsilon_{j}}\left|B\right|$ for the
remaining values of $i$. Changing the orientation of the field through an
azimuthal tilt, i.e. $B_{z}=|B|\cos(\alpha)$ (XY-plane component given by
$|B|\sin(\alpha)$) leads to figure 2 when plotting the expectation value of
the central spin as a function of the renormalised coupling.

Figure 2: Central spin’s z-projection expectation value as a function of the
renormalised coupling
$\tilde{g}=\frac{\sum_{k=1}^{N}g\epsilon_{k}}{\left|B\right|}$ for a specific
dark state with different angles $\cos{\alpha}=\frac{B_{z}}{\left|B\right|}$.
The results are for $N=20$ bath spins and the parameters are chosen as
$\epsilon_{k}=k$

These plots first demonstrates that the presence of dark states in the strong
coupling limit was not due to the tiny system size presented before since the
dark state feature is clearly seen emerging at strong coupling again in this
larger system. Moreover, these results make it clear that it is not the
magnitude of the magnetic field, but exclusively the magnitude of its in-plane
component which controls the coupling strength necessary for the dark state to
reemerge. The result is completely consistent with the mechanism which was at
play for central spin$-\frac{1}{2}$. Despite the fact that we are not in a
position to explicitly compute the expectation values of the various bath
spins to confirm it explicitly, the observed behaviour of the central spin
strongly support the hypothesis that similar physics is at play. Indeed the
whole phenomenology observed here is precisely the same as what was seen in
the spin$-\frac{1}{2}$ case: the system reproduces the U(1)-symmetric dark
states, does so exclusively when the coupling gets strong enough and the
required coupling strength is controlled by the value of the in-plane magnetic
field component which has to be cancelled to restore an effective
U(1)-symmetry.

##  V Conclusion

In this work, we have shown that the integrability of the XX central spin-1
model, is maintained in the presence of an arbitrarily oriented magnetic field
which breaks the rotational U(1)-symmetry around the z axis.

The set of commuting conserved charges and the hamiltonian have been shown to
obey polynomial equations, computed here when the bath spins are all
spin$-\frac{1}{2}$, which can be used in order to numerically access physical
properties of its eigenstates. Doing so, we have explicitly shown that dark
states, for which the central spin is completely unentangled with the bath do
exist in this system. However, they only emerge, as was the case when the
central spin is spin$-\frac{1}{2}$, when the coupling is strong enough.

It remains to be seen explicitly if the integrability of the central spin
model is true irrespective of the central spin’s realisation. This work seems
to suggest that if it exists, the connection to a R-G-like construction could
be made the models which are not U(1)-symmetric. Being able to make such a
connection could allow proofs purely based on algebraic considerations which,
being independent of the realisation, would generalise to arbitrary central-
spins.

## References

  * (1) D. Loss and D. P. DiVincenzo, Phys. Rev. A 57, 120 (1998)
  * (2) C. P. Koch , J. Phys.: Condens. Matter 28, 213001 (2016)
  * (3) W. Zhang, N. Konstantinidis, K. Al-Hassanieh, and V. Dobrovitski, J. Phys.: Condens. Matter 19, 083202 (2007)
  * (4) D. A. Lidar, Adv. Chem. Phys 154, 295 (2014)
  * (5) T. Villazon, A. Chandran and P. W. Claeys, Phys. Rev. Research 2, 032052 (2020)
  * (6) N. Wu, X.-W. Guan and J. Links, Phys. Rev. B 101, 155145 (2020)
  * (7) E. Kirstein, D. S. Smirnov, E. A. Zhukov, D. R. Yakovlev, N. E. Kopteva, D. N. Dirin, O. Hordiichuk, M. V. Kovalenko and M. Bayer, Nature Comm. 14, 6683 (2023)
  * (8) J. M. Taylor, A. Imamoglu, and M. D. Lukin, Phys. Rev. Lett. 91, 246802 (2003)
  * (9) Z. Kurucz, M. W. Sørensen, J. M. Taylor, M. D. Lukin, and M. Fleischhauer, Phys. Rev. Lett. 103, 010502 (2009)
  * (10) A. Laraoui, J. S. Hodges, C. A. Ryan, and C. A. Meriles, Phys. Rev. B 84, 104301 (2011)
  * (11) V. Dobrovitski, G. Fuchs, A. Falk, C. Santori, and D. Awschalom, Annu. Rev. Condens. Matter Phys. 4, 23 (2013)
  * (12) L. T. Hall, J. H. Cole, and L. C. Hollenberg, Phys. Rev. B 90, 075201 (2014)
  * (13) A. Ramsay, Semicond. Sci. Technol. 25, 103001 (2010)
  * (14) R. Hanson, L. P. Kouwenhoven, J. R. Petta, S. Tarucha, and L. M. Vandersypen, Rev. Mod. Phys. 79, 1217 (2007)
  * (15) J. Schliemann, A. Khaetskii, and D. Loss, J. Phys. Condens. Matter 15, R1809 (2003)
  * (16) T. Villazon, P. W. Claeys, M. Pandey, A. Polkovnikov and A. Chandran, Sci. Rep. 10, 16080 (2020)
  * (17) C. Dimo and A. Faribault, Phys. Rev. B 105, L121404 (2022)
  * (18) T. Skrypnyk, Nucl. Phys. B 941, 225 (2019)
  * (19) L.-H. Tang, D.M. Long, A. Polkovnikov, A. Chandran and P. W. Claeys, SciPost Phys. 15, 030 (2023)
  * (20) T. Skrypnyk, Nucl. Phys. B 856, 552 (2012)
  * (21) I. Lukyanenko, P. S. Isaac and J. Links, J. Phys. A: Math. Theor. 49, 084001 (2016)
  * (22) J.-S. Caux, J. Mossel, J. Stat. Mech., P02023 (2011)
  * (23) C. Dimo and A. Faribault, J. Phys. A: Math. Theor. 51, 325202 (2018)
  * (24) J. Links, Talk given at: Integrability in low-dimensional quantum systems, Creswick, Australia ( 2017)
Online: www.matrix-inst.org.au/wp_Matrix2016/wp-
content/uploads/2016/04/LinksTalk.pdf

  * (25) O. El Araby, V. Gritsev, and A. Faribault Phys. Rev. B 85, 115130 (2012)
  * (26) A. Faribault and H. Tschirhart, SciPost Physics 3, 009 (2017)
  * (27) P. W. Claeys, S. De Baerdemacker, M. Van Raemdonck and D. Van Neck, Phys. Rev. B 91, 155102 (2015)
  * (28) P.W . Claeys, S. De Baerdemacker, M. Van Raemdonck and D. Van Neck J. of Physics A: Mathematical and Theoretical 48 , 425201 (2015)
  * (29) A. Faribault, C. Dimo, J.-D. Moisset and P. A. Johnson, J Chem. Phys. 157 (2022)
  * (30) S. K. Goyal, B. N. Simon, R. Singh and S. Simon, J. Phys. A: Math. Theor. 49 165203 (2016)
  * (31) C.-É. Fecteau, S. Cloutier, J.-D. Moisset, J. Boulay, P. Bultinck, A. Faribault and P. A. Johnson, J. Chem. Phys. 156, 194103 (2022)
  * (32) A. Faribault, O. El Araby, C. Sträter, and V. Gritsev, Phys. Rev. B 83, 235124 (2011)
  * (33) P. W. Claeys, C. Dimo, S. De Baerdemacker and A. Faribault, J. Phys. A: Math. Theor. 52, 08LT01 (2019)