Generating Contrastive Narratives Using the Brownian Bridge Process for Narrative Coherence Learning (2024)

Abstract: A major challenge for narrative reasoning is to learn narrative coherence. Existing works mainly follow the contrastive learning paradigm. However, the negative samples in their methods can be easily distinguished, which makes their methods unsatisfactory. In this work, we devise two strategies for mining hard negatives, including (1) crisscrossing a narrative and its contrastive variants; and (2) event-level replacement. To obtain contrastive variants, we utilize the Brownian Bridge process to guarantee the quality of generated contrastive narratives. We evaluate our model on several tasks. The result proves the effectiveness of our method, and shows that our method is applicable to many applications.

heading: 1 Introduction
text: Narrative reasoning (Charniak, 1972; Winograd, 1972) is an account of the development of events, along with explanations of how and why these events happened (Hutto, 2015), which has provoked a variety of applcations, including commonsense causal reasoning (Roemmele et al., 2011; Gordon et al., 2012; Luo et al., 2016), abductive reasoning (Bhagavatula et al., 2019), and so on.
A major challenge for narrative reasoning is to evaluate narrative coherence (Mostafazadeh et al., 2016). Existing methods mainly focus on devising self-supervised tasks, in which positive samples are from large-scale real narratives (Mostafazadeh et al., 2016; Yao and Huang, 2018), and negative samples are created by sampling-based strategies. For example, Xie et al. (2020); Lin et al. (2020b); Uehara et al. (2020) create negative samples by shuffling or masking real narratives. Krishna et al. (2022) incorporates randomly sampled sequences and model-completed (Radford et al., 2019; Brown et al., 2020) sequences as negative samples. However, these strategies are generally coarse-grained and superficial. The resulting negatives still face
problems of low quality, such as being irrelevant or repetitive (Krishna et al., 2022), making them less representative, and easily distinguishable.
Hard negatives are critical in the contrastive learning framework (Wu et al., 2017; Mishchuk et al., 2017; Xuan et al., 2020). The ideal of hard negative samples should be that are similar to a real narrative but actually less coherent. To mine such negatives, a possible approach is to introduce contrastive narratives. Contrastive narratives are examples that are similar in content, but convey different semantics (Margatina et al., 2021; Wang et al., 2021). Due to this property, we can crisscross1 a narrative and its contrastive variants to obtain negative samples, as shown in Figure 1. The resulting negatives should be similar to the real narratives but less coherent, making them good candidates for hard negatives. However, existing works for collecting contrastive narratives rely heavily on manual annotation, which is costly and not scalable. To solve this problem, exploiting automated methods has great value, but is difficult since it requires preserving subtle differences while providing a clear delineation between the observed narrative and the generated ones.
Actually, the generation of contrastive narratives involves exploring the latent space surrounding a given narrative, enabling the creation of similar narratives with distinct characteristics. Assuming that the evolution tendency of an observed narrative can be represented as a continuous trajectory in latent space, which can be modeled by Brownian motion (Revuz and Yor, 2013; Wang et al., 2022). Consequently, we can sample the latent trajectories which exhibit proximity to the observed trajectory, and then decode the sampled trajectories into explicit narratives. But the problem is that the
1For example, according to X = (P, S) and Xc = (Pc, Sc), we can exchange their prefixes and suffixes to obtain the negatives (P, Sc) and (Pc, S). We define this strategy as “crisscrossing", and use this definition in the rest of our paper.
6538
decoded narratives may differ significantly in content from the observed narrative, which may not meet the requirements for contrastive narratives. To simplify the problem, we further suggest that contrastive narratives keep the same endpoint as the observed narrative, which directly models the fact that a narrative event can evolve to the same end through different paths (Qin et al., 2019). Based on this constraint, we are able to sample different trajectories from the Brownian Bridge (Majumdar and Orland, 2015; Wang et al., 2022) region that is centered around the observed narrative. The sampled trajectories are decoded as narratives with the same start and end as the observed narrative, while also having similar but different intermediate event chains. Then we crisscross the observed narrative and the generated ones to synthesize negative samples. In fact, in our crisscrossing strategy, the start and end points of resulting negatives remain the same as the positive ones. That is, the start and end of positive narratives will never be perturbed. This further motivates us to design an event-level perturbation to obtain negatives, as more diverse negatives definitely benefit contrastive learning.
In this paper, we devise two strategies to create hard negatives for narrative coherence learning. The first strategy crisscrosses a narrative with its contrastive variants, and the second strategy performs an event-level replacement. To obtain contrastive narratives, we first sample different latent trajectories from the Brownian Bridge region, then fix the start and end points of the narrative, and generate diverse contrastive narratives.
Our contributions can be summarized as follows. (1) Based on the Brownian Bridge process, we generate high-quality contrastive narratives, which are used to synthesize hard negatives. (2) We propose a new coherence evaluator (CohEval), which is enhanced by diverse and high-quality hard negatives. Our model is trained entirely through selfsupervised contrastive learning, and can be applied to a wide range of downstream tasks.
We evaluate our model on multi-choice tasks and one narrative generation task. We also conduct an in-depth analysis of our negative sample synthesis strategies. The experimental results demonstrate the effectiveness of our method. Code is released at github.com/mufeiteng/ContrastiveNarratives.

heading: 2 Related Work
text: Counterfactual Story Generation Counterfactual story generation (Qin et al., 2019; Hao et al., 2021; Chen et al., 2021) requires predicting how alternative events, contrary to what actually happened, might have resulted in different story endings. Existing works for counterfactual story generation mainly include manual annotation (Qin et al., 2019) or supervised fine-tuning (Hao et al., 2021) methods. In our work, contrastive narratives can be seen as a special case of counterfactual narratives, where we confine that an observed narrative and its contrastive variants have the same start and end. We generate contrastive narratives in a selfsupervised manner, which is based on the Brownian Bridge process (Wang et al., 2022).
Language Modeling via Stochastic Process Generating long, coherent text is conceptually difficult for autoregressive models because they lack the ability to model text structure and dynamics (Lin et al., 2020a). Wang et al. (2022) explicitly models latent structure with Brownian Bridge dynamics, which can capture how sentence embeddings evolve over a document. (Wang et al., 2023) uses the stochastic process to model the temporal dynamics of dialogue paths. Motivated by Wang et al. (2022), we use Brownian Bridge for generating contrastive stories because it allows for the smooth modeling of gradual changes between two narrative states. Based on the simple constraint, we are able to generate coherent contrastive narratives, which are used to synthetic hard negatives.
Hard Negatives Mining Earlier researchers devise a series of corrupting strategies, such as shuffling, masking, or lexical conversion, to perturb real narratives (Cai et al., 2020; Xie et al., 2020; Lin et al., 2020b; Uehara et al., 2020; Zhou et al., 2022a,b). Recent methods focus on mining hard negatives. For example, Jwalapuram et al. (2021) retrieves hard negatives from the corpus with a momentum encoder. Krishna et al. (2022) incorporates random sequences and model-generated sequences as hard negatives. Kalantidis et al. (2020) mixes different negatives in latent space to create hard negatives. Zhang et al. (2022) mixes multiple positive samples to produce hard negatives. Instead, we propose to use a narrative with its contrastive variants to synthesize hard negatives. Since the contrastive narratives are similar to the original ones, we can obtain qualified negatives.

heading: 3 Methods

heading: 3.1 Data Preparation
text: Following the previous method (Cai et al., 2020), we use RocStories (Mostafazadeh et al., 2016) as our data corpus, since it contains abundant event commonsense knowledge, making it a good resource for narrative reasoning. Due to the limitation of computational resources, we randomly select about 20k samples from RocStories, and denote them as the positive sample set D+. Each sample in D+ is a narrative X = {e1, · · · , e5}, in which each ei (i = 1, · · · , 5) is an event. Following previous works, we lay narrative coherence learning in the contrastive learning framework, in which the negative samples are needed for training.
We devise two strategies for mining hard negatives: (1) crisscrossing a narrative and its contrastive variants; (2) event-level replacement. Next, we introduce how to obtain contrastive narratives.

heading: 3.2 Generating Contrastive Narratives via the Brownian Bridge Process
text: Given a narrative, the contrastive variants should be similar to it and express distinctive characteristics. We regard this problem as exploring the latent space surrounding the given narrative, and propose to model this problem by the Brownian Bridge process (Wang et al., 2022). The density distribution of a Brownian Bridge process from a start point z0 at t = 0 to an endpoint zT at t = T is:
p(zt|z0, zT ) ∼ N ((1− t T )z0 + t T zT , t(T − t) T ). (1)
The Brownian Bridge density acts like a noisy linear interpolation between the start and end point of the trajectory, where the intermediate point zt should be more like z0 at the start and more like zT at the end of the trajectory. Uncertainty is highest in the middle region, and low near the start and end points (rf. Figure 2, the green region). The characteristic of the Brownian Bridge is to maintain a smooth transition between the sampling midpoint and the starting and ending points.
Following (Wang et al., 2022), we pre-train an event encoder with the Brownian Bridge contrastive loss2. Given the starting and ending events, the encoder is responsible for encoding an event e into latent code z and ensuring that the latent codes of any intermediate events conform to the Brownian bridge distribution (Equation 1). Once the event encoder is trained, it will be frozen in all subsequent processes and will never get updated.
To train the contrastive narratives generator, we automatically construct training examples. Given the start event e1 and the end event e5, we first use the event encoder to encode them into latent vectors z1 and z5. Once z1 and z5 are obtained, we know the corresponding Brownian Bridge density (Equation 1), and we can sample middle points to obtain diverse latent trajectories, i.e., Z = {z1, z2, z3, z4, z5}. To generate contrastive narratives, we encode (e1, e5) with BART (Lewis et al., 2019) to obtain the context embeddings:
Hc = BARTEncoder([e1, e5]), (2)
where [; ] denotes the concatenation, Hc ∈ Rl×d, l is the length of [e1; e5]. Next, given Hc and latent codes Z, we generate middle events y = (e2, e3, e4). Specifically, let yt denotes the t-th tokens in y. At the timestep t, the generator must predict yt using Hc, all tokens in the past y<t, as well as the event latent codes Z:
hyt = BARTDecoder(y<t,Hc,W T z Z)
P (yt|Y<t) = softmaxV (Wvhyt + b). (3)
where V denotes the standard vocabulary, Wz denotes a linear layer that maps the dimension of z to be identical to Hc. This can be seen as decoding a latent trajectory {z1, z2, z3, z4, z5} into narrative events given the start event e1 and end event e5.
However, in our preliminary trials, we found that the generated narratives are coherent but less similar to the original one, which brings difficulties to the construction of hard negatives. The possible reason is that the encoding process, i.e., encoding
2See Appendix A and (Wang et al., 2022) for details.
e to z, lost too much information, making it difficult for the model to reconstruct y. To solve this problem, we randomly mask the y with the ratio of ρ (0.85 by default), and use the masked sequence as the prompt for the decoding phrase, which encourages the generator to generate more similar events to y. Actually, these can be seen as two types of constraints, where Z requires that y and the generated text show similar trajectories in latent space, and the masked prompt requires that y and the generated text are similar in vocabulary. The whole training process is shown in Figure 2.
When training, we use RocStories excluding D+ as training data. We have also tried other pretrained models, such as GPT2 (Radford et al., 2019) and T5 (Raffel et al., 2020), and BART empirically performs best, as shown in Appendix B. Therefore, we choose BART as the backbone. After training, for each X ∈ D+, we fix its start and end events, then sample different intermediate events. For each X , we first generate 200 candidates, then use several criteria3 to filter low-quality candidates. We finally retain N (60 by default) most-qualified contrastive examples.

heading: 3.3 Synthesizing Negative Examples
text: We devise two strategies to create negative examples. The first strategy crisscrosses a narrative with its contrastive variants, and the second strategy performs an event-level replacement.

heading: 3.3.1 Crisscrossing a Narrative and its
text: Contrastive Variants
Note that each X contains five events. For simplicity, we define the first three events as the prefix (P ), and the last two events as the suffix (S), so that we denote X = (P, S) and the contrastive variant Xc = (Pc, Sc). Then we are able to synthesize the negative example X− = (Pc, S). The basic intuition is: Pc is coherent with Sc, so it should be less coherent with S. This is because X and Xc are different paths with the same start and end points.
3See Appendix C for details.
More specifically, by comparing X = (P, S) and X− = (Pc, S), we can find that the difference between X and X− lies in the second and third events. In other words, we have replaced two events in the original story with different events. Therefore, the resulting samples should be less coherent than X . Meanwhile, X− = (Pc, S) is similar to X = (P, S), making it qualified as a hard negative4. With loss of generality, we denote the obtained negative samples as CX = {X−i }2Ni=1.
For each training epoch, we randomly sample K (15 by default) negatives samples {X−k }Kk=1 from CX for each X , and feed them as well as X into a pre-trained language model (PLM) (Devlin et al., 2018a; Liu et al., 2019), e.g. RoBERTa, to obtain sequence-level representations:
h+ = RoBERTa(X),h−k = RoBERTa(X − k ), (4)
where k = {1, · · · ,K}, h+ and h−k ∈ Rd, d is the hidden size of RoBERTa. We have also tried BERT (Devlin et al., 2018b) as the backbone, as shown in Appendix E. Next, the sequence-level representations are passed into a linear layer Wc ∈ Rd to derive coherence scores of all samples:
s+ = WTc h +, s−k = W T c h − k . (5)
Lastly, we use the contrastive classifying objective to distinguish the positive examples from the corresponding negative examples:
L1 = − 1|D+| ∑
D+ log
exp(s+)
exp(s+) + ∑K
k=1 exp(s − k )
. (6)
It should be noted that the difference between X− = (P, Sc) and X = (P, S) lies in the third and fourth events, i.e., e3 and e4. Due to the masked prompt, some tokens in (e3, e4) of X− are similar to those of X , making X− qualified. However, in the crisscrossing strategy, e1 and e5 will never be perturbed. This further motivates us to perform a simple event-level perturbation to X to create more diverse negative samples.
4Similarly, we can obtain the negative example X− = (P, Sc) by defining the first two events as the prefix.

heading: 3.3.2 Event-level Replacement
text: Due to the fact that events are the basic semantic unit of neural language, for a narrative, if we replace a component event with another similar but different event, the resulting example should be less coherent and similar to the original narrative.
Specifically, based on D+, we build an event pool, which consists of about 100k different events. We pre-compute the cosine similarity among all event pairs using SimCSE (Gao et al., 2021), and cache the top 20 most similar events Qe for each query event e. Then, given a positive example X , we randomly select a position i and replace i-th event ei with a randomly sampled event ē from Qe to create a negative example X̄ = {· · · , ei−1, ē, ei+1, · · · }. Likewise, for each training epoch, we create K negatives samples {X̄k}Kk=1. After obtaining hidden states of negatives: h̄k = RoBERTa(X̄k), we derive coherence scores of all samples and use the contrastive loss to rank the positive sample above the negatives:
s+ = WTc h +, s̄k = W T c h̄k, L2 = − 1|D+| ∑
D+ log
exp(s+)
exp(s+) + ∑K k=1 exp(s̄k) .
(7)

heading: 3.4 Training and Knowledge Transferring
text: When training, the final loss is
L = γL1 + (1− γ)L2, (8) where γ is set to 0.5. It should be noted that another way is to merge two types of negatives and directly perform contrastive learning. However, this requires more GPU memory, which exceeds our condition. Therefore, we calculate the two losses separately and then average them.
Our CohEval can be easily transferred to many downstream applications. For example, for the multi-choice task with a input C and option candidates O = {o1, · · · , on}, we can use CohEval to select most reasonable o by:
o← argmax i CohEval([C, oi]). (9)
Motivated by existing plug-and-play text generation methods (Miao et al., 2018; Chen et al., 2021), we also evaluate our CohEval in narrative text generation, with CohEval as coherence guidance. Details can be seen in the experiment.

heading: 4 Experiment

heading: 4.1 Datasets and Experimental Details
text: The evaluation datasets include COPA (Roemmele et al., 2011), e-Care (Du et al., 2022a), αNLI (Bhagavatula et al., 2020), Cloze (Mostafazadeh et al., 2016), Swag (Zellers et al., 2018), HellaSwag (Zellers et al., 2019), and TimeTravel (Qin et al., 2019). TimeTravel is a text-generation dataset, while others are multi-choice datasets. We evaluate our model on these datasets in the zero-shot setting. Note that the test sets of e-Care and HellaSwag are not released. So we evaluate our model on the validation set of the three datasets. The statistics of the datasets, as well as the experimental details are shown in Appendix D.

heading: 4.2 Baselines and Metrics
text: For multi-choice tasks, the metric is Accuracy. We compare our method with EventBERT (Zhou et al., 2022a), RankGen (Krishna et al., 2022), and several large language models (LLMs), including Alpaca-lora (7B)5, ChatGLM2 (6B) (Du et al., 2022b; Zeng et al., 2022) and ChatGPT (OpenAI. , 2023). For LLMs, we use one-shot prompting for experiments, the used prompts are in Appendix F. For TimeTravel, we follow Chen et al. (2021) and formulate this task in the MCMCbased sampling paradigm. The details are in Appendix G. We compare our method with DELOREAN (Qin et al., 2020), ClarET (Zhou et al., 2022b), CGMH (Miao et al., 2018), EDUCAT (Chen et al., 2021). Automatic evaluation metrics
5The checkpoint is at https://github.com/tloen/alpaca-lora.
include BLEU4 (Papineni et al., 2002), BertScore (Zhang et al., 2019), ENTScore (Chen et al., 2021), and HMean= 2·BLEU4·ENTScoreBLEU4·ENTScore (Chen et al., 2021). Manual evaluation metrics include Fluency, MinEdits (Chen et al., 2021), and Coherence.

heading: 4.3 Overall Results
text: Automatic Evaluation The automatic evaluation result can be seen in Table 1 and 2, respectively. We have the following observations. • In Table 1, our model surpasses all contrastive
Ablation Study To investigate the influence of the two kinds of negatives, we devise two ablated variants: (1) MER which means we create negatives via event-level replacement; (2) MCC which
means we create negatives via the crisscrossing strategy. The ablation study result is shown in Table 1, 2. We have the following observations. • Compared to CohEval, MER and MCC achieve
lower ENTScore, indicating their weaker coherence evaluation abilities. But both variants obtain higher BLEU4 and BertScore. In TimeTravel, there is a trade-off phenomenon between BLEU and EntScore. This is because the gold y′ is obtained through editing the original y with minimal-edits. This leads to a high word overlap between y′ and y. Due to the weaker coherence evaluation abilities of the two variants, the probability of accepting transitions is lower when adopting MCMC for rewriting. In other words, when using MER and MCC , the number of rewritings is relatively low, resulting in higher BLEU4 and BertScore but lower ENTScore. • The best ENTScore is achieved by combining two kinds of hard negatives. This indicates the two kinds of negatives complement each other. The reason is that more diverse negative examples contribute to contrastive learning. • MCC generally performs better than MER. The possible reason is that, compared to the crisscrossing strategy, the event-level perturbation is more coarse-grained. Nevertheless, event-level replacement is an effective supplement to the crisscrossing strategies.
Manual Evaluation on TimeTravel We perform an A/B test to compare our method with several baselines. Following (Chen et al., 2021), the human evaluation mainly focuses on three primary criteria: i) Fluency, whether a model produces fluent text; ii) Coherence, the logical consistency between the counterfactual context (z, x′) and the generated endings y; and iii) Min-Edits, the extent of minimal revision between two endings. We carry out a pairwise comparison with CGMH, EDUCAT, and two ablated models: Mexp and Mimp. We randomly sample 100 cases for each pair of models. Three annotators are recruited to make a preference among win, tie, and lose given the counterfactual context and two outputs by our model and a baseline respectively. The annotators are research students from the field of text generation to make sure they have a fair judgment of used metrics. We calculate Fleiss’s kappa reliability as the inter-annotator agreement. As is shown in Table 3, LLMs are able to generate fluent and coherent counterfactual ending, but tend to massively edit the original ending,
which coincides with the finding in automatic evaluation. Compared to EDUCAT and two ablated variants, CohEval achieves better fluency and coherence results. In addition, four models achieve similar Min-Edits results, this is because they run for the same editing steps. The Fleiss’s kappa reliability of Fluency, Min-Edits, and Coherence is 0.488, 0.507, and 0.428, respectively.
Human Correlation with our CohEval Same as (Chen et al., 2021), we analyze the correlation between our CohEval and human ratings in terms of coherence evaluation. We calculate Pearson’s r and Kendall’s τ coefficients. The result is shown in Appendix H. All results show positive correlations. The result of our CohEval is close to that of ENTScore. Notice that ENTScore is trained with human-labeled counterfactual data, while our CohEval is trained in a self-supervised manner. This demonstrates the applicability of our CohEval.
Overall, the result demonstrates that our CohEval is a generic narrative coherence evaluator, and can be applied to a wide range of downstream tasks.

heading: 4.4 Deeper Analysis about Contrastive Narratives Generation
text: Indirect Evaluation through Multi-choice Tasks We conduct an ablation experiment to explore the impact of different sub-modules in contrastive narratives generation. We compare our BrownianBridge based method (denoted as “BB") with the following variants. (1) “w/o prompt", in which we ablate the masked prompt when training. (2) “w/o trajectory", in which we ablate the latent trajectories sampled from the Brownian bridge. (3) “Infilling", in which we ablate the masked prompt and the sampled latent trajectory when training. In this case, the ablated variant degenerates into a text-infilling model. We use the counterparts generated by different variants for crisscrossing to obtain negative examples, which are then used for contrastive learning. The result is shown in Table 4.
We find: (1) Compared to “BB", “w/o prompt" and “w/o trajectory" get result drops, respectively; (2) “Infilling" gets a further performance drop.
The possible reasons lie in the following aspects. (1) If contrastive narratives are incoherent, then the synthesized negatives are not “hard". The sampled latent trajectories help to maintain the coherence of generated contrastive narratives, which benefits the quality of synthesized negatives. (2) The masked prompt helps to reduce the difficulty of the generation process, as a result, the obtained contrastive counterparts are similar to the original ones, making the resulting negatives more qualified.
Direct Evaluation through Manual Judgement We further conduct a manual evaluation to directly evaluate the quality of generated contrastive narratives. Since we want the generated narrative to be similar to the original one and reflect subtle differences (such as changes in opinions or entities) to make itself a different story, we use Coherence, as well as Similarity and SubtleDifference (SubtleDiff.) as metrics. Coherence reflect the logical consistency between the given (start,end) events and the generated middle events. Similarity reflects the similarity between the generated middle events and those of the original story. SubtleDiff. measures whether the generated example is a qualified contrastive narrative, which reflects subtle differences from the original story but is actually a different story. We randomly select 100 stories that have no overlap with train data for the experiment.
For each story, we use different models to generate its contrastive variant. We also perform a pairwise comparison with “w/o prompt", “Infilling", and two LLMs: ChatGLM2 and ChatGPT. The same three annotators are asked to make a preference among win, tie, and lose for each pair of generations. In Table 5, ChatGPT generally exhibits the best result, which reflects its powerful reasoning ability. Our “BB" is slightly inferior to ChatGLM2 on SubtleDiff. , but wins on the other two metrics. This indicates that our method is comparable to small LLMs. In addition, “BB" significantly surpasses the ablated variants. Specifically, we find that the masked prompt helps to improve Similarity, while latent trajectory helps to improve Coherence. This coincides with human intuition. The Fleiss’s kappa reliability of Coherence, Similarity, and SubtleDiff. is 0.369, 0.371, 0.244, respectively.
Generally, by utilizing the Brownian bridge process, we harvest qualified contrastive narratives, which contributes to contrastive learning.

heading: 4.5 Further Discussion
text: Influence of Different Strategies for Creating Negatives In our method, we crisscross a positive narrative with its contrastive counterparts to create negatives. Here, we further investigate the result when using Mixup (Zhang et al., 2017) to create negatives. The experimental setting is shown in Appendix I. We additionally explore three ways of obtaining the counterparts: (1) “BB" denotes our Brownian-Bridge based contrastive narratives; (2) “w/o prompt" denotes we ablate the prompt when generating contrastive narratives; (3) Random denotes we randomly select different positive narratives as counterparts. The result is shown in Table 6. We observe that: • The crisscrossing strategy is superior then Mixup
by a large margin. We speculate that in the era of self-attention (Vaswani et al., 2017), using the transformer to directly learn the representation
of negative samples is better than manipulating representations of samples in the hidden space.
• Whether adopting “CrissC." or Mixup, our BBbased contrastive narratives far surpass “random", which proves the strength of our method.
Results under Different Number of Retained Contrastive Narratives We explore the influence of the number of retained contrastive narratives. The result is shown in Figure 3. Our method generally achieves the best result when N = 60, and the result even decreases when N further increases. We speculate that as N increases, incoherent contrastive examples increase, which has a negative impact on the quality of synthesized negative examples. So, we set N = 60 by default.
Impact of the Mask Ratio ρ We investigate the impact of the different mask ratios ρ when generating contrastive narratives. In Table 7, the result is best when ρ = 0.85. As ρ decreases, the result gets worse. To investigate the reason, we manually examine the generated examples, and find the model tends to paraphrase the original story and generate duplicate examples when ρ decreases. This is because more information about the original story will be exposed when using a lower mask rate, making it easier to reconstruct the original story. We additionally calculate the diversity of the contrastive narratives generated at different ρ. We use Distinct-n (Li et al., 2015) as the metric. As shown in Table 7, as ρ decreases, the corresponding Distinct scores also decrease. This indicates that a lower mask rate ρ may lead to duplicate samples when the generation phase, which harms the diversity of synthesized negative samples. Therefore, we proactively filter out duplicate items.
The Reliability of Created Negative Examples We further analyze whether the created negative samples are indeed “negative". On the training set, we first use ENTScore to directly evaluate the coherence of positive samples and two types of negatives. As shown in Table 8, the real positive ex-
amples receive an especially high ENTScore. However, the synthesized two types of negatives receive lower ENTScore, proving that they are obviously less coherent than positive examples. Next, we sample 100 cases and ask the annotators to make a judgment about whether the created ‘negatives‘ are actually more coherent than positives, making them false negatives. As shown in Table 8, both types of negatives show a low FN rate. We show the error cases in the Appendix J.
Visualize the Representations of Examples using t-SNE It is interesting to qualitatively visualize our model’s ability to distinguish hard negatives. Based on the test set of TimeTravel, we are able to obtain positive examples and corresponding hard negatives. We leave the details in Appendix K. We use our CohEval and the ablated variant MER, respectively, to obtain the representations of the examples, then we use t-SNE (Van der Maaten and Hinton, 2008) to visualize the representations. As shown in Figure 4 (a), the representations of positive and negative examples obtained by MER entangle together, this shows that MER, a model that significantly outperforms baselines, still suffers from distinguishing the created positive and negative examples. But in Figure 4 (b), positive samples are concentrated on the right, while negative samples are concentrated on the left. This proves our CohEval’s ability to distinguish positive examples from hard negatives, and confirms the effectiveness of the generated contrastive narratives.
Case Study Appendix L, Table 15 presents a case study for the task of TimeTravel. The counterfactual endings generated by ChatGLM2 and Chat-
GPT are coherent but very different from the original ending. This conflicts with the minimal-editing requirement of the task. On the contrary, based on the MCMC sampling, our method can produce similar and coherent counterfactual endings. Appendix L, Table 16 presents a case study for contrastive narratives generation. Due to the sampled different trajectories, in the case #1, our method shifts the topic of accent to personality, and produces a coherent story. And in the case #2, our method exchanges the opinions of two participants. On the contrary, the middle events generated by ChatGLM2 and ChatGPT show a significant difference from that of the original story.

heading: 5 Conclusion
text: In this paper, we propose to use the Brownian Bridge process to generate contrastive narratives, then we crisscross a positive story and its contrastive variants to create negative examples for contrastive learning. In addition, we devise the event-level replacement, which is an effective supplement to the crisscrossing strategy. The experiment verifies that (1) the generated contrastive narratives are qualified, and (2) our CohEval is effective and is a general coherence evaluator that is applicable to many downstream tasks.

heading: Acknowledgements
text: We thank the anonymous reviewers for their encouraging feedback. This work is supported by Research Grants Council of Hong Kong(PolyU/15207920, PolyU/15207821, PolyU/5213323) and National Natural Science Foundation of China (62076212).
Limitations
To automatically generate contrastive narratives, we made the following assumption: the observed story and its contrastive variants have the same start
and end events. However, this assumption may not be consistent with reality. In addition, under limited computing resources, we are unable to explore our method on larger data scales and larger pre-trained models. The experiment shows that our method is not able to surpass ChatGPT. But this does not mean that our work has no value in the era of large language models.
Our method is essentially a discriminative model, while LLMs are generative models. They have different advantages. For example, LLM is better at generating coherent text, and our CohEval is better at multi-choice tasks. In fact, on TimeTravel, we use MCMC to make our CohEval applicable to generating tasks. Therefore, the gap between our method and LLM has been magnified. On discriminative tasks, although our model is not as good as ChatGPT, it outperforms the smaller ChatGLM on most multi-choice tasks. On the other hand, it is inherently unfair to directly compare small models with LLMs, as large models are obtained with massive resources, e.g., data, hardware, funding, etc. Due to resource limitations, our method is not as good as ChatGPT, but it is superior to ChatGLM, which also indicates that our method is valuable in low-resource scenarios. With sufficient computational resources, we can use a larger backbone and more data for training, which is expected to yield better results. We leave this in future works.
Ethical Considerations
This work does not involve any sensitive data, but only crowd-sourced datasets released in previous works, including RocStories (Mostafazadeh et al., 2016), COPA (Roemmele et al., 2011), e-Care (Du et al., 2022a), αNLI (Bhagavatula et al., 2020), Cloze (Mostafazadeh et al., 2016), Swag (Zellers et al., 2018), HellaSwag (Zellers et al., 2019), and TimeTravel (Qin et al., 2019). We believe that our research work meets the ethics of ACL.

heading: A Training Details about the Event Encoder
text: The event encoder is a nonlinear mapping from raw input space to latent space, fθ : X → Z . Consider a set of triplet observations, (x1, x2, x3), the goal is to ensure that fθ(x1), fθ(x2), fθ(x3) follow the Brownian bridge transition density in Equation 1. Following (Wang et al., 2022), we ensure this using a contrastive objective. Formally, given a narrative event sequences, S = {e0, · · · , e4}, we draw batches consisting of randomly sampled positive triplets e0, et, eT where 0 < t < T : B = {(e0, et, eT )}. Note that we use indices 0, t, T to denote the start, middle, and end points of a Brownian bridge, but these do not correspond to strictly sampling the first, middle, and last events of a narrative story. The encoder is optimized by,
Lf = − log exp(d(e0, et, eT ; fθ))∑ (e0,et′ ,eT )∈B exp(d(e0, et′ , eT ; fθ)) d(e0, et, eT ; fθ) = − 1 2σ2 ||fθ(et)− µ||22, (10)
where µ and σ2 are the mean and variance in Equation 1. As suggested by (Wang et al., 2022), we freeze the BART and add a non-linear layer that converts the BART output to a latent vector. The size of the latent space is set to 64 by default.
B Impact of Different Backbones for Generating Contrastive Narratives
We conduct a preliminary study on the influence of different backbones, including GPT2 (Radford et al., 2019) and T5 (Raffel et al., 2020), and BART (Lewis et al., 2019), for generating contrastive narratives. We use Fluency and ENTScore as metrics. Fluency evaluates whether the generated text is a fluent text sequence. We use off-the-shelf GPT2 to calculate Fluency. ENTScore evaluates the coherence of the generated stories. We randomly sample 2000 examples that do not exist in training for evaluation. We calculate the average result. As shown
in Table 9, GPT2 is good at generating more fluent text, and BART generates more coherent text. A possible reason is that the contrastive narrative generation is more compatible with BART’s pretraining task, e.g., masked auto-encoding. Finally, we choose BART as the backbone.

heading: C Criteria for Filtering Low-Quality Candidates
text: For each positive narrative, we generate 200 candidates. In practice, we observe that the generator may produce incoherent or duplicate candidates. Therefore, we set several rules to filter low-quality items. We first use our event-level replacement strategy to train the base evaluator MER. We use MER to filter items whose coherence scores are smaller than a threshold (empirically set to 0). Next, for each candidate, we calculate its text similarity with the remaining candidates. We gradually discard the candidates with the highest similarity until there are 100 remaining. When training Coheval, we select N top-ranked candidates according to their coherence scores for synthesizing negative samples.

heading: D Statistics and Experimental Details
text: Statistics Table 12 shows the statistics of the used datasets.
Experimental Details For training the contrastive narratives generator, we use BART-base as the backbone. Batch-size is set to 16. We use the AdamW optimizer. lr is set to 5e-5. Weightdecay is set to 1e-4. We train the generator with 10 epochs and linearly decrease the lr to zero with no warmup. When the generation phase, we kept the N = 60 most qualified contrastive narratives for creating negative examples. For training our CohEval, we adopt RoBERTa-large as the backbone. We train our model for 5 epochs, and then evaluate it on downstream tasks. We set batch-size to 1 and gradient-accumulation-steps to 16. For each positive example, we sample 15 negative examples for contrastive training. lr is set to 5e-5. Weight-decay is set to 1e-4. We use the AdamW optimizer and linearly decrease the lr to zero with a 10% warmup ratio. The random seed is set to 42 for all experiments. All experiments are performed on a Ubuntu server with 4×RTX2080Ti GPUs.

heading: E Different Backbones for Narrative Coherence Learning
text: We additionally build our method on the BERTbase (Devlin et al., 2018b) and RoBERT-base backbones, as shown in Figure 5. RoBERTa-base has a better performance than BERT-base, and the RoBERTa-large tends to have a better result than RoBERTa-base. However, due to the limitation of computing resources, we are not able to evaluate our method under larger pre-trained models.

heading: F The Prompts for Different Tasks
text: The multi-choice datasets have a similar format except for the number of choices. For simplicity, we take the HellaSwag dataset as an example. An example and its corresponding instruction are shown in Table 10. For other multi-choice datasets, we use a similar format for evaluation.

heading: G The Non-autoregressive Generation Process on TimeTravel
text: TimeTravel is a counterfactual story generation dataset. A story is defined as a five-sentence text
{z, x, y}, where the first sentence z is the premise, the second sentence x is the original condition, and the last three sentences constitute the original ending, abbreviated as y. After given a counterfactual condition denoted as x′, the task requires revising the original ending y into a counterfactual ending y′ which minimally modifies the original one and regains narrative coherency to the counterfactual condition. An example is shown in Table 11.
Existing EDUCAT (Miao et al., 2018; Chen et al., 2021) adopts the Markov chain Monte Carlo (MCMC) sampling process to this task. EDUCAT directly samples from the sentence space with three local operations: token replacement, deletion and insertion. During sampling, after an edit position is found, the operation is randomly chosen with equal probability. Finally, the proposed new sentence will either be accepted or rejected according to the acceptance rate computed by desired properties π(y). The above process is repeated till convergence.
The stationary distribution π(y) in EDUCAT is defined as the product of the fluency score and the coherence score as follows:
π(y) = XLM (y) · XCoh(y), (11)
where the fluency score XLM (y) is the probability of the generated ending based on GPT2. The coherence score XCoh(y) is defined by:
XCoh(y′) = PCoh(Y = y ′|z, x′) PCoh(Y = y′|z, x) , (12)
where PCoh(·) is the conditional probability calculated by GPT2. This definition encourages the generated y′ to be more coherent to x′ instead of x.
Following EDUCAT, we define the stationary distribution π(y) as Equation 11. The difference is that we replace XCoh(y) with our CohEval:
XCoh(y) = CohEval([z;x; y′]), (13)
where [; ] denotes the concatenation. Same as EDUCAT, we run our model and its variants for 100 steps for fairness.

heading: H The Correlation between Automatic Metrics and Human Ratings
text: Table 13 shows the correlation between automatic metrics, including ENTScore, CohEval, and human ratings in coherence. All results show a positive correlation. The result of our CohEval is similar to that of ENTScore. Notice that ENTScore is trained with human-labeled counterfactual data, while our CohEval is trained in a self-supervised manner.

heading: I Details and Results for Mixing-up in Latent Space
text: The mixup strategy creates negative examples via mixing-up a positive X and several counterparts {Xkc }Kk=1 in the latent space:
h+ = RoBERTa(X)
hkc = RoBERTa(X k c ), h̄k = αkh + + (1− αk)hkc , αk ∼ Uniform[0, 1].
(14)
Then, the loss is:
s+ = WTc h +, s̄k = WTc h̄ k,
LM = − 1|D+| ∑
D+ log
exp(s+)
exp(s+) + ∑K
k=1 exp(s̄ k)
.
(15)
The experiment setting details are the same as those used in Appendix D.

heading: J Error Cases when Creating Negative Examples
text: The most common error in event-level replacement is that the sampled event ē from Qe is especially similar to the original e, or is the paraphrase of the original e, as shown in Table 14, Case #1. The most common mistake in cross strategy is that the contrastive variant and the original story describe different actions for the same purpose, resulting in the false negative. An example is shown in Table 14, Case #2.
Overall, the proportion of errors is relatively low.

heading: K Details of Obtaining Samples in t-NSE Visualization
text: In TimeTravel, each example consists of an original story (z, x, y) and a counterfactual story (z, x′, y′), where y′ is similar to y. Motivated by (Chen et al., 2021), we obtain positive and negative samples from the perspective of natural language inference, i.e., the original context (z, x) entails by y but contradicts with y′, and the counterfactual context (z, x′) entails by y′ but contradicts with y. Because y is similar to y′, (z, x, y′) and (z, x′, y) tend to be hard negatives. Based on the test set of TimeTravel, we obtain 3742 positive examples and 3742 negative examples. Then, we use t-SNE to visualize representations of the examples that are encoded by different models.

heading: L Case Study
text: Table 15 presents a case study for the task of TimeTravel. The counterfactual endings generated by ChatGLM2 and ChatGPT are very different from the original ending, which conflicts with the minimal-edits requirement of the task. On the contrary, based on the MCMC-sampling, our method produces the counterfactual ending, which is similar to the original ending, as well as coherent to the counterfactual condition.
Table 16 presents a case study for the task of contrastive narratives generation. In the case #1, our method shifts the topic of accent to personality. In the case #2, our method exchanges the opinions
#1
Original context Tim was mad. He saw roaches in his house.
Original ending He bought some cheap bug spray. However, it did not get rid of them. Tim called an exterminator.
of two participants. Due to the limited changes, the generated story is very similar to the original story and meets the requirements for contrastive narratives. On the contrary, the middle events generated by ChatGLM2 and ChatGPT show a significant difference from that of the original story, as a result, the synthesized negative samples should be easily distinguished.

heading: Future Work
text: We leave this in future works. Ethical Considerations
This work does not involve any sensitive data, but only crowd-sourced datasets released in previous works, including RocStories (Mostafazadeh et al. , 2016), COPA (Roemmele et al. , 2011), e-Care (Du et al. , 2022a), αNLI (Bhagavatula et al. , 2020), Cloze (Mostafazadeh et al. , 2016), Swag (Zellers et al. , 2018), HellaSwag (Zellers et al. , 2019), and TimeTravel (Qin et al. , 2019)