CoLLEGe: Concept Embedding Generation for Large Language Models

Authors: ryan  teehan
brenden m lake
mengye  ren
Venue: colmweb_org_COLM_2024_Conference
Published: 2024-03-22 20:57:50

Abstract: Current language models are unable to quickly learn new concepts on the fly, often requiring a more involved finetuning process to learn robustly. Prompting in-context is not robust to context distractions, and often fails to confer much information about the new concepts. Classic methods for few-shot word learning in NLP, relying on global word vectors, are less applicable to large language models. In this paper, we introduce a novel approach named **CoLLEGe** (**Co**ncept **L**earning with **L**anguage **E**mbedding **Ge**neration) to modernize few-shot concept learning. CoLLEGe is a meta-learning framework capable of generating flexible embeddings for new concepts using a small number of example sentences or definitions. Our primary meta-learning objective is simply to facilitate a language model to make next word predictions in forthcoming sentences, making it compatible with language model pretraining. We design a series of tasks to test new concept learning in challenging real-world scenarios, including new word acquisition, definition inference, and verbal reasoning, and demonstrate that our method succeeds in each setting **without task-specific training**. Code and data for our project can be found at [https://college-concept-learning.github.io/](https://college-concept-learning.github.io/).

Main paper: 
 introduction: 
 Imagine a student first attending a philosophy lecture on epistemology, wherein their professor discusses and critiques the positions of idealists, pragmatists, and foundationalists, among others. Some concepts and terms, such as idealism or pragmatism, may be familiar from past experience but in this new and unfamiliar context they seem to have taken on new meaning. Other concepts may be entirely new, including the concept of "epistemology" itself. During the lecture, the examples the professor provides for each concept, as well as the sentences they use when discussing them, allow the student to form an initial sense of their meaning and usage. With time, additional examples, and using the concepts directly in writing, the student's knowledge solidifies and what was once unfamiliar is now intuitive.Building intuitions about the meaning of unfamiliar concepts in this way, with only a few examples of their usage, is common in real-world human learning, but remains difficult for language models, particularly when we want to consolidate this knowledge into discrete tokens. Providing a few in-context examples of how to use these new tokens can be a stopgap, but is often less powerful the additional examples can serve as distractors that confuse the language model, to say nothing about how unnatural it is (imagine if, each time the professor wanted the student to answer a question about epistemological idealism, they began by repeating a few sentences containing "idealism"). Instead, with a few example sentences, language models should know general semantic knowledge about this new concept, similar to the knowledge encoded in their pretrained representations. We frame this as a few-shot learning problem, where, given a few example sentences, the goal is generate an embedding for a new concept token with expressive and task-general semantic information.Prior work on few-shot word learning in natural language focused on leveraging the seminal works on global word vector representations (Mikolov et al., 2013; Pennington et al., 2014;  The delicate diamond sparkled beautifully on her chest, catching the light in a mesmerizing dance of colors.The emerald , delicately hanging from her neck, shimmered under the soft glow of the chandelier.The definition of is a piece of jewelry worn around the neck. ? ?Figure 1 : Our model generates an embedding for an unseen token given one or a few example sentences. The ground truth word is pendant, and the model is able to generate an accurate definition using the embedding produced by CoLLEGe. Khodak et al., 2018; Lampinen & McClelland, 2017) . However, these methods are less well suited to augmenting the knowledge of contemporary large language models. First, the embeddings generated from methods based on global word vector representations may be difficult to adapt to the representation space of contemporary language models. Additionally, learned contextual representations from pretrained language models provide a more powerful and semantically rich source for few-shot concept learning, allowing for complex usage of new concepts using embeddings generated from only a few examples.Furthermore, prior evaluation methods for new concept learning were limited to noisy proxy measures, such as the correlation between embedding cosine similarity and human similarity judgements (Lazaridou et al., 2017) , or the cosine similarity between the few-shot concept embeddings and "ground truth" Word2Vec embeddings (e.g. the definitional nonce in Herbelot & Baroni (2017) ). Current language models are able to use language in highly sophisticated and complex ways; true evaluation of few-shot concept learning in this setting should assess whether new concepts can be used in similarly complex and sophisticated ways. What older evaluations measure tell us little about how well language models can use learned concepts. How well can they define a concept given only a few examples? Can they correctly answer fill-in-the-blank questions for difficult words? We ask humans the same questions to determine how well they have internalized a new concept. Our evaluations of language models should follow suit.In this paper, we present CoLLEGe, a novel and conceptually simple framework to enable large language models to quickly learn new concept tokens. To evaluate our method, we develop a suite of tasks to directly evaluate how well these concepts are learned, including GRE-style fill-in-the-blank verbal reasoning, definition inference and generation, and Internet slang usage. Our method leverages the vast amount of pre-training data and learning can be seamlessly embedded in the model pre-training process. We discover that training techniques such as an example buffer, negative example sampling, and knowledge distillation contributed significantly to the model's concept learning performance. Moreover, thanks to our general pre-training procedure, our model is able to transfer to these concept learning tasks in a zero-shot manner with no additional task-specific training needed, while maintaining the LLM's original performance on regular data.In summary, our contributions are:• A simple add-on learnable module for few-shot, LLM concept learning;• An approach to training our algorithm which combines an example buffer, negative sampling, and knowledge distillation. We show that each of these components plays an important role in learning;• Three challenging datasets -CoLLEGe-GRE, CoLLEGe-DefGen, and CoLLEGe-Slangused to measure the effectiveness of few-shot concept learning methods for LLMs. These datasets test both general and complex concept knowledge, naturalistic acquisition of new concepts, and relational abstraction;• Experiments showing that, by training an embedding generation modules in a taskgeneral manner, we can generate embeddings that allow a pretrained LLM to: a) generate plausible definitions for new concepts, b) correctly solve fill-in-the-blank tasks for difficult  
related work: 
 Few-Shot Word Learning: A classic and related task in NLP is rare word learning (Luong et al., 2015) . Lazaridou et al. (2017) create the synthetic "chimera" concepts and provide early evidence that summation over (global) word vectors in the context surrounding a new or rare word can produce a useful embedding. Khodak et al. (2018) build on this, presenting a method which includes a learned linear transformation to account for shared features across global word vectors. Lampinen & McClelland (2017) present an even simpler method, involving freezing the majority of the weights of the network and using gradient descent to tune only the weights related to the new word(s). For a more complex approach, Herbelot & Baroni (2017) modify the Word2Vec algorithm for more effective few-shot learning. More modern approaches include HiCE (Hu et al., 2019) , which uses Transformer layers to induce a new word embedding from Word2Vec embeddings, and Mem2Vec (Sun et al., 2018) , which uses a long-term memory system. Similarly, Weston et al. (2015) model new words by using contextual examples from memory. They store a bag-of-words for the left and right context surrounding the new word, and simulate new word learning with a fixed percent of words encountered during training. Instead of using global word vectors to represent the context, we use the contextual representations from a frozen MLM to learn a representation for the new concept token. We also combine autoregressive losses, cosine distance, and distillation loss to train our model, whereas older work either reused the Skip-gram objective or used cosine distance. Other approaches incorporate morphological information (Luong et al., 2013; Schick & Sch ütze, 2019) . While these methods are useful, particlarly for learning global word vector representations, they are less useful for augmenting the embeddings of pretrained LLMs. In part, this is because global word vectors do not map easily to the pretrained LLM embedding space. Additionally, global word vector representations are often less informative than the pretrained representations from BERT-style models.Meta-Learning: Matching Networks (Vinyals et al., 2016) and Prototypical Networks (Snell et al., 2017) both approach few-shot learning as a meta-learning problem. Online prototypical networks (Ren et al., 2021) build on the latter for novel concept learning in an online and continual fashion. Our approach is also related to fast-weight networks (Schmidhuber, 1992) , since we use the support sequences to generate a fast embedding weight for the new concept.For language, meta-learning is often used for knowledge augmentation (Hu et al., 2023) , task adaptation (Chen et al., 2022; Zhong et al., 2021; Bansal et al., 2020) , domain adaptation (Qian & Yu, 2019; Li et al., 2020; Geng et al., 2019) , rare word recognition (Lux & Vu, 2021) (in ASR), and word sense disambiguation Holla et al. (2020) , among other applications (Lee et al., 2022) . Some recent methods frame meta-learning as a sequence modeling problem, drawing inspiration from in-context learning (Chen et al., 2022; Fifty et al., 2024) . Finally, Lake & Baroni (2023) recently developed a method for learning compositional concepts. In our work, context sentences are encoded to generate a new embedding, conceptually similar to a prototype for the new concept, to optimize a general language modeling objective, rather than a collection of task objectives.Compression: A number of methods exist to compress sentences into new embeddings or tokens. Prior work in NLP developed methods for generating task-general embeddings from natural language sentences (Conneau et al., 2017; Kiros et al., 2015; Wang et al., 2020) .ReadOnce (Lin et al., 2021 ) is a more recent method for generating compressed document representations which can be used across a variety of downstream tasks. Similarly, recent methods compress prompts (Chevalier et al., 2023; Ge et al., 2024; Mu et al., 2024) or documents Xu et al. (2024) into summary vectors either as a form of memory or a method for re-using prompts (e.g. when specifying instructions). RMT (Bulatov et al., 2022)  
college: concept learning with language embedding generation: 
 In this section, we describe our proposed approach for enabling LLMs to quickly learn new concept tokens. Given a new word or concept and a set of example sentences containing that word or concept, we want to produce an embedding that captures its semantically meaningful features. We visualize this process for a simple language modeling example in Figure 2 .Framing this as a few-shot learning problem, we use a set of K support sequences {s 1 , ..., s K }, containing a new token, <nonce> to produce a useful embedding for this new token. The new embedding can then be used to augment the knowledge of a frozen autoregressive language model. During training, we encourage the LM to use the new embedding to correctly generate a query sequence q.Concept Embedding Generation: To perform this generation, the new token in each support sequence is replaced with a <mask> token, and each is embedded with a frozen masked language model (MLM) used for feature extraction. The contextual embeddings for each sequence are then passed through an additional Transformer self-attention layer to process the contextual embeddings for each sequence to obtain {h i,t }. These are then aggregated using mean pooling, producing k sequence embeddings {e 1 , ..., e k }:e i = 1 n i ∑ n i t=1 h i,t, where n i is the length of each sequence. The sequence embeddings are aggregated once more using mean pooling, producing a single output embedding e new : e new = 1 K ∑ K i=1 e i . Mean pooling can also facilitate incremental consolidation of new concepts without having to store past examples. To integrate the embedding with a frozen autoregressive LM, we apply two distinct linear layers to produce an input and output embedding for the new token e in and e out : [e in , e out ] = Linear(e new ). The autoregressive LM's input and output token embedding matrices are then expanded with these generated embeddings, and used to model the query sequence.W emb in, new = [W emb in , e in ],(1)W emb out, new = [W emb out , e out ].(2)Sampling Few-Shot Learning Episodes: One novel aspect of our framework is that, unlike many meta-learning approaches, our training procedure follows the same style as pretraining by directly leveraging text data from the pretraining datasets. We hypothesize that a good way to rapidly learn new concept is to actually "use" the concept in another sentence-we let an LLM consume the newly learned embedding to generate another sentence. Moreover, the autoregressive cross entropy loss is the same as the pretraining objective, so, in theory, our meta-learning procedure can be perfectly blended into the pretraining stage.To efficiently sample support and query sequences, terms we borrow from the few-shot learning literature, we save sentences containing a new token in an example buffer to serve as support sequences, and when we encounter the same token being used again in the training corpus, we will use the sequence as a query sequence. The query sequence can then be saved in the example buffer and used as a support sequence again. We find that reusing query sequences as support sequences is helpful for training and allows the model to make containing the new token, tended to yield generated embeddings with norms of much higher magnitude than those of other LLM input or output token embeddings. One hypothesis was that, since every example the model has to learn contains a new token, it prefers to converge an embedding with high norm, to ensure that the new token appears in the query sequence. During normal pretraining, few tokens are shared across all sequences, and language models learn both when to generate and when not to generate each token. To likewise teach our model when not to generate a new token, we sample a sequence without a new token, which we call a negative example, and take the sum of the cross entropy loss on the positive example, L + ce , and the cross entropy loss on the negative example, L - ce . Knowledge Distillation: Since we pretrain by replacing existing words with new tokens, we can compute the "true" language model embeddings and logits for the remainder of the sequence. Ideally, we want the generated embeddings from our model to match the ground truth embeddings and logits as faithfully as possible, to better approximate the underlying language model distribution. To do this, we retain the original sequence, before masking a word with a new token, and compute the output embeddings and logits for the rest of the sequence with a non-augmented version of our pretrained autoregressive model. We then compute the cosine distance between those output embeddings and the output embeddings from CoLLEGe, L cos , as well as the MSE between the CoLLEGe LLM logits and the "true" LLM logits using the original embeddings, L mse . Using a more standard objective with a distillation temperature (Hinton et al., 2015) was less effective during training.In order to compute these two distillation loss terms, we define the positive example token sequence as t 1,+ , ...., t n,+ and original example token sequence as t 1,orig , ...., t l,orig , and additionally construct a deterministic mapping σ : N → N that maps a token at index i in the positive example to its corresponding token at index k in the original sequence. The tokens following the new token in the positive sequence are guaranteed to have a match in the original example sequence, by definition, but the index may be different (if, for example, the word replaced with <nonce> is subtokenized in the original example sequence). We compute our distillation loss terms using:EQUATIONEQUATION)where I new is the set of new token indices in the positive example sequence, E i,• denotes the output embedding at token position i for the positive or negative example sequence, and ℓ i,• denotes the logit vector at token position i for the positive or negative example sequence.Final Loss: Our final training loss is simply a sum of these individual loss terms. We explored using a linear combination of the loss terms to weight each differently, but found TT-1 6.8 ± 0.0 6.8 ± 0.0 6.8 ± 0.0 6.8 ± 0.0 10.9 ± 3.0 8.6 ± 3.1 8.1 ± 3.9 8.8 ± 4.3 TT-2 6.8 ± 0.0 6.8 ± 0.0 6.8 ± 0.0 6.8 ± 0.0 12.3 ± 3.5 9.3 ± 2.5 8.1 ± 5.3 7.6 ± 2.5 HiCE 11.5 ± 5.0 12.5 ± 2.7 13.1 ± 3.6 16.1 ± 4.2 19.3 ± 3.5 15.9 ± 8.2 11.4 ± 2.3 10.6 ± 1.3 Additive 13.6 ± 2.3 9.1 ± 3.9 13.6 ± 3.9 11.4 ± 0.0 12.9 ± 1.3 10.6 ± 6.6 12.9 ± 3.5 7.6 ± 1. 35.0 ± 5.6 40.5 ± 4.3 42.7 ± 3.9 44.5 ± 3.9 42.5 ± 3.9 46.8 ± 3.7 45.2 ± 3.2 49.3 ± 1.5Table 1 : Accuracy in percentage on the GRE Verbal Reasoning task. For Token Tuning, we use LR = 1e-3, as that gave the best performance.it was not significantly better. Our final loss, L total , is:L total = L + ce + L - ce Cross Entropy Losses + L cos + L mse Distillation Losses.(5) 
datasets for training college: 
 In contrast to many other meta-learning methods, which use a specific set of tasks during training, we adopt a training approach that mirrors general-purpose pretraining. In a sense, we treat each query sequence, and each new token in turn, as its own "task" to solve. Pretrained language model representations are highly adaptable, and can be successfully applied to a variety of tasks with simple prompting strategies. By adopting a task-general training method, we train a module that can produce similarly adaptable embeddings on the fly.Because CoLLEGe is designed to learn a single new token per sequence, and the LLM is frozen, training is highly sensitive to data quality, both for the support and query sequences. Additionally, three forms of mismatch between support and query sequences are important to guard against: language, contextual meaning, and knowledge mismatch. The first case is mostly self-explanatory, non-English support sequences for an English query sequence cause difficulties in training. Contextual meaning mismatch was particularly important to avoid when training with the Pile (Gao et al., 2020) , whose examples are drawn from a variety of sources. Creating support and query sequences from WikiText, as in HiCE, often implicitly controls for contextual meaning (all examples are from one source (Wikipedia), and support and query sequences for a word are often unintentionally drawn from the same article and thus share contextual meaning). Likewise, knowledge mismatch is more prominent when training with the Pile, since it contains more diverse sources. If one, or many, support sequences are more confusing than the query sequence, this can destabilize training.Using the Squeakily3 library, we filtered for English text at threshold 0.90 using the FastText (Joulin et al., 2016)  
experiments: 
 In this section, we show experimental results on four different evaluation tasks that we designed: GRE verbal reasoning, definition generation, and slang identification. Note that We compare the model generated definitions with a reference definition using BERTScore and also compute an ELO score for head-to-head comparison. For Token Tuning, we use LR = 3e-4, as that performed best. Definitions are generated 1-, 2-, and 3-shot and scores are averaged.CoLLEGe is a task-general concept embedding generation network, and all of the evaluations are performed zero-shot, without further training or fine-tuning, just like pretrained LLMs. In the following, we first discuss implementation and training details, then describe the baseline methods. Afterwards, we present the core results in Subsections 5.1-5.3.As our pretrained MLM model for the Sequence Encoder, we use RoBERTa-Large (Liu et al., 2019) , and apply a trainable Transformer Encoder layer to encode the RoBERTa sequence embeddings. These embeddings are aggregated using mean-pooling to produce a single embedding per sequence, which is further mean-pooled into our Concept Embedding. We use a pretrained LLaMA-2 7B model (Touvron et al., 2023) as the pretrained autoregressive language model in all our experiments. Further implementation details can be found in Appendix B.In order to evaluate the effectivness of our method, evaluate against baselines from prior work on new concept learnign as well as prompting and gradient descent tuning. More details on implementation for the baselines can be found in Appendix E.• Token Tuning (TT) (Lampinen & McClelland, 2017) finetunes only the new token embedding(s) using gradient descent. The support sequences are treated as the training batch for each step. TT-N denotes N gradient descent steps. Unlike Lampinen & McClelland (2017) , N is kept small here since we found that a large N results in degraded performance.A similar approach has been proposed in Textual Inversion (Gal et al., 2023) for image few-shot learning and generation.• HiCE (Hu et al., 2019) consists of a Transformer sequence encoder as well as a Transformer layer to aggregate the sequence embeddings. It is trained to output an embedding with minimal cosine distance to the true Word2Vec embedding.• Additive (Lazaridou et al., 2017 ) is a simple baseline that consists of summing the Word2Vec embeddings for all tokens in the context that are not the new token.• Prompting uses randomly initialized new token embeddings and includes the support sequences in the prompt. It is a strong baseline with direct context access. Since prompting allows the LM to reason over the tokens in context, it can be combined with our embedding generation approach (see Appendix F for additional experiments). However, prompting original sentences can also make the context window too long and distracting.The GRE verbal reasoning task is a challenging type of question appearing in Graduate Record Examinations that not only tests the understanding of rare vocabulary but also their logical placement in a sentence. We increase the difficulty here by making each multiple choice answer an unknown vocabulary word with a few example sentences as hints. We test whether the CoLLEGe generated concept embeddings can directly support downstream verbal reasoning.Dataset: Using actual GRE practice questions from a Kaplan GRE prep book (Kaplan, 2019) , we design a task where a language model has to either select the top or top-2 choices for a sequence with blanks. Examples for each of these questions are provided in Table 3 : Definitions generated with CoLLEGe, using the prompt "The word <nonce> is defined as". Each definition is generated using the single example sentence shown. None of the example sentences are provided in-context to the model.Reasoning problems with a single blank (i.e. not multi-part). No partial credit is given for selecting one of the two answers for a "top-2" question and chance accuracy is 8.1%. On a version of this task with the real word forms, not new tokens, a pretrained LLaMa-2 7B scores 75%, which serves as an upper bound on our potential performance.To evaluate, we create a version of the sequence for each possible choice, and calculate the log probability of each such sequence. The highest log probability sequence is selected as the chosen answer. The final scores reflect the average accuracy over 10 trials of sampling different example sentences from GPT-4. To probe how well our model understands a new word, we prompt the LLM to generate a definition for the word given one or more example sentences, as shown in Figure 1 .We evaluate on two different datasets to test definition generation: CoLLEGe-DefGen, which we create, and the Oxford dataset used in Giulianelli et al., 2023. To construct CoLLEGe-DefGen, we selected 954 words from WordNet (Miller, 1994) . We then prompt GPT-4 (OpenAI, 2023) to generate an example sentence for the word using the prompt: Give me a unique, descriptive sentence using the word " 2023)'s FLAN-T5 models on our CoLLEGe-DefGen dataset and the Oxford dataset. All evaluations are done 1-shot, with a single example sentence, and the target word is replaced with a new token. fairly precise, for example the generated definition for willies is exactly correct and similarly with copyist. CoLLEGe is also able to identify Wynnea americana as a mushroom. Even when the definition is not quite right, it may capture general features of the concept correctly, and may reflect the limited information contained in the example sentence. The definition for acupressure, for example, is not exactly correct but a very good inference based on the example provided. Additional generated definitions, including those generated using more than one example sentence, are shown in Table 11 in Appendix G.1. We also show side-byside comparisons with the baselines in Table 12 in Appendix G.2. Some failure cases are described in Appendix G.3.In order to evaluate the quality of generated definitions, we compare a definition generated from our model to one generated from a baseline model as well as to a ground truth definition. Definitions are generated 1-, 2-, and 3-shot and results are averaged and reported in Table 2 . For comparison between models, we simulate a head-to-head competition and compute the ELO score (Elo, 1978) of each model. Specifically, for each example in the task dataset, we choose a k-shot setting and sample a baseline at random. We then compare the definition generated by CoLLEGe with the one generated by the baseline. Based on the result-win, lose, or tie-we update the ELO score, starting with an initial score of 1000 for all models. To choose a winner in each "round", we use the Outlines package4 , we ask GPT-3.5 to select which definition is best for the word in question or if they are tied. The order of the choices (both generated definitions and "tie") are randomized. We compute ELO separately for Table 9 . We also compare the generated definitions with ground truth definitions for each word by computing the BERTScore F1 (Zhang et al., 2020) and ROUGE-L (Lin, 2004) . In all three quantitative evaluations, CoLLEGe outperforms the baselines. Qualitatively, only Prompting produces generated definitions that are somewhat competitive. Definitions generated by the other baselines are often incoherent, generating repetitive text or unrelated words and characters.We next compare CoLLEGe with the series FLAN-T5 (Chung et al., 2024) models finetuned by Giulianelli et al. (2023) to generate definitions, which we denote FLAN-Base-DefInstr, FLAN-Large-DefInstr, and FLAN-XL-DefInstr. Each of these models is prompted with an example sentence followed by the question, "What is the definition of [WORD]?". For a fair comparison, we replace the target word with a new token when evaluating the FLAN-T5 models and restrict CoLLEGe to one example sentence, since the finetuned FLAN-T5 models are trained to only use one example as well. Finally, since the FLAN-T5 models are prompted, we include results for Prompting + CoLLEGe as well. The results are presented in Table 4 . When evaluated on our dataset, both CoLLEGe and Prompting + CoLLEGe achieve much higher ROUGE-L scores than all FLAN-T5 models. For BERTScore, Prompting + CoLLEGe outperforms all but FLAN-Large, although all scores are fairly close together. On the Oxford dataset, CoLLEGe and Prompting + CoLLEGe score comparably to the FLAN-T5 models, and Prompting + CoLLEGe slightly outperforms in terms of ROUGE-L. Notably, CoLLEGe achieves this zero-shot, without any additional training on the definition generation task, while the FLAN-T5 models are specialized for this purpose.To emulate new word learning in a more natural setting, we construct a task based on identifying the correct definition for a slang term, using Tweets as example sentences.Model 1-Shot 2-Shot 3-Shot 4-Shot TT-1 32.2 ± 1.4 32.1 ± 2.6 32.6 ± 1.3 34.5 ± 0.4 TT-2 32.3 ± 1.6 32.8 ± 3.9 33.1 ± 0.2 32.5 ± 3.0 Additive 27.0 ± 1.0 28.3 ± 1.9 28.0 ± 0.7 29.0 ± 1.0 HiCE 34.0 ± 1.1 32.7 ± 1.9 31.3 ± 2.3 32.8 ± 1.0 Prompting 41.0 ± 1.0 47.0 ± 2.1 51.7 ± 1.8 53.8 ± 1.4 CoLLEGe 49.3 ± 1.0 53.2 ± 1.6 54.8 ± 2.6 60.0 ± 0.7Table 5 : Accuracy in percentage on the CoLLEGe-Slang benchmark dataset. CoLLEGe achieves higher accuracy on our Twitter Slang task than each of the baselines, including Prompting.Dataset: To build CoLLEGe-Slang, we first hand-curate a set of 80 recent slang terms as well as their definitions. Alongside each term is a list of up to 8 high-quality example Tweets which use the term in an informative way. For this hand-curated set, example tweets are predominantly from 2022 and 2023. To supplement these, we then sample 120 additional slang terms from UrbanDictionary and the Online Slang Dictionary. We select example tweets from the Twitter archive, using the pipeline from Hu et al. (2022) . Some examples from the hand-crafted set are shown in Table 13 . More information about the filtering process, data sources, and curation details for this dataset can be found in Appendix D.To evaluate the different models on this task, we select the true slang term, its example tweets, and its true definition. We then select 3 different incorrect slang terms and their examples. We score the log probability of the true definition conditioned on each set of examples. The highest probability is selected as the "choice". If it corresponds to the correct combination of definition and slang term, that is counted as a correct choice, otherwise not. We score the model based on its accuracy across the whole set of slang terms.Results are presented in Table 5 . Without providing example tweets in-context, CoLLEGe outperforms each baseline. In fact, CoLLEGe is able to outperform prompting directly, showing that in novel contexts (such as Twitter slang), in-context examples may be more confusing than a concise embedding representation. Notably, when including example tweets in-context, the baselines hurt performance compared to a simple prompting baseline. Only using the CoLLEGe generated embeddings in this setting improve performance over prompting with randomly initialized new token embeddings. We also compare CoLLEGe to our baselines in the prompting setting in Table 10 . 
conclusion: 
 In this paper we present CoLLEGe, a few-shot learning framework for new concept acquisition for pretrained LLMs. We model our meta-learning approach on the original pretraining task by sampling few-shot learning episodes from language model pretraining datasets and using next-word prediction, as our primary meta-learning objective. CoLLEGe generated embeddings contain rich and task-general semantic information, generalize to multiple challenging tasks at test time zero-shot, without additional finetuning or training, and are particularly useful for more complex reasoning tasks. 
limitations and future work: 
 While CoLLEGe achieves the best performance in all of the benchmarks, we summarize a few limitations in our current framework. First, the generated embeddings sometimes miss precise details in the examples, instead encoding higher level semantic information. This can be seen in some incorrect generated definitions, where general features of the unknown concept are correctly inferred even though specific details are missed. Second, we find the averaging mechanism cannot fully achieve parity with pretrained embeddings, even with more support sequences.Our work points to a number of future research directions. In the short term, work needs to be done to investigate different data mixes for training CoLLEGe. More broadly, this research is a first step in an exciting direction for future research: online continual concept acquisition performed jointly with pretraining-incrementally identifying and compressing new concepts from an online stream of sequential experience. Select the two answer choices that, when inserted into the sentence, fit the meaning of the sentence as a whole and yield complete sentences that are similar in meaning.Table 7 : The two types of questions used in CoLLEGe-GRE. 
 
 Appendix: The cleaning process for the GRE dataset involved normalizing the different formats for blanks (i.e. empty spaces, underlines, "(a)", etc.), removing artifacts from the conversion to text from PDF, and associating each question with its answer from the answer key.We filter examples from this archive for flagged obscene words using Squeakily, but it is important to note that online slang is often obscene. This is especially true for the sources used to define the slang terms (UrbanDictionary in particular).We used slang definitions from UrbanDictionary5 Dictionary.com's Pop Culture6 and Slang7 sections, the recent American Dialect Society meeting8 , Bark9 , Wiktionary10 , and the Online Slang Dictionary11 for our dataset.Hice: To train HiCE, we follow the method outlined in the paper, and use the WikiText-103 dataset to train the model with a morphology network. We use hyperparameters from the authors' implementation.Word2Vec Projection: For the Additive baseline as well as HiCE, the baseline outputs a Word2Vec embedding. To make this compatable with LLaMa, we train a linear layer on shared tokens between LLaMa and Word2Vec to map between the embedding spaces.Token Tuning: For Token Tuning, we treat the example sentences as a "batch" and perform N=1,2 steps of gradient descent on only the input and output embeddings for the new token.Since our Prompting baseline provides all the support sentences in the context window, allowing the LM to attend to the new token embeddings directly, we also show using CoLLEGe-generated embeddings improves performance over random initialization and our other baselines (denoted "Prompting+...").Table 8 shows results for the GRE task when prompting with examples in-context, using embeddings for the new token generated by the model or baseline following the "+". We present results in We compare the model generated definitions with a reference definition generated by GPT-4 using BERTScore and simulate random challenges between CoLLEGe and each baseline and compute and ELO rating. Token Tuning results are for LR = 3e-4, as in the main paper.Generated definitions improve with in-context examples, and we note that our model far outperforms the baselines. The only competitive baseline is prompting with randomly initialized embeddings.When examples Tweets are provided in-context, our CoLLEGe model's accuracy on the slang identification task increases. For other baselines, aside from prompting with randomly initialized embeddings, however, performance either degrades or remains about the same. With the Word2Vec-based baselines, this may be due to the difficulty of mapping between Word2Vec embeddings and the LLaMA input and output embedding space. We present these results in Table 10 .We show additional definitions generated from CoLLEGe, including definitions generated with more than one example, in Table 11 . The yellow blooms of the <nonce> added a vibrant contrast to the green canvas of the wetlands."a plant of the genus Ficus, having a milky sap and large, often edible, fruit." aromatic evergreen or deciduous dioecious shrubs or trees of eastern Asia and North AmericaThe prestigious <nonce>, clad in elaborate costumes, filled the auditorium with their mesmerizing harmonies and dramatic performances. After months of rigorous rehearsals, the <nonce> finally brought their magnum opus to life, filling the ornate theater with powerful harmonies that resonated with every member of the riveted audience. a person who is skilled in the art of dancing.a company that produces operas opera company Despite countless imitations flooding the market, only her grandmother's secret recipe for apple pie was the <nonce>. After tasting many alternatives, he finally found the <nonce> of artisanal cheeses in a quaint little shop in Paris. Despite all the replica paintings she had seen, it was breathtaking to stand before the <nonce> in the museum. the most beautiful or perfect specimen of its kind.Table 11 : Additional definitions generated with CoLLEGe, using the prompt "The word <nonce> is defined as". Each definition is generated using the examples. None of the example sentences are provided in-context to the model.We present the definitions generated by CoLLEGe side-by-side with those generated by our baselines in Table 12 . in a manner that is intended to attract attention or admiration HiCE a word" "the a word a" is a a " a "a" a a word a word a a a Additive that the place where you are the place. that the same.follows.'the opposite of the word " " in the dictionary TT-2follows.the opposite of the word,in the heart of bustling 19th century Boston, he spent his mornings as a loyal conductor, navigating through a flamboyant manner of acting or speaking.Table 12 : Side-by-side comparison between CoLLEGe-generated definitions and definitions generated by the baselines.In general, the baselines (without Prompting) are unable to generate usable definitions for the new concept.Word2Vec Baselines: Both Word2Vec baselines tended to produce embeddings that were unusable for generating definitions.CoLLEGe Failures: When analyzing generated definitions, it is clear that there are some "default" definitions the model will generate when the embedding for the new token is not informative enough.Some of these common "default" definitions, listed in order of frequency, are:• a person who is not a member of a particular group or class • a place of refuge or shelter • a person who is a source of annoyance or irritation • a nounWe highlight a few Twitter slang examples from the hand-curated subset of our task dataset in Table 13 .The ability to confidently approach people and talk to them, in a more romantic or flirty way.Imagine having so little rizz that even the AI girlfriend rejects you. Just complete negative game.hits different When something is significantly better than usual or is way better under certain circumstances.getting called pretty in person just hits different. people be making my day.gorpcore A fashion style that is similar to that of hiking/wilderness/utility tech wear.An anecdote from my coverage of Gorpcore as a trend: This vintage seller put 4 Gore-Tex hats up for sale on his website at $135.... https://www.urbandictionary.com/define.php?term=Beige%20flaghttps://github.com/CarperAI/squeakilyhttps://github.com/outlines-dev/outlineshttps://www.urbandictionary.com/https://www.dictionary.com/e/pop-culture/https://www.dictionary.com/e/slang/https://americandialect.org/nominations-for-words-of-the-year-2023/bark.ushttps://www.wiktionary.org/http://onlineslangdictionary.com/ 


Decision: This paper proposes a new method for large language models to learn new concepts on the fly to overcome current methods such as prompt-based in-context learning and few-shot fine-tuning. For achieving this, the authors design a meta-learning approach for flexible embeddings for new coming concepts. 

Among three reviewers, two reviewers voted to acceptance score (7) and one reviewer gave a rejection (4) initially.
All reviewers agree that interesting setup, the importance of the task that this paper addresses, novel methods, and good writing. 
The main concerns were less natural setup and lack of description on related research area. 

During the rebuttal period, the authors tried to address the concerns and it seems that some of them were alleviated. 

AC carefully read the paper, the review comments, and the authors' feedback.

Considering the discussion comments as well, AC agree the contribution of this paper, and thus recommends accepting this paper.

AC asks the authors reflect valuable comments of the reviewers in the final camera-ready version.

Reviews: review: paper_summary: paper_summary: The paper proposed a few-shot method to enable a language model to learn new concepts on the fly.
strength_weakness: strength_weakness: I found the problem studied in the paper artificial. I have a few concerns: 

New concepts come constantly and naturally and should be identified and learned naturally by the language model itself in the particular contexts of the concepts. Manually identifying such concepts is not practical. How do you know that the language model does not have a concept already in the system? After identifying such concepts, positive and negative examples have to be prepared in sophisticated ways in order to learn the concepts. Training even involves meta-learning, which makes the task even more difficult. 

Experiments are conducted but again artificial. 

The paper mainly described what the authors have done with gory details, but provided little principle.  

There are two closely related areas of research that the paper has missed. The first area is model editing. A large body of literature on the topic is trying to do what you are doing. Another area is continual learning, which tries to ensure little negative interference to the language model when learning new knowledge or concepts. The following papers can give you some ideas about the existing work in these two areas. 

Mitchell et al., Fast Model Editing at Scale, ICLR-2022

Wang et al. Knowledge Editing for Large Language Models: A Survey. arXiv:2310.16218 [cs.CL]

Ke et al. Continual Pre-training of Language Models. ICLR-2023.
questions: questions: No other questions
paper_summary: paper_summary: This paper introduces a framework called CoLLEGe for learning how to embed concepts from LLMs. The framework uses a meta-learning approach and makes use of text data from pretrained LM datasets. The proposed method efficiently samples support and query sequences by using saved sentences with new tokens. The knowledge distillation process then involves matching the generated embeddings with the ground truth embeddings and logits.
strength_weakness: strength_weakness: - Several works have been proposed recently on learning static vector representations of concepts such as MirrorBERT, Numberbach, etc. Perhaps authors should discuss these concept embeddings and use them instead of simply averaging mentions. 

- more detail about the sampling and knowledge distillation process in section 3
questions: questions: - Could the authors explain how the concept embedding is taken into account in the LLM to produce the definition? 
- Could the authors add more clarification about the sampling process?
paper_summary: paper_summary: This paper presents a framework for a concept embedding generation system. The proposed method is a rather elegant approach to learning new concept embeddings, where new concepts are learned by masking them with a frozen MLM (roBERTa), encoding example sentences mentioning them, pooling their representation, and then train an autoregressive LLM (LLama2-7b) with an augmented vocabulary of +1 new concept. Different components play an important role, such as sampling negative examples or ensuring the masked representation is as close as possible to the true (unmasked) one. 

The method I found to be really neat, and the presentation and general writeup very clear. The experiments are also reasonable (verbal reasoning, definition generation and correct definition identificatino from Twitter), and show that such models could be very useful for domain-specific or slang understanding.

My main criticism is that the evaluation, while sensible, seems to be quite limited and not be well positioned with existing lexical semantics benchmarks. It seems this would be important so that we can understand, beyond comparing with GPT, etc., how this fine-tuned Llama-2 model fares with older but well tested models.
strength_weakness: strength_weakness: The evaluation is a bit slim and ad-hoc. For example:

- GRE experiment seems fine, however I was't able to find any discussion about the role of definitions, and given that increasing the number of definitions for the considered terms boosts performance significantly, it would be good to understand a bit better why. It is not clear if they all come from the same source, mixed, or if more than 4 were tested.

- Definition generation. There is a body of work on definition generation (aka definition modeling), with standard datasets and metrics. I would have expected these works and baselines to be included (see below).

- Twitter slang experiment seems fine, although again, there are other works and datasets that could have been referenced. Beyond this, this looks very similar to the WiC-TSV task, so I'd encourage the authors to add an experiment here and compare with appropriate baselines.


Definition generation
[1] - Bevilacqua, M., Maru, M., & Navigli, R. (2020). Generationary or “how we went beyond word sense inventories and learned to gloss”. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP) (pp. 7207-7221).
[2] - Giulianelli, M., Luden, I., Fernández, R., & Kutuzov, A. (2023). Interpretable word sense representations via definition generation: The case of semantic change analysis. arXiv preprint arXiv:2305.11993.
[3] - Mickus, T., Van Deemter, K., Constant, M., & Paperno, D. (2022). Semeval-2022 Task 1: CODWOE--Comparing Dictionaries and Word Embeddings. arXiv preprint arXiv:2205.13858.

WiC-TSV
[3] - Breit, A., Revenko, A., Rezaee, K., Pilehvar, M. T., & Camacho-Collados, J. (2020). WiC-TSV: An evaluation benchmark for target sense verification of words in context. arXiv preprint arXiv:2004.15016.
Mapping words to definitions and mentions

Other helpful works mapping words, definitions and examples, maybe good for swapping with the original encoder
[4] - Yu, W., Zhu, C., Fang, Y., Yu, D., Wang, S., Xu, Y., ... & Jiang, M. (2021). Dict-bert: Enhancing language model pre-training with dictionary. arXiv preprint arXiv:2110.06490.
[5] - Chen, P., & Zhao, Z. (2022). A unified model for reverse dictionary and definition modelling. arXiv preprint arXiv:2205.04602.
questions: questions: Just a typo: Sect 5.1 "On an version"

Comments: title: Thanks for the rebuttal
comment: Thank you for reading our comments and increasing your score.
During the evaluation, we noticed that KE methods took much longer to evaluate than CoLLEGe. To quantify this, we computed the average amount of time each method took on each GRE evaluation example, which we present below. CoLLEGe and Prompting + CoLLEGe are 7x and 3x, respectively, faster than the fastest KE method, MEND. CoLLEGe is also 50x faster than the slowest method, IKE. One caveat is that we are using the implementation of these methods from EasyEdit and did not separately optimize their efficiency. 

|       Method        | Avg. Time Elapsed Per Example (s) &#8595; |
| :-----------------: | :---------------------------------------: |
|       CoLLEGe       |                   0.51                    |
| Prompting + CoLLEGe |                   0.96                    |
|  Prompting + MEND   |                   3.59                    |
|  Prompting + ROMEO  |                   14.0                    |
|   Prompting + IKE   |                   25.8                    |
Thank you for your response and for increasing your score, as well as for suggesting we compare with Knowledge Editing methods. To address your concerns, we evaluated some of these methods on our GRE task. Here, we use the definition of the new concept for editing and also present support sequences in-context. IKE [1] uses in-context learning for knowledge editing, whereas ROME [2] and MEND [3] update the model weights. To train MEND, we use the zsRE dataset and we use the implementations provided in EasyEdit [4]. In the first table below, we provide only support sequences in-context and in the second we also provide definitions.

|                  |       1 shot       |      2 shots       |      3 shots       |      4 shots       |
| :--------------: | :----------------: | :----------------: | :----------------: | :----------------: |
|     CoLLEGe      | **35.0 ± 5.6** | **40.5 ± 4.3** | **42.7 ± 3.9** | **44.5 ± 3.9** |
|    Prompting     |   13.9 ± 4.3    |   17.7 ± 3.0    |   19.8 ± 4.2    |   21.8 ± 3.0    |
| Prompting + MEND |   13.4 ± 5.0   |   10.1 ± 2.9   |   14.7 ± 5.4   |   19.4 ± 1.9   |
| Prompting + IKE  |   18.1 ± 2.7   |   22.3 ± 3.1   |   23.2 ± 3.2   |   27.9 ± 5.9   |
| Prompting + ROME |   14.9 ± 5.2   |   16.2 ± 3.2   |   16.7 ± 5.3   |   22.3 ± 1.8   |


|                  |   Def. + 1 shot    |   Def. + 2 shots   |   Def. + 3 shots   |   Def. + 4 shots   |
| :--------------: | :----------------: | :----------------: | :----------------: | :----------------: |
|     CoLLEGe      | **42.5 ± 4.3** | **46.8 ± 3.7** | **45.2 ± 3.2** | **49.3 ± 1.5** |
|    Prompting     |   21.6 ± 5.7    |   20.5 ± 6.8    |   19.3 ± 4.8    |   24.0 ± 4.7    |
| Prompting + MEND |   23.3 ± 5.0   |   10.8 ± 4.0   |   16.3 ± 1.9   |   20.2 ± 2.2   |
| Prompting + IKE  |   20.0 ± 6.2   |   17.2 ± 5.2   |   17.6 ± 2.3   |   23.7± 5.8    |
| Prompting + ROME |   21.9 ± 6.7   |   18.6 ± 5.1   |   14.4 ± 4.7   |   23.2 ± 3.2   |

We find that knowledge editing methods score better than our Prompting baseline in some cases, when the definition is not provided in-context, but around the same or slightly worse when it is provided. In either case, CoLLEGe achieves much higher accuracy than all KE methods. 

We also tried using the support sequences as well as the definition during editing. Unfortunately, the time it took to evaluate ROME in this setting was much longer, and we were only able to complete 2 evaluation runs (as opposed to 5 above). Nonetheless, we found that performance was sometimes a bit worse than if we just use the definition for editing. As above, in the first table we provide only support sequences in-context and in the second we also provide definitions. In both cases, definitions and support sequences are used for editing.


|      Method      |       1 shot        |       2 shots       |       3 shots       |       4 shots       |
| :--------------: | :-----------------: | :-----------------: | :-----------------: | :-----------------: |
|     CoLLEGe      | **35.0 ± 5.6** | **40.5 ± 4.3** | **42.7 ± 3.9** | **44.5 ± 3.9** |
|    Prompting     |   13.9 ± 4.3    |   17.7 ± 3.0    |   19.8 ± 4.2    |   21.8 ± 3.0    |
| Prompting + ROME |   10.4 ± 1.1    |   14.0 ± 2.3    |   12.8 ± 1.2    |   20.9 ± 0.0    |

|      Method      |   Def. + 1 shot    |   Def. + 2 shots   |   Def. + 3 shots   |   Def. + 4 shots   |
| :--------------: | :----------------: | :----------------: | :----------------: | :----------------: |
|     CoLLEGe      | **42.5 ± 4.3** | **46.8 ± 3.7** | **45.2 ± 3.2** | **49.3 ± 1.5** |
|    Prompting     |   21.6 ± 5.7   |   20.5 ± 6.8   |   19.3 ± 4.8   |   24.0 ± 4.7   |
| Prompting + ROME |   26.7 ± 1.2   |   16.3 ± 4.7   |   11.6 ± 2.3   |   22.1 ± 3.5   |

We find that ROME performs worse than Prompting in most cases, and each achieves lower accuracy than CoLLEGe.
 
[1] Zheng, Ce, et al. "Can We Edit Factual Knowledge by In-Context Learning?." *Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing*. 2023.

[2] Meng, Kevin, et al. "Locating and editing factual associations in GPT." *Advances in Neural Information Processing Systems* 35 (2022): 17359-17372.

[3] Mitchell, Eric, et al. "Fast model editing at scale." *arXiv preprint arXiv:2110.11309* (2021).

[4] Wang, Peng, et al. "Easyedit: An easy-to-use knowledge editing framework for large language models." *arXiv preprint arXiv:2308.07269* (2023).
Thank you for the answers and the additional experiments, the comparison with the Flan definition generation models is insightful.
I don't agree with your reply to my final point. I think they are very relevant. Model editing is not done manually. Some model editing methods also use positive and negative examples. Your method has to deal with forgetting as in continual learning or model editing. 

Thanks for responding to my comments. Since you have addressed some of my concerns, I increased my score to 5.
Thank you for the answers.