Original: F EAR N ET : B RAIN -I NSPIRED M ODEL FOR I NCREMENTAL L EARNING
Revised: F EAR N ET : B RAIN -I NSPIRED M ODEL FOR I NCREMENTAL L EARNING

Original: Anonymous authors
Revised: Anonymous authors

Original: Paper under double-blind review
Revised: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Original: Incremental class learning involves sequentially learning classes in bursts of examples from the same class.
Revised: Incremental class learning involves sequentially learning classes in bursts of examples from the same class.

Original: This violates the assumptions that underlie methods for training standard deep neural networks, and will cause them to suffer from catastrophic forgetting.
Revised: This violates the assumptions that underlie methods for training standard deep neural networks, and will cause them to suffer from catastrophic forgetting.

Original: Arguably, the best method for incremental class learning is iCaRL, but it requires storing training examples for each class, making it challenging to scale.
Revised: Arguably, the best method for incremental class learning is iCaRL, but it requires storing training examples for each class, making it challenging to scale.

Original: Here, we propose FearNet for incremental class learning.
Revised: Here, we propose FearNet for incremental class learning.

Original: FearNet is a generative model that does not store previous examples, making it memory efﬁcient.
Revised: FearNet is a generative model that does not store previous examples, making it memory efﬁcient.

Original: FearNet uses a brain-inspired dual-memory system in which new memories are consolidated from a network for recent memories inspired by the mammalian hippocampal complex to a network for long-term storage inspired by medial prefrontal cortex.
Revised: FearNet uses a brain-inspired dual-memory system in which new memories are consolidated from a network for recent memories inspired by the mammalian hippocampal complex to a network for long-term storage inspired by medial prefrontal cortex.

Original: Memory consolidation is inspired by mechanisms that occur during sleep.
Revised: Memory consolidation is inspired by mechanisms that occur during sleep.

Original: FearNet also uses a module inspired by the basolateral amygdala for determining which memory system to use for recall.
Revised: FearNet also uses a module inspired by the basolateral amygdala for determining which memory system to use for recall.

Original: FearNet achieves state-of-the-art performance at incremental class learning on image (CIFAR-100,
Revised: FearNet achieves state-of-the-art performance at incremental class learning on image (CIFAR-100,

Original: CUB-200) and audio classiﬁcation (AudioSet) benchmarks.
Revised: CUB-200) and audio classiﬁcation (AudioSet) benchmarks.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: In incremental classiﬁcation, an agent must sequentially learn to classify training examples, without necessarily having the ability to re-study previously seen examples.
Revised: In incremental classiﬁcation, an agent must sequentially learn to classify training examples, without necessarily having the ability to re-study previously seen examples.

Original: While deep neural networks (DNNs) have revolutionized machine perception (Krizhevsky et al., 2012), off-the-shelf DNNs cannot incrementally learn classes due to catastrophic forgetting.
Revised: While deep neural networks (DNNs) have revolutionized machine perception (Krizhevsky et al., 2012), off-the-shelf DNNs cannot incrementally learn classes due to catastrophic forgetting.

Original: Catastrophic forgetting is a phenomenon in which a DNN completely fails to learn new data without forgetting much of its previously learned knowledge (McCloskey & Cohen, 1989).
Revised: Catastrophic forgetting is a phenomenon in which a DNN completely fails to learn new data without forgetting much of its previously learned knowledge (McCloskey & Cohen, 1989).

Original: While methods have been developed to try and mitigate catastrophic forgetting, as shown in Kemker et al.
Revised: While methods have been developed to try and mitigate catastrophic forgetting, as shown in Kemker et al.

Original: , these methods are not sufﬁcient and perform poorly on larger datasets.
Revised: , these methods are not sufﬁcient and perform poorly on larger datasets.

Original: In this paper, we propose FearNet, a brain-inspired system for incrementally learning categories that signiﬁcantly outperforms previous methods.
Revised: In this paper, we propose FearNet, a brain-inspired system for incrementally learning categories that signiﬁcantly outperforms previous methods.

Original: The standard way for dealing with catastrophic forgetting in DNNs is to avoid it altogether by mixing new training examples with old ones and completely re-training the model ofﬂine.
Revised: The standard way for dealing with catastrophic forgetting in DNNs is to avoid it altogether by mixing new training examples with old ones and completely re-training the model ofﬂine.

Original: For large datasets, this may require weeks of time, and it is not a scalable solution.
Revised: For large datasets, this may require weeks of time, and it is not a scalable solution.

Original: An ideal incremental learning system would be able to assimilate new information without the need to store the entire training dataset.
Revised: An ideal incremental learning system would be able to assimilate new information without the need to store the entire training dataset.

Original: A major application for incremental learning includes real-time operation on-board embedded platforms that have limited computing power, storage, and memory, e.g., smart toys, smartphone applications, and robots.
Revised: A major application for incremental learning includes real-time operation on-board embedded platforms that have limited computing power, storage, and memory, e.g., smart toys, smartphone applications, and robots.

Original: For example, a toy robot may need to learn to recognize objects within its local environment and of interest to its owner.
Revised: For example, a toy robot may need to learn to recognize objects within its local environment and of interest to its owner.

Original: Using cloud computing to overcome these resource limitations may pose privacy risks and may not be scalable to a large number of embedded devices.
Revised: Using cloud computing to overcome these resource limitations may pose privacy risks and may not be scalable to a large number of embedded devices.

Original: A better solution is on-device incremental learning, which requires the model to use less storage and computational power.
Revised: A better solution is on-device incremental learning, which requires the model to use less storage and computational power.

Original: In this paper, we propose an incremental learning framework called FearNet (see Fig. 1).
Revised: In this paper, we propose an incremental learning framework called FearNet (see Fig. 1).

Original: FearNet has three brain-inspired sub-systems: 1) a recent memory system for quick recall, 2) a memory system for long-term storage, and 3) a sub-system that determines which memory system to use for a particular example.
Revised: FearNet has three brain-inspired sub-systems: 1) a recent memory system for quick recall, 2) a memory system for long-term storage, and 3) a sub-system that determines which memory system to use for a particular example.

Original: FearNet mitigates catastrophic forgetting by consolidating recent memories into long-term storage using pseudorehearsal (Robins, 1995).
Revised: FearNet mitigates catastrophic forgetting by consolidating recent memories into long-term storage using pseudorehearsal (Robins, 1995).

Original: Pseudorehearsal allows the network to revisit previous memories during incremental training without the need to store previous training examples, which is more memory efﬁcient.
Revised: Pseudorehearsal allows the network to revisit previous memories during incremental training without the need to store previous training examples, which is more memory efﬁcient.

Original: Problem Formulation: Here, incremental class learning consists of T study-sessions.
Revised: Problem Formulation: Here, incremental class learning consists of T study-sessions.

Original: At time t , the learner receives a batch of data B t , which contains N t labeled training samples, i.e., B t = { ( x j , y j ) } N t j =1 , where x j ∈ R d is the input feature vector to be classiﬁed and y j is its corresponding label.
Revised: At time t , the learner receives a batch of data B t , which contains N t labeled training samples, i.e., B t = { ( x j , y j ) } N t j =1 , where x j ∈ R d is the input feature vector to be classiﬁed and y j is its corresponding label.

Original: The number of training samples N t may vary between sessions, and  a study-session is not assumed to be indepen dent and identically distributed (iid).
Revised: The number of training samples N t may vary between sessions, and the inside a study-session is not assumed to be independent and identically distributed (iid).

Original: During a  session, the learner only has access to its current batch, but it may use its own memory to store information from prior study sessions the as the model’s “base-knowledge
Revised: During a study session, the learner only has access to its current batch, but it may use its own memory to store information from prior study sessions.

Original: ” which contains exemplars from M ≥ 1 classes.
Revised: refer to the session as the model’s “base-knowledge,” which contains exemplars from M ≥ 1 classes.

Original: The batches learned in all subsequent sessions contain only one class, i.e., all y j will be identical within those sessions
Revised: The batches learned in all subsequent sessions contain only one class, i.e., all y j will be identical within those sessions.

Original: Novel Contributions:
Revised: Novel Contributions:

Original: Our contributions include:
Revised: Our contributions include:

Original: FearNet’s architecture includes three neural networks: one inspired by the hippocampal complex (HC) for recent memories, one inspired by the medial prefrontal cortex (mPFC) for long-term storage, and one inspired by the basolateral amygdala (BLA) that determines whether to use HC or mPFC for recall.
Revised: FearNet’s architecture includes three neural networks: one inspired by the hippocampal complex (HC) for recent memories, one inspired by the medial prefrontal cortex (mPFC) for long-term storage, and one inspired by the basolateral amygdala (BLA) that determines whether to use HC or mPFC for recall.

Original: Motivated by rapid eye movement (REM) sleep, FearNet employs a generative autoencoder for pseudorehearsal, which mitigates catastrophic forgetting by generating previously learned examples that are replayed alongside novel information during consolidation.
Revised: Motivated by rapid eye movement (REM) sleep, FearNet employs a generative autoencoder for pseudorehearsal, which mitigates catastrophic forgetting by generating previously learned examples that are replayed alongside novel information during consolidation.

Original: This process does not involve storing previous training data.
Revised: This process does not involve storing previous training data.

Original: FearNet achieves state-of-the-art results on large image and audio datasets with a relatively small memory footprint, demonstrating how dual-memory models can be scaled.
Revised: FearNet achieves state-of-the-art results on large image and audio datasets with a relatively small memory footprint, demonstrating how dual-memory models can be scaled.

Original:  R ELATED WORK
Revised:  R ELATED W

Revised: ORK

Original: Catastrophic forgetting in DNNs occurs due to the plasticity-stability dilemma (Abraham & Robins, 2005).
Revised: Catastrophic forgetting in DNNs occurs due to the plasticity-stability dilemma (Abraham & Robins, 2005).

Original: If the network is too plastic, older memories will quickly be overwritten; however, if the network is too stable, it is unable to learn new data.
Revised: If the network is too plastic, older memories will quickly be overwritten; however, if the network is too stable, it is unable to learn new data.

Original: This problem was recognized almost 30 years ago.
Revised: This problem was recognized almost 30 years ago (McCloskey & Cohen, 1989).

Original: In French (1999), methods developed in the 1980s and 1990s are extensively discussed, and French argued that mitigating catastrophic forgetting would require having two separate memory centers: one for the long-term storage of older memories and another to quickly process new information as it comes in.
Revised: In French (1999), methods developed in the 1980s and 1990s are extensively discussed, and French argued that mitigating catastrophic forgetting would require having two separate memory centers: one for the long-term storage of older memories and another to quickly process new information as it comes in.

Original: He also theorized that this type of dual-memory system would be capable of consolidating memories from the fast learning memory center to long-term storage.
Revised: He also theorized that this type of dual-memory system would be capable of consolidating memories from the fast learning memory center to longterm storage.

Revised: Catastrophic forgetting often occurs when a system is trained on non-iid data.

Revised: One strategy for reducing this phenomenon is to mix old examples with new examples, which simulates iid conditions.

Revised: For example, if the system learns ten classes in a study session and then needs to learnnew classes in a later study session, rehearsal would mix examples from the ﬁrst study session into the later study session.

Original: One of the earliest methods for reducing catastrophic forgettingis rehearsal (Hetherington & Seidenberg, 1989).
Revised: This method is known as rehearsal, and it is one of the earliest methods for reducing catastrophic forgetting (Hetherington & Seidenberg, 1989).

Original: In rehearsal, the new training examples in a study session are mixed with a random selection of old training examples from previous study sessions, which is a kind of memory replay.
Revised: Rehearsal essentially uses an external memory to strengthen the model’s representations for examples learned previously, so that they are not overwritten when learning data from new classes.

Original: Rehearsal reduces forgetting, but performance is still worse than ofﬂine models.
Revised: Rehearsal reduces forgetting, but performance is still worse than ofﬂine models.

Original: Moreover, rehearsal requires storing all of the training data.
Revised: Moreover, rehearsal requires storing all of the training data.

Original: Robins (1995) argued that storing of training examples was inefﬁcient and of “little interest,” so he introduced pseudorehearsal.
Revised: Robins (1995) argued that storing of training examples was inefﬁcient and of “little interest,” so he introduced pseudorehearsal.

Original: Rather than replaying past training data, in pseudorehearsal, the algorithm generates new examples for a given class.
Revised: Rather than replaying past training data, in pseudorehearsal, the algorithm generates new examples for a given class.

Original: In Robins (1995), this was done by creating random input vectors, having the network assign them a label, and then mixing them into the new training data.
Revised: In Robins (1995), this was done by creating random input vectors, having the network assign them a label, and then mixing them into the new training data.

Original: This idea was revived in Draelos et al.
Revised: This idea was revived in Draelos et al.

Original: (2017), where a generative autoencoder was used to create pseudo-examples for unsupervised incremental learning.
Revised: (2017), where a generative autoencoder was used to create pseudo-examples for unsupervised incremental learning.

Original: This method was the inspiration for memory consolidation in FearNet.
Revised: This method inspired FearNet’s approach to memory consolidation.

Revised: Pseudorehearsal is related to memory replay that occurs in mammalian brains, which involves reactivation of recently encoded memories in HC so that they can be integrated into long-term storage in mPFC (Rasch & Born, 2013).

Original: Recently there has been renewed interest in solving catastrophic forgetting in supervised learning.
Revised: Recently there has been renewed interest in solving catastrophic forgetting in supervised learning.

Original: Many new methods are designed to mitigate catastrophic forgetting when each study session contains a permuted version of the entire training dataset (see Goodfellow et al.
Revised: Many new methods are designed to mitigate catastrophic forgetting when each study session contains a permuted version of the entire training dataset (see Goodfellow et al.

Original: Unlike incre- mental class learning, all labels are contained in each study session.
Revised: Unlike incremental class learning, all labels are contained in each study session.

Original: PathNet uses an evolutionary algorithm to ﬁnd the optimal path through a large DNN, and then freezes the weights along that path (Fernando et al., 2017).
Revised: PathNet uses an evolutionary algorithm to ﬁnd the optimal path through a large DNN, and then freezes the weights along that path (Fernando et al., 2017).

Original: It assumes all classes are seen in each study session, and it is not capable of incremental class learning.
Revised: It assumes all classes are seen in each study session, and it is not capable of incremental class learning.

Original: Elastic Weight Consolidation (EWC) employs a regularization scheme that redirects plasticity to the weights that are least important to previously learned study sessions (Kirkpatrick et al., 2017).
Revised: Elastic Weight Consolidation (EWC) employs a regularization scheme that redirects plasticity to the weights that are least important to previously learned study sessions (Kirkpatrick et al., 2017).

Original: After EWC learns a study session, it uses the training data to build a
Revised: After EWC learns a study session, it uses the training data to build a

Original: Fisher matrix that determines the importance of each feature to the classiﬁcation task it just learned.
Revised: Fisher matrix that determines the importance of each feature to the classiﬁcation task it just learned.

Original: EWC was shown to work poorly at incremental class learning in Kemker et al.
Revised: EWC was shown to work poorly at incremental class learning in Kemker et al.

Original: The Fixed Expansion Layer (FEL) model mitigates catastrophic forgetting by using sparse updates (Coop et al., 2013).
Revised: The Fixed Expansion Layer (FEL) model mitigates catastrophic forgetting by using sparse updates (Coop et al., 2013).

Original: FEL uses two hidden layers, where the second hidden layer (i.e., the FEL layer) has connectivity constraints.
Revised: FEL uses two hidden layers, where the second hidden layer (i.e., the FEL layer) has connectivity constraints.

Original: The FEL layer is much larger than the ﬁrst hidden layer, is sparsely populated with excitatory and inhibitory weights, and is not updated during training.
Revised: The FEL layer is much larger than the ﬁrst hidden layer, is sparsely populated with excitatory and inhibitory weights, and is not updated during training.

Original: This limits learning of dense shared representations, which reduces the risk of learning interfering with old memories.
Revised: This limits learning of dense shared representations, which reduces the risk of learning interfering with old memories.

Original: FEL requires a large number of units to work well (Kemker et al., 2017).
Revised: FEL requires a large number of units to work well (Kemker et al., 2018). [Figure] C l a ss A cc u r a c y o n F i r s t

Original: [Figure]
Revised: [Figure]

Revised: l

Revised: [Figure]

Revised: e s [

Revised: [Figure]

Revised: heavily on the number of exemplars per class (EPC) that it stores.

Original:  Gepperth & Karaoguz (2016) introduced a new approach for incremental learning, which we call GeppNet.
Revised: Reducing severely Gepperth & Karaoguz (2016) introduced a new approach for incremental learning, which we call GeppNet.

Original: GeppNet uses a self-organizing map (SOM) to reorganize the input onto a two-dimensional lattice.
Revised: GeppNet uses a self-organizing map (SOM) to reorganize the input onto a two-dimensional lattice.

Original: This serves as a long-term memory, which is fed into a simple linear layer for classiﬁcation.
Revised: This serves as a long-term memory, which is fed into a simple linear layer for classiﬁcation.

Original: After the SOM is initialized, it can only be updated if the input is sufﬁciently novel.
Revised: After the SOM is initialized, it can only be updated if the input is sufﬁciently novel.

Original: This prevents the model from forgetting older data too quickly.
Revised: This prevents the model from forgetting older data too quickly.

Original: GeppNet also uses rehearsal using all previous training data.
Revised: GeppNet also uses rehearsal using all previous training data.

Original: A variant of GeppNet, GeppNet+STM, uses a ﬁxed-size memory buffer to store novel examples.
Revised: A variant of GeppNet, GeppNet+STM, uses a ﬁxed-size memory buffer to store novel examples.

Original: When this buffer is full, it replaces the oldest example.
Revised: When this buffer is full, it replaces the oldest example.

Original: During pre-deﬁned intervals, the buffer is used to train the model.
Revised: During pre-deﬁned intervals, the buffer is used to train the model.

Original: GeppNet+STM is better at retaining base-knowledge since it only trains during its consolidation phase, but the
Revised: GeppNet+STM is better at retaining base-knowledge since it only trains during its consolidation phase, but the

Original: STM-free version learns new data better because itis updates the model on every novel labeled input.
Revised: STM-free version learns new data better because it updates the model on every novel labeled input.

Original: iCaRL  is an incremental class learning framework developed by Rebufﬁ et al.
Revised: iCaRL (Rebufﬁ et al., 2017) is an incremental class learning framework.

Original: Rather than directly using a DNN for classiﬁcation, they focus on using it for supervised representation learning.
Revised: Rather than directly using a DNN for classiﬁcation, iCaRL uses it for supervised representation learning.

Original: During a study session, iCaRL updates a DNN using the study session’s data and a set of J stored examples fromeach class observed in earlier sessions ( J = 20 in their paper), which is a kind of rehearsal.
Revised: During a study session, iCaRL updates a DNN using the study session’s data and a set of J stored examples from earlier sessions ( J = 2 , 000 for CIFAR-100 in their paper), which is a kind of rehearsal.

Original: After a study session, the J examples retained are carefully chosen using herding.
Revised: After a study session, the J examples retained are carefully chosen using herding.

Revised: After learning the entire dataset, iCaRL has retained J/T exemplars per class (e.g., J/T = 20 for CIFAR-100).

Original: The
Revised: The

Original: DNN in iCaRL is then used to compute an embedding for each stored example, and then the mean embedding for each class seen is computed.
Revised: DNN in iCaRL is then used to compute an embedding for each stored example, and then the mean embedding for each class seen is computed.

Original: To classify a new instance, the DNN is used to compute an embedding for it, and then the class with the nearest mean embedding is assigned.
Revised: To classify a new instance, the DNN is used to compute an embedding for it, and then the class with the nearest mean embedding is assigned.

Original: iCaRL’s performance is heavily inﬂuenced by the number of examples it stores, as shown in Fig.
Revised: iCaRL’s performance is heavily inﬂuenced by the number of examples it stores, as shown in Fig.

Original:  M AMMALIAN M EMORY : N EUROSCIENCE AND M ODELS
Revised:  M AMMALIAN M EMORY : N EUROSCIENCE AND M ODELS

Original: FearNet is heavily inspired by the dual-memory model of mammalian memory (McClelland et al., 1995), which has considerable experimental support from neuroscience (Frankland et al., 2004;
Revised: FearNet is heavily inspired by the dual-memory model of mammalian memory (McClelland et al., 1995), which has considerable experimental support from neuroscience (Frankland et al., 2004;

Original: Takashima et al., 2006; Kitamura et al., 2017; Bontempi et al., 1999; Taupin & Gage, 2002; Gais et al., 2007).
Revised: Takashima et al., 2006; Kitamura et al., 2017; Bontempi et al., 1999; Taupin & Gage, 2002; Gais et al., 2007).

Original: This theory proposes that HC and mPFC operate as complementary memory systems, where HC is responsible for recalling recent memories and mPFC is responsible for recalling remote (mature) memories.
Revised: This theory proposes that HC and mPFC operate as complementary memory systems, where HC is responsible for recalling recent memories and mPFC is responsible for recalling remote (mature) memories.

Original: GeppNet is the most recent DNN to be based on this theory, but it was also independently explored in the 1990s in French (1997) and Ans & Rousset (1997).
Revised: GeppNet is the most recent DNN to be based on this theory, but it was also independently explored in the 1990s in French (1997) and Ans & Rousset (1997).

Original: In this section, we review some of the evidence for the dual-memory model.
Revised: In this section, we review some of the evidence for the dual-memory model.

Original: One of the major reasons why HC is thought to be responsible for recent memories is that if HC is bilaterally destroyed, then anterograde amnesia occurs with old memories for semantic information preserved.
Revised: One of the major reasons why HC is thought to be responsible for recent memories is that if HC is bilaterally destroyed, then anterograde amnesia occurs with old memories for semantic information preserved.

Original: One mechanism HC may use to facilitate creating new memories is adult neurogenesis.
Revised: One mechanism HC may use to facilitate creating new memories is adult neurogenesis.

Original: This occurs in HC’s dentate gyrus (Altman, 1963; Eriksson et al., 1998).
Revised: This occurs in HC’s dentate gyrus (Altman, 1963; Eriksson et al., 1998).

Original: The new neurons have higher initial plasticity, but it reduces as time progresses (Deng et al., 2010).
Revised: The new neurons have higher initial plasticity, but it reduces as time progresses (Deng et al., 2010).

Original: In contrast, mPFC is responsible for the recall of remote (long-term) memories (Bontempi et al., 1999).
Revised: In contrast, mPFC is responsible for the recall of remote (long-term) memories (Bontempi et al., 1999).

Original: Taupin & Gage (2002) and Gais et al.
Revised: Taupin & Gage (2002) and Gais et al.

Original: (2007) showed that mPFC plays a strong role in memory consolidation during REM sleep.
Revised: (2007) showed that mPFC plays a strong role in memory consolidation during REM sleep.

Original: McClelland et al.
Revised: McClelland et al.

Original: and Euston et al.
Revised: and Euston et al.

Original: (2012) theorized that, during sleep, HC reactivates recent memories to prevent forgetting which causes these recent memories to replay in mPFC as well, with dreams possibly being caused by this process.
Revised: (2012) theorized that, during sleep, HC reactivates recent memories to prevent forgetting which causes these recent memories to replay in mPFC as well, with dreams possibly being caused by this process.

Original: After memories are transferred from HC to mPFC, evidence suggests that corresponding memory in HC is erased (Poe, 2017).
Revised: After memories are transferred from HC to mPFC, evidence suggests that corresponding memory in HC is erased (Poe, 2017).

Original: Recently, Kitamura et al.
Revised: Recently, Kitamura et al.

Original: (2017) performed contextual fear conditioning (CFC) experiments in mice to trace the formation and consolidation of recent memories to long-term storage.
Revised: (2017) performed contextual fear conditioning (CFC) experiments in mice to trace the formation and consolidation of recent memories to long-term storage.

Original: CFC experiments involve shocking mice while subjecting them to various visual stimuli (i.e., colored lights).
Revised: CFC experiments involve shocking mice while subjecting them to various visual stimuli (i.e., colored lights).

Original: They found that BLA, which is responsible for regulating the brain’s fear response, would shift where it retrieved the corresponding memory from (HC or mPFC) as that memory was consolidated over time.
Revised: They found that BLA, which is responsible for regulating the brain’s fear response, would shift where it retrieved the corresponding memory from (HC or mPFC) as that memory was consolidated over time.

Original: FearNet follows the memory consolidation theory proposed by Kitamura et al.
Revised: FearNet follows the memory consolidation theory proposed by Kitamura et al.

Original:  T HE F EAR N ET M ODEL
Revised:  T HE F EAR N ET M ODEL

Original: FearNet has two complementary memory centers, 1) a short-term memory system that immediately learns new information for recent recall (HC) and 2) a DNN for the storage of remote memories (mPFC).
Revised: FearNet has two complementary memory centers, 1) a short-term memory system that immediately learns new information for recent recall (HC) and 2) a DNN for the storage of remote memories (mPFC).

Original: FearNet also has a separate BLA network that determines which memory center contains the associated memory required for prediction.
Revised: FearNet also has a separate BLA network that determines which memory center contains the associated memory required for prediction.

Original: During sleep phases, FearNet uses a generative model to consolidate data from HC to mPFC through pseudorehearsal.
Revised: During sleep phases, FearNet uses a generative model to consolidate data from HC to mPFC through pseudorehearsal.

Revised: Pseudocode for FearNet is provided in the supplemental material.

Revised: Because the focus of our work is not representation learning, we use pre-trained ResNet embeddings to obtain features that are fed to FearNet.

Original: 4. D UAL -M EMORY S TORAGE
Revised: 4. D UAL -M EMORY S TORAGE

Original: FearNet’s HC model is a variant of a probabilistic neural network (Specht, 1990).
Revised: FearNet’s HC model is a variant of a probabilistic neural network (Specht, 1990).

Original: HC computes class conditional probabilities using stored training examples.
Revised: HC computes class conditional probabilities using stored training examples.

Original: Formally, HC estimates the probability that an input feature vector x belongs to class k as
Revised: Formally, HC estimates the probability that an input feature vector x belongs to class k as

Original: [Equation]
Revised: [Equation]

Original: if HC contains instances of class k otherwise (2) where (cid:15) > 0 is a regularization parameter and u k,j is the j ’th stored exemplar in HC for class k .
Revised: if HC contains instances of class k otherwise (2) where (cid:15) > 0 is a regularization parameter and u k,j is the j ’th stored exemplar in HC for class k .

Original: All exemplars are removed from HC after they are consolidated in mPFC.
Revised: All exemplars are removed from HC after they are consolidated in mPFC.

Original: FearNet’s mPFC is implemented using a DNN trained both to reconstruct its input using a symmetric encoder-decoder (autoencoder) and to compute P PFC ( C = k | x ) .
Revised: FearNet’s mPFC is implemented using a DNN trained both to reconstruct its input using a symmetric encoder-decoder (autoencoder) and to compute P PFC ( C = k | x ) .

Original: The autoencoder enables us to use pseudorehearsal, which is described in more detail in Sec. 4.2.
Revised: The autoencoder enables us to use pseudorehearsal, which is described in more detail in Sec. 4.2.

Original: The loss function for mPFC is
Revised: The loss function for mPFC is

Original: [Equation]
Revised: [Equation]

Original: where L class is the supervised classiﬁcation loss and L recon is the unsupervised reconstruction loss, as illustrated in Fig. 3(a).
Revised: where L class is the supervised classiﬁcation loss and L recon is the unsupervised reconstruction loss, as illustrated in Fig. 3(a).

Original: For L class , we use standard softmax loss.
Revised: For L class , we use standard softmax loss.

Original: L recon is the weighted sum of  mean squared error (MSE) reconstruction losses from each layer, which is given by
Revised: L recon is the weighted sum of [Figure] mean squared error (MSE) reconstruction losses from each layer, which is given by

Original: [Equation]
Revised: [Equation]

Original: where M is the number of layers in the encoder/decoder, L recon,j is the reconstruction loss for layer j ,  and λ j is the reconstruction weight for that layer.
Revised: where M is the number of mPFC layers, H j is the number of hidden units in layer j , h encoder, ( i,j ) and h decoder, ( i,j ) are the outputs of the encoder/decoder at layer j respectively, and λ j is the reconstruction weight for that layer.

Original: mPFC is similar to a Ladder Networkarchitecture (Rasmus et al., 2015), which combines classiﬁcation and reconstruction to improve regularization, especially during low-shot learning.
Revised: mPFC is similar to a Ladder Network (Rasmus et al., 2015), which combines classiﬁcation and reconstruction to improve regularization, especially during lowshot learning.

Original: The λ j hyperparameters were found empirically, with λ 0 being largest and decreasing for deeper layers (see supplementary material).
Revised: The λ j hyperparameters were found empirically, with λ 0 being largest and decreasing for deeper layers (see supplementary material).

Original: This prioritizes the reconstruction task so that the generated pseudo-examplesare more realistic.
Revised: This prioritizes the reconstruction task, which makes the generated pseudo-examples more realistic.

Original: [Figure] After training mPFC using the data stored in HC, all of the data in HC is pushed through the encoder to extract a dense feature representation of the originaldata. Using this data,  we compute a mean feature vector µ c and covariance matrix Σ c for each class c .
Revised: When training is completed during a study session, all of the data in HC is pushed through the encoder to extract a dense feature representation of the original data, and then we compute a mean feature vector µ c and covariance matrix Σ c for each class c .

Original: Thesevalues are stored and used to generate pseudo-examples during consolidation (see Sec. 4.2).
Revised: These are stored and used to generate pseudo-examples during consolidation (see Sec. 4.2).

Revised: We study FearNet’s performance as a function of how much data is stored in HC in Sec. 6.2.

Original: 4. P SEUDOREHEARSAL FOR M EMORY C ONSOLIDATION
Revised: P SEUDOREHEARSAL FOR M EMORY C ONSOLIDATION

Original: During FearNet’s sleep phase, the original inputs stored in HC are transferred to mPFC using pseudo-examples created using an autoencoder.
Revised: During FearNet’s sleep phase, the original inputs stored in HC are transferred to mPFC using pseudo-examples created by an autoencoder.

Original: This process  known as intrinsic replay, and it was used by Draelos et al.
Revised: This process is known as intrinsic replay, and it was used by Draelos et al.

Original: (2017) for unsupervised learning.
Revised: (2017) for unsupervised learning.

Original: Using the class statistics from the encoder, pseudo-examples for a class c are generated by sampling a Gaussian with mean µ c and covariance matrix Σ c to obtain ˆ x rand .
Revised: Using the class statistics from the encoder, pseudo-examples for a class c are generated by sampling a Gaussian with mean µ c and covariance matrix Σ c to obtain ˆ x rand .

Original: Then, ˆ x rand is passed through the decoder to generate a pseudo-example.
Revised: Then, ˆ x rand is passed through the decoder to generate a pseudo-example.

Original: To create a balanced training set, for each class that mPFC has learned, we generate (cid:100) m (cid:101) pseudo-examples, where m is the average number of examples per class stored in HC.
Revised: To create a balanced training set, for each class that mPFC has learned, we generate (cid:100) m (cid:101) pseudo-examples, where m is the average number of examples per class stored in HC.

Original: The pseudo-examples are mixed with the data in HC, and the mixture is used to ﬁne-tune mPFC using backpropagation.
Revised: The pseudo-examples are mixed with the data in HC, and the mixture is used to ﬁne-tune mPFC using backpropagation.

Original: After consolidation, all units in HC are deleted.
Revised: After consolidation, all units in HC are deleted.

Original: 4. N ETWORK S ELECTION USING BLA
Revised: 4. N ETWORK S ELECTION USING BLA

Original: During prediction, FearNet uses the BLA network (Fig. 3(b)) to determine whether to classify an input x using HC or mPFC.
Revised: During prediction, FearNet uses the BLA network (Fig. 3(b)) to determine whether to classify an input x using HC or mPFC.

Original: This can be challenging because if HC has only been trained on one class, it will put all of its probability mass on that class, whereas mPFC will likely be less conﬁdent.
Revised: This can be challenging because if HC has only been trained on one class, it will put all of its probability mass on that class, whereas mPFC will likely be less conﬁdent.

Original: The output of BLA is given by A ( x ) and will be a value between 0 and 1, with a 1 indicating mPFC should be used.
Revised: The output of BLA is given by A ( x ) and will be a value between 0 and 1, with a 1 indicating mPFC should be used.

Original: BLA is trained after each study session using only the data in HC and with pseudoexamples generated with mPFC, using the same procedure described in Sec. 4.2.
Revised: BLA is trained after each study session using only the data in HC and with pseudoexamples generated with mPFC, using the same procedure described in Sec. 4.2.

Original: Instead of using solely BLA to determine which network to use, we found that combining its output with those of mPFC and HC improved results.
Revised: Instead of using solely BLA to determine which network to use, we found that combining its output with those of mPFC and HC improved results.

Original: The predicted class ˆ y is computed as
Revised: The predicted class ˆ y is computed as

Original: [Equation]
Revised: [Equation]

Revised: otherwise

Revised: [Equation]

Revised: [Equation]

Original: where
Revised: where

Original: [Equation]
Revised: [Equation]

Original: ψ is the probability of the class prediction made by HC weighted by the conﬁdence that the associated memory is actually stored in HC.
Revised: ψ is the probability of the class according to HC weighted by the conﬁdence that the associated memory is actually stored in HC.

Original: BLA has the same number of layers/units as the mPFC encoder, and uses a logistic output unit.
Revised: BLA has the same number of layers/units as the mPFC encoder, and uses a logistic output unit.

Revised: We discuss alternative BLA models in supplemental material.

Original:  E XPERIMENTAL S ETUP
Revised:  E XPERIMENTAL S ETUP

Original: Evaluating Incremental Learning Performance.
Revised: Evaluating Incremental Learning Performance.

Original: To evaluate how well the incrementally trained models perform compared to an ofﬂine model, we use the three metrics proposed in Kemker et al.
Revised: To evaluate how well the incrementally trained models perform compared to an ofﬂine model, we use the three metrics proposed in Kemker et al.

Original: After each study session t in which a model learned a new class k , we compute the model’s test accuracy on the new class ( α new,t ), the accuracy on the base-knowledge ( α base,t ), and the accuracy of all of the test data seen to this point ( α all,t ).
Revised: After each study session t in which a model learned a new class k , we compute the model’s test accuracy on the new class ( α new,t ), the accuracy on the base-knowledge ( α base,t ), and the accuracy of all of the test data seen to this point ( α all,t ).

Original: After all T study sessions are complete, a model’s ability to retain the base-knowledge is given by Ω base = 1 T − 1 (cid:80) Tt =2 α base,t α offline , where α offline is the accuracy of a multi-layer perceptron (MLP) trained ofﬂine (i.e., it is given all of the training data at once).
Revised: After all T study sessions are complete, a model’s ability to retain the base-knowledge is given by Ω base = [Equation] offline , where α offline is the accuracy of a multi-layer perceptron (MLP) trained ofﬂine (i.e., it is given all of the training data at once).

Original: The model’s ability to immediately recall new information is measured by Ω new = 1 T − 1 (cid:80)
Revised: The model’s ability to immediately recall new information is measured by Ω new = 1 T − 1 (cid:80)

Original: Tt =
Revised: Tt =

Original: α new,t .
Revised: α new,t .

Original: Finally, we measure how well the model does on all available test data with Ω all = 1 T − 1 (cid:80) Tt
Revised: Finally, we measure how well the model does on all available test data with Ω all = 1 T − 1 (cid:80) Tt

Original: =

Revised: =

Original: α all,t α offline .
Revised: α all,t α offline .

Original: The Ω all metric shows how well new memories are integrated into the model over time.
Revised: The Ω all metric shows how well new memories are integrated into the model over time.

Original: For all of the metrics, higher values indicate superior performance.
Revised: For all of the metrics, higher values indicate superior performance.

Original: Both Ω base and Ω all are relative to an ofﬂine MLP model, so a value of 1 indicates that a model has similar performance to the ofﬂine baseline.
Revised: Both Ω base and Ω all are relative to an ofﬂine MLP model, so a value of 1 indicates that a model has similar performance to the ofﬂine baseline.

Original: This allows results across datasets to be better compared.
Revised: This allows results across datasets to be better compared.

Original: Note that Ω base > 1 and Ω all > 1 only if the incremental learning algorithm is more accurate than the ofﬂine model, which can occur due to better regularization strategies employed by different models.
Revised: Note that Ω base > 1 and Ω all > 1 only if the incremental learning algorithm is more accurate than the ofﬂine model, which can occur due to better regularization strategies employed by different models.

Original: [Table]
Revised: [Figure]

Original: We evaluate all of the models on three benchmark datasets (Table 1): CIFAR-100, CUB-200, and AudioSet.
Revised: We evaluate all of the models on three benchmark datasets (Table 1): CIFAR-100, CUB-200, and AudioSet.

Original: CIFAR-100 is a popular image classiﬁcation dataset containing 100 mutually-exclusive object categories, and it was used in Rebufﬁ et al.
Revised: CIFAR-100 is a popular image classiﬁcation dataset containingmutually-exclusive object categories, and it was used in Rebufﬁ et al.

Original: (2017) to evaluate iCaRL.
Revised: (2017) to evaluate iCaRL.

Original: All images are 32 × 32 pixels.
Revised: All images are 32 × 32 pixels.

Original: CUB-200 is a ﬁne-grained image classiﬁcation dataset containing high resolution images of 200 different bird species (Welinder et al., 2010).
Revised: CUB-200 is a ﬁne-grained image classiﬁcation dataset containing high resolution images of 200 different bird species (Welinder et al., 2010).

Original: We use the 2011 version of the dataset.
Revised: We use the 2011 version of the dataset.

Original: AudioSet is an audio classiﬁcation dataset (Gemmeke et al., 2017).
Revised: AudioSet is an audio classiﬁcation dataset (Gemmeke et al., 2017).

Original: We use the variant of AudioSet used by Kemker et al.
Revised: We use the variant of AudioSet used by Kemker et al.

Original: (2017), which contains a 100 class subset such that none of the classes were super- or sub-classes of one another.
Revised: (2018), which contains a 100 class subset such that none of the classes were super- or sub-classes of one another.

Original: Also, since the AudioSet data samples can have more than one class, the chosen samples had only one of the 100 classes chosen in this subset.
Revised: Also, since the AudioSet data samples can have more than one class, the chosen samples had only one of the 100 classes chosen in this subset.

Original: For CIFAR-100 and CUB-200, we extract ResNet-50 image embeddings as the input to each of the models, where ResNet-50 was pre-trained on ImageNet (He et al., 2016).
Revised: For CIFAR-100 and CUB-200, we extract ResNet-50 image embeddings as the input to each of the models, where ResNet-50 was pre-trained on ImageNet (He et al., 2016).

Original: We use the output after the mean pooling layer and normalize the features to unit length.
Revised: We use the output after the mean pooling layer and normalize the features to unit length.

Original: For AudioSet, we use the audio
Revised: For AudioSet, we use the audio

Original: CNN embeddings produced by pre-training the model on the YouTube-8M dataset (Abu-El-Haija et al., 2016).
Revised: CNN embeddings produced by pre-training the model on the YouTube-8M dataset (Abu-El-Haija et al., 2016).

Original: We use the pre-extracted AudioSet feature embeddings, which represent ten second sound clips (i.e., ten 128-dimensional vectors concatenated in order).
Revised: We use the pre-extracted AudioSet feature embeddings, which represent ten second sound clips (i.e., ten 128-dimensional vectors concatenated in order).

Original: Comparison Models .
Revised: Comparison Models .

Original: We compare FearNet to FEL, GeppNet, GeppNet+STM,  and iCaRL. FEL,
Revised: We compare FearNet to FEL, GeppNet, GeppNet+STM, iCaRL, and an onenearest neighbor (1-NN).

Original:  GeppNet, and GeppNet+STM were chosen due to their previously reported efﬁcacy at incremental class learning in Kemker et al.
Revised: FEL, GeppNet, and GeppNet+STM were chosen due to their previously reported efﬁcacy at incremental class learning in Kemker et al.

Original: We also compare against iCaRL, which was explicitly designed for  this task.
Revised: iCARL is explicitly designed for incremental class learning, and represents the state-of-the-art on this problem. We compare against 1-NN due to its similarity to our HC model.

Revised: 1-NN does not forget any previously observed examples, but it tends to have worse generalization error than parametric methods and requires storing all of the training data.

Original: In each of our experiments, all models take the same feature embedding as input for a given dataset.
Revised: In each of our experiments, all models take the same feature embedding as input for a given dataset.

Original: This required modifying iCaRL by turning its CNN into a fully connected network.
Revised: This required modifying iCaRL by turning its CNN into a fully connected network.

Original: We performed a hyperparameter search for each model/dataset combination to tune the number of units and layers (see Supplemental Materials). 
Revised: We performed a hyperparameter search for each model/dataset combination to tune the number of units and layers (see Supplemental Materials). [Figure] M e a n - C l a ss A cc u r a c

Revised: y

Revised: [ % ] o n C l a ss e s S ee n s o

Original: Training Parameters .
Revised: F a r [Figure] STM [Figure]

Revised: [Figure]

Revised: cc

Revised: [Figure]

Revised: [Figure]

Revised: o n

Revised: [Figure]

Revised: l

Revised: [Figure]

Revised: [Figure]

Revised: Training Parameters .

Original: FearNet was implemented in Tensorﬂow.
Revised: FearNet was implemented in Tensorﬂow.

Original: For mPFC and BLA, each fully connected layer uses an exponential linear unit activation function (Clevert et al., 2016).
Revised: For mPFC and BLA, each fully connected layer uses an exponential linear unit activation function (Clevert et al., 2016).

Original: The output of the encoder also connects to a softmax output layer.
Revised: The output of the encoder also connects to a softmax output layer.

Original: Xavier initialization is used to initialize all weight layers (Glorot & Bengio, 2010), and all of the biases are initialized to one.
Revised: Xavier initialization is used to initialize all weight layers (Glorot & Bengio, 2010), and all of the biases are initialized to one.

Original: BLA’s architecture is identical to mPFC’s encoder, except it has a logistic output unit, instead of a softmax layer.
Revised: BLA’s architecture is identical to mPFC’s encoder, except it has a logistic output unit, instead of a softmax layer.

Original: mPFC and BLA were trained using the NAdam optimizer.
Revised: mPFC and BLA were trained using NAdam.

Original: We train mPFC on the base-knowledge set for 1,000 epochs, consolidate HC over to mPFC for 60 epochs, and train BLA for 20 epochs.
Revised: We train mPFC on the base-knowledge set for 1, epochs, consolidate HC over to mPFC for 60 epochs, and train BLA for 20 epochs.

Original: Because mPFC’s decoder is vital to preserving memories, its learning rate is 1 / 100 times lower than the encoder.
Revised: Because mPFC’s decoder is vital to preserving memories, its learning rate is 1 / 100 times lower than the encoder.

Original: We performed a hyperparameter search for each dataset and model, varying the model shape (64-1,024 units), depth (2-4 layers), and how often to sleep (see Sec. 6.2).
Revised: We performed a hyperparameter search for each dataset and model, varying the model shape (64-1, units), depth (2-4 layers), and how often to sleep (see Sec. 6.2).

Original: Across datasets, mPFC and BLA performed best with two hidden layers, but the number of units per layer varied [Figure] ss [Figure]
Revised: Across datasets, mPFC and BLA performed best with two hidden layers, but the number of units per layer varied across datasets.

Original: [Figure]

Original: [Figure]

Original: a

Original: [Figure] [Figure] [Table] [Table]
Revised: The speciﬁc values used for each dataset are given in supplemental material.

Original: [Figure]

Original: [Table] [Figure] [Table] across speciﬁc are experiments, we found no beneﬁt to adding weight decay to mPFC, likely because the reconstruction task helps regularize the model.
Revised: In preliminary experiments, we found no beneﬁt to adding weight decay to mPFC, likely because the reconstruction task helps regularize the model.

Original:  E XPERIMENTAL R ESULTS
Revised:  E XPERIMENTAL R ESULTS

Original: Unless otherwise noted, each class is only seen in one unique study-session and the ﬁrst baseknowledge study session contains half the classes in the dataset.
Revised: Unless otherwise noted, each class is only seen in one unique study-session and the ﬁrst baseknowledge study session contains half the classes in the dataset.

Original: We perform additional experiments to study how changing the number of base-knowledge classes affects performance in Sec. 6.2.
Revised: We perform additional experiments to study how changing the number of base-knowledge classes affects performance in Sec. 6.2.

Original: Unless otherwise noted, FearNet sleeps every 10 study sessions across datasets.
Revised: Unless otherwise noted, FearNet sleeps every 10 study sessions across datasets.

Original: 6. S TATE - OF - THE -A RT C OMPARISON
Revised: 6. S TATE - OF - THE -A RT C OMPARISON

Original: Table 2 shows incremental class learning summary results for all ﬁve methods.
Revised: Table 2 shows incremental class learning summary results for all six methods.

Original: FearNet achieves the best Ω base and Ω all on all three datasets.
Revised: FearNet achieves the best Ω base and Ω all on all three datasets.

Original: Fig.
Revised: Fig.

Original: 4 shows that FearNet more closely resembles the ofﬂine MLP baseline than other methods.
Revised: 4 shows that FearNet more closely resembles the ofﬂine MLP baseline than other methods.

Original: Ω new measures test accuracy on the most recently trained class.
Revised: Ω new measures test accuracy on the most recently trained class.

Original: For FearNet, this measures the performance of HC and BLA.
Revised: For FearNet, this measures the performance of HC and BLA.

Original: Ω new does not account for how well the class was consolidated into mPFC which happens later during a sleep phase; however, Ω all does account for this.
Revised: Ω new does not account for how well the class was consolidated into mPFC which happens later during a sleep phase; however, Ω all does account for this.

Original: FEL achieves a high Ω new score because it is able to achieve nearly perfect test accuracy on every new class it learns, but this results in forgetting more quickly than FearNet.
Revised: FEL achieves a high Ω new score because it is able to achieve nearly perfect test accuracy on every new class it learns, but this results in forgetting more quickly than FearNet.

Revised: 1-NN is similar to our HC model; but on its own, it fails to generalize as well as FearNet, is memory inefﬁcient, and is slow to make predictions.

Original: The ﬁnal mean-class test accuracy for the ofﬂine MLP used to normalize the metrics is 69.9% for CIFAR-100, 59.8% for CUB-200, and 45.8% for AudioSet.
Revised: The ﬁnal mean-class test accuracy for the ofﬂine MLP used to normalize the metrics is 69.9% for CIFAR-100, 59.8% for CUB-200, and 45.8% for AudioSet.

Original: 6. A DDITIONAL E XPERIMENTS
Revised: 6. A DDITIONAL E XPERIMENTS

Original: Novelty Detection with BLA .
Revised: Novelty Detection with BLA .

Original: We evaluated the performance of BLA by comparing it to an oracle version of FearNet, i.e., a version that knew if the relevant memory was stored in either mPFC or
Revised: We evaluated the performance of BLA by comparing it to an oracle version of FearNet, i.e., a version that knew if the relevant memory was stored in either mPFC or

Original: HC.
Revised: HC.

Original: Table 3 shows that FearNet’s BLA does a good job at predicting which network to use; however, the decrease in Ω new suggests BLA is sometimes using mPFC when it should be using HC.
Revised: Table 3 shows that FearNet’s BLA does a good job at predicting which network to use; however, the decrease in Ω new suggests BLA is sometimes using mPFC when it should be using HC.

Original: [Table]
Revised: [Table]

Original: With BLA

Original: Oracle

Original: With BLA

Original: Oracle

Original: [Table]
Revised: [Table]

Original: BLA
Revised: 10 12 14 Number of Classes Stored Before Sleep 0.

Original: [Table]
Revised: P e r f

Original: [Figure]
Revised: o r m a n c e Ω base Ω new Ω all

Original: When should the model sleep?
Revised: When should the model sleep?

Original: To study how the frequency of memory consolidation affects FearNet’s performance, we trained FearNet on CUB-200 and varied the sleep frequency from 1-15 study sessions.
Revised: To study how the frequency of memory consolidation affects FearNet’s performance, we trained FearNet on CUB-200 and varied the sleep frequency from 1-15 study sessions.

Original: As shown in Fig. 5, when FearNet increases the number of classes it learns before sleeping, it is better able to retain its base-knowledge, but this reduces its ability to recall new information.
Revised: When FearNet increases the number of classes it learns before sleeping (Fig. 5), it is better able to retain its base-knowledge, but this reduces its ability to recall new information.

Original: In humans,it is known that sleep deprivation impairs new learning (Yoo et al., 2007), and that forgetting occurs during sleep (Poe, 2017).
Revised: In humans, sleep deprivation is known to impair new learning (Yoo et al., 2007), and that forgetting occurs during sleep (Poe, 2017).

Original: Each time FearNet sleeps, the mPFC weights are perturbed which can cause it to gradually forget older memories.
Revised: Each time FearNet sleeps, the mPFC weights are perturbed which can cause it to gradually forget older memories.

Original: Sleeping less causesFearNet’s HC’s recall performance to deteriorate.
Revised: Sleeping less causes HC’s recall performance to deteriorate.

Original: [Table]
Revised: [Table]

Original: FearNet was trained with various base-knowledge sets (column-header) and then incrementally trained on all remaining data.
Revised: FearNet was trained with various base-knowledge sets (column-header) and then incrementally trained on all remaining data.

Original: Multi-Modal Incremental Learning .
Revised: Multi-Modal Incremental Learning .

Original: As shown in
Revised: As shown in

Original: Sec. 6.1, FearNet can incrementally learn and retain information from a single dataset, but how does it perform if new inputs differ greatly from previously learned ones?
Revised: Sec. 6.1, FearNet can incrementally learn and retain information from a single dataset, but how does it perform if new inputs differ greatly from previously learned ones?

Original: This scenario is one of the ﬁrst shown to cause catastrophic forgetting in MLPs.
Revised: This scenario is one of the ﬁrst shown to cause catastrophic forgetting in MLPs.

Original: To study this, we trained
Revised: To study this, we trained

Original: FearNet to incrementally learn CIFAR-100 and AudioSet, which after training is a 200-way classiﬁcation problem.
Revised: FearNet to incrementally learn CIFAR-100 and AudioSet, which after training is a 200-way classiﬁcation problem.

Original: To do this, AudioSet’s features are zero-padded to make them the same length as CIFAR-100s.
Revised: To do this, AudioSet’s features are zero-padded to make them the same length as CIFAR-100s.

Original: Table 4 shows the performance of FearNet for three separate training paradigms: 1) FearNet learns CIFAR-100 as the baseknowledge and then incrementally learns AudioSet; 2) FearNet learns AudioSet as the baseknowledge and then incrementally learns CIFAR-100; and 3) the base-knowledge contains a 50/ split from both datasets with FearNet incrementally learning the remaining classes.
Revised: Table 4 shows the performance of FearNet for three separate training paradigms: 1) FearNet learns CIFAR-100 as the baseknowledge and then incrementally learns AudioSet; 2) FearNet learns AudioSet as the baseknowledge and then incrementally learns CIFAR-100; and 3) the base-knowledge contains a 50/ split from both datasets with FearNet incrementally learning the remaining classes.

Original: Our results suggest FearNet is capable of incrementally learning multi-modal information, if the model has a good starting point (high base-knowledge); however, if the model starts with lower base-knowledge performance (e.g., AudioSet), the model struggles to learn new information incrementally (see Supplemental Material for detailed plots).[Figure]
Revised: Our results suggest FearNet is capable of incrementally learning multi-modal information, if the model has a good starting point (high base-knowledge); however, if the model starts with lower base-knowledge performance (e.g., AudioSet), the model struggles to learn new information incrementally (see Supplemental Material for detailed plots).

Original: Base-Knowledge Effect on Performance .
Revised: Base-Knowledge Effect on Performance .

Original: In this section, we show how the size of the base-knowledge (i.e., number of classes) affects FearNet’s performance on CUB-200.
Revised: In this section, we examine how the size of the baseknowledge (i.e., number of classes) affects FearNet’s performance on CUB-200.

Original: To do this, we varied the size of the base-knowledge from 10150 classes, with the remaining classes learned incrementally.
Revised: To do this, we varied the size of the base-knowledge from 10-150 classes, with the remaining classes learned incrementally.

Original: Results are given in Fig.
Revised: Detailed plots are provided in the Supplemental Material.

Original: As the base-knowledge size increases, there is a noticeable increase in overall model performance because 1) PFC has a better learned representation from a larger quantity of data and 2) there are not as many incremental learning steps remaining for the dataset, so the base-knowledge performance is less perturbed.
Revised: As the base-knowledge size increases, there is a noticeable increase in overall model performance because 1) PFC has a better learned representation from a larger quantity of data and 2) there are not as many incremental learning steps remaining for the dataset, so the base-knowledge performance is less perturbed.

Original:  D ISCUSSION
Revised:  D ISCUSSION

Original: [Table]
Revised: FearNet’s mPFC is trained to both discriminate examples and also generate new examples. While the main use of mPFC’s generative abilities is to enable psuedorehearsal, this ability may also help make the model more robust to catastrophic forgetting. Gillies (1991) observed that unsupervised networks are more robust (but not immune) to catastrophic forgetting because there are no target outputs to be forgotten.

Original: CIFAR-100 and the amount of memory that would be required if these models were trained
Revised: Since the pseudoexample generator is learned as a unsupervised reconstruction task, this could explain why FearNet is slow to forget old information.

Original: [Table]
Revised: [Table]

Original: Table 5 shows the memory requirements for each model in Sec.
Revised: Table 5 shows the memory requirements for each model in Sec.

Original: 6.1 for learning CIFAR-100 and a hypothetical extrapolation for learning 1,000 classes.
Revised: 6.1 for learning CIFAR-100 and a hypothetical extrapolation for learning 1,000 classes.

Original: This chart accounts for a ﬁxed model capacity and storage of any data or class statistics.
Revised: This chart accounts for a ﬁxed model capacity and storage of any data or class statistics.

Original: FearNet’s memory footprint is comparatively small because it only stores class statistics rather than some or all of the raw training data, which makes it better suited for deployment.
Revised: FearNet’s memory footprint is comparatively small because it only stores class statistics rather than some or all of the raw training data, which makes it better suited for deployment.

Original: An open question is how to deal with storage and updating of class statistics if classes are seen in more than one study sessions.
Revised: An open question is how to deal with storage and updating of class statistics if classes are seen in more than one study sessions.

Original: One possibility is to use a running update for the class means and covariances, but it may be better to favor the data from the most recent study session due to learning in the autoencoder.
Revised: One possibility is to use a running update for the class means and covariances, but it may be better to favor the data from the most recent study session due to learning in the autoencoder.

Original: FearNet assumed that the output of the mPFC encoder was normally distributed for each class, which may not be the case.
Revised: FearNet assumed that the output of the mPFC encoder was normally distributed for each class, which may not be the case.

Original: It would be interesting to consider modeling the classes with a more complex model, e.g., a Gaussian Mixture Model.
Revised: It would be interesting to consider modeling the classes with a more complex model, e.g., a Gaussian Mixture Model.

Original: Robins (1995) showed that pseudorehearsal worked reasonably well with randomly generated vectors because they were associated with the weights of a given class.
Revised: Robins (1995) showed that pseudorehearsal worked reasonably well with randomly generated vectors because they were associated with the weights of a given class.

Original: Replaying these vectors strengthened their corresponding weights, which could be what is happening with the pseudo-examples generated by FearNet’s decoder.
Revised: Replaying these vectors strengthened their corresponding weights, which could be what is happening with the pseudo-examples generated by FearNet’s decoder.

Original: [Table]
Revised: [Table]

Original: instead of a full covariance matrix on

Original: CIFAR-100.

Original: The largest impact on model size is the stored covariance matrix Σ c for each class.
Revised: The largest impact on model size is the stored covariance matrix Σ c for each class.

Original: We tested a variant of FearNet that used a diagonal Σ c instead of a full covariance matrix.
Revised: We tested a variant of FearNet that used a diagonal Σ c instead of a full covariance matrix.

Original: Table 6 shows that performance degrades, but FearNet still works.
Revised: Table 6 shows that performance degrades, but FearNet still works.

Original: FearNet can be adapted to other paradigms, such as unsupervised learning and regression.
Revised: FearNet can be adapted to other paradigms, such as unsupervised learning and regression.

Original: For unsupervised learning, FearNet’s mPFC already does a form of it implicitly.
Revised: For unsupervised learning, FearNet’s mPFC already does a form of it implicitly.

Original: For regression, this would require changing mPFC’s loss function and may require grouping input feature vectors into similar collections.
Revised: For regression, this would require changing mPFC’s loss function and may require grouping input feature vectors into similar collections.

Original: FearNet could also be adapted to perform the supervised data permutation experiment performed by Goodfellow et al.
Revised: FearNet could also be adapted to perform the supervised data permutation experiment performed by Goodfellow et al.

Original: (2013) and Kirkpatrick et al.
Revised: (2013) and Kirkpatrick et al.

Original: This would likely require storing statistics from previous permutations and classes.
Revised: This would likely require storing statistics from previous permutations and classes.

Original: FearNet would sleep between learning different permutations; however, if the number of classes was high, recent recall may suffer.
Revised: FearNet would sleep between learning different permutations; however, if the number of classes was high, recent recall may suffer.

Original: FearNet does have room for improvement.

Original: Future work will focus on integrating BLA directly into the model, rather than training it independently.

Original: Additionally, we will explore replacing FearNet’s pseduorehearsal mechanism with a generative model that does not require the storage of class statistics, which would be more memory efﬁcient.

Original:  C ONCLUSION
Revised:  C ONCLUSION

Original: In this paper, we proposed a brain-inspired framework capable of incrementally learning data with different modalities and object classes.
Revised: In this paper, we proposed a brain-inspired framework capable of incrementally learning data with different modalities and object classes.

Original: FearNet outperforms existing methods for incremental class learning on large image and audio classiﬁcation benchmarks, demonstrating that FearNet is capable of recalling and consolidating recently learned information while also retaining old information.
Revised: FearNet outperforms existing methods for incremental class learning on large image and audio classiﬁcation benchmarks, demonstrating that FearNet is capable of recalling and consolidating recently learned information while also retaining old information.

Original: In addition, we showed that FearNet is more memory efﬁcient, making it ideal for platforms where size, weight, and power requirements are limited.
Revised: In addition, we showed that FearNet is more memory efﬁcient, making it ideal for platforms where size, weight, and power requirements are limited.

Original: Future work will focus on incorporating the entire framework into  a single end-to-end framework.
Revised: Future work will include 1) integrating BLA directly into the model (versus training it independently); 2) replacing HC with a semi-parametric model; 3) learning the feature embedding from raw inputs; and 4) replacing the pseduorehearsal mechanism with a generative model that does not require the storage of class statistics, which would be more memory efﬁcient.

Original: A S UPPLEMENTAL M ATERIAL A. M ODEL H YPERPARAMETERS
Revised: A S UPPLEMENTAL M ATERIAL A. M ODEL H YPERPARAMETERS

Original: Table S1 shows the training parameters for the FearNet model for each dataset.
Revised: Table S1 shows the training parameters for the FearNet model for each dataset.

Original: We also experimented with various dropout rates, weight decay, and various activation functions; however, weight decay did not work well with FearNet’s mPFC.
Revised: We also experimented with various dropout rates, weight decay and various activation functions; however, weight decay did not work well with FearNet’s mPFC

Original: [Table]
Revised: [Table]

Original:  Table S2 shows the training parameters for the iCaRL framework used in this paper.
Revised: [Figure] [Table] Table S2 shows the training parameters for the iCaRL framework used in this paper.

Original: We adapted the code from the author’s GitHub page for our own experiments.
Revised: We adapted the code from the author’s GitHub page for our own experiments.

Original: The ResNet-18 convolutional neural network was replaced with a fully-connected neural network.
Revised: The ResNet-18 convolutional neural network was replaced with a fully-connected neural network.

Original: We experimented with various regularization strategies to increase the initial base-knowledge accuracy with weight decay working the best.
Revised: We experimented with various regularization strategies to increase the initial base-knowledge accuracy with weight decay working the best.

Original: The values that are given as a range of values are the hyperparameter search spaces.
Revised: The values that are given as a range of values are the hyperparameter search spaces

Original: [Table]
Revised: [Table]

Original: Table S3 shows the training parameters for GeppNet and GeppNet+STM.
Revised: Table S3 shows the training parameters for GeppNet and GeppNet+STM.

Original: Parameters not listed here are the default parameters deﬁned by Gepperth & Karaoguz (2016).
Revised: Parameters not listed here are the default parameters deﬁned by Gepperth & Karaoguz (2016).

Original: The values that are given as a range of values are the hyperparameter search spaces.
Revised: The values that are given as a range of values are the hyperparameter search spaces.

Original: [Table]
Revised: [Table]

Original: Table S4 shows the training parameters for the Fixed Expansion Layer (FEL).
Revised: Table S4 shows the training parameters for the Fixed Expansion Layer (FEL).

Original: The number of units in the FEL layer is given by
Revised: The number of units in the FEL layer is given by

Original: [Equation]
Revised: [Equation]

Original: where H is the number of units in the ﬁrst hidden-layer and K is the maximum number of classes in the dataset.
Revised: where H is the number of units in the ﬁrst hidden-layer and K is the maximum number of classes in the dataset.

Original: The values that are given as a range of values are the hyperparameter search spaces.
Revised: The values that are given as a range of values are the hyperparameter search spaces.

Original: [Table]
Revised: [Table]

Original: A. I C A RL P ERFORMANCE WITH M ORE E XEMPLARS
Revised: A. I C A RL P ERFORMANCE WITH M ORE E XEMPLARS

Original: Table S5 provides additional experimental results for when there are more exemplars per class (EPC) for the iCaRL framework.
Revised: Table S5 provides additional experimental results for when there are more exemplars per class (EPC) for the iCaRL framework.

Original: Rebufﬁ et al.
Revised: Rebufﬁ et al.

Original: (2017) used 20 EPC in their original paper; however, we increased the number to 100 EPC to see if storing more training data helped iCaRL.
Revised: (2017) used 20 EPC in their original paper; however, we increased the number to 100 EPC to see if storing more training data helped iCaRL.

Original: Although a higher EPC does increase iCaRL performance, it still does not outperform FearNet.
Revised: Although a higher EPC does increase iCaRL performance, it still does not outperform FearNet.

Original: Note that
Revised: Note that

Original: CUB-200 only has about 30 training samples per class, so iCaRL is storing the entire training set for 100 EPC.
Revised: CUB-200 only has about 30 training samples per class, so iCaRL is storing the entire training set for 100 EPC.

Original: Our main results use the default value of 
Revised: Our main results use the default value of 20.

Original: [Table]
Revised: [Table]

Revised: A. BLA V ARIANTS

Revised: Our BLA model is a classiﬁer that determines whether a prediction should be made using HC (recent memory) or mPFC (remote memory).

Revised: An alternative approach would be to use an outlier detection algorithm that determines whether the data being processed by a sub-network is an outlier for that sub-network and should therefore be processed by the other sub-network.

Revised: To explore this alternative

Revised: BLA formulation, we experimented with three outlier detection algorithms: 1) one-class support vector machine (SVM)

Revised: Sch¨olkopf et al.

Revised: (2001), 2) determining if the data ﬁts into a Gaussian distribution using a minimum covariance determinant estimation (i.e., elliptical envelope) Rousseeuw & Driessen (1999), and 3) the isolation forest Liu et al.

Revised: All three of these methods set a rejection criterion for if the test sample exists in HC; whereas the binary MLP reports a probability on how likely the test sample resides in HC.

Revised: Table S6 compares these individual methods.

Revised: Isolation

Revised: Forest and Elliptic Envelope seem to prefer the data in HC, one-class SVM prefers the data in mPFC, and our binary MLP worked best at choosing the correct sub-network to use.

Revised: [Table]

Revised: A. F EAR N ET A LGORITHM

Revised: Pseudocode for FearNet’s training and prediction algorithms are given in Algorithms 1 and 2 respectively.

Revised: The variables match the ones deﬁned in the paper.

Original: A. M ULTI -M ODAL L EARNING E XPERIMENT
Revised: Data: X,y Classes/Study-Sessions : T; K : Sleep Frequency; Initialize mPFC with base-knowledge;

Revised: Store µ t , Σ t for each class in the base-knowledge; for c ← T/ 2 to T do

Revised: Store X, y for class c in HC; if c % K =

Original: {+= 
+}
Revised: {+= 
+}

Revised: then

Revised: Fine-tune mPFC with X, y in HC and pseudoexamples generated by mPFC decoder;

Revised: Update µ t , Σ t for all classes seen so far;

Revised: Clear HC; else

Revised: Update BLA;

Revised: Data: X

Revised: A ( X ) ← P BLA ( C = 1 | X ) ; ψ ← max k P HC ( C = k | X ) A ( X ) 1 − A

Revised: ( X ) ; if ψ > max k P mPFC ( C = k

Revised: | X ) then return arg

Revised: [Equation]

Revised: k (cid:48) | X ) ; else return

Revised: [Equation]

Revised: A. M ULTI -M ODAL L EARNING E XPERIMENT

Original: Fig.
Revised: Fig.

Original: S1 shows the plots for the multi-modal experiments in Sec. 6.2.
Revised: S1 shows the plots for the multi-modal experiments in Sec. 6.2.

Original: The three base-knowledge experiments were 1) CIFAR-100 is the base-knowledge and AudioSet is trained incrementally, 2) AudioSet is the base-knowledge and then AudioSet is trained incrementally, and 3) the base-knowledge is a 50/50 mix of the two datasets and then the remaining classes are trained incrementally.
Revised: The three base-knowledge experiments were 1) CIFAR-100 is the base-knowledge and AudioSet is trained incrementally, 2) AudioSet is the base-knowledge and then AudioSet is trained incrementally, and 3) the base-knowledge is a 50/50 mix of the two datasets and then the remaining classes are trained incrementally.

Original: For all three base-knowledge experiments, we show the mean-class accuracy on the base-knowledge and the entire test set.
Revised: For all three base-knowledge experiments, we show the mean-class accuracy on the base-knowledge and the entire test set.

Original: FearNet works well when it adequately learns the base-knowledge (Experiment #1 and #3); however, when FearNet learns it poorly, incremental learning deteriorates. 
Revised: FearNet works well when it adequately learns the base-knowledge (Experiment #1 and #3); however, when FearNet learns it poorly, incremental learning deteriorates. A. B ASE -K NOWLEDGE E FFECT ON P ERFORMANCE

Original: [Figure]
Revised: Fig.

Revised: S2 shows the effect of the base-knowledge’s size on FearNet’s performance.

Revised: As expected, Ω base increases because there are not as many sleep phases to overwrite existing base-knowledge.

Revised: Ω new remains relatively even because the size of the base-knowledge has no effect on the HC model’s ability to immediately recall new information; however, there is a very slight decrease that corresponds to the BLA model erroneously favoring mPFC in a few cases.

Revised: Most importantly, Ω all sees an increase in performance because; like Ω base , there are not as many sleep phases to perturb older memories in mPFC.

Revised: [Figure]

Revised: [Figure]