Upload folder using huggingface_hub (part 40)

parse/dev/uuUQraD4XX/uuUQraD4XX.md

@@ -0,0 +1,461 @@
+# Large Language Models Can Self-Improve
+
+Jiaxin Huang1∗ Shixiang Shane $\mathbf { G u ^ { 2 } }$ Le $\mathbf { H o u } ^ { 2 \dagger }$ Yuexin $\mathbf { W } \mathbf { u } ^ { 2 }$ Xuezhi Wang2 Hongkun $\mathbf { Y } \mathbf { u } ^ { 2 }$ Jiawei Han1
+
+1University of Illinois at Urbana-Champaign 2Google 1{jiaxinh3, hanj}@illinois.edu 2{shanegu, lehou, crickwu, xuezhiw, hongkuny}@google.com
+
+# Abstract
+
+Large Language Models (LLMs) have achieved excellent performances in various tasks. However, fine-tuning an LLM requires extensive supervision. Human, on the other hand, may improve their reasoning abilities by self-thinking without external inputs. In this work, we demonstrate that an LLM is also capable of self-improving with only unlabeled datasets. We use a pre-trained LLM to generate “highconfidence” rationale-augmented answers for unlabeled questions using Chain-of-Though (CoT) prompting and self-consistency, and finetune the LLM using those self-generated solutions as target outputs. We show that without any ground truth label, our approach significantly improves the general reasoning ability of PaLM 540B model $7 4 . 4 \%  8 2 . 1 \%$ on GSM8K, $9 0 . 0 \%  9 4 . 4 \%$ on OpenBookQA, and $6 3 . 4 \%  6 7 . 9 \%$ on ANLI-A3) and can also be adapted to extreme low-resource cases where even training questions and CoT prompts are limited. We conduct ablation studies and show that fine-tuning on diverse reasoning paths is critical for self-improvement.
+
+# 1 Introduction
+
+self-consistency (Wang et al., 2022c) further improves the performance via self-evaluating multiple reasoning paths.
+
+Scaling has enabled Large Language Models (LLMs) to achieve state-of-the-art performance on a range of Natural Language Processing (NLP) tasks (Wang et al., 2018, 2019; Rajpurkar et al., 2016). More importantly, new capabilities have emerged from LLMs as they are scaled to hundreds of billions of parameters (Wei et al., 2022b): in-context few-shot learning (Brown et al., 2020) makes it possible for an LLM to perform well on a task it never trained on with only a handful of examples; Chain-of-Thought (CoT) prompting (Wei et al., 2022c; Kojima et al., 2022) demonstrates strong reasoning ability of LLMs across diverse tasks with or without few-shot examples;
+
+Despite these incredible capabilities of models trained on large text corpus (Brown et al., 2020; Chowdhery et al., 2022), fundamentally improving the model performances beyond few-shot baselines still requires finetuning on an extensive amount of high-quality supervised datasets. FLAN (Wei et al., 2021; Chung et al., 2022) and T0 (Sanh et al., 2022) curated tens of benchmark NLP datasets to boost zero-shot task performances on unseen tasks; InstructGPT (Ouyang et al., 2022) crowd-sourced many human answers for diverse sets of text instructions to better align their model to human instructions; Minerva (Lewkowycz et al., 2022) parsed the full ArXiv database carefully for relevant articles to excel on challenging competitive math and science datasets. The need for large annotated data for supervised LLM training still remains a burden for low-resource applications or specific domains where only limited annotations are available.
+
+In this paper, we study how an LLM capable of in-context few-shot learning and chain-ofthought reasoning, is able to self-improve its reasoning ability without supervised data. We show that using only input sequences (without ground truth output sequences) from multiple NLP task datasets, a pre-trained LLM is able to improve performances for both in-domain and out-of-domain tasks. Our method is shown in Figure 1: we first sample multiple predictions using few-shot Chain-of-Thought (CoT) (Wei et al., 2022c) as prompts, filter “high-confidence” predictions using majority voting (Wang et al., 2022c), and finally finetune the LLM on these high-confidence predictions. The resulting model shows improved reasoning in both greedy and multi-path evaluations. We call the model fine-tuned in this way as Language Model Self-Improved (LMSI).
+
+Note that LMSI depends on in-context few-shot learning and chain-of-thought reasoning abilities which small language models do not necessarily have. We empirically verify LMSI using a pre-trained 540B PaLM model (Chowdhery et al., 2022), where our method not only significantly improves training task performances $7 4 . 4 \%  8 2 . 1 \%$ on GSM8K, $9 0 . 0 \%  9 4 . 4 \%$ on OpenBookQA, and $6 3 . 4 \%  6 7 . 9 \%$ on ANLI-A3), but also enhances out-of-domain (OOD) tasks, without relying on supervised ground truth answers. Lastly, we explore more extreme cases where training questions and human-curated CoTs are also limited, and propose self-generating additional input questions and few-shot CoT prompts for model self-improving. We hope our simple approaches and strong empirical results could inspire more future work by the community to investigate optimal performances of pretrained LLMs without additional human supervision.
+
+Our contributions are summarized as follows:
+
+• We demonstrate that a large language model can self-improve by taking datasets without ground truth outputs, by leveraging CoT reasoning (Wei et al., 2022c) and self-consistency (Wang et al., 2022c) to generate diverse reasoning paths for self-training, and can achieve great improvments on in-domain multi-task performances as well as out-of-domain generalization.
+
+• We provide detailed ablation studies on training sample formatting and sampling temperature after fine-tuning, and identify critical design choices for most successful self-improvement by LLMs.
+
+• We further propose two approaches for model self-improving under extreme low-resource cases where even training questions and CoT prompts are limited, and achieve $7 4 . 2 \%$ on zero-shot GSM8K, against $4 3 . 0 \%$ by Kojima et al. (2022) or $70 . 1 \%$ through its naive extension with Wang et al. (2022c).
+
+The rest of this paper is organized as follows. Section 2 discusses related work. Section 3 lays out our method in detail. Section 4 shows our setup for experiments. Section 5 demonstrates our experiment results with ablation studies. Section 6 concludes our work. The chain-of-thought prompts used in our work are included in Appendix A.
+
+# 2 Related Work
+
+Learning from explanations. Augmenting a machine learning model with explanations has been studied in existing literature extensively. For example, in the supervised learning setting, a model can be fine-tuned using human-annotated rationales (Zaidan et al., 2007; Ling et al., 2017a; Narang et al., 2020; Camburu et al., 2018; Cobbe et al., 2021; Chung et al., 2022). A few works have also looked at how explanations can help the models in various settings, e.g., in-context learning (Lampinen et al., 2022) and in distillation (Pruthi et al., 2022). Lightman et al. (2023) treat explanations as process supervision to train a reward model. In this paper, we focus more on the unsupervised learning setting, where we do not assume we have a rationale-augmented training dataset available, since human-annotated rationales can be expensive.
+
+Few-shot explanations improves reasoning in LLMs. Recently, a lot of progress has been made towards improving LLMs’ reasoning abilities via prompting or in-context learning. Wei et al. (2022c) propose Chain-of-Thought prompting, which prompts the language model to generate a series of natural-language-based intermediate steps, and show it can help language models better solve complex and multi-step reasoning tasks, with recent study (Wang et al., 2022a) analyzing the relevant contents and correct reasoning order being the most crucial factor of the success of Chain-ofThought prompting. Wang et al. (2022c) improve Chain-of-Thought prompting by sampling multiple diverse reasoning paths and finding the most consistent answers via majority voting. Kojima et al. (2022); Zhang et al. (2022) propose to prompt the language model with “Let’s think step by step” to generate reasoning in a zero-shot fashion. Zhou et al. (2022) decompose the questions into multiple sub-questions, and ask the language model to solve each sub-question sequentially.
+
+Refining explanations. More recent work proposes to further refine the generated reasoning paths as some of them could be unreliable. For example, Ye and Durrett (2022) calibrate model predictions based on the reliability of the explanations, Jung et al. (2022) show that inducing a tree of explanations and inferring the satisfiability of each explanation can further help judge the correctness of explanations. Li et al. (2022a) show that sampling a diverse set of prompts from the training data, and a voting verifier can be used to improve model’s reasoning performance. Xi et al. (2023) and Zheng et al. (2023) propose to polish the problem progressively before the model reaching a stable answer. Zelikman et al. (2022) proposes better rationale generation by augmenting ground truth answers as hints when predicted answers are incorrect. Our work is orthogonal to these lines of work, as we utilize refined explanations for model selfimprovement, and could readily incorporate these other refinement techniques for generating higherquality self-training data. Our work is closely related to Zelikman et al. (2022) where we both propose to fine-tune a model on self-generated CoT data, but our method does not require ground truth labels and shows stronger empirical results with multi-task generalization. Different from existing work, we show that a mixture of the reasoningpath refinement techniques can be combined to further improve the quality of the generated reasoning paths, which is shown to be effective in boosting model’s performance via self-improvement.
+
+![](images/c75604b02ce44f7ac2495321043ac6bfbd5b61a9f005ee18ee50036ab7cd0b59.jpg)  
+Figure 1: Overview of our method. With Chain-of-Thought (CoT) examples as demonstration (Wei et al., 2022c), the language model generates multiple CoT reasoning paths and answers (temperature $T > 0$ ) for each question. The most consistent answer is selected by majority voting (Wang et al., 2022c). The CoT reasoning paths that lead to the answer with the highest confidence are augmented by mixed formats, and are fed back to the model as the final training samples.
+
+Self-training models. One related line of work is self-training (see a survey from Amini et al. (2022)). The key idea is to assign pseudo labels from a learned classifier to unlabeled data, and use these pseudo-labeled examples to further improve the original model training, e.g., (RoyChowdhury et al., 2019; Xie et al., 2020; He et al., 2020; Chen et al., 2021). Different from such prior work, our proposed self-improvement framework uses CoT prompting plus self-consistency to obtain highconfidence solutions on a large set of unlabeled data to augment the fine-tuning process.
+
+Distillation and dark knowledge. Language models are known to preserve parametric knowledge (Schick and Schütze, 2020a,b) during the pretraining stage. Our method tangentially relates to rich literature on distillation (Ba and Caruana, 2014; Hinton et al., 2015), where a student network imitates a teacher network’s classifier predictions on input examples. A key detail is to learn from soft targets instead of hard predicted labels, as softmax outputs with a high temperature reveal more detailed relative class likelihoods, colloquially known as dark knowledge (Hinton et al., 2015; Korattikara Balan et al., 2015). Recent studies (Zelikman et al., 2022; Snell et al., 2022; Eisenstein et al., 2022) show that dark knowledge within LLMs can be retrieved with more computation at inference time, such as adding informative instructions into the input sequence and output CoT generation (Wei et al., 2022c; Kojima et al., 2022). Recent works (Magister et al., 2022; dhar et al., 2023; Ho et al., 2023) demonstrated that distillation on explanations generated from large models can increase the reasoning abilities of smaller models with ground truth filtering.
+
+# 3 Method
+
+The overview of our method is illustrated in Fig. 1: We are given a pre-trained Large Language Model (LLM) $M$ and a question-only train
+
+Question: Stefan goes to a restaurant with his family. They order an appetizer that costs $\$ 10$ and 4 entrees that are $\$ 20$ each. If they tip $20 \%$ of the total, what is the total amount of money that they spend?
+
+# Multiple Path Decoding:
+
+Output 1: The appetizer costs $\$ 10$ . The entrees cost $\$ 20$ each so in total $4 * \ S 2 0 = \ S 8 0$ . This means the total cost is $\$ 10+580=590$ . They tip $20 \%$ of it, so the total amount they spend is $\$ 90 *1.2$ $= \$ 108$ . The answer is 108.
+
+Output 2: The appetizer costs $\$ 10$ and the entrees are $\$ 20$ each. There are 4 entrees so the sum is $\$ 20 *4=\ S 80$ . The waiter gets $20 \%$ of the total. $20 \%$ of $\$ 80$ is $\$ 80 *.2=916$ . The answer is $\$ 80$ $+ \$ 16= \$ 96$ . (Incorrect reasoning path)
+
+Output 3: The appetizer costs $\$ 10$ . The entrees cost $4 * \$ 20=980$ . The tip is $20 \%$ of the total, so it is $20 \%$ of the $\$ 90$ they have spent. The tip is $0 . 2 * 9 0 = \$ 18$ . The total they spent is $\$ 90+\$ 18$ $= \$ 108$ . The answer is 108.
+
+ing dataset $\mathcal { D } ^ { \mathrm { t r a i n } } = \{ x _ { i } \} _ { i = 1 } ^ { D }$ with few-shot Chainof-Thought $( \mathrm { C o T } )$ examples (Wei et al., 2022c). We apply multiple path decoding with a sampling temperature $T \ > \ 0$ for generating $m$ reasoning paths and answers $\{ r _ { i _ { 1 } } , r _ { i _ { 2 } } , \ldots , r _ { i _ { m } } \}$ for each question $x _ { i }$ in $\scriptstyle { \mathcal { D } } ^ { \mathtt { t r a i n } }$ , and use majority voting (selfconsistency) to select the most consistent, highest confidence answer (Wang et al., 2022c). We then keep all reasoning paths that lead to the most consistent answer, apply mixed formats of prompts and answers for augmentation, and fine-tune the model on these self-generated reasoning-answer data. We consider our approach as making the model self-improve. In the following sections, we detail important designs within our method, along with additional approaches for the model to selfimprove without supervised data.
+
+![](images/21ba3235aa5b574c2a6455191982da9b18312279c87045e355d640468f02b67b.jpg)  
+Figure 2: The relation of accuracy and confidence of the majority-voted answer after multiple path decoding on GSM8K training-set questions. A recent study (Kadavath et al., 2022) shows that language models are not perfectly-calibrated though their calibration increases with model size, and models with more than 10B parameters are reasonably calibrated on some few-shot tasks. This aligns well with our study and serve as the basis of this self-improving method.
+
+# 3.1 Generating and Filtering Multiple Reasoning Paths
+
+Self-consistency (Wang et al., 2022c) brings large improvements on reasoning tasks (e.g., $5 6 . 5 \% $ $7 4 . 4 \%$ on GSM8K test set), and the gap between greedy decoding and diverse decoding shows there is a potential for further improving the reasoning ability of $M$ , using the self-selected highconfidence reasoning paths as training data.
+
+For each training question $x _ { i }$ , we sample $m$ CoT reasoning paths, denoted as $\{ r _ { i _ { 1 } } , r _ { i _ { 2 } } , \ldots , r _ { i _ { m } } \}$ (see Table 1 for examples). An example of a training question with the self-generated CoT reasoning paths is shown in Table 1. Since $M$ is prompted with the CoT examples from Wei et al. (2022c), we apply the same output parsing with “The answer is” to generate their predicted answers $\{ y _ { i _ { 1 } } , y _ { i _ { 2 } } , . . . , y _ { i _ { m } } \}$ . The most consistent answer, which is not necessarily a correct answer, is selected by majority voting, denoted as $\begin{array} { r } { \tilde { y } _ { i } = \mathrm { a r g } \operatorname* { m a x } _ { y _ { i _ { j } } } \sum _ { k = 1 } ^ { m } \mathbb { I } ( y _ { i _ { j } } = y _ { i _ { k } } ) } \end{array}$ . In Table 1, the most consistent answer $\tilde { y }$ is 108, derived by output path 1 and output path 3, while the output path 2 makes a mistake in calculating the cost of the foods. For all the training questions, we filter the CoT reasoning paths that reach $\tilde { y }$ as the final answer to be put into the self-training data,
+
+Table 2: An example of how a reasoning path is augmented into four formats of training data with different prompts (in input) and answer styles (in output). Specifically, the CoT prompting examples used for each tasks are listed in Appendix A.2. The Standard prompting examples are the same question-answer pairs with CoT prompting examples, except that reasoning is removed.   
+
+<table><tr><td>Question: Amy is 1O years old. Jake is 8 years old. Alex&#x27;s age is right in the middle. How old is Alex? Selected Chain-of-Thought: Amy is 1O years old. Jake is 8 years old. Alex&#x27;s age is in the middle of Amy and Jake, so Alex is（8 + 10) /2= 9 years old. The answer is 9.</td></tr><tr><td>Mixed-formats of training data: Format 1: Input: [CoT prompting examples] + ‘\n’ + [Question] +&quot;\n’ +‘A:&#x27; Output: Amy is 10 years old. Jake is 8 years old. Alex&#x27;s age is in the middle of Amy and Jake, so Alex</td></tr><tr><td>is（8 + 10)/2 =9 years old. The answer is 9. Format 2: Input: [Standard prompting examples] + &quot;\n’ + [Question] + &#x27;\n&#x27; + ‘A:</td></tr><tr><td>Output: The answer is 9.</td></tr><tr><td>Format 3: Input: [Question] + ‘\n’ + ‘A: Let&#x27;s think step by step.&#x27;</td></tr><tr><td></td></tr><tr><td>Output: Amy is 10 years old. Jake is 8 years old. Alex&#x27;s age is in the middle of Amy and Jake, so Alex is（8 + 10)/2=9 years old. The answer is 9.</td></tr><tr><td>Format4:Input:[Ouestion]+‘\n&#x27;+‘A:&#x27;</td></tr></table>
+
+Output: The answer is 9.
+
+denoted as Dself−consistent $\mathbf { \Sigma } = \{ x _ { i } , \tilde { r _ { i } } \}$ , where $\tilde { r _ { i } } = \{ r _ { i _ { j } } | 1 \le j \le m , y _ { i _ { j } } = \tilde { y } _ { i } \}$ .
+
+Since we do not use any ground truth labels to filter out cases where $\tilde { y } _ { i } \ne y _ { i }$ , it is important that the self-generated CoT reasoning paths are mostly reliable and incorrect answers do not hurt the self-improvement of the model. We plot the relation between the accuracy and confidence of selfgenerated CoT paths for each question in GSM8K training set in Fig. 2. The confidence is the number of CoT paths leading to $\tilde { y }$ divided by the total path number $m$ . The y-axis shows the accuracy of $\tilde { y }$ under a certain confidence. The circle area and the color darkness shows the number of questions under a certain confidence. We can observe that confident answers are more likely to be correct, which means that when a question has many consistent CoT paths, then the corresponding $\tilde { y }$ is more likely to be correct. On the other hand, when $\tilde { y }$ is wrong, it is likely to be supported by fewer CoT paths, and brings little noise to the training samples.
+
+ble 2. In the first format, a few Chain-of-Thought examples (questions followed by reasoning paths leading to the correct final answers) are prepended to the new question, while the language model output is trained to be the same with the filtered CoT reasoning paths. In the second format, we use examples of questions and their direct answers as standard prompting, and the language model output is supposed to also only contain the direct answer. The third and fourth format are similar to the first and second format, except that no example of question-answer pairs are given, so that the model will learn to think on its own in an in-context zero-shot manner. In the third format, where we want the model to output CoT reasoning without prepending examples containing CoT reasonings, we append “Let’s think step by step.” at the end of the input sequence, to guide the language model to generate step-by-step CoT reasoning paths (Kojima et al., 2022). The mixed formats of training samples are then used to fine-tune the pre-trained language model $M$ .
+
+# 3.2 Training with Mixed Formats
+
+To prevent the language model from overfitting to specific prompts or answer styles, we create four different formats for each reasoning path to be mixed in the self-training data, shown in Ta
+
+# 3.3 Generating Questions and Prompts
+
+In some cases where even training questions or human-curated CoT prompts are limited, our method may not generate sufficient training samples for language model self-training. Therefore, we investigate how to self-generate more training questions as well as example prompts to further reduce human effort.
+
+Question Generation. Previous work (Yoo et al., 2021; Meng et al., 2022) discuss few-shot data augmentation by generating diverse training samples using LLMs. However, those methods are designed for classification tasks and require ground truth label for each few-shot example. We use a simple yet effective approach to generate diverse questions (without using ground truth answers) from a few example questions. Specifically, we randomly sample and concatenate example questions in a random order as input prompt, and let the language model generate consecutive sequences as new questions. We repeat the process to obtain a large set of new questions, then use self-consistency (Wang et al., 2022c) to only keep the questions that have a highly confident answer. Those questions are then used as self-generated training questions.
+
+Prompt Generation. Given a set of questions, humans can write CoT examples as reasoning paths leading to the final answer. In zero-shot setting without manual prompts, we can generate these CoT paths using the model itself. Following (Kojima et al., 2022), we start the answer with “A: Let’s think step by step.” and let the language model generate the consecutive reasoning paths. We then use those generated reasoning paths as examples for few-shot CoT prompting.
+
+# 4 Experimental Setup
+
+Tasks and Datasets. We demonstrate the effectiveness of our method on three types of tasks1:
+
+• Arithmetic reasoning: We use the math problem set GSM8K (Cobbe et al., 2021), and a reading comprehension benchmark DROP (Dua et al., 2019) which requires numerical reasoning. We follow (Zhou et al., 2022) to partition the DROP dataset into football related and non-football related subsets for training.
+
+• Commonsense reasoning: We use the OpenBookQA (Mihaylov et al., 2018) dataset, and the AI2 Reasoning Challenge (ARC) (Clark et al., 2018) dataset. Note that for ARC, we only use the Challenge sub-set (ARC-c) in our experiments. Both datasets contain multiple-choice questions.
+
+• Natural Language Inference: We use the Adversarial NLI (ANLI) (Mihaylov et al., 2018) subsets, ANLI-A2 and ANLI-A3, which are the more challenging subsets compared to ANLI-A1. These datasets contain pairs of sentences with relations of entailment, neutral, or contradiction.
+
+Models, Training settings and Hyperparameters. We follow previous studies (Wei et al., 2022c; Wang et al., 2022c) and conduct our experiments on the PaLM 540B model (Chowdhery et al., 2022), an autoregressive Transformer-based language model. The CoT examples for each dataset are listed in Appendix A.2. We generate $m = 3 2$ reasoning paths for each question in a training set, followed by format augmentation in Sec. 3.2. For DROP and ANLI-A2/A3, we sample $5 \mathrm { k }$ examples for reasoning path generation to reduce the training burden; For other datasets, we keep the whole training set. For each dataset, we fine-tune the model for $1 0 \mathrm { k }$ steps with a learning rate of $5 \mathrm { e } - 5$ and a batch size of 32. We use a sampling temperature of $T = 0 . 7$ with the pre-trained model as suggested by (Wang et al., 2022c). We use $T = 1 . 2$ for the language model after self-improvement (LMSI ). We set the maximum number of decoded steps to 256 for all experiments.
+
+# 5 Experiments and Results
+
+We conduct a series of experiments to demonstrate the effectiveness of our proposed self-improving method. First, we apply our method on each individual dataset (task) and report the results. We then merge the generated data from all datasets and train one model to study the generalization ability of the model on unseen datasets as in (Wei et al., 2021). In addition to the results of using generated CoT reasoning paths, we show studies on generating input questions and few-shot prompts. We end with ablation studies on model sizes and hyperparameters.
+
+# 5.1 Main Results
+
+We list the results of using the 540B PaLM model before and after LMSI in Table 3. For each model, during test time, we apply three separate prompting methods on all six datasets: standard-prompting, CoT-Prompting, and Self-Consistency. We observe that after LMSI , the performance of all three prompting methods increase by a large margin. We observe significant improvement, comparing selfconsistency versus LMSI with self-consistency: $+ 7 . 7 \%$ on GSM8K, $+ 4 . 8 \%$ on DROP, $+ 4 . 4 \%$ on OpenBookQA, and $+ 4 . 5 \%$ on ANLI-A3. This shows that our proposed method is quite effective. Furthermore, the single path CoT-Prompting performance of LMSI is close to or even better than the multiple path Self-Consistency performance of the model without LMSI , showing that LMSI truly helps the language model learn from the multiple consistent reasoning paths. We also apply LMSI on a recently proposed public language model, UL2 (20B) (Tay et al., 2022), and show the results in Appendix A.1. Compared to the 540B PaLM model (decoder-only), UL2 has a smaller scale, and a different architecture (encoder-decoder). We observe that for most datasets, LMSI still outperforms the original UL2 results, but the improvement is not as large as that on the 540B PaLM model.
+
+Table 3: Accuracy results on six reasoning benchmarks with or without LMSI using different prompting method.   
+
+<table><tr><td>Prompting Method</td><td> w. or w/o LMSI</td><td>GSM8K</td><td>DROP</td><td>ARC-c</td><td>OpenBookQA</td><td>ANLI-A2</td><td>ANLI-A3</td></tr><tr><td>Standard-Prompting</td><td>w/o LMSI w. LMSI</td><td>17.9 32.2 (+14.3)</td><td>60.0 71.7 (+11.7)</td><td>87.1 87.2 (+0.1)</td><td>84.4 92.0 (+7.6)</td><td>55.8 64.8 (+9.0)</td><td>55.8 66.9 (+11.1)</td></tr><tr><td>CoT-Prompting</td><td>w/o LMSI w. LMSI</td><td>56.5 73.5 (+17.0)</td><td>70.6 76.2 (+5.6)</td><td>85.2 88.3 (+3.1)</td><td>86.4 93.0 (+6.6)</td><td>58.9 65.3 (+6.4)</td><td>60.6 67.3 (+6.7)</td></tr><tr><td>Self-Consistency</td><td>w/o LMSI w. LMSI</td><td>74.4 82.1 (+7.7)</td><td>78.2 83.0 (+4.8)</td><td>88.7 89.8 (+1.1)</td><td>90.0 94.4 (+4.4)</td><td>64.5 66.5 (+2.0)</td><td>63.4 67.9 (+4.5)</td></tr></table>
+
+Table 4: Comparison of CoT-prompting accuracy results on six Out-Of-Domain benchmarks with or without training on six In-Domain (GSM8K, DROP, ARC-c, OpenBookQA, ANLI-A2, ANLI-A3) training-set questions.   
+
+<table><tr><td></td><td>Self-training data</td><td>AQUA</td><td> SVAMP</td><td> StrategyQA</td><td>ANLI-A1</td><td>RTE</td><td>MNLI-M/MM</td></tr><tr><td>w/o LMSI</td><td>-</td><td>35.8</td><td>79.0</td><td>75.3</td><td>68.8</td><td>79.1</td><td>72.0/74.0</td></tr><tr><td>w. LMSI</td><td>GSM8K + DROP +...</td><td>39.0 (+3.2)</td><td>82.8 (+3.8)</td><td>77.8 (+2.5)</td><td>79.2 (+10.4)</td><td>80.1 (+1.0)</td><td>81.8/82.2 (+9.8/+8.2)</td></tr></table>
+
+Multi-task self-training for unseen tasks. To demonstrate the generalization ability of LMSI , we conduct experiments of self-training on a mixture of the training-set questions from the above six datasets (denoted as In-Domain tasks), then use the same model checkpoint for the evaluation on six Out-Of-Domain (OOD) tasks, as shown in Table 4. Of all the OOD tasks: (1) AQUA (Ling et al., 2017b) and SVAMP (Patel et al., 2021) are arithmetic reasoning tasks; (2) StrategyQA (Geva et al., 2021) is a commonsense reasoning task; (3) ANLIA1 (Nie et al., 2019), RTE (Dagan et al., 2005) and MNLI-M/MM (Williams et al., 2018) are natural language inference tasks.2 Among these tasks, AQUA, StrategyQA, and RTE are significantly different from any In-Domain task, and have their own few-shot prompts. From Table 4, we observe that LMSI achieves higher accuracy results on all OOD tasks, showing that the overall reasoning ability of the language model is improved.
+
+Importance of training with augmented formats. We demonstrate the importance of training language models with augmented formats (both Chainof-Thought prompting and direct prompting, and both few-shot prompting and zero-shot prompting). In Table 5, we list the results of LMSI with all four formats, the results of LMSI with only direct answer formats, and the results of LMSI with only few-shot Chain-of-Thought prompting formats. The results show that without the CoT formats, the language model can still self-improve, but the performance gain drops by a large amount compared to using all four formats. However, if only using few-shot CoT prompting format for selftraining, the model can overfit to the prompting style and may not generalize well on downstream tasks.
+
+# 5.2 Pushing the limit of self-improvements
+
+Self-Generating Questions We further explore the few-shot setting where there are only limited training questions in the target domain. On GSM8K, we sample 10 real questions as few-shot samples, and use the language model to generate more training questions using the method in Section 3.3. We then self-train the language model with these generated questions and list the results in Table 6. The results show that using self-generated questions still improves the reasoning ability of language models, but using the real training-set questions leads to better results.
+
+Table 5: Ablation study: LMSI with different combinations of training format on GSM8K dataset.   
+
+<table><tr><td colspan="2">Results on GSM8K</td></tr><tr><td>w/o LMSI</td><td>Std. Prompting CoT Prompting 17.9 56.5</td></tr><tr><td>LMSI w/o CoT formats</td><td>23.6 (+5.7)</td></tr><tr><td>LMSI only few-shot CoT</td><td>61.6 (+5.1) 69.4 (+12.9)</td></tr><tr><td>LMSI w/CoT formats</td><td>29.2 (+11.3) 32.2 (+14.3) 73.5 (+17.0)</td></tr></table>
+
+Table 6: Accuracy on GSM8K test set after self-training on different question sets. Results are shown for both CoT-Prompting (CoT) and Self-Consistency (SC).   
+
+<table><tr><td rowspan="2"></td><td rowspan="2">Questions used for Self-Training</td><td colspan="2">GSM8K</td></tr><tr><td>CoT</td><td>SC</td></tr><tr><td>w/o LMSI</td><td></td><td>56.5</td><td>74.4</td></tr><tr><td>w. LMSI</td><td>Generated</td><td>66.2 (+9.7)</td><td>78.1 (+3.7)</td></tr><tr><td>w. LMSI</td><td>Training-set</td><td>73.5 (+17.0)</td><td>82.1 (+7.7)</td></tr></table>
+
+Self-Generating Few-Shot CoT Prompts. We explore the situation where no in-domain CoT examples are provided for a task. We apply the Stepby-Step method (Kojima et al., 2022) to generate CoT examples using the language model as described in Section 3.3, and show the results in Figure 3. We observe that few-shot prompting with self-generated Step-by-Step CoT examples substantially outperforms the Step-by-Step (Kojima et al., 2022) baseline $6 6 . 2 \%$ vs $5 3 . 8 \%$ at 10 paths, $7 4 . 2 \%$ vs $7 0 . 1 \%$ at 40 paths), and nearly matches the performance of human-written few-shot CoT (Wei et al., 2021) $( 7 4 . 4 \%$ at 40 paths (Wang et al., 2022c)). The strong performance of “Few-Shot w/ Step-by-Step” despite the limited accuracy of prompt examples ( $4 3 . 0 \%$ for greedy Step-by-Step) likely comes from leveraging more diverse CoT prompts for multi-path decoding (Li et al., 2022b), where at 40 paths it uses 20 generate prompttemplates, each with 4-shot CoT examples, i.e. a total of 80 generated CoT examples compared to 8 human-written examples use in Wei et al. (2022c).
+
+Since we did not use training questions or few-shot CoT examples, $7 4 . 2 \%$ also marks the new state-ofthe-art zero-shot performance on GSM8K.
+
+![](images/dd69dade2171bed96a9241d1a30e748ed5fe732e0cf2428403c9cbd3553cfc6e.jpg)  
+Figure 3: Accuracy results on GSM8K test set using 540B model with multi-path sampling and selfconsistency (Wang et al., 2022c). “Step-by-Step” is the baseline performance of Kojima et al. (2022) plus selfconsistency (Wang et al., 2022c), while our “Few-Shot w/ Step-by-Step” uses exemplers self-generated from Step-by-Step (greedy decoding) for few-shot prompting the LLM.
+
+# 5.3 Distillation to smaller models
+
+Table 7: Distillation from 540B model to small models. We see that distilled smaller models outperform models that are one-tier larger.   
+
+<table><tr><td></td><td colspan="3">Results on GSM8K</td></tr><tr><td></td><td>8 billion</td><td>62 billion</td><td>540 billion</td></tr><tr><td>w/o LMSI</td><td>5.0</td><td>29.7</td><td>56.5</td></tr><tr><td>Distilled from LMSI</td><td>33.4 (+28.4)</td><td>57.4 (+27.7)</td><td>-</td></tr></table>
+
+We also explore whether the knowledge can be distilled to smaller models, such as in distillation (Hinton et al., 2015) and in Zelikman et al. (2022). We use the same set of training samples generated by the 540B PaLM model, but fine-tune on models with smaller sizes (8B PaLM model and 62B PaLM model respectively), and show the results of CoT-prompting in Table 7. It is interesting to point out that after distillation from LMSI , the 62B model can outperform the pre-trained 540B model, and the 8B model can outperform the pre-trained 62B model. This implies that for downstream applications with limited computing resources, the reasoning knowledge from large models can be used to largely enhance small models to achieve competitive performance.
+
+# 5.4 Hyperparameter Studies
+
+Sampling Temperature after Self-Improvement. We study the effect of varying the temperature $T$ for multiple path decoding after LMSI is applied. Specifically, we vary $T$ between [0.7, 1.0, 1.2, 1.5] and show the results on GSM8K and DROP dataset respectively in Fig. 4. As shown in the figure, $T = 1 . 2$ benefits both datasets the most, and is used in the Self-Consistency method for LMSI on all datasets. We notice that the optimal $T$ after model self-improvement is larger than the optimal $T = 0 . 7$ (Wang et al., 2022c) before selfimprovement. We believe the reason is that after training the model, the entropy of the output distribution is reduced.
+
+![](images/efbe75ef053d63876219c2ace74b92b8b1202d782da52ae0262b5d3d74fdf3fb.jpg)  
+Figure 4: Accuracy results of LMSI on GSM8K and DROP test set when different sampling temperatures are applied for Self-Consistency.
+
+Number of Sampled Reasoning Paths. We study whether the number of sampled reasoning paths $m$ for Self-Consistency largely affects the accuracy after LMSI is applied. We show the accuracy on GSM8K test set for models both with or without LMSI in Fig. 5. For both cases, setting $m = 1 5$ already achieves a reasonably good accuracy, and using a larger $m$ only brings marginal improvements. We also notice that after SelfImprovement, using 5 paths for Self-Consistency can already surpass the performance of using 32 paths for model without Self-Improvement. Thus, with a well-improved model, huge computing resources can be saved when applied to real applications.
+
+# 6 Conclusions
+
+We demonstrated that a Large Language Model (LLM) is capable of improving its performance on reasoning datasets by training on its own generated labels, given input questions only. Experiments using the PaLM model with 540 billion parameters show that LMSI improves the accuracy scores by $1 . 1 \%$ to $7 . 7 \%$ on six datasets, without training on ground truth labels. Furthermore, we show that it is possible for the LLM to self-improve even on its own generated questions and few-shot CoT prompts. As part of our future work, we plan to combine large-scale generated data from LMSI and existing supervised data, to further improve the performance of LLMs.
+
+![](images/2cfb6fd99ee3098a3d977f97ef9877c4291899eb705842fc1d61b479b999154f.jpg)  
+Figure 5: Accuracy results with or without LMSI on GSM8K test set using different numbers of sampled reasoning path for Self-Consistency.
+
+# Limitations
+
+Our approach mainly relies on the effectiveness of demonstration-based in-context few-shot learning which works most effectively on large language models, according to Wei et al. (2022a). For example, Zelikman et al. (2022) showed that a 6B model, GPT-J, achieves only $3 . 1 \%$ accuracy on GSM8K with few-shot CoT prompting, while GPT-3 (175 B) achieves $4 6 . 9 \%$ , according to Wei et al. (2022c). Moreover, a recent study (Kadavath et al., 2022) shows that language model calibration increases with model size. This aligns well with our observations that larger models are better at self-improving. Based on these existing studies, we believe that LMSI is more applicable to large-scale language models. In addition, we show that distillation from large models to small models are very promising in Sec. 5.3. Therefore, smaller models can also be improved when large model APIs are accessible. We are fortunate to have enough resources for this work. Though the computation requirements for training large-scale language models are still prohibitively high for most researchers to conduct empirical studies along this line, we believe that our findings are conceptually useful for the NLP community by providing new insights for the properties of large language models.
+
+# Acknowledgments
+
+We thank anonymous reviewers for valuable and insightful feedback.
+
+# References
+
+Massih-Reza Amini, Vasilii Feofanov, Loic Pauletto, Emilie Devijver, and Yury Maximov. 2022. Selftraining: A survey.
+
+Jimmy Ba and Rich Caruana. 2014. Do deep nets really need to be deep? Advances in neural information processing systems, 27.
+
+BIG bench collaboration. 2022. Beyond the imitation game: Quantifying and extrapolating the capabilities of language models. ArXiv, abs/2206.04615.
+
+Tom B. Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, Gretchen Krueger, T. J. Henighan, Rewon Child, Aditya Ramesh, Daniel M. Ziegler, Jeff Wu, Clemens Winter, Christopher Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, Jack Clark, Christopher Berner, Sam McCandlish, Alec Radford, Ilya Sutskever, and Dario Amodei. 2020. Language models are few-shot learners. In Neurips.
+
+Oana-Maria Camburu, Tim Rocktäschel, Thomas Lukasiewicz, and Phil Blunsom. 2018. e-snli: Natural language inference with natural language explanations. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett, editors, Advances in Neural Information Processing Systems 31, pages 9539–9549. Curran Associates, Inc.
+
+Xiaokang Chen, Yuhui Yuan, Gang Zeng, and Jingdong Wang. 2021. Semi-supervised semantic segmentation with cross pseudo supervision. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR).
+
+Aakanksha Chowdhery, Sharan Narang, Jacob Devlin, Maarten Bosma, Gaurav Mishra, Adam Roberts, Paul Barham, Hyung Won Chung, Charles Sutton, Sebastian Gehrmann, Parker Schuh, Kensen Shi, Sasha Tsvyashchenko, Joshua Maynez, Abhishek B Rao, Parker Barnes, Yi Tay, Noam M. Shazeer, Vinodkumar Prabhakaran, Emily Reif, Nan Du, Benton C. Hutchinson, Reiner Pope, James Bradbury, Jacob Austin, Michael Isard, Guy Gur-Ari, Pengcheng Yin, Toju Duke, Anselm Levskaya, Sanjay Ghemawat, Sunipa Dev, Henryk Michalewski, Xavier García, Vedant Misra, Kevin Robinson, Liam Fedus, Denny Zhou, Daphne Ippolito, David Luan, Hyeontaek Lim, Barret Zoph, Alexander Spiridonov, Ryan Sepassi, David Dohan, Shivani Agrawal, Mark Omernick, Andrew M. Dai, Thanumalayan Sankaranarayana Pillai, Marie Pellat, Aitor Lewkowycz, Erica Oliveira Moreira, Rewon Child, Oleksandr Polozov, Katherine Lee, Zongwei Zhou, Xuezhi Wang, Brennan Saeta, Mark Díaz, Orhan Firat, Michele Catasta, Jason Wei, Kathleen S. Meier-Hellstern, Douglas Eck, Jeff Dean, Slav Petrov, and Noah Fiedel. 2022. Palm: Scaling language modeling with pathways. ArXiv, abs/2204.02311.
+
+Hyung Won Chung, Le Hou, Shayne Longpre, Barret Zoph, Yi Tay, William Fedus, Eric Li, Xuezhi Wang, Mostafa Dehghani, Siddhartha Brahma, Adams Yu, Albert Webson, Xinyun Chen, Gaurav Mishra, Zhuyun Dai, Shixiang Shane Gu, Mirac Suzgun, Vincent Zhao, Aakanksha Chowdhery, Sharan Narang, Yanping Huang, Andrew Dai, Hongkun Yu, Ed H. Chi, Jeff Dean, Jacob Devlin, Adam Roberts, Denny Zhou, Quoc V. Le, and Jason Wei. 2022. Scaling instruction-finetuned language models. In arxiv.
+
+Peter Clark, Isaac Cowhey, Oren Etzioni, Tushar Khot, Ashish Sabharwal, Carissa Schoenick, and Oyvind Tafjord. 2018. Think you have solved question answering? try arc, the ai2 reasoning challenge. ArXiv, abs/1803.05457.
+
+Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Jacob Hilton, Reiichiro Nakano, Christopher Hesse, and John Schulman. 2021. Training verifiers to solve math word problems. ArXiv, abs/2110.14168.
+
+Ido Dagan, Oren Glickman, and Bernardo Magnini. 2005. The pascal recognising textual entailment challenge. In MLCW.
+
+Kumar Shri dhar, Alessandro Stolfo, and Mrinmaya Sachan. 2023. Distilling reasoning capabilities into smaller language models. In ACL.
+
+Dheeru Dua, Yizhong Wang, Pradeep Dasigi, Gabriel Stanovsky, Sameer Singh, and Matt Gardner. 2019. Drop: A reading comprehension benchmark requiring discrete reasoning over paragraphs. In NAACL.
+
+Jacob Eisenstein, Daniel Andor, Bernd Bohnet, Michael Collins, and David Mimno. 2022. Honest students from untrusted teachers: Learning an interpretable question-answering pipeline from a pretrained language model. arXiv preprint arXiv:2210.02498.
+
+Mor Geva, Daniel Khashabi, Elad Segal, Tushar Khot, Dan Roth, and Jonathan Berant. 2021. Did aristotle use a laptop? a question answering benchmark with implicit reasoning strategies. Transactions of the Association for Computational Linguistics, 9:346– 361.
+
+Junxian He, Jiatao Gu, Jiajun Shen, and Marc’Aurelio Ranzato. 2020. Revisiting self-training for neural sequence generation. In International Conference on Learning Representations.
+
+Geoffrey Hinton, Oriol Vinyals, Jeff Dean, et al. 2015. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2(7).
+
+Namgyu Ho, Laura Schmid, and Se-Young Yun. 2023. Large language models are reasoning teachers. ArXiv.
+
+Jaehun Jung, Lianhui Qin, Sean Welleck, Faeze Brahman, Chandra Bhagavatula, Ronan Le Bras, and Yejin Choi. 2022. Maieutic prompting: Logically consistent reasoning with recursive explanations.
+
+Saurav Kadavath, Tom Conerly, Amanda Askell, T. J. Henighan, Dawn Drain, Ethan Perez, Nicholas Schiefer, Zachary Dodds, Nova DasSarma, Eli TranJohnson, Scott Johnston, Sheer El-Showk, Andy Jones, Nelson Elhage, Tristan Hume, Anna Chen, Yuntao Bai, Sam Bowman, Stanislav Fort, Deep Ganguli, Danny Hernandez, Josh Jacobson, John Kernion, Shauna Kravec, Liane Lovitt, Kamal Ndousse, Catherine Olsson, Sam Ringer, Dario Amodei, Tom B. Brown, Jack Clark, Nicholas Joseph, Benjamin Mann, Sam McCandlish, Christopher Olah, and Jared Kaplan. 2022. Language models (mostly) know what they know. ArXiv, abs/2207.05221.
+
+Takeshi Kojima, Shixiang Shane Gu, Machel Reid, Yutaka Matsuo, and Yusuke Iwasawa. 2022. Large language models are zero-shot reasoners. Neural Information Processing Systems (NeurIPS).
+
+Anoop Korattikara Balan, Vivek Rathod, Kevin P Murphy, and Max Welling. 2015. Bayesian dark knowledge. Advances in neural information processing systems, 28.
+
+Andrew K. Lampinen, Ishita Dasgupta, Stephanie C. Y. Chan, Kory Matthewson, Michael Henry Tessler, Antonia Creswell, James L. McClelland, Jane X. Wang, and Felix Hill. 2022. Can language models learn from explanations in context?
+
+Aitor Lewkowycz, Anders Andreassen, David Dohan, Ethan Dyer, Henryk Michalewski, Vinay Venkatesh Ramasesh, Ambrose Slone, Cem Anil, Imanol Schlag, Theo Gutman-Solo, Yuhuai Wu, Behnam Neyshabur, Guy Gur-Ari, and Vedant Misra. 2022. Solving quantitative reasoning problems with language models. ArXiv, abs/2206.14858.
+
+Yifei Li, Zeqi Lin, Shizhuo Zhang, Qiang Fu, Bei Chen, Jian-Guang Lou, and Weizhu Chen. 2022a. On the advance of making language models better reasoners.
+
+Yifei Li, Zeqi Lin, Shizhuo Zhang, Qiang Fu, Bei Chen, Jian-Guang Lou, and Weizhu Chen. 2022b. On the advance of making language models better reasoners. ArXiv, abs/2206.02336.
+
+Hunter Lightman, Vineet Kosaraju, Yura Burda, Harrison Edwards, Bowen Baker, Teddy Lee, Jan Leike, John Schulman, Ilya Sutskever, and Karl Cobbe. 2023. Let’s verify step by step. ArXiv, abs/2305.20050.
+
+Lucie Charlotte Magister, Jonathan Mallinson, Jakub Adamek, Eric Malmi, and Aliaksei Severyn. 2022. Teaching small language models to reason. ArXiv, abs/2212.08410.
+
+Wang Ling, Dani Yogatama, Chris Dyer, and Phil Blunsom. 2017b. Program induction by rationale generation: Learning to solve and explain algebraic word problems. In ACL.
+
+Yu Meng, Jiaxin Huang, Yu Zhang, and Jiawei Han. 2022. Generating training data with language models: Towards zero-shot language understanding. ArXiv, abs/2202.04538.
+
+Todor Mihaylov, Peter Clark, Tushar Khot, and Ashish Sabharwal. 2018. Can a suit of armor conduct electricity? a new dataset for open book question answering. In EMNLP.
+
+Wang Ling, Dani Yogatama, Chris Dyer, and Phil Blunsom. 2017a. Program induction by rationale generation: Learning to solve and explain algebraic word problems. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers).
+
+Sharan Narang, Colin Raffel, Katherine Lee, Adam Roberts, Noah Fiedel, and Karishma Malkan. 2020. Wt5?! training text-to-text models to explain their predictions.
+
+Yixin Nie, Adina Williams, Emily Dinan, Mohit Bansal, Jason Weston, and Douwe Kiela. 2019. Adversarial nli: A new benchmark for natural language understanding. ArXiv, abs/1910.14599.
+
+Long Ouyang, Jeff Wu, Xu Jiang, Diogo Almeida, Carroll L Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, et al. 2022. Training language models to follow instructions with human feedback. arXiv preprint arXiv:2203.02155.
+
+Arkil Patel, S. Bhattamishra, and Navin Goyal. 2021. Are nlp models really able to solve simple math word problems? In NAACL.
+
+Danish Pruthi, Rachit Bansal, Bhuwan Dhingra, Livio Baldini Soares, Michael Collins, Zachary C. Lipton, Graham Neubig, and William W. Cohen. 2022. Evaluating Explanations: How Much Do Explanations from the Teacher Aid Students? Transactions of the Association for Computational Linguistics, 10:359–375.
+
+Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. 2016. Squad: $^ { 1 0 0 , 0 0 0 + }$ questions for machine comprehension of text. In EMNLP.
+
+Aruni RoyChowdhury, Prithvijit Chakrabarty, Ashish Singh, SouYoung Jin, Huaizu Jiang, Liangliang Cao, and Erik G. Learned-Miller. 2019. Automatic adaptation of object detectors to new domains using selftraining. In CVPR, pages 780–790.
+
+Victor Sanh, Albert Webson, Colin Raffel, Stephen H Bach, Lintang Sutawika, Zaid Alyafeai, Antoine Chaffin, Arnaud Stiegler, Teven Le Scao, Arun Raja, et al. 2022. Multitask prompted training enables zero-shot task generalization. In ICLR.
+
+Timo Schick and Hinrich Schütze. 2020a. Exploiting cloze-questions for few-shot text classification and natural language inference. In Conference of the European Chapter of the Association for Computational Linguistics.
+
+Timo Schick and Hinrich Schütze. 2020b. It’s not just size that matters: Small language models are also few-shot learners. ArXiv, abs/2009.07118.
+
+Charlie Snell, Dan Klein, and Ruiqi Zhong. 2022. Learning by distilling context. arXiv preprint arXiv:2209.15189.
+
+Yi Tay, Mostafa Dehghani, Vinh Quang Tran, Xavier García, Jason Wei, Xuezhi Wang, Hyung Won Chung, Dara Bahri, Tal Schuster, Huaixiu Zheng, Denny Zhou, Neil Houlsby, and Donald Metzler. 2022. Ul2: Unifying language learning paradigms.
+
+Alex Wang, Yada Pruksachatkun, Nikita Nangia, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R. Bowman. 2019. Superglue: A stickier benchmark for general-purpose language understanding systems. ArXiv, abs/1905.00537.
+
+Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R. Bowman. 2018. Glue: A multi-task benchmark and analysis platform for natural language understanding. In BlackboxNLP@EMNLP.
+
+Boshi Wang, Sewon Min, Xiang Deng, Jiaming Shen, You Wu, Luke Zettlemoyer, and Huan Sun. 2022a. Towards understanding chain-of-thought prompting: An empirical study of what matters. In Annual Meeting of the Association for Computational Linguistics.
+
+Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc Le, Ed Chi, and Denny Zhou. 2022b. Rationaleaugmented ensembles in language models. ArXiv, abs/2207.00747.
+
+Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc Le, Ed Chi, and Denny Zhou. 2022c. Self-consistency improves chain of thought reasoning in language models. ArXiv, abs/2203.11171.
+
+Jason Wei, Maarten Bosma, Vincent Y Zhao, Kelvin Guu, Adams Wei Yu, Brian Lester, Nan Du, Andrew M Dai, and Quoc V Le. 2021. Finetuned language models are zero-shot learners. arXiv preprint arXiv:2109.01652.
+
+Jason Wei, Yi Tay, Rishi Bommasani, Colin Raffel, Barret Zoph, Sebastian Borgeaud, Dani Yogatama, Maarten Bosma, Denny Zhou, Donald Metzler, Ed Huai hsin Chi, Tatsunori Hashimoto, Oriol Vinyals, Percy Liang, Jeff Dean, and William Fedus. 2022a. Emergent abilities of large language models. ArXiv, abs/2206.07682.
+
+Jason Wei, Yi Tay, Rishi Bommasani, Colin Raffel, Barret Zoph, Sebastian Borgeaud, Dani Yogatama, Maarten Bosma, Denny Zhou, Donald Metzler, et al. 2022b. Emergent abilities of large language models. arXiv preprint arXiv:2206.07682.
+
+Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Ed Chi, Brian Ichter, Fei Xia, Quoc Le, and Denny Zhou. 2022c. Chain of thought prompting elicits reasoning in large language models. Advances in Neural Information Processing Systems, 35.
+
+Adina Williams, Nikita Nangia, and Samuel R. Bowman. 2018. A broad-coverage challenge corpus for sentence understanding through inference. In NAACL.
+
+Zhiheng Xi, Senjie Jin, Yuhao Zhou, Rui Zheng, Songyang Gao, Tao Gui, Qi Zhang, and Xuanjing Huang. 2023. Self-polish: Enhance reasoning in large language models via problem refinement.
+
+Qizhe Xie, Minh-Thang Luong, Eduard Hovy, and Quoc V. Le. 2020. Self-training with noisy student improves imagenet classification. In 2020 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 10684–10695.
+
+Xi Ye and Greg Durrett. 2022. The unreliability of explanations in few-shot in-context learning.
+
+Kang Min Yoo, Dongju Park, Jaewook Kang, SangWoo Lee, and Woomyeong Park. 2021. Gpt3mix: Leveraging large-scale language models for text augmentation. In EMNLP Findings.
+
+Omar Zaidan, Jason Eisner, and Christine Piatko. 2007. Using “annotator rationales” to improve machine learning for text categorization. NAACL.
+
+Eric Zelikman, Yuhuai Wu, Jesse Mu, and Noah D. Goodman. 2022. Star: Bootstrapping reasoning with reasoning.
+
+Zhuosheng Zhang, Aston Zhang, Mu Li, and Alexander J. Smola. 2022. Automatic chain of thought prompting in large language models. ArXiv, abs/2210.03493.
+
+Chuanyang Zheng, Zhengying Liu, Enze Xie, Zhenguo Li, and Yu Li. 2023. Progressive-hint prompting improves reasoning in large language models. ArXiv, abs/2304.09797.
+
+Denny Zhou, Nathanael Scharli, Le Hou, Jason Wei, Nathan Scales, Xuezhi Wang, Dale Schuurmans, Olivier Bousquet, Quoc Le, and Ed Chi. 2022. Leastto-most prompting enables complex reasoning in large language models. ArXiv, abs/2205.10625.
+
+# A Appendix
+
+# A.1 Results on UL2 model
+
+We also apply LMSI on a recently proposed public language model, UL2 (Tay et al., 2022), using the pre-trained model at step $2 , 6 5 0 { , } 0 0 0 ^ { 3 }$ . We use a fixed set of hyperparameters for fine-tuning on each dataset. Specifically, we generate $m = 4 0$ reasoning paths for each question in a training set for majority voting. We fine-tune the model for 10k steps with a learning rate of $5 \mathrm { e } - 5$ and a batch size of 32. For multiple path decoding, we use a sampling temperature of $T = 0 . 5$ with the pre-trained UL2 model following Tay et al. (2022), and set $T = 0 . 7$ for the language model after LMSI . We set the maximum number of decode steps to 256 for all experiments.
+
+The results are shown in Table 8. For arithmetic reasoning datasets, we follow (Tay et al., 2022) to provide both exact matching accuracy scores as well as accuracy scores after an equation-correction postprocessing step. We observe that for most datasets, LMSI still improves the reasoning accuracy $( + 1 . 6 \%$ on DROP, $+ 1 . 2 \%$ on OpenBookQA, and $+ 0 . 7 \%$ on ANLI-A2), but the improvement on UL2 is not as large as that on 540B. We think the reason is that, since LMSI exploits the implicit rationale of language models, and the capacity of a language model is determined by its size, larger models can capture more high-order semantics and are more likely to benefit from LMSI . For example, on the adversarial entailment tasks of ANLI (which is a three-class classification problem with labels “yes”, “no”, or “it is not possible to tell”), the UL2 model w/o LMSI only achieves an accuracy of marginally above $1 / 3$ , implying that the model is slightly better than doing random guess on this challenging task without any training. Our proposed LMSI can still improve the performance under this hard case by training on its implicit knowledge from self-generated paths.
+
+Table 8: Accuracy results on six reasoning benchmarks with LMSI on UL2. On GSM8K and DROP, we also include accuracy scores after an equation-correction postprocessing step.
+
+<table><tr><td></td><td>Prompting Method</td><td>GSM8K</td><td>DROP</td><td>ARC-c</td><td>OpenBookQA</td><td>ANLI-A2</td><td>ANLI-A3</td></tr><tr><td rowspan="2"> w/o LMSI</td><td>CoT-Prompting</td><td>5.4/7.1</td><td>11.1/16.8</td><td>49.9</td><td>53.6</td><td>35.9</td><td>33.8</td></tr><tr><td>Self-Consistency</td><td>6.4/9.9</td><td>16.8/26.5</td><td>54.7</td><td>54.0</td><td>37.4</td><td>36.8</td></tr><tr><td rowspan="2">LMSI</td><td> CoT-Prompting</td><td>6.1/8.6</td><td>11.4/17.1</td><td>50.9</td><td>53.8</td><td>35.4</td><td>34.4</td></tr><tr><td>Self-Consistency</td><td>7.9/10.2</td><td>18.1/28.1</td><td>54.9</td><td>55.2</td><td>38.1</td><td>37.4</td></tr></table>
+
+# A.2 Chain-of-Thought Prompts for Each Dataset
+
+We list the Chain-of-Thought Prompts for each dataset for “CoT-Prompting” experiments and selfgenerated training samples.
+
+Table 10: Few-shot CoT prompts for OpenBookQA, from (Wang et al., 2022b).   
+
+<table><tr><td>Q: There are 15 trees in the grove. Grove workers willplant trees in the grove today. After they are done, there will be 21 trees.How many trees did the grove workers plant today? A: We start with 15 trees.Later we have 21 trees.The difference must be the number of trees they planted. So,they must have planted 21 - 15 = 6 trees. The answer is 6.</td></tr><tr><td>Q: If there are 3 cars in the parking lot and 2 more cars arrive,how many cars are in the parking lot?</td></tr><tr><td>A: There are 3cars in the parking lot already.2 more arrive.Now there are 3 + 2=5cars.The answer is 5.</td></tr><tr><td>Q: Leah had 32 chocolates and her sister had 42.If they ate 35,how many pieces do they have left in total? A: Leah had 32 chocolates and Leah&#x27;s sister had 42. That means there were originally 32 + 42 = 74</td></tr><tr><td>chocolates.35 have been eaten.So in total they stillhave 74 -35=39 chocolates.The answer is 39.</td></tr><tr><td>Q: Jason had 20 lollipops.He gave Denny some lolipops.Now Jason has 12 lollipops.How many lollipops did Jason give to Denny?</td></tr><tr><td>A: Jason had 20 lolipops.Since he only has 12 now, he must have given the rest to Denny. The number of lollipops he has given to Denny must have been 2O - 12 = 8 lollipops.The answer is 8.</td></tr><tr><td>Q: Shawn has five toys.For Christmas,he got two toys each from his mom and dad. How many toys does he have now?</td></tr><tr><td>A: He has 5 toys.He got 2 from mom,so after that he has 5 +2 =7 toys. Then he got 2 more from dad, so in total he has 7 + 2= 9 toys. The answer is 9.</td></tr><tr><td>Q: There were nine computers in the server room. Five more computers were installed each day, from monday to thursday. How many computers are now in the server room?</td></tr><tr><td>A: There are 4 days from monday to thursday.5 computers were added each day. That means in total 4 * 5= 20 computers were added.There were 9 computers in the beginning,so now there are9+ 20= 29 computers. The answer is 29.</td></tr><tr><td>Q: Michael had 58 golf bals.On tuesday, he lost 23 golf balls. On wednesday,he lost 2 more.How many golf balls did he have at the end of wednesday?</td></tr><tr><td>A: Michael initially had 58 balls.He lost 23on Tuesday,so after that he has 58- 23 =35 balls.On Wednesday he lost 2 more so now he has 35 -2= 33 balls. The answer is 33.</td></tr></table>
+
+Q: Poison causes harm to which of the following? (a) a Tree (b) a robot (c) a house (d) a car   
+A: Poison will harm living things, only a tree is a living thing. The answer is (a).   
+Q: As you look deeper into a Marbel you can see (a) the future (b) minut defects (c) colors (d) the other side A: Marbel is not transparent, so you can not see the other side. Marbel does not necessarily have multiple colors. You will see minut defects. The answer is (b).   
+Q: When food is reduced in the stomach (a) the mind needs time to digest (b) take a second to digest what I said (c) nutrients are being deconstructed (d) reader’s digest is a body of works   
+A: The food is being deconstructed in the stomach during digestion. The answer is (c).   
+Q: The sun is responsible for (a) puppies learning new tricks (b) children growing up and getting old (c) flowers wilting in a vase (d) plants sprouting, blooming and wilting   
+A: The sun can affect the growing of living things, like plants. The answer is (d).
+
+Q: Since the 1970s, U.S. governments have negotiated managed-trade agreements, such as the North American Free Trade Agreement in the 1990s, the Dominican Republic-Central America Free Trade Agreement in 2006, and a number of bilateral agreements. In Europe, six countries formed the European Coal and Steel Community in 1951 which became the European Economic Community in 1958. Two core objectives of the EEC were the development of a common market, subsequently renamed the single market, and establishing a customs union between its member states. How many years did the European Coal and Steel Community exist?
+
+A: According to the passage, the European Coal and Steel Community was established in 1951 and became the EEC in 1958. 1958 - $1 9 5 1 = 7$ . So the answer is 7.
+
+Q: In the county, the population was spread out with $2 3 . 5 0 \%$ under the age of 18, $8 . 7 0 \%$ from 18 to 24, $2 9 . 7 0 \%$ from 25 to 44, $2 4 . 7 0 \%$ from 45 to 64, and $1 3 . 3 0 \%$ who were 65 years of age or older. How many more percent are under the age of 18 compared to the 18 to 24 group?
+
+A: According to the passage, $2 3 . 5 \%$ are under the age of 18, and $8 . 7 \%$ are from ages 18 to $2 4 . 2 3 . 5 \% - 8 . 7 \%$ $= 1 4 . 8 \%$ . So the answer is 14.8.
+
+Q: Playing in their second straight Thanksgiving game, the Eagles struggled especially on defense, where they were unable to stop the much-hyped Lions offense. The worst of it all was how unproven rookie Eric Rowe was tasked with covering wide receiver Calvin Johnson, leading to Johnson catching 3 touchdowns. Stafford’s five passing touchdowns, including three of them to Johnson was too much for the Eagles to overcome and for the second consecutive time this season, the Eagles gave up 45 points in a game. With the loss, the Eagles drop to 4-7 on the season and 6-1 when playing on Thanksgiving. How many TD passes did Stafford throw other than to Johnson?
+
+A: According to the passage, Stafford threw $5 ~ \mathrm { T D }$ passes, 3 of which were to Johnson. $5 - 3 = 2$ . So the answer is 2.
+
+Table 12: Few-shot CoT prompts for DROP (football), from (Zhou et al., 2022).
+
+Q: The Seahawks played the San Francisco 49ers. In the first quarter, the Hawks RB Julius Jones got a 27-yard TD run, along with DT Craig Terrill returning a fumble 9 yards for a touchdown. In the third quarter, the 49ers almost rallied as RB H. J. Torres made a 12-yard TD pass to Lucas Nelly, along with Mare kicking a 32-yard field goal. In the final quarter, Julius Jones got another 11-yard TD. How many yards do the shortest touchdown run and the longest touchdown pass combine for?
+
+A: All the touchdown runs are: a 27-yard touchdown run, a 9-yard touchdown run, a 11-yard touchdown run. The smallest number among 27, 9, 11 is 9. So the shortest touchdown run was 9 yards. All the touchdown passes are: a 12-yard touchdown pass. So the longest touchdown pass was 12 yards. So the shortest touchdown run and the longest touchdown pass combine for $9 + 1 2 = 2 1$ yards. So the answer is 21 yards.
+
+Q: The Steelers went home for a duel with the Baltimore Ravens. Pittsburgh would deliver the opening punch in the first quarter with a 1-yard touchdown from running back Rashard Mendenhall. The Ravens would make it even as running back Willis McGahee got a 9-yard TD. The Ravens kicker Billy Cundiff got a 45-yard field goal in the second quarter, concluding the first half with a 10-7 lead. The Steelers brought the game into overtime with a 38-yard field goal by Andrew Foster. The Ravens Billy Cundiff pulled off a winning 33-yard field goal in overtime. How many points did the Ravens have at halftime?
+
+A: The Ravens kicker Billy Cundiff got a 45-yard field goal in the second quarter, concluding the first half with a 10-7 lead. So the Ravens had 10 points at halftime. So the answer is 10 points.
+
+Q: The Vikings flew to Bank of America Stadium to face the Carolina Panthers. After a scoreless first quarter, Carolina got on the board with quarterback Matt Moore finding fullback Brad Hoover on a 1-yard TD pass. After yet another scoreless quarter, Carolina sealed the game as Matt Moore completed a 42-yard touchdown pass to wide receiver Steve Smith. How many scoreless quarters were there?
+
+A: The first and third quarters were the scoreless quarters. So there are 2 scoreless quarters. So the answer is 2.
+
+Premise:   
+"Conceptually cream skimming has two basic dimensions - product and geography."   
+Based on this premise, can we conclude the hypothesis "Product and geography are what make cream skimming   
+work." is true?   
+OPTIONS:   
+- yes   
+- no   
+- it is not possible to tell
+
+A: Based on "cream skimming has two basic dimensions" we can’t infer that these two dimensions are what make cream skimming work. The answer is it is not possible to tell.
+
+"One of our member will carry out your instructions minutely."
+
+Based on this premise, can we conclude the hypothesis "A member of my team will execute your orders with immense precision." is true?
+
+OPTIONS:   
+- yes   
+- no   
+- it is not possible to tell
+
+A: "one of" means the same as "a member of", "carry out" means the same as "execute", and "minutely" means the same as "immense precision". The answer is yes.
+
+Premise:   
+"Fun for adults and children."   
+Based on this premise, can we conclude the hypothesis "Fun for only children." is true?   
+OPTIONS:   
+- yes   
+- no   
+- it is not possible to tell
+
+A: "adults and children" contradicts "only children". The answer is no.
+
+Premise:   
+"He turned and smiled at Vrenna."   
+Based on this premise, can we conclude the hypothesis "He smiled at Vrenna who was walking slowly behind   
+him with her mother." is true?   
+OPTIONS:   
+- yes   
+- no   
+- it is not possible to tell
+
+A: the premise does not say anything about "Vrenna was walking". The answer is it is not possible to tell.
+
+Premise:   
+"well you see that on television also"   
+Based on this premise, can we conclude the hypothesis "You can see that on television, as well." is true?   
+OPTIONS:   
+- yes   
+- no   
+- it is not possible to tell
+
+A: "also" and "as well" mean the same thing. The answer is yes.
+
+Premise:   
+"Vrenna and I both fought him and he nearly took us."   
+Based on this premise, can we conclude the hypothesis "Neither Vrenna nor myself have ever fought him." is true?   
+OPTIONS:   
+- yes   
+- no   
+- it is not possible to tell   
+A: "Vrenna and I both" contradicts "neither Vrenna nor myself". The answer is no. Q: John found that the average of 15 numbers is 40. If 10 is added to each number then the mean of the numbers is? Answer Choices: (a) 50 (b) 45 (c) 65 (d) 78 (e) 64   
+A: If 10 is added to each number, then the mean of the numbers also increases by 10. So the new mean would be 50. The answer is (a).   
+Q: If a $/ \mathrm { b } = 3 / 4$ and $8 \mathrm { a } + 5 \mathrm { b } = 2 2$ ,then find the value of a. Answer Choices: (a) 1/2 (b) 3/2 (c) $5 / 2$ (d) 4/2 (e) 7/2   
+A: If a $/ \mathrm { b } = 3 / 4$ , then $\mathsf { b } = 4 \mathsf { a } \mathrm { ~ / ~ } 3$ . So $8 \mathrm { a } + 5 ( 4 \mathrm { a } / 3 ) = 2 2$ . This simplifies to $8 \mathrm { a } + 2 0 \mathrm { a } / 3 = 2 2$ , which means $4 4 \mathrm { a } / 3 = 2 2$ . So a is equal to $3 / 2$ . The answer is (b).   
+Q: A person is traveling at $2 0 \mathrm { k m / h r }$ and reached his destiny in $2 . 5 \mathrm { h r }$ then find the distance? Answer Choices: (a) $5 3 \mathrm { k m }$ (b) $5 5 \mathrm { k m }$ (c) $5 2 \mathrm { k m }$ (d) $6 0 \mathrm { k m }$ (e) $5 0 \mathrm { k m }$   
+A: The distance that the person traveled would have been $2 0 \mathrm { k m } / \mathrm { h r } * 2 . 5 \mathrm { h r s } = 5 0 \mathrm { k m }$ . The answer is (e). Q: How many keystrokes are needed to type the numbers from 1 to 500? Answer Choices: (a) 1156 (b) 1392 (c) 1480 (d) 1562 (e) 1788   
+A: There are 9 one-digit numbers from 1 to 9. There are 90 two-digit numbers from 10 to 99. There are 401 three-digit numbers from 100 to $5 0 0 . ~ 9 + 9 0 ( 2 ) + 4 0 1 ( 3 ) = 1 3 9 2$ . The answer is (b).
+
+Table 16: Few-shot CoT prompts for StrategyQA, from (Wei et al., 2022c).   
+
+<table><tr><td>Q: Do hamsters provide food for any animals? A: Hamsters are prey animals.Prey are food for predators.Thus,hamsters provide food for some animals.</td></tr><tr><td>The answer is yes.</td></tr><tr><td>Q: Could Brooke Shields succeed at University of Pennsylvania? A: Brooke Shields went to Princeton University. Princeton University is about as academically rigorous as</td></tr><tr><td>the University of Pennsylvania. Thus,Brooke Shields could also succeed at the University of Pennsylvania. The answer is yes.</td></tr><tr><td>Q: Yes or no: Hydrogen&#x27;s atomic number squared exceeds number of Spice Girls?</td></tr><tr><td>A: Hydrogen has an atomic number of 1.1 squared is 1. There are 5 Spice Girls. Thus,Hydrogen&#x27;s atomic number squared is less than 5.The answer is no.</td></tr><tr><td>Q: Yes or no: Is it common to see frost during some college commencements?</td></tr><tr><td>A: College commencement ceremonies can happen in December,May,and June.December is in the winter,</td></tr><tr><td>so there can be frost. Thus,there could be frost at some commencements.The answer is yes.</td></tr><tr><td>Q: Yes or no: Could a llama birth twice during War in Vietnam (1945-46)?</td></tr><tr><td>A: The War in Vietnam was 6 months.The gestation period for alama is 11 months, which is more than 6 months.Thus,a llama could not give birth twice during the War in Vietnam. The answer is no.</td></tr><tr><td>Q: Yes or no: Would a pear sink in water?</td></tr><tr><td>A: The density of a pear is about O.6 g/cm,which is less than water. Objects less dense than water float.</td></tr></table>
+
+Table 17: Few-shot CoT prompts for RTE, from (Wang et al., 2022b).
+
+"No Weapons of Mass Destruction Found in Iraq Yet." Based on this premise, can we conclude the hypothesis "Weapons of Mass Destruction Found in Iraq." is true?
+
+A: "No Weapons of Mass Destruction Found" contradicts "Weapons of Mass Destruction Found". The answer is no.
+
+Premise:
+
+"A place of sorrow, after Pope John Paul II died, became a place of celebration, as Roman Catholic faithful gathered in downtown Chicago to mark the installation of new Pope Benedict XVI."
+
+Based on this premise, can we conclude the hypothesis "Pope Benedict XVI is the new leader of the Roman Catholic Church." is true?’
+
+A: "installation of new Pope Benedict XVI." means "Pope Benedict XVI is the new leader". The answer is yes.
+
+Premise:
+
+"A man is due in court later charged with the murder 26 years ago of a teenager whose case was the first to be featured on BBC One’s Crimewatch. Colette Aram, 16, was walking to her boyfriend’s house in Keyworth, Nottinghamshire, on 30 October 1983 when she disappeared. Her body was later found in a field close to her home. Paul Stewart Hutchinson, 50, has been charged with murder and is due before Nottingham magistrates later."
+
+Based on this premise, can we conclude the hypothesis "Paul Stewart Hutchinson is accused of having stabbed a girl." is true?
+
+A: The premise does not say Paul Stewart Hutchinson "stabbed" this girl. The answer is no.
+
+Premise:
+
+"Herceptin was already approved to treat the sickest breast cancer patients, and the company said, Monday, it will discuss with federal regulators the possibility of prescribing the drug for more breast cancer patients." Based on this premise, can we conclude the hypothesis "Herceptin can be used to treat breast cancer." is true?
+
+A: "Herceptin was approved to treat breast cancer" implies that "Herceptin can be used to treat breast cancer".   
+The answer is yes.

parse/dev/uuUQraD4XX/uuUQraD4XX_layout.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:12070c1a8465914fea2f3e3c0da7cc7735a95c16310d89ee47b6829de8b5c39a
+size 713074

parse/dev/uuUQraD4XX/uuUQraD4XX_origin.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:703c9ae2d5999a0cd3d6058e2d3bee33ae0eb739ba515ad646747b4acc2a0fad
+size 510042

parse/dev/uuUQraD4XX/uuUQraD4XX_span.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:81f49b947b32749c6c860583a95ef34bb344cc6ddeb6891febf7ec4347a2ef1f
+size 731022

parse/dev/uxxFrDwrE7Y/uxxFrDwrE7Y.md

@@ -0,0 +1,366 @@
+# LEARNING FAST, LEARNING SLOW: A GENERALCONTINUAL LEARNING METHOD BASED ON COMPLE-MENTARY LEARNING SYSTEM
+
+Elahe Arani∗, Fahad Sarfraz\* & Bahram Zonooz   
+Advanced Research Lab, NavInfo Europe, Eindhoven, Netherlands   
+{elahe.arani, fahad.sarfraz}@navinfo.eu, bahram.zonooz@gmail.com
+
+# ABSTRACT
+
+Humans excel at continually learning from an ever-changing environment whereas it remains a challenge for deep neural networks which exhibit catastrophic forgetting. The complementary learning system (CLS) theory suggests that the interplay between rapid instance-based learning and slow structured learning in the brain is crucial for accumulating and retaining knowledge. Here, we propose CLS-ER, a novel dual memory experience replay (ER) method which maintains short-term and long-term semantic memories that interact with the episodic memory. Our method employs an effective replay mechanism whereby new knowledge is acquired while aligning the decision boundaries with the semantic memories. CLSER does not utilize the task boundaries or make any assumption about the distribution of the data which makes it versatile and suited for “general continual learning”. Our approach achieves state-of-the-art performance on standard benchmarks as well as more realistic general continual learning settings.
+
+# 1 INTRODUCTION
+
+Continual learning (CL) refers to the ability of a learning agent to continuously interact with a dynamic environment and process a stream of information to acquire new knowledge while consolidating and retaining previously obtained knowledge (Parisi et al., 2019). This ability to continuously learn from a changing environment is a hallmark of intelligence and a critical missing component in our quest towards making our models truly intelligent. The major challenge towards enabling CL in deep neural networks (DNNs) is that the continual acquisition of incrementally available information from non-stationary data distributions leads to catastrophic forgetting whereby the performance of the model on previously learned tasks drops drastically (McCloskey & Cohen, 1989).
+
+Several approaches have been proposed to address the issue of catastrophic forgetting in CL. These can be broadly categorized into regularization-based methods (Farajtabar et al., 2020; Kirkpatrick et al., 2017; Ritter et al., 2018; Zenke et al., 2017) which penalizes changes in the network weights, network expansion-based methods (Rusu et al., 2016; Yoon et al., 2017) which dedicate a distinct set of network parameters to distinct tasks, and rehearsal-based methods (Chaudhry et al., 2018; Lopez-Paz & Ranzato, 2017) which maintains a memory buffer and replays samples from previous tasks. Amongst these, rehearsal-based methods have proven to be more effective in challenging CL tasks (Farquhar & Gal, 2018). However, an optimal approach for replaying memory samples and constraining the model update to efficiently consolidate knowledge remains an open question.
+
+In the brain, the ability to continually acquire, consolidate, and transfer knowledge over time is mediated by a rich set of neurophysiological processing principles (Parisi et al., 2019; Zenke et al., 2017) and multiple memory systems (Hassabis et al., 2017). In particular, the CLS theory (Kumaran et al., 2016) posits that efficient learning requires two complementary learning systems: the hippocampus exhibits short-term adaptation and rapid learning of episodic information which is then gradually consolidated to the neocortex for slow learning of structured information. Furthermore, a recent study by Hayes et al. (2021) identified the missing elements of biological reply in the replay mechanisms employed in DNNs for CL. They highlight that many existing approaches only focus on modeling the prefrontal cortex directly and do not have a fast learning network which plays a critical role in enabling efficient CL in the brain. Inspired by these studies, we hypothesize that mimicking the slow and rapid adaptation of information and having an efficient mechanism for incorporating them into the working memory can enable better CL in DNNs.
+
+![](images/a1cd21a22120eb2df3d8568fdf5222a5696c226232417616c6d15bea5f76ba11.jpg)  
+Figure 1: CLS-ER employs a dual-memory learning mechanism whereby the episodic memory stores the samples and the semantic memories build short-term and long-term memories of the learned representations of the working model. The two memories interact to enforce a consistency loss on the working model which prevents rapid changes in the parameter space and enables the alignment of the decision boundary with semantic memories for effective knowledge consolidation.
+
+To this end, we propose a novel dual memory experience replay method based on the complementary learning systems theory in the brain, dubbed as CLS-ER. In addition to a small episodic memory, our method builds long-term and short-term semantic memories which mimic the rapid and slow adaptation of information (Figure 1). As the network weights encode the learned representations of the tasks (Krishnan et al., 2019), the semantic memories are maintained by taking the exponential moving average of the working model’s weights to consolidate information across the tasks with varying time windows and frequencies. The semantic memories interact with the episodic memory to extract consolidated replay activation patterns and enforce a consistency loss on the update of the working model so that new knowledge is acquired while aligning the decision boundary of the working model with the decision boundaries of semantic memories. This maintains a balance between the plasticity and stability of the model for effective knowledge consolidation.
+
+CLS-ER provides a general CL method that does not utilize the task boundaries or make any strong assumption regarding the distribution of the data and tasks. We demonstrate the versatility and effectiveness of our method on a wide range of CL benchmark tasks as well as more challenging scenarios which simulate the complexities of CL in the real world.
+
+# 2 RELATED WORK
+
+The base method for the rehearsal-based approach, Experience Replay (ER) (Riemer et al., 2018) combines the memory samples with the task samples into the training batch. Several techniques have since been employed on top of ER. Meta Experience Replay (MER) (Riemer et al., 2018) considers replay as a meta-learning problem for maximizing the transfer from previous tasks and minimizing the interference. iCARL (Rebuffi et al., 2017) uses the nearest average representation of past exemplars to classify in an incrementally learned representation space. Gradient Episodic Memory (GEM) (Lopez-Paz & Ranzato, 2017) formulates optimization constraints on the exemplars in memory. Gradient-based Sample Selection (GSS) (Aljundi et al., 2019) aims for memory sample diversity in the gradient space and provides a greedy selection approach. Function Distance Regularization (FDR) (Benjamin et al., 2018) saves the network response at the task boundaries and adds a consistency loss on top of ER. Dark Experience Replay $( \mathrm { D E R + + } )$ applies knowledge distillation (Sarfraz et al., 2021) and regularization on logits sampled during the optimization trajectory.
+
+CLS has been used as a source of inspiration for dual memory learning systems in earlier works (French, 1999; Robins, 1993) but they have not been shown to scale to current computer vision tasks (Parisi et al., 2019). Recently, Rostami et al. (2019) utilizes a generative model to couple sequential tasks in a latent embedding space. Kamra et al. (2017) utilizes two generative models in a dual memory architecture. However, they utilize the task boundaries and generative replay has its own set of challenges as it is difficult to learn a faithful distribution and performs sub-par in comparison to instance-based replay methods on challenging CL settings. Generally, the inspiration from CLS theory in DNNs has been mostly limited to episodic memory and mimicking the rapid and slow learning mechanism is majorly ignored (Hayes et al., 2021) which we aim to address.
+
+![](images/24d7b7e6363b7a87d007247acd7ee41d41808ddef322b80d020f7b5aacc3ca20.jpg)  
+Figure 2: Task-wise performance on S-CIFAR-10 test set with 500 buffer size. The models are evaluated at the end of each task (y-axis) to evaluate how the task performances $\mathbf { \bar { X } }$ -axis) are affected as training progress. The stable model retains information from earlier tasks while the plastic model quickly adapts to the recent task. Note that there is less forgetting in the semantic memories compared to the working model. For other buffer sizes and S-TinyImageNet see Figures S1 and S2.
+
+# 3 METHOD
+
+We first provide an overview of the CLS theory for the brain and how we aim to mimic it for DNNs before introducing the main components of our method and the overall formulation.
+
+# 3.1 COMPLEMENTARY LEARNING SYSTEM THEORY
+
+The CLS theory posits that effective lifelong learning in the brain requires two complementary learning systems. The hippocampus rapidly encodes novel information as a short-term memory which is subsequently used to transfer and consolidate knowledge in the neocortex which gradually acquires structured knowledge representation as long-term memory through experience replay. The interplay between the functionality of the hippocampus and neocortex is crucial for concurrently learning efficient representations (for better generalization) and the specifics of instance-based episodic memory.
+
+# 3.2 COMPLEMENTARY LEARNING SYSTEM BASED EXPERIENCED REPLAY
+
+Inspired by the CLS theory, we propose a dual memory experience replay method, CLS-ER, which aims to mimic the interplay between fast learning and slow learning mechanisms for enabling effective CL in DNNs. Our method maintains short-term and long-term semantic memories of the encountered tasks which interact with the episodic memory for replaying the associated neural activities. The working model is updated so that it acquires new knowledge while aligning its decision boundary with the semantic memories to enable the consolidation of structured knowledge across the tasks. Figure 1 highlights the parallels between CLS theory and our method.
+
+Semantic Memories: Central to our method is the maintenance of two semantic memories which accumulate and consolidate information over long-term and short-term periods. As the acquired knowledge of the learned tasks is encoded in the weights of DNNs (Krishnan et al., 2019), we aim to form our semantic memories by accumulating the knowledge encoded in the corresponding weights of the model as it sequentially learns different tasks.
+
+An efficient method for aggregating the weights of a model is provided by Mean Teacher (Tarvainen & Valpola, 2017) which is a knowledge distillation approach that uses an exponential moving average (EMA) of the student’s weights during training as a teacher for semi-supervised learning. It can also be considered as forming a self-ensemble of the intermediate model states that leads to better internal representations. We adapt the Mean Teacher approach to build our semantic memories as it provides a computational and memory-efficient method for accumulating knowledge over the tasks.
+
+As CL involves learning tasks sequentially, the model weights at each training step can be considered as a student model specialized for a particular task. Therefore, averaging the weights during training can be considered as forming an ensemble of task-specific student models which effectively aggregates information across the tasks and leads to smoother decision boundaries. CLS-ER builds long-term (stable model) and short-term (plastic model) semantic memories by maintaining two EMA-weighted models over the working model’s weights. The stable model is updated less frequently with a larger window size so that it retains more information from the earlier tasks while the plastic model is updated more frequently with a smaller window size so that it adapts faster to information from new tasks (Figure 2). Section D further demonstrates the benefits of employing two semantic memories instead of a single semantic memory.
+
+Episodic Memory: Replay of samples from the previous tasks stored in a small episodic memory is a common approach in CL that has proven to be effective in mitigating catastrophic forgetting. As we aim to position CLS-ER as a versatile general incremental learning method, we do not utilize the task boundaries or make any strong assumptions about the distribution of the tasks or samples. Therefore, to maintain a fixed episodic memory buffer, we employ Reservoir sampling (Vitter, 1985) which assigns equal probability to each sample in the stream for being represented in the buffer and randomly replaces the existing memory samples (Algorithm 2). It is a global distribution matching strategy that ensures that at any given time the distribution of samples in the buffer will approximately match the distribution of all the samples seen so far (Isele & Cosgun, 2018).
+
+Consolidation of Information: The key challenge in CL is the consolidation of new information with the previously acquired information. This requires an effective balance between the stability and plasticity of the model. Furthermore, the sharp change in decision boundary as a new task is learned makes the consolidation of information over tasks more challenging. CLS-ER tackles these challenges through a novel dual memory experience replay mechanism. The long-term and shortterm semantic memories interact with the episodic memory to extract the consolidated activations for the memory samples which are then utilized to constrain the update of the working model so that new knowledge is obtained whilst the decision boundary is aligned with the semantic memories. This prevents rapid changes in the parameter space as new tasks are learned. Furthermore, aligning the working model’s decision boundary with the semantic memories serves two goals: (i) helps in retaining and consolidating information and (ii) leads to a smoother adaptation of decision boundary.
+
+# 3.3 FORMULATION
+
+CLS-ER involves training a working model $f ( . ; \theta _ { w } )$ on a data stream $\mathcal { D }$ sampled from a non-iid distribution. Two additional EMA-weighted models are maintained as semantic memories: plastic model $f ( . ; \theta _ { P } )$ and the stable model $f ( . ; \theta _ { S } )$ . Finally, Reservoir sampling (Vitter, 1985) is employed to maintain a small episodic memory $\mathcal { M }$ .
+
+At each training step, the working model receives the training batch $X _ { b }$ from the data stream and retrieves a random batch of exemplars $X _ { m }$ from the episodic memory. This is then followed by the retrieval of optimal semantic information, i.e. the structural knowledge encoded in the semantic memories which account for the consolidation of feature space and adaptation of the decision boundaries of the previous tasks. The semantic memories are designed so that the plastic model has higher performance on recent tasks whereas the stable model prioritizes retaining information on the older tasks. Therefore, we would prefer to use the logits from the stable model $Z _ { S }$ for older exemplars and the plastic model $Z _ { P }$ for recent exemplars. As CLS-ER is a general incremental learning method, instead of using a hard threshold or task information, we opt for a simple task-agnostic approach of using the performance of the semantic memories on the exemplars as a selection criterion that empirically works well. For each exemplar, we select the replay logits $Z$ based on which model has the highest softmax score for the ground-truth class (lines 5-6 in Algorithm 1).
+
+The selected replay logits from the semantic memories are then used to enforce a consistency loss on the working model so that it does not deviate from the already learned experiences. Hence, the working model is updated with a combination of the cross-entropy loss on the union of the data stream and episodic memory samples, $X$ , and the consistency loss on the exemplars $X _ { m }$ ,
+
+$$
+\mathcal { L } = \mathcal { L } _ { C E } ( \sigma ( f ( X ; \theta _ { W } ) ) , Y ) + \lambda \mathcal { L } _ { M S E } ( f ( X _ { m } ; \theta _ { W } ) , Z )
+$$
+
+Input: Data stream $\mathcal { D }$ , Learning rate $\eta$ , Consistency weight $\lambda$ , Update rates $r _ { P }$ and $r _ { S }$ , Decay parameters $\alpha _ { P }$ and $\alpha _ { S }$ Initialize: ${ \theta } _ { W } = { \theta } _ { P } = { \theta } _ { S }$ $\mathcal { M }  \{ \}$   
+1: while Training do   
+2: $( X _ { b } , Y _ { b } ) \sim \mathcal { D }$ and $( X _ { m } , Y _ { m } ) \sim { \mathcal { M } }$   
+3: $( X , Y ) = \{ ( X _ { b } , Y _ { b } ) , ( X _ { m } , Y _ { m } ) \}$   
+4: $Z _ { P } , Z _ { S } \gets f ( X _ { m } ; \theta _ { P } ) , f ( X _ { m } ; \theta _ { S } )$ . Select optimal semantic memory   
+5: $Z  Z _ { P }$ if $\sigma ( Z _ { P } ) ^ { ( Y _ { m } ) } > \sigma ( Z _ { S } ) ^ { ( Y _ { m } ) }$ else $Z _ { S }$   
+6: $\mathcal { L } = \mathcal { L } _ { C E } ( \sigma ( f ( X ; \theta _ { W } ) ) , Y ) + \lambda \mathcal { L } _ { M S E } ( f ( X _ { m } ; \theta _ { W } ) , Z )$ . Update working model   
+7: $\theta _ { W }  \theta _ { W } - \eta \nabla _ { \theta _ { W } } \mathcal { L }$   
+8: $a , b \sim \mathcal { U } ( 0 , 1 )$ . Update semantic memories   
+9: $\theta _ { P }  \alpha _ { p } \theta _ { P } + ( 1 - \alpha _ { P } ) \theta _ { W }$ if $a < r _ { P }$ else $\theta _ { P }$   
+10: $\theta _ { S }  \alpha _ { S } \theta _ { S } + ( 1 - \alpha _ { S } ) \theta _ { W }$ if $b < r _ { S }$ else $\theta _ { S }$   
+11: $\mathcal { M }  R e s e r v o i r ( \mathcal { M } , ( X _ { b } , Y _ { b } ) )$ $\triangleright$ Update episodic memory (Algorithm 2) return θW , θP , θS
+
+where $\sigma$ is the softmax function, $\lambda$ the regularization parameter, and $\mathcal { L } _ { M S E }$ the mean squared error loss used as consistency term.
+
+After updating the working model, we stochastically update the plastic and stable models with rates $r _ { P }$ and $r _ { S }$ (note that $r _ { P } > r _ { S }$ so that the plastic model is updated more frequently). A stochastic rather than a deterministic approach is more biologically plausible (Maass, 2014; Arani et al., 2021) which reduces the overlap in the snapshots of the working model and leads to more diversity in semantic memories. The semantic memories are updated by taking an exponential moving average of the working model’s weights (Tarvainen & Valpola, 2017) with decay parameters $\alpha _ { P }$ and $\alpha _ { S }$ ,
+
+$$
+\theta _ { i } = \alpha _ { i } \theta _ { i } + ( 1 - \alpha _ { i } ) \theta _ { W } , \quad i \in \{ P , S \}
+$$
+
+Note that $\alpha _ { P } \leq \alpha _ { S }$ so that the plastic model mimics the rapid adaptation of information while the stable model mimics slow acquisition of structured knowledge. See Algorithm 1 for more details.
+
+For inference, we use the stable model as it retains long-term memory across the tasks, consolidates structural knowledge, and learns efficient representations for generalization (Figure 1).
+
+# 4 EXPERIMENTAL SETUP
+
+To ensure a fair comparison of different CL methods under uniform experimental settings, we extended the Mammoth framework (Buzzega et al., 2020a) and unless stated otherwise, we follow the same training scheme (learning rate, batch sizes of incoming data and memory buffer, and the number of training epochs) as them for each of the evaluation settings. To find the optimal hyperparameters for CLS-ER, we run a grid search over $\lambda$ , $\alpha _ { S }$ , $\alpha _ { P }$ , $r _ { S }$ , and $r _ { P }$ on a small validation set. Sections C.4 and E show that our method is not highly sensitive to the particular choice of hyperparameters and different settings can attain similar performance. Also, because of the complementary nature of the components, we can often fix a set of parameters (e.g. $\lambda$ , $\alpha _ { S }$ , $\alpha _ { P }$ and $r _ { S }$ ) and only finetune the remaining parameters (e.g. $r _ { P }$ ) which facilitates hyperparameter tuning significantly.
+
+Following Buzzega et al. (2020a), we employ a fully connected network with two hidden layers, each with 100 ReLU units on all the variants of the MNIST dataset and ResNet-18 (He et al., 2015) without pretraining for the other datasets. In all the settings, we use the SGD optimizer. We use random horizontal flip and random crop on both the stream and buffer samples for S-CIFAR-10, S-Tiny-ImageNet, and GCIL-CIFAR-100. The selected hyperparameters for each of the settings are provided in Table S4. Note that for the vast majority of datasets, we use uniform settings (lr, epochs, batch size, memory batch size, and lambda) across different buffer sizes and only slight modifications in the other hyperparameters which shows that our method does not require extensive finetuning for different memory budgets. For each of our experiments, we fix the order of the classes and report the average and one standard deviation of the mean test accuracy of all the tasks across 10 runs with different initializations. Section E provides further training and implementation details.
+
+<table><tr><td rowspan="2">Buffer</td><td rowspan="2">Method</td><td colspan="3">Class-IL</td><td colspan="2">Domain-IL</td></tr><tr><td>S-MNIST</td><td>S-CIFAR-10</td><td>S-Tiny-ImageNet</td><td>R-MNIST</td><td>P-MNIST</td></tr><tr><td rowspan="2"></td><td>JOINT</td><td>95.57±0.24</td><td>92.20±0.15</td><td>59.99±0.19</td><td>95.76±0.04</td><td>94.33±0.17</td></tr><tr><td>SGD</td><td>19.60±0.04</td><td>19.62±0.05</td><td>7.92±0.26</td><td>67.66±8.53</td><td>40.70±2.33</td></tr><tr><td rowspan="7">200</td><td>ER</td><td>80.43±1.89</td><td>44.79±1.86</td><td>8.49±0.16</td><td>85.01±1.90</td><td>72.37±0.87</td></tr><tr><td>GEM</td><td>80.11±1.54</td><td>25.54±0.76</td><td>1</td><td>80.80±1.15</td><td>66.93±1.25</td></tr><tr><td>iCaRL</td><td>70.51±0.53</td><td>49.02±3.20</td><td>7.53±0.79</td><td>=</td><td>=</td></tr><tr><td>FDR</td><td>79.43±3.26</td><td>30.91±2.74</td><td>8.70±0.19</td><td>85.22±3.35</td><td>74.77±0.83</td></tr><tr><td>GSS</td><td>38.92±2.49</td><td>39.07±5.59</td><td>=</td><td>79.50±0.41</td><td>63.72±0.70</td></tr><tr><td>DER++</td><td>85.61±1.40</td><td>64.88±1.17</td><td>10.96±1.17</td><td>90.43±1.87</td><td>83.58±0.59</td></tr><tr><td>CLS-ER</td><td>89.54±0.21</td><td>66.19±0.75</td><td>23.47±0.80</td><td>92.26±0.18</td><td>84.63±0.40</td></tr><tr><td rowspan="8">500</td><td>ER</td><td>86.12±1.89</td><td>57.74±0.27</td><td>9.99±0.29</td><td>88.91±1.44</td><td>80.60±0.86</td></tr><tr><td>GEM</td><td>85.99±1.35</td><td>26.20±1.26</td><td>1</td><td>81.15±1.98</td><td>76.88±0.52</td></tr><tr><td>iCaRL</td><td>70.10±1.08</td><td>47.55±3.95</td><td>9.38±1.53</td><td>1</td><td>=</td></tr><tr><td>FDR</td><td>85.87±4.04</td><td>28.71±3.23</td><td>10.54±0.21</td><td>89.67±1.63</td><td>83.18±0.53</td></tr><tr><td>GSS</td><td>49.76±4.73</td><td>49.73±4.78</td><td>=</td><td>81.58±0.58</td><td>76.00±0.87</td></tr><tr><td>DER++</td><td>91.00±1.49</td><td>72.70±1.36</td><td>19.38±1.41</td><td>92.77±1.05</td><td>88.21±0.39</td></tr><tr><td>CLS-ER</td><td>92.05±0.32</td><td>75.22±0.71</td><td>31.03±0.56</td><td>94.06±0.07</td><td>88.30±0.14</td></tr><tr><td>ER</td><td>93.40±1.29</td><td>82.47±0.52</td><td>27.40±0.31</td><td>93.45±0.56</td><td>89.90±0.13</td></tr><tr><td rowspan="7">5120</td><td>GEM</td><td>95.11±0.87</td><td>25.26±3.46</td><td>1</td><td>88.57±0.40</td><td>87.42±0.95</td></tr><tr><td>iCaRL</td><td>70.60±1.03</td><td>55.07±1.55</td><td>14.08±1.92</td><td></td><td></td></tr><tr><td>FDR</td><td>87.47±3.15</td><td>19.70±0.07</td><td>28.97±0.41</td><td>94.19±0.44</td><td>90.87±0.16</td></tr><tr><td>GSS</td><td>89.39±0.75</td><td>67.27 ±4.27</td><td>=</td><td>85.24±0.59</td><td>82.22±1.14</td></tr><tr><td>DER++</td><td>95.30±1.20</td><td>85.24±0.49</td><td>39.02±0.97</td><td>94.65±0.33</td><td>92.26±0.17</td></tr><tr><td>CLS-ER</td><td>95.73±0.11</td><td>86.78±0.17</td><td>46.74±0.31</td><td>94.25±0.06</td><td>92.03±0.05</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+Table 1: Comparison with prior works on Class-IL and Domain-IL settings. The baseline results are from Buzzega et al. (2020a) (- indicates the experiments that the authors were unable to run).
+
+# 5 EMPIRICAL EVALUATION
+
+There are a plethora of evaluation protocols in the CL literature, each of which biases the evaluation towards a certain approach (Farquhar & Gal, 2018; Mi et al., 2020; van de Ven & Tolias, 2019). It is therefore of utmost importance to conduct an extensive and robust evaluation over different CL settings to gauge the versatility of the method. Details of the datasets used in each CL setting are provided in Section A. We compare our method with the state-of-the-art rehearsal-based approaches on various CL settings and memory budgets under uniform experimental settings. SGD refers to standard training and JOINT provides an upper bound given by training all tasks jointly.
+
+Class Incremental Learning (Class-IL): refers to the CL scenario where new classes are added with each subsequent task and the agent must learn to distinguish not only amongst the classes within the current task but also across previous tasks. Class-IL measures how well the method can learn general representations, accumulate, consolidate, and transfer the acquired knowledge to learn efficient representations and decision boundaries for all the classes seen so far.
+
+Table 1 provides the comparison with six rehearsal-based approaches on Class-IL settings with varying datasets and task length complexities. CLS-ER provides the highest performance in all of these scenarios. In particular, as the dataset complexity and number of tasks increase from S-MNIST to S-Tiny-ImageNet, the performance gap between CLS-ER and $\mathrm { D E R + + }$ increases considerably. Especially, with a smaller memory budget, CLS-ER is able to retain more information than other methods. In the most challenging setting, S-Tiny-ImageNet with 200 buffer size, CLS-ER provides a percentage gain of $1 7 6 \%$ and $1 1 4 \%$ over the baseline ER and the current state-of-the-art $\mathrm { D E R + + }$ , respectively. The results demonstrate the capability of CLS-ER to efficiently accumulate and retain knowledge over longer sequences under complex and memory restrictive scenarios.
+
+We believe that the performance gains over $\mathrm { D E R + + }$ highlight a key component of an efficient CL agent: the ability to consolidate previously acquired knowledge. $\mathrm { D E R + + }$ fails to account for the consolidation of feature space and adaptation of the decision boundaries of the previous tasks. Therefore, constraining the model to match the sub-optimal logits might hamper the consolidation of knowledge. This becomes more prominent as the number of classes in each task, the sequence length, and the cross-task resemblance increase. For instance, for $\mathrm { D E R + + }$ , replaying a sample from Task-1 when training on S-Tiny-ImageNet Task-10, the reference logit values which are used to enforce the consistency are from a model representation state which has not considered how to distinguish the 20 classes in Task-1 from 80 additional classes which are visually and semantically similar. It stands to reason that the optimal representation space and subsequently the decision boundaries for the classes in Task-1 would drift considerably when required to distinguish between 80 additional classes as well. Therefore, the local information provided by the sub-optimal saved logits in $\mathrm { D E R + + }$ fails to provide the global context required for consolidating knowledge. CLS-ER, on the other hand, extracts logits from the semantic memories which consolidate knowledge across the tasks, and hence the working model receives more optimal feedback.
+
+Table 2: Comparison with prior works on MNIST-360 test set. The baseline results are from Buzzega et al. (2020a).   
+
+<table><tr><td>JOINT</td><td>SGD</td><td>Buffer</td><td>ER</td><td>MER</td><td>GSS</td><td>DER++</td><td>CLS-ER</td></tr><tr><td rowspan="3">82.98±3.24</td><td rowspan="3">19.09±0.69</td><td>200</td><td>49.27±2.25</td><td>48.58±1.07</td><td>43.92±2.43</td><td>54.16±3.02</td><td>66.37±0.83</td></tr><tr><td>500</td><td>65.04±1.53</td><td>62.21±1.36</td><td>54.45±3.14</td><td>69.62±1.59</td><td>75.70±0.41</td></tr><tr><td>1000</td><td>75.18±1.50</td><td>70.91±0.76</td><td>63.84±2.09</td><td>76.03±1.61</td><td>79.54±0.34</td></tr></table>
+
+Table 3: Comparison with prior works on GCIL-CIFAR-100 dataset.   
+
+<table><tr><td>Distribution</td><td colspan="3">Uniform</td><td colspan="3">Longtail</td></tr><tr><td>JOINT</td><td colspan="3">58.36±1.02</td><td colspan="3">56.94±1.56</td></tr><tr><td>SGD</td><td></td><td>12.67±0.24</td><td></td><td></td><td>22.88±0.53</td><td>1000</td></tr><tr><td>Buffer ER</td><td>200 16.40±0.37</td><td>500</td><td>1000 31.98±0.72</td><td>200 19.27±0.77</td><td>500 20.30±0.63</td><td>34.13±0.83</td></tr><tr><td>DER++</td><td>18.84±0.60</td><td>28.21±0.69 32.92±0.74</td><td>38.95±0.56</td><td>26.94±1.27</td><td>25.82±0.83</td><td>33.64±0.88</td></tr><tr><td></td><td></td><td></td><td></td><td>28.54±0.87</td><td>28.63±0.68</td><td>39.52±0.91</td></tr><tr><td>CLS-ER</td><td>25.06±0.81</td><td>36.34±0.59</td><td>39.69±0.66</td><td></td><td></td><td></td></tr></table>
+
+Domain Incremental Learning (Domain-IL): refers to the CL scenario where the classes remain the same in subsequent tasks but the input distribution changes. We consider R-MNIST where each task contains digits rotated by a fixed angle and P-MNIST which applies a fixed random permutation to the pixels for each task. Table 1 shows that CLS-ER provides generalization gains under both settings, particularly for lower memory budget, and performs on par with $\mathrm { D E R + + }$ on 5120 buffer size. We attribute this to the consolidated soft targets from the semantic memories which provide relational information about the classes from a global context compared to the local information in $\mathrm { D E R + + }$ . This enables our method to maintain the similarity structure across sequences effectively.
+
+General Incremental Learning (GIL): Class-IL and Domain-IL fail to assimilate the challenges in the real-world setting where the task boundaries are blurry, and classes can reappear and have different distributions. The CL method has to consider the sample efficiency, challenge of imbalanced data, and efficient knowledge transfer in addition to preventing catastrophic forgetting. We consider two GIL settings: MNIST-360 (Buzzega et al., 2020a) exposes the model to both sharp (changes in class) and smooth (rotation of digits) distribution shifts. This requires the CL method to tackle the challenges of class-IL as well as domain-IL. The Generalized Class Incremental Learning (GCIL; Mi et al. (2020)) is the closest to the real-world scenario as it utilizes probabilistic modeling to sample the classes and data distributions in each task. The number of classes in each task is not fixed, the classes can overlap and the sample size for each class can vary.
+
+Table 2 shows that CLS-ER provides considerable performance gains on the challenging MNIST360, particularly with a low memory budget. Similarly, Table 3 demonstrates the effectiveness of CLS-ER on GCIL-CIFAR-100 under both uniform and imbalanced class samples. Both of these settings involve recurring classes in subsequent sequences which makes the transfer of knowledge from previous occurrences important. The performance gap between CLS-ER and $\mathrm { D E R + + }$ in the recurring classes setting alludes to another shortcoming of saving logits from the previous state. Consider the case where class c appears in sequence (Seq)-1 with 20 samples, and then subsequently in Seq-5 with 200 samples. In the following sequences, $\mathrm { D E R + + }$ uses exemplars from class c saved in Seq-1 with sub-optimal logits from the model state which was attained with only 20 samples and fails to take advantage of the better learned representations with additional data in Seq-5. CLS-ER, on the other hand, is able to take advantage of the additional samples and provide feedback from the improved learned representations. Moreover, the considerable performance improvement in the longtail setting shows that CLS-ER is more robust to class imbalance
+
+![](images/cc09b81bc4bf3ba7a715662721090fed97cd7e674719d2dbc70b1f9529d197a9.jpg)  
+Figure 3: Model characteristics analyses of different methods trained on S-CIFAR-10 with 500 buffer size. The Left and middle figures show the training loss and accuracy under varying Gaussian noise added to the weights of each layer of the model. CLS-ER is considerably less sensitive to perturbations, suggesting convergence to flatter minima. The right figure shows the task probabilities. CLS-ER effectively mitigates the bias to the recent tasks and provides a more uniform probability of being predicted for the classes over the tasks even very early ones.
+
+Note that the MNIST-based settings can be considered under the online CL setting (see Section A.4) as we only pass through the data once for each task and the performance of CLS-ER on these settings demonstrates its potential as an efficient method for online CL.
+
+# 6 MODEL CHARACTERISTICS
+
+We analyze CLS-ER and provide some insights into the characteristics of the proposed approach which enables it to learn effectively under challenging CL scenarios. In the subsequent analyses, we compare CLS-ER with the baseline ER and DER $^ { + + }$ .
+
+# 6.1 CONVERGENCE TO FLATTER MINIMA
+
+Due to the non-convexity of the loss landscape, there can be multiple solutions to the optimization objective, however, the local geometry at the convergence point can affect the generalization of the model. Solutions that reside in wide valleys instead of narrow crevices generalize better (Chaudhari et al., 2019; Hochreiter & Schmidhuber, 1997; Keskar et al., 2016) as the predictions do not change drastically with small perturbations. A CL model which converges to flatter minima has more flexibility to explore the neighboring parameter space to optimize on the new task without drastically increasing the loss on the previous tasks. Following the analysis in Zhang et al. (2018), we add independent Gaussian noise of increasing strength to the parameters of the trained model and analyze the change in accuracy and loss across the training samples. Figure 3 shows that CLS-ER is significantly less sensitive to perturbations compared to ER and $\mathrm { D E R + + }$ . CLS-ER also retains performance for a longer period and its performance drops more smoothly. These results suggest that the fast and slow adaptation of information in CLS-ER can guide the optimization to wider valleys.
+
+# 6.2 TASK PROBABILITIES
+
+Because of the sequential nature of CL, an implicit bias is induced towards the current task (Wu et al., 2019). A number of CL methods employ explicit techniques to reduce this bias (Hou et al., 2019; Wu et al., 2019), however, they utilize the task boundaries which is counterproductive for general incremental learning. We believe that the efficient knowledge consolidation in CLS-ER through the semantic memories can implicitly mitigate the bias towards recent tasks. We follow the analysis performed in Buzzega et al. (2020b) to observe the probability of each task being predicted at the end of the training. For each sample in the test dataset, we take the softmax output and then average the probabilities of the associated classes for each task across the dataset. We normalize the values and report the probability of each task being predicted. Figure 3 (right plot) shows that CLS-ER is able to maintain a more uniform prediction probability across all the tasks over a long sequence. Figures S3 and S4 shows similar results for other buffer sizes and S-TinyImageNet.
+
+![](images/fcf3b926f9b5848f246a2630ed9bae50598a97ee8677ceef394a03849730411c.jpg)  
+Figure 4: Reliability plots for different methods on S-CIFAR-10 with 500 buffer size. CLS-ER results in considerably better-calibrated models and hence more reliable predictions. For other buffer sizes and S-TinyImageNet see Figures S5 and S6.
+
+# 6.3 MODEL CALIBRATION
+
+Model calibration refers to the accuracy with which the scores provided by the model reflect its predictive uncertainty. The class probabilities predicted by DNNs are uncalibrated, often tending towards over-confidence which is detrimental to the reliability of the model’s prediction (Guo et al., 2017). This is even more pronounced in CL where the models tend to be biassed towards recent tasks. Following Guo et al. (2017), we provide the reliability diagrams (model accuracy as a function of its prediction confidence) and the Expected Calibration Error (ECE; a weighted average over the absolute difference between accuracy and confidence). Figure 4 shows the remarkable ability of CLS-ER to provide well-calibrated models without the application of any calibration technique.
+
+Note that these characteristics are complementary in nature: convergence to flatter minima allows our method to remain in the vicinity of optimal parameters for previous tasks when adapting to the new task, this leads to more uniform performance across tasks which can improve the task probabilities, and since the model is not too biased towards the current task, the model can provide reliable prediction across the tasks which improve the calibration. Additional characteristics analyses on different datasets and buffer sizes are provided in Appendix. We observe that our model’s behavior is consistent across varying datasets and buffer sizes.
+
+# 7 CONCLUSION
+
+We proposed a novel dual memory experience replay method based on the complementary learning systems theory in the brain. Our method maintains long-term and short-term semantic memories which are utilized to effectively replay the neural activities of the episodic memories and align the decision boundary of the working model for efficient knowledge consolidation. We demonstrated the effectiveness of our approach on benchmark datasets as well as more challenging general incremental learning scenarios and achieved the new state-of-the-art in the vast majority of the continual learning settings. We further showed that CLS-ER converges to flatter minima, mitigates the bias towards recent tasks, and provides a well-calibrated high-performance model. Our strong empirical results motivate further study into mimicking the complementary learning system in the brain more faithfully to enable optimal continual learning in DNNs.
+
+# REFERENCES
+
+Rahaf Aljundi, Min Lin, Baptiste Goujaud, and Yoshua Bengio. Gradient based sample selection for online continual learning. In Advances in Neural Information Processing Systems, pp. 11816– 11825, 2019. 2, 14
+
+Elahe Arani, Fahad Sarfraz, and Bahram Zonooz. Noise as a resource for learning in knowledge distillation. In Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision, pp. 3129–3138, 2021. 5
+
+Ari S Benjamin, David Rolnick, and Konrad Kording. Measuring and regularizing networks in function space. arXiv preprint arXiv:1805.08289, 2018. 2
+
+Pietro Buzzega, Matteo Boschini, Angelo Porrello, Davide Abati, and Simone Calderara. Dark experience for general continual learning: a strong, simple baseline. arXiv preprint arXiv:2004.07211, 2020a. 5, 6, 7, 13, 14, 17, 20
+
+Pietro Buzzega, Matteo Boschini, Angelo Porrello, and Simone Calderara. Rethinking experience replay: a bag of tricks for continual learning. arXiv preprint arXiv:2010.05595, 2020b. 8
+
+Pratik Chaudhari, Anna Choromanska, Stefano Soatto, Yann LeCun, Carlo Baldassi, Christian Borgs, Jennifer Chayes, Levent Sagun, and Riccardo Zecchina. Entropy-sgd: Biasing gradient descent into wide valleys. Journal of Statistical Mechanics: Theory and Experiment, 2019(12): 124018, 2019. 8
+
+Arslan Chaudhry, Marc’Aurelio Ranzato, Marcus Rohrbach, and Mohamed Elhoseiny. Efficient lifelong learning with a-gem. arXiv preprint arXiv:1812.00420, 2018. 1
+
+Matthias De Lange, Rahaf Aljundi, Marc Masana, Sarah Parisot, Xu Jia, Ales Leonardis, Gregory Slabaugh, and Tinne Tuytelaars. A continual learning survey: Defying forgetting in classification tasks. arXiv preprint arXiv:1909.08383, 2019. 13
+
+Mehrdad Farajtabar, Navid Azizan, Alex Mott, and Ang Li. Orthogonal gradient descent for continual learning. In International Conference on Artificial Intelligence and Statistics, pp. 3762–3773. PMLR, 2020. 1
+
+Sebastian Farquhar and Yarin Gal. Towards robust evaluations of continual learning. arXiv preprint arXiv:1805.09733, 2018. 1, 6, 13, 14
+
+Robert M French. Catastrophic forgetting in connectionist networks. Trends in cognitive sciences, 3(4):128–135, 1999. 2
+
+Chuan Guo, Geoff Pleiss, Yu Sun, and Kilian Q Weinberger. On calibration of modern neural networks. In International Conference on Machine Learning, pp. 1321–1330. PMLR, 2017. 9
+
+Demis Hassabis, Dharshan Kumaran, Christopher Summerfield, and Matthew Botvinick. Neuroscience-inspired artificial intelligence. Neuron, 95(2):245–258, 2017. 1
+
+Tyler L Hayes, Giri P Krishnan, Maxim Bazhenov, Hava T Siegelmann, Terrence J Sejnowski, and Christopher Kanan. Replay in deep learning: Current approaches and missing biological elements. arXiv preprint arXiv:2104.04132, 2021. 1, 3
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. corr abs/1512.03385 (2015), 2015. 5
+
+Sepp Hochreiter and Jürgen Schmidhuber. Flat minima. Neural computation, 9(1):1–42, 1997. 8
+
+Saihui Hou, Xinyu Pan, Chen Change Loy, Zilei Wang, and Dahua Lin. Learning a unified classifier incrementally via rebalancing. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 831–839, 2019. 8
+
+David Isele and Akansel Cosgun. Selective experience replay for lifelong learning. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 32, 2018. 4
+
+Nitin Kamra, Umang Gupta, and Yan Liu. Deep generative dual memory network for continual learning. arXiv preprint arXiv:1710.10368, 2017. 2
+
+Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. arXiv preprint arXiv:1609.04836, 2016. 8
+
+J Kirkpatrick, R Pascanu, N Rabinowitz, J Veness, G Desjardins, AA Rusu, K Milan, J Quan, T Ramalho, A Grabska-Barwinska, et al. Overcoming catastrophic forgetting in neural networks.(dec. arXiv preprint cs.LG/1612.00796, 2016. 13
+
+James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, et al. Overcoming catastrophic forgetting in neural networks. Proceedings of the national academy of sciences, 114(13):3521–3526, 2017. 1
+
+Giri P Krishnan, Timothy Tadros, Ramyaa Ramyaa, and Maxim Bazhenov. Biologically inspired sleep algorithm for artificial neural networks. arXiv preprint arXiv:1908.02240, 2019. 2, 3
+
+Alex Krizhevsky et al. Learning multiple layers of features from tiny images. 2009. 13
+
+Dharshan Kumaran, Demis Hassabis, and James L McClelland. What learning systems do intelligent agents need? complementary learning systems theory updated. Trends in cognitive sciences, 20 (7):512–534, 2016. 1
+
+Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. 13
+
+David Lopez-Paz and Marc’Aurelio Ranzato. Gradient episodic memory for continual learning. In Advances in neural information processing systems, pp. 6467–6476, 2017. 1, 2, 13
+
+Wolfgang Maass. Noise as a resource for computation and learning in networks of spiking neurons. Proceedings of the IEEE, 102(5):860–880, 2014. 5
+
+Zheda Mai, Ruiwen Li, Jihwan Jeong, David Quispe, Hyunwoo Kim, and Scott Sanner. Online continual learning in image classification: An empirical survey. Neurocomputing, 469:28–51, 2022. 14
+
+Michael McCloskey and Neal J Cohen. Catastrophic interference in connectionist networks: The sequential learning problem. In Psychology of learning and motivation, volume 24, pp. 109–165. Elsevier, 1989. 1
+
+Fei Mi, Lingjing Kong, Tao Lin, Kaicheng Yu, and Boi Faltings. Generalized class incremental learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops, pp. 240–241, 2020. 6, 7, 13, 20
+
+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. 1, 2
+
+Hadi Pouransari and Saman Ghili. Tiny imagenet visual recognition challenge. CS231N course, Stanford Univ., Stanford, CA, USA, 2015. 13
+
+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. 2
+
+Matthew Riemer, Ignacio Cases, Robert Ajemian, Miao Liu, Irina Rish, Yuhai Tu, and Gerald Tesauro. Learning to learn without forgetting by maximizing transfer and minimizing interference. arXiv preprint arXiv:1810.11910, 2018. 2
+
+Hippolyt Ritter, Aleksandar Botev, and David Barber. Online structured laplace approximations for overcoming catastrophic forgetting. In Advances in Neural Information Processing Systems, pp. 3738–3748, 2018. 1
+
+Anthony Robins. Catastrophic forgetting in neural networks: the role of rehearsal mechanisms. In Proceedings 1993 The First New Zealand International Two-Stream Conference on Artificial Neural Networks and Expert Systems, pp. 65–68. IEEE, 1993. 2
+
+Mohammad Rostami, Soheil Kolouri, and Praveen K Pilly. Complementary learning for overcoming catastrophic forgetting using experience replay. arXiv preprint arXiv:1903.04566, 2019. 2
+
+Andrei A Rusu, Neil C Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. arXiv preprint arXiv:1606.04671, 2016. 1
+
+Fahad Sarfraz, Elahe Arani, and Bahram Zonooz. Knowledge distillation beyond model compression. In 2020 25th International Conference on Pattern Recognition (ICPR), pp. 6136–6143. IEEE, 2021. 2
+
+Dongsub Shim, Zheda Mai, Jihwan Jeong, Scott Sanner, Hyunwoo Kim, and Jongseong Jang. Online class-incremental continual learning with adversarial shapley value. arXiv e-prints, pp. arXiv–2009, 2020. 13
+
+Antti Tarvainen and Harri Valpola. Mean teachers are better role models: Weight-averaged consistency targets improve semi-supervised deep learning results. arXiv preprint arXiv:1703.01780, 2017. 3, 5
+
+Gido M van de Ven and Andreas S Tolias. Three scenarios for continual learning. arXiv preprint arXiv:1904.07734, 2019. 6, 13
+
+Jeffrey S Vitter. Random sampling with a reservoir. ACM Transactions on Mathematical Software (TOMS), 11(1):37–57, 1985. 4
+
+Yue Wu, Yinpeng Chen, Lijuan Wang, Yuancheng Ye, Zicheng Liu, Yandong Guo, and Yun Fu. Large scale incremental learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 374–382, 2019.
+
+Jaehong Yoon, Eunho Yang, Jeongtae Lee, and Sung Ju Hwang. Lifelong learning with dynamically expandable networks. arXiv preprint arXiv:1708.01547, 2017. 1
+
+Friedemann Zenke, Ben Poole, and Surya Ganguli. Continual learning through synaptic intelligence. Proceedings of machine learning research, 70:3987, 2017. 1, 13
+
+Ying Zhang, Tao Xiang, Timothy M Hospedales, and Huchuan Lu. Deep mutual learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4320– 4328, 2018. 8
+
+# A CONTINUAL LEARNING SETTINGS
+
+There are a plethora of evaluation protocols in the CL literature, each of which biases the evaluation towards a certain approach (Farquhar & Gal, 2018; Mi et al., 2020; Shim et al., 2020; van de Ven & Tolias, 2019). It is therefore of utmost importance to conduct an extensive and robust evaluation to gauge the versatility of the method. We believe that adhering to the key desiderata as suggested in Farquhar & Gal (2018) would help the CL community immensely in moving towards a robust evaluation of methods. An experimental protocol that trains the method on a long sequence of tasks where the boundaries between the tasks are not distinct and the tasks themselves are not disjoint and the method does not make sure of task boundaries during training or testing can be considered as adhering to all five desiderata. Our work focuses on the aforementioned setting which can be considered as General Incremental Learning (GIL) setting. Here, we provide a broad categorization of these evaluation protocols which test different aspects of CL.
+
+# A.1 CLASS INCREMENTAL LEARNING (CLASS-IL)
+
+Class-IL refers to the CL scenario where new classes are added with each subsequent task and the agent must learn to distinguish not only amongst the classes within the current task but also across previous tasks. Class-IL measures how well the method can learn general representations, accumulate, consolidate, and transfer the acquired knowledge to learn efficient representations and decision boundaries for all the classes seen so far. Following Buzzega et al. (2020a); De Lange et al. (2019); Zenke et al. (2017), we consider the common benchmark datasets MNIST (LeCun et al., 1998) (SMNIST), CIFAR-10 (Krizhevsky et al., 2009) (S-CIFAR-10) and Tiny-ImageNet (Pouransari & Ghili, 2015) (S-Tiny-ImageNet) which are split into 5, 5, and 10 tasks each including 2, 2, and 20 classes respectively. These represent Class-IL settings of increasing dataset complexity as well as longer sequences. While it is an important and challenging benchmark, it assumes that each subsequent task will have the same number of disjoint classes and have uniform samples for each class which is not representative of real-world scenarios. We do not consider the related Task Increment Learning (Task-IL) setting as it assumes the availability of task labels at both training and inference which cannot truly be considered as a CL task (Farquhar & Gal, 2018).
+
+# A.2 DOMAIN INCREMENTAL LEARNING (DOMAIN-IL)
+
+Domain-IL refers to the CL scenario where the classes remain the same in each subsequent task but the input distribution changes. We consider Rotated-MNIST (Lopez-Paz & Ranzato, 2017) (R-MNIST) where each task contains digits rotated by a fixed angle between 0 and 180 degrees and Permuted-MNIST (Kirkpatrick et al., 2016) (P-MNIST) which applies a fixed random permutation to the pixels for each task. Though we provide the results for Permuted MNIST for completion, we share the opinion by Farquhar & Gal (2018) that it should not be considered as a benchmark dataset as it violates the cross-task resemblance desiderata and deviates from the goal of continual learning.
+
+# A.3 GENERAL INCREMENTAL LEARNING (GIL)
+
+The aforementioned CL scenarios fail to assimilate the challenges in the real world, setting where the task boundaries are blurry and the learning agent must rather learn from a continuous stream of data where classes can reappear and have different data distributions. The CL method must deal with the issues of sample efficiency, imbalanced classes, and efficient transfer of knowledge in addition to preventing catastrophic forgetting. To test the efficacy of our method in this challenging setting, we consider two GIL evaluation protocols. MNIST-360 (Buzzega et al., 2020a) models a stream of data which presents batches of two consecutive MNIST images with each sample rotated at an increasing angle and the sequence is repeated three times. This exposes the model to both a sharp distribution shift when the class changes and a smooth rotational distribution shift. However, the number of classes in each task and the samples are uniform. The Generalized Class Incremental Learning (GCIL) (Mi et al., 2020) utilizes probabilistic modeling to sample the classes and data distributions in each task. Hence, the number of classes in each task is not fixed, the classes can overlap and the sample size for each class can vary. Following Mi et al. (2020), we use GCIL on CIFAR-100 (Krizhevsky et al., 2009) dataset (GCIL-CIFAR-100), set the number of samples and maximum number of classes per task to 1000 and 50 respectively, number of tasks to 20, and evaluate on both uniform and longtail (imbalanced) sample distribution.
+
+# A.4 ONLINE CONTINUAL LEARNING
+
+Online continual learning refers to the challenging scenario where a stream of samples is only seen once and is non-iid (Mai et al., 2022; Aljundi et al., 2019). The common approach in the literature is to use the single-epoch protocol where the network is trained on each task in the sequence for only one epoch and there are no additional passages over data. As we aim to position CLS-ER as a general incremental learning method, we are also interested in the online continual learning setting. However, similar to Buzzega et al. (2020a), we also believe that the dataset complexity needs to be considered when setting the number of epochs to disentangle the effect of catastrophic forgetting from underfitting and share their suggestion that future CL works should strive for realism by designing experimental settings which are in line with the guidelines of General Continual Learning (Farquhar & Gal, 2018) which is the goal of our study rather than adopting the single-epoch protocol. For the MNIST-based settings, we use only one epoch per task as it is sufficient for the SGD baseline to learn the single task well. And for the more complex settings, we increase the number of epochs: 50 epochs for Sequential CIFAR-10 and Sequential Tiny-ImageNet and 100 epochs for GCIL-CIFAR-100.
+
+We would also like to emphasize that the experiments on MNIST based settings (S-MNIST, RMNIST, P-MNIST, and MNIST-360) can be considered as online continual learning settings as we only train the network for 1 epoch, and thereby the model only sees the data for each task once. CLSER’s performance in these settings demonstrates its potential for the challenging online continual learning setting.
+
+# B RESERVOIR SAMPLING
+
+Here, we provide the algorithm for the Reservoir Sampling for maintaining a fixed-size memory buffer. Reservoir sampling takes in a data stream of unknown length and assigns equal probability to each sample for being represented in the memory buffer $( \mathcal { M } )$ with a fixed budget size $( B )$ . Sampling and replacement are done at random and no priority is assigned to the samples being added or replaced from the memory buffer.
+
+# Algorithm 2 Reservoir Sampling Algorithm
+
+<table><tr><td>(x,y)</td><td>Input: Memory Buffer M, Memory Budget B,Number of seen examples N, Selected example</td></tr><tr><td>1: if B&gt; N then</td><td>Memory is not full</td></tr><tr><td>2: M[N] ← (x,y)</td><td></td></tr><tr><td>3: else</td><td>&gt; Select a sample to remove</td></tr><tr><td>4:</td><td>V = randomInteger(min= 0,max = N)</td></tr><tr><td>5: ifv&lt;Bthen</td><td></td></tr><tr><td>6: M[v]←(x,y)</td><td></td></tr><tr><td>return M</td><td></td></tr></table>
+
+# C ADDITIONAL RESULTS
+
+In this section, we provide additional experimental results and analysis of the behavior of the model.
+
+# C.1 CLS-ER COMPONENTS PERFORMANCE
+
+CLS-ER involves the interplay between the working model and the two semantic memories: the plastic and stable models. While we use the stable model for final inference, here we provide the performance of each of these individual components to provide further insights into the workings of our method. Table S1 shows the corresponding performance of the working model and plastic model for each of our experimental settings. We can see that the stable model can effectively consolidate knowledge across the tasks and therefore provide the highest mean performance for the vast majority of the settings. Figures S1 and S2 further shows how the task-wise performance (on test set) of each of the component varies as subsequent tasks are learned. The stable model retains the performance on previous tasks while the plastic model adapts better to the recent task. Both these models provide feedback to the working model which in turn improves the plastic and stable model.
+
+Table S1: CLS-ER components performance analysis for each of the experimental setting.   
+
+<table><tr><td>Dataset</td><td>Buffer</td><td>Stable Model</td><td>Working Model</td><td>Plastic Model</td></tr><tr><td rowspan="3">S-MNIST</td><td>200</td><td>89.54±0.21</td><td>89.32±0.23</td><td>89.52±0.21</td></tr><tr><td>500</td><td>92.05±0.30</td><td>91.61±0.47</td><td>92.04±0.33</td></tr><tr><td>5120</td><td>95.73±0.10</td><td>95.65±0.15</td><td>95.73±0.12</td></tr><tr><td rowspan="3">S-CIFAR-10</td><td>200</td><td>66.19±0.75</td><td>50.09±1.48</td><td>62.68±1.94</td></tr><tr><td>500</td><td>75.22±0.71</td><td>63.09±1.12</td><td>71.32±0.89</td></tr><tr><td>5120</td><td>86.78±0.17</td><td>85.00±0.33</td><td>86.77±0.17</td></tr><tr><td rowspan="3">S-Tiny-ImageNet</td><td>200</td><td>23.47±0.80</td><td>9.97±0.18</td><td>17.19±0.71</td></tr><tr><td>500</td><td>31.03±0.56</td><td>15.35±0.34</td><td>27.16±0.43</td></tr><tr><td>5120</td><td>46.74±0.31</td><td>41.39±0.39</td><td>47.10±0.42</td></tr><tr><td rowspan="3">R-MNIST</td><td>200</td><td>92.26±0.18</td><td>89.37±0.47</td><td>89.99±0.43</td></tr><tr><td>500</td><td>94.06±0.07</td><td>93.24±0.14</td><td>93.52±0.09</td></tr><tr><td>5120</td><td>94.25±0.06</td><td>94.28±0.08</td><td>94.37±0.06</td></tr><tr><td rowspan="3">P-MNIST</td><td>200</td><td>84.63±0.40</td><td>84.33±0.45</td><td>84.54±0.41</td></tr><tr><td>500</td><td>88.30±0.14</td><td>88.12±0.16</td><td>88.25±0.14</td></tr><tr><td>5120</td><td>92.03±0.05</td><td>91.96±0.06</td><td>92.02±0.05</td></tr><tr><td rowspan="3">MNIST-360</td><td>200</td><td>66.37±0.83</td><td>55.59±1.74</td><td>60.60±1.41</td></tr><tr><td>500</td><td>75.70±0.41</td><td>72.70±0.80</td><td>75.03±0.37</td></tr><tr><td>1000</td><td>79.54±0.34</td><td>78.39±0.69</td><td>79.16±0.42</td></tr><tr><td rowspan="3">GCIL-CIFAR-100 (Uniform)</td><td>200</td><td>33.15±2.80</td><td>31.74±2.72</td><td>32.70±2.78</td></tr><tr><td>500</td><td>37.01±1.67</td><td>35.89±1.69</td><td>36.18±1.68</td></tr><tr><td>1000</td><td>41.09±1.58</td><td>40.44±1.80</td><td>40.70±1.66</td></tr><tr><td rowspan="3">GCIL-CIFAR-100 (Longtail)</td><td>200</td><td>29.57±3.80</td><td>28.19±3.90</td><td>29.12±3.89</td></tr><tr><td>500</td><td>33.26±3.66</td><td>32.22±3.79</td><td>32.95±3.70</td></tr><tr><td>1000</td><td>39.21±3.46</td><td>38.51±3.55</td><td>38.84±3.52</td></tr></table>
+
+# C.2 TASK PROBABILITIES
+
+To test the effectiveness of our method in mitigating the bias towards recent tasks, we provide the task probabilities of the models trained with different buffer sizes on S-CIFAR-10 and S-TinyImageNet. Figures S3 and S4 show that CLS-ER consistently achieves more uniform task probabilities compared to ER and $\mathrm { D E R + + }$ and effectively mitigates the bias towards the last task.
+
+# C.3 MODEL CALIBRATION
+
+To further test the consistency of CLS-ER in providing well-calibrated models and the impact of the buffer size, we evaluate the calibration of models trained with different buffer sizes on S-CIFAR-10 and S-Tiny-ImageNet. Figures S5 and S6 show that CLS-ER consistently provides better calibrated models compared to ER and $\mathrm { D E R + + }$ . Remarkably, for both the datasets, on lower buffer sizes, the difference in Expected Calibration Error (ECE) is considerable. This demonstrates the capability of CLS-ER to train high-performance and reliable models under challenging conditions.
+
+# C.4 EFFECT OF HYPERPARAMETERS
+
+The interaction between the three components of CLS-ER is complementary. Table S3 shows how the performance of each component is affected under different hyperparameter settings. We can draw the following conclusions from the results. The performance improvement in the plastic and stable model is reflected in the working model and the best performance is seen in cases where both the semantic memories are performing well (albeit the focus on tasks is different). This highlights the crucial role of both memories in enabling CLS-ER to learn efficiently. For a fixed $r _ { S }$ value, the final performance of the stable model is affected considerably by the performance of the plastic model. The method is not highly sensitive to the particular choice of hyperparameters as different settings can attain similar performance. Because of the complementary nature of the components, we can often fix a set of parameters (e.g. $\lambda$ , $\alpha _ { S }$ , $\alpha _ { S }$ and $r _ { S }$ ) and only finetune the remaining parameters (e.g. $r _ { P } ^ { \prime }$ ) which facilitates hyperparameter tuning significantly.
+
+![](images/d857151b48e83ff3cf8d669fe2199ff6be049aca40295212d11cc1d228af46fd.jpg)  
+Figure S1: Test set task-wise performance for the individual models on S-CIFAR-10 with different buffer sizes. The task-wise performance $\mathbf { \dot { x } }$ -axis) is evaluated at the end of training of each task (y-axis) to evaluate how it is affected as training progresses.
+
+# D COMPARISON WITH A SINGLE SEMANTIC MEMORY
+
+CLS-ER employs two semantic memories as we aim to mimic the fast and slow learning mechanisms in the hippocampus and neocortex respectively. Here we compare our method with a single semantic memory (Mean-ER) and Table S2 shows that while it still performs admirably compared to the other CL methods, the dual semantic memories in CLS-ER provides additional performance gains especially on the complex datasets under the challenging lower memory buffer settings and has a much lower variance. We attribute this to the failure of Mean-ER in maintaining the performance on both the recent and earlier tasks together i.e there is an inherent trade-off as tuning the semantic memory to adapt to the recent changes comes at the cost of performance on earlier tasks and vice versa. CLS-ER efficiently tackles this trade-off by maintaining two specialized long-term and shortterm memories. The performance of Mean-ER, however, provides further evidence for the benefits of using consolidated information for memory replay.
+
+Note that for a fair comparison, we use the same hyperparameter search space as CLS-ER for finding the optimal parameters for Mean-ER and report the average and 1 std of 10 runs with different initializations using the best parameters for each setting. Table S6 provides the chosen hyperparameters. For inference, similar to CLS-ER, we use the EMA-weighted model (semantic memory) for Mean-ER.
+
+![](images/3e6883a1f7d2c3b538f68961a13252c10837ff431e0236e2985c8ec334efe633.jpg)  
+Figure S2: Test set task-wise performance for the individual models on S-Tiny-ImageNet with different buffer sizes. The task-wise performance ( $\mathbf { \dot { x } }$ -axis) is evaluated at the end of training of each task (y-axis) to evaluate how it is affected as training progresses.
+
+![](images/bbaf12b41b231df8112faa1215a9f09778a0b285d50e14ec4f41af0eb715d9ae.jpg)  
+Figure S3: Task probabilities for different methods on S-CIFAR-10 with varying memory budget.
+
+# E TRAINING AND IMPLEMENTATION DETAILS
+
+For a fair comparison, we aim to keep the experimental settings close to the current state-of-theart $\mathrm { D E R + + }$ (Buzzega et al., 2020a) as much as possible to disassociate the effect of the training schedule. We use the same optimizer, the number of epochs, batch size, and memory batch size as $\mathrm { D E R + + }$ . For S-Tiny-ImageNet, we reduce the number of epochs to 50 from 100 used by $\mathrm { D E R + + }$ as our method can learn efficiently with fewer epochs, and quickly acquiring new knowledge is preferred for CL. Similar to $\mathrm { D E R + + }$ , we finetune the memory batch size for S-MNIST and MNIST360. We select the hyperparameters for each of the experimental setting using a small validation set, $\alpha _ { S } , \alpha _ { P } \in ( 0 . 9 9 , 0 . 9 9 9 )$ , $r _ { S } , r _ { P } \in ( 0 , 1 ]$ , $\lambda \in ( 0 , 2 ]$ . Table S4 provides the hyperparameters used for each of the experimental settings. Note that for the vast majority of datasets, we use uniform settings (lr, epochs, batch size, memory batch size, and lambda) across the different buffer sizes and requires only slight modifications in the other hyperparameters which shows that our method does not require extensive finetuning for different memory budgets.
+
+![](images/3e568faa85c4dd263d654ec04d964a2b2e0170d03d6ed404cbb900cec3e52dfc.jpg)  
+Figure S4: Task probabilities for different methods on S-Tiny-ImageNet with varying memory budget.
+
+![](images/f5860c1110d4f1bbd6a729329cdccf9785cf10dc45cccfe959b39e0226b1b2fe.jpg)  
+Figure S5: Reliability plots for the different methods on S-CIFAR-10 with varying memory budget.
+
+![](images/d73417e4e5a32c0333a0cfd7c81926db646d5bc576f88ecf98975457ed9712f0.jpg)  
+Figure S6: Reliability plots for the different methods on S-Tiny-ImageNet with varying memory budget.
+
+Table S2: Comparison of CLS-ER with Mean-ER (single semantic memory) on Class-IL and Domain-IL settings. We report the mean and 1 std of 10 runs with different initializations.   
+
+<table><tr><td rowspan="2">Buffer</td><td rowspan="2">Method</td><td colspan="3">Class-IL</td><td colspan="2">Domain-IL</td></tr><tr><td>S-MNIST</td><td>S-CIFAR-10</td><td>S-Tiny-ImageNet</td><td>R-MNIST</td><td>P-MNIST</td></tr><tr><td rowspan="2"></td><td>JOINT</td><td>95.57±0.24</td><td>92.20±0.15</td><td>59.99±0.19</td><td>95.76±0.04</td><td>94.33±0.17</td></tr><tr><td>SGD</td><td>19.60±0.04</td><td>19.62±0.05</td><td>7.92±0.26</td><td>67.66±8.53</td><td>40.70±2.33</td></tr><tr><td rowspan="2">200</td><td>Mean-ER</td><td>88.32±0.65</td><td>61.88±2.43</td><td>17.68±1.65</td><td>92.10±1.07</td><td>83.28±0.68</td></tr><tr><td>CLS-ER</td><td>89.54±0.21</td><td>66.19±0.75</td><td>23.47±0.80</td><td>92.26±0.18</td><td>84.63±0.40</td></tr><tr><td rowspan="2">500</td><td>Mean-ER</td><td>91.79±0.23</td><td>70.40±1.21</td><td>24.97±0.80</td><td>92.78±0.44</td><td>87.73±0.39</td></tr><tr><td>CLS-ER</td><td>92.05±0.32</td><td>75.22±0.71</td><td>31.03±0.56</td><td>94.06±0.07</td><td>88.30±0.14</td></tr><tr><td rowspan="2">5120</td><td>Mean-ER</td><td>95.57±0.18</td><td>84.84±2.0</td><td>45.69±0.58</td><td>94.25±0.51</td><td>91.90±0.11</td></tr><tr><td>CLS-ER</td><td>95.73±0.11</td><td>86.78±0.17</td><td>46.74±0.31</td><td>94.25±0.06</td><td>92.03±0.05</td></tr></table>
+
+# E.1 GCIL-CIFAR-100
+
+To test our method under challenging GIL settings that better simulate the challenges of CL in the real world, we incorporate the GCIL setting from the code provided by Mi et al. (2020) with the continual dataset template class in the mammoth framework. We set the number of phases (length of task sequences) to 20, with the total number of samples in each phase set to 1000 and the maximum number of classes in each phase set to 50. We evaluate on both uniform and longtail (imbalanced) data distributions. Since GCIL involves the probabilistic sampling of the classes and their samples in each phase, the random seed determines the complexity of the GCIL setting. Therefore, for reproduciblility and to gauge the stability of the methods, we fix the dataset seed to 1993 and report the average and standard deviation of 10 differently initialized models trained on the same settings.
+
+For each of our method, we use identical training scheme $\mathrm { { ( l r { = } 0 . 1 } }$ , epochs $_ { \mathrm { \scriptsize = } 1 0 0 }$ , batch size $^ { \underline { { \ } } 3 2 }$ and memory batch $\mathrm { s i z e } { = } 3 2$ ). For $\mathrm { D E R + + }$ , as per the authors suggestion, we performed hyperparameter search over $\alpha \in [ 0 . 2 , 0 . 3 ]$ and $b e t a \in [ 0 . 5 , 1 . 0 ]$ with step size of 0.1. Table S5 provides the parameters chosen for each of the method under the different settings.
+
+# E.2 PERTURBATION ANALYSIS
+
+For the perturbation analysis, we used the code and checkpoints provided by Buzzega et al. (2020a) for $\mathrm { D E R + + }$ and ER. We would like to express our gratitude to the authors for their support and for making the mammoth framework available for the research community which provides a framework for a fair comparison of different CL methods under uniform experimental conditions.
+
+Table S3: The effect of different hyperparameter settings on the individual components of CLS-ER trained on S-CIFAR-10 with 500 buffer size. For all the experiments $\alpha _ { S }$ and $\alpha _ { P }$ are fixed to 0.999 and the performance is averaged over 3 runs with different initialization.   
+
+<table><tr><td>入</td><td>rs</td><td>rp</td><td>Stable Model</td><td>Working Model</td><td>Plastic Model</td></tr><tr><td rowspan="12">0.1</td><td></td><td>0.2</td><td>73.53±1.07</td><td>62.80±0.63</td><td>71.11±2.21</td></tr><tr><td></td><td>0.3</td><td>72.44±1.37</td><td>63.53±1.98</td><td>70.97±1.71</td></tr><tr><td></td><td>0.4</td><td>73.05±0.93</td><td>61.81±1.92</td><td>68.75±2.20</td></tr><tr><td></td><td>0.5</td><td>75.16±1.09</td><td>63.95±1.92</td><td>70.42±1.09</td></tr><tr><td>0.1</td><td>0.6</td><td>75.04±0.66</td><td>62.82±0.70</td><td>69.61±0.31</td></tr><tr><td></td><td>0.7</td><td>73.94±0.48</td><td>63.34±0.46</td><td>70.30±1.68</td></tr><tr><td></td><td>0.8</td><td>74.61±1.10</td><td>62.68±0.65</td><td>70.74±0.39</td></tr><tr><td rowspan="12"></td><td></td><td>73.74±2.14</td><td>62.69±1.97</td><td>69.52±0.79</td></tr><tr><td></td><td>0.9 1.0</td><td>64.21±1.11</td><td>72.00±0.56</td></tr><tr><td>0.3</td><td>75.73±0.68 70.26±1.79</td><td>61.63±1.03</td><td>69.31±1.82</td></tr><tr><td></td><td>71.80±1.17</td><td>62.64±0.18</td><td>70.64±1.22</td></tr><tr><td>0.4 0.5</td><td>70.69±2.13</td><td>61.76±0.64</td><td>69.65±1.92</td></tr><tr><td></td><td>72.45±0.68</td><td></td><td></td></tr><tr><td>0.2</td><td>0.6 0.7</td><td>71.47±1.98</td><td>63.87±0.85</td><td>71.29±0.72</td></tr><tr><td></td><td>0.8</td><td>72.16±0.56</td><td>61.12±1.90 62.71±0.57</td><td>70.22±2.24</td></tr><tr><td></td><td>0.9</td><td>72.09±0.59</td><td></td><td>70.83±0.64</td></tr><tr><td></td><td>1.0</td><td>72.05±1.35</td><td>63.33±1.01 63.74±1.75</td><td>71.20±0.87</td></tr><tr><td></td><td>0.4</td><td></td><td></td><td>71.01±1.28</td></tr><tr><td rowspan="12"></td><td></td><td></td><td>68.46±1.48</td><td>60.96±1.62</td><td>68.31±1.40</td></tr><tr><td></td><td>0.5 0.6</td><td>70.05±2.54</td><td>63.06±1.26</td><td>69.90±2.57</td></tr><tr><td></td><td></td><td>69.57±1.07</td><td>61.25±1.96</td><td>69.36±1.06</td></tr><tr><td>0.3</td><td>0.7</td><td>68.99±2.34</td><td>61.61±2.17</td><td>68.81±2.27</td></tr><tr><td></td><td>0.8</td><td>71.21±0.48</td><td>63.08±0.82</td><td>70.99±0.57</td></tr><tr><td>1</td><td>0.9</td><td>71.26±1.47</td><td>62.33±0.64</td><td>71.03±1.56</td></tr><tr><td></td><td>0.2</td><td>69.00±0.41</td><td>61.38±0.92</td><td>68.69±0.31</td></tr><tr><td rowspan="14"></td><td></td><td></td><td>70.19±1.97</td><td>61.39±2.06</td><td>69.81±1.60</td></tr><tr><td></td><td>0.3</td><td>73.72±0.83</td><td>62.07±0.84</td><td>70.18±0.09</td></tr><tr><td></td><td>0.4</td><td>71.60±2.30</td><td>61.11±2.00</td><td>69.15±1.08</td></tr><tr><td></td><td>0.5</td><td>74.18±0.37</td><td>63.32±0.98</td><td>71.08±2.04</td></tr><tr><td>0.1</td><td>0.6</td><td>74.90±0.40</td><td>62.35±2.31</td><td>71.58±0.79</td></tr><tr><td></td><td>0.7</td><td>74.52±1.10</td><td>62.59±2.64</td><td>70.90±2.30</td></tr><tr><td></td><td>0.8</td><td>75.27±1.21</td><td>62.00±1.98</td><td>71.27±1.64</td></tr><tr><td></td><td>0.9</td><td>74.61±0.91</td><td>63.47±1.60</td><td>70.49±0.95</td></tr><tr><td></td><td>1.0</td><td>76.03±0.64</td><td>63.63±1.01</td><td></td></tr><tr><td rowspan="12">0.15</td><td></td><td></td><td></td><td></td><td>71.42±1.11</td></tr><tr><td></td><td>0.3 0.4</td><td>72.59±1.44 71.30±3.42</td><td>61.81±1.03</td><td>72.02±1.30</td></tr><tr><td></td><td></td><td></td><td>63.15±0.51</td><td>70.92±2.83</td></tr><tr><td></td><td>0.5</td><td>69.89±1.95</td><td>60.60±0.95</td><td>68.87±2.56</td></tr><tr><td>0.2</td><td>0.6</td><td>72.34±0.89</td><td>62.18±1.31</td><td>71.15±0.94</td></tr><tr><td></td><td>0.7</td><td>72.70±1.11</td><td>62.50±1.18</td><td>71.49±1.21</td></tr><tr><td></td><td>0.8</td><td>72.42±1.50</td><td>61.85±0.83</td><td>71.04±1.68</td></tr><tr><td></td><td>0.9</td><td>71.18±0.71</td><td>61.81±1.29</td><td>70.09±0.54</td></tr><tr><td></td><td>1.0 0.4</td><td>73.52±0.65</td><td>64.19±0.86</td><td>72.56±0.52</td></tr><tr><td rowspan="8"></td><td></td><td>70.32±1.39</td><td>62.39±2.00</td><td>70.13±1.33</td></tr><tr><td>0.5</td><td>71.60±1.53</td><td>62.67±2.08</td><td>71.40±1.54</td></tr><tr><td>0.6</td><td>70.36±1.82</td><td>62.28±2.28</td><td>70.13±2.03</td></tr><tr><td>0.7 0.3</td><td>69.79±1.93</td><td>61.13±1.37</td><td>69.65±1.82</td></tr><tr><td>0.8</td><td>69.85±0.95</td><td>60.69±1.63</td><td>69.78±0.60</td></tr><tr><td>0.9</td><td>71.32±1.68</td><td>61.79±1.41</td><td>71.03±1.61</td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td>1.0</td><td>71.39±0.49</td><td>62.35±0.88</td><td>71.11±0.55</td></tr></table>
+
+Table S4: The hyperparameters used for each of the experimental settings for CLS-ER.   
+
+<table><tr><td>Dataset</td><td>Buffer</td><td>lr</td><td>Epochs</td><td>Batch Size</td><td>Memory Batch Size</td><td>入</td><td>αs</td><td>αp</td><td>rs</td><td>rp</td></tr><tr><td rowspan="3">S-MNIST</td><td>200</td><td>0.03</td><td>1</td><td>10</td><td>128</td><td>2.0</td><td>0.99</td><td>0.99</td><td>0.9</td><td>1.0</td></tr><tr><td>500</td><td>0.1</td><td>1</td><td>10</td><td>32</td><td>2.0</td><td>0.99</td><td>0.99</td><td>0.9</td><td>1.0</td></tr><tr><td>5120</td><td>0.1</td><td>1</td><td>10</td><td>32</td><td>2.0</td><td>0.99</td><td>0.99</td><td>0.8</td><td>1.0</td></tr><tr><td rowspan="3">S-CIFAR-10</td><td>200</td><td>0.1</td><td>50</td><td>32</td><td>32</td><td>0.15</td><td>0.999</td><td>0.999</td><td>0.1</td><td>0.3</td></tr><tr><td>500</td><td>0.1</td><td>50</td><td>32</td><td>32</td><td>0.15</td><td>0.999</td><td>0.999</td><td>0.1</td><td>0.9</td></tr><tr><td>5120</td><td>0.1</td><td>50</td><td>32</td><td>32</td><td>0.15</td><td>0.999</td><td>0.999</td><td>0.8</td><td>1.0</td></tr><tr><td rowspan="3">S-Tiny-ImageNet</td><td>200</td><td>0.05</td><td>50</td><td>32</td><td>32</td><td>0.1</td><td>0.999</td><td>0.999</td><td>0.04</td><td>0.08</td></tr><tr><td>500</td><td>0.05</td><td>50</td><td>32</td><td>32</td><td>0.1</td><td>0.999</td><td>0.999</td><td>0.05</td><td>0.08</td></tr><tr><td>5120</td><td>0.05</td><td>50</td><td>32</td><td>32</td><td>0.1</td><td>0.999</td><td>0.999</td><td>0.07</td><td>0.08</td></tr><tr><td rowspan="3">R-MNIST</td><td>200</td><td>0.2</td><td>1</td><td>128</td><td>128</td><td>0.75</td><td>0.999</td><td>0.99</td><td>1.0</td><td>1.0</td></tr><tr><td>500</td><td>0.2</td><td>1</td><td>128</td><td>128</td><td>0.75</td><td>0.999</td><td>0.99</td><td>1.0</td><td>1.0</td></tr><tr><td>5120</td><td>0.2</td><td>1</td><td>128</td><td>128</td><td>0.75</td><td>0.999</td><td>0.99</td><td>1.0</td><td>1.0</td></tr><tr><td rowspan="3">P-MNIST</td><td>200</td><td>0.2</td><td>1</td><td>128</td><td>128</td><td>1.0</td><td>0.99</td><td>0.99</td><td>0.8</td><td>1.0</td></tr><tr><td>500</td><td>0.2</td><td>1</td><td>128</td><td>128</td><td>1.0</td><td>0.99</td><td>0.99</td><td>0.8</td><td>1.0</td></tr><tr><td>5120</td><td>0.2</td><td>1</td><td>128</td><td>128</td><td>1.0</td><td>0.99</td><td>0.99</td><td>0.9</td><td>1.0</td></tr><tr><td rowspan="3">MNIST-360</td><td>200</td><td>0.2</td><td>1</td><td>16</td><td>16</td><td>0.75</td><td>0.999</td><td>0.99</td><td>1.0</td><td>1.0</td></tr><tr><td>500</td><td>0.2</td><td>1</td><td>16</td><td>32</td><td>1.25</td><td>0.99</td><td>0.99</td><td>0.9</td><td>1.0</td></tr><tr><td>1000</td><td>0.2</td><td>1</td><td>16</td><td>128</td><td>0.75</td><td>0.99</td><td>0.99</td><td>0.9</td><td>1.0</td></tr><tr><td rowspan="3">GCIL-CIFAR-100</td><td>200</td><td>0.1</td><td>100</td><td>32</td><td>32</td><td>0.1</td><td>0.999</td><td>0.999</td><td>0.6</td><td>0.7</td></tr><tr><td>500</td><td>0.1</td><td>100</td><td>32</td><td>32</td><td>0.1</td><td>0.999</td><td>0.999</td><td>0.6</td><td>0.7</td></tr><tr><td>1000</td><td>0.1</td><td>100</td><td>32</td><td>32</td><td>0.1</td><td>0.999</td><td>0.999</td><td>0.6</td><td>0.8</td></tr></table>
+
+Table S5: The hyperparameters used for $\mathrm { D E R + + }$ on GCIL-CIFAR-100 experiments. CLS-ER uses the same hyperparameters for both Uniform and Longtail settings (Table S4).   
+
+<table><tr><td>Distribution</td><td>Buffer</td><td>lr</td><td>Epochs</td><td>Batch Size</td><td>Memory Batch Size</td><td>a</td><td>B</td></tr><tr><td rowspan="3">Uniform</td><td>200</td><td>0.1</td><td>100</td><td>32</td><td>32</td><td>0.2</td><td>0.5</td></tr><tr><td>500</td><td>0.1</td><td>100</td><td>32</td><td>32</td><td>0.2</td><td>0.6</td></tr><tr><td>1000</td><td>0.1</td><td>100</td><td>32</td><td>32</td><td>0.3</td><td>0.6</td></tr><tr><td rowspan="3">Longtail</td><td>200</td><td>0.1</td><td>100</td><td>32</td><td>32</td><td>0.2</td><td>0.6</td></tr><tr><td>500</td><td>0.1</td><td>100</td><td>32</td><td>32</td><td>0.2</td><td>0.8</td></tr><tr><td>1000</td><td>0.1</td><td>100</td><td>32</td><td>32</td><td>0.3</td><td>0.9</td></tr></table>
+
+<table><tr><td>Dataset</td><td>Buffer</td><td>lr</td><td>Epochs</td><td>Batch Size</td><td>Memory Batch Size</td><td>入</td><td>a</td><td>r</td></tr><tr><td rowspan="3"> S-MNIST</td><td>200</td><td>0.03</td><td>1</td><td>10</td><td>128</td><td>2.0</td><td>0.99</td><td>1.0</td></tr><tr><td>500</td><td>0.1</td><td>1</td><td>10</td><td>32</td><td>2.0</td><td>0.99</td><td>1.0</td></tr><tr><td>5120</td><td>0.1</td><td>1</td><td>10</td><td>32</td><td>2.0</td><td>0.99</td><td>1.0</td></tr><tr><td rowspan="3">S-CIFAR-10</td><td>200</td><td>0.1</td><td>50</td><td>32</td><td>32</td><td>0.15</td><td>0.999</td><td>0.2</td></tr><tr><td>500</td><td>0.1</td><td>50</td><td>32</td><td>32</td><td>0.15</td><td>0.999</td><td>0.5</td></tr><tr><td>5120</td><td>0.1</td><td>50</td><td>32</td><td>32</td><td>0.15</td><td>0.999</td><td>0.8</td></tr><tr><td rowspan="3">S-Tiny-ImageNet</td><td>200</td><td>0.05</td><td>50</td><td>32</td><td>32</td><td>0.1</td><td>0.999</td><td>0.06</td></tr><tr><td>500</td><td>0.05</td><td>50</td><td>32</td><td>32</td><td>0.1</td><td>0.999</td><td>0.08</td></tr><tr><td>5120</td><td>0.05</td><td>50</td><td>32</td><td>32</td><td>0.1</td><td>0.999</td><td>0.08</td></tr><tr><td rowspan="3">R-MNIST</td><td>200</td><td>0.2</td><td>1</td><td>128</td><td>128</td><td>0.75</td><td>0.999</td><td>1.0</td></tr><tr><td>500</td><td>0.2</td><td>1</td><td>128</td><td>128</td><td>0.75</td><td>0.999</td><td>1.0</td></tr><tr><td>5120</td><td>0.2</td><td>1</td><td>128</td><td>128</td><td>0.75</td><td>0.999</td><td>1.0</td></tr><tr><td rowspan="3">P-MNIST</td><td>200</td><td>0.2</td><td>1</td><td>128</td><td>128</td><td>1.0</td><td>0.99</td><td>0.9</td></tr><tr><td>500</td><td>0.2</td><td>1</td><td>128</td><td>128</td><td>1.0</td><td>0.99</td><td>1.0</td></tr><tr><td>5120</td><td>0.2</td><td>1</td><td>128</td><td>128</td><td>1.0</td><td>0.99</td><td>0.9</td></tr></table>
+
+Table S6: The hyperparameters used for each of the experimental settings for Mean-ER.

parse/dev/uxxFrDwrE7Y/uxxFrDwrE7Y_layout.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:55d4315021daadb2f8d561afd7c5fc85b6e5453752683cfa00ff4b3bdf50fb1d
+size 815329

parse/dev/uxxFrDwrE7Y/uxxFrDwrE7Y_origin.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1d0f13deb2699d374e9bc25d5134ade57a3a029d90bdf8c75625e77469c589b9
+size 615597

parse/dev/uxxFrDwrE7Y/uxxFrDwrE7Y_span.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:08d274d20eae2ae645b1afbe6b2ea3e73866060e8c9f8e2f01189a746b03a897
+size 816699