Original: P ROTOTYPICAL R EPRESENTATION L EARNING FOR R ELATION E XTRACTION
Revised: P ROTOTYPICAL R EPRESENTATION L EARNING FOR R ELATION E XTRACTION

Original: A BSTRACT
Revised: A BSTRACT

Original: Recognizing relations between entities is a pivotal task of relational learning.
Revised: Recognizing relations between entities is a pivotal task of relational learning.

Original: Learning relation representations from distantly-labeled dataset is difﬁcult because of the abundant label noise and complicated expressions in human language.
Revised: Learning relation representations from distantly-labeled datasets is difﬁcult because of the abundant label noise and complicated expressions in human language.

Original: This paper aims to learn predictive, interpretable, and robust relation representations from distantly-labeled data that are effective in different settings, including supervised, distantly supervised, and few-shot learning.
Revised: This paper aims to learn predictive, interpretable, and robust relation representations from distantly-labeled data that are effective in different settings, including supervised distantly supervised, and few-shot learning.

Original: Instead of solely relying on the supervision from noisy labels, we propose to learn prototypes for each relation from contextual information to best explore the intrinsic semantics of relations.
Revised: Instead of solely relying on the supervision from noisy labels, we propose to learn prototypes for each relation from contextual information to best explore the intrinsic semantics of relations.

Original: Prototypes are representations in the feature space abstracting the essential semantics of relations between entities in sentences.
Revised: Pro totypes are representations in the feature space abstracting the essential semantics of relations between entities in sentences.

Original: We learn prototypes based on objectives with clear geometric interpretation, where the prototypes are unit vectors uniformly dispersed in a unit ball, and statement embeddings are centered at the end of their corresponding prototype vectors on the surface of the ball.
Revised: We learn prototypes based on objectives with clear geometric interpretation, where the prototypes are unit vectors uniformly dispersed in a unit ball, and statement embeddings are centered at the end of their corresponding prototype vectors on the surface of the ball.

Original: This approach allow us to learn meaningful, interpretable prototypes for the ﬁnal classiﬁcation.
Revised: This approach allows us to learn meaningful, interpretable prototypes for the ﬁnal classiﬁcation.

Original: Results on several relation learning tasks show that our model signiﬁcantly outperforms the previous state-of-the-art models.
Revised: Results on several relation learning tasks show that our model signiﬁcantly outperforms the previous state-of-the-art models.

Original: We further demonstrate the robustness of the encoder and the interpretability of prototypes with extensive experiments.
Revised: We further demonstrate the robustness of the encoder and the interpretability of prototypes with extensive experiments.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Relation extraction aims to predict relations between entities in sentences, which is crucial for understanding the structure of human knowledge and automatically extending knowledge bases (Cohen & Hirsh, 1994; Bordes et al., 2013; Zeng et al., 2015; Schlichtkrull et al., 2018;
Revised: Relation extraction aims to predict relations between entities in sentences, which is crucial for understanding the structure of human knowledge and automatically extending knowledge bases (Cohen & Hirsh, 1994; Bordes et al., 2013; Zeng et al., 2015; Schlichtkrull et al., 2018;

Original: Shen et al., 2020).
Revised: Shen et al., 2020).

Original: Learning representations for relation extraction is challenging due to the rich forms of expressions in human language, which usually contains ﬁne-grained, complicated correlations between marked entities.
Revised: Learning representations for relation extraction is challenging due to the rich forms of expressions in human language, which usually contains ﬁne-grained, complicated correlations between marked entities.

Original: Although many works are proposed to learn representations for relations from well-structured knowledge (Bordes et al., 2013; Lin et al., 2015; Ji et al., 2015), when we extend the learning source to be unstructured distantly-labeled text (Mintz et al., 2009), this task becomes particularly challenging due to spurious correlations and label noise (Riedel et al., 2010).
Revised: Although many works are proposed to learn representations for relations from well-structured knowledge (Bordes et al., 2013; Lin et al., 2015; Ji et al., 2015), when we extend the learning source to be unstructured distantly-labeled text (Mintz et al., 2009), this task becomes particularly challenging due to spurious correlations and label noise (Riedel et al., 2010).

Original: This paper aims to learn predictive, interpretable, and robust relation representations from large-scale distantly labeled data.
Revised: This paper aims to learn predictive, interpretable, and robust relation representations from large-scale distantly labeled data.

Original: We propose a prototype learning approach, where we impose a prototype for each relation and learn the representations from the semantics of each statement, rather than solely from the noisy distant labels.
Revised: We propose a prototype learning approach, where we impose a prototype for each relation and learn the representations from the semantics of each statement, rather than solely from the noisy distant labels.

Original: Statements are deﬁned as sentences expressing relations between two marked entities.
Revised: Statements are deﬁned as sentences expressing relations between two marked entities.

Original: As shown in Figure 1, a prototype is an embedding in the representation space capturing the most essential semantics of different statements for a given relation.
Revised: As shown in Figure 1, a prototype is an embedding in the representation space capturing the most essential semantics of different statements for a given relation.

Original: These prototypes essentially serve as the center of data representation clusters for different relations and are surrounded by statements expressing the same relation.
Revised: These prototypes essentially serve as the center of data representation clusters for different relations and are surrounded by statements expressing the same relation.

Original: We learn the relation and prototype representations based on objective functions with clear geometric interpretations.
Revised: We learn the relation and prototype representations based on objective functions with clear geometric interpretations.

Original: Speciﬁcally, our approach assumes prototypes are unit vectors uniformly dispersed in a unit ball, and statement embeddings are centered
Revised: Speciﬁcally, our approach assumes prototypes are unit vectors uniformly dispersed in a unit ball, and statement embeddings are centered

Original: [Table]
Revised: [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table]
Revised: [Table]

Original: Prototypes for the relation
Revised: Prototypes for the relation

Original: [Figure]
Revised: [Figure]

Original: : The subject of imply" is the source of an implication
Revised: : The subject of imply" is the source of an implication

Original: [Figure]
Revised: [Figure]

Original: the subject of "infer"
Revised: the subject of "infer"

Original: [Figure]
Revised: [Figure]

Original: Cause-
Revised: Cause-

Original: [Figure]
Revised: [Figure]

Original: : Lopez and Espinoza took plea agreements that resulted in diversion -- the completion of requirements… (Cause-Effect)
Revised: : Lopez and Espinoza took plea agreements that resulted in diversion -- the completion of requirements… (Cause-Effect)

Original: [Figure]
Revised: [Figure]

Original: at the end of their corresponding prototype vectors on the surface of the ball.
Revised: at the end of their corresponding prototype vectors on the surface of the ball.

Original: We propose statementstatement and prototype-statement objectives to ensure the intra-class compactness and inter-class separability .
Revised: We propose statementstatement and prototype-statement objectives to ensure the intra-class compactness and inter-class separability .

Original: Unlike conventional cross-entropy loss that only uses instance-level supervision (which could be noisy), our objectives exploit the interactions among all statements , leading to a predictively powerful encoder with more interpretable and robust representations.
Revised: Unlike conventional cross-entropy loss that only uses instance-level supervision (which could be noisy), our objectives exploit the interactions among all statements , leading to a predictively powerful encoder with more interpretable and robust representations.

Original: We further explore these properties of learned representations with extensive experiments.
Revised: We further explore these properties of learned representations with extensive experiments.

Original: We apply our approach using a pretraining ﬁne-tuning paradigm.
Revised: We apply our approach using a pretraining ﬁne-tuning paradigm.

Original: We ﬁrst pretrain a relation encoder with prototypes from a large-scale distantly labeled dataset, then ﬁne-tune it on the target dataset with different relational learning settings.
Revised: We ﬁrst pretrain a relation encoder with prototypes from a large-scale distantly labeled dataset, then ﬁne-tune it on the target dataset with different relational learning settings.

Original: We further propose a probing dataset, FuzzyRED dataset (Section 4.3), to verify if our method can capture the underlying semantics of statements.
Revised: We further propose a probing dataset, FuzzyRED dataset (Section 4.3), to verify if our method can capture the underlying semantics of statements.

Original: Experiments demonstrate the predictive performance, robustness, and interpretability of our method.
Revised: Experiments demonstrate the predictive performance, robustness, and interpretability of our method.

Original: For predictive performance, we show that our model outperforms existing state-of-the-art methods on supervised, few-shot, and zero-shot settings (Section 4.4 and 4.2).
Revised: For predictive performance, we show that our model outperforms existing state-of-the-art methods on supervised, few-shot, and zero-shot settings (Section 4.4 and 4.2).

Original: For robustness, we show how the model generalize to zero-shot setting (Section 4.2) and how the prototypes regularize the decision boundary (Section 4.5).
Revised: For robustness, we show how the model generalize to zero-shot setting (Section 4.2) and how the prototypes regularize the decision boundary (Section 4.5).

Original: For interpretability, we visualize the learned embeddings and their corresponding prototypes (Section 4.4) and show the cluster clearly follow the geometric structure that the objective functions impose.
Revised: For interpretability, we visualize the learned embeddings and their corresponding prototypes (Section 4.4) and show the cluster clearly follow the geometric structure that the objective functions impose.

Original: The source code of the paper will be released at https://github.com/
Revised: The source code of the paper will be released at https://github.com/

Original: Alibaba-NLP/ProtoRE .
Revised: Alibaba-NLP/ProtoRE .

Original:  R ELATED W ORK
Revised:  R ELATED W ORK

Original: Relation learning could be mainly divided into three categories.
Revised: Relation learning could be mainly divided into three categories.

Original: The logic-based methods reason relations via symbolic logic rules, with adopting probabilistic graphical models or inductive logic systems to learn and infer logic rules orienting to relations (Cohen & Hirsh, 1994; Wang et al., 2015;
Revised: The logic-based methods reason relations via symbolic logic rules, with adopting probabilistic graphical models or inductive logic systems to learn and infer logic rules orienting to relations (Cohen & Hirsh, 1994; Wang et al., 2015;

Original: Yang et al., 2017; Chen et al., 2018; Kazemi & Poole, 2018; Qu & Tang, 2019).
Revised: Yang et al., 2017; Chen et al., 2018; Kazemi & Poole, 2018; Qu & Tang, 2019).

Original: The graph-based methods encode entities and relations into low-dimensional continues spaces to capture structure features of KBs.
Revised: The graph-based methods encode entities and relations into low-dimensional continues spaces to capture structure features of KBs.

Original: (Nickel et al., 2011; Bordes et al., 2013; Yang et al., 2015; Wang et al., 2014; Nickel et al., 2016;
Revised: (Nickel et al., 2011; Bordes et al., 2013; Yang et al., 2015; Wang et al., 2014; Nickel et al., 2016;

Original: Ji et al., 2015; Lin et al., 2015; Trouillon et al., 2016; Sun et al., 2019; Balaˇzevi´c et al., 2019).
Revised: Ji et al., 2015; Lin et al., 2015; Trouillon et al., 2016; Sun et al., 2019; Balaˇzevi´c et al., 2019).

Original: The text-based methods have been widely explored recently, focusing on extracting semantic features from text to learn relations.
Revised: The text-based methods have been widely explored recently, focusing on extracting semantic features from text to learn relations.

Original: The conventional methods to learn relations from the text are mainly supervised models, like statistical supervised models (Zelenko et al., 2003; GuoDong et al., 2005; Mooney & Bunescu, 2006).
Revised: The conventional methods to learn relations from the text are mainly supervised models, like statistical supervised models (Zelenko et al., 2003; GuoDong et al., 2005; Mooney & Bunescu, 2006).

Original: As deep neural networks have gained much attention then, a series of neural supervised models have been proposed (Liu et al., 2013; Zeng et al., 2014; Xu et al., 2015; Santos et al., 2015; Zhang & Wang, 2015; Verga et al., 2016; Verga & McCallum, 2016;
Revised: As deep neural networks have gained much attention then, a series of neural supervised models have been proposed (Liu et al., 2013; Zeng et al., 2014; Xu et al., 2015; Santos et al., 2015; Zhang & Wang, 2015; Verga et al., 2016; Verga & McCallum, 2016;

Original: Li et al., 2019; Distiawan et al., 2019; Ding et al., 2019).
Revised: Li et al., 2019; Distiawan et al., 2019; Ding et al., 2019).

Original: To address the issue of the insufﬁciency of annotated data, distant supervision has been applied to automatically generate a dataset with heuristic rules (Mintz et al., 2009).
Revised: To address the issue of the insufﬁciency of annotated data, distant supervision has been applied to automatically generate a dataset with heuristic rules (Mintz et al., 2009).

Original: Accompanying with auto-labeled data, massive noise will be introduced into models.
Revised: Accompanying with auto-labeled data, massive noise will be introduced into models.

Original: Accordingly, various denoising methods have been explored to reduce noise effects for distant supervision (Zeng et al., 2015;
Revised: Accordingly, various denoising methods have been explored to reduce noise effects for distant supervision (Zeng et al., 2015;

Original: Lin et al., 2016; Jiang et al., 2016; Han et al., 2018a;
Revised: Lin et al., 2016; Jiang et al., 2016; Han et al., 2018a;

Original: Wu et al., 2017; Qin et al., 2018a;b; Feng et al.,
Revised: Wu et al., 2017; Qin et al., 2018a;b; Feng et al.,

Original: Further efforts pay attention to learning relations from the text in various speciﬁc scenarios, such as zero-few-shot scenarios (Levy et al., 2017; Han et al., 2018b; Gao et al., 2019;
Revised: Further efforts pay attention to learning relations from the text in various speciﬁc scenarios, such as zero-few-shot scenarios (Levy et al., 2017; Han et al., 2018b; Gao et al., 2019;

Original: Soares et al., 2019; Ye & Ling, 2019) and open-domain scenarios (Banko et al., 2007; Fader et al., 2011;
Revised: Soares et al., 2019; Ye & Ling, 2019) and open-domain scenarios (Banko et al., 2007; Fader et al., 2011;

Original: Mausam et al., 2012; Del Corro & Gemulla, 2013; Angeli et al., 2015; Stanovsky & Dagan, 2016; Mausam, 2016; Cui et al., 2018; Shinyama & Sekine, 2006;
Revised: Mausam et al., 2012; Del Corro & Gemulla, 2013; Angeli et al., 2015; Stanovsky & Dagan, 2016; Mausam, 2016; Cui et al., 2018; Shinyama & Sekine, 2006;

Original: Elsahar et al., 2017; Wu et al., 2019).
Revised: Elsahar et al., 2017; Wu et al., 2019).

Original: However, up to now, there are few strategies of relation learning that could be adapted to any relation learning tasks.
Revised: However, up to now, there are few strategies of relation learning that could be adapted to any relation learning tasks.

Original: Soares et al.
Revised: Soares et al.

Original: (2019) introduces a preliminary method that learns relation representations from unstructured corpus.
Revised: (2019) introduces a preliminary method that learns relation representations from unstructured corpus.

Original: And the assumption that two same entities must express the same relation is imprecise, because it does not consider the semantics of contextual information.
Revised: And the assumption that two same entities must express the same relation is imprecise, because it does not consider the semantics of contextual information.

Original: This paper abstracts the task from the text as a metric and prototype learning problem and proposes a interpretable method for relation representation learning.
Revised: This paper abstracts the task from the text as a metric and prototype learning problem and proposes a interpretable method for relation representation learning.

Original: Apart from the differences in methods and task scenarios, row-less universal schema (Verga & McCallum, 2016) has a similar spirit with our method, where relation type embeddings guide clustering of statements for entity pair representations and embeddings of entity pairs are regarded as an aggregation of relations.
Revised: Apart from the differences in methods and task scenarios, row-less universal schema (Verga & McCallum, 2016) has a similar spirit with our method, where relation type embeddings guide clustering of statements for entity pair representations and embeddings of entity pairs are regarded as an aggregation of relations.

Original: Although the intuition that assigns a representative prototype for each class is similar to some previous studies like Prototypical Networks (Snell et al., 2017) (ProtoNet), there exist some essential distinctions between our approach and the ProtoNet.
Revised: Although the intuition that assigns a representative prototype for each class is similar to some previous studies like Prototypical Networks (Snell et al., 2017) (ProtoNet), there exist some essential distinctions between our approach and the ProtoNet.

Original: The ProtoNet computes the prototype of each class as the average of the embeddings of all the instance embeddings, that could be regarded as a non-linear version of the nearest class mean approach (Mensink et al., 2013).
Revised: The ProtoNet computes the prototype of each class as the average of the embeddings of all the instance embeddings, that could be regarded as a non-linear version of the nearest class mean approach (Mensink et al., 2013).

Original: The idea of mean-ofclass prototypes could also be traced to earlier studies in machine learning (Graf et al., 2009) and cognitive modeling and psychology (Reed, 1972; Rosch et al., 1976).
Revised: The idea of mean-ofclass prototypes could also be traced to earlier studies in machine learning (Graf et al., 2009) and cognitive modeling and psychology (Reed, 1972; Rosch et al., 1976).

Original: In our method, prototypes and relation encoder are collaboratively and dynamically trained by three objectives, which divides the high-dimensional feature space into disjoint manifolds.
Revised: In our method, prototypes and relation encoder are collaboratively and dynamically trained by three objectives, which divides the high-dimensional feature space into disjoint manifolds.

Original: The ProtoNet performs instance-level classiﬁcation to update the parameters, which is not robust for noisy labels.
Revised: The ProtoNet performs instance-level classiﬁcation to update the parameters, which is not robust for noisy labels.

Original: Our method carries out a novel prototype-level classiﬁcation to effectively regularize the semantic information.
Revised: Our method carries out a novel prototype-level classiﬁcation to effectively regularize the semantic information.

Original: The prototype-level classiﬁcation reduces the distortion caused by noisy labels of the decision boundary ﬁtted by NNs.
Revised: The prototype-level classiﬁcation reduces the distortion caused by noisy labels of the decision boundary ﬁtted by NNs.

Original: Moreover, the ProtoNet is designed for few-zero-shot learning and our methods are more like a semi-supervised pre-training approach that could be applied to supervised, few-shot, and transfer learning scenarios.
Revised: Moreover, the ProtoNet is designed for few-zero-shot learning and our methods are more like a semi-supervised pre-training approach that could be applied to supervised, few-shot, and transfer learning scenarios.

Original: Furthermore, the ProtoNet does not contain the metric learning among instances, and our method simultaneously optimizes the prototype-statement and statement-statement metrics.
Revised: Furthermore, the ProtoNet does not contain the metric learning among instances, and our method simultaneously optimizes the prototype-statement and statement-statement metrics.

Original: We also make a geometry explanation of our method (Section 3.1).
Revised: We also make a geometry explanation of our method (Section 3.1).

Original:  M ETHOD
Revised:  M ETHOD

Original: Our method follows a pretraining-ﬁnetuning paradigm.
Revised: Our method follows a pretraining-ﬁnetuning paradigm.

Original: We ﬁrst pretrain an encoder with distantly labeled data, then ﬁne-tune it to downstream learning settings.
Revised: We ﬁrst pretrain an encoder with distantly labeled data, then ﬁne-tune it to downstream learning settings.

Original: We start with the pretraining phase.
Revised: We start with the pretraining phase.

Original: Given a large-scale, distantly labeled dataset containing training pairs ( w, r ) where w =
Revised: Given a large-scale, distantly labeled dataset containing training pairs ( w, r ) where w =

Original: [ w 1 , ..., w n ] is a relation statement, i.e., a sequence of words with a pair of entities [ h, t ] marked, h being the head and t being the tail, ∃ i 1 , i 2 , h = w i 1 : i 2 , ∃ j 1 , j 2 , t = w j 1 : j 2 , r is the relation between h and t .
Revised: [ w 1 , ..., w n ] is a relation statement, i.e., a sequence of words with a pair of entities [ h, t ] marked, h being the head and t being the tail, ∃ i 1 , i 2 , h = w i 1 : i 2 , ∃ j 1 , j 2 , t = w j 1 : j 2 , r is the relation between h and t .

Original: r is a discrete label and is probably noisy.
Revised: r is a discrete label and is probably noisy.

Original: We aim to learn an encoder Enc φ ( · ) parameterized by φ that encodes w into a representation s ∈ R m , m being the dimension:
Revised: We aim to learn an encoder Enc φ ( · ) parameterized by φ that encodes w into a representation s ∈ R m , m being the dimension:

Original: [Equation]
Revised: [Equation]

Original: A prototype z for relation r is an embedding in the same metric space with s that abstracts the essential semantics of r .
Revised: A prototype z for relation r is an embedding in the same metric space with s that abstracts the essential semantics of r .

Original: We use [( z 1 , r 1 ) , ..., ( z K , r K )] , z k ∈ R m to denote the set of prototype-relation pairs.
Revised: We use [( z 1 , r 1 ) , ..., ( z K , r K )] , z k ∈ R m to denote the set of prototype-relation pairs.

Original: K is the number of different relations.
Revised: K is the number of different relations.

Original: z k is the prototype for relation r k and superscripts denote the index of relation type.
Revised: z k is the prototype for relation r k and superscripts denote the index of relation type.

Original: Given a batch B =
Revised: Given a batch B =

Original: [( s 1 , r 1 ) , ..., ( s N , r N )] , N is the batch size and subscripts denote batch index, the similarity metric between two statement embeddings
Revised: [( s 1 , r 1 ) , ..., ( s N , r N )] , N is the batch size and subscripts denote batch index, the similarity metric between two statement embeddings

Original: d ( s i , s j ) , and between a statement embedding and a prototype d ( s, z ) are deﬁned as:
Revised: d ( s i , s j ) , and between a statement embedding and a prototype d ( s, z ) are deﬁned as:

Original: [Equation]
Revised: [Equation]

Original: Geometrically, this metric is based on the angles of the normalized embeddings restricted in a unit ball .
Revised: Geometrically, this metric is based on the angles of the normalized embeddings restricted in a unit ball .

Original: We will explain the geometric implication of this metric in the next section.
Revised: We will explain the geometric implication of this metric in the next section.

Original: Inspired by Soares et al.
Revised: Inspired by Soares et al.

Original: (2019), we deﬁne a contrastive objective function between statements:
Revised: (2019), we deﬁne a contrastive objective function between statements:

Original: [Equation]
Revised: [Equation]

Original: where δ ( s i , s j ) denotes if s i and s j corresponds to the same relations, i.e., given ( s i , r i ) , ( s j , r j ) , δ ( s i , s j ) = 1 if r i =
Revised: where δ ( s i , s j ) denotes if s i and s j corresponds to the same relations, i.e., given ( s i , r i ) , ( s j , r j ) , δ ( s i , s j ) = 1 if r i =

Original: r j else 0 .
Revised: r j else 0 .

Original: The computation of the numerator term forces that statements with same relations to be close, and the denominator forces that those with different relations are dispersed.
Revised: The computation of the numerator term forces that statements with same relations to be close, and the denominator forces that those with different relations are dispersed.

Original: When constructing the batch B , we equally sample all relation types to make sure the summation in the denominator contains all relations.
Revised: When constructing the batch B , we equally sample all relation types to make sure the summation in the denominator contains all relations.

Original: Essentially, equation 3 ensures intra-class compactness and inter-class separability in the representation space.
Revised: Essentially, equation 3 ensures intra-class compactness and inter-class separability in the representation space.

Original: Additionally, equation 3 contrast one positive sample to all the negative samples in the batch, which puts more weights on the negative pairs.
Revised: Additionally, equation 3 contrast one positive sample to all the negative samples in the batch, which puts more weights on the negative pairs.

Original: We ﬁnd it empirically more effective than previous objectives like Soares et al.
Revised: We ﬁnd it empirically more effective than previous objectives like Soares et al.

Original: 3. L EARNING P ROTOTYPES
Revised: 3. L EARNING P ROTOTYPES

Original: Now we discuss the objective functions for learning prototypes.
Revised: Now we discuss the objective functions for learning prototypes.

Original: Denote S =
Revised: Denote S =

Original: [ s 1 , ..., s N ] as the set of all embeddings in the batch B , given a ﬁxed prototype z r for relation r , we denote S r the subset of all statements s i in S with relation r , and S − r the set of the rest statements.
Revised: [ s 1 , ..., s N ] as the set of all embeddings in the batch B , given a ﬁxed prototype z r for relation r , we denote S r the subset of all statements s i in S with relation r , and S − r the set of the rest statements.

Original: Z − r as the set of prototypes z (cid:48) for all other relations except r .
Revised: Z − r as the set of prototypes z (cid:48) for all other relations except r .

Original: We impose two key inductive biases between prototypes and statements: (a) for a speciﬁc relation r , the “distance” between z r and any statements with the same relation r should be less than the “distance” between z r and any statements with relations r (cid:48)
Revised: We impose two key inductive biases between prototypes and statements: (a) for a speciﬁc relation r , the “distance” between z r and any statements with the same relation r should be less than the “distance” between z r and any statements with relations r (cid:48)

Original: (cid:54) =
Revised: (cid:54) =

Original: r .
Revised: r .

Original: (b) the “distance” between z r and any statements with relation r should be less than the “distance” between any prototypes z (cid:

Revised: (b) the “distance” between z r and any statements with relation r should be less than the “distance” between any prototypes z (cid:

Original: ) ∈
Revised: ) ∈

Original: Z − r and statements with relation r .
Revised: Z − r and statements with relation r .

Original: To realize these two properties, we deﬁne two objective functions:
Revised: To realize these two properties, we deﬁne two objective functions:

Original: [Equation]
Revised: [Equation]

Original: where equation 4 corresponds to (a) and equation 5 corresponds to (b).
Revised: where equation 4 corresponds to (a) and equation 5 corresponds to (b).

Original: These objectives effectively splits the data representations into K disjoint manifolds centering at different prototypes .
Revised: These objectives effectively splits the data representations into K disjoint manifolds centering at different prototypes .

Original: We further highlight the differences between equation 4 and 5 and a conventional cross-entropy loss: there is no interactions between different statements in the cross-entropy loss that solely relies on the instance level supervision, which is particularly noisy under a noisy-label setting.
Revised: We further highlight the differences between equation 4 and 5 and a conventional cross-entropy loss: there is no interactions between different statements in the cross-entropy loss that solely relies on the instance level supervision, which is particularly noisy under a noisy-label setting.

Original: On the other hand, our loss functions consider distances between different statements and prototypes, which exploits the interactions between statements.
Revised: On the other hand, our loss functions consider distances between different statements and prototypes, which exploits the interactions between statements.

Original: This type of interaction would effectively serve as a regularization to the decision boundary, as we will empirically verify in section 4.5.
Revised: This type of interaction would effectively serve as a regularization to the decision boundary, as we will empirically verify in section 4.5.

Original: [Figure]
Revised: [Figure]

Original: Combining equations 2, 3, 4 and 5, we further give a geometric explanation of the representation space: a prototype is a unit vector (because we normalize the vector length in equation 2) starting from the origin and ending at the surface of a unit ball, and statements for that prototypes are unit vectors with approximately same directions centering at the prototype (because our objective functions 3, 4, 5 push them to be close to each other).
Revised: Combining equations 2, 3, 4 and 5, we further give a geometric explanation of the representation space: a prototype is a unit vector (because we normalize the vector length in equation 2) starting from the origin and ending at the surface of a unit ball, and statements for that prototypes are unit vectors with approximately same directions centering at the prototype (because our objective functions 3, 4, 5 push them to be close to each other).

Original: Under the optimal condition, different prototype vectors would be uniformly dispersed with the angles between them as large as possible (because the distance metric is based on the angle in equation 2 where the minimum is at π , and we maximize distances between prototypes in equation 4 and 5).
Revised: Under the optimal condition, different prototype vectors would be uniformly dispersed with the angles between them as large as possible (because the distance metric is based on the angle in equation 2 where the minimum is at π , and we maximize distances between prototypes in equation 4 and 5).

Original: Consequently, the dataset is clustered with each cluster centered around the end of one prototype vector on the surface of the unit ball.
Revised: Consequently, the dataset is clustered with each cluster centered around the end of one prototype vector on the surface of the unit ball.

Original: The illustration of the intuition is shown in Figure 2.
Revised: The illustration of the intuition is shown in Figure 2.

Original: To further regularize the semantics of the prototypes, we use a prototype-level classiﬁcation objective:
Revised: To further regularize the semantics of the prototypes, we use a prototype-level classiﬁcation objective:

Original: [Equation]
Revised: [Equation]

Original: where γ denotes the parameters of an auxiliary classiﬁer.
Revised: where γ denotes the parameters of an auxiliary classiﬁer.

Original: Our prototype essentially serves as a regularization averaging the inﬂuence of label noises.
Revised: Our prototype essentially serves as a regularization averaging the inﬂuence of label noises.

Original: We further validate this regularization in
Revised: We further validate this regularization in

Original: Section 4.5 by showing that it reduces the distortion of the decision boundary caused by noisy labels.
Revised: Section 4.5 by showing that it reduces the distortion of the decision boundary caused by noisy labels.

Original: Finally, with hyper-parameters λ 1 , λ 2 and λ 3 , the full loss is:
Revised: Finally, with hyper-parameters λ 1 , λ 2 and λ 3 , the full loss is:

Original: [Equation]
Revised: [Equation]

Original: 3. F INE - TUNING ON D IFFERENT L EARNING S ETTINGS
Revised: 3. F INE - TUNING ON D IFFERENT L EARNING S ETTINGS

Original: We apply our learned encoder and prototypes to two typical relational learning settings: (a) supervised; (b) few-shot.
Revised: We apply our learned encoder and prototypes to two typical relational learning settings: (a) supervised; (b) few-shot.

Original: Under the supervised learning setting, having the pretrained encoder at hand, we ﬁnetune the model on a dataset of a target domain (which could again, be distantly labeled) containing new training pairs ( w, r ) , we encode w to the representation and feed it to a feed-forward classiﬁer:
Revised: Under the supervised learning setting, having the pretrained encoder at hand, we ﬁnetune the model on a dataset of a target domain (which could again, be distantly labeled) containing new training pairs ( w, r ) , we encode w to the representation and feed it to a feed-forward classiﬁer:

Original: [Equation]
Revised: [Equation]

Original:  where FF ( · ) denotes a feed-forward layer, and we train it with the conventional cross-entropy loss.
Revised: ) where FF ( · ) denotes a feed-forward layer, and we train it with the conventional cross-entropy loss.

Original: Under the few-shot learning setting, we assume a slightly different input data format.
Revised: Under the few-shot learning setting, we assume a slightly different input data format.

Original: Speciﬁcally, the training set consists of the relations [ r 1 , ..., r K ] and a list of supporting statements: s k 1 , ..., s kL for all r k .
Revised: Speciﬁcally, the training set consists of the relations [ r 1 , ..., r K ] and a list of supporting statements: s k 1 , ..., s kL for all r k .

Original: Denote S (cid:63) =
Revised: Denote S (cid:63) =

Original: { s kl } k
Revised: { s kl } k

Original: =1 ,...,K l =1 ,...,L all supporting statements for all relations.
Revised: =1 ,...,K l =1 ,...,L all supporting statements for all relations.

Original: Given a query statement q , the task is to classify the relation r ∗ that q expresses.
Revised: Given a query statement q , the task is to classify the relation r ∗ that q expresses.

Original: During traing, we use the average distance to different prototypes as the logits of a feed-forward classiﬁer and train the model with cross-entropy loss.
Revised: During traing, we use the average distance to different prototypes as the logits of a feed-forward classiﬁer and train the model with cross-entropy loss.

Original: During testing, we classify q according to the minimum similarity metrics:
Revised: During testing, we classify q according to the minimum similarity metrics:

Original: [Equation]
Revised: [Equation]

Original: Note this is equivalent to choosing the argmax of the logits because the logits are formed by the similarity scores.
Revised: Note this is equivalent to choosing the argmax of the logits because the logits are formed by the similarity scores.

Original: We note that model pre-trained by our approach performs surprisingly well even with no training data for ﬁne-tuning, which is reported in Figure 3 and 4 in Section 4.2.
Revised: We note that model pre-trained by our approach performs surprisingly well even with no training data for ﬁne-tuning, which is reported in Figure 3 and 4 in Section 4.2.

Original:  E XPERIMENTS
Revised:  E XPERIMENTS

Original: In order to evaluate the performance of prototypical metrics learning, we conduct extensive experiments on three tasks: supervised relation learning, few-shot learning and our proposed fuzzy relation learning evaluation.
Revised: In order to evaluate the performance of prototypical metrics learning, we conduct extensive experiments on three tasks: supervised relation learning, few-shot learning and our proposed fuzzy relation learning evaluation.

Original: We make a comprehensive evaluation and analysis of our method, as well as full-scale comparisons between our work with previous state-of-the-art methods.
Revised: We make a comprehensive evaluation and analysis of our method, as well as full-scale comparisons between our work with previous state-of-the-art methods.

Original: 4. E XPRIMENTAL D ETAILS Pretraining dataset
Revised: 4. E XPRIMENTAL D ETAILS Pretraining dataset

Original: We prepare the weakly-supervised data by aligning relation tuples from the
Revised: We prepare the weakly-supervised data by aligning relation tuples from the

Original: Wikidata database to Wikipedia articles.
Revised: Wikidata database to Wikipedia articles.

Original: Speciﬁcally, all entities in wikipedia sentences are identiﬁed by a named entity recognition system.
Revised: Speciﬁcally, all entities in wikipedia sentences are identiﬁed by a named entity recognition system.

Original: For an entity pair ( h, t ) in a sentence w , if it also exists in the knowledge base with a relation r, then w will be distantly annotated as r. After processing, we collect more than 0.86 million relation statements covering over 700 relations.
Revised: For an entity pair ( h, t ) in a sentence w , if it also exists in the knowledge base with a relation r, then w will be distantly annotated as r. After processing, we collect more than 0.86 million relation statements covering over 700 relations.

Original: Baseline Models We primarily compare our model with MTB because it is a previous SOTA model.
Revised: Baseline Models We primarily compare our model with MTB because it is a previous SOTA model.

Original: For fair comparison, we re-implement MTB with BERT base (Devlin et al., 2018) and pretrain it on our collected distant data as same as our methods.
Revised: For fair comparison, we re-implement MTB with BERT base (Devlin et al., 2018) and pretrain it on our collected distant data as same as our methods.

Original: We note under our setting, the reported number of MTB is smaller than its original paper because: (a) the original paper uses much larger dataset than ours (600 million vs 0.86 million); (b) they use BERT large encoder.
Revised: We note under our setting, the reported number of MTB is smaller than its original paper because: (a) the original paper uses much larger dataset than ours (600 million vs 0.86 million); (b) they use BERT large encoder.

Original: In addition, multiple previous state-of-the-art approaches are picked up for comparison in all the three relation learning tasks (detailed later).
Revised: In addition, multiple previous state-of-the-art approaches are picked up for comparison in all the three relation learning tasks (detailed later).

Original: For baseline models (PCNN, Meta Network, GNN, Prototypical Network,
Revised: For baseline models (PCNN, Meta Network, GNN, Prototypical Network,

Original: MLMAN) with publicly available source code, we run the source code manually, and if the produced results are close to those in the original paper, we would select and report the results in the original paper.
Revised: MLMAN) with publicly available source code, we run the source code manually, and if the produced results are close to those in the original paper, we would select and report the results in the original paper.

Original: For ones without open source code ( BERT EM , MTB), we re-implement the methods with
Revised: For ones without open source code ( BERT EM , MTB), we re-implement the methods with

Original: BERT base pre-trained on our distant data and report the results.
Revised: BERT base pre-trained on our distant data and report the results.

Original: We also implement a baseline that directly trains BERT base on our distant data with cross-entropy loss ( L CE ), namely BERT CE in the section (the encoder is pre-trained by directly predicting the distant label for each statement).
Revised: We also implement a baseline that directly trains BERT base on our distant data with cross-entropy loss ( L CE ), namely BERT CE in the section (the encoder is pre-trained by directly predicting the distant label for each statement).

Original: The IND baseline We additionally design a baseline, where the prototypes are pre-computed by vectorizing the extracted relation patterns independently (IND).
Revised: The IND baseline We additionally design a baseline, where the prototypes are pre-computed by vectorizing the extracted relation patterns independently (IND).

Original: In this way, for each statement, we pre-compute a ﬁxed metric as its weight demonstrating the similarity with the corresponding prototype.
Revised: In this way, for each statement, we pre-compute a ﬁxed metric as its weight demonstrating the similarity with the corresponding prototype.

Original: The IND baseline is primarily for validating the effectiveness of trained prototypes over the rule-based prototypes.
Revised: The IND baseline is primarily for validating the effectiveness of trained prototypes over the rule-based prototypes.

Original: Given the distantly-labeled training set, we use the Snowball algorithm from Agichtein & Gravano (2000) to extract relation patterns.
Revised: Given the distantly-labeled training set, we use the Snowball algorithm from Agichtein & Gravano (2000) to extract relation patterns.

Original: This algorithm takes a corpus of relational instances as inputs and outputs a list of patterns and their embeddings for each relation.
Revised: This algorithm takes a corpus of relational instances as inputs and outputs a list of patterns and their embeddings for each relation.

Original: After getting these patterns, we use patterns to match instances and calculate how many instances can each pattern match.
Revised: After getting these patterns, we use patterns to match instances and calculate how many instances can each pattern match.

Original: For each relation label, we select the top-k patterns that match the most instances and use the average of their embeddings as the prototype embedding.
Revised: For each relation label, we select the top-k patterns that match the most instances and use the average of their embeddings as the prototype embedding.

Original: Note that these embeddings are not comparable to the sentence embeddings generated by our encoders, so the loss functions in our equation 4 and 5 are not usable for the prototypes generated here.
Revised: Note that these embeddings are not comparable to the sentence embeddings generated by our encoders, so the loss functions in our equation 4 and 5 are not usable for the prototypes generated here.

Original: To incorporate the information of the extracted prototype embeddings, we slightly modify equation 3 and use the similarity of instances to the embeddings to weight the instance embeddings.
Revised: To incorporate the information of the extracted prototype embeddings, we slightly modify equation 3 and use the similarity of instances to the embeddings to weight the instance embeddings.

Original: The modiﬁed loss function is:
Revised: The modiﬁed loss function is:

Original: [Equation]
Revised: [Equation]

Original: where w i denote the corresponding sentence to s i , z (cid:48) ( w i ) denote the correspond prototype.
Revised: where w i denote the corresponding sentence to s i , z (cid:48) ( w i ) denote the correspond prototype.

Original: Implementation Details
Revised: Implementation Details

Original: For encoding relation statements into a feature space, we adopt deep
Revised: For encoding relation statements into a feature space, we adopt deep

Original: Transformers (Vaswani et al., 2017), speciﬁcally BERT, as E θ .
Revised: Transformers (Vaswani et al., 2017), speciﬁcally BERT, as E θ .

Original: We take the input and the output of the BERT encoder as follows: given a statement s , we add special entity markers to mark M h and M t before the entities, then input the statement and special markers to Enc φ to compute ﬁnal representations.
Revised: We take the input and the output of the BERT encoder as follows: given a statement s , we add special entity markers to mark M h and M t before the entities, then input the statement and special markers to Enc φ to compute ﬁnal representations.

Original: Note that our framework is designed independently to the encoder choice, and other neural architectures like CNN (Zeng et al., 2014) and RNN (Zhang & Wang, 2015) can be easily adopted as the encoder.
Revised: Note that our framework is designed independently to the encoder choice, and other neural architectures like CNN (Zeng et al., 2014) and RNN (Zhang & Wang, 2015) can be easily adopted as the encoder.

Original: We use PyTorch (Paszke et al., 2019) framework to implement our model.
Revised: We use PyTorch (Paszke et al., 2019) framework to implement our model.

Original: All the experiments run on NVIDIA Tesla V100 GPUs.
Revised: All the experiments run on NVIDIA Tesla V100 GPUs.

Original: The encoder is optimized with the combination of the prototype-statement and statement-statement metrics as well as the masked language model loss with the settings as follows.
Revised: The encoder is optimized with the combination of the prototype-statement and statement-statement metrics as well as the masked language model loss with the settings as follows.

Original: For the sake of saving resources, we choose
Revised: For the sake of saving resources, we choose

Original: BERT base as the backbone instead of BERT large , although our method sacriﬁces a considerable part of the performance.
Revised: BERT base as the backbone instead of BERT large , although our method sacriﬁces a considerable part of the performance.

Original: We select AdamW (Loshchilov & Hutter, 2018) with the learning rate of 1 e −for optimization.
Revised: We select AdamW (Loshchilov & Hutter, 2018) with the learning rate of 1 e −for optimization.

Original: Meanwhile, Warmup (Popel & Bojar, 2018) mechanism is used during training.
Revised: Meanwhile, Warmup (Popel & Bojar, 2018) mechanism is used during training.

Original: The number of layers is 12, and the number of heads is 12.
Revised: The number of layers is 12, and the number of heads is 12.

Original: The hidden size is set to 768 and the batch size is set to 60.
Revised: The hidden size is set to 768 and the batch size is set to 60.

Original: We train the model for 5 epochs in each experiment.
Revised: We train the model for 5 epochs in each experiment.

Original: 4. F EW -S HOT R ELATION L EARNING
Revised: 4. F EW -S HOT R ELATION L EARNING

Original: Dataset We use a large few-shot relation learning dataset FewRel (Han et al., 2018b) in this task.
Revised: Dataset We use a large few-shot relation learning dataset FewRel (Han et al., 2018b) in this task.

Original: FewRel consists of 70000 sentences (about 25 tokens in each sentence) of 100 relations (700 sentences for each relation), on the basis of Wikipedia.
Revised: FewRel consists of 70000 sentences (about 25 tokens in each sentence) of 100 relations (700 sentences for each relation), on the basis of Wikipedia.

Original: We utilize the ofﬁcial evaluation setting which splits the 100 relations into 64, 16, 20 relations for training, validation, and testing respectively.
Revised: We utilize the ofﬁcial evaluation setting which splits the 100 relations into 64, 16, 20 relations for training, validation, and testing respectively.

Original: Experimental settings We use accuracy as the evaluation metric in this task.
Revised: Experimental settings We use accuracy as the evaluation metric in this task.

Original: The batch size for few-shot training is 4, the training step is 20000 and the learning rate is 2e-5 with AdamW.
Revised: The batch size for few-shot training is 4, the training step is 20000 and the learning rate is 2e-5 with AdamW.

Original: We follow the original meaning of N-way-K-shot in this paper, please refer to (Han et al., 2018b) for details.
Revised: We follow the original meaning of N-way-K-shot in this paper, please refer to (Han et al., 2018b) for details.

Original: Results and analysis The results for few-shot relation learning are illustrated in Table 1.
Revised: Results and analysis The results for few-shot relation learning are illustrated in Table 1.

Original: It is worth noting that we report the average score rather than the best score of each method for the sake of fairness.
Revised: It is worth noting that we report the average score rather than the best score of each method for the sake of fairness.

Original: One observation is that the task is challenging without the effectiveness of pre-trained language models.
Revised: One observation is that the task is challenging without the effectiveness of pre-trained language models.

Original: Prototypical network (CNN) only yields 69.20 and 56.44 accuracies (%) forway 1 shot and 10 way 1 shot respectively.
Revised: Prototypical network (CNN) only yields 69.20 and 56.44 accuracies (%) forway 1 shot and 10 way 1 shot respectively.

Original: Methods that have achieved signiﬁcant performances on supervised RE (such as PCNN, GNN, and Prototypical Network) suffer grave declines.
Revised: Methods that have achieved signiﬁcant performances on supervised RE (such as PCNN, GNN, and Prototypical Network) suffer grave declines.

Original: MTB learns the metrics between statements based on large pre-trained language models and yield surprising results on this task.
Revised: MTB learns the metrics between statements based on large pre-trained language models and yield surprising results on this task.

Original: Better performance gains by considering the semantic information by applying ﬁxed-prototypes to MTB (IND strategy).
Revised: Better performance gains by considering the semantic information by applying ﬁxed-prototypes to MTB (IND strategy).

Original: The collaborative prototype-based methods are proven to be effective as shown in the last four rows.
Revised: The collaborative prototype-based methods are proven to be effective as shown in the last four rows.

Original: The results of COL ( L S2S (cid:48)
Revised: The results of COL ( L S2S (cid:48)

Original: + L Z2S + L Z2S (cid:48) ) indicate that the loss of MTB have little inﬂuence for the performance.
Revised: + L Z2S + L Z2S (cid:48) ) indicate that the loss of MTB have little inﬂuence for the performance.

Original: Finally, our ﬁnal collaborative model achieve the best performance on all the N -way K -shot settings.
Revised: Finally, our ﬁnal collaborative model achieve the best performance on all the N -way K -shot settings.

Original: Our method also outperforms human inway 1 shot setting (92.41 vs 92.22) and 10 way 1 shot setting (86.39 vs 85.88).
Revised: Our method also outperforms human inway 1 shot setting (92.41 vs 92.22) and 10 way 1 shot setting (86.39 vs 85.88).

Original: Effect of the amount of training data In real-world scenarios, it is costly and labor-consuming to construct a dataset like FewRel containing 70,000 positive instances.
Revised: Effect of the amount of training data In real-world scenarios, it is costly and labor-consuming to construct a dataset like FewRel containing 70,000 positive instances.

Original: Some relations rarely appear in public articles and obtain candidate instances via distance supervision introduces much noise.
Revised: Some relations rarely appear in public articles and obtain candidate instances via distance supervision introduces much noise.

Original: Therefore, the amount of instances to annotate may much larger than 70, 000.
Revised: Therefore, the amount of instances to annotate may much larger than 70, 000.

Original: To investigate the ability of few-shot classiﬁcation when lack of high-quality task-speciﬁc training data, we intentionally control the amount of instances in training data and run evaluations with the new training set.
Revised: To investigate the ability of few-shot classiﬁcation when lack of high-quality task-speciﬁc training data, we intentionally control the amount of instances in training data and run evaluations with the new training set.

Original: Figureand Figure 4 respectively display the accuracy of the 5-way-1-shot task given a limited numberof relation types or amount of instances of each relation in training data.
Revised: Figureand Figure 4 respectively display the accuracy of the 5-way-1-shot task given a limited number

Original: As shown in the ﬁgures, pre-trained relation encoders outperform the basic BERT EM model when short of training data.

Original: [Table]
Revised: [Table]

Original: ) 91.08 ( ↑ ) 95.52 ( ↑ ) 85.83 ( ↑ ) 92.18 ( ↑ ) COL Final ( L S2S + L Z + L CLS ) 92.51 ( ↑ ) 95.88 ( ↑ ) 86.39 ( ↑ ) 92.76 ( ↑ )
Revised: ) 91.08 ( ↑ ) [Figure] 52 ( ↑ ) 85.83 ( ↑ ) 92.18 ( ↑ ) COL Final ( L S2S + L Z + L CLS ) 92.51 ( ↑ ) 95.88 ( ↑ ) 86.39 ( ↑ ) 92.76 ( ↑ )

Original: [Figure]
Revised: [Figure]

Original: Number of
Revised: Number of

Original: [Figure]

Original: in

Original: [Figure]
Revised: [Figure]

Original: BERTMTBOurs
Revised: BERTMTBOurs

Original: [Figure]
Revised: [Figure]

Revised: [Figure]

Revised: [Figure]

Revised: [Figure]

Revised: [Figure]

Original: Δ
Revised: Δ

Original: [Figure]
Revised: [Figure]

Original: Number of instancesper type in
Revised: [Figure] [Figure] [Figure] of instances

Original: [Figure]
Revised: [Figure]

Original: BERTMTBOurs

Revised: [Figure]

Original: [Figure]
Revised: [Figure]

Original: r ac y
Revised: r ac y

Original: Number of relation types in training
Revised: Number of relation types in training

Original: BERTMTBOurs 71.
Revised: BERTMTBOurs 71.

Original: Δ = 17 .(cid:6418)(cid:3794) 1-1 #Rel
Revised: Δ = 17 .(cid:6418)(cid:3794) 1-1 #Rel

Original: BERT
Revised: BERT

Original: MTB
Revised: MTB

Original: Ours71.
Revised: Ours71.

Original: A cc u r ac y
Revised: A cc u r ac y

Original: Number of instances per type in training
Revised: Number of instances per type in training

Original: BERTMTBOurs
Revised: BERTMTBOurs

Revised: Figure of relation types or amount of instances of each relation in training data.

Revised: As shown in the ﬁgures, pre-trained relation encoders outperform the basic BERT EM model when short of training data.

Original: Encoder learned with our proposed method shows large superiority over the others, when there is no training data (0), the absolute improvement of our framework is 17.96 .
Revised: Encoder learned with our proposed method shows large superiority over the others, when there is no training data (0), the absolute improvement of our framework is 17.96 .

Original: Besides, the accuracy increase with the increment of training data regardless of providing more relations or more instances of each relation.
Revised: Besides, the accuracy increase with the increment of training data regardless of providing more relations or more instances of each relation.

Original: However, the diversity of relations is more important, since the performance in
Revised: However, the diversity of relations is more important, since the performance in

Original: Figure 4 outperforms those in Figure 3 while the former is trained on a much smaller training data.
Revised: Figure 4 outperforms those in Figure 3 while the former is trained on a much smaller training data.

Original: Lack of diversity even hurts the performance when applying relation encoder which is learned with prototype-statement metric.
Revised: Lack of diversity even hurts the performance when applying relation encoder which is learned with prototype-statement metric.

Original: Similar conclusions have been mentioned in Soares et al.
Revised: Similar conclusions have been mentioned in Soares et al.

Original: 4. F UZZY R ELATION E VALUATION
Revised: 4. F UZZY R ELATION E VALUATION

Original: Dataset Aimed at evaluating relation representation learning on the noisy weakly supervised corpus, we propose a new evaluation dataset named FuzzyRED to quantitatively evaluate the capture of relational information.
Revised: Dataset Aimed at evaluating relation representation learning on the noisy weakly supervised corpus, we propose a new evaluation dataset named FuzzyRED to quantitatively evaluate the capture of relational information.

Original: FuzzyRED is constructed aimed at the shortcoming of distant supervision, that is not all the statements contain the same entity pairs express the same relation.
Revised: FuzzyRED is constructed aimed at the shortcoming of distant supervision, that is not all the statements contain the same entity pairs express the same relation.

Original: All the instances are from the weakly-supervised data and manually annotated binary labels to judge if the sentence semantically expresses the relation.
Revised: All the instances are from the weakly-supervised data and manually annotated binary labels to judge if the sentence semantically expresses the relation.

Original: For example, for “Jack was born in London , UK ”, even if the relation Capital is correct between the entities in knowledge base, the sentence does not express the capital relationship and will be labeled as False in FuzzyRED.
Revised: For example, for “Jack was born in London , UK ”, even if the relation Capital is correct between the entities in knowledge base, the sentence does not express the capital relationship and will be labeled as False in FuzzyRED.

Original: The dataset contains 1000 manually annotated instances covering 20 relations.
Revised: The dataset contains 1000 manually annotated instances covering 20 relations.

Original: For detailed information please refer to Appendix A.
Revised: For detailed information please refer to Appendix A.

Original: Experimental settings The pre-trained relation encoders are directly utilized on FuzzyRED and expected to separate the false positive instances from true positives.
Revised: Experimental settings The pre-trained relation encoders are directly utilized on FuzzyRED and expected to separate the false positive instances from true positives.

Original: For each relation, we calculate the minimum of statement-statement distances among all true positives as the threshold T .
Revised: For each relation, we calculate the minimum of statement-statement distances among all true positives as the threshold T .

Original: Then for each instance s to be classiﬁed, we sample 1 K (k-shot) true positive instances s (cid:48) ∈ { s 1 , s 2 , ..., s K } and compare the average score of a = p ( l = 1 | s, s (cid:48) ) with T .
Revised: Then for each instance s to be classiﬁed, we sample 1 K (k-shot) true positive instances s (cid:48) ∈ { s 1 , s 2 , ..., s K } and compare the average score of a = p ( l = 1 | s, s (cid:48) ) with T .

Original: If a > T , the instance is classiﬁed as positive.
Revised: If a > T , the instance is classiﬁed as positive.

Original: FuzzyRED is considerably challenging since it is designed for the issue of distant supervision and directly reﬂects the gap between semantic relations and annotation information.
Revised: FuzzyRED is considerably challenging since it is designed for the issue of distant supervision and directly reﬂects the gap between semantic relations and annotation information.

Original: [Table]
Revised: [Table]

Original: Results
Revised: Results

Original: The accuracies of FuzzyRED are reported in Table 2.
Revised: The accuracies of FuzzyRED are reported in Table 2.

Original: The accuracy of labels annotated according to the DS assumption is denoted by DS, which indicates that the majority of the dataset are noise.
Revised: The accuracy of labels annotated according to the DS assumption is denoted by DS, which indicates that the majority of the dataset are noise.

Original: From the experimental results, we could ﬁrstly observe that all the relation encoders suffer from the noise issue and get lower results.
Revised: From the experimental results, we could ﬁrstly observe that all the relation encoders suffer from the noise issue and get lower results.

Original: The impact of noise increases with the k increasing.
Revised: The impact of noise increases with the k increasing.

Original: But Tablestill shows that pre-trained relation encoders do detect a few noise data thus they all yield better performance than DS.
Revised: But Tablestill shows that pre-trained relation encoders do detect a few noise data thus they all yield better performance than DS.

Original: Taking consideration of noise by prototypes leads to better performances, and the ﬁxed prototypes play a small role to detect the complex semantics that express relations.
Revised: Taking consideration of noise by prototypes leads to better performances, and the ﬁxed prototypes play a small role to detect the complex semantics that express relations.

Original: Even though the COL model achieves remarkable improvement, the evaluation task is still very challenging because of the fuzziness of relation semantics.
Revised: Even though the COL model achieves remarkable improvement, the evaluation task is still very challenging because of the fuzziness of relation semantics.

Original: 4. S UPERVISED R ELATION L EARNINGDataset
Revised: 4. S UPERVISED R ELATION L EARNING

Original:  We use classic benchmark dataset SemEval 2010 Task 8 (Hendrickx et al., 2010) as the dataset for supervised relation learning.
Revised: Dataset We use classic benchmark dataset SemEval 2010 Task 8 (Hendrickx et al., 2010) as the dataset for supervised relation learning.

Original: SemEval 2010 Task 8 contains nine different pre-deﬁned bidirectional relations and a None relation, thus the task is a 19-way classiﬁcation.
Revised: SemEval 2010 Task 8 contains nine different pre-deﬁned bidirectional relations and a None relation, thus the task is a 19-way classiﬁcation.

Original: For model selection, we randomly sample 1500 instances from the ofﬁcial training data as the validation set.
Revised: For model selection, we randomly sample 1500 instances from the ofﬁcial training data as the validation set.

Original: [Table]
Revised: [Table]

Original: Experimental settings For evaluation, we use standard precision, recall, and Fmeasure for supervised RE task.
Revised: Experimental settings For evaluation, we use standard precision, recall, and Fmeasure for supervised RE task.

Original: Since the annotation schema of SemEval dataset differs from the data for the encoder training, we ﬁne-tune the relation encoder in SemEval training data.
Revised: Since the annotation schema of SemEval dataset differs from the data for the encoder training, we ﬁne-tune the relation encoder in SemEval training data.

Original: The batch size is set to 20, the training epoch is 30, the learning rate is 1ewith Adam (Kingma & Ba, 2014).
Revised: The batch size is set to 20, the training epoch is 30, the learning rate is 1ewith Adam (Kingma & Ba, 2014).

Original: We note that the numbers for MTB are different from their paper because their original setting uses BERTLarge with 600 million instances and is trained on TPUs.
Revised: We note that the numbers for MTB are different from their paper because their original setting uses BERT large with 600 million instances and is trained on TPUs.

Original: Given the restricted resources at hand, to make fair comparison, we re-implemented their model with BERTBase and pretrain it in our setting (0.86 million instances).
Revised: Given the restricted resources at hand, to make fair comparison, we re-implemented their model with BERT base and pretrain it in our setting (0.86 million instances).

Original: [Figure]
Revised: [Figure]

Revised: [Table]

Revised: [Figure]

Revised: [Table]

Revised: [Figure]

Revised: [Table]

Revised: [Figure]

Revised: [Table]

Revised: [Figure]

Revised: [Table]

Revised: [Figure]

Revised: [Table]

Revised: [Figure]

Revised: [Table]

Revised: [Figure]

Revised: [Table]

Revised: [Figure]

Revised: [Table]

Revised: [Figure]

Original: Results
Revised: Results

Original: The results for supervised RE are reported in Table 3.
Revised: The results for supervised RE are reported in Table 3.

Original: As a classic benchmark task, results on SemEval 2010 Task 8 are already relatively high compared with other supervised RE tasks.
Revised: As a classic benchmark task, results on SemEval 2010 Task 8 are already relatively high compared with other supervised RE tasks.

Original: The BERT based models outperform the traditional model signiﬁcantly.
Revised: The BERT based models outperform the traditional model signiﬁcantly.

Original: By ﬁne-tuning the relation encoder in Semeval training data, we gain 0.6 percent improvement over the original BERT model.
Revised: By ﬁne-tuning the relation encoder in Semeval training data, we gain 0.6 percent improvement over the original BERT model.

Original: We also calculate the Silhouette Coefﬁcient (Rousseeuw, 1987) to evaluate the denseness of the learned representations for one class.

Original: The computation is β − α max( α,β ) ( − 1 , 1) , where α is the mean distance between a sample and all other points in the same class and β is the mean distance between a sample and all other points in the next nearest class.

Original: The BERT model yields − 0 .

Original: 2438 and our model yields 0 .

Original: Since the SemEval data contains rich semantical information, it is meaningful to visualize the relation representations produced by the trained relation encoders.
Revised: Since the SemEval data contains rich semantical information, it is meaningful to visualize the relation representations produced by the trained relation encoders.

Original: In this part, we use t -SNE (Maaten & Hinton, 2008) method to project the 768 -dimensional relation representations of the test set of SemEval data to 2 -dimensional points.
Revised: In this part, we use tSNE (Maaten & Hinton, 2008) method to project the 768 -dimensional relation representations of the test set of SemEval data to 2 -dimensional points.

Original: The visualization is illustrated in Figure 5, where each round marker represents a statement and a star marker represents a prototype.
Revised: The visualization is illustrated in Figure 5, where each round marker represents a statement and a star marker represents a prototype.

Original: First, the visualization shows that statements are well clustered and the prototypes are effectively learned for all the relations.
Revised: First, the visualization shows that statements are well clustered and the prototypes are effectively learned for all the relations.

Original: Another interesting observation is that the visualization shows visible directions and it is identical to our geometric explanation Section 3.1.
Revised: Another interesting observation is that the visualization shows visible directions and it is identical to our geometric explanation Section 3.1.

Original: 4. A TOY E XPERIMENT OF D ECISION B OUNDARIES FOR P ROTOTYPICAL L EARNING
Revised: 4. A TOY E XPERIMENT OF D ECISION B OUNDARIES FOR P ROTOTYPICAL L EARNING

Original: In section 3.1, we mention that the prototype-level classiﬁcation (equation 6) reduces the disortion of the decision boundary caused by noisy labels.
Revised: In section 3.1, we mention that the prototype-level classiﬁcation (equation 6) reduces the disortion of the decision boundary caused by noisy labels.

Original: In this section, we carry out a toy experiment to explore the point.
Revised: In this section, we carry out a toy experiment to explore the point.

Original: We perform a simple binary classiﬁcation on the iris dataset (Blake, 1998).
Revised: We perform a simple binary classiﬁcation on the iris dataset (Blake, 1998).

Original: Here, we use the instance-level linear classiﬁer and the prototype-level classiﬁer.
Revised: Here, we use the instance-level linear classiﬁer and the prototype-level classiﬁer.

Original: For the prototype-level classiﬁer, the decision function could be written as g ( x ) =
Revised: For the prototype-level classiﬁer, the decision function could be written as g ( x ) =

Original: sign (cid:107) ( x − z − ) (cid:107) 2 − (cid:107) ( x − z + ) (cid:107) 2 , where x is a data point and z − and z + represent the prototypes for two classes.
Revised: sign (cid:107) ( x − z − ) (cid:107) 2 − (cid:107) ( x − z + ) (cid:107) 2 , where x is a data point and z − and z + represent the prototypes for two classes.

Original: This equation is also equivalent to a linear classiﬁer g ( x ) = sign( w (cid:62) x + b ) with w = z + − z − and b = (cid:107) z − (cid:107) 2 −(cid:107)
Revised: This equation is also equivalent to a linear classiﬁer g ( x ) = sign( w (cid:62) x + b ) with w = z + − z − and b = (cid:107) z − (cid:107) 2 −(cid:107)

Original: z + (cid:107) 2.
Revised: z + (cid:107) 2.

Original: Prototypes z are computed as the classical mean-of-class (Reed, 1972) method, thus the decision boundary could be easily depicted.
Revised: Prototypes z are computed as the classical mean-of-class (Reed, 1972) method, thus the decision boundary could be easily depicted.

Original: We focus on the distortion of the decision boudaries, as shown in Figure 6, when the instances are wrongly labeled, the instance-level boundary is easily impacted and overﬁtted by noisy labels (Figure 6(b)).
Revised: We focus on the distortion of the decision boudaries, as shown in Figure 6, when the instances are wrongly labeled, the instance-level boundary is easily impacted and overﬁtted by noisy labels (Figure 6(b)).

Original: And the boundary of prototype-level classiﬁer is hardly affected because of the regularization, it is an interesting phenomenon and we believe it worth further theoretical and empirical study.
Revised: And the boundary of prototype-level classiﬁer is hardly affected because of the regularization, it is an interesting phenomenon and we believe it worth further theoretical and empirical study.

Original: The results also demonstrate the potential of our model for the generalization of other standard/noisy/few-shot classiﬁcation tasks. 
Revised: The results also demonstrate the potential of our model for the generalization of other standard/noisy/few-shot classiﬁcation tasks. [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: [Table] 
Revised: [Table] [Figure] [Table] [Figure]

Revised: l

Original: [Figure]
Revised: [Figure]

Revised: i

Original: [Table]
Revised: [Figure]

Revised: h

Original: [Figure]
Revised: [Figure]

Original:  C ONCLUSION
Revised:  C ONCLUSION

Original: In this paper, we re-consider the essence of relation representation learning and propose an effective method for relation learning directly from the unstructured text with the perspective of prototypical metrics.
Revised: In this paper, we re-consider the essence of relation representation learning and propose an effective method for relation learning directly from the unstructured text with the perspective of prototypical metrics.

Original: We contrastively optimize the metrics between statements and infer a prototype to abstract the core features of a relation class.
Revised: We contrastively optimize the metrics between statements and infer a prototype to abstract the core features of a relation class.

Original: With our method, the learned relation encoder could produce predictive, interpretable, and robust representations over relations.
Revised: With our method, the learned relation encoder could produce predictive, interpretable, and robust representations over relations.

Original: Extensive experiments are conducted to support our claim, and the method also shows the good potential of generalization.
Revised: Extensive experiments are conducted to support our claim, and the method also shows the good potential of generalization.

Original: A CKNOWLEDGMENT
Revised: A CKNOWLEDGMENT

Original: This research is supported by National Natural Science Foundation of China (Grant No.and 6201101015), Alibaba Innovation Research (AIR) programme, the Shenzhen General Research
Revised: This research is supported by National Natural Science Foundation of China (Grant No.and 6201101015), Alibaba Innovation Research (AIR) programme, the Shenzhen General Research

Original: Project (Grand No. JCYJ20190813165003837, No.JCYJ20190808182805919), and Overseas Cooperation Research Fund of Graduate School at Shenzhen, Tsinghua University (Grant No. HW2018002).
Revised: Project (Grand No. JCYJ20190813165003837, No.JCYJ20190808182805919), and Overseas Cooperation Research Fund of Graduate School at Shenzhen, Tsinghua University (Grant No. HW2018002).

Original: Finally, we thank the valuable help of Xu Han and suggestions of all the anonymous reviewers.
Revised: Finally, we thank the valuable help of Xu Han and suggestions of all the anonymous reviewers.

Original: A F UZZY R ELATION E VALUATION D ATASET A. D ISTANT S UPERVISION
Revised: A F UZZY R ELATION E VALUATION D ATASET A. D ISTANT S UPERVISION

Original: Even though our framework is adaptive for a variety of data types, weakly (distantly) supervised data is the most suitable in terms of quantity and quality.
Revised: Even though our framework is adaptive for a variety of data types, weakly (distantly) supervised data is the most suitable in terms of quantity and quality.

Original: Generally, weakly supervised data is constructed on the basis of a large unstructured textual data (e.g. Wikipedia) and a large structured knowledge base (e.g. Wikidata) via the method of distant supervision.
Revised: Generally, weakly supervised data is constructed on the basis of a large unstructured textual data (e.g. Wikipedia) and a large structured knowledge base (e.g. Wikidata) via the method of distant supervision.

Original: First, all the entities are identiﬁed by a named entity recognition system which could tag persons, organizations and locations, etc.
Revised: First, all the entities are identiﬁed by a named entity recognition system which could tag persons, organizations and locations, etc.

Original: Those entities form an entity set E that is mentioned in Section 2.
Revised: Those entities form an entity set E that is mentioned in Section 2.

Original: Then if for a sentence I , the entity pair ( h, t ) also exists in the knowledge base with a relation r , then I will be distantly annotated as r .
Revised: Then if for a sentence I , the entity pair ( h, t ) also exists in the knowledge base with a relation r , then I will be distantly annotated as r .

Original: After the distant supervision, all the relations form a relation set R .
Revised: After the distant supervision, all the relations form a relation set R .

Original: A. M OTIVATION OF F UZZY RED
Revised: A. M OTIVATION OF F UZZY RED

Original: The distant supervision assumption demonstrates that if two entities participate in a relation, then all the sentences that mention these two entities express that relation.
Revised: The distant supervision assumption demonstrates that if two entities participate in a relation, then all the sentences that mention these two entities express that relation.

Original: While obtaining plenty of weakly (distant) supervised data, this assumption has also become the primary drawback of distant supervision.
Revised: While obtaining plenty of weakly (distant) supervised data, this assumption has also become the primary drawback of distant supervision.

Original: Generally, one entity pair in the distant dataset may correspond to multiple relations in different textual environments.
Revised: Generally, one entity pair in the distant dataset may correspond to multiple relations in different textual environments.

Original: For example, the entity pair (Steve Jobs, California) has three relations, which are Place of Birth , Place of Work , and Place of Residence .
Revised: For example, the entity pair (Steve Jobs, California) has three relations, which are Place of Birth , Place of Work , and Place of Residence .

Original: Thus, instances of these corresponding relations prone to introducing false-positive noise.
Revised: Thus, instances of these corresponding relations prone to introducing false-positive noise.

Original: We named such relations as fuzzy relations.
Revised: We named such relations as fuzzy relations.

Original: Intuitively, conducting extraction on fuzzy relations is more challenging.
Revised: Intuitively, conducting extraction on fuzzy relations is more challenging.

Original: To empirically evaluate if encoder trained on distant supervised could really learn the correct semantic from the noisy distant supervised corpus and perform well on Fuzzy relations, we present a novel dataset, namely, Fuzzy Relation Extraction Dataset (FuzzyRED).
Revised: To empirically evaluate if encoder trained on distant supervised could really learn the correct semantic from the noisy distant supervised corpus and perform well on Fuzzy relations, we present a novel dataset, namely, Fuzzy Relation Extraction Dataset (FuzzyRED).

Original: In this section, We will ﬁrstly introduce the construction process for FuzzyRED and report some statistics.
Revised: In this section, We will ﬁrstly introduce the construction process for FuzzyRED and report some statistics.

Original: A. C ONSTRUCTION P ROCESS OF F UZZY RED
Revised: A. C ONSTRUCTION P ROCESS OF F UZZY RED

Original: Broadly speaking, the dataset is selected from a distant supervised corpus and judged by humans to determine whether each instance really expresses the same relation as the distant supervision labels.
Revised: Broadly speaking, the dataset is selected from a distant supervised corpus and judged by humans to determine whether each instance really expresses the same relation as the distant supervision labels.

Original: For instance, sentence ” Jobs was born in California ” really expresses the supervision label ”Place of
Revised: For instance, sentence ” Jobs was born in California ” really expresses the supervision label ”Place of

Original: Birth” while sentence ” Jobs lived in California ” does not.
Revised: Birth” while sentence ” Jobs lived in California ” does not.

Original: The detailed process is as follows:
Revised: The detailed process is as follows:

Original: First, following the distant supervision assumption, we align the relation triples in Wikidata with Wikipedia articles to generate massive relation instances.
Revised: First, following the distant supervision assumption, we align the relation triples in Wikidata with Wikipedia articles to generate massive relation instances.

Original: We count the number of corresponding relations for each entity pair, denote as Count R (pair) .
Revised: We count the number of corresponding relations for each entity pair, denote as Count R (pair) .

Original: For example, the entity pair (Steve Jobs, California) has three relations, which are Place of Birth , Place of Work , and Place of Residence .
Revised: For example, the entity pair (Steve Jobs, California) has three relations, which are Place of Birth , Place of Work , and Place of Residence .

Original: Larger Count R (pair) implies a higher risk of introducing noise.
Revised: Larger Count R (pair) implies a higher risk of introducing noise.

Original: Thus, we consider a pair whose Count R ( pair ) larger than two as an ambiguous seed of the relations that it is involved in.
Revised: Thus, we consider a pair whose Count R ( pair ) larger than two as an ambiguous seed of the relations that it is involved in.

Original: Then, for each relation, we count the number of ambiguous seeds, denote as Count S (rel) .
Revised: Then, for each relation, we count the number of ambiguous seeds, denote as Count S (rel) .

Original: The bigger Count S (rel) is, the more likely the relation will get the wrong data, which will lead to a worse learning effect of the relation.
Revised: The bigger Count S (rel) is, the more likely the relation will get the wrong data, which will lead to a worse learning effect of the relation.

Original: We sort the relations according to Count S (rel) and select the top 20 relations as fuzzy relations of FuzzyRED.
Revised: We sort the relations according to Count S (rel) and select the top 20 relations as fuzzy relations of FuzzyRED.

Original: For each relation, 50 instances are randomly selected to annotate.
Revised: For each relation, 50 instances are randomly selected to annotate.

Original: For the speciﬁc annotation process, each annotator strictly judges whether the sentence could express the given relation according to the deﬁnition of the relation in Wikidata.
Revised: For the speciﬁc annotation process, each annotator strictly judges whether the sentence could express the given relation according to the deﬁnition of the relation in Wikidata.

Original: A. S TATISTICS OF F UZZY RED
Revised: A. S TATISTICS OF F UZZY RED

Original: In FuzzyRED, there are 20 different kinds of relations, and 50 instances for each relation.
Revised: In FuzzyRED, there are 20 different kinds of relations, and 50 instances for each relation.

Original: As mentioned above, every instance is manually classiﬁed as true positive (TP) or false positive (FP).
Revised: As mentioned above, every instance is manually classiﬁed as true positive (TP) or false positive (FP).

Original: Table 4 shows the statistics of FP rates, which are calculated as
Revised: Table 4 shows the statistics of FP rates, which are calculated as

Original: [Table]
Revised: [Table]

Original: As shown in
Revised: As shown in

Original: Table 4, the average FP rate is more than 50 percent, in other words, the majority of the data are FPs.
Revised: Table 4, the average FP rate is more than 50 percent, in other words, the majority of the data are FPs.

Original: Hence, it is challenging to learn a relation extraction model from FuzzyRED if it doesn’t take the
Revised: Hence, it is challenging to learn a relation extraction model from FuzzyRED if it doesn’t take the

Original: [Table]
Revised: [Table]

Original: noise problem into consideration.
Revised: noise problem into consideration.

Original: In this paper, we empirically evaluate different relation encoders by conducting a binary classiﬁcation task.
Revised: In this paper, we empirically evaluate different relation encoders by conducting a binary classiﬁcation task.

Original: A better encoder is expected to distinguish TPs from FPs.
Revised: A better encoder is expected to distinguish TPs from FPs.

Original: Speciﬁcally, a model based on such relation encoder should predict a higher probability for TPs.
Revised: Speciﬁcally, a model based on such relation encoder should predict a higher probability for TPs.

Original: B A LGORITHMS
Revised: B A LGORITHMS

Original: In Section 3.2, we introduce the adaptation of different downstream scenarios for our framework, which trains an encoder Enc φ .
Revised: In Section 3.2, we introduce the adaptation of different downstream scenarios for our framework, which trains an encoder Enc φ .

Original: In this section, we provide the algorithms for the three relation learning scenarios.
Revised: In this section, we provide the algorithms for the three relation learning scenarios.

Original: Algorithm 1 reports the training of supervied relation learning.
Revised: Algorithm 1 reports the training of supervied relation learning.

Original: Algorithm
Revised: Algorithm

Original: Input: Supervised dataset S r = { s 1: n } , statement encoder Enc φ while not converge do
Revised: Input: Supervised dataset S r = { s 1: n } , statement encoder Enc φ while not converge do

Original: Sample mini-batches S batches from S r .
Revised: Sample mini-batches S batches from S r .

Original: for S batch in S batches do for s in S batch do s =
Revised: for S batch in S batches do for s in S batch do s =

Original: Enc φ ( s ) p ( y | s, θ ) =
Revised: Enc φ ( s ) p ( y | s, θ ) =

Original: Softmax( W s + b ) end for
Revised: Softmax( W s + b ) end for

Original: Update W , b and Enc φ w.r.t.
Revised: Update W , b and Enc φ w.r.t.

Original: l ( θ ) =
Revised: l ( θ ) =

Original: (cid:80) s ∈ S batch log p ( y | s, θ ) end for end while
Revised: (cid:80) s ∈ S batch log p ( y | s, θ ) end for end while

Original: Similarly, Algorithm 2 illustrates the training algorithm for few-shot relation learning.
Revised: Similarly, Algorithm 2 illustrates the training algorithm for few-shot relation learning.

Original: Algorithm
Revised: Algorithm

Original: Input: Few-shot dataset S f , statement encoder Enc φ repeat
Revised: Input: Few-shot dataset S f , statement encoder Enc φ repeat

Original: R (cid:48) =
Revised: R (cid:48) =

Original: SampleRelation( N, R ) .
Revised: SampleRelation( N, R ) .

Original: S = ∅ , Q = ∅ for r in R (cid:48) do { s ri } =
Revised: S = ∅ , Q = ∅ for r in R (cid:48) do { s ri } =

Original: SampleInstance( k, r ) , i ∈ { 1 , 2 ...k } q r = SampleInstanc(1 , r )
Revised: SampleInstance( k, r ) , i ∈ { 1 , 2 ...k } q r = SampleInstanc(1 , r )

Original: S (cid:83) { s ri } , Q (cid:83) { q r } end for for q r in Q do for s r (cid:48)
Revised: S (cid:83) { s ri } , Q (cid:83) { q r } end for for q r in Q do for s r (cid:48)

Original: i in S do sim r (cid:48)
Revised: i in S do sim r (cid:48)

Original: i
Revised: i

Original: =
Revised: =

Original: Enc φ ( q r ) ·
Revised: Enc φ ( q r ) ·

Original: Enc φ ( s r (cid:48) i ) end for ˆ r = argmax r (cid:48) ,r (cid:48) ∈R (cid:48) (sim r (cid:48) i )
Revised: Enc φ ( s r (cid:48) i ) end for ˆ r = argmax r (cid:48) ,r (cid:48) ∈R (cid:48) (sim r (cid:48) i )

Original: Update Enc φ w.r.t.
Revised: Update Enc φ w.r.t.

Original: CrossEntropy( r, ˆ r ) end for until enough steps
Revised: CrossEntropy( r, ˆ r ) end for until enough steps

Original: Algorithm 3 reports the training of fuzzy relation learning.
Revised: Algorithm 3 reports the training of fuzzy relation learning.

Original: Note that FuzzyRED is designed for evaluation, so the algorithm shows the inference phase.
Revised: Note that FuzzyRED is designed for evaluation, so the algorithm shows the inference phase.

Original: Algorithm
Revised: Algorithm

Original: Input: FuzzyRED S z = { s 1: n } , statement encoder Enc φ while not converge do for s in S z do { s i } =
Revised: Input: FuzzyRED S z = { s 1: n } , statement encoder Enc φ while not converge do for s in S z do { s i } =

Original: SampleInstance( k ) , i ∈ { 1 , 2 , ..., k }
Revised: SampleInstance( k ) , i ∈ { 1 , 2 , ..., k }

Original: Compute
Revised: Compute

Original: a w.r.t a = 1 k (cid:80) p ( l = 1 | s, s i ) if a > T then s is true positive (TP) else s is false positive (FP) end if end for end while
Revised: a w.r.t a = 1 k (cid:80) p ( l = 1 | s, s i ) if a > T then s is true positive (TP) else s is false positive (FP) end if end for end while