From the One, Judge of the Whole: Typed Entailment Graph Construction with Predicate Generation
Year: 2023

Abstract:
Entailment Graphs (EGs) have been constructed based on extracted corpora as a strong and explainable form to indicate contextindependent entailment relations in natural languages. However, EGs built by previous methods often suffer from the severe sparsity issues, due to limited corpora available and the longtail phenomenon of predicate distributions. In this paper, we propose a multi-stage method, Typed Predicate-Entailment Graph Generator (TP-EGG), to tackle this problem. Given several seed predicates, TP-EGG builds the graphs by generating new predicates and detecting entailment relations among them. The generative nature of TP-EGG helps us leverage the recent advances from large pretrained language models (PLMs), while avoiding the reliance on carefully prepared corpora. Experiments on benchmark datasets show that TP-EGG can generate high-quality and scale-controllable entailment graphs, achieving significant in-domain improvement over state-of-the-art EGs and boosting the performance of down-stream inference tasks1.

heading: 1 Introduction
text: The entailment relation between textual predicates plays a critical role in natural language inference and natural language understanding tasks, including question answering (Pathak et al., 2021; McKenna et al., 2021) and knowledge graph completion (Yoshikawa et al., 2019; Hosseini et al., 2019, 2021). To detect entailment relations, previous works pay attention to the Recognizing Textual Entailment (RTE) task, which takes a pair of sentences as input and predicts whether one sentence entails the other (Bowman et al., 2015; He et al., 2021b; Pilault et al., 2020). Current RTE models perform well on RTE benchmarks, but most of
∗Corresponding author. 1Our code is available at https://github.com/
ZacharyChenpk/TP-EGG
them are lacking in explainability, as they make use of the black-box Language Models (LM) without providing any explainable clues.
Recent works focus on learning the Entailment Graph (EG) structure, which organizes typed predicates in directional graphs with entailment relations as the edges (Hosseini et al., 2018, 2019; McKenna et al., 2021), as shown in Figure 1. With the explicit graph structure containing predicates and their entailment relations, similar to Knowledge Graphs (KGs), using EGs becomes an explainable and context-independent way to represent the knowledge required in natural language inference and other NLP tasks.
Most existing EGs are constructed with the Distributional Inclusion Hypothesis (DIH), which suggests that all typical context features of a predicate v can also occur with another predicate w if v entails w (Geffet and Dagan, 2005). Constructing EGs with DIH requires distributional cooccurrences of contextual features from large corpora to calculate the semantic similarity between predicates (Szpektor and Dagan, 2008; Schoenmackers et al., 2010). However, the EGs constructed from large corpora often suffer from two different kinds of sparsity issues: the predicate sparsity and the edge sparsity. Existing corpora used for EG construction are mainly collected from
3534
specific resources (Zhang and Weld, 2013), such as news articles. As a result, entailment relations could not be learned between those predicates that do not appear in the corpora, which leads to the predicate sparsity issue. Meanwhile, if two predicates scarcely appear around similar contexts in the given corpora, the DIH could not indicate the potential entailment relationship between them. It leads to the edge sparsity of EGs as the corresponding edges may be missing due the limited coverage of the corpora.
To tackle the sparsity issues, previous works pay attention to learning global graph structures to mine latent entailment relations and alleviate the edge sparsity (Berant et al., 2011, 2015; Hosseini et al., 2018; Chen et al., 2022), but predicate sparsity is still holding back the improvement of EGs. Solving predicate sparsity by simply scaling up the distributional feature extraction is impracticable, due to the long-tail phenomenon of predicate distribution (McKenna and Steedman, 2022).
The shortcomings of extractive methods come in quest for non-extraction way to overcome. Recent progress in deep generative LMs, including GPT3 (Brown et al., 2020) and T5 (Raffel et al., 2022), makes it possible to produce predicates and entailment relations by generative methods. Inspired by the Commonsense Transformer (Bosselut et al., 2019), we propose a novel generative multi-stage EG construction method, called Typed PredicateEntailment Graph Generator (TP-EGG). As shown in Figure 2, TP-EGG takes several seed predicates as input of the LM-based predicate generator to depict the domain of predicates and generate more in-domain predicates. With generated predicates, TP-EGG uses a novel transitivity-ensured edge se-
lector by representing predicates as spheres in the vector space, to pick out the potential entailment relations among generated predicates. Then TP-EGG calculates the corresponding edge weights by the LM-based edge calculator. Our key insight is that by re-modeling the predicate extraction process as a generation process, we can leverage the underlying knowledge about natural language inference inside the LMs to avoid the data sparsity issues of extractive methods. By choosing appropriate seed predicates and setting the parameters of TP-EGG, one can generate EGs containing knowledge from a specific domain in arbitrary scales to fit the downstream requirement, without limitations from the uncontrollable distribution in domain-independent corpora. Since almost all the EG construction modules in TP-EGG is controlled by pre-trained LMs, the output EGs can be seen as explicit representations of the knowledge in LMs and used in downstream tasks, such as RTE in our experiments.
In a word, our contributions can be summarized as follows: (1) We propose a novel generative EG construction method to alleviate the data sparsity issues on generated EGs and avoid the reliance on corpora preparation in traditional EG methods; (2) We propose a new method to evaluate the quality of EGs in downstream tasks such as RTE; (3) Our TP-EGG outperforms strong baselines with significant improvement on benchmark datasets, and we show that generation-based EGs methods can alleviate the predicate sparsity by leveraging pre-trained LMs as predicate generators.

heading: 2 Related Work
text: Previous EG construction methods construct feature representations for typed predicates, weighted
by counts or Pointwise Mutual Information (Berant et al., 2015), and compute the distribution similarity guided by DIH. For a predicate pair, different similarities are calculated, such as cosine similarity, Lin (Lin, 1998), Weed (Weeds and Weir, 2003), and Balanced Inclusion (Szpektor and Dagan, 2008). Markov chain of predicate-argument transition (Hosseini et al., 2019) and temporal information from extracted corpora (Guillou et al., 2020) are also used in EGs construction. These methods independently calculate the entailment relations for each pair, called local methods. Besides, global constraints are used to detect new entailment relations beyond local relations. The transitivity in EGs, which means a entails b and b entails c indicate a entails c for three predicates a, b and c, is the most widely used in previous works as hard constraints (Berant et al., 2011, 2015) or soft loss functions (Hosseini et al., 2018; Chen et al., 2022). The weight similarity constraints between different typed EGs and similar predicates are also taken into consideration (Hosseini et al., 2018).
As one of the most important areas of NLP, text generation, or Natural Language Generation (NLG), has also been advanced by the surgent development of pre-trained LMs. BART (Lewis et al., 2020) uses encoder-decoder transformer architecture to re-correct the corrupted data in pre-training phase; GPT-3 (Brown et al., 2020) uses transformer decoder to achieve in-context learning with massive multi-task unsupervised data. T5 (Raffel et al., 2022) unifies different tasks into natural language prefixes and solves them by text generation.
Pre-trained LMs are also applied in recent EG methods. CNCE (Hosseini et al., 2021) initializes the contextualized embeddings of entity-relation triplets by BERT (Devlin et al., 2019) and uses random walk to get the entailment probability; EGT2 (Chen et al., 2022) fine-tunes a patternadapted LM on the predicate sentences and recalculates high-quality edge weights for global constraints; McKenna and Steedman (2022) applies RoBERTa (Liu et al., 2019) as predicate encoder and matches missing predicates in EGs with KNearest Neighbor algorithm to alleviate the predicate sparsity. As far as we are concerned, our method is the first attempt to use generative LM in EG construction and directly generate EGs without the distributional features from large corpora.

heading: 3 Our Approach
text: EGs store predicates as nodes and entailment relations between them as edges in graph structures. Following previous EG methods (Hosseini et al., 2018, 2019; Chen et al., 2022), we use the neo-Davisonian semantic form of binary relation (Parsons, 1990) to indicate typed predicates, whose types are defined by the combination of argument types. Predicate p connecting two arguments a1, a2 with types t1, t2 can be represented as p = (w1.i1, w2.i2, t1, t2), where wj is the center relation tokens (and perhaps prepositions) about aj , and ij is corresponding argument order of aj in wj . For example, the event "The government is elected in 1910 and adored by natives" contains two predicates (elect.2, elect.in.2, government, time) and (adore.1, adore.2, person, government). We denote P as the collection of all typed predicates, T as the collection of all argument types, and τ1, τ2 : P → T as type indicator functions, where τ1(p) = t1 and τ2(p) = t2 for any predicate p = (w1.i1, w2.i2, t1, t2).
We formally define that a typed entailment graph G(t1, t2)=<P (t1, t2), E(t1, t2)> includes the collection of typed predicates P (t1, t2) = {p|(τ1(p), τ2(p)) ∈ {(t1, t2), (t2, t1)}}, and the directional weighted edge set E(t1, t2), which can be represented as an adjacent matrix W (t1, t2) ∈ [0, 1]|P (t1,t2)|×|P (t1,t2)|. For those G(t1, t2) whose t1 ̸= t2, the order of types t1, t2 is naturally determined. When t1 = t2 = t, argument types are ordered such that G(t, t) can determine the order of types like "Thing A" and "Thing B" to distinguish predicates like "Thing A eat Thing B" and "Thing B eat Thing A". This order obviously affect the meaning of predicates, as “Thing A eats Thing B” entails “Thing B is eaten by Thing A”, but “Thing eats Thing” is doubtful to entail “Thing is eaten by Thing”.

heading: 3.1 Predicate Generation
text: In order to avoid the predicate sparsity issue in a given corpus, TP-EGG uses a predicate generator G to generate novel in-domain predicates. G takes a set of seed predicates Pseed ⊂ P (t1, t2) as input and outputs a set of generated predicates PG , where Pseed are expected to contain the domain knowledge of required EGs and PG should be semantically related to Pseed in varying degrees.
Our G is designed to be based on generative LMs, thus the input predicates p ∈ Pseed should
be converted into natural language forms to fit in the LMs. We use Chen et al. (2022)’s sentence generator S to convert predicate p into its corresponding sentence S(p). For example, p = (elect.2, elect.in.2, government, time) will be converted into Government A is elected in Time B. With converted sentences, generator G uses a generative LM, T5-large (Raffel et al., 2022) in our experiments, to generate new sentences and then re-converts them into generated predicates by a sentence-predicate mapping function S−1 (details in Appendix C). Starting from the seed sentences S0 = {S(p)|p ∈ Pseed}, the generative LM outputs sentences S1 for the next step, and S1 is used to generate S2 and so on, while S−1 is used to re-convert Si to Pi = S−1(Si) for every step. The generation process continues until the union of seed predicates and generated predicates P ′i = Pseed ∪ P1... ∪ Pi is equal to P ′i−1 or its size |P ′i | exceeds a pre-defined scale parameter Kp.
To use T5-large as the generation component, we need to design an input template to generate new sentences. For sentence s ∈ Si, the input template will be constructed like: s, which entails that t1 A <extra_id_0> t2 B. s, which entails that t2 B <extra_id_0> t1 A. where <extra_id_0> is the special token representing the generating location of the T5-large output. The max length of stripped output sequence s′ is limited to 5, and the new predicate p′ is produced by S−1("t1 A s′ t2 B.") or S−1("t2 B s′ t1 A.") correspondingly. For each s, T5-large uses beam-search algorithm with beam size Kbeam to find top-Ksent output sequences s′ with highest probabilities.
To ensure the quality of generated predicates and filter noisy ones, only those predicates which are generated by T5-large from at least two different predicates in P ′i−1 could be included in Pi. Algorithm 1 depicts how predicate generator G works (more details and exmaples in Appendix D).

heading: 3.2 Edge Selection
text: After generating new predicates P (t1, t2) = PG , TP-EGG constructs G(t1, t2) by generating weighted edge set E(t1, t2). As TP-EGG does not use large corpora to calculate distributional features regarding context coherence, we need to determine which predicate pairs could be potential entailment relations for later calculation. Regarding ALL pairs as candidates is a simple solution, but when P (t1, t2) scales up, calculating all |P |2 pairs
Algorithm 1 The predicate generator G. Require: A set of seed predicates Pseed, sentence generator
S, parameter Kbeam,Ksent,Kp Ensure: A set of generated predicates PG 1: Ponce = {} 2: i = 0, P0 = P ′0 = Pseed 3: while |P ′i | ≤ Kp do 4: Si = {S(p)|p ∈ Pi} 5: Pi+1 = {} 6: for s ∈ Si do 7: Sg = T5(s,Kbeam,Ksent) 8: P g = Set(S−1(sg)|sg ∈ Sg) 9: P g = P g − P ′i 10: Pi+1.update(P g ∩ Ponce) 11: Ponce = Ponce XOR Pg 12: end for 13: Pi+1 = Pi+1 − P ′i 14: P ′i+1 = P ′ i ∪ Pi+1 15: if P ′i+1 = P ′i then 16: return PG = P ′i 17: end if 18: i = i+ 1 19: end while 20: return PG = P ′i
will be unacceptably expensive as we intend to adopt an LM-based edge weight calculator, which only takes one pair as input at a time. Therefore, we require an effective edge selector M to select potential pairs E′ ⊂ P (t1, t2)×P (t1, t2) with acceptable computational overhead, where |E′| should be equal to a given parameter Kedge.
Calculating embeddings for each predicate and quickly getting similarities between all pairs in P (t1, t2) perform worse than pair-wise LMs with cross attention in general, but are good enough as the edge selector to maintain high-quality pairs in high ranking. Inspired by Ristoski et al. (2017), we represent predicate p as a sphere in the vector space. TP-EGG uses BERT-base (Devlin et al., 2019) to calculate embedding vector vp for every predicate p based on S(p), and represents p as a sphere ⊙p in a vector space with center cp and radius rp:
vp = BERT (S(p)) ∈ Rdv , cp = fc(vp) ∈ Rdc , rp = f +(fr(vp)) ∈ R+. (1)
where fc, fr are two-layer trainable neural networks, dv, dr are corresponding vector dimensions, f+(x) ∈ {exp(x), x2} ensures the positive radius. By representing p as a sphere, we expect that when p entails q, ⊙q should enclose ⊙p, as all points in ⊙p are also included in ⊙q. Under such assumption, the transitivity referred in Section 2 is naturally satisfied as ⊙a ⊂ ⊙b ⊂ ⊙c. The overlapping ratio between spheres can be seen as the entail-
ment probability Pr(p → q), and we simplify the calculation of sphere overlapping to diameter overlapping along the straight line between two centers:
dpq = ||cp − cq||2
Pr(p → q) =    0 , rq ≤ dpq − rp 1 , rq ≥ dpq + rp rp+rq−dpq
2rp , otherwise
(2) Chen et al. (2022) defines soft transitivity as Pr(a → b)Pr(b → c) ≤ Pr(a → c) for all predicate pairs above a threshold. Similar in spirit, our simplified sphere-based probability holds transitivity in part:
Theorem 1 Given a threshold ϵ ∈ (0, 1), ∀a, b, c where Pr(a → b) > ϵ and Pr(b → c) > ϵ, we have Pr(a → c) > ϵ− (1− ϵ) rbra . We give its proof in Appendix A. Noted that while ϵ is close to 1, the right part ϵ − (1 − ϵ) rbra will be nearly equal to ϵ. As we use this probability in edge selection, higher Pr(a → b) and Pr(b → c) will naturally ensure the appearance of (a, c) in final entailment relations, without the disturbance from low-confident edges. As Pr(p → q) is constant when rq ≤ dpq − rp or rq ≥ dpq + rp, its gradient becomes zero which makes it untrainable. Therefore, we smooth it with order-preserving Sigmoid function and interpolation, and finally get the selected edge set for G(t1, t2):
M(p, q) = σ(2rq − 2dpq rp ),
E(t1, t2) = {topKedge(M(p, q))|p, q ∈ V (t1, t2)} (3) where σ is Sigmoid function σ(x) = 1/(1+ex). A geometrical illustration presenting how the selector M works can be found in Appendix B.

heading: 3.3 Edge Weight Calculation
text: With the selected edge set E(t1, t2) ⊂ P (t1, t2)× P (t1, t2), TP-EGG calculates the edge weight Wp,q for each predicate pairs (p, q) individually in the adjacent matrix W (t1, t2). Inspired by Chen et al. (2022), as the distributional features of generated predicates are unavailable for TP-EGG, we re-implement their local entailment calculator W to obtain the entailment edge weight Wp,q. W is based on DeBERTa (He et al., 2020, 2021a) and fine-tuned to adapt to the sentence patterns generated by S. The entailment-oriented LM will produce three scores, corresponding to entailment (E),
neutral (N) and contradiction (C) respectively, for each sentence pair. The score of entailment class is used as the entailment edge weight in our EGs:
Wp,q = W(p, q) = exp(LM(E|p, q))∑
r∈{E,N,C} exp(LM(r|p, q)) (4)
where LM(r|p, q) is the score of class r. After calculating all predicate pairs (p, q) ∈ E(t1, t2) by the LM-based calculator W , TP-EGG completes the adjacent matrix W (t1, t2), and consequently constructs G(t1, t2), as shown in Figure 2.

heading: 4 Experimental Setup
text: Datasets. Following previous works (Hosseini et al., 2018, 2019, 2021; Chen et al., 2022), we include Levy/Holt Dataset (Levy and Dagan, 2016; Holt, 2018) and Berant Dataset (Berant et al., 2011) into EG evaluation datasets. Besides, we reorganize the SherLIiC Dataset (Schmitt and Schütze, 2019), a dataset for Lexical Inference in Context (LIiC), into an EG benchmark. We further reannotate conflicting pairs in Levy/Holt, referred as Levy/Holt-r Dataset. Dataset statistics are shown in Table 1. More details can be found in Appendix F.
Metrics. Following previous works, we evaluate TP-EGG on the test datasets by calculating the area under the curves (AUC) of Precision-Recall Curve (PRC) for precision>0.5 and traditional ROC curve.2 The evaluated EGs are used to match the predicate pairs in datasets and return the entailment scores. Noted that our generated predicates might be semantically same with required ones but have different forms, like (use.2,use.in.2,thing,event) and (be.1,be.used.in.2,thing,event) are both reasonable for "Thing A is used in Event B" while our S−1 generates the first one. Hence we relax the predicate matching standard in evaluation from exactly matching to sentence matching, i.e., S(p) = S(p′)
2We have found that the evaluation scripts written by Hosseini et al. (2018) do not connect the curve with (1,0) and (0,1) point correctly, which wrongly decreases the performance. We fix and use the scripts to generate results in this paper.
rather than p = p′. This modification has nearly no effect on previous extraction-based EGs, but can better evaluate generative methods..
Implementation Details. In experiments, TPEGG uses BERT-base in M and T5-large in G implemented by the Hugging Face transformer library (Wolf et al., 2020)3, and DeBERTa reimplementation from Chen et al. (2022) to finetune on MNLI and adapt to sentence pattern in W . Taking both EG performance and computational overhead into account, we set Kp = 5× 103, Kedge = 2 × 107, Kbeam = 50, Ksent = 50, dr = 16, dv = 768. Discussion about Kp and Kedge can be found in Appendix E.
For EG generation, TP-EGG uses the predicates in validation set of Levy/Holt-r and SherLIiC Dataset respectively as the seed predicate Pseed. With different Pseed, we also only use corresponding validation set as the training data for all later modules to keep the EGs in-domain, called TPEGGL/H−r and TP-EGGSherLIiC respectively.
Only positive pairs are used to generate the training inputs and outputs to fine-tune T5-large in the predicate generator G with learning rate αG = 10−3. We use f+(x) = exp(x) for TPEGGL/H−r and f+(x) = x2 for TP-EGGSherLIiC . The edge selector M is also trained by the validation predicate pairs, but the positive examples are repeat 5 times (for Levy/Holt-r) or 2 times (for SherLIiC) to alleviate the label imbalance in training. BERT-base parameters are trained with learning rate αM,1 = 10−5, while other parameters, including fc and fr, are trained with learning rate αM,2 = 5× 10−4. The edge weight calculator W is trained by the same method in Chen et al. (2022).
All modules are trained by AdamW optimizer (Loshchilov and Hutter, 2018) with cross entropy loss function, and controlled by early-stop mechanism, which stops the training when performances (loss for G and F1 for others) on validation set do not reach the highest in the last 10 epoches. It takes about 5-6 hours to train all modules in TPEGG, and about 2-3 hours to generate a typed EG on GeForce RTX 3090. The three modules, G,M and W , contain 738M, 109M and 139M parameters respectively.
To be comparable with previous works (Hosseini et al., 2018), we apply their lemma-based heuristic
3https://github.com/huggingface/transformers
on all datasets except SherLIiC, and their average backup strategy on all datasets.
Compared Methods We compare TP-EGG with the best local distributional feature, Balanced Inclusion or called BInc (Szpektor and Dagan, 2008), and existing state-of-the-art local and global EG construction methods, including Hosseini et al. (2018, 2019), CNCE (Hosseini et al., 2021) and EGT2 (Chen et al., 2022).
Downstream Task. Despite of evaluating on EG construction benchmarks, we adapt an LM-based three-way RTE framework into the EG evaluation testbed. For premise pm and hypothesis h, RTE models take their concatenation [pm;h] as inputs, and return three probability scores of three classes. In order to incorporate the knowledge in EGs into RTE models, we design the following architecture available to any LM-based RTE model: given pm and h, we extract binary predicates from them, and try to match the predicates in our EGs. Each matched predicates a in premise pm will be replaced by its Knbr neighbors b with highest weight Wab. For h, the neighbors b are with highest weight Wba. Replaced sentences pm1, ..., pmj and h1, ..., hk for pm and h will be concatenated to represent the information from EGs in calculation:
(sE1, sN1, sC1) = Softmax(LM1([pm;h])),
(sE2, sN2, sC2) = Softmax(LM2([pm;
pm1; ...; pmj ;h;h1; ...;hk])),
si = (si1 + si2)/2, i ∈ {E,N,C}.
(5)
where LM1 and LM2 represent two different LMs followed by a linear layer respectively. As the additional calculation unfairly requires more parameters, we also consider the models with equal parameters but do not use the EGs, referred as NO-EG setting, by inputting [pm;h] into LM2 directly. We use SNLI (Bowman et al., 2015) and SciTail (Khot et al., 2018) as our RTE benchmark datasets. We use BERT-base and DeBERTa-base as the backbone, learning rate αRTE = 10−5, Knbr = 5 for SNLI and Knbr = 3 for SciTail.

heading: 5 Results and Analysis

heading: 5.1 Main Results
text: The performance of different EGs on benchmark datasets are shown in Table 2, and the PrecisionRecall Curves of EGs on Levy/Holt-r and Berant datasets are presented in Figure 3. Without
using extracted features from large corpora, TPEGG achieves significant improvement or at least reaches comparable performance with baselines for in-domain evaluations (L/H and L/H-r for TPEGGL/H−r and SherLIiC for TP-EGGSherLIiC). Interestingly, TP-EGG always performs better on the AUC of PRC, which indicates the strong ability of our generative methods to maintain impressive recall with high precision as shown in the curves. On Levy/Holt-r, TP-EGGL/H−r significantly outperforms all other extraction-based methods on precision>0.5, showing that with higher classification threshold, extraction-based methods fail to detect the entailment relations between rare predicates due to the sparsity issues, while generation-based TP-EGG successfully finds these relations by generating more predicates and correctly assigns high probabilities between them.
Noted that our TP-EGG is a local method, although certain global properties are ensured by our edge selector M. We try to apply a state-of-the-art global method, EGT2-L1 (Chen et al., 2022) on our local EGs4. As shown in the bottom of Table 2, the global method further improves the performance of TP-EGG, demonstrating the potential of our local EGs to continuously reducing the data sparsity with global EG learning methods.
Although we have observed the significant improvement of evaluation metrics by TP-EGG, it is not clear enough to determine TP-EGG can alleviate the predicate sparsity to what extent. Therefore, we count the predicate pairs in Levy/Holt testset that exactly appeared as edges in EGs. We find
4Chen et al. (2022) reports that L3 variant performs better on their local graphs, but we find L1 is better on TP-EGG.
that 6,873 pairs appear in TP-EGGL/H−r, meanwhile 875 in EGT2-L3. The far more appearance of in-domain predicates indicates the alleviation of predicate sparsity.
Previous works have claimed that LMs for entailments might be strong in undirectional paraphrasing, but weak in directional entailment recognizing (Cabezudo et al., 2020; Chen et al., 2022). To check out the directional entailment ability of TPEGG and other methods, we evaluate them on the directional portion5 of Levy/Holt Dataset as shown in Table 3. The directional portion contains entailment pairs (p, q) where (p → q)XOR(q → p) is
5https://github.com/mjhosseini/entgraph_eval/ tree/master/LevyHoltDS
True, and therefore symmetric models will have AUC<0.5. TP-EGG performs better than baselines on the directional portion, and the AUC far higher than 0.5 indicates its directional entailment ability. Global models perform better here, which is reasonable as global constraints are strongly related to the directional reasoning.

heading: 5.2 Learning with Multiple Domains
text: Although TP-EGG performs well on in-domain evaluation, the out-domain scenario is still hard, as the knowledge required for out-domain evaluation is inaccessible in all training and generation steps of TP-EGG. To check the impact of training data domains in different modules of TP-EGG, we use Levy/Holt-r and SherLIiC Dataset to produce seed predicates Pseed and train different modules, including predicate generator G, edge selector M and weight calculator W , with different combinations of two datasets. As shown in Table 4, involving indomain training data into more modules will lead to higher performance on corresponding dataset in general, which is in accordance with expectation.
Interestingly, by comparing different combinations, we find that fine-tuning G with data from do-
mains different with Pseed will lead to better overall performance on two datasets. For example, row ③ attains improvement about 0.15 on SherLIiC with dropping about 0.11 on Levy/Holt-r by changing training data of G from Levy/Holt-r (①) to SherLIiC, and when Pseed also changes to SherLIiC (⑦), the performance on Levy/Holt-r is severely damaged without benefit to SherLIiC. Similar situation is also observed in row ②,④ and ⑧. We assume that involving knowledge from different domains in predicate generation, i.e. Pseed and G, could alleviate the over-fitting by mixing two predicate domains and encouraging G to find more novel predicates to cover the gap between training and testing. Empirically, involving different data in G leads to the best performance among the modules.
Next, we study the effect of using merged validation sets of Levy/Holt-r and SherLIiC Dataset at different modules. The performance of TP-EGG trained with the merged data, referred as L+S, are shown in Table 5. While using merged data as Pseed and also as training data for other modules (❶), TP-EGG reaches impressive performances on both datasets, which is not surprising, as both datasets are in-domain in this situation.
Using merged dataset to train G,M and W boosts out-domain performance with in-domain performance loss (comparing ❷ and ❹, ❺ and ❼). However, adding some out-domain predicates into Pseed is surprisingly beneficial to the in-domain evaluation while improving out-domain generalization (comparing ❷ and ❸, ❺ and ❻). We attribute it to the diversity of generated predicates led by the newly incorporated seed predicates, which might not be generated with the in-domain seed predicates. The out-domain predicates help TP-EGG to find new predicates related to in-domain predicates as Algorithm 1 might tend to generate predicates
from at least two predicates across two domains. Therefore, the predicate coverage over evaluation datasets can be increased.

heading: 5.3 Results on RTE
text: In downstream task evaluation, we use EGs generated by different methods to enhance LM-based RTE models, and report the results in Table 6. Compared with CNCE and EGT2, our TP-EGG achieves better performance on two RTE datasets with both BERTbase and DeBERTabase backbones. The performances of TP-EGG on DeBERTabase are significantly better than NO-EG (p<0.05). Noted that TP-EGG offers pmj , hk for 4,600 sentences in SNLI testset, which is 5,596 for EGT2-L3. Even with lower coverage over predicates in the dataset, TP-EGG supports RTE models with more highquality entailment relations to generate pmj , hk and improve the performance. On the other hand, the noisy entailment relations in CNCE and EGT2 perhaps misguide RTE models, thus lead to even worse results than NO-EG in some cases.

heading: 5.4 Ablation Study
text: We run the ablation experiments which directly use the original version of LMs in G,M and W without fine-tuning on EG benchmark datasets. For M, as non-LM parameters are involved, we replace it with randomly selecting Kedge edges. As shown in Table 7, without fine-tuning G or W , the performance on Levy/Holt-r suffers a significant drop (about 0.1), indicating the importance of fine-tuned modules for EG generation. The performance on SherLIiC also decreases severely without fine-tuning G, as the fine-tuning step can improve the quality of generated predicates and cover
more out-domain predicates. Fine-tuning W critically affects the result on Berant Dataset, which is compatible with the results in Chen et al. (2022), showing the importance of fine-tuning and pattern adaptation in weight calculation on this dataset. Fine-tuning M is mainly beneficial to SherLIiC by comparison. From the results, we can see that high quality predicate pair construction from G and M is more beneficial to out-domain evaluation, while the weight calculation from W plays a more important role for in-domain cases.

heading: 6 Conclusions
text: In this work, we propose a novel generative typed entailment graph construction method, called TPEGG, with predicate generation, edge selection and calculation modules. TP-EGG takes several seed predicates as input to the predicate generator to find novel predicates, selects potential entailment predicate pairs as edges, and calculates the edge weights without distributional features. TP-EGG can construct high-quality EGs with flexible scales and avoid the data sparsity issues to some extent. Experiments on EG benchmacks and RTE task show the significant improvement of TP-EGG over the state-of-the-art EG learning methods. We find that mixing data from different domains in different ways can improve the generalization of TP-EGG in varying degrees, and using out-domain data in predicate generation modules brings the most significant improvement.
Limitations
First, as we do not rely on specific corpora and avoid the shortcomings of extractive methods, we also lose their advantages. The typed EGs generated by our TP-EGG is strongly related to the seed predicates and training data of generation modules, while extractive EGs can generate domainindependent EGs from large corpora and do not require supervised training data to a considerable degree. Second, the edge calculator W is time-
consuming even we can control the scales of output EGs, as the edge num |E(t1, t2)| will be relatively large for TP-EGG to generate powerful EGs. Furthermore, how to effectively select seed predicates still remains a difficult problem which has not been discussed thoroughly in this work by using the validation datasets. We assume that this problem could be solved by carefully confirming how the seed predicates represent corresponding domain knowledge and we leave it to future work.
Ethics Statement
We re-annotate the Levy/Holt Dataset which is a publicly available dataset for entailment graph evaluation. Annotators receive a competitive pay of about 100 yuan per hour under the agreement of the institute, which is more than 4 times the local minimum wage. The annotation complies with the ACL Code of Ethics. The sentences used in annotation are generated from the original dataset and we do not incorporate external content into the sentences. However, there may still be sentences containing potentially improper content, which do not reflect the views or stances of the authors. The re-annotation results are confirmed by the majority voting of annotators, and may still contain natural errors. Further usage of the re-annotated dataset should be aware of the limitation and the authors are not responsible for any issues in further usage of this dataset.

heading: Acknowledgements
text: This work is supported in part by NSFC (62161160339). We would like to thank the anonymous reviewers for their helpful comments and suggestions.

heading: A The Proof of Theorem 1
text: Theorem 1 Given a threshold ϵ ∈ (0, 1), ∀a, b, c where Pr(a → b) > ϵ and Pr(b → c) > ϵ, we have Pr(a → c) > ϵ− (1− ϵ) rbra .
As Pr(p → q) = rp+rq−dpq2rp holds when dpq − rp < rq < dpq + rp, and Pr(p → q) = 1 ≤ rp+rq−dpq
2rp holds when rq ≥ dpq + rp, we have:
ra + rb − dab 2ra ≥ Pr(a → b) > ϵ
→ dab < rb + (1− 2ϵ)ra. (6)
Similarly, for b, c:
dbc < rc + (1− 2ϵ)rb. (7)
For the case Pr(a → c) = 1, obviously the theorem holds for ϵ ∈ (0, 1);
For the case Pr(a → c) = 0 or Pr(a → c) = rp+rq−dpq
2rp , we have Pr(a → c) ≥ rp+rq−dpq2rp as rp + rq − dpq < 0 under Pr(a → c) = 0, and therefore:
Pr(a → b)
≥ra + rc − dac 2ra ≥ra + rc − (dab + dbc) 2ra (dac ≤ dab + dbc) > ra + rc − (rb + (1− 2ϵ)ra + rc + (1− 2ϵ)rb)
2ra
= ϵra + (ϵ− 1)rb
ra
=ϵ+ (ϵ− 1) rb ra . (8) Q.E.D.

heading: B Geometrical Illustration of Edge Selector M
text: To understand how the edge selector M works more intuitively, we pick four predicate sentences from Levy/Holt Dataset and visualize their corresponding spheres ⊙p in Figure 4: p0: Living Thing A is imported from Location B.
p1: Living Thing A is native to Location B. p2: Living Thing A is found in Location B.
p3: Living Thing A is concentrated in Location B. The centers cp and radius rp are generated by M from our final TP-EGG model, while the dimension of cp are reduced to maintain the distances between them. Three entailment relations, p0 → p1, p1 → p2 and p3 → p2, are annotated in the dataset, and p0 → p3 is also plausible. In Figure 4, the hypothesis spheres obviously enclose premise spheres, and the more generic a predicate
is, the bigger its sphere becomes, which is consistent with our expectation about M. With high directional overlapping, all of the four entailment relations will correctly appear in later weight calculation while low-confident inverse edges will be filtered out.

heading: C The Sentence-Predicate Mapping Function S−1
text: The sentence-predicate mapping function S−1 used in predicate generation is described in Algorithm 2. Noted that S−1 is a simplified approximation of the reverse function of sentence generator S while different predicates might generate the same sentence by S. Therefore, S−1 does not cover all possible predicates and sentences.
Algorithm 2 The mapping function S−1. Require: A generated sentence s. Ensure: A predicate p, or NULL indicating that s is not a
valid predicate sentence. 1: Split the sentences into tokens l and strip t1 A, t2 B 2: prefix="" 3: if |l| = 0 then 4: return NULL 5: end if 6: if not or n’t in l[0] then 7: prefix=NEG // representing the negation 8: end if 9: Remove the modal verbs in l
10: if l begins with have been or has been then 11: l=l[1:] 12: end if 13: if |l| > 1 and l[: 2] is have+P.P. then 14: l=l[1:] 15: end if 16: if |l| > 2 and the present tense of l[: 2] is have to then 17: l=l[2:] 18: end if
19: if |l| = 0 then 20: return NULL 21: end if 22: ihead = 0, itail = |l| − 1 23: while ihead ≤ itail and l[ihead] is not a verb do 24: ihead = ihead + 1 25: end while 26: while ihead ≤ itail and l[itail] is not a verb or a preposi-
tion do 27: itail = itail − 1 28: end while 29: if ihead > itail then 30: return NULL 31: end if 32: l′ = l[ihead : itail + 1] // cut the token between ihead
and itail 33: if l′[0 : 2] is a verb like be doing then 34: l′ = l′[1 :] 35: end if 36: t = lemmatize(l′[0]) 37: if t is be then 38: if |l′| = 1 then 39: return prefix+(be.1, be.2, t1, t2) 40: end if 41: if l′[1] is not a preposition then 42: if l′[1] is an adverb then 43: l′ = l′[0 : 1] + l′[2 :] 44: end if 45: if l′[1] is an adjective or a noun, and l′[−1] is a
preposition then 46: l′[1] = lemmatize(l′[1]) 47: return prefix+(l′[1].1, l′[1 :].2, t1, t2) 48: end if 49: if l′[1] is P.P. verb then 50: l′[1] = lemmatize(l′[1]) 51: if l′[−1] is a preposition then 52: return prefix+(l′[1].2, l′[1 :].2, t1, t2) 53: else 54: return prefix+(l′[1].2, l′[1 :].3, t1, t2) 55: end if 56: end if 57: end if 58: return NULL 59: end if 60: l′[0] = lemmatize(l′[0]) 61: if |l′| = 1 then 62: return prefix+(l′[0].1, l′[0].2, t1, t2) 63: end if 64: if l′[−1] is a preposition then 65: return prefix+(l′[0].1, l′.2, t1, t2) 66: end if 67: return NULL

heading: D An Example of Generating Predicates from Seed Predicates
text: We show an example process of generating new predicates by the generator G of TP-EGG in Table 8. We set Pseed = {p1, p2, p3}, Kbeam = Ksent = 8, Kp = 15. The predicates repeating in current generation or appearing in previous stages, and sentences that cannot be resolved by S−1 are omitted. Predicates generated from at least two different s are in red, and predicates appeared in generation of previous steps are in blue. According to Algorithm 1, only seed predicates and colored predicates will

heading: 1000 2000 5000 10000 20000
text: appear in final predicate set P ′2.

heading: E Discussion about Graph Scales
text: As referred in Section 4, we set the number of predicates Kp = 5× 103 and edges Kedge = 2× 107, which determine the final scale of generated EGs. We report the performance of TP-EGGL/H−r on the evaluation datasets with different Kp and Kedge in Figure 5. Changing Kp from 1× 103 to 2× 104, the overall performance is the best while Kp = 5× 103. We assume that lower Kp might limit the coverage of predicate set, while higher Kp makes the EGs more sparse and miss potential entailment relations. Noted that the computational overhead and space occupation is almost proportional to Kedge, setting Kedge = +∞ to regard ALL pairs as candidates is impractical (the largest EG in TPEGGL/H−r will contain 7× 107 edges). We find that Kedge = 2 × 107 is able to reach the overall performances comparable with Kedge = +∞ under our settings, while further decreasing Kedge will significantly cut down the performances. To balance between the overall performance and computational overhead, we finally set Kp = 5× 103 and Kedge = 2× 107.

heading: F Details about Datasets
text: Levy and Dagan (2016) uses questions and candidate answers with textual predicates to collect the entailment relations, and proposes a widely used
EG evaluation dataset which is later re-annotated by Holt (2018), called Levy/Holt Dataset. For example, if the annotator figures out that "The government is adored by natives" can be used to answer "Who recognize the government?", the dataset will indicate that "adore" entails "recognize" between type person and government. Levy/Holt Dataset contains 18,407 predicate pairs (14,491 negative and 3,916 positive). We use the 30%/70% splitting of validation/test set as Hosseini et al. (2018) in our experiments.
However, because the QA annotation form incorporates additional information about entities related to the predicates, some consistent predicates pairs are annotated with different labels, and the transitivity is disobeyed between some predicate pairs. The inconsistent pairs are those (a, b) which (a, b, T rue) and (a, b, False) both appear in the dataset. The transitivity-disobeying pairs are those (a, b), (b, c) and (a, c) which (a, b, T rue), (b, c, T rue) and (a, c, False) all appear. We find that there are 89 inconsistent pairs and 159 transitivity-disobeying pairs in Levy/Holt Dataset, and re-annotate these 248 pairs by five annotators with Fleiss’ κ = 0.43. After re-annotating, we get the final Levy/Holt-r Dataset with 14,490 negative and 3,777 positive pairs.
Berant et al. (2011) proposes an annotated entailment relation dataset, containing 3,427 positive and 35,585 negative examples, called Berant Dataset.
Schmitt and Schütze (2019) extracts verbal relations from ClueWeb09 (Gabrilovich et al., 2013) based on Freebase (Bollacker et al., 2008) entities, and splits the extracted relations into typed one based on their most frequent Freebase types, which is naturally compatible to typed EG settings. We use their manually-labeled 1,325 positive and 2,660 negative examples in our EG benchmark, called SherLIiC Dataset. The dataset is split into 25%(validation) and 75%(test) in our experiments.
Stage Predicates and Sentences Pseed(S0) p1 :(adore.1, adore.2, person,government) (Person A adores Government B),
p2 :(recognize.1, recognize.2, person,government) (Person A recognizes Government B), p3 :(know.1, know.2, person,government) (Person A knows Government B)
Sg(P g) p1 →{Person A is identified with Government B. (identify.2, identify.with.2, person,government), Person A is Government B. (be.1, be.2, person,government), Government B is magnet for Person A. (magnet.1, magnet.for.2, government,person), Government B is worshipped in Person A. (worship.2, worship.in.2, government,person), Government B is drawn to Person A. (draw.2, draw.to.2, government,person), Person A is devoted to Government B. (devote.2, devote.to.2, person,government), Person A is associated with Government B. (associate.2, associate.with.2, person,government), Government B is magnet of Person A. (magnet.1, magnet.of.2, government,person)} p2 →{Government B is family of Person A. (family.1, family.of.2, government,person), Government B is associated with Person A. (associate.2, associate.with.2, government,person), Person A identifies with Government B. (identify.1, identify.with.2, person,government), Government B is drawn to Person A. (draw.2, draw.to.2, government,person), Person A is associated with Government B. (associate.2, associate.with.2, person,government), Person A identifies with Government B. (identify.1, identify.with.2, person,government), Person A is connected with Government B. (connect.2, connect.with.2, person,government), Government B wants Person A. (want.1, want.2, government,person)} p3 →{Government B is associated with Person A. (associate.2, associate.with.2, government,person), Person A identifies with Government B. (identify.1, identify.with.2, person,government), Government B awards Person A. (award.1, award.2, government,person), Government B is drawn to Person A. (draw.2, draw.to.2, government,person), Person A embodies Government B. (embody.1, embody.2, person,government), Person A is associated with Government B. (associate.2, associate.with.2, person,government), Person A is connected with Government B. (connect.2, connect.with.2, person,government), Government B is enemy of Person B. (enemy.1, enemy.of.2, government,person)} P1 p4 :(associate.2, associate.with.2, person,government) p5 :(identify.1, identify.with.2, person,government) p6 :(connect.2, connect.with.2, person,government) p7 :(draw.2, draw.to.2, government,person) p8 :(associate.2, associate.with.2, government,person) Sg(P g) p4 →{Person A is identified with Government B. (identify.2, identify.with.2, person,government), Government B awards Person A. (award.1, award.2, government,person), Person A practices Government B. (practice.1, practice.2, person,government),
ACL 2023 Responsible NLP Checklist

heading: A For every submission:
text: 3 A1. Did you describe the limitations of your work?
Section "Limitations"
3 A2. Did you discuss any potential risks of your work? Section "Ethics Statement"
3 A3. Do the abstract and introduction summarize the paper’s main claims? Abstract and Section 1
7 A4. Have you used AI writing assistants when working on this paper? Left blank.
B 3 Did you use or create scientific artifacts? Section 3 and 4
3 B1. Did you cite the creators of artifacts you used? Section 3 and 4
3 B2. Did you discuss the license or terms for use and / or distribution of any artifacts? Section 3 and 4
3 B3. Did you discuss if your use of existing artifact(s) was consistent with their intended use, provided that it was specified? For the artifacts you create, do you specify intended use and whether that is compatible with the original access conditions (in particular, derivatives of data accessed for research purposes should not be used outside of research contexts)? Section 3 and 4
3 B4. Did you discuss the steps taken to check whether the data that was collected / used contains any information that names or uniquely identifies individual people or offensive content, and the steps taken to protect / anonymize it? Section 3, 4 and "Ethics Statement"
3 B5. Did you provide documentation of the artifacts, e.g., coverage of domains, languages, and linguistic phenomena, demographic groups represented, etc.? Section 4
3 B6. Did you report relevant statistics like the number of examples, details of train / test / dev splits, etc. for the data that you used / created? Even for commonly-used benchmark datasets, include the number of examples in train / validation / test splits, as these provide necessary context for a reader to understand experimental results. For example, small differences in accuracy on large test sets may be significant, while on small test sets they may not be. Section 4
C 3 Did you run computational experiments? Section 4 and 5
3 C1. Did you report the number of parameters in the models used, the total computational budget (e.g., GPU hours), and computing infrastructure used? Section 4
The Responsible NLP Checklist used at ACL 2023 is adopted from NAACL 2022, with the addition of a question on AI writing assistance.
3 C2. Did you discuss the experimental setup, including hyperparameter search and best-found hyperparameter values? Section 4 and Appendix E
3 C3. Did you report descriptive statistics about your results (e.g., error bars around results, summary statistics from sets of experiments), and is it transparent whether you are reporting the max, mean, etc. or just a single run? Section 5
3 C4. If you used existing packages (e.g., for preprocessing, for normalization, or for evaluation), did you report the implementation, model, and parameter settings used (e.g., NLTK, Spacy, ROUGE, etc.)? Section 3 and 4
D 3 Did you use human annotators (e.g., crowdworkers) or research with human participants? Section 4
D1. Did you report the full text of instructions given to participants, including e.g., screenshots, disclaimers of any risks to participants or annotators, etc.? Not applicable. Left blank.
3 D2. Did you report information about how you recruited (e.g., crowdsourcing platform, students) and paid participants, and discuss if such payment is adequate given the participants’ demographic (e.g., country of residence)? Section "Ethics Statement"
3 D3. Did you discuss whether and how consent was obtained from people whose data you’re using/curating? For example, if you collected data via crowdsourcing, did your instructions to crowdworkers explain how the data would be used? Appendix F
D4. Was the data collection protocol approved (or determined exempt) by an ethics review board? Not applicable. Left blank.
D5. Did you report the basic demographic and geographic characteristics of the annotator population that is the source of the data? Not applicable. Left blank.

heading: Future Work
text: We assume that this problem could be solved by carefully confirming how the seed predicates represent corresponding domain knowledge and we leave it to future work