{'fraction_non_alphanumeric': 0.036834825653344984, 'fraction_numerical': 0.01497173084855985, 'mean_word_length': 4.631593331511342, 'pattern_counts': {'":': 3, '<': 3, '<?xml version=': 0, '>': 1, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 11, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Keep Me Updated! Memory Management in Long-term Conversations

Remembering important information from the past and continuing to talk about it in the present are crucial in long-term conversations. However, previous literature does not deal with cases where the memorized information is outdated, which may cause confusion in later conversations. To address this issue, we present a novel task and a corresponding dataset of memory management in long-term conversations, in which bots keep track of and bring up the latest information about users while conversing through multiple sessions. In order to support more precise and interpretable memory, we represent memory as unstructured text descriptions of key information and propose a new mechanism of memory management that selectively eliminates invalidated or redundant information. Experimental results show that our approach outperforms the baselines that leave the stored memory unchanged in terms of engagingness and humanness, with larger performance gap especially in the later sessions.


Introduction
In human interactions, memory is an important mechanism that helps us hold conversations, develop rapport, and maintain long-term relationships (Alea and Bluck, 2003;Nelson, 2003;Brewer et al., 2017). To this end, recent studies (Wu et al., 2020;Xu et al., 2022a,b) on open-domain dialogues have proposed methods to remember and utilize persona information (Zhang et al., 2018) of the interlocutors obtained from previous conversations. Specifically, they summarize the persona information in an extractive or abstractive way and give it as a condition for generating responses in subsequent conversations. They show that this feature leads to better consistency and engagingness of the chatbot systems.
Despite such progress, an aspect overlooked by previous studies is that memorized information can Figure 1: An example of a long-term dialogue. There is information obtained from an early session that is no longer true in a later session, e.g. "Got a sore throat". This information should be removed from the memory of later sessions in order to correctly follow up with the interlocuter.
be invalidated by newly gathered information. They simply accumulate and maintain the stored information in memory; once stored, such information has no possibility of getting updated in the future. Memory in real-life conversations, however, can change over time, either in a short period of time (e.g. health status, plans for the weekend, or recently watched movie) or in relatively longer period of time (e.g. age, job, or hobby). Such memory needs to be kept track by asking its status again in subsequent conversations, as exemplified in Figure  1. Therefore, updating previous memory with new relevant information and maintaining it up-to-date are important features of human-like long-term conversations.
In this work, we study the methods of memorizing and updating dynamic information and utilizing them in successive dialogues. We formulate a new task of memory management in long-term conversations and construct its corresponding dataset 1 , by extending an existing Korean open-domain dialogue dataset (Bae et al., 2022) to multiple sessions with changing user information. In each session of our dataset, while the user and the bot have a conversation, information about the user is identified from the dialogue. Then, in successive sessions, the bot keeps in memory only the information valid at that point and utilizes the resulting memory in dialogue.
In addition, we propose a long-term dialogue system including a novel memory management mechanism. In this system, information about the interlocutors revealed in the previous conversation is abstractively summarized and stored in memory. Specifically, the memory management mechanism decides which information to keep in memory. For this purpose, we define four pairwise operations (PASS, REPLACE, APPEND, and DELETE) to find and eliminate the information that can cause confusion or redundancy in later conversations. For example, if the previous memory sentence is "Haven't got COVID tested yet" and the new incoming summary is "Just got positive results from COVID test", the two sentences are contradictory, in which the former needs to be replaced in memory by the latter. Through this process, only valid information remains in new memory. Then, in subsequent sessions, a relevant information from this memory is retrieved and given as additional condition for generating chatbot responses.
With extensive experiments and ablations, we show that the proposed memory management mechanism becomes more advantageous in terms of memorability as the sessions proceed, leading to better engagingness and humanness in multisession dialogues.
Our contributions are as follows: 1. We make a step towards long-term conversations with dynamic memory that must be kept up-to-date.
2. We propose a novel memory management mechanism in the form of unstructured text that achieves better results in automatic and human evaluation over baselines.

Related Work
Personalized Dialogue System Building human-like open-domain chatbots is one of the seminal research topics in the field of natural language processing. Zhang et al. (2020) has provided a strong backbone generator model for dialogue systems, while Adiwardana et al. (2020),  and Thoppilan et al. (2022) have paved the way for the development of more human-like, natural-sounding chatbots.
The applications of open-domain chatbots have also widely expanded, including role-specified (Bae et al., 2022) and personalized (Zhang et al., 2018) dialogue systems. In particular, personalized dialogue system has typically been studied either via utilizing predefined, explicitly stated user profile (Zhang et al., 2018), or via directly extracting user profile from dialogue history (Xu et al., 2022a,b). While the latter approach is preferred in recent research works (Zhong et al., 2022), long-term management of the obtained information is yet to be studied.

Long-term Memory in Conversation
Because it is inefficient to use the entire dialogue history as long-term memory, techniques for obtaining and managing information from dialogue history have been studied. Representing latent features as neural memory (Weston et al., 2015;Tran et al., 2016;Munkhdalai et al., 2019) used to be a traditional method. Slot-value format in dialogue state tracking (Heck et al., 2020;Hosseini-Asl et al., 2020;Kim et al., 2020), and graph format in Hsiao et al. (2020) have been the two major approaches in handling the memorized information in a structured way. Kim et al. (2020) suggested update operations on fixed-sized slot-value pairs for dialogue states. Wu et al. (2020) extracted user attributes from dialogues in triples. However, such approaches have not been demonstrated in a multi-session setting.
Leveraging the advancement of pre-trained language models (Devlin et al., 2019;Raffel et al., 2020;Brown et al., 2020;Kim et al., 2021), recent studies attempt to use the unstructured form of text as memory, which is expected to be advantageous in terms of generalizability and interpretability. Ma et al. (2021) and Xu et al. (2022b) selectively stored dialogue history with relevant information, while Zhong et al. (2022) employed refiners to extract fine-grained information from dialogue history. Xu et al. (2022a) summarized the dialogue history to avoid overflow and redundancy. Nevertheless, these works rarely consider that the obtained information may change and become outdated. Specifically, MSC (Xu et al., 2022a) does not reflect the change of information. In other words, information in MSC remains fixed once it is stored. DuLeMon (Xu et al., 2022b) is not formatted in a multi-session manner, making it impossible to track memory changes across multiple sessions.

Task and Dataset
This section describes the task of long-term conversations with dynamic memory changes and the process of constructing a new dataset to conduct research on this task.

Task Definition
An episode consists of multiple consecutive dialogue sessions with a specific user. Dialogue context of the current session is D t = {c 1 , u 1 , c 2 , u 2 , · · · , c t , u t } at time step t, where c and u represent the chatbot's and user's utterance, respectively. Natural language memory sentences M = {m 1 , m 2 , · · · , m n } contain user information abstracted from the previous sessions of the same episode. Then, given the dialogue context D t , and memory M , we are interested in predicting the chatbot's response c t+1 . At the end of each session, the entire session D is summarized into several sentences of user information, denoted as S = {s 1 , s 2 , · · · , s k }. Memory sentences M for the next session are constructed by combining M and S.

Dataset Construction
To study this task, we build a new dataset based on CareCall dataset 2 (Bae et al., 2022), which consists of single sessions of open-domain dialogues between bots and users. We choose this dataset because the sessions contain various topics that are likely to change in a short period of time, such as user's health, sleep, and diet, as well as those in a relatively longer period of time, such as family, pets, and frequently visited places. We extend this single-session dataset to a multi-session setting, which is a similar procedure presented in MSC (Xu et al., 2022a) more persona updates than other datasets (Xu et al., 2022a,b) (see Section C.1 in Appendix for more details).

Preliminary Step: Dialogue and Summary
To efficiently collect the dataset, we train preliminary models for dialogue summaries and memory grounded dialogues to first automatically generate the dataset, and then a group of annotators revise them. This procedure has shown to be more effective in recent studies (Sun et al., 2021;Bae et al., 2022;Liu et al., 2022;Zheng et al., 2022). In the entire process, we leverage the large-scale language models (LMs) for each step; HyperCLOVA 6.9B as backbone LM.
Dialogue Summary We randomly sample 600 dialogue sessions with more than 15 turns from the CareCall dataset. We ask annotators to summarize each session into several sentences to build S that may be useful to continue the next conversation. Using these summaries, we fine-tune LMs to generate summaries given dialogues P (S|D). The models then generate summaries of unseen dialogues randomly sampled from the CareCall dataset. Finally, annotators edit the generated summaries by filling in missing information or correcting erroneous sentences. Since there is no memory sentence for the first session, i.e. M = ∅, memory for the second session M is equal to S. Memory Grounded Dialogue To build a second session of each episode, annotators write dialogue sessions grounded on the 600 human-written summaries from the previous step. Likewise, we finetune LMs to generate the entire dialogue sessions given previous memory P (D|M ). Then, the finetuned models generate memory grounded dialogues from the unseen dialogue summaries in the previous paragraph. Lastly, human annotators revise the generated dialogues, i.e. correcting wrong responses (misuse of memory, not sensible, or outof-bounds from CareCall's role described in Bae et al. (2022)).

Interactive Step: Multi-Session Dialogue
From the preliminary step, we obtain the data to build a chatbot that can conduct interactive conversation utilizing the memorized information. To construct a multi-session dialogue system, we train the dialogue summarizer and memory grounded response generator described in Section 4 on previously collected (D, S) pairs with (M, D) pairs respectively. Then, crowdworkers converse with the resulting system for 5 sessions per episode, starting from the first session. The interval between sessions is assumed to be from 1 to 2 weeks. At the end of each session, the summarizer generates S from the current session. Both generated responses and summaries are edited by annotators to correct errors.
Lastly, we ask annotators to select which sentences in M and S should remain in new memory M for the next session. We provide details of quality control in Appendix A and an example episode in Figure 4 in Appendix. We name this dataset as CareCall mem and the statistics of the dataset are given in Table 1, which includes all the collected data described in Section 3.2.1-3.2.2.

Models
We propose a long-term dialogue system with memory management mechanism. The system consists of three parts: memory grounded response generation, dialogue summarization, and memory update. The overall architecture is shown in Figure 2.

Memory Grounded Response Generation
Response Generation We consider the response generation model conditioned on memory sentences. Given the memory M and the dialogue history D t = {c 1 , u 1 , c 2 , u 2 , · · · , c t , u t } at time step t, the conditional probability of the next target response c t+1 = {w 1 , w 2 , · · · , w |c t+1 | } can be written as the product of a sequence of conditional probabilities: where w i is i-th token of the sequence and θ is trainable parameters of the model. We use Hyper-CLOVA 6.9B as the response generation model.
The model is fine-tuned using the maximum likelihood estimation (MLE), which minimizes: (2) Memory Retrieval In addition, following the previous studies (Xu et al., 2022a,b), we consider that retrieving information relevant to the current dialogue context is effective when dealing with a large collection of sentences in memory. We use an approach almost identical to context persona matching (CPM) method proposed in Xu et al. (2022b), replacing persona sentences to memory sentences in our task (See Appendix B.3 for more details). At the inference time, the retrieved top k sentences constitute M ret , which is the actual input condition of the response generator described in the preceding paragraph.

Dialogue Summarization
Given the dialogue history of the entire session D, our abstractive summarization model summarizes important user information in the form of several natural language sentences S = {s 1 , s 2 , · · · , s k }. What information to be summarized can be learned based on the human annotation from our newly collected CareCall mem dataset. Here, we train Hy-perCLOVA 6.9B as the summarizer to generate summary sentences given the dialogue history as an input. Formally, this is done by minimizing loss for each gold summary sentence s t = {w 1 , w 2 , · · · , w |st| }: where φ is trainable parameters of the summarizer.

Memory Update
The memory update process stores the latest user information in memory by combining the old and the new information sentences. At the end of each session, n existing memory sentences M = {m 1 , m 2 , ..., m n } and k new summary sentences S = {s 1 , s 2 , ..., s k } are given. The memory writer combines them to find M = {m 1 , m 2 , ..., m |M | } that are lossless, consistent, and not redundant in terms of information. Here, we assume that M and S are internally consistent and not redundant.
Our approach finds the sentence set M by classifying the relationship of the sentence pair for ∀s j ∈ S: Algorithm 1: Our memory update algorithm. P, R, A, and D are abbreviations for PASS, REPLACE, AP-PEND, and DELETE, respectively.
• PASS means storing only m i . It reflects the case in which the information of m i already contains that of s j , i.e. m i ⊇ s j in terms of information. Only m i is stored in order to avoid redundancy.
• REPLACE means storing only s j . When s j and m i are inconsistent, the more recent information s j remains. This operation is also useful when s j has more information than m i , i.e. m i ⊂ s j in terms of information.
• APPEND means storing both m i and s j . If m i and s j are irrelevant, both are stored in order to avoid loss of information.
• DELETE means removing both m i and s j . We found that there are cases where this operation is useful. It can reduce the memory confusion by "forgetting" a completed state that no longer needs to be remembered. For example, if m i = "having a cold and taking medicine" and s j = "cold is all better now", not only m i should be removed because it  is no longer true, but s j should also be removed because the chatbot doesn't have to remember the user's cold anymore. If such information is not forgotten and remained in memory, something like Pink Elephant Paradox (Wegner et al., 1987) can occur, causing hallucination of the dialogue model. Therefore, we decided to delete the information that no longer needs to be remembered.
A formal description of the entire algorithm for memory update is given in Algorithm 1, which use the proposed pairwise operations. We fine-tune a classification model of T5 (Raffel et al., 2020) architecture to perform O(m, s).

Experiments
In this section we describe experimental settings and results including the evaluations of the proposed memory update methods of memory management (Section 5.1) and the evaluations of the entire system on multi-session dialogues (Section 5.2).

Memory Update
In this section, we compare several types of models to perform O(m i , s j ) described in Section 4.3.

Pairwise Evaluation
To build a dataset to train and evaluate, we ask the annotators to annotate each pair of (m i , s j ) in CareCall mem dataset into 4 classes {"PASS", "REPLACE", "APPEND", "DELETE"}. If any one of the four labels is chosen by at least two of the three annotators, it is regarded as the gold label.  If there is no such consensus, which occur in about 2% of the cases, we discard the example. Table  2 reports some key statistics about the collected dataset. Examples of the annotated pairs are in Table 7 of the Appendix and see Appendix C.2 for discussions of the cases we found that need further research on this direction.
We consider three types of model for this task. A pre-trained T5 architecture is used for all three models (See Appendix B.4 for more details).
• From scratch: A model fine-tuned on the collected dataset.
• NLI zero-shot: A model fine-tuned on KLUE-NLI (Park et al., 2021), a Korean natural language inference (NLI) dataset. Assuming the old memory sentence and the new memory sentence as a premise and a hypothesis, respectively, we can map the memory update operations as follows."PASS": entailment, "REPLACE": contradiction or reversely entailment, "APPEND": neutral. "DELETE" is not mapped, so this model has minimum 5.1% of error. The NLI zero-shot is used to see if the knowledge from NLI can be transferred to the proposed memory operations.
• NLI transfer (fine-tune): The NLI zero-shot model further fine-tuned on the collected dataset.
The results are shown in Table 3. Although NLI zero-shot reaches certain level of performance, there is a significant performance drop compared to From scrach model (−12.15% on test set). We hypothesize that this is because the memory update requires common sense beyond pure logical reasoning. For example, if m i = "planning to see a doctor" and s j = "went to the hospital", there is no logical inconsistency, but m i can generally be expected to be replaced by s j . Eventually, we found that further training the NLI model on the collected dataset is the best (NLI transfer).

Set Evaluation
We manually annotate the test set in Table 2 to measure the performance of set level algorithm f (M, S) → M (Alg. 1). The annotation process is the same as the one described in Section 3.2.2, and the compared models are the same as the pairwise evaluation. We measure the sentence-level F1 scores between gold M and the predicted one. The evaluation results in Table 3 show a trend similar to the pairwise evaluation; NLI transfer achieves the best performance.

Multi-session Dialogues
We evaluate our entire system described in Section 4 in a multi-session dialogue setting. The response generation model (4.1) is trained on both CareCall mem and original CareCall datasets (details are in Appendix D). The memory retrieval (4.1) and dialogue summarization (4.2) models are trained on CareCall mem only. The memory update model (4.3) is NLI transfer (fine-tune) from 5.1.
• Without memory: This model consists of only the response generation model in Section 4. The input at inference is current dialogue history D t only.
• History accumulate: This model consists of only a response generation model, with input of all previous sessions concatenated before D t for both training and inference.
• Memory accumulate: This model consists of all components in Section 4, but it use "APPEND" as the only pairwise operation.
• Memory update: This model consists of all components in Section 4. The entire memory update method in Algorithm 1 is used.
• Memory gold*: This model consists of all components in Section 4, but M for each session is gold memory in the dataset. This serves as the upper limit for memory management mechanism. Table 4 shows the results. First, Without memory shows a relatively high PPL in memory turns of all sessions. History accumulate is competitive in all metrics in early sessions, but its performance drops significantly as the session progresses. This is conjectured that there are many distractions in accumulated dialogue history which make it difficult to track changing information. Furthermore, the performance gain of Memory update over Memory accumulate becomes larger as the sessions progress. This is because Memory accumulate has a relatively high possibility of utilizing outdated information, which can be a noise to the model. Memory update achieves the best performance in most metrics especially in later sessions (Session 4-5), showing advantage of up-to-date memory.

Human Evaluation
We also perform human evaluation in multi-session dialogues. For a reliable evaluation, we use con-   Table 9 in Appendix. tinuous rating for the live conversations proposed in Ji et al. (2022), which is shown to be easily reproducible with high correlation among repeated experiments. We extend this evaluation process to multi-session dialogues. A crowdworker conducts live conversations for five sessions per episode (assuming 1-2 weeks are elapsed between sessions) with a randomly selected model among the compared models. At the end of each session, we ask the crowdworkers to rate the degree to which they agree with the statements on each evaluation metric on a scale of 0-100. After an episode is over, they repeat another episode with another randomly selected model. The score distribution of each crowdworker is standardized, removing the potential bias of each worker. The evaluation metrics are summarized in Appendix E and the interface used for evaluation is shown in Figure 5 in Appendix. There are three models compared in this evaluation: Without memory, Memory accumulate, and Memory update described in Section 5.2.1. A total of 155 episodes and 775 sessions are evaluated trough this process.
Overall results are shown in Table 5. Memory update shows a clear advantage over Memory accumulate in memorability (p-value < 0.05 for pairwise significance test). We also discover that memorabil-ity positively correlates with engagingness (Pearson correlation 0.68 at p-value < 0.01). Furthermore, there is some positive correlation between memorability and humanness (Pearson correlation 0.47 at p-value < 0.01). Accordingly, Memory update shows the highest engagingness and humanness compared to the other two models. Additionally, coherence and consistency have no statistically meaningful difference among the models (p-value > 0.1 for pairwise significance test). This allows us to conclude that Memory update has better ability to remember while still preserving general conversational abilities like coherence and consistency. Figure 3 shows scores of each session for the three metrics (results for all five metrics are in Table  8 in Appendix). In the case of Without memory, it is observed that engagingness and humanness consistently drop as the sessions progress. In contrast, Memory accumulate and Memory update maintain engagingness and humanness to some level in the subsequent sessions. However, in the later sessions (Session 4-5), the difference between Memory accumulate and Memory update grows with regards to all three metrics. It seems that the crowdworkers feel as if the chatbot doesn't remember well when it brings up an information that has become no longer true in previous sessions, resulting in a lower engagingness and humanness. This is likely the reason why crowdworkers rate Memory update as the most engaging and human-like.

Conclusion
We present a novel task of long-term conversation with dynamic memory changes and build the corresponding dataset. We propose a memory management method that performs operations between old and new memory information in the form of unstructured text. Through an extensive series of experiments, we demonstrate the effectiveness of the proposed method in terms of improving memorability of a chatbot system. We also show that keeping memory up-to-date in long-term conversations is important for engaging and human-like dialogues. We release the newly collected dataset, looking forward to further research on this promising direction.

Limitations
For the sake of simplicity and clarity in our current research study, we only considered remembering and updating information of a single interlocutor. However, our future studies should aim to include memorized information from both sides and bringing it up in conversations, just as Xu et al. (2022a,b) did by duplicating the proposed memory management for both sides.
Regarding the generalizablity of our results, it should be noted that the experiment was performed on data collected in Korean language. Although we do not use a Korean-language-specific approach in our experimental settings, whether or not our results would extend across different languages is yet to be determined.
Our experiments do not cover extremely long conversations where memory reaches its maximum capacity. In this case, removing the oldest memories (i.e. first in, first out) could be a plausible approach, just as human memory fades over time. Still, the amount of computation can grow large. Since pairwise operation occurs O(|M ||S|) times and each operation is predicted by T5 in our experiments (it takes about 80ms on 1 NVIDIA V100 for a single inference), the memory update can be costly when |M | gets large.
Finally, our experiments require large GPU resources, at least 1 NVIDIA A100 or multiple GPUs equivalent to it. The specifications of GPUs used for training the models are provided in Appendix B.

Ethical Considerations
Our dataset is created by authors, crowdworkers, and large-scale language models. Throughout the interactive data collection process, we instructed crowdworkers to play the role of potential users only, without disclosing any personally identifiable information about workers themselves. Meanwhile, it is known that the generated output from pre-trained language models may contain toxicity (Gehman et al., 2020;), private information (Carlini et al., 2021, or social biases (Bordia and Bowman, 2019; Shwartz and Choi, 2020;Bender et al., 2021;Garrido-Muñoz et al., 2021). To address these issues, we carefully constructed criteria for harmful texts based on legal and ethical considerations offered by our group's specialists. We guided all annotators to filter and edit the dataset based on such criteria. In addition, since the users in our dataset might be deemed as a vulnerable social group, our group's ethical consultation included a review of sensitive subjects and the elimination of sessions involving any mention of such topics. We also had multiple filtering processes by multiple workers for every example to ensure that the final dataset does not contain any potentially malicious or unintended harmful effects.
Furthermore, since the proposed system has the capability of storing the information they learned from the interactions with users, we emphasize that the information in long-term memory remains absolutely private to the individual's conversation and is not shared with anyone else. Also, if it comes into the wrong hands, chatbots are exposed to the possibility of getting programmed to imitate humans and be used for phishing and fraud. In such conversations, we can expect abusive cases where individuals accidentally disclose important and confidential information. Thus, incorporating the proposed system into real-world applications requires developers to ensure that it is used only in a safe and ethical manner.

A Data Quality Control
In each annotation process, we provide detailed guidance and training for all annotators in order to optimize our dataset qulity. Specifically, we instruct them with a comprehensive manual for each job and clarify all questions in a group chat to eliminate potential misunderstandings. We also give personalized feedback to each annotator every week. We recruited annotators from a freelancing platform and in-house labeling services. The major instructions for the data collection process are summarized as follows.
Dialogue Summary We ask annotators to summarize the core information of the user in a given dialogue session, particularly the information that is worth continuing with the subsequent sessions. The resulting summaries are abstractive summaries, as we instruct them not to copy the utterance itself from the dialogues, but write it into a new abstractive sentence. For the summarized information, we guide the annotators to exclude information about one-off events or overly-detailed information about the user such as "had three eggs for breakfast" or "went to the park at 9:10AM", given that they are difficult or irrelevant to use in subsequent dialogues. However, if the user's information has been changed, such information would be included in the summary (e.g. "just got married" or "recovered from flu") to keep track of. Three different groups of annotators consecutively edited the summaries, only 1.4% of which were edited in the last iteration.

Memory Grounded Dialogue
We ask annotators to make sure that the dialogues contain various daily topics and that the information in memory is utilized in a context as naturally as possible, rather than obsessively mentioning memorized information. In addition, for consistency, we ask them to correct cases where the bot generates responses or questions that may contradict information already included in the memory. For example, if the bot already knows that the user is hospitalized for back surgery, the bot wouldn't ask questions such as "Are there any health issues?". Also, the bots are not allowed to mention things that are not in memory as if they do remember those things. For other remaining instructions, we refer to the specifications in Bae et al. (2022) for the consistent role of the bot.
Memory Update At the end of each session, annotators are asked to select the sentences in M and S that could be used in the subsequent sessions. In other words, the statements that are no longer valid or redundant are removed, and the statements that do not conflict with others remain. Additionally, every time when m i and s j are exactly the same in terms of information, even if it might be okay to leave either of them, we guide to leave m i for consistency of the dataset.

B.1 Pre-trained Language Models
We use three types of Transformer-based pretrained language models in our experiments. For response generation (Section 4.1) and dialogue summarization (Section 4.2), we use HyperCLOVA (Kim et al., 2021) with 6.9B parameters. The model specification follows Kim et al. (2021) and the implementation is based on Megatron-LM (Shoeybi et al., 2019). For the memory update model (Section 4.3), we use a model of T5 (Raffel et al., 2020) architecture pre-trained on the corpus identical to that of Kim et al. (2021). This model consists of 24 layers, 1024-dimensional embeddings, and 16 attention heads, resulting in total of 822M parameters. Lastly, for retriever (Section 4.1), we pre-train BERT (Devlin et al., 2019) on a corpus that we collected in-house and a public Korean dialogue corpus 3 . Our BERT consists of 12 layers, 768-dimensional embeddings, and 12 attention heads, resulting in total of 110M parameters. The models except HyperCLOVA are based on Huggingface Transformers (Wolf et al., 2020). Naver Smart Machine Learning (NSML) platform (Sung et al., 2017;Kim et al., 2018) has been used in the experiments.

B.2 Generator
For efficient training, we employ LoRA (Hu et al., 2021) for fine-tuning of all response generation and dialogue summarization models. We fix adaptor rank to 4 and LoRA α to 32, with learning rate of 5 × 10 −4 , weight decay factor of 0.1, and batch size of 8. The maximum training epoch is 3 with early stopping. Training is completed within 10 hours using 1 NVIDIA A100. The maximum sequence length is 2,048 and the inputs that exceed this length are truncated from the front.

B.3 Retriever
Our retriever implementation is similar to context persona matching (CPM) method proposed in Xu et al. (2022b). The current dialogue context D t is encoded with dialogue encoder E D (·), and each memory sentence m i ∈ M is encoded with memory sentence encoder E m (·). Here, E(·) refers to each input's representation, i.e. the encoder's output on the first input token ([CLS]). The encoders E D and E m are initialized with pre-trained BERT (Devlin et al., 2019) architecture. We use triplet loss to fine-tune the encoders as: where m + is a memory sentence matched with D t in the training dataset, m − is a memory sentence from other dialogue sessions in the training dataset, and α = 0.2 is the margin. The models are trained for 20 epochs with early stopping using a maximum learning rate of 3 × 10 −5 and an linear scheduler. This training takes about 3 hours using 1 NVIDIA V100. At inference time, the top k (k = 5 in our experiments) memory sentences are retrieved from M using cosine similarity:
The models are trained with a batch size of 8. They are trained for 20 epochs with early stopping, a maximum learning rate of 5 × 10 −5 , and a linear scheduler. This training takes about 1 hour using 1 NVIDIA A100.

B.5 Hpyerparameter Search
For all models, the learning rate was searched in the range of [3 × 10 −5 , 5 × 10 −5 , 5 × 10 −4 ] and the batch size in the range of [8,16,32]. We tried at least 3 times for each setting to find the best configurations.

C.1 Persona Updates in Our Dataset
Our dataset contains more persona updates, because of 1) relationship setting between interlocutors and 2) duration of episodes.
According to Altman and Taylor (1973), people disclose more private information as their relationship deepens. MSC (Xu et al., 2022a) was collected in a setting of two strangers getting to know each other, where people tend to discuss rather easily shareable information such as their profiles or preferences. Our dataset reflects a more intimate relationship where people disclose more private realms of life, which is more likely to change over a few weeks (e.g. "getting a physiotherapy", "gained a few pounds", "arguing with son") or do not change frequently but will share updates if occured (e.g. "got laid off", "got back together with partner").
Also, the assumed duration of dialogue in our dataset is relatively longer than MSC (Xu et al., 2022a). The average term between sessions is about 2 days in MSC, while 10 days in our dataset. The entire span of each episode is 5 hours to 5 weeks in MSC, while 5 weeks to 10 weeks in our dataset. Thus, more persona information might change.

C.2 Memory Operation
While collecting the dataset in Section 5.1, we found a few cases where the four proposed pairwise operations might not perfectly guarantee that the stored memory is lossless, consistent, and not redundant. For example, when m i = "Back hurts but hasn't seen a doctor yet" and s j = "Receiving physiotherapy at the hospital", the resulting memory might not be lossless if only one of them is stored, while it might be inconsistent if both are left in memory. In these cases, we ask the annotators to label them as "FUSION", which might require combining the two sentences into a new sentence like "Receiving physiotherapy at the hospital for back pain". The cases of gold label = "FUSION" occur in about 1.09% in the collected pairs, so we assume them to be negligible and discard them from our dataset in Table 2, since it would be costly to collect data exclusively for such cases and train a separate generator. It might be helpful to use a generative approach that combines information from the two sentences into a new one p(m |m, s) selectively for such cases, though this would require additional consideration about the relationship between the newly generated sentence and other sentences.
Also, dependencies between memory sentences may exist. For example, in the case of m i = "got gastroenteritis" and m j = "The doctor banned alcohol, meat, and flour", if the preceding sentence disappears, the following sentence should also be removed. This case can be resolved simply by clarifying the fact that it is due to enteritis in the second sentence, but there may be some cases in which putting all the dependencies in a sentence is difficult. A graph structure may be an alternative to design dependencies between memories.

D Variants of Response Generation Models
We compare various types of response generation models according to the training dataset and dialogue context type. When using the original Care-Call dataset, since this is a single session dataset, the model is always trained to predict c t+1 given only D t , i.e. p(c t+1 |D t ). When using the new CareCall mem dataset, the inputs vary depending on the context type.
• Without memory: Given only D t to predict c t+1 .
• Dialogue history grounded: The dialogue histories from all previous sessions are concatenated before D t .
• Memory grounded: The model described in Section 4.1, in which M is concatenated before D t .
We evaluate the above models with 300 sessions of the human written dialogues described in Section 3.2.1 as the test set (all D t 's are second sessions of each episode). Table 6 shows the results. The model trained with CareCall dataset has no significant performance improvement in all metrics when the previous session history is given as a context. Since CareCall dataset does not contain utterances that utilize memory, simply giving previous context at inference time does not enable the model converse using memory. On the other hand, the newly collected CareCall mem dialogues are dependent on the previous session. The model trained with such CareCall mem has a significant performance gain when the previous session history is given in the form of either raw dialogue history or summary. Also, it is better to give a summary than to give a dialogue history, a finding consistent with a previous work (Xu et al., 2022a). Furthermore, using CareCall + CareCall mem shows better or competitive results in all three types of session context. This is probably because the general conversation performance is more advantageous with more data. We also found that the utterances that explicitly mention memorized information are about 24.8% of all utterances in the CareCall mem dataset, which is a reasonable proportion in real-life conversations. This means that the general conversational ability is also important to predict responses in this task. Therefore, we use CareCall + CareCall mem as the training dataset for response generation model on multi-session dialogues (Section 5.2).

E Human Evaluation Metrics
For each session of dialogue between human and a chatbot, we ask the crowdworkers to evaluate the quality of the chatbot by rating the degree to which they agree with the statement on each evaluation metric on a scale of 0-100 (inferface is given in Figure 5). The statements for evaluation metrics are as follows.
• Coherence: This chatbot understood the context and responded coherently.
• Consistency: This chatbot was consistent throughout the conversation.
• Engagingness: I wound like to chat with this chatbot for a longer time.
• Humanness: This chatbot sounded like a human.
• Memorability: This chatbot remembered what I said before.
The statements for the first four metrics are referred from previous literature (Li et al., 2019;Finch and Choi, 2020;Ji et al., 2022; for consistency of evaluation across different works. We additionally defined memorability to evaluate how well the model remembers previous conversations.     Table 9: Average absolute scores of human evaluation metrics on live conversation for 5 sessions in each episode. Figure 5: Web-based user interface for the human evaluation. All texts are translated into English. For each session, crowdworkers can communicate with the system by sending messages. At the end of the session, they rate the degree to which they agree with the statements on a scale of 0-100 by moving the sliders. They converse with a randomly selected model for 5 sessions, and then reset episode to converse with another model.