# Memory3: Language Modeling with Explicit Memory
**Authors**: Hongkang Yang, Zehao Lin, Wenjin Wang, Hao Wu, Zhiyu Li, Bo Tang, Wenqiang Wei, Jinbo Wang, Zeyun Tang, Shichao Song, Chenyang Xi, Yu Yu, Kai Chen, Feiyu Xiong, Linpeng Tang, Weinan E
> Center for LLM, Institute for Advanced Algorithms Research, Shanghai
> Moqi Inc
> Also at School of Mathematical Sciences, Peking University and AI for Science InstituteCorresponding authors: xiongfy@iaar.ac.cn, linpengt@myscale.com, weinan@math.pku.edu.cnCenter for Machine Learning Research, Peking UniversityCenter for LLM, Institute for Advanced Algorithms Research, Shanghai
(July 1, 2024)
Abstract
The training and inference of large language models (LLMs) are together a costly process that transports knowledge from raw data to meaningful computation. Inspired by the memory hierarchy of the human brain, we reduce this cost by equipping LLMs with explicit memory, a memory format cheaper than model parameters and text retrieval-augmented generation (RAG). Conceptually, with most of its knowledge externalized to explicit memories, the LLM can enjoy a smaller parameter size, training cost, and inference cost, all proportional to the amount of remaining “abstract knowledge”. As a preliminary proof of concept, we train from scratch a 2.4B LLM, which achieves better performance than much larger LLMs as well as RAG models, and maintains higher decoding speed than RAG. The model is named Memory 3, since explicit memory is the third form of memory in LLMs after implicit memory (model parameters) and working memory (context key-values). We introduce a memory circuitry theory to support the externalization of knowledge, and present novel techniques including a memory sparsification mechanism that makes storage tractable and a two-stage pretraining scheme that facilitates memory formation.
<details>
<summary>extracted/5700921/Figures/key_figure/m3mory_opening.png Details</summary>
### Visual Description
## Diagram: Transformer LLM with Explicit Memory
### Overview
The image is a diagram illustrating how a Transformer Large Language Model (LLM) can be enhanced with explicit memory, drawing inspiration from brain-inspired designs. It shows the flow of information between a memory bank, the Transformer LLM, and a knowledge base, highlighting the processes of writing (encoding) and reading (recalling) memory.
### Components/Axes
* **Memory Bank:** A series of memory slots labeled "Memory 0", "Memory 1", "Memory 2", "Memory ...", and "Memory m".
* **Transformer LLM (Top-Right):** A red rounded rectangle labeled "Transformer LLM".
* **Transformer LLM (Bottom-Left):** A red rounded rectangle labeled "Transformer LLM".
* **Read (self-attention):** An arrow pointing from the memory slots to the Transformer LLM (top-right).
* **Write (encode) in advance:** An arrow pointing from the Transformer LLM (bottom-left) to the explicit memory.
* **Explicit Memory (sparse attention key-values):** A table-like structure representing the explicit memory, with rows labeled "Head h\_m", "Head ...", "Head h\_2", and "Head h\_1". The cells in the table are either empty or filled with a light blue color, indicating the presence of a key-value pair.
* **Knowledge Base:** Three stacked cards labeled "Reference N", "Reference N+1", and "Reference N+2".
* **Memory Recall:** An arrow pointing from the memory bank to the text "<s>... will benefit from brain-inspired designs. LLM equipped with explicit memory can \_\_".
* **Reference:** Text snippets "<s>Reference:" and "<s>... will benefit from brain-inspired designs. LLM equipped with explicit memory can \_\_".
### Detailed Analysis or ### Content Details
* **Memory Bank:** The memory bank consists of multiple memory slots, suggesting a sequential organization of memory. The slots are labeled from "Memory 0" to "Memory m", indicating a range of memory locations.
* **Read (self-attention):** The "Read (self-attention)" arrow indicates that the Transformer LLM accesses the memory bank through a self-attention mechanism.
* **Transformer LLM:** The Transformer LLM is represented twice in the diagram, once for reading memory (top-right) and once for writing (encoding) memory (bottom-left).
* **Write (encode) in advance:** The "Write (encode) in advance" arrow indicates that the Transformer LLM writes information into the explicit memory before it is needed.
* **Explicit Memory (sparse attention key-values):** The explicit memory is organized into "Heads," each with a sparse set of key-value pairs. The presence of light blue cells indicates the existence of a key-value pair for a specific head.
* Head h\_m: Has a key-value pair in the first column.
* Head ...: Has a key-value pair in the second column.
* Head h\_2: Has key-value pairs in the third and fifth columns.
* Head h\_1: Has key-value pairs in the first and fourth columns.
* **Knowledge Base:** The knowledge base contains references to external information.
* **Reference N:** "Explicit memory is one of the two main types of long-term human memory, the other of which ..."
* **Reference N+1:** "Hippocampal cells are activated depending on what information one is exposed to, while ..."
* **Reference N+2:** "The hippocampus plays an important role in the formation of new memories about ..."
* **Memory Recall:** The "memory recall" arrow indicates that the memory bank is used to provide context or information to the LLM.
* **Reference:** The text snippets suggest that the LLM is using the memory bank to improve its performance.
### Key Observations
* The diagram highlights the interaction between the Transformer LLM and an external memory bank.
* The explicit memory is represented as a sparse attention key-value store, suggesting that only relevant information is stored and retrieved.
* The knowledge base provides additional context and information to the LLM.
* The diagram emphasizes the importance of both writing (encoding) and reading (recalling) memory for the LLM.
### Interpretation
The diagram illustrates a system where a Transformer LLM leverages an explicit memory component to enhance its capabilities. The memory bank acts as a repository of information that the LLM can access and utilize during processing. The explicit memory, organized as sparse attention key-values, allows the LLM to selectively attend to relevant information, improving efficiency and performance. The knowledge base provides external references that further enrich the LLM's understanding.
The diagram suggests that by incorporating explicit memory, the Transformer LLM can better mimic the human brain's ability to store and retrieve information, leading to more sophisticated and context-aware language processing. The use of sparse attention mechanisms highlights the importance of selective attention in memory retrieval, allowing the LLM to focus on the most relevant information and avoid being overwhelmed by irrelevant details.
</details>
Figure 1: The Memory 3 model converts texts to explicit memories, and then recalls these memories during inference. The explicit memories can be seen as retrievable model parameters, externalized knowledge, or sparsely-activated neural circuits.
<details>
<summary>extracted/5700921/Figures/Result/memory3_benchmark_vs_size_small.png Details</summary>
### Visual Description
## Scatter Plot: Benchmark Performance vs. Non-Embedding Parameter Size
### Overview
The image is a scatter plot comparing the benchmark performance (average evaluation score) of various language models against their non-embedding parameter size (in billions). Each data point represents a different model, labeled with its name. The plot visually represents the relationship between model size and performance.
### Components/Axes
* **X-axis:** Non-embedding parameter size (billion). The scale is logarithmic, with marked values at 1, 2, 4, 8, 16, and 32.
* **Y-axis:** Benchmark performance (avg eval score). The scale is linear, ranging from 40 to 65, with tick marks at intervals of 5.
* **Data Points:** Each model is represented by a dot, with its name displayed nearby. Most dots are blue, but one is red.
* **Labels:** Model names are placed near their corresponding data points.
### Detailed Analysis
* **Data Points and Values:**
* **Memory³-2B-SFT:** (Red dot) Located at approximately x=2, y=63.
* **Qwen1.5-4B-Chat:** (Blue dot) Located at approximately x=2.5, y=57.
* **Phi-2:** (Blue dot) Located at approximately x=2.5, y=55.
* **MiniCPM-2B-SFT:** (Blue dot) Located at approximately x=2.5, y=55.
* **Qwen1.5-1.8B-Chat:** (Blue dot) Located at approximately x=1.5, y=50.
* **Gemma-2B-it:** (Blue dot) Located at approximately x=2, y=37.
* **Llama2-7B-Chat:** (Blue dot) Located at approximately x=4, y=47.
* **Gemma-7B-it:** (Blue dot) Located at approximately x=8, y=47.
* **Llama3-8B-it:** (Blue dot) Located at approximately x=6, y=65.
* **Qwen1.5-7B-Chat:** (Blue dot) Located at approximately x=6, y=64.
* **Mistral-7B-v0.1:** (Blue dot) Located at approximately x=6, y=60.
* **Baichuan2-7B-Chat:** (Blue dot) Located at approximately x=5, y=56.
* **ChatGLM3-6B:** (Blue dot) Located at approximately x=5, y=53.
* **Vicuna-13B-v1.5:** (Blue dot) Located at approximately x=12, y=52.
* **Llama2-13B-Chat:** (Blue dot) Located at approximately x=12, y=51.
* **Falcon-40B:** (Blue dot) Located at approximately x=32, y=56.
* **Trends:**
* Generally, there is a positive correlation between the non-embedding parameter size and benchmark performance. Larger models tend to perform better.
* However, there are exceptions, indicating that model architecture and training data also play significant roles.
### Key Observations
* **Outlier:** Memory³-2B-SFT (red dot) shows a relatively high benchmark performance for its parameter size, suggesting it might be more efficient or specialized.
* **Performance Plateau:** The performance seems to plateau for models with parameter sizes greater than 16 billion.
* **Model Clustering:** Several models with similar parameter sizes (around 7B) exhibit varying performance, highlighting the impact of architectural differences.
### Interpretation
The scatter plot illustrates the relationship between model size and performance for a selection of language models. The general trend suggests that increasing the number of parameters tends to improve performance. However, the presence of outliers and variations among models with similar sizes indicates that other factors, such as model architecture, training data quality, and optimization techniques, also significantly influence benchmark performance. The red data point, Memory³-2B-SFT, stands out as a potentially more efficient model, achieving a high score with a relatively small parameter size. The plateauing of performance for larger models suggests diminishing returns in simply scaling up the parameter count.
</details>
(a)
<details>
<summary>extracted/5700921/Figures/Result/memory3_profession_vs_throughput.png Details</summary>
### Visual Description
## Scatter Plot: Professional Tasks vs. Decoding Speed with Retrieval
### Overview
The image is a scatter plot comparing the performance of several language models on professional tasks with retrieval against their decoding speed with retrieval. The y-axis represents the average score on professional tasks, while the x-axis represents the decoding speed in tokens per second. Each data point represents a different language model.
### Components/Axes
* **Title:** There is no explicit title.
* **X-axis:** Decoding speed with retrieval (token/sec). The scale is logarithmic. Markers are at 4 x 10^2, 6 x 10^2, and 10^3.
* **Y-axis:** Professional tasks with retrieval (avg score). The scale is linear, ranging from 35.0 to 55.0, with tick marks at intervals of 2.5.
* **Data Points:** Each model is represented by a dot and a label. The models are:
* Qwen1.5-4B-Chat (blue)
* Memory³-2B-SFT (red)
* Qwen1.5-1.8B-Chat (blue)
* MiniCPM-2B-SFT (blue)
* Gemma-2B-it (blue)
* Llama2-7B-Chat (blue)
* Phi-2 (blue)
### Detailed Analysis
* **Qwen1.5-4B-Chat:** Located at approximately (400, 56.5).
* **Memory³-2B-SFT:** Located at approximately (700, 48). This point is colored red.
* **Qwen1.5-1.8B-Chat:** Located at approximately (950, 48).
* **MiniCPM-2B-SFT:** Located at approximately (480, 46).
* **Gemma-2B-it:** Located at approximately (1100, 40.5).
* **Llama2-7B-Chat:** Located at approximately (400, 36.5).
* **Phi-2:** Located at approximately (620, 35.5).
### Key Observations
* Qwen1.5-4B-Chat has the highest average score on professional tasks with retrieval.
* Llama2-7B-Chat and Phi-2 have the lowest average scores.
* Gemma-2B-it has the highest decoding speed among the models shown.
* Memory³-2B-SFT is highlighted in red, possibly indicating a point of interest or comparison.
### Interpretation
The scatter plot visualizes the trade-off between performance on professional tasks and decoding speed for different language models. Models like Qwen1.5-4B-Chat excel in task performance but may have lower decoding speeds compared to models like Gemma-2B-it. The red data point, Memory³-2B-SFT, might represent a baseline model or a model with a specific characteristic being compared against the others. The plot suggests that there is no single model that dominates in both performance and speed, and the choice of model depends on the specific application requirements.
</details>
(b)
Figure 2: Left: Performance on benchmarks, with respect to model size (top-left is better). Right: Retrieval-augmented performance on professional tasks, versus decoding speed with retrieval (top-right is better). The left plot is based on Table 16. The right plot is based on Tables 20 and 21. Memory 3 uses high frequency retrieval of explicit memories, while the RAG models use a fixed amount of 5 references. This is a preliminary experiment and we have not optimized the quality of our pretraining data as well as the efficiency of our inference pipeline, so the results may not be comparable to those of the SOTA models.
1 | Introduction
Large language models (LLMs) have enjoyed unprecedented popularity in recent years thanks to their extraordinary performance [5, 9, 110, 11, 126, 4, 56, 54]. The prospect of scaling laws [60, 53, 99] and emergent abilities [119, 105] constantly drives for substantially larger models, resulting in the rapid increase in the cost of LLM training and inference. People have been trying to reduce this cost through optimizations in various aspects, including architecture [40, 6, 30, 75, 89, 109], data quality [104, 58, 48, 66], operator [32, 63], parallelization [95, 103, 62, 91], optimizer [71, 124, 117], scaling laws [53, 127], generalization theory [132, 55], hardware [33], etc.
We introduce the novel approach of optimizing knowledge storage. The combined cost of LLM training and inference can be seen as the cost of encoding the knowledge from text data into various memory formats, plus the cost of reading from these memories during inference:
$$
\sum_{\text{knowledge }k}\min_{\text{format }m}\text{cost}_{\text{write}}(k,m)%
+n_{k}\cdot\text{cost}_{\text{read}}(k,m) \tag{1}
$$
where $\text{cost}_{\text{write}}$ is the cost of encoding a piece of knowledge $k$ into memory format $m$ , $\text{cost}_{\text{read}}$ is the cost of integrating $k$ from format $m$ into inference, and $n_{k}$ is the expected usage count of this knowledge during the lifespan of this LLM (e.g. a few months for each version of ChatGPT [86, 102]). The definitions of knowledge and memory in the context of LLMs are provided in Section 2, and this paper uses knowledge as a countable noun. Typical memory formats include model parameters and plain text for retrieval-augmented generative models (RAG); their write functions and read functions are listed in Table 3, and their $\text{cost}_{\text{write}}$ and $\text{cost}_{\text{read}}$ are provided in Figure 4.
We introduce a new memory format, explicit memory, characterized by moderately low write cost and read cost. As depicted in Figure 1, our model first converts a knowledge base (or any text dataset) into explicit memories, implemented as sparse attention key-values, and then during inference, recalls these memories and integrates them into the self-attention layers. Our design is simple so that most of the existing Transformer-based LLMs should be able to accommodate explicit memories with a little finetuning, and thus it is a general-purpose “model amplifier”. Eventually, it should reduce the cost of pretraining LLMs, since there will be much less knowledge that must be stored in parameters, and thus less training data and smaller model size.
The new memory format enables us to define a memory hierarchy for LLMs:
plain text (RAG) $→$ explicit memory $→$ model parameter
such that by going up the hierarchy, $\text{cost}_{\text{write}}$ increases while $\text{cost}_{\text{read}}$ decreases. To minimize the cost (1), one should store each piece of knowledge that is very frequently/rarely used in the top/bottom of this hierarchy, and everything in between as explicit memory. As illustrated in Table 3, the memory hierarchy of LLMs closely resembles that of humans. For humans, the explicit/implicit memories are the long-term memories that are acquired and used consciously/unconsciously [59].
| Memory format of humans | Example | Memory format of LLMs | Write | Read |
| --- | --- | --- | --- | --- |
| Implicit memory | common expressions | model parameters | training | matrix multiplication |
| Explicit memory | books read | this work | memory encoding | self-attention |
| External information | open-book exam | plain text (RAG) | none | encode from scratch |
Table 3: Analogy of the memory hierarchies of humans and LLMs.
As a remark, one can compare the plain LLMs to patients with impaired explicit memory, e.g. due to injury to the medial temporal lobe. These patients are largely unable to learn semantic knowledge (usually stored as explicit memory), but can acquire sensorimotor skills through repetitive priming (stored as implicit memories) [42, 26, 12]. Thus, one may hypothesize that due to the lack of explicit memory, the training of plain LLMs is as inefficient as repetitive priming, and thus has ample room for improvement. In analogy with humans, for instance, it is easy to recall and talk about a book we just read, but to recite it as unconsciously as tying shoe laces requires an enormous effort to force this knowledge into our muscle memory. From this perspective, it is not surprising that LLM training consumes so much data and energy [121, 77]. We want to rescue LLMs from this poor condition by equipping it with an explicit memory mechanism as efficient as that of humans.
<details>
<summary>extracted/5700921/Figures/Theory/total_cost_2B_chunk.png Details</summary>
### Visual Description
## Chart: Cost vs. Expected Usage Count
### Overview
The image is a line chart comparing the cost of write + read (in Tflops) against the expected usage count (nk) for three different methods: RAG (Retrieval-Augmented Generation), Explicit memory, and Model parameter. The x-axis is logarithmic, ranging from 10^-2 to 10^5. The y-axis represents the cost in Tflops, ranging from 0.0 to 2.5. The chart also includes shaded regions indicating the areas where each method is most cost-effective.
### Components/Axes
* **X-axis:** Expected usage count (nk), logarithmic scale from 10^-2 to 10^5.
* **Y-axis:** Cost of write + read (Tflops), linear scale from 0.0 to 2.5.
* **Legend (top-left):**
* Red line: RAG
* Green line: Explicit memory
* Blue line: Model parameter
### Detailed Analysis
* **RAG (Red Line):** The cost of RAG starts near 0 at low usage counts and increases exponentially as the expected usage count increases.
* At nk = 10^-2, cost ≈ 0.01 Tflops
* At nk = 10^-1, cost ≈ 0.03 Tflops
* At nk = 10^0, cost ≈ 0.3 Tflops
* At nk = 10^1, cost ≈ 1.0 Tflops
* **Explicit Memory (Green Line):** The cost of explicit memory is relatively constant at low usage counts, then increases sharply around nk = 10^4.
* From nk = 10^-2 to nk = 10^3, cost ≈ 0.3 Tflops
* At nk = 10^4, cost ≈ 1.5 Tflops
* At nk = 10^5, cost ≈ 2.7 Tflops
* **Model Parameter (Blue Line):** The cost of the model parameter is constant across all usage counts.
* Cost ≈ 2.25 Tflops
* **Shaded Regions:**
* Light red shading: RAG is most cost-effective for nk < approximately 0.7.
* Light green shading: Explicit memory is most cost-effective for approximately 0.7 < nk < 10^4.
* Light blue shading: Model parameter is most cost-effective for nk > 10^4.
### Key Observations
* RAG is cost-effective for very low usage counts.
* Explicit memory is cost-effective for moderate usage counts.
* Model parameter is cost-effective for high usage counts.
* The cost of RAG increases much faster than explicit memory as usage count increases.
* The cost of the model parameter is constant, regardless of usage count.
### Interpretation
The chart illustrates the trade-offs between different methods for handling data based on the expected usage count. RAG is suitable for infrequently accessed data due to its low initial cost, but its cost quickly escalates with increased usage. Explicit memory offers a stable cost for moderate usage levels, making it a good choice for frequently accessed data up to a certain point. The model parameter method, with its constant cost, becomes the most economical option for very high usage counts, despite its higher initial cost. The shaded regions visually represent the optimal usage ranges for each method, providing a clear guideline for selecting the most cost-effective approach based on the anticipated usage patterns.
</details>
Figure 4: The total cost (TFlops) of writing and reading a piece of knowledge by our 2.4B model with respect to its expected usage count. The curves represent the cost of different memory formats, and the shaded area represents the minimum cost given the optimal format. The plot indicates that $(0.494,13400)$ is the advantage interval for explicit memory. The calculations are provided in Appendix A. (The blue curve is only a lower bound on the cost of model parameters.)
A quantitative illustration of the cost (1) is given by Figure 4, where we characterize $\text{cost}_{\text{write}}$ and $\text{cost}_{\text{read}}$ by the amount of compute (TFlops). The plot indicates that if a piece of knowledge has an expected usage count $∈(0.494,13400)$ , then it is optimal to be stored as an explicit memory. Moreover, the introduction of explicit memory helps to externalize the knowledge stored in model parameters and thus allow us to use a lighter backbone, which ultimately reduces all the costs in Figure 4.
The second motivation for explicit memory is to alleviate the issue of knowledge traversal. Knowledge traversal happens when the LLM wastefully invokes all its parameters (and thus all its knowledge) each time it generates a token. As an analogy, it is unreasonable for humans to recall everything they learned whenever they write a word. Let us define the knowledge efficiency of an LLM as the ratio of the minimum amount of knowledge sufficient for one decoding step to the amount of knowledge actually used. An optimistic estimation of knowledge efficiency for a 10B LLM is $10^{-5}$ : On one hand, it is unlikely that generating one token would require more than $10^{4}$ bits of knowledge (roughly equivalent to a thousand-token long passage, sufficient for enumerating all necessary knowledge); on the other hand, each parameter is involved in the computation and each stores at least 0.1 bit of knowledge [7, Result 10] (this density could be much higher if the LLM is trained on cleaner data), thus using $10^{9}$ bits in total.
A novel architecture is needed to boost the knowledge efficiency of LLMs from $10^{-5}$ to $1$ , whereas current designs are far from this goal. Consider the mixture-of-experts architecture (MoE) for instance, which uses multiple MLP layers (experts) in each Transformer block and process each token with only a few MLPs. The boost of MoE, namely the ratio of the total amount of parameters to the amount of active parameters, is usually bounded by $4\sim 32$ [40, 56, 98]. Similarly, neither the mixture-of-depth architecture [37, 94] nor sparsified MLP neurons and attention heads [75] can bring greater gains. RAG appears very sparse if we compare the amount of retrieved texts with the size of the text database; nevertheless, RAG is usually built upon a plain LLM as backbone, which provides most of the knowledge used in inference, and thus offers little assistance in addressing the knowledge traversal problem.
An ideal solution is to retrieve only the needed parameters for each token. This is naturally achieved by explicit memories if we compare memory recall to parameter retrieval.
The third motivation is that, as a human-like design, explicit memory enables LLMs to develop more human-like capabilities. To name a few,
- Infinitely long context: LLMs have the difficulty of processing long texts since their working memory (context key-values) costs too much GPU memory and compute. Meanwhile, despite that humans have very limited working memory capacity [27, 28], they can manage to read and write long texts by converting working memories to explicit memories (thus saving space) and retrieving only the needed explicit memories for inference (thus saving compute). Similarly, by saving explicit memories on drives and doing frequent and constant-size retrieval, LLMs can handle arbitrarily long contexts with time complexity $O(l\log l)$ instead of $\Theta(l^{2})$ , where $l$ is the context length.
- Memory consolidation: Instead of writing a piece of knowledge directly into implicit memory, i.e. training model parameters, LLM can first convert it to explicit memory through plain encoding, and then convert this explicit memory to implicit memory through a low-cost step such as compression and finetuning, thus reducing the overall cost.
- Factuality and interpretability: Encoding texts as explicit memories is less susceptible to information loss compared to dissolving them in model parameters. With more factual details provided by explicit memories, the LLMs would have less tendency to hallucinate. Meanwhile, the correspondence of explicit memories to readable texts makes the inference more transparent to humans, and also allows the LLM to consciously examine its own thought process.
We demonstrate the improved factuality in the experiments section, and leave the rest to future work.
In this work, we introduce a novel architecture and training scheme for LLM based on explicit memory. The architecture is called Memory 3, as explicit memory is the third form of memory in LLM after working memory (context key-values) and implicit memory (model parameters).
- Memory 3 utilizes explicit memories during inference, alleviating the burden of model parameters to memorize specific knowledge.
- The explicit memories are encoded from our knowledge base, and our sparse memory format maintains a realistic storage size.
- We trained from scratch a Memory 3 model with 2.4B non-embedding parameters, and its performance surpasses SOTA models with greater sizes. It also enjoys better performance and faster inference than RAG.
- Furthermore, Memory 3 boosts factuality and alleviates hallucination, and it enables fast adaptation to professional tasks.
This paper is structured as follows: Section 2 lays the theoretical foundation for Memory 3, in particular our definitions of knowledge and memory. Section 3 discusses the basic design of Memory 3, including its architecture and training scheme. Sections 4, 5, and 6 describes the training of Memory 3. Section 7 evaluates the performance of Memory 3 on general benchmarks and professional tasks. Finally, Section 8 concludes this paper and discusses future works.
1.1 | Related work
1.1.1 | Retrieval-augmented Training
Several language models have incorporated text retrieval from the pretraining stage. REALM [49] augments a BERT model with one retrieval step to solve QA tasks. Retro [16] enhances auto-regressive decoding with multiple rounds of retrieval, once per 64 tokens. The retrieved texts are injected through a two-layer encoder and then several cross-attention layers in the decoder. Retro++ [113] explores the scalability of Retro by reproducing Retro up to 9.5B parameters.
Meanwhile, several models are adapted to retrieval in the finetuning stage. WebGPT [83] learns to use search engine through imitation learning in a text-based web-browsing environment. Toolformer [100] performs decoding with multiple tools including search engine, and the finetuning data is labeled by the LM iself.
The closest model to ours is Retro. Unlike explicit memory, Retro needs to encode the retrieved texts in real-time during inference. To alleviate the cost of encoding these references, it chooses to use a separate, shallow encoder and also retrieve few references. Intuitively, this compromise greatly reduces the amount of knowledge that can be extracted and supplied to inference.
Another line of research utilizes retrieval to aid long-context modeling. Memorizing Transformer [123] extends the context of language models by an approximate kNN lookup into a non-differentiable cache of past key-value pairs. LongLlama [112] enhances the discernability of context key-value pairs by a finetuning process inspired by contrastive learning. LONGMEM [118] designs a decoupled architecture to avoid the memory staleness issue when training the Memorizing Transformer. These methods are not directly applicable to large knowledge bases since the resulting key-value caches will occupy enormous space. Our method overcomes this difficulty through a more intense memory sparsification method.
1.1.2 | Sparse Computation
To combat the aforementioned knowledge traversal problem and improve knowledge efficiency, ongoing works seek novel architectures that process each token with a minimum and adaptive subset of model parameters. This adaptive sparsity is also known as contextual sparsity [75]. The Mixture-of-Experts (MoE) use sparse routing to assign Transformer submodules to tokens, scaling model capacity without large increases in training or inference costs. The most common MoE design [40] hosts multiple MLP layers in each Transformer block and routes each token to a few MLPs with the highest allocation score predicted by a linear classifier. Furthermore, variants based on compression such as QMoE [41] are introduced to alleviate the memory burden of MoE. Despite the sparse routing, the boost in parameter efficiency is usually bounded by $4\sim 32$ . For instance, the Arctic model [98], one of the sparsest MoE LLM in recent years, has an active parameter ratio of about $3.5\%$ . Similarly, the Mixture of Depth architecture processes each token with an adaptive subset of the model layers. The implementations can be based on early exit [37] or top- $k$ routing [94], reducing the amount of compute to $12.5\sim 50\%$ . More fine-grained approaches can perform sparsification at the level of individual MLP neurons and attention heads. The model Deja Vu [75] trains a low-cost network for each MLP/attention layer that predicts the relevance of each neuron/head at this layer to each token. Then, during inference, Deja Vu keeps the top $5\sim 15\%$ MLP neurons and $20\sim 50\%$ attention heads for each token.
1.1.3 | Parameter as memory
Several works have portrayed model parameters as implicit memory, in accordance with our philosophy. [46] demonstrates that the neurons in the MLP layers of GPTs behave like key-value pairs. Specifically, with the MLP layer written as $\sigma(XK^{T})V$ , each row of the first layer weight $K_{i}$ functions like a key vector, with the corresponding row in the second layer weight $V_{i}$ being the value vector. [46] observes that for most of the MLP neurons, the $K_{i}$ is activated by context texts that obey some human interpretable pattern, and the $V_{i}$ activates the column of the output matrix that corresponds to the most probable next token of the pattern (e.g. $n$ -gram). Based on this observation, [108] designs a GPT variant that consists of only attention layers, with performance matching that of the usual GPTs. The MLP layers are incorporated into the attention layers in the form of key-value vector pairs, which are called persistent memories. Similarly, using sensitivity analysis, [29] discovers that factual knowledge learned by BERT is often localized at one or few MLP neurons. These neurons are called “knowledge neurons”, and by manipulating them, [29] manages to update single pieces of knowledge of BERT. Meanwhile, [38] studies an interesting phenomenon known as superposition or polysemanticity, that a neural network can store many unrelated concepts into a single neuron.
2 | Memory Circuitry Theory
This section introduces our memory circuitry theory, which defines knowledge and memory in the context of LLM. We will see that this theory helps to determine which knowledge can be stored as explicit memory, and what kind of model architecture is suitable for reading and writing explicit memories. For readers interested primarily in the results, it may suffice to review Claim 1 and Remark 1 before proceeding to the subsequent sections. The concepts to be discussed are illustrated in Figure 5.
<details>
<summary>extracted/5700921/Figures/Theory/memory_circuitry_theory.png Details</summary>
### Visual Description
## Diagram: Knowledge Hierarchy in Transformer Circuits
### Overview
The image is a diagram illustrating a hierarchical flow of knowledge within transformer circuits, ultimately influencing model parameters. It depicts how transformer circuits lead to abstract and specific knowledge, which then branches into implicit memory, explicit memory, and external information, all contributing to the final model parameters.
### Components/Axes
* **Boxes:** Represent different types of knowledge or components.
* **Arrows:** Indicate the flow of information or influence.
* **Colors:** Used to distinguish different levels or categories in the hierarchy.
* **Blue:** Represents higher-level knowledge.
* **Green:** Represents memory and information types.
* **Red:** Represents model parameters.
* **Text Labels:** Describe the type of knowledge or component within each box.
### Detailed Analysis
The diagram can be broken down into the following components:
1. **Transformer Circuits (Top):**
* A blue box at the top labeled "Transformer circuits."
* This is the starting point of the diagram.
2. **Separable Knowledge (Middle-Top):**
* A light blue box encompassing "Abstract knowledge" and "Specific knowledge" and labeled "Separable knowledge" on the right.
3. **Abstract and Specific Knowledge (Middle):**
* Two blue boxes branching from "Transformer circuits":
* Left box: "Abstract knowledge"
* Right box: "Specific knowledge"
4. **Memory Hierarchy (Middle-Bottom):**
* A light green box encompassing "Implicit memory", "Explicit memory", and "External information" and labeled "Memory hierarchy" on the right.
5. **Memory and Information Types (Bottom):**
* Three green boxes branching from "Specific knowledge":
* Left box: "Implicit memory"
* Middle box: "Explicit memory"
* Right box: "External information"
6. **Model Parameters (Bottom):**
* A red box at the bottom labeled "Model parameters."
* "Abstract knowledge" flows directly into "Model parameters" with a solid black arrow.
* "Implicit memory" flows directly into "Model parameters" with a solid black arrow.
* "Explicit memory" flows into "Model parameters" with a dashed black arrow.
### Key Observations
* The diagram illustrates a hierarchical structure, starting from transformer circuits and leading to model parameters.
* The flow of information is primarily top-down.
* Abstract and specific knowledge are separated but both contribute to the memory hierarchy and ultimately the model parameters.
* There are three types of memory/information: implicit, explicit, and external.
* Explicit memory has a dashed line connection to model parameters, suggesting a different or less direct influence compared to implicit memory.
### Interpretation
The diagram represents a conceptual model of how knowledge is processed and utilized within transformer circuits to influence model parameters. It suggests that transformer circuits generate both abstract and specific knowledge. Specific knowledge is further categorized into implicit memory, explicit memory, and external information. All these elements ultimately contribute to shaping the model parameters. The dashed line from "Explicit memory" to "Model parameters" might indicate a weaker or more indirect influence compared to the solid lines from "Abstract knowledge" and "Implicit memory". The diagram highlights the importance of different types of knowledge and memory in the functioning of transformer-based models.
</details>
Figure 5: Categorization of knowledge and memory formats. The explicit memories, extracted from model activations, lie half-way between raw data and model parameters, so we use a dotted line to indicate that they may or may not be regarded as parameters.
2.1 | Preliminaries
The objective is to decompose the computations of a LLM into smaller, recurring parts, and analyze which parts can be separated from the LLM. These small parts will be defined as the “knowledge” of the LLM, and this characterization helps to identify what knowledge can be externalized as explicit memory, enabling both the memory hierarchy and a lightweight backbone.
One behaviorist approach is to define the smaller parts as input-output relations between small subsequences, such that if the input text contains a subsequence belonging to some pattern, then the output text of the LLM contains a subsequence that belongs to some corresponding pattern.
- One specific input-output relation is that if the immediate context contains “China” and “capital”, then output the token “Beijing”.
- One abstract input-output relation is that if the immediate context is some arithmetic expression (e.g. “ $123× 456=$ ”) then output the answer (e.g. “ $56088$ ”).
- One abstract relation that will be mentioned frequently is the “search, copy and paste” [85], such that if the context has the form “…[a][b]…[a]” then output “[b]”, where [a] and [b] are arbitrary tokens.
A decomposition into these relations seems natural since autoregressive LLMs can be seen as upgraded versions of $n$ -grams, with the fixed input/output segments generalized to flexible patterns and with the plain lookup table generalized to multi-step computations.
Nevertheless, a behaviorist approach is insufficient since an input-output relation alone cannot uniquely pin down a piece of knowledge: a LLM may answer correctly to arithmetic questions based on either the actual knowledge of arithmetic or memorization (hosting a lookup table for all expressions such as “ $123× 456=56088$ ”). Therefore, we take a white-box approach that includes in the definition the internal computations of the LLM that convert these inputs to the related outputs.
Here are two preliminary examples of internal computations.
**Example 1**
*Several works have studied the underlying mechanisms when LLMs answer to the prompt “The capital of China is” with “Beijing”, as well as other factual questions [29, 46, 79, 22]. At least two mechanisms are involved, and the LLM may use their superposition [79]. One mechanism is to use general-purpose attention heads (called “mover heads”) to move “capital” and “China” to the last token “is”, and then use the MLP layers to map the feature of the last token to “Beijing” [79]. Often, only one or a few MLP neurons are causally relevant, and they are called “knowledge neurons” [29]. This mechanism is illustrated in Figure 6 (left). Another mechanism involves attention heads $h$ whose value-to-output matrices $W^{h}_{V}W^{h}_{O}$ function like bigrams, e.g. mapping “captial” to {“Paris”, “Beijing”, …} and “China” to {“panda”, “Beijing”, …} , which sum up to produce “Beijing” [22, 46, 79]. This mechanism is illustrated in Figure 6 (middle).*
**Example 2**
*The ability of LLMs to perform “search, copy and paste”, namely answering to the context “…[a][b]…[a]” with “[b]”, is based on two attention heads, together called induction heads [85]. The first head copies the feature of the previous token, enabling [b] to “dress like” its previous token [a]. The second head searches for similar features, enabling the second [a] to attend to [b], which now has the appearance of [a]. Thereby, the last token [a] manages to retrieve the feature of [b] and to output [b]. This mechanism is illustrated in Figure 6 (right). A similar mechanism is found for in-context learning [116].*
<details>
<summary>extracted/5700921/Figures/Theory/classical_circuits_demo.png Details</summary>
### Visual Description
## Diagram: Attention and FFN Edges in a Neural Network
### Overview
The image presents three diagrams illustrating attention and feed-forward network (FFN) edges within a neural network architecture. Each diagram shows nodes representing states (X) at different time steps and layers, connected by edges that represent attention mechanisms or FFN connections. The diagrams highlight how information flows between these nodes, with annotations specifying the query/key (qk) and output (o) associated with each edge.
### Components/Axes
**General Components:**
* **Nodes (X):** Represent states at different time steps (t) and layers (l). They are depicted as blue circles.
* **Edges:** Represent connections between nodes, indicating information flow. Green edges denote attention edges, while red edges denote FFN edges.
* **Annotations:** Textual descriptions associated with each edge, specifying the query/key (qk) and output (o).
* **Labels:** Text in blue rectangles at the top and bottom, indicating the input or output tokens.
**Diagram 1 (Left):**
* **Top Node:** Labeled "Beijing" in a blue rectangle. Node is labeled X<sub>t</sub><sup>l+2</sup>
* **Middle Node:** Labeled X<sub>t</sub><sup>l+1</sup>
* **Bottom Nodes:** Labeled X<sub>t-3</sub><sup>l</sup>, X<sub>t-1</sub><sup>l</sup>, and X<sub>t</sub><sup>l</sup>
* **Bottom Labels:** "capital", "China", and "is" in blue rectangles.
* **FFN Edge:** Red edge connecting X<sub>t</sub><sup>l+1</sup> to X<sub>t</sub><sup>l+2</sup>. Annotation: "FFN edge e<sub>t</sub><sup>l+1,m</sup>; qk: (China, capital); o: Beijing"
* **Attention Edges:** Green edges connecting X<sub>t-3</sub><sup>l</sup> and X<sub>t-1</sub><sup>l</sup> to X<sub>t</sub><sup>l+1</sup>. Annotations: "Attention edge e<sub>t-3,t</sub><sup>l,h</sup>; qk: relation; o: capital" and "Attention edge e<sub>t-1,t</sub><sup>l,k</sup>; qk: topic; o: China"
**Diagram 2 (Middle):**
* **Top Node:** Labeled "Beijing" in a blue rectangle. Node is labeled X<sub>t-1</sub><sup>l+2</sup>
* **Middle Node:** Labeled X<sub>t</sub><sup>l+1</sup>
* **Bottom Nodes:** Labeled X<sub>t-3</sub><sup>l</sup>, X<sub>t-1</sub><sup>l</sup>, and X<sub>t</sub><sup>l</sup>
* **Bottom Labels:** "capital", "China", and "is" in blue rectangles.
* **Attention Edges:** Green edges connecting X<sub>t-3</sub><sup>l</sup> and X<sub>t-1</sub><sup>l</sup> to X<sub>t</sub><sup>l+1</sup>, and X<sub>t</sub><sup>l+1</sup> to X<sub>t-1</sub><sup>l+2</sup>. Annotations: "Attention edge e<sub>t-3,t</sub><sup>l,h</sup>; qk: relation; o: Paris, Beijing" and "Attention edge e<sub>t-1,t</sub><sup>l+2,k</sup>; qk: country; o: panda, Beijing"
**Diagram 3 (Right):**
* **Top Node:** Labeled "[b]" in a blue rectangle. Node is labeled X<sub>t</sub><sup>l+3</sup>
* **Middle Nodes:** Labeled X<sub>s</sub><sup>l+2</sup> and X<sub>s</sub><sup>l+1</sup>
* **Bottom Nodes:** Labeled X<sub>s-1</sub><sup>l</sup>, X<sub>s</sub><sup>l</sup>, and X<sub>t</sub><sup>l</sup>
* **Bottom Labels:** "[a]", "[b]", and "[a]" in blue rectangles.
* **Attention Edges:** Green edges connecting X<sub>s-1</sub><sup>l</sup> to X<sub>s</sub><sup>l+1</sup>, and X<sub>s</sub><sup>l+1</sup> to X<sub>t</sub><sup>l+3</sup>. Annotations: "Attention edge e<sub>s-1,s</sub><sup>l,h</sup>; q: previous position; k: current position; o: [a]" and "Attention edge e<sub>s,t</sub><sup>l+2,k</sup>; qk: [a]; o: [b]"
### Detailed Analysis
**Diagram 1:**
* The diagram shows how the state X<sub>t</sub><sup>l+1</sup> is influenced by the states X<sub>t-3</sub><sup>l</sup> and X<sub>t-1</sub><sup>l</sup> through attention edges.
* The attention edge from X<sub>t-3</sub><sup>l</sup> to X<sub>t</sub><sup>l+1</sup> focuses on the "relation" with the output being "capital".
* The attention edge from X<sub>t-1</sub><sup>l</sup> to X<sub>t</sub><sup>l+1</sup> focuses on the "topic" with the output being "China".
* The FFN edge from X<sub>t</sub><sup>l+1</sup> to X<sub>t</sub><sup>l+2</sup> uses "(China, capital)" as the query/key and outputs "Beijing".
**Diagram 2:**
* The diagram shows how the state X<sub>t</sub><sup>l+1</sup> is influenced by the states X<sub>t-3</sub><sup>l</sup> and X<sub>t-1</sub><sup>l</sup> through attention edges.
* The attention edge from X<sub>t-3</sub><sup>l</sup> to X<sub>t</sub><sup>l+1</sup> focuses on the "relation" with the output being "Paris, Beijing".
* The attention edge from X<sub>t</sub><sup>l+1</sup> to X<sub>t-1</sub><sup>l+2</sup> focuses on the "country" with the output being "panda, Beijing".
**Diagram 3:**
* The diagram shows how the state X<sub>s</sub><sup>l+1</sup> is influenced by the state X<sub>s-1</sub><sup>l</sup> through attention edges.
* The attention edge from X<sub>s-1</sub><sup>l</sup> to X<sub>s</sub><sup>l+1</sup> focuses on the "previous position" with the output being "[a]".
* The attention edge from X<sub>s</sub><sup>l+1</sup> to X<sub>t</sub><sup>l+3</sup> uses "[a]" as the query/key and outputs "[b]".
### Key Observations
* The diagrams illustrate the flow of information through attention mechanisms and FFNs in a neural network.
* The annotations provide insights into the query/key and output associated with each edge, indicating the type of information being transferred.
* The diagrams show how different states at different time steps and layers influence each other through attention and FFN connections.
### Interpretation
The diagrams demonstrate the inner workings of a neural network, specifically highlighting the role of attention mechanisms and FFNs in processing sequential data. The attention edges allow the network to focus on relevant parts of the input sequence when making predictions, while the FFN edges transform the representations learned by the attention mechanisms. The query/key and output annotations provide a glimpse into the specific information being processed at each step, revealing how the network learns to extract and combine relevant features to generate the desired output. The diagrams suggest a model that uses attention to relate different tokens in a sequence and FFNs to transform the attended representations. The different diagrams show different attention patterns and FFN connections, possibly representing different layers or heads in a multi-head attention mechanism.
</details>
Figure 6: Illustration of three subgraphs. Left: A subgraph that inputs “the capital of China is” and outputs “Beijing”. The knowledge neuron is marked in red and the mover heads in green. Middle: Another subgraph with similar function using task-specific heads. Right: The induction-heads subgraph that inputs “[a][b]…[a]” and outputs [b], where [a], [b] are arbitrary tokens. The notations are introduced in Section 2.2. The locations of these attention heads and MLP neurons may be variable.
We will address the internal mechanism for an input-output relation as a circuit, and will define a piece of knowledge as an input-output relation plus its circuit. By manipulating these circuits, one can separate many pieces of knowledge from a LLM while keeping its function intact.
Recent works on circuit discovery demonstrate that some knowledge and skills possessed by Transformer LLMs can be identified with patterns in their computation graphs [85, 116, 106, 45, 115, 24, 29, 46], but there has not been a universally accepted definition of circuit. Different from works on Boolean circuits [50, 80] and circuits with Transformer submodules as their nodes [24, 129], we characterize a circuit as a “spatial-temporal” phenomenon, whose causal structure is localized at the right places (MLP neurons and attention heads) and right times (tokens). Thus, we define a computation graph as a directed acyclic graph, whose nodes are the hidden features of all tokens at all all MLP and attention layers, and whose edges correspond to all activations inside these layers. In particular, the computation graph hosts one copy of the Transformer architecture at each time step. To transcend this phenomenological characterization, we define a circuit as an equivalence class of similar subgraphs across multiple computation graphs.
As a remark, it is conceptually feasible to identify a circuit with the minimal subset of Transformer parameters that causes this circuit. The benefit is that such definition of knowledge seems more intrinsic to the LLM. Nevertheless, with the current definition, it is easier to perform surgery on the circuits and derive constructive proofs. Besides, it is known that Transformer submodules exhibit superposition or polysemanticity, such that one MLP neuron or attention head may serve multiple distinct functions [38, 79], making the identification of parameter subsets a challenge task.
2.2 | Knowledge
We begin with the definition of the knowledge of LLMs. For now, it suffices to adopt heuristic definitions instead of fully rigorous ones. Throughout this section, by LLM we mean autoregressive Transformer LLM that has at least been pretrained. Let $L$ be the number of Transformer blocks and $H$ be the number of attention heads at each attention layer, and the blocks and heads are numbered by $l=0,... L-1$ and $h=0,... H-1$ . There are in total $2L$ layers (MLP layers and attention layers), and the input features to these layers are numbered by $0,... 2L-1$ .
**Definition 1**
*Given an LLM and a text $\mathbf{t}=(t_{0},... t_{n})$ , the computation graph $G$ on input $(t_{0},... t_{n-1})$ and target $(t_{1},... t_{n})$ is a directed graph with weighted edges such that
- Its nodes consist of the hidden vectors $\mathbf{x}_{i}^{2l}$ before all attention layers, the hidden vectors $\mathbf{x}_{i}^{2l+1}$ before all MLP layers, and the output vectors $\mathbf{x}_{i}^{2L}$ , for all blocks $l=0,... L-1$ and positions $i=0,... n-1$ .
- Its directed edges consist of each attention edge $e^{l,h}_{i,j}$ that goes from $\mathbf{x}_{i}^{2l}$ to $\mathbf{x}_{j}^{2l+1}$ at the $h$ -th head of the $l$ -th attention layer for all $l,h$ and $i≤ j$ , as well as each MLP edge $e^{l,m}_{i}$ that goes from $\mathbf{x}_{i}^{2l+1}$ to $\mathbf{x}_{i}^{2l+2}$ through the $m$ -th neuron of the $l$ -th MLP layer for all $l,m,i$ .
- The weight of each attention edge $e^{l,h}_{i,j}$ , which measures the influence of the attention score $a^{l,h}_{i,j}$ on the LLM output, is defined by
$$
\mathcal{L}-\mathcal{L}\big{|}_{a^{l,h}_{i,j}=0}\quad\text{or}\quad\frac{%
\partial\mathcal{L}}{\partial a^{l,h}_{i,j}}
$$
where $\mathcal{L}$ is the log-likelihood of the target $(t_{1},... t_{n})$ , with $\mathcal{L}|_{a=0}$ obtained by setting $a=0$ (i.e. causal intervention). Similarly, the weight of each MLP edge $e^{l,m}_{i}$ , which measures the influence of the neuron activation $a^{l,m}_{i}$ on the LLM output, is defined likewise.
- Given any subgraph $S⊂eq G$ , define the associated input of $S$ as a subsequence $\mathbf{t}_{\text{in}}(S)⊂eq(t_{0},... t_{n-1})$ such that a token $t_{i}$ belongs to $\mathbf{t}_{\text{in}}(S)$ if and only if $\big{\|}∇_{\mathbf{x}_{i}^{0}}a\big{\|}$ is large for some attention edge (or MLP edge) in $S$ with attention score (or activation) $a$ .
- Similarly, define the associated output of the subgraph $S$ as a subsequence $\mathbf{t}_{\text{out}}(S)⊂eq(t_{1},... t_{n})$ such that a token $t_{i}$ belongs to $\mathbf{t}_{\text{out}}(S)$ if and only if
$$
\mathcal{L}_{i}-\mathcal{L}_{i}\big{|}_{a=0}\quad\text{or}\quad\frac{\partial%
\mathcal{L}_{i}}{\partial a}
$$
is large for some attention edge (or MLP edge) in $S$ with attention score (or activation) $a$ . Here $\mathcal{L}_{i}$ is the log-likelihood of $t_{i}$ with respect to the LLM output.*
<details>
<summary>extracted/5700921/Figures/Theory/LLM_computation_graph.png Details</summary>
### Visual Description
## Diagram: Neural Network Layer Connections
### Overview
The image depicts a diagram of connections between nodes in a neural network across three layers. The diagram shows how information flows between nodes in adjacent layers, with some connections spanning multiple nodes in the intermediate layer.
### Components/Axes
* **Nodes:** Represented by circles. Each node is labeled with a variable 'x' and a subscript indicating its position (i, i+1, i+2) and layer (2l, 2l+1, 2l+2).
* **Layers:** Three layers are shown, labeled as 2l, 2l+1, and 2l+2 from bottom to top.
* **Connections:** Represented by arrows. The arrows indicate the direction of information flow. The connections are colored in shades of blue, with darker shades indicating stronger connections or more direct paths.
* **Labels:**
* x<sub>i</sub><sup>2l</sup>, x<sub>i+1</sub><sup>2l</sup>, x<sub>i+2</sub><sup>2l</sup> (Bottom Layer)
* x<sub>i</sub><sup>2l+1</sup>, x<sub>i+1</sub><sup>2l+1</sup>, x<sub>i+2</sub><sup>2l+1</sup> (Middle Layer)
* x<sub>i</sub><sup>2l+2</sup>, x<sub>i+1</sub><sup>2l+2</sup>, x<sub>i+2</sub><sup>2l+2</sup> (Top Layer)
* e<sub>i,i</sub><sup>l,h</sup> (Label near the bottom-left, indicating a connection between nodes in the bottom and middle layers)
* e<sub>i</sub><sup>l,m</sup> (Label near the top-left, indicating a connection between nodes in the middle and top layers)
### Detailed Analysis
* **Bottom Layer (2l):**
* Node x<sub>i</sub><sup>2l</sup> connects to node x<sub>i</sub><sup>2l+1</sup> in the middle layer.
* Node x<sub>i+1</sub><sup>2l</sup> connects to node x<sub>i+1</sub><sup>2l+1</sup> in the middle layer.
* Node x<sub>i+2</sub><sup>2l</sup> connects to node x<sub>i+2</sub><sup>2l+1</sup> in the middle layer.
* Additionally, each node in the bottom layer connects to all nodes in the middle layer. The connections to the node directly above are darker than the connections to the other nodes.
* **Middle Layer (2l+1):**
* Node x<sub>i</sub><sup>2l+1</sup> connects to node x<sub>i</sub><sup>2l+2</sup> in the top layer.
* Node x<sub>i+1</sub><sup>2l+1</sup> connects to node x<sub>i+1</sub><sup>2l+2</sup> in the top layer.
* Node x<sub>i+2</sub><sup>2l+1</sup> connects to node x<sub>i+2</sub><sup>2l+2</sup> in the top layer.
* Each node in the middle layer also has a self-loop connection to itself in the top layer.
* **Top Layer (2l+2):**
* The top layer consists of nodes x<sub>i</sub><sup>2l+2</sup>, x<sub>i+1</sub><sup>2l+2</sup>, and x<sub>i+2</sub><sup>2l+2</sup>.
### Key Observations
* The diagram illustrates a neural network architecture with connections between adjacent layers.
* Each node in the bottom layer connects to all nodes in the middle layer.
* Each node in the middle layer connects to the corresponding node in the top layer and has a self-loop connection.
* The connections between nodes in adjacent layers are represented by arrows, indicating the direction of information flow.
### Interpretation
The diagram represents a simplified view of a neural network layer, showcasing the connections between nodes. The connections from the bottom layer to the middle layer suggest a form of attention or feature extraction, where each node in the bottom layer contributes to the activation of all nodes in the middle layer. The self-loop connections in the middle layer to the top layer could represent a form of residual connection or memory, allowing the network to retain information from previous layers. The diagram highlights the flow of information and the relationships between nodes in different layers, which are fundamental concepts in neural network architectures.
</details>
(a)
<details>
<summary>extracted/5700921/Figures/Theory/LLM_subgraph_homomorphism.png Details</summary>
### Visual Description
## Diagram: Neural Network Representation of Text
### Overview
The image is a diagram representing a simplified neural network processing text. It shows connections between nodes arranged in layers, with text snippets associated with the input layer. The diagram uses circles to represent nodes and arrows (solid, dashed red, and dashed blue) to represent connections between nodes.
### Components/Axes
* **Nodes:** Represented by circles. They are arranged in four layers.
* **Connections:** Represented by arrows.
* Solid black arrows: Represent direct connections.
* Dashed red arrows: Represent one type of connection.
* Dashed blue arrows: Represent another type of connection.
* **Text:**
* "Vicent van Gogh was born on ... later Vicent van" - Associated with the bottom-left part of the diagram.
* "... known as dentate gyrus. The dentate gyrus ... neurons in dentate" - Associated with the bottom-right part of the diagram.
### Detailed Analysis
The diagram shows a network with four layers of nodes. The bottom layer is associated with text snippets.
* **Layer 1 (Bottom):**
* Nodes are associated with the text "Vicent van Gogh was born on ... later Vicent van" on the left and "... known as dentate gyrus. The dentate gyrus ... neurons in dentate" on the right.
* **Layer 2:**
* Nodes are connected to the nodes in Layer 1 via solid black arrows (vertical connections) and dashed red/blue arrows (diagonal connections).
* **Layer 3:**
* Nodes are connected to the nodes in Layer 2 via solid black arrows (vertical connections) and dashed red/blue arrows (diagonal connections).
* **Layer 4 (Top):**
* Nodes are connected to the nodes in Layer 3 via solid black arrows (vertical connections) and dashed red/blue arrows (diagonal connections).
The connections between the layers are complex, with each node in a layer potentially connected to multiple nodes in the adjacent layers. The dashed red and blue arrows indicate different types of connections, possibly representing different weights or activation patterns.
### Key Observations
* The diagram illustrates a feedforward network architecture.
* The text snippets suggest that the network is processing information related to Vincent van Gogh and the dentate gyrus (a part of the brain).
* The connections between the nodes are not fully connected, indicating a specific architecture or learning pattern.
### Interpretation
The diagram represents a simplified model of how a neural network might process and connect information from text. The text snippets "Vicent van Gogh was born on ... later Vicent van" and "... known as dentate gyrus. The dentate gyrus ... neurons in dentate" are likely inputs to the network. The network then processes this information through multiple layers of interconnected nodes. The different types of connections (solid, dashed red, and dashed blue) likely represent different weights or activation patterns, which determine how the information flows through the network. The diagram suggests a potential relationship between the concepts of Vincent van Gogh and the dentate gyrus, as they are both processed by the same network. This could represent a semantic relationship or a contextual association learned by the network.
</details>
(b)
Figure 7: Left: Illustration of the computation graph over one Transformer block, showing only three tokens, one attention head and three MLP neurons. The edge weights are not shown. Right: The subgraphs $S_{1},S_{2}$ , namely the induced subgraphs of the attention edges (black arrows), belong to the circuit of the induction head. The red arrows denote a homomorphism from $S_{1}$ to $S_{2}$ , and the blue arrows denote a homomorphism from $S_{2}$ to $S_{1}$ .
**Definition 2**
*Given two computation graphs $G_{1},G_{2}$ of an LLM and their subgraphs $S_{1},S_{2}$ , a mapping $f$ from the nodes of $S_{1}$ to the nodes of $S_{2}$ (not necessarily injective) is a homomorphism if
- every node at depth $l∈\{0,... 2L\}$ is mapped to depth $l$ ,
- if two nodes are on the same position $i$ , then they are mapped onto the same position,
- if two nodes share an edge on attention head $h$ or MLP neuron $m$ , then their images also share an edge on head $h$ or neuron $m$ .
If such a homomorphism exists, then we say that $S_{1}$ is homomorphic to $S_{2}$ .*
It may be more convenient to define the mapping to be between the input tokens of two sentences, but we adopt the current formulation as it is applicable to more general settings without an obvious correspondence between the tokens and the hidden features at each layer.
**Definition 3**
*Given an LLM and a distribution of texts, a circuit is an equivalence class $\mathcal{K}$ of subgraphs from computation graphs on random texts, such that
- The computation graph on a random text contains some subgraph $S∈\mathcal{K}$ with positive probability.
- All subgraphs $S∈\mathcal{K}$ are homomorphic to each other.
- All edges of all $S∈\mathcal{K}$ have non-negligible weights.
- The pairs $(\mathbf{t}_{\text{in}}(S),\mathbf{t}_{\text{out}}(S))$ share some interpretable meaning across all $S∈\mathcal{K}$ .*
**Definition 4**
*Given an LLM and a distribution of texts, we call each circuit a knowledge. Furthermore, a circuit $\mathcal{K}$ is called a
- specific knowledge, if the associated inputs $t_{\text{in}}(S)$ for all subgraphs $S∈\mathcal{K}$ share some interpretable meaning, and the associated outputs $t_{\text{out}}(S)$ for all $S∈\mathcal{K}$ are the same or differ by at most a small fraction of tokens.
- abstract knowledge, else.*
From now on, we use knowledge as a countable noun since the circuits are countable. Note that the criterion in Definition 4 is stronger than the last criterion in Definition 3, e.g. consider the circuit that always copy-and-pastes the previous token. We will see that the rigidity of specific knowledges makes them easier to externalize.
Here are some well-known examples of knowledge.
**Example 3**
*Recall the knowledge neuron from Example 1 that helps to answer “The capital of China is Beijing”. Such neurons can be activated by a variety of contexts that involve the subject-relation pair (“China”, “capital”) [29]. Its circuit can be simply defined as the equivalence class of subgraphs induced by edges $e^{l,m}_{i}$ , where $(l,m)$ is the fixed location of the knowledge neuron and $i$ is the variable position of the last token of the context. The associated inputs are “China” and “capital”, and the associated outputs are always “Beijing”. By definition, this circuit is a specific knowledge, since its associated output is fixed and its associated inputs share a clear pattern (fixed tokens with variable positions).*
Similarly, by straightforward construction, one can show that each $n$ -gram can be expressed as a specific knowledge.
**Example 4**
*Recall the induction heads [85] from Example 2 that complete “[a][b] …[a]” with “[b]”. Let $(l,h),(l+1,h^{\prime})$ be the locations of these two heads, and denote the variable positions of the two token [a]’s by $i,j$ . Its circuit is the equivalence class of subgraphs induced by the two edges $e^{l,h}_{i,i+1},e^{l+1,h^{\prime}}_{i+1,j}$ . Although the associated input-output pairs “[a][b]…[a][b]” have a clear pattern, the associated outputs “[b]” alone can be arbitrary, so the induction head is an abstract knowledge.*
More sophisticated abstract knowledges have been identified for in-context learning [116] and indirect object identification [115].
**Definition 5**
*Given a LLM and a knowledge $\mathcal{K}$ , a text $\mathbf{t}=(t_{0},... t_{n})$ is called a realization of $\mathcal{K}$ , if the computation graph on $\mathbf{t}$ has a subgraph that belongs to $\mathcal{K}$ .*
For instance, any text of the form [a][b]…[a][b] can be a realization of the abstract knowledge of induction head.
Our definition of knowledge is extrinsic, depending on a specific LLM, instead of intrinsic, depending only on texts. From this perspective, Problem (1) can be interpreted as relocating the knowledges from an all-encompassing LLM to more efficient models equipped with memory hierarchy. For concreteness, one can fix this reference LLM to be the latest version of ChatGPT or Claude [5, 9], or some infinitely large model from a properly defined limit that has learned from infinite data.
**Assumption 1 (Completeness)**
*Fix a reference LLM and a distribution of texts, let $G$ be the computation graph of a random text. Assume that there exists a set $\mathfrak{K}$ of knowledges such that, with probability 1 over the random text, the subgraph of $G$ induced by edges with non-negligible weights can be expressed as a union of subgraphs $\{S_{i}∈\mathcal{K}_{i}\}$ from $\{\mathcal{K}_{i}\}⊂eq\mathfrak{K}$ .*
Essentially, Assumption 1 posits that all computations in the LLM can be fully decomposed into circuits, so that the LLM is nothing more than a collection of specific and abstract knowledges. This viewpoint underscores that the efficiency of LLMs is ultimately about the effective organization of these knowledges, an objective partially addressed by Problem (1).
2.3 | Memory
Now the question is what knowledge can be separated from the model parameters and moved to the lower levels of the memory hierarchy.
**Definition 6**
*A knowledge $\mathcal{K}$ of the reference LLM is separable if there exists another LLM $M$ such that
- $M$ does not possess this knowledge, such that for any realization $\mathbf{t}$ of $\mathcal{K}$ , the model $M$ cannot generate each token of the associated output $\mathbf{t}_{\text{out}}$ with high probability, e.g. $\mathbb{P}_{M}(t_{i}|t_{0}... t_{i-1})≤ 1/2$ for some $t_{i}∈\mathbf{t}_{\text{out}}$ .
- There exists a text $\mathbf{t}_{*}$ such that for any realization $\mathbf{t}$ of $\mathcal{K}$ , the model $M$ using $\mathbf{t}_{*}$ as prefix can generate each token of the associated output $\mathbf{t}_{\text{out}}$ with high probability, e.g. $\mathbb{P}_{M}(t_{i}|\mathbf{t}_{*}t_{0}... t_{i-1})≥ 0.9$ for every $t_{i}∈\mathbf{t}_{\text{out}}$ .
If among the realizations of $\mathcal{K}$ , the same associated input $\mathbf{t}_{\text{in}}$ can correspond to multiple associated outputs $\mathbf{t}_{\text{out}}$ , then the above probabilities are summed over all branches if position $i$ is a branching point.*
**Definition 7**
*A separable knowledge $\mathcal{K}$ of the reference LLM is imitable if any realization $\mathbf{t}^{\prime}$ of $\mathcal{K}$ can be used as the prefix $\mathbf{t}_{*}$ in Definition 6, e.g. for any realizations $\mathbf{t},\mathbf{t}^{\prime}$ of $\mathcal{K}$ , we have $\mathbb{P}_{M}(t_{i}|\mathbf{t}^{\prime}t_{0}... t_{i-1})≥ 0.9$ for every $t_{i}∈\mathbf{t}_{\text{out}}$ .*
Basically, imitability means that LLMs can achieve the same effect as possessing this knowledge by retrieving example texts that demonstrate this knowledge. Few-shot prompting can be seen as a special case of providing realizations.
Separability is a more general property than imitability. For instance, one can set the prefix $\mathbf{t}_{*}$ to be an abstract description of $\mathcal{K}$ instead of its realization, and this is reminiscent of instruction prompting. Nevertheless, it is not obvious whether the set of separable knowledges is strictly larger than the set of imitable knowledges.
**Claim 1**
*Every specific knowledge $\mathcal{K}$ is imitable and thus is separable.*
* Proof (informal)*
Without loss of generality, we can assume that for any realization $\mathbf{t}$ of $\mathcal{K}$ , all tokens of the associated input $\mathbf{t}_{\text{in}}$ precede all tokens of the associated output $\mathbf{t}_{\text{out}}$ . Otherwise, we can split $\mathbf{t}_{\text{in}}$ into two halves $\mathbf{t}_{1},\mathbf{t}_{2}$ that precedes/does not precede $\mathbf{t}_{\text{out}}$ , and split the corresponding subgraph $S∈\mathcal{K}$ into two halves $S_{1},S_{2}$ that have high weights with respect to $\mathbf{t}_{1},\mathbf{t}_{2}$ . Using monotonicity arguments once Definition 3 is fully formalized, one can try to show that this splitting is invariant across $S∈\mathcal{K}$ and therefore the sets of $S_{1},S_{2}$ are two specific knowledges. Consider sequences of the form [a][b]…[a’][b’], where [a], [a’] (or [b], [b’]) could be the associated inputs (or outputs) of any subgraphs $S,S^{\prime}∈\mathcal{K}$ . By Definition 4, [a] and [a’] always share some interpretable meaning, while [b] and [b’] are approximately the same sequence. One can construct an abstract knowledge that completes [a][b]…[a’] with [b’]: the first part of this circuit detects the common feature of the [a]’s (possibly overlapping with the subgraphs of $\mathcal{K}$ ), the second part is an induction head (analogous to Example 4, it provides [b] with the common feature of the [a]’s and lets [a’] to attend to [b]), and the third part generates [b’] based on [b] with possible slight modifications. This circuit is an abstract knowledge since it can be applied to other specific knowledges as long as their associated inputs share the same meaning with the [a]’s, no matter how their associated outputs could vary. Meanwhile, construct the model $M$ by letting the reference model forget $\mathcal{K}$ (e.g. by finetuning on a modified data distribution such that the associated input of $\mathcal{K}$ is never followed by the associated output, while the rest of the distribution remains the same). Combining this circuit with $M$ completes the proof. ∎
Claim 1 indicates that a lot of knowledges can be externalized from the model parameters. The converse of Claim 1 may not hold, since it is imaginable that some abstract knowledges can also be substituted with their realizations.
**Remark 1**
*There are three details in the proof of Claim 1 that will be useful later
1. The circuit we construct has only one attention head that attends to the reference text $\mathbf{t}^{\prime}$ from the present text $\mathbf{t}$ , while all other computations are confined within either $\mathbf{t}$ or $\mathbf{t^{\prime}}$ .
1. Moreover, in this attention head, the circuit only needs the edges from [b] to [a’]. Thus, in general this head only needs to attend to very few tokens in the reference.
1. It suffices for the reference $\mathbf{t}^{\prime}$ to attend only to itself.
These properties will guide our architecture design.*
To finish the set-up of Problem (1), we define the memory formats. The definition should subsume the aforementioned formats of model parameters, explicit memories and plain texts for RAG, and also allow for new memory formats of future LLMs.
**Definition 8**
*Let $\mathfrak{K}$ be the complete set of knowledges from Assumption 1 and consider the subset of separable knowledges. Let $\mathfrak{T}$ be a set that contains one or several realizations $\mathbf{t}$ for each separable knowledge. Let $f_{1},... f_{m}$ be any functions over $\mathfrak{T}$ . Abstractly speaking, a memory-augmented LLM $M$ is some mapping from prefixes to token distributions with additional inputs
$$
M:\big{(}(t_{0}\dots t_{i-1}),\{\mathcal{K}_{1},\dots\mathcal{K}_{N}\},X_{1},%
\dots X_{m}\big{)}\mapsto\mathbb{P}(\cdot|t_{0}\dots t_{i-1}) \tag{2}
$$
where the set $\{\mathcal{K}_{1},...\mathcal{K}_{N}\}$ consists of non-separable knowledges of $M$ that are invoked at this step, and the sets $X_{j}$ consist of encoded texts
$$
X_{j}=\big{\{}f_{j}(\mathbf{t}_{j,k})\big{\}} \tag{3}
$$
for some $\mathbf{t}_{j,k}∈\mathfrak{T}$ . Each $j=1,... m$ represents a memory format and $f_{j}$ is called the write function of this format. If some realization of a separable knowledge $\mathcal{K}$ participates in the mapping $M$ , then we say that $\mathcal{K}$ is written in format $j$ and read by $M$ .*
Analogous to Assumption 1, we are decomposing each step of LLM inference into the invoked circuits, but the decomposition here also involves reference texts that are written in various memory formats.
Table 3 demonstrates that the write functions could be diverse, and the list is probably far from conclusive. Nevertheless, some heuristics still apply. The write function $f_{j}$ and the read process in $M$ for each format $j$ should be non-trivial such that, for any separable knowledge $\mathcal{K}$ not contained in $M$ and any realization $\mathbf{t}$ of $\mathcal{K}$ , if $\mathcal{K}$ enters in $M$ through format $j$ , then $M$ should be able to generate each token of the associated output of $\mathcal{K}$ in $\mathbf{t}$ with higher probability as in Definition 6. Thus, informally speaking, the total cost of writing and reading $\mathcal{K}$ must be bounded from 0, since some minimum computation is necessary for reducing the uncertainty in generating the correct tokens. It follows that the write cost and read cost are complementary, i.e. cheaper writing must be accompanied by more expensive reading.
We define this inverse relationship between the write cost and read cost as the memory hierarchy. This relationship is in accordance with our experience regarding the three examples of human memories in Table 3, e.g. we can utter the common expressions almost immediately while it may take a few seconds to recall a book we read, but the former skill is acquired through years of language speaking. For the LLM memories in Table 3, the inverse relationship is illustrated Figure 4 and established by the calculations in Appendix A.
<details>
<summary>extracted/5700921/Figures/Theory/knowledge_distribution.png Details</summary>
### Visual Description
## Diagram: Knowledge Representation and Usage
### Overview
The image is a diagram illustrating how knowledge is represented and used, categorized by usage count. It shows the flow of information from "Specific knowledge in raw data" to "Specific knowledge in inference" through different pathways representing "Trivia," "Expertise," and "Common phrases." The diagram also highlights the "Write cost" and "Read cost" associated with different memory formats.
### Components/Axes
* **Title:** Knowledge by usage count
* **Source Node (Left):** Specific knowledge in raw data (contained in a light orange box)
* **Destination Node (Right):** Specific knowledge in inference (contained in a light orange box)
* **Memory Formats (Bottom Left):** Memory formats
* **Intermediate Nodes (Bottom):**
* Retrieved text (contained in a red box)
* Explicit memory (contained in a green box)
* Model parameter (contained in a blue box)
* **Categories (Top):**
* Trivia (red)
* Expertise (green)
* Common phrases (blue)
* **Arrows:** Represent the flow of information, colored according to the category.
* Red arrows: Trivia
* Green arrows: Expertise
* Blue arrows: Common phrases
* **Labels on Arrows:**
* Write cost (associated with Trivia and Expertise)
* Read cost (associated with Expertise and Common phrases)
### Detailed Analysis
* **Specific knowledge in raw data:** Located on the left side, represented by a light orange box.
* **Specific knowledge in inference:** Located on the right side, represented by a light orange box.
* **Trivia (Red):**
* A small red rectangle is positioned above the "Retrieved text" box, indicating the relative usage count of trivia.
* A red arrow originates from the "Specific knowledge in raw data" box, splits into two paths: one going down to "Retrieved text" and the other going directly to "Specific knowledge in inference."
* The arrow segment going from the split to "Retrieved text" is labeled "Write cost".
* **Expertise (Green):**
* A green rectangle is positioned above the "Explicit memory" box, indicating the relative usage count of expertise.
* A green arrow originates from the "Specific knowledge in raw data" box, splits into two paths: one going down to "Explicit memory" and the other going directly to "Specific knowledge in inference."
* The arrow segment going from the split to "Explicit memory" is labeled "Write cost".
* The arrow segment going from "Explicit memory" to "Specific knowledge in inference" is labeled "Read cost".
* **Common phrases (Blue):**
* A blue rectangle is positioned above the "Model parameter" box, indicating the relative usage count of common phrases.
* A blue arrow originates from the "Specific knowledge in raw data" box, goes down to "Model parameter" and then to "Specific knowledge in inference."
* The arrow segment going from "Model parameter" to "Specific knowledge in inference" is labeled "Read cost".
* **Memory Formats:** Located at the bottom, indicating the type of memory associated with each category.
* Retrieved text (red box)
* Explicit memory (green box)
* Model parameter (blue box)
### Key Observations
* The diagram illustrates the flow of knowledge from raw data to inference, categorized by usage count.
* Trivia has a direct path from raw data to inference and also involves retrieved text.
* Expertise involves explicit memory and has both write and read costs.
* Common phrases involve model parameters and have a read cost.
* The relative size of the rectangles above each category ("Trivia," "Expertise," "Common phrases") indicates the relative usage count, with "Common phrases" having the highest usage count, followed by "Expertise," and then "Trivia."
### Interpretation
The diagram suggests that different types of knowledge are processed and stored in different ways. Trivia is quickly retrieved and may not require extensive processing. Expertise requires more structured storage and processing, involving both writing to and reading from explicit memory. Common phrases are likely stored as model parameters, allowing for efficient retrieval during inference. The diagram highlights the trade-offs between different knowledge representation methods in terms of storage, processing cost, and usage frequency. The "Write cost" and "Read cost" labels suggest that there are computational or resource costs associated with storing and retrieving different types of knowledge. The relative heights of the "Trivia", "Expertise", and "Common phrases" blocks suggest the relative frequency of each type of knowledge.
</details>
Figure 8: Different memory formats with different balances of write cost and read cost. The specific knowledges with high to low usage counts are exemplified by common expressions, expertise and trivia, and are assigned to implicit memory, explicit memory and external information.
The imbalanced use of knowledges leads to a heterogeneous distribution of knowledges across the memory hierarchy. To minimize the total cost (1), the separable knowledges that are used more often should be assigned to memory formats with high write cost and low read cost, whereas the rarely used knowledges should be assigned to formats with low write cost and high read cost. Also, adding a new memory format $m+1$ is always beneficial as it expands the search space and decreases the minimum cost whenever the usage count of some knowledge $\mathcal{K}$ lies in the interval
$$
[n^{-}_{m+1},n^{+}_{m+1}]=\big{\{}n\in[0,\infty)~{}\big{|}~{}\text{argmin}_{j}%
~{}\text{cost}_{\text{write}}(\mathcal{K},j)+n\cdot\text{cost}_{\text{read}}(%
\mathcal{K},j)=m+1\big{\}}
$$
Examples of these intervals are displayed in Figure 4. For concreteness, Figure 8 depicts a reasonable distribution of the specific knowledges for humans, and we expect a similar distribution to hold for LLMs equipped with explicit memory.
3 | Design
This section describes the architecture and training scheme of Memory 3.
Regarding architecture, the goal is to design an explicit memory mechanism for Transformer LLMs with moderately low write cost and read cost. In addition, we want to limit the modification to the Transformer architecture to be as little as possible, adding no new trainable parameters, so that most of the existing Transformer LLMs can be converted to Memory 3 models with little finetuning. Thus, we arrive at a simple design:
- Write cost: Before inference, the LLM writes each reference to an explicit memory, saved on drives. The memory is selected from the key-value vectors of the self-attention layers, so the write process involves no training. Each reference is processed independently, avoiding the cost of long-context attention.
- Read cost: During inference, explicit memories are retrieved from drives and read by self-attention alongside the usual context key-values. Each memory consists of very few key-values from a small amount of attention heads, thus greatly reducing the extra compute, GPU storage, drive storage and loading time. It allows the LLM to retrieve many references frequently with limited influence on decoding speed.
Regarding training, the goal is to reduce the cost of pretraining with a more efficient distribution of knowledge. Based on the discussion in Section 2.3, we want to encourage the LLM to learn only abstract knowledges, with the specific knowledges mostly externalized to the explicit memory bank. Ideally, the pretraining cost should be reduced to be proportional to the small amount of knowledge stored in the model parameters, thereby taking a step closer to the learning efficiency of humans.
3.1 | Inference Process
From now on, we refer to the realizations of separable knowledges (Definitions 5 and 6) as references. Our knowledge base (or reference dataset) consists of $1.1× 10^{8}$ text chunks with length bounded by 128 tokens. Its composition is described in Section 4.4.
Each reference can be converted to an explicit memory, which is a tensor with shape
(memory layers, 2, key-value heads, sparse tokens, head dimension) = $(22,2,8,8,80)$
The 2 stands for the key and value, while the other numbers are introduced later.
Before inference, the Memory 3 model converts all references to explicit memories and save them on drives or non-volatile storage devices. Then, at inference time, whenever (the id of) a reference is retrieved, its explicit memory is loaded from drives and sent to GPU to be integrated into the computation of Memory 3. By Remark 1, a reference during encoding does not need to attend to any other texts (e.g. other references or query texts), so it is fine to encode each reference independently prior to inference. Such isolation also helps to reduce the compute of attention.
One can also employ a “cold start” approach to bypass preparation time: each reference is converted to explicit memory upon its initial retrieval, rather than prior to inference. Subsequent retrievals will then access this stored memory. The aforementioned inference with precomputed explicit memories will be called “warm start”.
<details>
<summary>extracted/5700921/Figures/key_figure/m3mory_inference.png Details</summary>
### Visual Description
## Diagram: Memory and Chunk Processing
### Overview
The image is a diagram illustrating the flow of data and processing steps involving memory and data chunks. It shows how data is accessed from memory, processed into chunks, and then decoded. The diagram includes memory blocks, chunk representations, and annotations indicating the span of tokens processed in parallel.
### Components/Axes
* **Memory Blocks:** Five blue rectangular blocks labeled "Memory 0", "Memory 1", "Memory 2", "Memory 3", and "Memory 4". These are stacked vertically on the left side of the diagram.
* **Memory Bank:** A larger blue rectangular block containing 12 smaller rectangles, representing a memory bank. It is located to the right of the memory blocks.
* **Chunks:** Green rectangular blocks labeled "Chunk 0", "Chunk ...", "Chunk C", and "decoding". These represent data chunks being processed.
* **Reference Blocks:** Yellow rectangular blocks labeled "<s\>Reference:" and "<\s\>".
* **Timeline:** A horizontal black arrow indicating the flow of processing from left to right.
* **Annotations:** Red brackets with text indicating "span 128 tokens in parallel" and "64 tokens".
* **Arrows:** Blue arrows indicating the flow of data from the memory blocks to the memory bank and from the chunks to the memory bank.
### Detailed Analysis
* **Memory Blocks:** The memory blocks are arranged vertically, suggesting a sequential or hierarchical memory structure.
* **Memory Bank:** The memory bank appears to be a larger storage unit where data from the memory blocks is consolidated.
* **Chunks:** The chunks represent processed data segments. "Chunk C" is enclosed in a dashed line, possibly indicating a specific stage or type of chunk.
* **Reference Blocks:** The reference blocks are located near the memory blocks and chunks, suggesting they provide context or pointers to specific data locations.
* **Timeline:** The timeline indicates the progression of data processing from the memory blocks to the chunks and decoding stage.
* **Annotations:** The annotations provide information about the size of the data being processed in terms of tokens. "Span 128 tokens in parallel" suggests parallel processing of a larger data segment, while "64 tokens" indicates a smaller segment size.
### Key Observations
* The diagram illustrates a process where data is retrieved from memory, divided into chunks, and then decoded.
* The memory bank acts as an intermediary storage unit.
* The annotations highlight the parallel processing of data and the size of the data chunks.
* The dashed line around "Chunk C" suggests it may have a special role or status in the processing pipeline.
### Interpretation
The diagram depicts a data processing pipeline where data is fetched from memory, organized into chunks, and then decoded. The memory bank likely serves as a buffer or cache to facilitate efficient data access. The annotations regarding token spans suggest that the system is designed to handle variable-sized data segments, with parallel processing employed for larger segments to improve throughput. The distinction of "Chunk C" may indicate a specific type of data chunk or a particular processing stage. The diagram provides a high-level overview of the data flow and processing steps involved in the system.
</details>
Figure 9: The decoding process of Memory 3 with memory recall. Each chunk is a fixed-length interval of tokens, which may belong to either the prompt or generated text.
During inference, as illustrated in Figure 9, whenever the LLM generates 64 tokens, it discards the current memories, uses these 64 tokens as query text to retrieve 5 new memories, and continues decoding with these memories. Similarly, when processing the prompt, the LLM retrieves 5 memories for each chunk of 64 tokens. Each chunk attends to its own memories, and the memories could be different across chunks. We leave it to future work to optimize these hyperparameters.
The retrieval is performed with plain vector search with cosine similarity. The references as well as the query chunks are embedded by BGE-M3, a multilingual BERT model [17]. The query and key vectors for retrieval are both obtained from the output feature of the $\langle\text{cls}\rangle$ token. The vector index is built with FAISS [35].
To further save time, we maintain a fixed-size cache in RAM to store the most recently used explicit memories. It’s been observed that adjacent chunks often retrieve some of the same references. So the cache reduces the cost of loading explicit memories from drives.
**Remark 2**
*It would be ideal to perform retrieval using the hidden features from the LLM itself, since conceptually the LLM should know its needs better than any external module, and such internalized retrieval appears more anthropomorphic. Moreover, retrieving with the hidden features from different layers, different heads and different keywords can help to obtain more diverse results. One simple implementation is to use the sparsified attention queries of the query text to directly search for the explicit memories. Since the explicit memories are the attention key-values, such retrieval can work without the need to finetune the LLM. Specifically, this multi-vector retrieval can follow the routine of [61] with the additional constraint that a query from attention head $h$ can only search for keys from $h$ , while the sparse attention queries can be obtain using the same selection mechanism for explicit memories described later.*
**Remark 3**
*One shortcoming of RAG is that the references are usually text chunks instead of whole documents, and thus during inference the references are encoded without their contexts, making them less comprehensible. This shortcoming can be easily overcome for explicit memories. One solution is to encode each document as one sequence, then chunk the attention key-values into 128-token chunks and sparsify them into explicit memories. This procedure allows the key-values to attend to all their contexts.*
3.2 | Writing and Reading Memory
Each explicit memory is a subset of the attention key-values from a subset of attention heads when encoding a reference. Thus, during inference, the LLM can directly read the retrieved explicit memories through its self-attention layers by concatenating them with the usual context key-values (Figure 9). Specially, for each attention head $h$ at layer $l$ , if it is chosen as a memory head, then its output $Y^{l,h}$ changes from the usual
$$
Y^{l,h}_{i}=\text{softmax}\Big{(}\frac{X^{l,h}_{i}W^{l,h}_{Q}\big{(}X^{l,h}_{[%
:i]}W^{l,h}_{K}\big{)}^{T}}{\sqrt{d_{h}}}\Big{)}X^{l,h}_{[:i]}W^{l,h}_{V}W^{l,%
h}_{O}
$$
where $X_{[:i]}$ denotes all tokens before or at position $i$ and $d_{h}$ denotes the head dimension, to
$$
Y^{l,h}_{i}=\text{softmax}\Big{(}\frac{X^{l,h}_{i}W^{l,h}_{Q}\cdot\text{concat%
}\big{(}K^{l,h}_{0},\dots K^{l,h}_{4},X^{l,h}_{[:i]}W^{l,h}_{K}\big{)}^{T}}{%
\sqrt{d_{h}}}\Big{)}\text{concat}\big{(}V^{l,h}_{0},\dots V^{l,h}_{4},X^{l,h}_%
{[:i]}W^{l,h}_{V}\big{)}W^{l,h}_{O} \tag{4}
$$
where each $(K_{j},V_{j})$ denotes the keys and values of an explicit memory.
While the context BOS token is $\langle\text{s}\rangle$ as usual, when encoding each reference we modify the BOS to “ $\langle\text{s}\rangle$ Reference:” to help the LLM distinguish between encoding normal texts and encoding references. This modified BOS is also prepended to the context during inference, as illustrated in Figure 9, while the context BOS token now serves as a separator between the references and context. Unlike the explicit memories which only appear at a subset of attention heads, this modified BOS is placed at every head at every layer. The motivation is that since the context BOS can attend to the references, its feature is no longer constant, so the LLM needs the modified BOS to serve as the new constant for all attention heads.
Furthermore, we adopt parallel position encoding for all explicit memories, namely the positions of all their keys lie in the same interval of length 128, as depicted in Figure 9. We use the rotary position encoding (RoPE) [107]. The token sparsification is applied after RoPE processes the attention keys, so the selected tokens retain their relative positions in the references. Besides flexibility, one motivation for parallel position is to avoid the “lost in the middle” phenomenon [72], such that if the references are positioned serially, then the ones in the middle are likely to be ignored. Similarly, token sparsification also helps to alleviate this issue by making the attention more focused on the important tokens. We note that designs analogous to the parallel position have been used to improve in-context learning [96] and long-context modeling [15].
3.3 | Memory Sparsification and Storage
One of the greatest challenges for explicit memories is that the attention key-values occupy too much space. They not only demand more disk space, which could be costly, but also occupy GPU memory during inference, which could harm the batch size and thus the throughput of LLM generation. An intense compression is needed to save space. The full attention key tensor (or value tensor) for each reference has shape (layers, key-value heads, tokens, head dimension), so we compress all four dimensions.
Regard layers, we only set the first half of the attention layers to be memory layers, i.e. layers that produce and attend to explicit memories (4), while the second half remain as the usual attention layers. Note that Remark 1 suggests that it is usually the attention heads in the middle of the LLM that attend to the references. So it seems that appointing the middle attention layers (e.g. the ones within the $25\%$ to $75\%$ depth range) to be memory layers is a more sensible choice. This heuristic is supported by the observations in [122, 39] that the attention to the distant context usually takes place in the middle layers.
Regarding heads, we set all key-value heads at each memory layer to be memory heads. We reduce their amount by grouped query attention (GQA) [6], letting each key-value head be shared by multiple query heads, and obtain 20% sparsity (8 versus 40 heads). It is worth mentioning that, besides GQA and memory layers, another approach is to select a small subset of heads that are most helpful for reading memories, and this selection does not have to be uniform across layer. We describe several methods for selecting memory heads in Remark 4.
Regarding tokens, we select 8 tokens out of 128 for each key-value head. We choose a high level of sparsity, since Remark 1 indicates that the attention from the context to the references are expected to be concentrated on very few tokens. Note that the selected tokens are in general different among heads, so in principle their union could cover a lot of tokens. For each head $h$ at layer $l$ , the selection uses top-8 over the attention weight
$$
w^{l,h}_{j}=\sum_{i=0}^{127}\tilde{a}^{l,h}_{i,j},\quad\tilde{a}^{l,h}_{i,j}=%
\text{softmax}_{j}\Big{(}\frac{X^{l,h}_{i}W^{l,h}_{Q}(X^{l,h}_{j}W^{l,h}_{K})^%
{T}}{\sqrt{d_{h}}}\Big{)}
$$
which measures the importance of a token by the attention received from all tokens. The BOS tokens and paddings do not participate in the the computation of the weights. These attention weights $\tilde{a}$ are different from the usual ones, such that there is no causal mask or position encoding involved. The consideration is that since the explicit memories are prepared before any inference, the selection can only depend on the reference itself instead of any context texts. The removal of causal mask and position encoding ensures that tokens at any position has an equal chance to receive attention from others. To speed up computation, we adopt the following approximate weights in our implementation, although in retrospect this speedup is not necessary.
$$
w^{l,h}_{j}=\sum_{i=0}^{127}\exp\Big{(}\frac{X^{l,h}_{i}W^{l,h}_{Q}(X^{l,h}_{j%
}W^{l,h}_{K})^{T}}{\sqrt{d_{h}}}\Big{)}
$$
Similar designs that sparsify tokens based on attention weights have been adopted in long-context modeling to save space [74, 131].
Regarding head dimension, we optionally use a vector quantizer to compress each of the key and value vectors using residual quantizations [18] built with FAISS [35]. The compression rate is $80/7≈ 11.4$ . During inference, the retrieved memories are first loaded from drives, and then decompressed by the vector quantizer before being sent to GPU. The evaluations in Section 7.1 indicate that this compression has negligible influence on the performance of Memory 3. More details can be found in Appendix B.
Hence, the total sparsity is 160 or 1830 (without or with vector compression). Originally, the explicit memory bank would have an enormous size of 7.17PB or equivalently 7340TB (given the model shape described in Section 3.4 and saved in bfloat16). Our compression brings it down to 45.9TB or 4.02TB (without or with vector compression), both acceptable for the drive storage of a GPU cluster.
To deploy the Memory 3 model on end-side devices such as smart phones and laptops, one can place the explicit memory bank and the vector index on a cloud server, while the devices only need to store the model parameters and the decoder of the vector quantizer. During inference, to perform retrieval, the model on the end-side device sends the query vector to the cloud server, which then searches the index and returns the compressed memories. The speed test of this deployment is recorded in Section 7.5.
**Remark 4**
*If one wants to finetune a pretrained LLM into a Memory 3 model, there are several ways to select a small but effective subset of attention heads (among all heads at all layers) for memory heads (4). Methods such as [122, 39] are proposed to identify the heads that contribute the most to long-context modeling by retrieving useful information from distant tokens, and usually these special heads account for only $<10\%$ of the total heads. Here we also propose a simple method for selecting memory heads: Given the validation subsets of a representative collection of evaluation tasks, one can measure the average performance $s_{h}$ for a modified version of the LLM for each attention head $h$ . The modification masks the distant tokens for head $h$ so it can only see the preceding 100 tokens and the BOS token. Then, it is reasonable to expect that $s_{h}$ would be markedly low for a small subset of heads $h$ , indicating that they are specialized for long-range attention.*
**Remark 5**
*Actually, Remark 1 suggests that each reference only needs to be attended to by just one attention head, although in general this special head may be different among the references. Thus, it seems a promising approach to apply adaptive sparsity not only to token selection, but also to the memory heads, namely each reference is routed to one or two heads (analogously to MoE), and its explicit memory is produced and read by these heads. Such design if feasible can further boost the sparsity of explicit memory and save much more space.*
3.4 | Model Shape
As discussed in Section 2.3, the specific knowledges can be externalized to explicit memories, and thus to minimize the total cost (1), the model parameters (or implicit memory) only need to store abstract knowledges and the subset of specific knowledges that are frequently used. The shape of our model, i.e. (the number of Transformer blocks $L$ , heads $H$ , head dimension $d_{h}$ , width of the MLP layers $W$ ), is chosen to accommodate this desired knowledge distribution. Informally speaking, given a fixed parameter size $P$ , the shape maximizes the following objective
$$
\max_{L,H,d_{h},W}\Big{\{}\frac{\text{capacity for abstract knowledge}}{\text{%
capacity for specific knowledge}}~{}\Big{|}~{}\text{size}(L,H,d_{h},W)\approx P%
\Big{\}} \tag{5}
$$
Here we set $P$ to be 2.4 billion.
Some recent works suggest that the capacities for learning specific knowledges and abstract knowledges are subject to different constraints. On one hand, [29] observes that the amount of bits of trivia information (such as a person’s name, date of birth and job title) that a LLM can store depends only on its parameter size. Regardless of $L$ and $H$ , the max capacity is always around 2 bits per parameter.
On the other hand, [120] trains Transformers to learn simple algorithms such as reversing a list and counting the occurrence of each letter. It is observed that for several such tasks, there exists a minimum $L_{0}$ and $H_{0}$ such that a Transformer with $L≥ L_{0}$ and $H≥ H_{0}$ can learn the task with perfect accuracy, whereas the accuracy drops significantly for Transformers with either $L=L_{0}-1$ or $H=H_{0}-1$ (given that either $L_{0}$ or $H_{0}≥ 2$ ). This sharp transition supports the view that the layers and heads of Transformer LLMs can be compared to algorithmic steps, and tasks with a certain level of complexity require at least a certain amount of steps. It is worth mentioning that the emergent phenomenon [119, 105] of LLMs can also be explained by this view and thus adds support to it, although it may not be the only explanation.
By Definition 4, the abstract knowledges are expected to be circuits with greater complexity than specific knowledges, since their associated inputs and outputs exhibit greater variability and thus express more complex patterns. It follows that, in the context of the aforementioned works, the separation of specific and abstract knowledges should be positively correlated with the distinction between trivia information and algorithmic procedures. Hence, it is reasonable to adopt the approximation that the capacity of an LLM for specific knowledges only depends on its parameter size, whereas the capacity for abstract knowledges depends only on $L$ and $H$ .
The informal problem (5) reduces to the maximization of $L$ and $H$ given a fixed parameter size. However, we are left with two ambiguities: first, this formulation does not specify the ratio between $L$ and $H$ , and second the head dimension $d_{h}$ and MLP width $W$ cannot be too small as the training may become unstable. Regarding the second point, our experiments indicate that pretraining becomes more unstable with increased spikes if $d_{h}≤ 64$ , so we set $d_{h}=80$ (though it needs to be pointed out that the loss spikes may not be solely attributed to the choice of $d_{h}$ , and high-quality data for instance may stabilize training and allow us to choose a smaller $d_{h}$ ). Also, the MLP width $W$ is set to be equal to the hidden dimension $d=Hd_{h}$ . Regarding the first point, controlled experiments (Figure 10) indicate that the loss decreases slightly more rapidly with $L:H≈ 1$ than with other ratios, so we adopt this ratio.
<details>
<summary>extracted/5700921/Figures/key_figure/optimize_2B_shape_warmup.png Details</summary>
### Visual Description
## Line Chart: Warmup
### Overview
The image is a line chart titled "Warmup". It displays the performance of six different configurations, likely during a model training warmup phase. The x-axis represents the number of samples (in millions), ranging from 5M to 8M. The y-axis represents a performance metric, ranging from 2.6 to 2.75. Each configuration is represented by a colored line, with shaded regions around the lines indicating variability.
### Components/Axes
* **Title:** Warmup (located at the top-center of the chart)
* **X-axis:**
* Label: "sample" (located at the bottom-right of the chart)
* Scale: 5M, 5.5M, 6M, 6.5M, 7M, 7.5M, 8M
* **Y-axis:**
* Scale: 2.6, 2.65, 2.7, 2.75
* **Legend:** Located at the top of the chart, listing the configurations and their corresponding colors:
* Red: l45-h24-d128
* Purple: l48-h48-d64
* Green: l66-h32-d80
* Blue: l44-h40-d80
* Brown: l30-h48-d80
* Orange: l30-h40-d96
### Detailed Analysis
* **l45-h24-d128 (Red):** The red line starts at approximately 2.74 at 5M samples and gradually decreases to approximately 2.62 at 8M samples. The line shows a consistent downward trend.
* **l48-h48-d64 (Purple):** The purple line starts at approximately 2.74 at 5M samples and decreases to approximately 2.62 at 8M samples. The line shows a consistent downward trend, similar to the red line.
* **l66-h32-d80 (Green):** The green line starts at approximately 2.76 at 5M samples. It initially decreases, then exhibits a sharp increase around 6.3M samples, peaking above 2.72, before decreasing again to approximately 2.62 at 8M samples. This line shows the most variability.
* **l44-h40-d80 (Blue):** The blue line starts at approximately 2.72 at 5M samples and decreases to approximately 2.61 at 8M samples. The line shows a consistent downward trend.
* **l30-h48-d80 (Brown):** The brown line starts at approximately 2.73 at 5M samples and decreases to approximately 2.61 at 8M samples. The line shows a consistent downward trend.
* **l30-h40-d96 (Orange):** The orange line starts at approximately 2.73 at 5M samples and decreases to approximately 2.61 at 8M samples. The line shows a consistent downward trend.
### Key Observations
* All configurations show a general downward trend, indicating improvement in the performance metric as the number of samples increases.
* The green line (l66-h32-d80) exhibits a significant spike around 6.3M samples, suggesting a temporary degradation in performance for that configuration.
* The blue line (l44-h40-d80) consistently performs slightly better (lower value) than the other configurations, except for the green line after 7M samples.
* The red and purple lines are very close to each other.
* The brown and orange lines are very close to each other.
### Interpretation
The chart illustrates the "warmup" phase of a model training process, where different configurations are being evaluated. The downward trend in the performance metric suggests that the models are learning and improving over time. The spike in the green line indicates a potential issue or instability with that particular configuration. The blue line appears to be the most stable and performant configuration overall, at least during this warmup phase. The close proximity of the red/purple and brown/orange lines suggests that those configurations may have similar characteristics or performance profiles. The shaded regions around the lines indicate the variance in the performance metric, which could be due to factors such as data variability or stochasticity in the training process.
</details>
Figure 10: Comparison of the training losses of models with different shapes, whose parameter sizes range in $2.1\sim 2.4$ B. The legend l44h40d80 denotes $L=44,H=40,d_{h}=80$ , and the $x$ -axis denotes the amount of training samples. Nevertheless, this comparison is not definite, since this is only the warmup stage of our training scheme (Section 3.6) and the ranking may change in the continual train stage when explicit memory is introduced.
In addition, as discussed in Section 3.3, our model uses grouped query attention (GQA), so the number of key-value heads $H_{kv}$ is set to be $8$ , which is the usual choice for GQA. The MLP layers are gated two-layer networks without bias, which are the default choice in recent years [110, 11, 21, 8].
Finally, the model shape is set to be $L=44,H=40,H_{kv}=8,d_{h}=80,W=3200$ , with the total non-embedding parameter size being $2.4$ B.
3.5 | Training Designs
Similar to our architecture design, the design of our training scheme focuses on learning abstract knowledges. The goal is to reduce the training compute, as the LLM no longer needs to memorize many of the specific knowledges. This shift in learning objective implies that all the default settings for pretraining LLMs may need to be redesigned, as they were optimized for the classical scenario when the LLMs learn both abstract and specific knowledges.
1. Data: Ideally, the pretraining data should have a high concentration of abstract knowledges and minimum amount of specific knowledges. It is known that LLM pretraining is very sensitive to the presence of specific knowledges. For instance, [55] observes that a small model can master arithmetic (e.g. addition of large numbers) if trained on clean data. However, if the training data is mixed with trivial information (e.g. random numbers), then the test accuracy stays at zero unless the model size is increased by a factor of 1500. It suggests that training on specific knowledges significantly inhibits the learning of abstract knowledges, and may explain why emergent abilities [119] are absent from small models. Notably, the Phi-3 model [4] is pretrained with a data composition that closely matches our desired composition. Although the technical details are not revealed, it is stated that they filter data based on two criteria: the data should encourage reasoning, and should not contain information that is too specific.
1. Initialization: [132] observes that initializing Transformer parameters with a smaller standard deviation ( $d^{c}$ with $c<-1/2$ instead of the usual $\Theta(d^{-1/2})$ [47, 52]) can encourage the model to learn compositional inference instead of memorization. Specially, an arithmetic dataset is designed with a train set and an out-of-distribution test set, which admits two possible answers. One answer relies on memorizing more rules during training, while the other requires an understanding of the compositional structure underlying these rules. The proposed mechanism is that training with smaller initialization belongs to the condensed regime that encourages sparse solutions, contrary to training with large initialization that belongs to the kernel regime or critical regime [78, 19].
1. Weight decay: [90, 88] observe that using a larger weight decay coefficient (i.e. greater than the usual range of $0.001\sim 0.1$ ) can guide LLMs to favor generalization over memorization, and accelerate the learning of generalizable solutions. They consider settings that exhibit grokking [90] such that training would transit from perfect train accuracy and zero test accuracy to perfect test accuracy, and generalization ability is measured by how quickly this transition occurs. Moreover, theoretically speaking, it is expected that training generative models needs stronger regularization than training regression models, in order to prevent the generated distributions from collapsing onto the training data and become trivial [128].
In summary, it is recommendable to pretrain the Memory 3 model with a data composition that emphasizes abstract knowledges and minimizes specific information, a smaller initialization for parameters, and a larger weight decay coefficient.
Since this work is only a preliminary version of Memory 3, we decide to stick with the conventional setting for training and have not experimented with any of these ideas. We look forward to incorporating these designs in future versions of the Memory 3 model.
3.6 | Two-stage Pretrain
The Memory 3 model learns to write and read explicit memories during pretraining. The training data is prepended with retrieved references; the model encodes these references into explicit memories in real time, and integrates them into the self-attention computation of the training data.
Unexpectedly, our pretraining consists of two stages, which we name as warmup and continual train. Only the continual train stage involves explicit memories, while the warmup stage uses the same format as ordinary pretraining. Our motivation is depicted in Figure 11. We observe that pretraining with explicit memories from the beginning would render the memories useless, as there appears to be no gain in training loss compared to ordinary pretraining. Meanwhile, given a checkpoint from ordinary pretraining, continual training with explicit memory exhibits a visible decrease in training loss. This comparison implies that a memory-less warmup stage might be necessary for pretraining a Memory 3 model. One possible explanation for this phenomenon is that in the beginning of pretraining, the model is too weak to understand and leverage the explicit memories it generates. Then, to reduce distraction, the self-attention layers might learn to always ignore these memories, thus hindering indefinitely the development of explicit memory.
<details>
<summary>extracted/5700921/Figures/key_figure/warmup_l40-h32-d64-ml20_smooth95.png Details</summary>
### Visual Description
## Line Chart: Pretrain (Warmup)
### Overview
The image is a line chart comparing the performance of two models during pretraining: a control model (without memory) and a model pretrained with memory. The chart displays the trend of some metric (likely loss or error) over the number of samples processed. Both models show a decreasing trend, indicating learning, but the chart aims to highlight any differences in their learning curves.
### Components/Axes
* **Title:** Pretrain (Warmup)
* **X-axis:** samples, with markers at 5M, 10M, 15M, 20M, and 25M.
* **Y-axis:** Numerical values ranging from 2.6 to 3.0, with markers at 2.6, 2.7, 2.8, 2.9, and 3.
* **Legend:** Located at the top of the chart.
* Blue line: control (without memory)
* Green line: pretrain with memory
### Detailed Analysis
* **Control (without memory) - Blue Line:**
* Trend: The blue line starts at approximately 3.0 and generally slopes downward, indicating a decrease in the metric being measured.
* Data Points:
* At 5M samples, the value is approximately 2.9.
* At 10M samples, the value is approximately 2.8.
* At 15M samples, the value is approximately 2.7.
* At 20M samples, the value is approximately 2.65.
* At 25M samples, the value is approximately 2.62.
* **Pretrain with memory - Green Line:**
* Trend: The green line also starts at approximately 3.0 and slopes downward, similar to the blue line.
* Data Points:
* At 5M samples, the value is approximately 2.9.
* At 10M samples, the value is approximately 2.8.
* At 15M samples, the value is approximately 2.7.
* At 20M samples, the value is approximately 2.67.
* At 25M samples, the value is approximately 2.62.
### Key Observations
* Both lines start at roughly the same point (approximately 3.0) and decrease over time.
* The green line (pretrain with memory) appears to be slightly above the blue line (control without memory) for most of the chart, suggesting a slightly higher value for the metric being measured.
* The difference between the two lines seems to diminish as the number of samples increases, indicating that the models converge.
* There is a light blue/green shaded region around each line, which likely represents the variance or standard deviation of the data.
### Interpretation
The chart suggests that pretraining with memory may initially lead to slightly higher values for the metric being measured compared to the control model. However, as the training progresses (more samples are processed), the difference between the two models decreases, indicating that both models eventually achieve similar performance levels. The shaded regions around the lines suggest that there is some variability in the data, but the overall trends are consistent. The "Warmup" in the title suggests that this is the initial phase of training, and the long-term performance of the models may differ.
</details>
(a)
<details>
<summary>extracted/5700921/Figures/key_figure/continual_l40-h32-d64-ml20_smooth95.png Details</summary>
### Visual Description
## Line Chart: Continual Train
### Overview
The image is a line chart titled "Continual Train" that compares three different training configurations: "memory-memory" (green), "control-memory" (red), and "control-control" (blue). The chart displays the performance of these configurations over a range of samples, from 0 to 10 million. The y-axis represents an unspecified metric, ranging from 2.56 to 2.66. The background contains faint vertical lines, possibly representing individual data points or iterations.
### Components/Axes
* **Title:** Continual Train
* **X-axis:** samples (labeled at the bottom-right corner)
* Scale: 0 to 10M, with major ticks at 2M intervals (2M, 4M, 6M, 8M, 10M).
* **Y-axis:** No explicit label.
* Scale: 2.56 to 2.66, with major ticks at 0.02 intervals (2.56, 2.58, 2.6, 2.62, 2.64, 2.66).
* **Legend:** Located at the top of the chart.
* memory-memory (green line)
* control-memory (red line)
* control-control (blue line)
### Detailed Analysis
* **memory-memory (green line):**
* Trend: Initially decreases, then stabilizes and slightly decreases again towards the end.
* Starting value: Approximately 2.62
* Value at 2M samples: Approximately 2.61
* Value at 4M samples: Approximately 2.615
* Value at 6M samples: Approximately 2.61
* Value at 8M samples: Approximately 2.60
* Value at 10M samples: Approximately 2.595
* **control-memory (red line):**
* Trend: Decreases significantly over the entire range.
* Starting value: Approximately 2.66
* Value at 2M samples: Approximately 2.60
* Value at 4M samples: Approximately 2.59
* Value at 6M samples: Approximately 2.59
* Value at 8M samples: Approximately 2.58
* Value at 10M samples: Approximately 2.575
* **control-control (blue line):**
* Trend: Decreases slightly, then stabilizes.
* Starting value: Approximately 2.62
* Value at 2M samples: Approximately 2.615
* Value at 4M samples: Approximately 2.62
* Value at 6M samples: Approximately 2.615
* Value at 8M samples: Approximately 2.61
* Value at 10M samples: Approximately 2.61
### Key Observations
* The "control-memory" configuration (red line) shows the most significant decrease in the metric over the training period.
* The "memory-memory" (green) and "control-control" (blue) configurations show a more stable performance, with a slight decrease over time.
* All three configurations appear to converge towards the end of the training period.
* The background noise (faint vertical lines) suggests high variability in the metric at each sample point.
### Interpretation
The chart compares the performance of three different training configurations for a "Continual Train" task. The "control-memory" configuration exhibits a clear downward trend, suggesting that it may be learning or adapting in a way that reduces the measured metric. The "memory-memory" and "control-control" configurations are more stable, indicating that they may be less sensitive to the training process or have already reached a stable performance level. The high variability in the background suggests that the training process is noisy, and the reported values are likely averages or smoothed representations of the underlying data. The y-axis label is missing, so the exact meaning of the metric is unknown, but the data suggests that minimizing this metric is the goal of the training process.
</details>
(b)
Figure 11: Left: Comparison of the warmup stage (training from scratch) with and without explicit memory. The blue and green curves are trained without and with explicit memories, respectively. Right: Comparison of the continual train stage. The blue and green curves are continual trained from their warmup checkpoints, and the red curve is initialized with the warmup checkpoint of the blue curve and continual trained with explicit memory. These plots indicate that pretraining a Memory 3 model requires a memory-less warmup stage. These experiments use a smaller model with 0.92B non-embedding parameters $(L=40,H=32,d_{h}=64)$ . The warmup stage uses 60B data and the continual train stage uses 22B.
Another modification is to reduce the cost of continual train. Recall from Section 3.1 that during inference, each 64-token chunk attends to five explicit memories, or equivalently five 128-token references if using cold start, increasing the amount of input tokens by 10 times. The inference process avoids the cost of memory encoding by precomputation or warm start, but for the continual train, the references need to be encoded in real time. Our solution is to let the chunks share their references during training to reduce the total number of references in a batch. Specifically, each chunk of a training sequence retrieves only one reference, and in compensation, attends to the references of the previous four chunks, besides its own reference. Each train sequence has length 2048 and thus 32 chunks, so it is equipped with $32× 128=4096$ reference tokens. The hidden features of these reference tokens are discarded once passing the last memory layer, since after that they no longer participate in the update of the hidden feature of the train tokens. Hence, each continual train step takes slightly more than twice the amount of time of a warmup step.
It is necessary to avoid information leakage when equipping the training data with references (i.e. the train sequence and its retrieved references could be the same text), for otherwise training becomes too easy and the model would not learn much. Previously, Retro [16] requires that no train sequence can retrieve a reference from the same document, but this criterion may be insufficient since near-identical paragraphs may appear in multiple documents. Thus, we require that no train sequence can be accompanied by a reference sequence that has $>90\%$ overlap with it. The overlap is measured by the length of their longest common subsequence divided by the length of the reference length. Specially, given any train sequence $\mathbf{t}$ and reference $\mathbf{r}$ , define their overlap by
$$
\displaystyle\begin{split}\text{overlap}(\mathbf{t},\mathbf{r}):=\frac{1}{|%
\mathbf{r}|}\max\big{\{}N&~{}\big{|}~{}\exists 1\leq i_{1}<\dots<i_{N}\leq|%
\mathbf{t}|~{}\text{and}~{}\exists 1\leq j_{1}<\dots<j_{N}\leq|\mathbf{r}|\\
&~{}\text{and}~{}|i_{N}-i_{1}|\leq 2|\mathbf{r}|,~{}\text{such that}~{}\mathbf%
{t}_{i_{k}}=\mathbf{r}_{j_{k}}~{}\text{for}~{}k=1,\dots N\big{\}}\end{split} \tag{6}
$$
The constraint $|i_{N}-i_{1}|≤ 2|\mathbf{r}|$ ensures that the overlap is not over-estimated as $|\mathbf{t}|→∞$ .
4 | Pretraining Data
This section describes the procedures for collecting and filtering our pretraining dataset and knowledge base (or reference dataset).
4.1 | Data Collection
The pretrain data is gathered from English and Chinese text datasets, mostly publicly available collections of webpages and books. We also include code, SFT data (supervised finetuning), and synthetic data.
Specially, the English data mainly consists of RedPajamaV2 [23], SlimPajama [104] and the Piles [43], in total 200TB prior to filtering. The Chinese data mainly comes from Wanjuan [51], Wenshu [2], and MNBVC [81], in total 500TB prior to filtering. The code data mainly comes from Github, and we take the subset with the highest repository stars. The SFT data is included since these samples generally have higher quality than the webpages. We use the same data as in SFT training (Section 6.1), except that these samples are treated as ordinary texts during pretraining, i.e. all tokens participate in the loss computation, not just the answer tokens.
4.2 | Filtering
The raw data is filtered with three steps: deduplication, rule-based filtering, and model-based filtering.
First, deduplication is performed with MinHash for most of the datasets. One exception is RedPajamaV2, which already comes with deduplication labels.
Second, we devise heuristic, rule-based filters analogous to the ones from [76, 92, 25]. The purpose is to eliminate texts that are ostensibly unsuitable for training, such as ones that only contain webpage source codes, random numbers, or incomprehensible shards. Our filters remove documents with less than 50 words, documents whose mean word lengths exceed 10 characters, documents with 70% of context being non-alphabetic characters, documents whose fractions of unique words are disproportionately high, documents whose entropy of unigrams is excessively low, and so on.
Finally, we select the subset of data with highest “quality”, a score produced by a finetuned BERT model. Specially, we sample ten thousand documents and grade them by the XinYu-70B model [65, 68] with prompt-guided generation. The prompt asks the model to determine whether the input text is informative and produce a score between $0 0$ and $5$ . Then, these scores are used to finetune the Tiny-BERT model [57], which has only 14M parameters. The hyperparameters of this finetuning are optimized with respect to a held-out validation set. After that, we use this lightweight BERT to grade the entire dataset.
**Remark 6**
*Recall from Section 3.5 that the pretraining data of Memory 3 should emphasize abstract knowledges and minimize specific knowledges. The purpose is to not only obtain a lightweight LLM with an ideal distribution of knowledges in accordance with the memory hierarchy (Figure 8), but also prevent the specific knowledges from hindering the learning process of the model. The focus of our prompt on “informativeness” might be contradictory to this goal, since the selected texts that are rich in information content may contain too many specific knowledges. For future versions of Memory 3, we will switch to a model-based filter favoring texts that exhibit more reasoning and less specifics.*
<details>
<summary>extracted/5700921/Figures/Data/pretrain_data_distribution.png Details</summary>
### Visual Description
## Chart Type: Pie Chart
### Overview
The image is a 3D pie chart illustrating the distribution of data types in a pre-training dataset. The chart shows the percentage breakdown of English Data, Chinese Data, Code Data, Synthetic Data (SFT), and a very small sliver of an unlabeled data type. The English Data makes up the majority of the dataset.
### Components/Axes
* **Title:** Distribution of Data Types in Pre-training Dataset
* **Categories:**
* English Data (light blue) - 62.0%
* Chinese Data (gold) - 22.1%
* Code Data (light green) - 12.8%
* Synthetic Data SFT (light red) - 3.0%
* Unlabeled Data (gray) - 0.1%
### Detailed Analysis
* **English Data:** The largest slice of the pie, colored light blue, represents 62.0% of the dataset.
* **Chinese Data:** The second largest slice, colored gold, represents 22.1% of the dataset. This slice is slightly separated from the rest of the pie chart, giving it emphasis.
* **Code Data:** The third largest slice, colored light green, represents 12.8% of the dataset.
* **Synthetic Data SFT:** A smaller slice, colored light red, represents 3.0% of the dataset.
* **Unlabeled Data:** A very small sliver, colored gray, represents 0.1% of the dataset.
### Key Observations
* English data dominates the pre-training dataset, accounting for nearly two-thirds of the total data.
* Chinese data is the second largest component, but significantly smaller than English data.
* The unlabeled data is a negligible portion of the dataset.
* The Chinese Data slice is visually separated from the rest of the pie, possibly to highlight its contribution.
### Interpretation
The pie chart provides a clear overview of the composition of the pre-training dataset. The dominance of English data suggests that the model trained on this dataset may be more proficient in English-related tasks. The presence of Chinese data indicates some multilingual capability. The small percentage of Synthetic Data (SFT) suggests that synthetic data augmentation may not be a primary focus. The unlabeled data is so small that it is likely negligible in the training process. The separation of the Chinese Data slice could indicate its importance or a specific focus during the data collection or pre-processing phase.
</details>
Figure 12: Composition of our pretraining dataset.
The filtered dataset consists of around four trillion tokens, and its composition is illustrated in Figure 12.
4.3 | Tokenizer
Similar to our dataset, our tokenizer mainly consists of Chinese and English tokens. The English vocabulary comes from the 32000 tokens of the LLaMA2 tokenizer. We include roughly the same amount of Chinese tokens produced from byte-pair encoding (BPE). The BPE is trained on a 20GB Chinese corpus that consists of Chinese news and e-books. After deduplication, the final vocabulary has 60299 tokens.
4.4 | Knowledge Base
The knowledge base (or reference dataset) is used during training and inference as the source of explicit memories, as depicted in Figure 1. It consists of reference texts that are split into token sequences with length $≤ 128$ , as described in Section 3.1.
Heuristically, a larger knowledge base is always better, as long as it does not contain misinformation, so it is not surprising that the reference dataset of Retro contains its entire pretrain dataset [16]. Nevertheless, the storage of explicit memories is more costly than plain texts despite our sparsification (Section 3.3), and thus to save storage space, we select a small subset of our pretrain dataset as the knowledge base.
With a focus on high quality data, we include for references the English Wikipedia, WikiHow, the Chinese baike dataset, the subset of English and Chinese books whose titles appear academic, Chinese news, synthetic data and high quality codes. These texts are tokenized and split into chunks of 128 tokens, resulting in $1.1× 10^{8}$ references in total.
One may be curious whether our knowledge base may contain some of the evaluation questions, rendering our evaluation results (Section 7.1) less credible. To prevent such leakage, we include in our evaluation code a filtering step, such that for each evaluation question, if a retrieved reference has an overlap with the question that exceeds a threshold, then it is discarded. This deduplication is analogous to the one used when preparing for continual train (Section 3.6), with the overlap measured by (6). The threshold $2/3$ is chosen since we observe that typically a reference that contains a question would have an overlap $≥ 80\%$ , while a relevant but distinct reference would have an overlap $≤ 40\%$ .
**Remark 7**
*Currently, the compilation of the knowledge base is based on human preference. For future versions of Memory 3, we plan to take a model-oriented approach and measure the fitness of a candidate reference by its actual utility, e.g. the expected decrease in the validation loss of the LLM conditioned on this reference being retrieved by a random validation sample.*
5 | Pretrain
This section describes the details of the pretraining process. The two-stage pretrain and memory-augmented data follow the designs introduced in Section 3.6. As an interpretation, the Memory 3 model during the warmup stage develops its reading comprehension, which is necessary during the continual train stage for initiating memory formation.
5.1 | Set-up
Training is conducted with the Megatron-DeepSpeed package [3] and uses mixed-precision training with bfloat16 model parameters, bfloat16 activations, and float32 AdamW states. The batch size is around 4 million training tokens with sequence length 2048, not including the reference tokens. The weight decay is the common choice of 0.1.
We adopt the “warmup-stable-decay” learning rate schedule of MiniCPM [54], which is reportedly better than the usual cosine schedule in term of training loss reduction. The learning rate linearly increases to the maximum value, then stays there for the majority of training steps, and finally in the last 10% steps decays rapidly to near zero. Our short-term experiments confirm the better performance of this schedule. Nevertheless, frequent loss spikes and loss divergences are encountered during the official pretraining, so we have to deviate from this schedule and manually decrease the learning rate to stabilize training.
Originally, it is planned that both the warmup and continual train stages go through the entire 4T token pretrain dataset (Section 4). Due to the irremediable loss divergences, both stages have to be terminated earlier.
5.2 | Warmup Stage
<details>
<summary>extracted/5700921/Figures/key_figure/warmup_loss.png Details</summary>
### Visual Description
## Line Chart: Continual Train
### Overview
The image is a line chart titled "Continual Train". It displays a single blue line representing a data series that decreases over the x-axis, which is labeled "sample" and measured in units of data volume (500M, 1G, 1.5G). The y-axis represents an unspecified metric, ranging from 1.8 to 2.4. The line shows a rapid initial decrease, followed by a more gradual decline, with a noticeable drop around the 1G mark.
### Components/Axes
* **Title:** Continual Train
* **X-axis:**
* Label: sample
* Scale: 0 to 1.5G
* Markers: 500M, 1G, 1.5G
* **Y-axis:**
* Scale: 1.8 to 2.4
* Markers: 1.8, 1.9, 2, 2.1, 2.2, 2.3, 2.4
* **Data Series:** Single blue line. No legend is present, so the meaning of the line is not explicitly defined.
### Detailed Analysis
* **Data Series Trend:** The blue line shows a decreasing trend.
* From the start to 500M, the line decreases rapidly from approximately 2.4 to 2.0.
* From 500M to 1G, the line decreases gradually from approximately 2.0 to 1.95, with some minor fluctuations.
* At 1G, there is a sharp drop in the line.
* From 1G to 1.5G, the line continues to decrease gradually from approximately 1.9 to 1.85, with minor fluctuations.
### Key Observations
* The most significant drop in the data series occurs between 0 and 500M.
* A secondary, smaller drop occurs at 1G.
* The rate of decrease slows down considerably after 500M.
* The data series appears to be approaching a stable value near 1.85 towards the end of the chart.
### Interpretation
The chart likely represents the training progress of a machine learning model in a continual learning setting. The y-axis could represent a loss function or error rate, which decreases as the model is trained on more data ("sample" on the x-axis). The rapid initial decrease suggests fast initial learning, while the subsequent gradual decline indicates diminishing returns. The drop at 1G might indicate a change in the training process, such as the introduction of new data or a change in the learning rate. The overall trend suggests that the model is learning, but the rate of learning decreases over time.
</details>
(a)
<details>
<summary>extracted/5700921/Figures/key_figure/warmup_lr.png Details</summary>
### Visual Description
## Line Chart: Learning Rate
### Overview
The image is a line chart displaying the learning rate over the course of training, measured in samples. The learning rate initially increases rapidly, plateaus, and then decreases in two stages.
### Components/Axes
* **Title:** Learning Rate
* **X-axis:** sample
* Scale: 0 to 1.5G (1.5 * 10^9), with tick marks at 500M (5 * 10^8) and 1G (1 * 10^9).
* **Y-axis:** Learning Rate
* Scale: 0 to 0.0008, with tick marks at 0.0002 intervals.
### Detailed Analysis
* **Data Series:** The single data series is represented by a blue line.
* **Trend:** The line initially rises sharply, plateaus at approximately 0.0008, then drops to approximately 0.0006, remains constant for a while, and then decreases linearly in two segments.
* **Data Points:**
* Starts near 0.
* Rises sharply to approximately 0.0008 before 500M samples.
* Drops to approximately 0.0006 before 500M samples.
* Remains at approximately 0.0006 until approximately 1G samples.
* Decreases to approximately 0.0004 at approximately 1.5G samples.
* Decreases further to approximately 0.00027 after 1.5G samples.
### Key Observations
* The learning rate experiences an initial rapid increase.
* The learning rate plateaus at two different levels.
* The learning rate decreases linearly in two distinct segments towards the end of the training.
### Interpretation
The chart illustrates a learning rate schedule commonly used in machine learning. The initial rapid increase allows for quick learning at the beginning of training. The plateau phase maintains a consistent learning rate. The final decrease helps to fine-tune the model and avoid overshooting the optimal parameters. The two-stage decrease suggests a more granular approach to fine-tuning, potentially targeting different aspects of the model.
</details>
(b)
Figure 13: The warmup stage without explicit memory. Left: Training loss. Right: Learning rate schedule.
The training loss and learning rate schedule are plotted in Figure 13. Whenever severe loss divergence occurs, we restart from the last checkpoint before the divergence with a smaller learning rate, and thus the divergences are not shown in the figure. Eventually, the training terminates at around 3.1T tokens, when reducing the learning rate can no longer avoid loss divergence.
5.3 | Continual Train Stage
<details>
<summary>extracted/5700921/Figures/key_figure/2B_continual_train_loss.png Details</summary>
### Visual Description
## Line Chart: Continual Train
### Overview
The image is a line chart titled "Continual Train". It displays a single blue line representing a training process, with the x-axis labeled "sample" and the y-axis showing values ranging from 1.72 to 1.84. The x-axis spans from 0 to 60M. The line generally decreases over time, indicating a potential learning or convergence process.
### Components/Axes
* **Title:** Continual Train
* **X-axis:**
* Label: sample
* Scale: 0 to 60M, with major ticks at 10M intervals (10M, 20M, 30M, 40M, 50M, 60M)
* **Y-axis:**
* Scale: 1.72 to 1.84, with major ticks at intervals of 0.02 (1.72, 1.74, 1.76, 1.78, 1.8, 1.82, 1.84)
* **Data Series:**
* Blue Line: Represents the "Continual Train" data.
### Detailed Analysis
The blue line starts at approximately 1.84 and exhibits a decreasing trend with fluctuations.
* **Initial Phase (0-10M):** The line rapidly decreases from 1.84 to approximately 1.78.
* **Mid Phase (10M-40M):** The line continues to decrease, but at a slower rate, fluctuating between 1.74 and 1.78.
* **Final Phase (40M-60M):** The line stabilizes, fluctuating around 1.73-1.74, with a slight upward trend towards the end, reaching approximately 1.74 at 60M.
Specific data points (approximate):
* 0: 1.84
* 10M: 1.78
* 20M: 1.75
* 30M: 1.75
* 40M: 1.74
* 50M: 1.73
* 60M: 1.74
### Key Observations
* The training process shows a clear decreasing trend, suggesting improvement or convergence over time.
* The rate of decrease slows down as the number of samples increases, indicating diminishing returns.
* The fluctuations in the line suggest variability in the training process.
* There is a slight increase at the end of the training.
### Interpretation
The chart likely represents the loss or error during a continual training process. The decreasing trend indicates that the model is learning and improving its performance as it is exposed to more samples. The fluctuations suggest that the training process is not perfectly smooth and may be affected by factors such as the specific data samples encountered at each step. The slight increase at the end could indicate overfitting or a change in the data distribution.
</details>
(a)
<details>
<summary>extracted/5700921/Figures/key_figure/2B_continual_lr_schedule.png Details</summary>
### Visual Description
## Line Chart: Learning Rate
### Overview
The image is a line chart depicting the learning rate over a number of samples. The x-axis represents the number of samples in millions (M), ranging from 0 to 60M. The y-axis represents the learning rate, ranging from 0 to 5e-5. The line shows the learning rate initially increasing rapidly, then remaining constant for a period, and finally decreasing in steps.
### Components/Axes
* **Title:** Learning Rate
* **X-axis:** sample
* Scale: 0, 10M, 20M, 30M, 40M, 50M, 60M
* **Y-axis:** Learning Rate
* Scale: 0, 1e-5, 2e-5, 3e-5, 4e-5, 5e-5
* **Data Series:**
* A single line in a dark purple color represents the learning rate.
### Detailed Analysis
The learning rate data series exhibits the following behavior:
1. **Initial Increase:** The line starts at approximately 0 at sample 0 and rises sharply to 5e-5 by approximately 2M samples.
2. **Plateau:** The line remains constant at 5e-5 from approximately 2M samples to approximately 45M samples.
3. **Gradual Decrease:** From approximately 45M to 50M samples, the line gradually decreases from 5e-5 to approximately 4.5e-5.
4. **Sharp Drop:** At approximately 50M samples, the line drops sharply to approximately 2.7e-5.
5. **Slight Decrease:** From approximately 50M to 55M samples, the line decreases slightly to approximately 2.6e-5.
6. **Sharp Drop:** At approximately 55M samples, the line drops sharply to approximately 0.9e-5.
7. **Final Plateau:** The line remains relatively constant at approximately 0.9e-5 from approximately 55M samples to 60M samples.
### Key Observations
* The learning rate is initially increased rapidly.
* The learning rate is held constant for a significant portion of the training.
* The learning rate is decreased in steps, with a larger drop occurring around 50M samples and 55M samples.
* The final learning rate is significantly lower than the initial learning rate.
### Interpretation
The chart illustrates a learning rate schedule that is commonly used in machine learning to improve model convergence and performance. The initial high learning rate allows the model to quickly explore the parameter space and find a good starting point. The constant learning rate allows the model to refine its parameters and converge to a local minimum. The decreasing learning rate helps the model to avoid overshooting the optimal solution and to fine-tune its parameters for better generalization. The sharp drops in learning rate at 50M and 55M samples suggest that the model may have encountered plateaus or oscillations in the loss function, and the learning rate was reduced to help it escape these regions.
</details>
(b)
Figure 14: The continual train stage with explicit memory. Left: Training loss. Right: Learning rate schedule.
The explicit memories enter into the Memory 3 model at this stage. The training steps are slower since the model needs to encode the references retrieved for the pretrain data to explicit memories in real time, and each step takes a bit more than twice the time of a warmup step. The training loss and learning rate schedule are plotted in Figure 14.
The loss divergence soon becomes irremediable at around 120B training tokens, much shorter than the planned 4T tokens, and training has to stop there. One possible cause is that the continual train is initialized from the latest warmup checkpoint, which is located immediately before the break down of the warmup stage, and thus is already at the brink of divergence. The smaller learning rate of continual train delays the onset of divergence but not for long.
6 | Fine-tuning and Alignment
This section describes our model finetuning, specifically supervised finetuning (SFT) and direct preference optimization (DPO).
6.1 | Supervised Finetuning
Analogous to the StableLM model [14], our Memory 3 model is finetuned on a diverse collection of SFT datasets. We use the following datasets, which are publicly accessible on the Hugging Face Hub: UltraChat [34], WizardLM [125], SlimOrca [67], ShareGPT [114], Capybara [31], Deita [73], and MetaMathQA [130]. We also include synthetic data with emphasis on multi-round chat, mathematics, commonsense and knowledge. Each training sample consists of one or more rounds of question and answer pairs. We remove any sample with more than eight rounds. The final composition is listed in Table 15.
| Dataset | Source | Number of Samples |
| --- | --- | --- |
| UltraChat | HuggingFaceH4/ultrachat_200k | 194409 |
| WizardLM | WizardLM/WizardLM_evol_instruct_V2_196k | 80662 |
| SlimOrca | Open-Orca/SlimOrca-Dedup | 143789 |
| ShareGPT | openchat/openchat_sharegpt4_dataset | 3509 |
| Capybara | LDJnr/Capybara | 7291 |
| Deita | hkust-nlp/deita-10k-v0 | 2860 |
| MetaMathQA | meta-math/MetaMathQA | 394418 |
| Multi-round Chat | synthetic | 20000 |
| Mathematics | synthetic | 20000 |
| Commonsense | synthetic | 150000 |
| Knowledge | synthetic | 270000 |
Table 15: Composition of SFT dataset.
The training process uses the cosine learning rate schedule with a max learning rate of $5× 10^{-5}$ and a $10\%$ linear warmup phase. The weight decay is 0.1, batch size is 512, and max sequence length is 2048 tokens. Finetuning is performed for 3 epochs.
6.2 | Direct Preference Optimization
The Memory 3 model is further finetuned by DPO [93], to align with human preference and improve its conversation skills. The DPO dataset consists of general conversations (UltraFeedback Binarized [111]), math questions (Distilabel Math [10]) and codes questions (Synth Code [36]). The training uses the cosine learning rate schedule with max lr $4× 10^{-6}$ . The inverse temperature $\beta$ of the DPO loss is set to $0.01$ . The improvement from DPO is displayed in Section 7.2.
7 | Evaluation
We evaluate the general abilities (benchmark tasks), conversation skills, professional abilities (law and medicine), and facutality & hallucination of the Memory 3 model. We also measure its decoding speed. Our model is compared with SOTA LLMs of similar and larger sizes, as well as RAG models.
7.1 | General Abilities
To evaluate the general abilities of Memory 3, we adopt all tasks from the Huggingface leaderboard and also include two Chinese tasks. Most of the results are displayed in Table 16, while TruthfulQA is listed in Table 19. All results are obtained in bfloat16 format, using the lm-evaluation-harness package [44] and the configuration of HuggingFace Open LLM leaderboard [13], i.e. the number of few-shot examples and grading methods.
As described in Section 4.4, to prevent cheating, a filtering step is included in the retrieval process so that the model cannot copy from references that resemble the evaluation questions.
| | | | English | Chinese | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| LLM | Size | Avg. | ARC-C | HellaSwag | MMLU | Winogrande | GSM8k | CEVAL | CMMLU |
| Falcon-40B | 41B | 55.75 | 61.86 | 85.28 | 56.89 | 81.29 | 21.46 | 41.38 | 42.07 |
| Llama2-7B-Chat | 6.5B | 46.87 | 52.90 | 78.55 | 48.32 | 71.74 | 7.35 | 34.84 | 34.40 |
| Llama2-13B-Chat | 13B | 51.78 | 59.04 | 81.94 | 54.64 | 74.51 | 15.24 | 38.63 | 38.43 |
| Llama3-8B-it | 7.0B | 65.77 | 62.03 | 78.89 | 65.69 | 75.77 | 75.82 | 50.52 | 51.70 |
| Vicuna-13B-v1.5 | 13B | 52.02 | 57.08 | 81.24 | 56.67 | 74.66 | 11.30 | 41.68 | 41.53 |
| Mistral-7B-v0.1 | 7.0B | 59.15 | 59.98 | 83.31 | 64.16 | 78.37 | 37.83 | 45.91 | 44.49 |
| Gemma-2B-it | 2.0B | 36.64 | 38.02 | 40.36 | 55.74 | 35.29 | 55.88 | 8.26 | 29.94 |
| Gemma-7B-it | 7.8B | 47.23 | 51.45 | 71.96 | 53.52 | 67.96 | 32.22 | 27.93 | 25.70 |
| MiniCPM-2B-SFT | 2.4B | 54.37 | 47.53 | 71.95 | 51.32 | 67.72 | 45.26 | 48.07 | 48.76 |
| Phi-2 | 2.5B | 55.70 | 61.09 | 75.11 | 58.11 | 74.35 | 54.81 | 34.40 | 32.04 |
| ChatGLM3-6B | 5.7B | 54.62 | 41.38 | 66.98 | 50.54 | 64.25 | 51.25 | 54.01 | 53.91 |
| Baichuan2-7B-Chat | 6.5B | 55.16 | 52.73 | 74.06 | 52.77 | 69.77 | 28.28 | 53.12 | 55.38 |
| Qwen1.5-1.8B-Chat | 1.2B | 49.67 | 38.74 | 60.02 | 45.87 | 59.67 | 33.59 | 55.57 | 54.22 |
| Qwen1.5-4B-Chat | 3.2B | 58.15 | 43.26 | 69.73 | 55.55 | 64.96 | 52.24 | 61.89 | 59.39 |
| Qwen1.5-7B-Chat | 6.5B | 64.80 | 56.48 | 79.02 | 60.52 | 66.38 | 54.36 | 68.20 | 68.67 |
| Memory 3 -SFT | 2.4B | 63.31 | 58.11 | 80.51 | 59.68 | 74.51 | 52.84 | 59.29 | 58.24 |
| with vector compression | 2.4B | 63.33 | 57.94 | 80.65 | 59.66 | 75.14 | 52.24 | 59.66 | 58.05 |
| without memory | 2.4B | 60.80 | 57.42 | 73.14 | 57.29 | 74.35 | 51.33 | 56.32 | 55.72 |
Table 16: Few-shot evaluation of general abilities. The model sizes only include non-embedding parameters.
The results of our model without using explicit memory is included, which indicates that explicit memory boosts the average score by $2.51\%$ . In comparison, the score difference between Llama2-7B and 13B is $4.91\%$ while the latter has twice the amount of non-embedding parameters. Thus, it reasonable to say that explicit memory can increase the “effective model size” by $2.51/4.91≈ 51.1\%$ . (Also, the score difference between Qwen-1.8B and 4B is $8.48\%$ while the latter has $167\%$ more non-embedding parameters. With respect to this scale, explicit memory increases the “effective model size” by $1.2.51/8.48× 1.67≈ 49.4\%$ .)
We also include the results of Memory 3 with vector compression (Section 3.3). Even though the key-value vectors of the explicit memories are compressed to $8.75\%$ of their original sizes, the performance of our model does not show any degradation.
Other supplementary evaluations can be found in Appendix C.
Next, we compare with a LLM that is pretrained with text retrieval. Specially, we consider the largest version of the Retro++ model [113], Retro++ XXL with 9.5B parameters. All tasks from Table 6 of [113] are taken, except for HANS, which is not available on lm-eval-harness, and all tasks are zero-shot. Similar to Table 16, Memory 3 is tested with a filtering threshold of 2/3. The results are listed in Table 17, where Memory 3 outperforms the model with much larger parameter size and reference dataset size.
| LLM | Param size | Avg. | HellaSwag | BoolQ | Lambada | RACE |
| --- | --- | --- | --- | --- | --- | --- |
| Retro++ XXL | 9.1B | 61.0 | 70.6 | 70.7 | 72.7 | 43.2 |
| Memory 3 -SFT | 2.4B | 64.7 | 83.3 | 80.4 | 57.9 | 45.3 |
| Reference size | | PiQA | Winogrand | ANLI-R2 | WiC | |
| 330B | | 77.4 | 65.8 | 35.5 | 52.4 | |
| 14.3B | | 76.6 | 75.8 | 41.6 | 56.9 | |
Table 17: Zero-shot comparison of LLMs pretrained with retrieval. The scores of Retro++ are taken from [113]. The size of a reference dataset is its number of tokens. The non-embedding parameter size of Retro++ is inferred from its vocabulary size.
7.2 | Conversation Skill
Next we evaluate the conversation skills of Memory 3. We use MT-Bench (the Multi-turn Benchmark) [133] that consists of multi-round and open-ended questions. The results are listed in Table 18, including the Memory 3 model finetuned by DPO introduced in Section 6.2.
| LLM | Size | MT-Bench Score |
| --- | --- | --- |
| Phi-3 | 3.6B | 8.38 |
| Mistral-7B-Instruct-v0.2 | 7.0B | 7.60 |
| Qwen1.5-7B-Chat | 6.5B | 7.60 |
| Zephyr-7B-beta | 7.0B | 7.34 |
| MiniCPM-2B-DPO | 2.4B | 6.89 |
| Llama-2-70B-Chat | 68B | 6.86 |
| Mistral-7B-Instruct-v0.1 | 7.0B | 6.84 |
| Llama-2-13B-Chat | 13B | 6.65 |
| Llama-2-7B-Chat | 6.5B | 6.57 |
| MPT-30B-Chat | 30B | 6.39 |
| ChatGLM2-6B | 6.1B | 4.96 |
| Falcon-40B-Instruct | 41B | 4.07 |
| Vicuna-7B | 6.5B | 3.26 |
| Memory 3 -SFT | 2.4B | 5.31 |
| Memory 3 -DPO | 2.4B | 5.80 |
Table 18: MT-Bench scores. The model sizes only include non-embedding parameters.
We obtain all these scores using GPT-4-0613 as grader, following the single answer grading mode of MT-Bench. Our model outperforms Vicuna-7B, Falcon-40B-Instruct, and ChatGLM2-6B with fewer parameters.
7.3 | Hallucination and Factuality
Despite considerable progress, LLMs still face issues with hallucination, leading to outputs that often stray from factual accuracy [97]. Conceptually, Memory 3 should be less vulnerable to hallucination, since its explicit memories directly correspond to reference texts, whereas compressing texts into the model parameters might incur information loss. To evaluate hallucination, we select two English datasets, TruthfulQA [70] and HaluEval, and one Chinese dataset [64], HalluQA [20]. TruthfulQA is implemented with lm-evaluation-harness [44], while HaluEval and HalluQA are implemented with UHGEval [69]. The results are shown in Table 19, with Memory 3 achieving the highest scores on most tasks.
| | | | English | Chinese | | | |
| --- | --- | --- | --- | --- | --- | --- | --- |
| LLM | Size | Avg. | HaluE-QA | HaluE-Dialogue | TruQA-MC1 | TruQA-MC2 | HalluQA |
| Falcon-40B | 41B | 35.37 | 46.84 | 40.80 | 27.29 | 41.71 | 20.18 |
| Llama2-13B | 13B | 28.01 | 23.34 | 31.05 | 25.95 | 36.89 | 22.81 |
| Vicuna-13B-v1.5 | 13B | 37.07 | 24.93 | 37.35 | 35.13 | 50.88 | N/A |
| Baichuan2-13B | 13B | 37.64 | 46.02 | 45.45 | 26.81 | 39.79 | 30.12 |
| Gemma-7B | 7.8B | 37.03 | 50.91 | 48.19 | 20.69 | 46.65 | 18.71 |
| Mistral-7B-v0.1 | 7.0B | 34.18 | 40.68 | 37.64 | 28.03 | 42.60 | 21.93 |
| Llama2-7B | 6.5B | 36.80 | 52.46 | 51.93 | 25.09 | 38.94 | 15.59 |
| Baichuan2-7B | 6.5B | 38.63 | 62.33 | 47.84 | 23.01 | 37.46 | 22.51 |
| ChatGLM3-6B | 5.7B | 40.96 | 43.38 | 50.03 | 33.17 | 49.87 | 28.36 |
| Qwen1.5-4B-Chat | 3.2B | 33.30 | 24.64 | 37.72 | 29.38 | 44.74 | 30.00 |
| Phi-2 | 2.5B | 38.31 | 50.71 | 39.55 | 31.09 | 44.32 | 25.89 |
| MiniCPM-SFT | 2.4B | 36.47 | 49.24 | 47.80 | 24.11 | 37.51 | 23.71 |
| Gemma-2B | 2.0B | 38.04 | 53.41 | 52.22 | 24.60 | 39.78 | 20.18 |
| Qwen1.5-1.8B-Chat | 1.2B | 37.52 | 47.18 | 52.11 | 26.68 | 40.57 | 21.05 |
| Memory 3 -SFT | 2.4B | 48.60 | 56.61 | 53.91 | 38.80 | 57.72 | 35.96 |
Table 19: Evaluation of hallucination. HaluE and TruQA denote HaluEval and TruthfulQA, respectively. Bolded numbers are the best results. The model sizes only include non-embedding parameters. Vicuna-13B-v1.5 gets one N/A since that entry is near zero and seems abnormal.
7.4 | Professional Tasks
One benefit of using explicit memory is that the LLM can easily adapt to new fields and tasks by updating its knowledge base. One can simply import task-related references into the knowledge base of Memory 3, and optionally, convert them to explicit memories in the case of warm start. Then, the model can perform inference with this new knowledge, skipping the more costly and possibly lossy process of finetuning, and running faster than RAG. This cost reduction has been demonstrated in Figure 4 and Appendix A, and could facilitate the rapid deployment of LLMs across various industries.
Besides cost reduction, we need to demonstrate that Memory 3 can perform no worse than RAG. We consider two professional tasks in law and medicine. The legal task consists of multiple-choice questions from the Chinese National Judicial Examination (JEC-QA) dataset [134]. The field-specific references are legal documents from the Chinese national laws and regulations database [1]. These references are merged with our general-purpose knowledge base (Section 4.4) for inference.
The medical task consists of the medicine-related questions of C-Eval, MMLU and CMMLU, specifically from the following subsets:
- C-Eval: clinical medicine, basic medicine
- MMLU: clinical knowledge, anatomy, college medicine, college biology, nutrition, virology, medical genetics, professional medicine
- CMMLU: anatomy, clinical knowledge, college medicine, genetics, nutrition, traditional Chinese medicine, virology
Our knowledge base is supplemented with medical texts from the open-source medical books dataset [101].
| | JEC-QA | MED | | | | |
| --- | --- | --- | --- | --- | --- | --- |
| LLM | 3 refs | 5 refs | 7 refs | 3 refs | 5 refs | 7 refs |
| Memory 3 -2B-SFT | 39.38 | 56.22 | | | | |
| MiniCPM-2B-SFT | 38.83 | 37.65 | 37.94 | 53.73 | 53.29 | 52.84 |
| Gemma-2B | 28.16 | 28.06 | 25.29 | 42.04 | 42.49 | 42.96 |
| Gemma-2B-it | 30.04 | 31.13 | 29.34 | 41.70 | 43.24 | 42.66 |
| Llama-2-7B | 28.06 | 24.70 | 24.90 | 45.14 | 44.43 | 37.96 |
| Llama-2-7B-Chat | 26.18 | 25.10 | 25.20 | 48.18 | 47.29 | 39.39 |
| Phi-2 | 25.00 | 25.30 | 23.32 | 50.05 | 45.42 | 45.59 |
| Qwen1.5-1.8B-Chat | 42.98 | 43.87 | 41.50 | 52.16 | 52.50 | 52.16 |
| Qwen1.5-4B-Chat | 51.98 | 50.49 | 50.99 | 61.19 | 61.02 | 61.06 |
Table 20: Comparison with RAG on professional tasks.
The results are shown in Table 20, and Memory 3 achieves better performance than most of the models. All evaluations use 5-shot prompting. The RAG models retrieve from the same knowledge bases and FAISS indices, except that they receive text references instead of explicit memories. They only retrieve once for each question, using only the question text for query, so the 5-shot examples do not distract the retrieval. Since the optimal number of references is not known for these RAG models, we test them for 3, 5, and 7 references per question, and it seems that $3\sim 5$ references are optimal. The usual formatting for RAG is used, i.e. header 1 + reference 1 + reference 2 + reference 3 + header 2 + few-shot examples + question, all separated by line breaks.
The performance plotted in Figure 2 (right) is the average of the scores of the two tasks in Table 20 with five references.
7.5 | Inference Speed
Finally, we evaluate the decoding speed or throughput of Memory 3, measured by generated tokens per second. The results are compared to those of RAG models, to quantify the speedup of explicit memory over text retrieval.
A direct comparison of speeds is uninformative: The memory hierarchy (Figure 8) implies that the Memory 3 model is more reliant on retrieval to supply knowledge, and naturally Memory 3 performs retrieval with higher frequency ( $5$ references per 64 tokens, possibly higher in future versions). Therefore, it is necessary to jointly compare performance and speed. The speed measured in this section is plotted against the retrieval-augmented test accuracy from Section 7.4, resulting in Figure 2 (right).
We measure decoding speed on a A800 GPU, and run all models with Flash Attention [32]. All models receive an input of batch size 32 and length 128 tokens, and generate an output with length 128 tokens. The throughput is computed by $32× 128$ divided by the time spent. We test each model 9 times, remove the first record, and take the average of the rest. Memory 3 performs $2× 128/64-1=3$ retrievals (the $-1$ means that the first decoded chunk inherits the explicit memories retrieved by the last input chunk). Each retrieval uses 32 queries to get $32× 5$ explicit memories. We consider the warm start scenario, with the explicit memories precomputed and saved to drives. We implement the worst case scenario, such that the reference ids are reset to be unique after vector search and the memory cache on RAM is disabled, forcing Memory 3 to load $32× 5$ memories from drives. Meanwhile, each RAG model performs one retrieval with query length 64 tokens, receives 5 references for each sample, and inserts them at the beginning of the sample, similar to the setup for Table 20.
The results are listed in Table 21 (local server). The throughput of these models without retrieval is also provided.
| | | Local server | End-side device | | |
| --- | --- | --- | --- | --- | --- |
| LLM | Size | with retrieval | w/o retrieval | with retrieval | w/o retrieval |
| Memory 3 -2B | 2.4B | 733.0 | 1131 | 27.6 | 44.36 |
| MiniCPM-2B | 2.4B | 501.5 | 974.0 | 21.7 | 51.79 |
| Gemma-2B-it | 2.0B | 1581 | 2056 | 22.0 | 29.23 |
| Gemma-7B-it | 7.8B | 395.6 | 1008 | 9.5 | 18.61 |
| Mistral-7B-Instruct-v0.1 | 7.0B | 392.9 | 894.5 | 11.1 | 28.7 |
| Llama-2-7B-Chat | 6.5B | 382.8 | 1005 | 10.0 | 23.19 |
| Llama-2-13B-Chat | 13B | 241.1 | 632.5 | 2.5 | 5.44 |
| Qwen1.5-1.8B-Chat | 1.2B | 908.2 | 1770 | - | - |
| Qwen1.5-4B-Chat | 3.2B | 460.7 | 1002 | 22.3 | 53.39 |
| Qwen1.5-7B-Chat | 6.5B | 365.8 | 894.5 | - | - |
| Phi-2 | 2.5B | 622.2 | 1544 | - | - |
Table 21: Inference throughput, measured by tokens per second.
In addition, we study the throughput of these models when they are hosted on an end-side device and retrieve from a knowledge base on a remote server. Specifically, we use Jetson AGX Orin, and the server uses the vector engine MyScale [82]. The models are run with plain attention, with batch size 1. To simulate real-world use cases, the input is a fixed text prompt, with approximately 128 tokens, while the exact length can vary among different tokenizers. The output length is fixed to be 128 tokens. The results are listed in Table 21 (end-side device), and the Memory 3 model .
**Remark 8**
*Table 21 indicates that our Memory 3 -2B model is $1-733/1131≈ 35.2\%$ slower than the same model without using memory. This is peculiar considering that reading explicit memories accounts for only a tiny fraction of the total compute:
$$
\frac{2.884\times 10^{-3}~{}\text{TFlops}}{1.264~{}\text{TFlops}}\approx 0.228\%
$$
(The calculations are based on Appendix A.) Controlled experiments indicate that the time consumption is mainly due to two sources:
- Loading the memory key-values from drives to GPU: This overhead becomes prominent as Memory 3 retrieves with higher frequency.
- Python implementation of chunkwise attention: When encoding a prompt, since each chunk attends to a different set of explicit memories, we use a for loop over the chunks to compute their attentions.
They dominate other sources such as computing query vectors by the embedding model and searching the vector index. We will try to optimize our code to reduce these overheads to be as close as possible to $0.228\%$ of the total inference time, e.g. implement the chunkwise attention with a CUDA kernel.*
8 | Conclusion
The goal of this work is to reduce the cost of LLM training and inference, or equivalently, to construct a more efficient LLM that matches the performance of larger and slower LLMs. We analyze LLMs from the new perspective of knowledge manipulation, characterizing the cost of LLMs as the transport cost of “knowledges” in and out of various memory formats. Two causes of inefficiency are identified, namely the suboptimal placement of knowledges and the knowledge traversal problem. We solve both problems with explicit memory, a novel memory format, along with a new training scheme and architecture. Our preliminary experiment, the Memory 3 -2B model, exhibits stronger abilities and higher speed than many SOTA models with greater sizes as well as RAG models.
For future work, we plan to explore the following directions:
1. Efficient training with abstract knowledges: Ideally, the training cost of Memory 3 model should be proportional to the small amount of non-separable knowledges, approaching the learning efficiency of humans. One approach is to filter the training data to maximize abstract knowledges and minimize specific knowledges (cf. Section 3.5 and Remark 6), and preferably the LLM should assess the quality of its own training data and ignore the unhelpful tokens.
1. Human-like capabilities: As described in the introduction, the explicit memory allows for interesting cognitive functions such as handling infinite contexts (conversion of working memory to explicit memory), memory consolidation (conversion of explicit memory to implicit memory), and conscious reasoning (reflection on the memory recall process). These designs may further improve the efficiency and reasoning ability of Memory 3.
1. Compact representation of explicit memory: The explicit memory of humans can be subdivided into episodic memory, which involve particular experiences, and semantic memory, which involve general truths [59]. This classification is analogous to our definition of specific and abstract knowledges. Our current implementation of explicit memory is closer to the episodic memory of humans, as each memory directly corresponds to a reference text. To improve its reasoning ability, one can try to equip Memory 3 with semantic memories, e.g. obtained from induction on the episodic memories.
Besides these broad topics, there are also plenty of engineering works that can be done. For instance, an internalized retrieval process that matches sparse attention queries with memory keys (Remark 2), sparser memory heads with routing (Remark 5), memory extraction that fully preserves contexts (Remark 3), compilation of the knowledge base based on machine preference (Remark 7), reduction of the time consumption of explicit memory to be proportional to its compute overhead (Remark 8), and so on.
Acknowledgement
This work is supported by the NSFC Major Research Plan - Interpretable and General Purpose Next-generation Artificial Intelligence of China (No. 92270001). We thank Prof. Zhiqin Xu, Prof. Zhouhan Lin, Fangrui Liu, Liangkai Hang, Ziyang Tao, Xiaoxing Wang, Mingze Wang, Yongqi Jin, Haotian He, Guanhua Huang, Yirong Hu for helpful discussions.
References
- [1] The Chinese National Laws and Regulations Database. https://flk.npc.gov.cn/. [Accessed 20-03-2024].
- [2] Wenshu. https://wenshu.court.gov.cn/. [Accessed 20-03-2024].
- [3] Megatron-DeepSpeed. https://github.com/microsoft/Megatron-DeepSpeed, 2022.
- [4] Marah Abdin, Sam Ade Jacobs, Ammar Ahmad Awan, Jyoti Aneja, Ahmed Awadallah, Hany Awadalla, Nguyen Bach, Amit Bahree, Arash Bakhtiari, Harkirat Behl, Alon Benhaim, Misha Bilenko, Johan Bjorck, Sébastien Bubeck, and et al. Phi-3 technical report: A highly capable language model locally on your phone, 2024.
- [5] Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, Ilge Akkaya, Florencia Leoni Aleman, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, et al. GPT-4 technical report. arXiv preprint arXiv:2303.08774, 2023.
- [6] Joshua Ainslie, James Lee-Thorp, Michiel de Jong, Yury Zemlyanskiy, Federico Lebrón, and Sumit Sanghai. GQA: Training generalized multi-query transformer models from multi-head checkpoints, 2023.
- [7] Zeyuan Allen-Zhu and Yuanzhi Li. Physics of language models: Part 3.3, knowledge capacity scaling laws, 2024.
- [8] Ebtesam Almazrouei, Hamza Alobeidli, Abdulaziz Alshamsi, Alessandro Cappelli, Ruxandra Cojocaru, Mérouane Debbah, Étienne Goffinet, Daniel Hesslow, Julien Launay, Quentin Malartic, Daniele Mazzotta, Badreddine Noune, Baptiste Pannier, and Guilherme Penedo. The falcon series of open language models, 2023.
- [9] AI Anthropic. The Claude 3 model family: Opus, Sonnet, Haiku. Claude-3 Model Card, 2024.
- [10] Argilla. Distilabel Math Preference DPO. https://huggingface.co/datasets/argilla/distilabel-math-preference-dpo, 2023.
- [11] Jinze Bai, Shuai Bai, Yunfei Chu, Zeyu Cui, Kai Dang, Xiaodong Deng, Yang Fan, Wenbin Ge, Yu Han, Fei Huang, Binyuan Hui, Luo Ji, Mei Li, Junyang Lin, Runji Lin, Dayiheng Liu, Gao Liu, et al. Qwen technical report, 2023.
- [12] Peter J Bayley and Larry R Squire. Failure to acquire new semantic knowledge in patients with large medial temporal lobe lesions. Hippocampus, 15(2):273–280, 2005.
- [13] Edward Beeching, Clémentine Fourrier, Nathan Habib, Sheon Han, Nathan Lambert, Nazneen Rajani, Omar Sanseviero, Lewis Tunstall, and Thomas Wolf. Open LLM leaderboard. https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard, 2023.
- [14] Marco Bellagente, Jonathan Tow, Dakota Mahan, Duy Phung, Maksym Zhuravinskyi, Reshinth Adithyan, James Baicoianu, Ben Brooks, Nathan Cooper, Ashish Datta, et al. Stable lm 2 1.6 b technical report. arXiv preprint arXiv:2402.17834, 2024.
- [15] Amanda Bertsch, Uri Alon, Graham Neubig, and Matthew Gormley. Unlimiformer: Long-range transformers with unlimited length input. Advances in Neural Information Processing Systems, 36, 2024.
- [16] Sebastian Borgeaud, Arthur Mensch, Jordan Hoffmann, Trevor Cai, Eliza Rutherford, Katie Millican, George Bm Van Den Driessche, Jean-Baptiste Lespiau, Bogdan Damoc, Aidan Clark, et al. Improving language models by retrieving from trillions of tokens. In International conference on machine learning, pages 2206–2240. PMLR, 2022.
- [17] Jianlv Chen, Shitao Xiao, Peitian Zhang, Kun Luo, Defu Lian, and Zheng Liu. BGE M3-embedding: Multi-lingual, multi-functionality, multi-granularity text embeddings through self-knowledge distillation. arXiv preprint arXiv:2402.03216, 2024.
- [18] Yongjian Chen, Tao Guan, and Cheng Wang. Approximate nearest neighbor search by residual vector quantization. Sensors, 10(12):11259–11273, 2010.
- [19] Zheng Chen, Yuqing Li, Tao Luo, Zhaoguang Zhou, and Zhi-Qin John Xu. Phase diagram of initial condensation for two-layer neural networks. ArXiv, abs/2303.06561, 2023.
- [20] Qinyuan Cheng, Tianxiang Sun, Wenwei Zhang, Siyin Wang, Xiangyang Liu, Mozhi Zhang, Junliang He, Mianqiu Huang, Zhangyue Yin, Kai Chen, and Xipeng Qiu. Evaluating hallucinations in chinese large language models, 2023.
- [21] Aakanksha Chowdhery, Sharan Narang, Jacob Devlin, Maarten Bosma, Gaurav Mishra, Adam Roberts, Paul Barham, Hyung Won Chung, Charles Sutton, et al. Palm: Scaling language modeling with pathways, 2022.
- [22] Bilal Chughtai, Alan Cooney, and Neel Nanda. Summing up the facts: Additive mechanisms behind factual recall in llms. arXiv preprint arXiv:2402.07321, 2024.
- [23] Together Computer. Redpajama: an open dataset for training large language models, October 2023.
- [24] Arthur Conmy, Augustine Mavor-Parker, Aengus Lynch, Stefan Heimersheim, and Adrià Garriga-Alonso. Towards automated circuit discovery for mechanistic interpretability. Advances in Neural Information Processing Systems, 36:16318–16352, 2023.
- [25] Alexis Conneau, Kartikay Khandelwal, Naman Goyal, Vishrav Chaudhary, Guillaume Wenzek, Francisco Guzmán, Edouard Grave, Myle Ott, Luke Zettlemoyer, and Veselin Stoyanov. Unsupervised cross-lingual representation learning at scale. arXiv preprint arXiv:1911.02116, 2019.
- [26] Suzanne Corkin. What’s new with the amnesic patient H.M.? Nature reviews neuroscience, 3(2):153–160, 2002.
- [27] Nelson Cowan. The magical number 4 in short-term memory: A reconsideration of mental storage capacity. Behavioral and Brain Sciences, 24(1):87–114, 2001.
- [28] Nelson Cowan. Working memory capacity: Classic Edition. Routledge, 2016.
- [29] Damai Dai, Li Dong, Yaru Hao, Zhifang Sui, Baobao Chang, and Furu Wei. Knowledge neurons in pretrained transformers. arXiv preprint arXiv:2104.08696, 2021.
- [30] Zihang Dai, Zhilin Yang, Yiming Yang, Jaime Carbonell, Quoc V. Le, and Ruslan Salakhutdinov. Transformer-xl: Attentive language models beyond a fixed-length context, 2019.
- [31] Luigi Daniele and Suphavadeeprasit. Amplify-instruct: Synthetically generated diverse multi-turn conversations for effecient llm training. arXiv preprint arXiv:(coming soon), 2023.
- [32] Tri Dao, Dan Fu, Stefano Ermon, Atri Rudra, and Christopher Ré. Flashattention: Fast and memory-efficient exact attention with io-awareness. Advances in Neural Information Processing Systems, 35:16344–16359, 2022.
- [33] Nolan Dey, Gurpreet Gosal, Zhiming, Chen, Hemant Khachane, William Marshall, Ribhu Pathria, Marvin Tom, and Joel Hestness. Cerebras-gpt: Open compute-optimal language models trained on the cerebras wafer-scale cluster, 2023.
- [34] Ning Ding, Yulin Chen, Bokai Xu, Yujia Qin, Zhi Zheng, Shengding Hu, Zhiyuan Liu, Maosong Sun, and Bowen Zhou. Enhancing chat language models by scaling high-quality instructional conversations, 2023.
- [35] Matthijs Douze, Alexandr Guzhva, Chengqi Deng, Jeff Johnson, Gergely Szilvasy, Pierre-Emmanuel Mazaré, Maria Lomeli, Lucas Hosseini, and Hervé Jégou. The faiss library, 2024.
- [36] Phung Van Duy. synth_code_preference_4k. https://huggingface.co/datasets/pvduy/synth_code_preference_4k, 2023.
- [37] Maha Elbayad, Jiatao Gu, Edouard Grave, and Michael Auli. Depth-adaptive transformer, 2020.
- [38] Nelson Elhage, Tristan Hume, Catherine Olsson, Nicholas Schiefer, Tom Henighan, Shauna Kravec, Zac Hatfield-Dodds, Robert Lasenby, Dawn Drain, Carol Chen, Roger Grosse, Sam McCandlish, Jared Kaplan, Dario Amodei, Martin Wattenberg, and Christopher Olah. Toy models of superposition. Transformer Circuits Thread, 2022. https://transformer-circuits.pub/2022/toy_model/index.html.
- [39] Junjie Fang, Likai Tang, Hongzhe Bi, Yujia Qin, Si Sun, Zhenyu Li, Haolun Li, Yongjian Li, Xin Cong, Yukun Yan, Xiaodong Shi, Sen Song, Yankai Lin, Zhiyuan Liu, and Maosong Sun. UniMem: Towards a unified view of long-context large language models, 2024.
- [40] William Fedus, Barret Zoph, and Noam Shazeer. Switch transformers: Scaling to trillion parameter models with simple and efficient sparsity. J. Mach. Learn. Res., 23:120:1–120:39, 2022.
- [41] Elias Frantar and Dan Alistarh. Qmoe: Practical sub-1-bit compression of trillion-parameter models. CoRR, abs/2310.16795, 2023.
- [42] John DE Gabrieli, Neal J Cohen, and Suzanne Corkin. The impaired learning of semantic knowledge following bilateral medial temporal-lobe resection. Brain and cognition, 7(2):157–177, 1988.
- [43] Leo Gao, Stella Biderman, Sid Black, Laurence Golding, Travis Hoppe, Charles Foster, Jason Phang, Horace He, Anish Thite, Noa Nabeshima, Shawn Presser, and Connor Leahy. The pile: An 800gb dataset of diverse text for language modeling. CoRR, abs/2101.00027, 2021.
- [44] Leo Gao, Jonathan Tow, Baber Abbasi, Stella Biderman, Sid Black, Anthony DiPofi, Charles Foster, Laurence Golding, Jeffrey Hsu, Alain Le Noac’h, Haonan Li, Kyle McDonell, Niklas Muennighoff, Chris Ociepa, Jason Phang, Laria Reynolds, Hailey Schoelkopf, Aviya Skowron, Lintang Sutawika, Eric Tang, Anish Thite, Ben Wang, Kevin Wang, and Andy Zou. A framework for few-shot language model evaluation, 12 2023.
- [45] Mor Geva, Jasmijn Bastings, Katja Filippova, and Amir Globerson. Dissecting recall of factual associations in auto-regressive language models. arXiv preprint arXiv:2304.14767, 2023.
- [46] Mor Geva, Roei Schuster, Jonathan Berant, and Omer Levy. Transformer feed-forward layers are key-value memories, 2021.
- [47] Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the thirteenth international conference on artificial intelligence and statistics, pages 249–256. JMLR Workshop and Conference Proceedings, 2010.
- [48] Suriya Gunasekar, Yi Zhang, Jyoti Aneja, Caio César Teodoro Mendes, Allie Del Giorno, Sivakanth Gopi, Mojan Javaheripi, Piero Kauffmann, Gustavo de Rosa, Olli Saarikivi, Adil Salim, Shital Shah, Harkirat Singh Behl, Xin Wang, Sébastien Bubeck, Ronen Eldan, Adam Tauman Kalai, Yin Tat Lee, and Yuanzhi Li. Textbooks are all you need, 2023.
- [49] Kelvin Guu, Kenton Lee, Zora Tung, Panupong Pasupat, and Mingwei Chang. Retrieval augmented language model pre-training. In International conference on machine learning, pages 3929–3938. PMLR, 2020.
- [50] Yiding Hao, Dana Angluin, and Robert Frank. Formal language recognition by hard attention transformers: Perspectives from circuit complexity. Transactions of the Association for Computational Linguistics, 10:800–810, 2022.
- [51] Conghui He, Zhenjiang Jin, Chao Xu, Jiantao Qiu, Bin Wang, Wei Li, Hang Yan, Jiaqi Wang, and Dahua Lin. Wanjuan: A comprehensive multimodal dataset for advancing english and chinese large models. CoRR, abs/2308.10755, 2023.
- [52] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In Proceedings of the IEEE international conference on computer vision, pages 1026–1034, 2015.
- [53] Jordan Hoffmann, Sebastian Borgeaud, Arthur Mensch, Elena Buchatskaya, Trevor Cai, Eliza Rutherford, Diego de Las Casas, Lisa Anne Hendricks, Johannes Welbl, Aidan Clark, et al. Training compute-optimal large language models. arXiv preprint arXiv:2203.15556, 2022.
- [54] Shengding Hu, Yuge Tu, Xu Han, Chaoqun He, Ganqu Cui, Xiang Long, Zhi Zheng, Yewei Fang, Yuxiang Huang, Weilin Zhao, Xinrong Zhang, Zheng Leng Thai, Kaihuo Zhang, Chongyi Wang, Yuan Yao, Chenyang Zhao, Jie Zhou, Jie Cai, Zhongwu Zhai, Ning Ding, Chao Jia, Guoyang Zeng, Dahai Li, Zhiyuan Liu, and Maosong Sun. Minicpm: Unveiling the potential of small language models with scalable training strategies, 2024.
- [55] Yufei Huang, Shengding Hu, Xu Han, Zhiyuan Liu, and Maosong Sun. Unified view of grokking, double descent and emergent abilities: A perspective from circuits competition. arXiv preprint arXiv:2402.15175, 2024.
- [56] Albert Q. Jiang, Alexandre Sablayrolles, Arthur Mensch, Chris Bamford, Devendra Singh Chaplot, Diego de las Casas, Florian Bressand, Gianna Lengyel, Guillaume Lample, Lucile Saulnier, Lélio Renard Lavaud, Marie-Anne Lachaux, Pierre Stock, Teven Le Scao, Thibaut Lavril, Thomas Wang, Timothée Lacroix, and William El Sayed. Mistral 7b, 2023.
- [57] Xiaoqi Jiao, Yichun Yin, Lifeng Shang, Xin Jiang, Xiao Chen, Linlin Li, Fang Wang, and Qun Liu. Tinybert: Distilling bert for natural language understanding, 2020.
- [58] Jean Kaddour. The minipile challenge for data-efficient language models, 2023.
- [59] E.R. Kandel, J.D. Koester, S.H. Mack, and S.A. Siegelbaum. Principles of Neural Science, Sixth Edition. McGraw Hill LLC, 2021.
- [60] Jared Kaplan, Sam McCandlish, Tom Henighan, Tom B. Brown, Benjamin Chess, Rewon Child, Scott Gray, Alec Radford, Jeffrey Wu, and Dario Amodei. Scaling laws for neural language models, 2020.
- [61] Omar Khattab and Matei Zaharia. Colbert: Efficient and effective passage search via contextualized late interaction over bert, 2020.
- [62] Vijay Korthikanti, Jared Casper, Sangkug Lym, Lawrence McAfee, Michael Andersch, Mohammad Shoeybi, and Bryan Catanzaro. Reducing activation recomputation in large transformer models, 2022.
- [63] Woosuk Kwon, Zhuohan Li, Siyuan Zhuang, Ying Sheng, Lianmin Zheng, Cody Hao Yu, Joseph E. Gonzalez, Hao Zhang, and Ion Stoica. Efficient memory management for large language model serving with pagedattention, 2023.
- [64] Junyi Li, Xiaoxue Cheng, Xin Zhao, Jian-Yun Nie, and Ji-Rong Wen. Halueval: A large-scale hallucination evaluation benchmark for large language models. In The 2023 Conference on Empirical Methods in Natural Language Processing, 2023.
- [65] Miao Li, Ming-Bin Chen, Bo Tang, Shengbin Hou, Pengyu Wang, Haiying Deng, Zhiyu Li, Feiyu Xiong, Keming Mao, Peng Cheng, and Yi Luo. Newsbench: A systematic evaluation framework for assessing editorial capabilities of large language models in chinese journalism, 2024.
- [66] Yuanzhi Li, Sébastien Bubeck, Ronen Eldan, Allie Del Giorno, Suriya Gunasekar, and Yin Tat Lee. Textbooks are all you need ii: phi-1.5 technical report, 2023.
- [67] Wing Lian, Guan Wang, Bleys Goodson, Eugene Pentland, Austin Cook, Chanvichet Vong, and ”Teknium”. Slimorca: An open dataset of gpt-4 augmented flan reasoning traces, with verification, 2023.
- [68] Xun Liang, Shichao Song, Simin Niu, Zhiyu Li, Feiyu Xiong, Bo Tang, Yezhaohui Wang, Dawei He, Peng Cheng, Zhonghao Wang, and Haiying Deng. Uhgeval: Benchmarking the hallucination of chinese large language models via unconstrained generation, 2024.
- [69] Xun Liang, Shichao Song, Simin Niu, Zhiyu Li, Feiyu Xiong, Bo Tang, Zhaohui Wy, Dawei He, Peng Cheng, Zhonghao Wang, and Haiying Deng. UHGEval: Benchmarking the hallucination of chinese large language models via unconstrained generation. arXiv preprint arXiv:2311.15296, 2023.
- [70] Stephanie Lin, Jacob Hilton, and Owain Evans. TruthfulQA: Measuring how models mimic human falsehoods. In Smaranda Muresan, Preslav Nakov, and Aline Villavicencio, editors, Proceedings of the 60th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 3214–3252, Dublin, Ireland, May 2022. Association for Computational Linguistics.
- [71] Hong Liu, Zhiyuan Li, David Hall, Percy Liang, and Tengyu Ma. Sophia: A scalable stochastic second-order optimizer for language model pre-training, 2024.
- [72] Nelson F. Liu, Kevin Lin, John Hewitt, Ashwin Paranjape, Michele Bevilacqua, Fabio Petroni, and Percy Liang. Lost in the middle: How language models use long contexts, 2023.
- [73] Wei Liu, Weihao Zeng, Keqing He, Yong Jiang, and Junxian He. What makes good data for alignment? a comprehensive study of automatic data selection in instruction tuning, 2023.
- [74] Zichang Liu, Aditya Desai, Fangshuo Liao, Weitao Wang, Victor Xie, Zhaozhuo Xu, Anastasios Kyrillidis, and Anshumali Shrivastava. Scissorhands: Exploiting the persistence of importance hypothesis for llm kv cache compression at test time, 2023.
- [75] Zichang Liu, Jue Wang, Tri Dao, Tianyi Zhou, Binhang Yuan, Zhao Song, Anshumali Shrivastava, Ce Zhang, Yuandong Tian, Christopher Ré, and Beidi Chen. Deja vu: Contextual sparsity for efficient llms at inference time. In Andreas Krause, Emma Brunskill, Kyunghyun Cho, Barbara Engelhardt, Sivan Sabato, and Jonathan Scarlett, editors, International Conference on Machine Learning, ICML 2023, 23-29 July 2023, Honolulu, Hawaii, USA, volume 202 of Proceedings of Machine Learning Research, pages 22137–22176. PMLR, 2023.
- [76] Shayne Longpre, Gregory Yauney, Emily Reif, Katherine Lee, Adam Roberts, Barret Zoph, Denny Zhou, Jason Wei, Kevin Robinson, David Mimno, et al. A pretrainer’s guide to training data: Measuring the effects of data age, domain coverage, quality, & toxicity. arXiv preprint arXiv:2305.13169, 2023.
- [77] Alexandra Sasha Luccioni, Sylvain Viguier, and Anne-Laure Ligozat. Estimating the carbon footprint of bloom, a 176b parameter language model, 2022.
- [78] Tao Luo, Zhi-Qin John Xu, Zheng Ma, and Yaoyu Zhang. Phase diagram for two-layer relu neural networks at infinite-width limit. Journal of Machine Learning Research, 22(71):1–47, 2021.
- [79] Ang Lv, Yuhan Chen, Kaiyi Zhang, Yulong Wang, Lifeng Liu, Ji-Rong Wen, Jian Xie, and Rui Yan. Interpreting key mechanisms of factual recall in transformer-based language models, 2024.
- [80] William Merrill and Ashish Sabharwal. A logic for expressing log-precision transformers, 2023.
- [81] MOP-LIWU Community and MNBVC Team. Mnbvc: Massive never-ending bt vast chinese corpus. https://github.com/esbatmop/MNBVC, 2023.
- [82] MyScale. MyScaleDB. https://github.com/myscale/MyScaleDB. [Accessed 20-03-2024].
- [83] Reiichiro Nakano, Jacob Hilton, Suchir Balaji, Jeff Wu, Long Ouyang, Christina Kim, Christopher Hesse, Shantanu Jain, Vineet Kosaraju, William Saunders, et al. Webgpt: Browser-assisted question-answering with human feedback. arXiv preprint arXiv:2112.09332, 2021.
- [84] Deepak Narayanan, Mohammad Shoeybi, Jared Casper, Patrick LeGresley, Mostofa Patwary, Vijay Anand Korthikanti, Dmitri Vainbrand, Prethvi Kashinkunti, Julie Bernauer, Bryan Catanzaro, Amar Phanishayee, and Matei Zaharia. Efficient large-scale language model training on gpu clusters using megatron-lm, 2021.
- [85] Catherine Olsson, Nelson Elhage, Neel Nanda, Nicholas Joseph, Nova DasSarma, Tom Henighan, Ben Mann, Amanda Askell, Yuntao Bai, Anna Chen, Tom Conerly, Dawn Drain, Deep Ganguli, Zac Hatfield-Dodds, Danny Hernandez, Scott Johnston, Andy Jones, Jackson Kernion, Liane Lovitt, Kamal Ndousse, Dario Amodei, Tom Brown, Jack Clark, Jared Kaplan, Sam McCandlish, and Chris Olah. In-context learning and induction heads, 2022.
- [86] OpenAI. GPT-4 turbo and GPT-4. https://platform.openai.com/docs/models/gpt-4-turbo-and-gpt-4, 2024. [Accessed 22-05-2024].
- [87] Long Ouyang, Jeffrey Wu, Xu Jiang, Diogo Almeida, Carroll Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, et al. Training language models to follow instructions with human feedback. Advances in neural information processing systems, 35:27730–27744, 2022.
- [88] Adam Pearce, Asma Ghandeharioun, Nada Hussein, Nithum Thain, Martin Wattenberg, and Lucas Dixon. Do machine learning models memorize or generalize? People+ AI Research, 2023.
- [89] Bo Peng, Eric Alcaide, Quentin Anthony, Alon Albalak, Samuel Arcadinho, Stella Biderman, Huanqi Cao, Xin Cheng, Michael Chung, Matteo Grella, et al. Rwkv: Reinventing rnns for the transformer era, 2023.
- [90] Alethea Power, Yuri Burda, Harri Edwards, Igor Babuschkin, and Vedant Misra. Grokking: Generalization beyond overfitting on small algorithmic datasets, 2022.
- [91] Penghui Qi, Xinyi Wan, Guangxing Huang, and Min Lin. Zero bubble pipeline parallelism, 2023.
- [92] Jack W Rae, Sebastian Borgeaud, Trevor Cai, Katie Millican, Jordan Hoffmann, Francis Song, John Aslanides, Sarah Henderson, Roman Ring, Susannah Young, et al. Scaling language models: Methods, analysis & insights from training gopher. arXiv preprint arXiv:2112.11446, 2021.
- [93] Rafael Rafailov, Archit Sharma, Eric Mitchell, Christopher D Manning, Stefano Ermon, and Chelsea Finn. Direct preference optimization: Your language model is secretly a reward model. Advances in Neural Information Processing Systems, 36, 2024.
- [94] David Raposo, Sam Ritter, Blake Richards, Timothy Lillicrap, Peter Conway Humphreys, and Adam Santoro. Mixture-of-depths: Dynamically allocating compute in transformer-based language models, 2024.
- [95] Jeff Rasley, Samyam Rajbhandari, Olatunji Ruwase, and Yuxiong He. Deepspeed: System optimizations enable training deep learning models with over 100 billion parameters. In Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 3505–3506, 2020.
- [96] Nir Ratner, Yoav Levine, Yonatan Belinkov, Ori Ram, Inbal Magar, Omri Abend, Ehud Karpas, Amnon Shashua, Kevin Leyton-Brown, and Yoav Shoham. Parallel context windows for large language models. arXiv preprint arXiv:2212.10947, 2022.
- [97] Vipula Rawte, Swagata Chakraborty, Agnibh Pathak, Anubhav Sarkar, S.M Towhidul Islam Tonmoy, Aman Chadha, Amit Sheth, and Amitava Das. The troubling emergence of hallucination in large language models - an extensive definition, quantification, and prescriptive remediations. In Houda Bouamor, Juan Pino, and Kalika Bali, editors, Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, pages 2541–2573, Singapore, December 2023. Association for Computational Linguistics.
- [98] Snowflake AI Research. Snowflake arctic: The best LLM for enterprise AI — efficiently intelligent, truly open, Apr 2024. Accessed: 2024-05-15.
- [99] Yangjun Ruan, Chris J. Maddison, and Tatsunori Hashimoto. Observational scaling laws and the predictability of language model performance, 2024.
- [100] Timo Schick, Jane Dwivedi-Yu, Roberto Dessì, Roberta Raileanu, Maria Lomeli, Eric Hambro, Luke Zettlemoyer, Nicola Cancedda, and Thomas Scialom. Toolformer: Language models can teach themselves to use tools. Advances in Neural Information Processing Systems, 36, 2024.
- [101] Scienceasdf. Medical books. https://github.com/scienceasdf/medical-books. [Accessed 20-03-2024].
- [102] Azure AI Services. GPT-4 and GPT-4 turbo models. https://learn.microsoft.com/en-us/azure/ai-services/openai/concepts/models#gpt-4-and-gpt-4-turbo-models, 2024. [Accessed 22-05-2024].
- [103] Mohammad Shoeybi, Mostofa Patwary, Raul Puri, Patrick LeGresley, Jared Casper, and Bryan Catanzaro. Megatron-lm: Training multi-billion parameter language models using model parallelism, 2020.
- [104] Daria Soboleva, Faisal Al-Khateeb, Robert Myers, Jacob R Steeves, Joel Hestness, and Nolan Dey. SlimPajama: A 627B token cleaned and deduplicated version of RedPajama. https://www.cerebras.net/blog/slimpajama-a-627b-token-cleaned-and-deduplicated-version-of-redpajama, June 2023.
- [105] Aarohi Srivastava, Abhinav Rastogi, Abhishek Rao, Abu Awal Md Shoeb, Abubakar Abid, Adam Fisch, Adam R. Brown, Adam Santoro, Aditya Gupta, Adrià Garriga-Alonso, Agnieszka Kluska, Aitor Lewkowycz, Akshat Agarwal, Alethea Power, Alex Ray, Alex Warstadt, Alexander W. Kocurek, Ali Safaya, Ali Tazarv, Alice Xiang, and et al. Beyond the imitation game: Quantifying and extrapolating the capabilities of language models, 2023.
- [106] Alessandro Stolfo, Yonatan Belinkov, and Mrinmaya Sachan. A mechanistic interpretation of arithmetic reasoning in language models using causal mediation analysis. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, pages 7035–7052, 2023.
- [107] Jianlin Su, Murtadha Ahmed, Yu Lu, Shengfeng Pan, Wen Bo, and Yunfeng Liu. Roformer: Enhanced transformer with rotary position embedding. Neurocomputing, 568:127063, 2024.
- [108] Sainbayar Sukhbaatar, Edouard Grave, Guillaume Lample, Herve Jegou, and Armand Joulin. Augmenting self-attention with persistent memory, 2019.
- [109] Yutao Sun, Li Dong, Yi Zhu, Shaohan Huang, Wenhui Wang, Shuming Ma, Quanlu Zhang, Jianyong Wang, and Furu Wei. You only cache once: Decoder-decoder architectures for language models. arXiv preprint arXiv:2405.05254, 2024.
- [110] Hugo Touvron, Louis Martin, Kevin Stone, Peter Albert, Amjad Almahairi, Yasmine Babaei, Nikolay Bashlykov, Soumya Batra, Prajjwal Bhargava, Shruti Bhosale, et al. Llama 2: Open foundation and fine-tuned chat models. arXiv preprint arXiv:2307.09288, 2023.
- [111] Lewis Tunstall, Edward Beeching, Nathan Lambert, Nazneen Rajani, Kashif Rasul, Younes Belkada, Shengyi Huang, Leandro von Werra, Clémentine Fourrier, Nathan Habib, Nathan Sarrazin, Omar Sanseviero, Alexander M. Rush, and Thomas Wolf. Zephyr: Direct distillation of lm alignment, 2023.
- [112] Szymon Tworkowski, Konrad Staniszewski, Mikołaj Pacek, Yuhuai Wu, Henryk Michalewski, and Piotr Miłoś. Focused transformer: Contrastive training for context scaling. Advances in Neural Information Processing Systems, 36, 2024.
- [113] Boxin Wang, Wei Ping, Peng Xu, Lawrence McAfee, Zihan Liu, Mohammad Shoeybi, Yi Dong, Oleksii Kuchaiev, Bo Li, Chaowei Xiao, Anima Anandkumar, and Bryan Catanzaro. Shall we pretrain autoregressive language models with retrieval? A comprehensive study. In Houda Bouamor, Juan Pino, and Kalika Bali, editors, Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, pages 7763–7786, Singapore, December 2023. Association for Computational Linguistics.
- [114] Guan Wang, Sijie Cheng, Xianyuan Zhan, Xiangang Li, Sen Song, and Yang Liu. Openchat: Advancing open-source language models with mixed-quality data, 2023.
- [115] Kevin Wang, Alexandre Variengien, Arthur Conmy, Buck Shlegeris, and Jacob Steinhardt. Interpretability in the wild: a circuit for indirect object identification in gpt-2 small. arXiv preprint arXiv:2211.00593, 2022.
- [116] Lean Wang, Lei Li, Damai Dai, Deli Chen, Hao Zhou, Fandong Meng, Jie Zhou, and Xu Sun. Label words are anchors: An information flow perspective for understanding in-context learning. arXiv preprint arXiv:2305.14160, 2023.
- [117] Mingze Wang, Haotian He, Jinbo Wang, Zilin Wang, Guanhua Huang, Feiyu Xiong, Zhiyu Li, Weinan E, and Lei Wu. Improving generalization and convergence by enhancing implicit regularization, 2024.
- [118] Weizhi Wang, Li Dong, Hao Cheng, Xiaodong Liu, Xifeng Yan, Jianfeng Gao, and Furu Wei. Augmenting language models with long-term memory. Advances in Neural Information Processing Systems, 36, 2024.
- [119] Jason Wei, Yi Tay, Rishi Bommasani, Colin Raffel, Barret Zoph, Sebastian Borgeaud, Dani Yogatama, Maarten Bosma, Denny Zhou, Donald Metzler, Ed H. Chi, Tatsunori Hashimoto, Oriol Vinyals, Percy Liang, Jeff Dean, and William Fedus. Emergent abilities of large language models, 2022.
- [120] Gail Weiss, Yoav Goldberg, and Eran Yahav. Thinking like transformers, 2021.
- [121] Carole-Jean Wu, Ramya Raghavendra, Udit Gupta, Bilge Acun, Newsha Ardalani, Kiwan Maeng, Gloria Chang, Fiona Aga Behram, James Huang, Charles Bai, Michael Gschwind, Anurag Gupta, Myle Ott, Anastasia Melnikov, Salvatore Candido, David Brooks, Geeta Chauhan, Benjamin Lee, Hsien-Hsin S. Lee, Bugra Akyildiz, Maximilian Balandat, Joe Spisak, Ravi Jain, Mike Rabbat, and Kim Hazelwood. Sustainable ai: Environmental implications, challenges and opportunities, 2022.
- [122] Wenhao Wu, Yizhong Wang, Guangxuan Xiao, Hao Peng, and Yao Fu. Retrieval head mechanistically explains long-context factuality, 2024.
- [123] Yuhuai Wu, Markus Norman Rabe, DeLesley Hutchins, and Christian Szegedy. Memorizing transformers. In International Conference on Learning Representations, 2021.
- [124] Xingyu Xie, Pan Zhou, Huan Li, Zhouchen Lin, and Shuicheng Yan. Adan: Adaptive nesterov momentum algorithm for faster optimizing deep models, 2023.
- [125] Can Xu, Qingfeng Sun, Kai Zheng, Xiubo Geng, Pu Zhao, Jiazhan Feng, Chongyang Tao, and Daxin Jiang. Wizardlm: Empowering large language models to follow complex instructions. arXiv preprint arXiv:2304.12244, 2023.
- [126] Aiyuan Yang, Bin Xiao, Bingning Wang, Borong Zhang, Ce Bian, Chao Yin, Chenxu Lv, Da Pan, Dian Wang, Dong Yan, Fan Yang, Fei Deng, Feng Wang, Feng Liu, Guangwei Ai, Guosheng Dong, Haizhou Zhao, et al. Baichuan 2: Open large-scale language models, 2023.
- [127] Greg Yang, Edward J Hu, Igor Babuschkin, Szymon Sidor, Xiaodong Liu, David Farhi, Nick Ryder, Jakub Pachocki, Weizhu Chen, and Jianfeng Gao. Tensor programs v: Tuning large neural networks via zero-shot hyperparameter transfer. arXiv preprint arXiv:2203.03466, 2022.
- [128] Hongkang Yang. A mathematical framework for learning probability distributions. Journal of Machine Learning, 1(4):373–431, 2022.
- [129] Yunzhi Yao, Ningyu Zhang, Zekun Xi, Mengru Wang, Ziwen Xu, Shumin Deng, and Huajun Chen. Knowledge circuits in pretrained transformers, 2024.
- [130] Longhui Yu, Weisen Jiang, Han Shi, Jincheng Yu, Zhengying Liu, Yu Zhang, James T Kwok, Zhenguo Li, Adrian Weller, and Weiyang Liu. Metamath: Bootstrap your own mathematical questions for large language models. arXiv preprint arXiv:2309.12284, 2023.
- [131] Zhenyu Zhang, Ying Sheng, Tianyi Zhou, Tianlong Chen, Lianmin Zheng, Ruisi Cai, Zhao Song, Yuandong Tian, Christopher Ré, Clark Barrett, et al. H2o: Heavy-hitter oracle for efficient generative inference of large language models. Advances in Neural Information Processing Systems, 36, 2024.
- [132] Zhongwang Zhang, Pengxiao Lin, Zhiwei Wang, Yaoyu Zhang, and Zhi-Qin John Xu. Initialization is critical to whether transformers fit composite functions by inference or memorizing, 2024.
- [133] Lianmin Zheng, Wei-Lin Chiang, Ying Sheng, Siyuan Zhuang, Zhanghao Wu, Yonghao Zhuang, Zi Lin, Zhuohan Li, Dacheng Li, Eric Xing, et al. Judging llm-as-a-judge with mt-bench and chatbot arena. Advances in Neural Information Processing Systems, 36, 2024.
- [134] Haoxi Zhong, Chaojun Xiao, Cunchao Tu, Tianyang Zhang, Zhiyuan Liu, and Maosong Sun. Jec-qa: A legal-domain question answering dataset. Proceedings of the AAAI Conference on Artificial Intelligence, 34(05):9701–9708, Apr. 2020.
Appendix A Cost Estimation
This section provides the calculations for Figure 4, and we equate cost with the amount of compute measured in Tflops.
Our 2.4B Memory 3 model is adopted as the backbone. Recall from Section 3.4 that this model has shape
- Transformer blocks $L=44$
- Query heads $H=40$ and key-value heads $H_{kv}=8$
- Head dimension $d_{h}=80$ and hidden dimension $d=Hd_{h}=3200$
- MLP width $W=d$
- Vocabulary size as well as LM head size $n_{\text{vocab}}=60416$
- memory layers $L_{\text{mem}}=22$ , which is also the depth of the deepest memory layer.
Fix a separable knowledge $\mathcal{K}$ , and represent it by one of its realizations $\mathbf{t}$ (Definition 5), and assume that $\mathbf{t}$ has length $l_{\text{ref}}=128$ tokens, following the setup of our reference dataset (Section 4.4). Recall from Section 3.3 that each memory has $l_{\text{mem}}=8$ tokens per memory head, and it is read by a chunk of length $l_{\text{chunk}}=64$ .
Since we want to show that explicit memory is cheaper than implicit memory and RAG, it suffices to use coarse lower bounds on their costs.
A.1 | Implicit Memory
The write cost of implicit memory or model parameters is the training compute with $\mathbf{t}$ as input. Usually the training data of Transformer LLMs have length $2048\sim 8192$ , so we assume that $\mathbf{t}$ is a subsequence of a train sample $\mathbf{t}_{\text{train}}$ with length $l_{\text{train}}=2048$ . By [84], the training compute of one step with one sample is approximately
$$
3\cdot 2\cdot\big{[}L\big{(}l_{\text{train}}(2d^{2}+2dd_{h}H_{kv}+3dW)+2\frac{%
l_{\text{train}}^{2}}{2}d\big{)}+l_{\text{train}}n_{\text{vocab}}d\big{]}
$$
where $3$ means that the backward step costs twice as the forward step (and thus 3 times in total), the first $2$ means that the compute of matrix multiplication involves same amount of additions and multiplications. The five terms in the bracket come from QO embedding, KV embedding, MLP, attention, and LM head, respectively. The lower order terms, such as layer normalizations, are omitted. The fraction of the compute attributable to $\mathbf{t}$ is given by
$$
3\cdot 2\cdot\big{[}L\big{(}l_{\text{ref}}(2d^{2}+2dd_{h}H_{kv}+3dW)+2l_{\text%
{ref}}\frac{l_{\text{train}}}{2}d\big{)}+l_{\text{ref}}n_{\text{vocab}}d\big{]}
$$
Assume that one training step is sufficient for storing knowledge $\mathcal{K}$ into model parameters. Then, the write cost is equal to the above term, and we obtain
$$
\text{cost}_{\text{write}}\approx 2.24~{}\text{TFlops}
$$
Meanwhile, we lower bound the read cost by zero.
$$
\text{cost}_{\text{read}}\geq 0~{}\text{TFlops}
$$
This lower bound is obviously correct and suits our comparison, since it makes implicit memory appear more competitive. The difficulty in estimating the cost is that the correspondence between knowledges and parameters is not fully understood. Nevertheless, we describe a possible way to obtain a reasonable bound. Recall from Section 1 that the model parameters suffer from the issue of knowledge traversal such that each parameter (and thus each implicit memory) is invoked during each call of the LLM. So the read cost of each implicit memory does not depend on its usage count $n_{k}$ , but instead on the total amount of model calls during the lifespan of this LLM. Dividing the total amount of inference compute used by this LLM by the amount of knowledges it possesses gives an estimation of the average read cost of a knowledge. The amount of knowledges in the LLM can be upper bounded based on the knowledge capacities measured by [7].
A.2 | Explicit Memory
The write cost of an each explicit memory mainly comes from $L_{\text{mem}}$ self-attention layers, $L_{\text{mem}}-1$ MLP layers, and $L_{\text{mem}}$ token sparsification operations (computing the full attention matrix):
| | $\displaystyle\text{cost}_{\text{write}}$ | $\displaystyle=2·\big{[}L_{\text{mem}}\big{(}l_{\text{ref}}(2d^{2}+2dd_{h}H%
_{kv})+2\frac{l_{\text{ref}}^{2}}{2}d\big{)}+(L_{\text{mem}}-1)(l_{\text{ref}}%
· 3dW)+L_{\text{mem}}(l_{\text{ref}}^{2}d)\big{]}$ | |
| --- | --- | --- | --- |
The read cost consists of the attention to the sparse tokens of an explicit memory from the chunk that retrieves this memory:
$$
\text{cost}_{\text{read}}=2L_{\text{mem}}\cdot 2l_{\text{chunk}}l_{\text{mem}}%
d\approx 1.44\times 10^{-4}~{}\text{TFlops}
$$
A.3 | External Information
The write cost of text retrieval-augmented generation (RAG) is set to be zero, since the reference is stored as plain text.
$$
\text{cost}_{\text{write}}=0~{}\text{TFlops}
$$
The read cost is the additional compute brought by the retrieved references that are inserted in the prompt. To make RAG appear more competitive, we assume that only a chunk of the prompt or decoded text with length $l_{\text{chunk}}$ can attend to the references, and each reference can only attend to itself, which in general is not true. Then,
| | $\displaystyle\text{cost}_{\text{write}}$ | $\displaystyle≥ 2·\big{[}L\big{(}l_{\text{ref}}(2d^{2}+2dd_{h}H_{kv})+2l%
_{\text{ref}}\big{(}\frac{l_{\text{ref}}}{2}+l_{\text{chunk}}\big{)}d\big{)}+(%
L-1)(l_{\text{ref}}· 3dW)\big{]}$ | |
| --- | --- | --- | --- |
In summary, the total cost (TFlops) of writing and reading each separable knowledge in terms of its expected usage count $n$ is given by
$$
\begin{cases}c_{\text{implicit}}(n)\geq 2.24\\
c_{\text{explicit}}(n)=0.308+0.000144n\\
c_{\text{external}}(n)\geq 0.624n\end{cases}
$$
These curves are plotted in Figure 4. Hence, if $n∈(0.494,13400)$ , then it is optimal to store the knowledge as an explicit memory.
**Remark 9 (Knowledge retention)**
*One aspect not covered by Problem (1) is the retention of knowledges in the model if its parameters are updated, e.g. due to finetuning. Both implicit memory and explicit memory are vulnerable to parameter change. Usually, model finetuning would include some amount of pretrain data to prevent catastrophic forgetting [87]. Similarly, if some explicit memories have already been produced, then they need to be rebuilt in order to remain readable by the updated model. It is an interesting research direction to design a more efficient architecture such that the implicit and explicit memories are robust with respect to model updates.*
Appendix B Vector Compression
Regarding the vector quantizer discussed in Sections 3.3 and 7.1, we use the composite index of FAISS with index type OPQ20x80-Residual2x14-PQ8x10. It can encode a 80-dimensional bfloat16 vector into a 14-dimensional uint8 vector, and thus its compression rate is $\frac{80× 2}{14× 1}≈ 11.4$ .
To train this quantizer, we sample references from our knowledge base, encode them into explicit memories by our Memory 3 -2B-SFT model, and feed these key-value vectors to the quantizer. The references are sampled uniformly and independently, so the training is not biased towards the references that are retrieved by any specific evaluation task.
Appendix C Supplementary Evaluation Results
First, Table 22 records the growth of the test scores (Table 16) over the three training stages: warmup, continual train, and SFT. We believe that for future versions of Memory 3, fixing the loss divergence during the warmup stage can allow the continual train stage to proceed much further (cf. Section 5.3), and thus increase the performance boost of this stage.
| | | English | Chinese | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| LLM | Avg. | ARC-C | HellaSwag | MMLU | Winogrande | GSM8k | CEVAL | CMMLU |
| Warmup | 42.13 | 40.27 | 64.57 | 41.62 | 61.96 | 5.23 | 40.12 | 41.17 |
| Continual train | 45.12 | 42.66 | 79.21 | 41.81 | 59.43 | 6.29 | 42.20 | 44.21 |
| - without memory | 42.89 | 42.15 | 66.98 | 39.79 | 61.80 | 6.44 | 39.97 | 43.13 |
| SFT | 63.31 | 58.11 | 80.51 | 59.68 | 74.51 | 52.84 | 59.29 | 58.24 |
| - without memory | 60.80 | 57.42 | 73.14 | 57.29 | 74.35 | 51.33 | 56.32 | 55.72 |
Table 22: Performance of Memory 3 -2B at different stages of training. The setup of the evaluation tasks is the same as in Table 16.
Next, recall that for the evaluations in Section 7.1, a filter is included in the retrieval process to prevent copying, which removes references that overlap too much with the evaluation question. The filtering threshold should lie between $100\%$ and the usual level of overlap between two related but distinct texts, and we set it to $2/3$ in Table 16. Table 23 records the impact of the filtering threshold on the test scores. The scores are stable for most tasks, indicating that their questions do not appear in our knowledge basis.
| Threshold | Avg. | ARC-C | HellaSwag | MMLU | Winogrande | GSM8k | CEVAL | CMMLU |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| no filter | 63.71 | 58.11 | 83.37 | 59.65 | 74.51 | 52.84 | 59.29 | 58.22 |
| 80% | 63.62 | 58.11 | 82.69 | 59.65 | 74.51 | 52.84 | 59.29 | 58.24 |
| 2/3 | 63.31 | 58.11 | 80.51 | 59.68 | 74.51 | 52.84 | 59.29 | 58.24 |
| without memory | 60.80 | 57.42 | 73.14 | 57.29 | 74.35 | 51.33 | 56.32 | 55.72 |
Table 23: Influence of the filtering threshold on the test scores in Table 16.
Finally, Table 24 studies the influence of the few-shot prompts on the benchmark tasks. Recall that the number of few-shot examples for each task is ARC-C (25), HellaSwag (10), MMLU (5), Winogrande (5), GSM8k (5) as in HuggingFace OpenLLM Leaderboard [13], and we also adopt CEVAL (5), CMMLU (5). Interestingly, the boost from explicit memory increases from $2.51\%$ to $3.70\%$ as we switch to 0-shot.
| Mode | Avg. | ARC-C | HellaSwag | MMLU | Winogrande | GSM8k | CEVAL | CMMLU |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Few-shot | 63.31 | 58.11 | 80.51 | 59.68 | 74.51 | 52.84 | 59.29 | 58.24 |
| - without memory | 60.80 | 57.42 | 73.14 | 57.29 | 74.35 | 51.33 | 56.32 | 55.72 |
| 0-shot | 58.23 | 58.79 | 83.29 | 60.53 | 75.85 | 13.50 | 57.95 | 57.74 |
| - without memory | 54.54 | 57.34 | 73.15 | 58.59 | 74.98 | 10.46 | 54.53 | 54.26 |
Table 24: Few-shot versus 0-shot for the benchmark tasks in Table 16.