Original: S EMI - PARAMETRIC P ROMPT -G ENERATION FOR M ODEL E DITING
Revised: S EMI - PARAMETRIC P ROMPT -G ENERATION FOR M ODEL E DITING

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: Large Language models are used in various downstream tasks with great success.
Revised: Large Language models are used in various downstream tasks with great success.

Original: However, changing specific knowledge or beliefs of a model (a.k.a. model editing) efficiently to revise inaccurate predictions while not affecting all other cases is still challenging.
Revised: However, changing specific knowledge or beliefs of a model (a.k.a. model editing) efficiently to revise inaccurate predictions while not affecting all other cases is still challenging.

Original: Most previous methods compute gradients to change the model.
Revised: Most previous methods compute gradients to change the model.

Original: These strategies generally work, paying the cost of high computing and memory complexity.
Revised: These strategies generally work, paying the cost of high computing and memory complexity.

Original: The semi-parametric strategy has recently shown its effectiveness in alleviating the complexity via introducing memory to store the edits of knowledge.
Revised: The semi-parametric strategy has recently shown its effectiveness in alleviating the complexity via introducing memory to store the edits of knowledge.

Original: However, the memory does not have a proper mechanism to be utilized by a large pre-trained language model, limiting its generalizability to more complicated model editing scenarios.
Revised: However, the memory does not have a proper mechanism to be utilized by a large pre-trained language model, limiting its generalizability to more complicated model editing scenarios.

Original: This work proposes a prompt generation mechanism to bridge the gap.
Revised: This work proposes a prompt generation mechanism to bridge the gap.

Original: Our method encodes the edits as prefix prompts for language models, then has the large pre-trained language model perform inference with the prompts.
Revised: Our method encodes the edits as prefix prompts for language models, then has the large pre-trained language model perform inference with the prompts.

Original: In other words, the model is edited by prompts without changing model parameters.
Revised: In other words, the model is edited by prompts without changing model parameters.

Original: Our method, S E P RO G, significantly outperforms state-of-art methods by up to 20% on entailed edit benchmarks and provides up to 30% better performance over gradient-based methods on non-entailed benchmarks.
Revised: Our method, S E P RO G, significantly outperforms state-of-art methods by up to 20% on entailed edit benchmarks and provides up to 30% better performance over gradient-based methods on non-entailed benchmarks.

Original: These advantages are achieved with much less computation and memory consumption, proving prompt generation’s great potential in model editing problems.
Revised: These advantages are achieved with much less computation and memory consumption, proving prompt generation’s great potential in model editing problems.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Large pre-trained language models (Devlin et al., 2018; Lewis et al., 2019; Radford et al., 2019; Liu et al., 2019) have shown tremendous success on a wide variety of downstream tasks (Brown et al., 2020) such as language generation, fact-checking, summarization, etc.
Revised: Large pre-trained language models (Devlin et al., 2018; Lewis et al., 2019; Radford et al., 2019; Liu et al., 2019) have shown tremendous success on a wide variety of downstream tasks (Brown et al., 2020) such as language generation, fact-checking, summarization, etc.

Original: These successes are due to their ability to capture world-scaled knowledge by pre-training on massive corpora (Petroni et al., 2019), as well as their effectiveness in fine-tuning to adapt to arbitrary downstream tasks.
Revised: These successes are due to their ability to capture world-scaled knowledge by pre-training on massive corpora (Petroni et al., 2019), as well as their effectiveness in fine-tuning to adapt to arbitrary downstream tasks.

Original: However, modifying the underlying beliefs of large language models with a desired degree of control is still an open problem (Hase et al., 2021).
Revised: However, modifying the underlying beliefs of large language models with a desired degree of control is still an open problem (Hase et al., 2021).

Original: The need to evolve the model’s beliefs may range from reflecting simple factual changes about the world  to updating entailed relationships between knowledge entities.
Revised: The need to evolve the model’s beliefs may range from reflecting simple factual changes about the world (such as changing the capital of a country) to updating entailed relationships between knowledge entities (such as deducing properties of a new species based on its biological taxonomy).

Original: The problem setting of Model Editing (Mitchell et al., 2021; Sinitsin et al., 2020) formulates the challenge well.
Revised: The problem setting of Model Editing (Mitchell et al., 2021; Sinitsin et al., 2020) formulates the challenge well.

Original: Specifically, given a small sample of edit data ( e . g ., description of factual changes), the goal is to make the model provide updated predictions for inputs that are semantically related to the edit data ( i .
Revised: Specifically, given a small sample of edit data ( e . g ., description of factual changes), the goal is to make the model provide updated predictions for inputs that are semantically related to the edit data ( i .

Original: e ., in-scope data), while retaining the same beliefs for inputs outside the scope of edit data ( i .
Revised: e ., in-scope data), while retaining the same beliefs for inputs outside the scope of edit data ( i .

Original: e ., out-scope data).
Revised: e ., out-scope data).

Original: Previous model editing strategies learn a gradient-based optimizer (Mitchell et al., 2021) or a model that can quickly adopt the edits via gradient descents (Sinitsin et al., 2020; Hase et al., 2021).
Revised: Previous model editing strategies learn a gradient-based optimizer (Mitchell et al., 2021) or a model that can quickly adopt the edits via gradient descents (Sinitsin et al., 2020; Hase et al., 2021).

Original: These methods achieve significant success with few edits, but their accuracy falls quickly with a larger amount of edits.
Revised: These methods achieve significant success with few edits, but their accuracy falls quickly with a larger amount of edits.

Original: The interference between edits may be a cause, but controlling the beliefs through the space of model parameters introduces unmanageable complexity.
Revised: The interference between edits may be a cause, but controlling the beliefs through the space of model parameters introduces unmanageable complexity.

Original: One obvious side-effect is scalability.
Revised: One obvious side-effect is scalability.

Original: Mitchell et al.
Revised: Mitchell et al.

Original: (2021) has shown it is non-trivial to generate the gradients by neural networks or impractical to compute the gradient of gradients ( i .
Revised: (2021) has shown it is non-trivial to generate the gradients by neural networks or impractical to compute the gradient of gradients ( i .

Original: e ., hypergradients) for learning the fast adapting models beyond billions of parameters.
Revised: e ., hypergradients) for learning the fast adapting models beyond billions of parameters.

Original: A recent work, SERAC (Mitchell et al., 2022), tackles model editing using a semi-parametric approach with an explicit memory to store the edit data.
Revised: A recent work, SERAC (Mitchell et al., 2022), tackles model editing using a semi-parametric approach with an explicit memory to store the edit data.

Original: SERAC first classifies whether an input is in-scope or out-scope.
Revised: SERAC first classifies whether an input is in-scope or out-scope.

Original: If a case is out-scope ( i .
Revised: If a case is out-scope ( i .

Original: e ., unrelated to the edit data), SERAC uses the base model for predictions.
Revised: e ., unrelated to the edit data), SERAC uses the base model for predictions.

Original: In the in-scope case, SERAC uses an additional model (named counterfactual model in the original paper) for predictions.
Revised: In the in-scope case, SERAC uses an additional model (named counterfactual model in the original paper) for predictions.

Original: The counterfactual model extracts the most similar edit in the memory, then uses the edit together with the input for generating predictions.
Revised: The counterfactual model extracts the most similar edit in the memory, then uses the edit together with the input for generating predictions.

Original: SERAC updates only its memory when there are new edits; therefore, it avoids maneuvering the model parameter space.
Revised: SERAC updates only its memory when there are new edits; therefore, it avoids maneuvering the model parameter space.

Original: This strategy is, therefore, scalable and agnostic to the base model.
Revised: This strategy is, therefore, scalable and agnostic to the base model.

Original: However, the two branches in SERAC make predictions independently, isolating the counterfactual model from leveraging the knowledge of the base model, which was trained with massive corpora.
Revised: However, the two branches in SERAC make predictions independently, isolating the counterfactual model from leveraging the knowledge of the base model, which was trained with massive corpora.

Original: In other words, the design has no knowledge sharing between the branches, making an entailed prediction less likely for the edit-related (in-scope) inputs.
Revised: In other words, the design has no knowledge sharing between the branches, making an entailed prediction less likely for the edit-related (in-scope) inputs.

Original: This limitation is convoluted with the challenge of training a generalizable classifier to distinguish in-/out-scope, causing the strategy to stumble on harder cases (examined in later sections).
Revised: This limitation is convoluted with the challenge of training a generalizable classifier to distinguish in-/out-scope, causing the strategy to stumble on harder cases (examined in later sections).

Original: This work proposes S E P RO G (Semi-parametric Prompt-Generation) to retain the good parts of the above strategies while minimizing the limitations: (1) scalable base model size; (2) scalable edit dataset size; (3) good generalizability to hard edits (4) low cost to train and inference.
Revised: This work proposes S E P RO G (Semi-parametric Prompt-Generation) to retain the good parts of the above strategies while minimizing the limitations: (1) scalable base model size; (2) scalable edit dataset size; (3) good generalizability to hard edits (4) low cost to train and inference.

Original: Our approach was inspired by the non-parametric neural models (Graves et al., 2014; Garnelo et al., 2018a), which stores training data (or edits) rather than model parameters; and prompt-tuning methods (Li & Liang, 2021; Lester et al., 2021), which convert task descriptions (or the edits) to real-valued prefix for language inputs.
Revised: Inspired by the non-parametric neural models (Graves et al., 2014; Garnelo et al., 2018a), which stores training data (or edits) rather than model parameters, our semi-parametric approach stores latent representations of the edit data as well as leverages the information from pre-trained base model. Our approach also builds on recent advances in prompt-tuning methods (Li & Liang, 2021; Lester et al., 2021), which convert task descriptions (or the edits) to real-valued prefix for language inputs.

Original: These two ideas lead to an end-to-end solution to change the belief of a model with encoder-decoder structures (Lewis et al., 2019; Raffel et al., 2020).
Revised: These two ideas lead to an end-to-end solution to change the belief of a model with encoder-decoder structures (Lewis et al., 2019; Raffel et al., 2020).

Original: Our method generates edit dataset-specific embeddings by leveraging the encoder, then injects the embeddings as the prefix of inputs to the decoder (Figure 1).
Revised: Our method generates edit dataset-specific embeddings by leveraging the encoder, then injects the embeddings as the prefix of inputs to the decoder (Figure 1).

Original: As a result, S E P RO G does not change the base model after deployment (the advantage of SERAC) while still using the base model to generate predictions on both in-scope and out-scope inputs.
Revised: As a result, S E P RO G does not change the base model after deployment (the advantage of SERAC) while still using the base model to generate predictions on both in-scope and out-scope inputs.

Original: The inference of in-scope inputs therefore can leverage the world knowledge of the base model to achieve better generalization on hard edits (the advantage of gradient-based methods).
Revised: The inference of in-scope inputs therefore can leverage the world knowledge of the base model to achieve better generalization on hard edits (the advantage of gradient-based methods).

Original: Our contributions are summarized as follows:
Revised: Our contributions are summarized as follows:

Original: • We propose a novel model editing method that leverages both prompting and semi-parametric strategies.
Revised: • We propose a novel model editing method that leverages both prompting and semi-parametric strategies.

Original: • We examined 6 model editing strategies on 3 evaluation aspects: (1) small/large amount of edit data; (2) easy/hard edits; (3) cost of training/inference.
Revised: • We examined 6 model editing strategies on 3 evaluation aspects: (1) small/large amount of edit data; (2) easy/hard edits; (3) cost of training/inference.

Original: This comprehensive comparison shows that the dominant strategy is yet to come, but S E P RO G’s well-balanced advantages in all 3 aspects make it the best frontier in the current solution space.
Revised: This comprehensive comparison shows that the dominant strategy is yet to come, but S E P RO G’s well-balanced advantages in all 3 aspects make it the best frontier in the current solution space.

Original:  M ODEL E DITING P ROBLEM
Revised:  M ODEL E DITING P ROBLEM

Original: Let M base be a large pre-trained language model trained on a task T with dataset D T
Revised: Let M base be a large pre-trained language model trained on a task T with dataset D T

Original: = { [ x i , y i ] } |D T | i =1 .
Revised: = { [ x i , y i ] } |D T | i =1 .

Original: The goal of model editing is to update the beliefs of M base with a set of K edit descriptors Z e = { z e i } K i =1 .
Revised: The goal of model editing is to update the beliefs of M base with a set of K edit descriptors Z e = { z ei } Ki =1 .

Original: In the case of question-answering, the edit descriptor could be a question-answer pair z ei =
Revised: In the case of question-answering, the edit descriptor could be a question-answer pair z ei =

Original: [ x ei , y ei ] .
Revised: [ x ei , y ei ] .

Original: The edited model will need to provide updated answers for questions that are semantically related to data in Z e while not changing its predictions for inputs unrelated to Z e .
Revised: The edited model will need to provide updated answers for questions that are semantically related to data in Z e while not changing its predictions for inputs unrelated to Z e .

Original: Formally, we are given a model M base : R n → R m trained on dataset D T .
Revised: Formally, we are given a model M base : R n → R m trained on dataset D T .

Original: Let I ( z e ) =
Revised: Let I ( z e ) =

Original: [ x, y ] } be the set of inputs whose predictions are affected by information in edit descriptor z e , i.e., labels y is different for datapoints in I ( z e ) due to updated information from z e .
Revised: [ x, y ] } be the set of inputs whose predictions are affected by information in edit descriptor z e , i.e., labels y is different for datapoints in I ( z e ) due to updated information from z e .

Original: (Note that z e ∈
Revised: (Note that z e ∈

Original: I ( z e ) ).
Revised: I ( z e ) ).

Original: Let O ( z e ) ⊂ D T be set of inputs whose predictions are not affected by z e .
Revised: Let O ( z e ) ⊂ D T be set of inputs whose predictions are not affected by z e .

Original: Then we define
Revised: Then we define

Original: I ( Z e ) =
Revised: I ( Z e ) =

Original: (cid:83) z e I ( z e ) as the in-scope data and O ( Z e ) =
Revised: (cid:83) z e I ( z e ) as the in-scope data and O ( Z e ) =

Original: (cid:83)
Revised: (cid:83)

Original: z e O ( z e ) as out-scope data.
Revised: z e O ( z e ) as out-scope data.

Original: The goal of model-editing is to derive an edited model M edit from M base such that:
Revised: The goal of model-editing is to derive an edited model M edit from M base such that:

Original: M edit outputs the revised predictions for in-scope data ( [ x ′ , y ′ ] ∼ I ( Z e ) ): arg max y p ( y | x ′ ; M edit ) =
Revised: M edit outputs the revised predictions for in-scope data ( [ x ′ , y ′ ] ∼ I ( Z e ) ): arg max y p ( y | x ′ ; M edit ) =

Original: y ′ 2.
Revised: y ′ 2.

Original: The changes in the output probability distribution should be small for out-scope inputs.
Revised: The changes in the output probability distribution should be small for out-scope inputs.

Original: In other words, the KL-Divergence between M base and M edit ’s predictions is small: min M edit KL ( p ( ·| x, M base ) || p ( ·| x, M edit )) .
Revised: In other words, the KL-Divergence between M base and M edit ’s predictions is small: [Equation]

Original: [Figure]
Revised: [Figure]

Original:  S E P RO G: M ODEL EDITING VIA P REFIX P ROMPT G ENERATION 3. O VERVIEW
Revised:  S E P RO G: M ODEL EDITING VIA P REFIX P ROMPT G ENERATION 3. O VERVIEW

Original: Our approach assumes that the base model M base is an encoder-decoder architecture with encoder
Revised: Our approach assumes that the base model M base is an encoder-decoder architecture with encoder

Original: E base and decoder D base .
Revised: E base and decoder D base .

Original: Many widely used language models fall in this category (Raffel et al., 2020;
Revised: Many widely used language models fall in this category (Raffel et al., 2020;

Original: Lewis et al., 2019; Brown et al., 2020).
Revised: Lewis et al., 2019; Brown et al., 2020).

Original: Unlike most previous works on model-editing that altered the weights of the base model (Mitchell et al., 2021; 2022; Sinitsin et al., 2020), S E P RO G trains a neural model to learn to generate prompt embeddings pr ( Z e , x ) based on the edit descriptors Z e and input x .
Revised: Unlike most previous works on model-editing that altered the weights of the base model (Mitchell et al., 2021; 2022; Sinitsin et al., 2020), S E P RO G trains a neural model to learn to generate prompt embeddings pr ( Z e , x ) based on the edit descriptors Z e and input x .

Original: The generated prompt pr ( Z e , x ) provides information on the parts of the edit descriptors relevant to input so that the model can use the edit information to provide updated beliefs.
Revised: The generated prompt pr ( Z e , x ) provides information on the parts of the edit descriptors relevant to input so that the model can use the edit information to provide updated beliefs.

Original: This prompt is prepended to the token embeddings as input for decoder D base to inform the model to provide updated predictions.
Revised: This prompt is prepended to the token embeddings as input for decoder D base to inform the model to provide updated predictions.

Original: 3. M ODEL ARCHITECTURE
Revised: 3. M ODEL ARCHITECTURE

Original: S E P RO G contains 3 modules to generate the prompt: 1) Edit encoder 2)
Revised: S E P RO G contains 3 modules to generate the prompt: 1) Edit encoder 2)

Original: Edit selection module and 3)
Revised: Edit selection module and 3)

Original: Prompt output decoder.
Revised: Prompt output decoder.

Original: Edit Encoder Edit encoder E edit converts each of the edit descriptors z ei to a fixed-sized embeddings h ei :
Revised: Edit Encoder Edit encoder E edit converts each of the edit descriptors z ei to a fixed-sized embeddings h ei :

Original: [Equation]
Revised: [Equation]

Original: Any encoder style architecture like BERT (Devlin et al., 2018) or encoders of a seq2seq architecture can be used based on the task and the base model.
Revised: Any encoder style architecture like BERT (Devlin et al., 2018) or encoders of a seq2seq architecture can be used based on the task and the base model.

Original: Edit selection module Given the set of embeddings of edit descriptors H e = { h ei } Ni =1 and encoding of input x as b ( x ) =
Revised: Edit selection module Given the set of embeddings of edit descriptors H e = { h ei } Ni =1 and encoding of input x as b ( x ) =

Original: E base ( x ) , edit module first selects the most relevant edit descriptor via cross-attention:
Revised: E base ( x ) , edit module first selects the most relevant edit descriptor via cross-attention:

Original: [Equation]
Revised: [Equation]

Original: where W att a learnable weight matrix that performs a linear transform on b ( x ) .
Revised: where W att a learnable weight matrix that performs a linear transform on b ( x ) .

Original: Since the input x maybe either in-scope or out-scope, we also introduce an edit classifier module that predicts if x is in-scope using information from cross-attention layer:
Revised: Since the input x maybe either in-scope or out-scope, we also introduce an edit classifier module that predicts if x is in-scope using information from cross-attention layer:

Original: [Equation]
Revised: [Equation]

Original: where NN e is a simple feed-forward neural network with last layer returning a scalar, ⊕ is concatenation operator and σ is the sigmoid function.
Revised: where NN e is a simple feed-forward neural network with last layer returning a scalar, ⊕ is concatenation operator and σ is the sigmoid function.

Original: Therefore, e ( x ) ∈ [0 , 1] is the probability of x belonging to in-scope set
Revised: Therefore, e ( x ) ∈ [0 , 1] is the probability of x belonging to in-scope set

Original: I
Revised: I

Original: ( Z e ) .
Revised: ( Z e ) .

Original: Prompt Output Decoder Given the relevancy information h ( x ) of edit descriptors Z e to input x as well as likelihood e ( x ) that x is in-scope, we now leverage this information to generate prompts pr ( x, Z e ) ∈ R p ×
Revised: Prompt Output Decoder Given the relevancy information h ( x ) of edit descriptors Z e to input x as well as likelihood e ( x ) that x is in-scope, we now leverage this information to generate prompts pr ( x, Z e ) ∈ R p ×

Original: d where p is the number of prompt embeddings and d is the input token embedding dimension of base decoder D base .
Revised: d where p is the number of prompt embeddings and d is the input token embedding dimension of base decoder D base .

Original: First note that we only produce the prompts if e ( x ) > 0 . 5 , i.e., the model classifies x as in-scope.
Revised: First note that we only produce the prompts if e ( x ) > 0 . 5 , i.e., the model classifies x as in-scope.

Original: We use a feed-forward neural network NN prompt that produces a p × d dimensional embedding:
Revised: We use a feed-forward neural network NN prompt that produces a p × d dimensional embedding:

Original: [Equation]
Revised: [Equation]

Original: Since the prompt is fed into the unchanged base decoder D base , the decoder leverages information from the prompt as well as its prior knowledge from pre-training to effectively provide updated output predictions.
Revised: Since the prompt is fed into the unchanged base decoder D base , the decoder leverages information from the prompt as well as its prior knowledge from pre-training to effectively provide updated output predictions.

Original: 3. T RAINING THE MODEL
Revised: 3. T RAINING THE MODEL

Original: The training of S E P RO G learns only the 3 modules that output h ( x ) , e ( x ) , and pr ( x, Z e ) with frozen base model ( E base and D base ).
Revised: The training of S E P RO G learns only the 3 modules that output h ( x ) , e ( x ) , and pr ( x, Z e ) with frozen base model ( E base and D base ).

Original: The 3 modules are optimized with two losses: scope classification loss and prompt guidance loss.
Revised: The 3 modules are optimized with two losses: scope classification loss and prompt guidance loss.

Original: Scope classification loss The weights of edit encoder E edit and the components of edit selection module ( W att , CrossAttention and NN e ) are optimized with this loss to predict the in-scope likelihood e ( x ) :
Revised: Scope classification loss The weights of edit encoder E edit and the components of edit selection module ( W att , CrossAttention and NN e ) are optimized with this loss to predict the in-scope likelihood e ( x ) :

Original: [Equation]
Revised: [Equation]

Original: Prompt Guidance Loss All the components of S E P RO G used to generate in-scope prompts will be jointly optimized with L pg to change the output from D base :
Revised: Prompt Guidance Loss All the components of S E P RO G used to generate in-scope prompts will be jointly optimized with L pg to change the output from D base :

Original: [Equation]
Revised: [Equation]

Original: For each in-scope input x , we obtain base encoder output E base ( x ) and generate prompt pr ( x, Z e ) from S E P RO G which is fed as prefix to D base .
Revised: For each in-scope input x , we obtain base encoder output E base ( x ) and generate prompt pr ( x, Z e ) from S E P RO G which is fed as prefix to D base .

Original: The output predictions of D base are optimized towards updated ground-truth y by tuning the parameters of S E P RO
Revised: The output predictions of D base are optimized towards updated ground-truth y by tuning the parameters of S E P RO

Original: G.
Revised: G.

Original: The total training loss is a linear combination of both losses with hyperparameter λ :
Revised: The total training loss is a linear combination of both losses with hyperparameter λ :

Original: [Equation]
Revised: [Equation]

Original:  R ELATED WORK
Revised:  R ELATED WORK

Original: Model Editing Editing model beliefs based on a small set of out-of-distribution samples has been an active area of research with recent advances in the effectiveness of using large pre-trained models on a wide range of NLG and NLU tasks.
Revised: Model Editing Editing model beliefs based on a small set of out-of-distribution samples has been an active area of research with recent advances in the effectiveness of using large pre-trained models on a wide range of NLG and NLU tasks.

Original: Most straightforward approaches involve fine-tuning a full set or partial subset of model weights (Zhu et al., 2020).
Revised: Most straightforward approaches involve fine-tuning a full set or partial subset of model weights (Zhu et al., 2020).

Original: However, these approaches overfit to edit datasets while degrading performance on out-scope data.
Revised: However, these approaches overfit to edit datasets while degrading performance on out-scope data.

Original: Sinitsin et al.
Revised: Sinitsin et al.

Original: (2020) propose a gradient-based meta-learning approach based on MAML (Finn et al., 2017) of learning to learn to update model weights for new edit dataset during test-time while retaining performance on out-scope datasets.
Revised: (2020) propose a gradient-based meta-learning approach based on MAML (Finn et al., 2017) of learning to learn to update model weights for new edit dataset during test-time while retaining performance on out-scope datasets.

Original: This method, however, is prohibitively expensive for large models with ≥ 10 7 parameters.
Revised: This method, however, is prohibitively expensive for large models with ≥ 10 7 parameters.

Original: Another alternative line of work (Mitchell et al., 2021; De Cao et al., 2021;
Revised: Another alternative line of work (Mitchell et al., 2021; De Cao et al., 2021;

Original: Hase et al., 2021) for learning to update model weights instead learn independent smaller neural networks that input gradients of model weights on edit task and provide refined gradients.
Revised: Hase et al., 2021) for learning to update model weights instead learn independent smaller neural networks that input gradients of model weights on edit task and provide refined gradients.

Original: Since these methods do not retrain model weights, they are relatively scalable but still computationally expensive to train.
Revised: Since these methods do not retrain model weights, they are relatively scalable but still computationally expensive to train.

Original: Moreover, they do not adapt to edit datasets for large sizes.
Revised: Moreover, they do not adapt to edit datasets for large sizes.

Original: SERAC (Mitchell et al., 2022) propose an alternative gradient-free, model-agnostic approach for editing where they classify each input as related to the edit dataset and allocate out-scope inputs to underlying base models while using a separate counterfactual model for dealing with in-scope inputs.
Revised: SERAC (Mitchell et al., 2022) propose an alternative gradient-free, model-agnostic approach for editing where they classify each input as related to the edit dataset and allocate out-scope inputs to underlying base models while using a separate counterfactual model for dealing with in-scope inputs.

Original: While this method effectively deals with benchmarks that have simple factual edits in edit datasets and similarity between edit dataset and input is easy to detect they fail on more complex scenarios involving complex relations between input and edit such as entailment or leveraging nuanced world knowledge from the base model.
Revised: While this method effectively deals with benchmarks that have simple factual edits in edit datasets and similarity between edit dataset and input is easy to detect they fail on more complex scenarios involving complex relations between input and edit such as entailment or leveraging nuanced world knowledge from the base model.

Original: Neural non-parametric Models In the general machine learning setup, most models are parametric, i.e., we learn the optimal set of parameters θ for function f θ that learns a mapping X → Y that fits the data D
Revised: Neural non-parametric Models In the general machine learning setup, most models are parametric, i.e., we learn the optimal set of parameters θ for function f θ that learns a mapping X → Y that fits the data D

Original: = { x i , y i } i .
Revised: = { x i , y i } i .

Original: Non-parametric models, in contrast, use the training data to directly derive a functional:
Revised: Non-parametric models, in contrast, use the training data to directly derive a functional:

Original: y = f θ ( x i ; D ) .
Revised: y = f θ ( x i ; D ) .

Original: Memory or retrieval based models (Graves et al., 2014; Rastogi et al., 2022; Yogatama et al., 2021) fall into this category.
Revised: Memory or retrieval based models (Graves et al., 2014; Rastogi et al., 2022; Yogatama et al., 2021) fall into this category.

Original: Neural Process based models (Garnelo et al., 2018a;b) leverage this explicit dependency of the model’s functional with the dataset towards multi-task learning and zero-shot meta-learning problems.
Revised: Neural Process based models (Garnelo et al., 2018a;b) leverage this explicit dependency of the model’s functional with the dataset towards multi-task learning and zero-shot meta-learning problems.

Original: At a high level, neural process models learn a latent embedding for each task based on the training dataset of the task.
Revised: At a high level, neural process models learn a latent embedding for each task based on the training dataset of the task.

Original: This task embedding is in turn used by decoder to provide predictions for test inputs related to the given task.
Revised: This task embedding is in turn used by decoder to provide predictions for test inputs related to the given task.

Original: Since these methods explicitly model dependency of training data in the predictive process they are used in various applications where modeling these dependencies improves inductive bias of such models (Rastogi et al., 2022) or provide robust and interpretable predictions (Kamarthi et al., 2021).
Revised: Since these methods explicitly model dependency of training data in the predictive process they are used in various applications where modeling these dependencies improves inductive bias of such models (Rastogi et al., 2022) or provide robust and interpretable predictions (Kamarthi et al., 2021).

Original: Prompt based fine-tuning Using human-generated prompts as prefixes to inputs has shown to be an effective method of zero-shot tuning of large-scale models to specific downstream tasks (Brown et al., 2020) without requiring any update to model parameters.
Revised: Prompt based fine-tuning Using human-generated prompts as prefixes to inputs has shown to be an effective method of zero-shot tuning of large-scale models to specific downstream tasks (Brown et al., 2020) without requiring any update to model parameters.

Original: However, these approaches are limited by the length of input prompts and the requirement of expert human prompting, which may be sub-optimal for some tasks.
Revised: However, these approaches are limited by the length of input prompts and the requirement of expert human prompting, which may be sub-optimal for some tasks.

Original: Li & Liang (2021) propose to learn optimal hidden activation prefixes for transformer layers of language models that are fine-tuned for the given downstream task (without changing model weights).
Revised: Li & Liang (2021) propose to learn optimal hidden activation prefixes for transformer layers of language models that are fine-tuned for the given downstream task (without changing model weights).

Original: They show surprisingly similar performance to explicit fine-tuning while optimizing a very small number of parameters of prefix activations.
Revised: They show surprisingly similar performance to explicit fine-tuning while optimizing a very small number of parameters of prefix activations.

Original: Lester et al.
Revised: Lester et al.

Original: (2021) instead proposed to optimize only prefix word embeddings for each task showing similar downstream performance with an even lesser number of parameters to optimize.
Revised: (2021) instead proposed to optimize only prefix word embeddings for each task showing similar downstream performance with an even lesser number of parameters to optimize.

Original: Liu et al.
Revised: Liu et al.

Original: (2021) further generalizes this approach beyond prefixes to have prompts between inputs and output.
Revised: (2021) further generalizes this approach beyond prefixes to have prompts between inputs and output.

Original: While prompt tuning methods mostly focus on training prompt embeddings for specific tasks, we study prompt generation to produce prompts specific to the input given the edit descriptors to inform the base model of updated belief from the batch of edit descriptors that are relevant to input
Revised: While prompt tuning methods mostly focus on training prompt embeddings for specific tasks, we study prompt generation to produce prompts specific to the input given the edit descriptors to inform the base model of updated belief from the batch of edit descriptors that are relevant to input

Original: [Table]
Revised: [Table]

Original:  E XPERIMENT S ETUP 5. D ATASETS
Revised:  E XPERIMENT S ETUP 5. D ATASETS

Original: [Table]
Revised: [Table]

Original: We experiment with two types of datasets: Copy-edit datasets (easy edits) and Entail-edit datasets (hard edits), each of which are shown to be effective with memory-based (Mitchell et al., 2022) and gradient-based methods (Mitchell et al., 2021; Sinitsin et al., 2020), respectively.
Revised: We experiment with two types of datasets: Copy-edit datasets (easy edits) and Entail-edit datasets (hard edits), each of which are shown to be effective with memory-based (Mitchell et al., 2022) and gradient-based methods (Mitchell et al., 2021; Sinitsin et al., 2020), respectively.

Original: Copy-edit datasets These datasets are designed such that the inputs of in-scope datapoint [ x ′ , y ′ ] have very similar input x ′ (rephrases) to the input x e of edit descriptors [ x e , z e ] and the output ground truth of these in-scope examples are identical to the output of edit descriptor ( y ′ =
Revised: Copy-edit datasets These datasets are designed such that the inputs of in-scope datapoint [ x ′ , y ′ ] have very similar input x ′ (rephrases) to the input x e of edit descriptors [ x e , z e ] and the output ground truth of these in-scope examples are identical to the output of edit descriptor ( y ′ =

Original: y e ).
Revised: y e ).

Original: In other words, Copy-edit datasets require M edit to simply map the in-scope input to the relevant edit descriptor and copy the label from the edit-descriptor.
Revised: In other words, Copy-edit datasets require M edit to simply map the in-scope input to the relevant edit descriptor and copy the label from the edit-descriptor.

Original: We include the following 3 copy-edit datasets:
Revised: We include the following 3 copy-edit datasets:

Original: zsRE Question Answering : It contains 151631 questions based on factual knowledge from Wikipedia (Levy et al., 2017).
Revised: zsRE Question Answering : It contains 151631 questions based on factual knowledge from Wikipedia (Levy et al., 2017).

Original: We use the train/validation/test split similar to De Cao et al.
Revised: We use the train/validation/test split similar to De Cao et al.

Original: The in-scope inputs are rephrased questions with the same answer.
Revised: The in-scope inputs are rephrased questions with the same answer.

Original: FEVER Fact-checking (Thorne et al., 2018):
Revised: FEVER Fact-checking (Thorne et al., 2018):

Original: It contains 115409 factual claims with True/False labels.
Revised: It contains 115409 factual claims with True/False labels.

Original: In-scope data include rephrases of updated fact x e in the edit-descriptor. 3.
Revised: In-scope data include rephrases of updated fact x e in the edit-descriptor. 3.

Original: Wikipedia Text Generation :
Revised: Wikipedia Text Generation :

Original: For each edit descriptor input x e taken from WikiText-103, an alternate 10-token completion generated from a pre-trained distilGPT-2 model is chosen as output.
Revised: For each edit descriptor input x e taken from WikiText-103, an alternate 10-token completion generated from a pre-trained distilGPT-2 model is chosen as output.

Original: There are no alternate in-scope inputs; therefore, this tests whether the model can replicate y e .
Revised: There are no alternate in-scope inputs; therefore, this tests whether the model can replicate y e .

Original: Entail-edit datasets These datasets were chosen such that in-scope examples have complex entailment relationships with edit descriptors and require retaining and leveraging additional knowledge from beliefs of the base model.
Revised: Entail-edit datasets These datasets were chosen such that in-scope examples have complex entailment relationships with edit descriptors and require retaining and leveraging additional knowledge from beliefs of the base model.

Original: These benchmarks may include hard out-scope data related to edit descriptors but with a different label.
Revised: These benchmarks may include hard out-scope data related to edit descriptors but with a different label.

Original: We evaluate on following 2 datasets used in Hase et al.
Revised: We evaluate on following 2 datasets used in Hase et al.

Original: LeapOfThought (LoT): This dataset introduced by Talmor et al.
Revised: LeapOfThought (LoT): This dataset introduced by Talmor et al.

Original: (2020) consists of claims labeled as true or false based on supporting facts.
Revised: (2020) consists of claims labeled as true or false based on supporting facts.

Original: Wikidata

Revised: Wikidata

Original: m: This benchmark uses a relational database (Wang et al., 2021) similar to Hase et al.
Revised: m: This benchmark uses a relational database (Wang et al., 2021) similar to Hase et al.

Original: (2021) to build this dataset.
Revised: (2021) to build this dataset.

Original: The database contains triplets ( o 1 , r, o 2 )
Revised: The database contains triplets ( o 1 , r, o 2 )

Original: where
Revised: where

Original: oand o 2 are objects with relation r .
Revised: oand o 2 are objects with relation r .

Original: In general cases, a triplet ( o 1 , r, o 2 ) is not related to triplet ( o 1 , r ′ , o 3 ) ; therefore, having ( o 1 , r, o 2 ) as an edit should not affect the prediction of ( o 1 , r ′ , o 3 ) , unless r ′ is a paraphrase of r .
Revised: In general cases, a triplet ( o 1 , r, o 2 ) is not related to triplet ( o 1 , r ′ , o 3 ) ; therefore, having ( o 1 , r, o 2 ) as an edit should not affect the prediction of ( o 1 , r ′ , o 3 ) , unless r ′ is a paraphrase of r .

Original: This property allows the benchmark to test M edit ’s ability in discriminating the hard out-scope inputs (with unrelated r ′ ) from in-scope inputs (with paraphrased r ).
Revised: This property allows the benchmark to test M edit ’s ability in discriminating the hard out-scope inputs (with unrelated r ′ ) from in-scope inputs (with paraphrased r ).

Original: We provide examples from each dataset in Table 1.
Revised: We provide examples from each dataset in Table 1.

Original: 5. B ASELINE METHODS
Revised: 5. B ASELINE METHODS

Original: We includes four gradient-based (1 to 4) and one memory-based methods.
Revised: We includes four gradient-based (1 to 4) and one memory-based methods.

Original: Each of them may target different aspects of model editing problem and have specific strength.
Revised: Each of them may target different aspects of model editing problem and have specific strength.

Original: We compare all of them under a coherent experimental setting.
Revised: We compare all of them under a coherent experimental setting.

Original: These methods are:
Revised: These methods are:

Original: FT:
Revised: FT:

Original: It directly fine-tunes the model with edit descriptor using the total loss L (Equation 7).
Revised: It directly fine-tunes the model with edit descriptor using the total loss L (Equation 7).

Original: ENN (Sinitsin et al., 2020): Editable Neural Networks (ENN) uses a bi-level optimization meta-learning similar to MAML (Finn et al., 2017) to make the base model adaptable to simple fine-tuning with edit descriptors.
Revised: ENN (Sinitsin et al., 2020): Editable Neural Networks (ENN) uses a bi-level optimization meta-learning similar to MAML (Finn et al., 2017) to make the base model adaptable to simple fine-tuning with edit descriptors.

Original: SLAG (Hase et al., 2021):
Revised: SLAG (Hase et al., 2021):

Original: It extends the learned optimizer method from De Cao et al.
Revised: It extends the learned optimizer method from De Cao et al.

Original: (2021) for a larger amount of edits and entailed edits.
Revised: (2021) for a larger amount of edits and entailed edits.

Original: MEND (Mitchell et al., 2021):
Revised: MEND (Mitchell et al., 2021):

Original: It is a state-of-art method that learns a special neural networks to generate the gradient update for specific layers of the base model during fine-tuning.
Revised: It is a state-of-art method that learns a special neural networks to generate the gradient update for specific layers of the base model during fine-tuning.

Original: SERAC (Mitchell et al., 2022):
Revised: SERAC (Mitchell et al., 2022):

Original: The state-of-art memory-based method performs particularly effectively on copy-edit datasets.
Revised: The state-of-art memory-based method performs particularly effectively on copy-edit datasets.

Original: 5. B ACKBONE MODEL AND TASK - SPECIFIC ARCHITECTURE
Revised: 5. B ACKBONE MODEL AND TASK - SPECIFIC ARCHITECTURE

Original: For base models, similar to Mitchell et al.
Revised: For base models, similar to Mitchell et al.

Original: (2022; 2021), we use pre-trained T5 model (Raffel et al., 2020) (
Revised: (2022; 2021), we use pre-trained T5 model (Raffel et al., 2020) (

Original: [Table]
Revised: [Table]

Original: for LeapOfThought and Wikidata5m. We edit only the last two layers of the backbone models’ encoders and decoders for all gradient-based methods.
Revised: for LeapOfThought and Wikidata5m. We edit only the last two layers of the backbone models’ encoders and decoders for all gradient-based methods.

Original: For both ZSRE and Wikipedia generation, we use t5-small for the edit encoder due to its small computational complexity and memory consumption.
Revised: For both ZSRE and Wikipedia generation, we use t5-small for the edit encoder due to its small computational complexity and memory consumption.

Original: We use bert-base-uncased for FEVER and facebook/bart-base encoder for LeapOfThought and Wikidata5m.
Revised: We use bert-base-uncased for FEVER and facebook/bart-base encoder for LeapOfThought and Wikidata5m.

Original: 5. E VALUATION M ETRICS
Revised: 5. E VALUATION M ETRICS

Original: Following prior works (Sinitsin et al., 2020; De Cao et al., 2021; Hase et al., 2021; Mitchell et al., 2021; 2022), we use Edit Success (ES) and Drawdown (DD) as evaluation metrics.
Revised: Following prior works (Sinitsin et al., 2020; De Cao et al., 2021; Hase et al., 2021; Mitchell et al., 2021; 2022), we use Edit Success (ES) and Drawdown (DD) as evaluation metrics.

Original: Edit Success (ES) measures the ability of the model to change its predictions on in-scope inputs based on edit descriptors.
Revised: Edit Success (ES) measures the ability of the model to change its predictions on in-scope inputs based on edit descriptors.

Original: For a model M edit with edit descriptors Z e , the edit success is defined as the average times the prediction of the model is an exact match to the ground truth of in-scope input:
Revised: For a model M edit with edit descriptors Z e , the edit success is defined as the average times the prediction of the model is an exact match to the ground truth of in-scope input:

Original: [Equation]
Revised: [Equation]

Original: Drawdown(DD) measures model’s ability to retain similar predictions for out-scope inputs.
Revised: Drawdown(DD) measures model’s ability to retain similar predictions for out-scope inputs.

Original: DD is defined as:
Revised: DD is defined as:

Original: [Equation]
Revised: [Equation]

Original:  R ESULTS 6. M ODEL E DITING PERFORMANCE
Revised:  R ESULTS 6. M ODEL E DITING PERFORMANCE

Original: To analyze the performance of S E P RO G and baselines on edit batches of varying sizes, we evaluate for batch sizes in { 1 , 4 , 10 , 20 , 64 , 128 } .
Revised: To analyze the performance of S E P RO G and baselines on edit batches of varying sizes, we evaluate for batch sizes in { 1 , 4 , 10 , 20 , 64 , 128 } .

Original: The average Edit Success (ES) and Drawdown (DD) are reported in Table 2.
Revised: The average Edit Success (ES) and Drawdown (DD) are reported in Table 2.

Original: On copy-edit datasets, SERAC significantly outperforms other models in both
Revised: On copy-edit datasets, SERAC significantly outperforms other models in both

Original: ES and DD due to the easier task of classifying in-scope and out-scope data and copying labels of relevant edit descriptors for in-scope inputs.
Revised: ES and DD due to the easier task of classifying in-scope and out-scope data and copying labels of relevant edit descriptors for in-scope inputs.

Original: In the case of entail-edit datasets, on average (over all batch sizes) S E P RO G outperforms baselines by 1-7% in ES and has comparable drawdown to best performing models.
Revised: In the case of entail-edit datasets, on average (over all batch sizes) S E P RO G outperforms baselines by 1-7% in ES and has comparable drawdown to best performing models.

Original: We will now look at the performance of models across varying edit batch sizes as shown in Figure 2.
Revised: We will now look at the performance of models across varying edit batch sizes as shown in Figure 2.

Original: Performance on copy-edit datasets across batch size SERAC consistently outperforms all other models across varying batch sizes due reasons discussed above.
Revised: Performance on copy-edit datasets across batch size SERAC consistently outperforms all other models across varying batch sizes due reasons discussed above.

Original: However, we observe that S E P RO G consistently outperforms all other gradient-based baselines in both ES and DD for larger edit batch sizes (64 and 128) with 7-30% better ES and 14-20% DD.
Revised: However, we observe that S E P RO G consistently outperforms all other gradient-based baselines in both ES and DD for larger edit batch sizes (64 and 128) with 7-30% better ES and 14-20% DD.

Original: This is due to our approach of generating prompts based on the automatic selection of relevant edit descriptors and providing these prompts as prefixes to the decoder without changing the weights of the base model.
Revised: This is due to our approach of generating prompts based on the automatic selection of relevant edit descriptors and providing these prompts as prefixes to the decoder without changing the weights of the base model.

Original: Performance on entail-edit dataset across batch sizes Unlike the previous case, SERAC’s performance is poor in entail-edit datasets that require knowledge from the base model to deal with entailed predictions for in-scope inputs.
Revised: Performance on entail-edit dataset across batch sizes Unlike the previous case, SERAC’s performance is poor in entail-edit datasets that require knowledge from the base model to deal with entailed predictions for in-scope inputs.

Original: For larger batches (64 and 128), S E P RO G outperforms all
Revised: For larger batches (64 and 128), S E P RO G outperforms all

Original: [Figure]
Revised: [Figure]

Original: ES and DD of S E P RO G and baselines across varying edit batch sizes.

Original: baselines in ES with 13-20% better scores.
Revised: baselines in ES with 13-20% better scores.

Original: Meanwhile, S E P RO G’s DD performance is comparable to SERAC, both of which outperform gradient-based baselines.
Revised: Meanwhile, S E P RO G’s DD performance is comparable to SERAC, both of which outperform gradient-based baselines.

Original: Therefore, due to the combination of separate edit descriptor retrieval mechanism as well as leveraging information from base model,
Revised: Therefore, due to the combination of separate edit descriptor retrieval mechanism as well as leveraging information from base model,

Original: S E P RO G overcomes shortcomings of both memory-based and gradient-based baselines to provide state-of-art performance on entail-edit datasets for large edit batches.
Revised: S E P RO G overcomes shortcomings of both memory-based and gradient-based baselines to provide state-of-art performance on entail-edit datasets for large edit batches.

Original: 6. E FFICIENCY OF S E P RO G
Revised: 6. E FFICIENCY OF S E P RO G

Original: A major issue with the deployment of gradient-based methods is their large compute and memory requirements, making it prohibitively expensive for editing large language models.
Revised: A major issue with the deployment of gradient-based methods is their large compute and memory requirements, making it prohibitively expensive for editing large language models.

Original: For example,
Revised: For example,

Original: ENN needs to compute hypergradients on model weights during the training of the base model.
Revised: ENN needs to compute hypergradients on model weights during the training of the base model.

Original: While methods like MEND and SLAG use a separate set of neural networks to modify gradient updates of the base model, computing the hypergradients to train these neural networks is still expensive and consumes much memory.
Revised: While methods like MEND and SLAG use a separate set of neural networks to modify gradient updates of the base model, computing the hypergradients to train these neural networks is still expensive and consumes much memory.

Original: Memory-based methods, like SERAC and our S E P RO G, act as wrappers around the base model without updating the base model’s weights.
Revised: Memory-based methods, like SERAC and our S E P RO G, act as wrappers around the base model without updating the base model’s weights.

Original: Moreover, while SERAC trains a separate counterfactual model to deal with in-scope inputs, S E P RO G only learns to generate prefix prompts and does not need to train another language model.
Revised: Moreover, while SERAC trains a separate counterfactual model to deal with in-scope inputs, S E P RO G only learns to generate prefix prompts and does not need to train another language model.

Original: However, S E P RO G needs to calculate gradients of the decoder model to derive the intermediate gradients ∇ pr ( x,Z e ) L w.r.t the input prompt.
Revised: However, S E P RO G needs to calculate gradients of the decoder model to derive the intermediate gradients ∇ pr ( x,Z e ) L w.r.t the input prompt.

Original: [Table]
Revised: [Table]

Original: To measure the compute and memory requirement during editing of a large language model, we measure the time it takes and the peak GPU memory usage during training and inference for a single batch of size 64 of ZSRE dataset (with T5 base model) on an NVIDIA Tesla V100 GPU with 
Revised: To measure the compute and memory requirement during editing of a large language model, we measure the time it takes and the peak GPU memory usage during training and inference for a single batch of size 64 of ZSRE dataset (with T5 base model) on an NVIDIA Tesla V100 GPU with 32 GB

Original: GB VRAM in Table 3.
Revised: VRAM in Table 3 (Results for additional batch sizes are in Appendix Section C).

Original: During training, we observe that the time and memory requirements of S E P RO G are  3 times and 2 times lesser than the most efficient gradient-based baselines, respectively.
Revised: During training, we observe that the time and memory requirements of S E P RO G are around 3 times and 2 times lesser than the most efficient gradient-based baselines, respectively.

Original: SERAC is observed to be two times more efficient than S E P RO G forboth compute time and memory usage.
Revised: SERAC is observed to be 1.8 and 1.2 times more efficient than S E P RO G for compute time and memory usage respectively.

Original: However, during inference, S E P RO G uses the least memory since it does not need to calculate gradients like gradient-based methods or use two separate language models for in-scope and out-scope inputs like SERAC.
Revised: However, during inference, S E P RO G uses the least memory since it does not need to calculate gradients like gradient-based methods or use two separate language models for in-scope and out-scope inputs like SERAC.

Original: 6. A BLATION STUDIES Ablation variants of S E P RO G
Revised: 6. A BLATION STUDIES Ablation variants of S E P RO G

Original: We study the effectiveness of prompt-generating without finetuning model weights as well as the efficacy of edit classifier modules using the following variants of
Revised: We study the effectiveness of prompt-generating without finetuning model weights as well as the efficacy of edit classifier modules using the following variants of

Original: S E P RO G:
Revised: S E P RO G:

Original: • SP-F INE T UNE : We use generated prefixes from S E P RO G and fine-tune the base model.
Revised: • SP-F INE T UNE : We use generated prefixes from S E P RO G and fine-tune the base model.

Original: • SP-N O C LASSIFIER :
Revised: • SP-N O C LASSIFIER :

Original: We remove the edit classifier (Equation 3) and do not use Scope Classification Loss.
Revised: We remove the edit classifier (Equation 3) and do not use Scope Classification Loss.

Original: • SP-N O S ELECT :
Revised: • SP-N O S ELECT :

Original: We have scope classification during training but remove it in inference.
Revised: We have scope classification during training but remove it in inference.

Original: In other words, the generated prefix will always inject into the decoder, no matter whether the input is in-scope or out-scope.
Revised: In other words, the generated prefix will always inject into the decoder, no matter whether the input is in-scope or out-scope.

Original: Prefix-tuning has shown to be an efficient method of tuning a large language model Li & Liang (2021).
Revised: Prefix-tuning has shown to be an efficient method of tuning a large language model Li & Liang (2021).

Original: Moreover, Li & Liang (2021) and Lester et al. (2021) showed that they are more generalizable to domain transfers and don’t overfit to training data.
Revised: Moreover, Li & Liang (2021) and Lester et al. (2021) showed that they are more generalizable to domain transfers and don’t overfit to training data.

Original: Therefore, SP-F INE T UNE is designed to test the hypothesis that using prompt generation alone is a more effective method of preventing overfitting and handling large edit batches than updating model weights on new datasets.
Revised: Therefore, SP-F INE T UNE is designed to test the hypothesis that using prompt generation alone is a more effective method of preventing overfitting and handling large edit batches than updating model weights on new datasets.

Original: We also test the efficacy of having a separate classifier module to avoid interference between in-scope and out-scope inputs during training and inference through SP-N O C LASSIFIER and SP-N O S ELECT , respectively.[Figure] [Table] [Figure]
Revised: We also test the efficacy of having a separate classifier module to avoid interference between in-scope and out-scope inputs during training and inference through SP-N O C LASSIFIER and SP-N O S ELECT , respectively.

Original: [Table]

Original: [Figure]

Original: [Table]

Original: [Figure]

Original: [Table]

Original: [Figure]

Original: [Table]

Original: [Figure]

Original: [Table]

Original: [Figure]

Original: [Table]

Original: [Figure]
Revised: [Figure]

Original: Edit performance of the ablation variants We compare ES and DD for all edit batch sizes in
Revised: Edit performance of the ablation variants We compare ES and DD for all edit batch sizes in

Original: Figure 3.
Revised: Figure 3.

Original: On average, we observe that S E P RO G outperforms the best performing variant in both ES and DD by 5% and 31%, respectively.
Revised: On average, we observe that S E P RO G outperforms the best performing variant in both ES and DD by 5% and 31%, respectively.

Original: For larger batch sizes of 64 and 128, we observe 8% better ES and 24% better DD on average.
Revised: For larger batch sizes of 64 and 128, we observe 8% better ES and 24% better DD on average.

Original: SP-N O C LASSIFIER is the worst performing model in terms of DD, followed by SP-N O S ELECT , showing the efficacy of the edit classifier module both for tuning the modules of S E P RO G via additional signal for learning supervision as well as for selecting when to append prefix prompts.
Revised: SP-N O C LASSIFIER is the worst performing model in terms of DD, followed by SP-N O S ELECT , showing the efficacy of the edit classifier module both for tuning the modules of S E P RO G via additional signal for learning supervision as well as for selecting when to append prefix prompts [Figure]

Original:  C ONCLUSION
Revised:  C ONCLUSION

Original: We proposed S E P RO G, a prefix generation model for effective model editing over large edit batch sizes.
Revised: We proposed S E P RO G, a prefix generation model for effective model editing over large edit batch sizes.

Original: S E P RO G overcomes the scalability issues of gradient-based methods and inflexibility of memory-based approaches by directly leveraging the base model for adapting to edit dataset by providing appropriate prefix prompts based on the relevance of input to edit dataset.
Revised: S E P RO G overcomes the scalability issues of gradient-based methods and inflexibility of memory-based approaches by directly leveraging the base model for adapting to edit dataset by providing appropriate prefix prompts based on the relevance of input to edit dataset.

Original: We observed up to 30% improvement in edit performance over gradient-based models on copy-edit datasets and up to 20% better scores than all state-of-art models for harder entail-edit datasets with large edit batches.
Revised: We observed up to 30% improvement in edit performance over gradient-based models on copy-edit datasets and up to 20% better scores than all state-of-art models for harder entail-edit datasets with large edit batches.

Original: Due to our prefix generation model, learning over a much smaller number of parameters S E P RO G is also 2-3 times more efficient than gradient-based approaches.
Revised: Due to our prefix generation model, learning over a much smaller number of parameters S E P RO G is also 2-3 times more efficient than gradient-based approaches.

Original: Appendix for Semi-parametric Prompt-Generation for Model Editing A D ATASET AND B ASELINE C ODE
Revised: Appendix for Semi-parametric Prompt-Generation for Model Editing A D ATASET AND B ASELINE C ODE

Original: The copy-edit datasets were sourced from Mitchell et al.
Revised: The copy-edit datasets were sourced from Mitchell et al.

Original: LeapOfThought dataset was constructed based on code from Hase et al.
Revised: LeapOfThought dataset was constructed based on code from Hase et al.

Original: We also use the same train/validation/test splits as in the official data sources.
Revised: We also use the same train/validation/test splits as in the official data sources.

Original: We use the code for all gradient-based methods except SLAG from the official code of Mitchell et al.
Revised: We use the code for all gradient-based methods except SLAG from the official code of Mitchell et al.

Original: We used official implementation of SLAG from the authors Hase et al.
Revised: We used official implementation of SLAG from the authors Hase et al.

Original: Since the official implementation for SERAC is not publicly available at the time of writing, we implemented it based on details from Mitchell et al.
Revised: Since the official implementation for SERAC is not publicly available at the time of writing, we implemented it based on details from Mitchell et al.

Original: and observed the results to be similar to that reported in the paper.
Revised: and observed the results to be similar to that reported in the paper.

Original: B H YPERPARAMETERS
Revised: B H YPERPARAMETERS

Original: Architecture Details We appended a single feed-forward layer of 768 units to all edit encoders such that h ei ∈ R 768 .
Revised: Architecture Details We appended a single feed-forward layer of 768 units to all edit encoders such that h ei ∈ R 768 .

Original: The learnable weight W att of CrossAttention has dimensions 768 × d where d is the output dimensions of b ( x ) from base encoder E base .
Revised: The learnable weight W att of CrossAttention has dimensions 768 × d where d is the output dimensions of b ( x ) from base encoder E base .

Original: NN e is a two-layer feed-forward with all hidden and output layers having 768 units.
Revised: NN e is a two-layer feed-forward with all hidden and output layers having 768 units.

Original: While larger prefix-length p generally provides better performance (Li & Liang, 2021), we found the marginal performance gains to be minimal for p greater than 32 in all benchmarks.
Revised: While larger prefix-length p generally provides better performance (Li & Liang, 2021), we found the marginal performance gains to be minimal for p greater than 32 in all benchmarks.

Original: Training specifics
Revised: Training specifics

Original: In all benchmarks, we used an Adam optimizer (Kingma & Ba, 2014) with a linear warm-up in learning rate over the first 200 epochs and gradient clipping threshold set at 5.0.
Revised: In all benchmarks, we used an Adam optimizer (Kingma & Ba, 2014) with a linear warm-up in learning rate over the first 200 epochs and gradient clipping threshold set at 5.0.

Original: We use early stopping with the patience of 200 epochs over total loss on the validation data for copy-edit datasets and 1000 epochs for entail-edit datasets.
Revised: We use early stopping with the patience of 200 epochs over total loss on the validation data for copy-edit datasets and 1000 epochs for entail-edit datasets.

Original: For each benchmark, we mostly tuned over learning rate and λ and found that the learning rate between 1e-5 and 1e-4 and λ ∈ [0 . 1 , 0 . 5] provided good performance.
Revised: For each benchmark, we mostly tuned over learning rate and λ and found that the learning rate between 1e-5 and 1e-4 and λ ∈ [0 . 1 , 0 . 5] provided good performance.

Original: During training, we sample the same number of in-scope and out-scope samples per batch and we use only in-scope examples to derive prompt guidance loss whereas we use both for scope classification loss. 
Revised: During training, we sample the same number of in-scope and out-scope samples per batch and we use only in-scope examples to derive prompt guidance loss whereas we use both for scope classification loss. C T RAINING AND INFERENCE TIMES FOR VARYING BATCH SIZES [Table] [Table]

Revised: [Table]