def test_not_embedding(self):
self.assertEqual(
True,
features.not_embedding(
Mention(None, Span(3, 3), {
"tokens": ["it"],
"type": "PRO",
"fine_type": "PERS"
}),
Mention(
None, Span(0, 4), {
"tokens": ["the", "company", "which", "it", "bought"],
"type": "NOM"
})))
self.assertEqual(
False,
features.not_embedding(
Mention(None, Span(3, 3), {
"tokens": ["its"],
"type": "PRO",
"fine_type": "POSS_ADJ"
}),
Mention(
None, Span(0, 4), {
"tokens":
["the", "company", "which", "loves", "its", "success"],
"type":
"NOM"
})))
def test_mention_get_sentence_id(self):
self.assertEqual(
0,
Mention.from_document(Span(
13, 20), self.real_document).attributes["sentence_id"])
self.assertEqual(
1,
Mention.from_document(Span(
33, 34), self.real_document).attributes["sentence_id"])
def test_mention_get_ancestry(self):
expected = "-L-VBN-L-NONE"
self.assertEqual(
expected,
Mention.from_document(Span(11, 11),
self.real_document).attributes["ancestry"])
expected = "-R-NNS-R-VBN"
self.assertEqual(
expected,
Mention.from_document(Span(0, 0),
self.real_document).attributes["ancestry"])
def test_mention_tokens(self):
expected = ["the", "massacre"]
self.assertEqual(
expected,
Mention.from_document(Span(33, 34),
self.real_document).attributes["tokens"])
expected = "the massacre"
self.assertEqual(
expected,
Mention.from_document(
Span(33, 34),
self.real_document).attributes["tokens_as_lowercase_string"])
def test_get_modifiers(self):
self.assertEqual(
set(["long-awaited", "new", "century"]),
features.get_modifier(
Mention(
None, Span(10, 16), {
"tokens": [
"the", "long-awaited", "beginning", "of", "a",
"new", "century"
],
"head_span":
Span(12, 12),
"pos": ["DT", "JJ", "NN", "IN", "DT", "JJ", "NN"]
})))
def test_mention_set_id(self):
self.assertEqual(
0,
Mention.from_document(Span(
33, 34), self.real_document).attributes["annotated_set_id"])
self.assertEqual(
4,
Mention.from_document(Span(6, 10),
self.complicated_mention_document).
attributes["annotated_set_id"])
self.assertEqual(
1,
Mention.from_document(Span(3, 3), self.complicated_mention_document
).attributes["annotated_set_id"])
def test_non_pronominal_string_match(self):
self.assertEqual(
True,
features.non_pronominal_string_match(
Mention(
None, Span(0, 4), {
"tokens":
["the", "newly-elect", "leader", "'s", "wife"],
"pos": ["DT", "JJ", "NN", "POS", "NN"],
"type": "NOM"
}),
Mention(
None, Span(5, 7), {
"tokens": ["newly-elect", "leader", "wife"],
"pos": ["JJ", "NN", "NN"],
"type": "NOM"
})))
self.assertEqual(
False,
features.non_pronominal_string_match(
Mention(
None, Span(0, 4), {
"tokens":
["the", "newly-elect", "leader", "'s", "wife"],
"pos": ["DT", "JJ", "NN", "POS", "NN"],
"type": "NOM"
}),
Mention(None, Span(5, 5), {
"tokens": ["leader"],
"pos": ["NN"],
"type": "NOM"
})))
self.assertEqual(
True,
features.non_pronominal_string_match(
Mention(None, Span(0, 0), {
"tokens": ["President"],
"pos": ["NNP"],
"type": "NAM"
}),
Mention(
None, Span(1, 2), {
"tokens": ["the", "president"],
"pos": ["DT", "NN"],
"type": "NOM"
})))
self.assertEqual(
False,
features.non_pronominal_string_match(
Mention(None, Span(0, 0), {
"tokens": ["it"],
"pos": ["PRP"],
"type": "PRO"
}),
Mention(None, Span(1, 1), {
"tokens": ["IT"],
"pos": ["NNP"],
"type": "NAM"
})))
def test_get_coref(self):
simple = {Span(13, 20): 0, Span(33, 34): 0}
complicated = {
Span(0, 0): 0,
Span(3, 3): 1,
Span(3, 4): 0,
Span(6, 6): 1,
Span(6, 10): 4,
Span(8, 8): 2,
Span(9, 10): 2,
Span(9, 11): 0
}
self.assertEqual(simple, self.real_document.coref)
self.assertEqual(complicated, self.complicated_mention_document.coref)
def test_mention_get_context(self):
self.assertEqual(
["laid", "plans"],
Mention.from_document(Span(21, 27),
self.date_mention_document).get_context(2))
self.assertEqual(
None,
Mention.from_document(Span(21, 27),
self.date_mention_document).get_context(0))
self.assertEqual(
["through"],
Mention.from_document(Span(31, 32),
self.date_mention_document).get_context(-1))
self.assertEqual(
None,
Mention.from_document(Span(
21, 27), self.date_mention_document).get_context(1000))
def test_mention_get_fine_type(self):
self.assertEqual(
"DEF",
Mention.from_document(Span(33, 34),
self.real_document).attributes["fine_type"])
self.assertEqual(
"DEF",
Mention.from_document(Span(
21, 27), self.date_mention_document).attributes["fine_type"])
self.assertEqual(
"INDEF",
Mention.from_document(Span(
22, 22), self.date_mention_document).attributes["fine_type"])
self.assertEqual(
"POSS_ADJ",
Mention.from_document(Span(
45, 45), self.date_mention_document).attributes["fine_type"])
def test_mention_get_head(self):
expected = ["massacre"]
self.assertEqual(
expected,
Mention.from_document(Span(33, 34),
self.real_document).attributes["head"])
expected = ["Wedding"]
self.assertEqual(
expected,
Mention.from_document(Span(3, 3),
self.for_head_document).attributes["head"])
expected = "wedding"
self.assertEqual(
expected,
Mention.from_document(
Span(3, 3),
self.for_head_document).attributes["head_as_lowercase_string"])
def test_mention_type(self):
self.assertEqual(
"NAM",
Mention.from_document(Span(
37, 37), self.date_mention_document).attributes["type"])
self.assertEqual(
"NAM",
Mention.from_document(Span(
11, 12), self.date_mention_document).attributes["type"])
self.assertEqual(
"NAM",
Mention.from_document(Span(
31, 32), self.date_mention_document).attributes["type"])
self.assertEqual(
"NAM",
Mention.from_document(Span(
8, 8), self.date_mention_document).attributes["type"])
self.assertEqual(
"NOM",
Mention.from_document(Span(33, 34),
self.real_document).attributes["type"])
def test_get_head_index(self):
self.real_example = """#begin document (bn/voa/02/voa_0220); part 000
bn/voa/02/voa_0220 0 0 Unidentified JJ (TOP(S(NP(NP* - - - - * -
bn/voa/02/voa_0220 0 1 gunmen NNS *) - - - - * -
bn/voa/02/voa_0220 0 2 in IN (PP* - - - - * -
bn/voa/02/voa_0220 0 3 north JJ (NP(ADJP* - - - - * -
bn/voa/02/voa_0220 0 4 western JJ *) - - - - * -
bn/voa/02/voa_0220 0 5 Colombia NNP *))) - - - - (GPE) -
bn/voa/02/voa_0220 0 6 have VBP (VP* have - - - * -
bn/voa/02/voa_0220 0 7 massacred VBN (VP* massacre - - - * -
bn/voa/02/voa_0220 0 8 at IN (NP(QP(ADVP* - - - - (CARDINAL* -
bn/voa/02/voa_0220 0 9 least JJS *) - - - - * -
bn/voa/02/voa_0220 0 10 twelve CD *) - - - - *) -
bn/voa/02/voa_0220 0 11 peasants NNS *) - - - - * -
bn/voa/02/voa_0220 0 12 in IN (PP* - - - - * -
bn/voa/02/voa_0220 0 13 the DT (NP(NP* - - - - * (0
bn/voa/02/voa_0220 0 14 second JJ * - - - - (ORDINAL) -
bn/voa/02/voa_0220 0 15 such JJ * - - - - * -
bn/voa/02/voa_0220 0 16 incident NN *) incident - 2 - * -
bn/voa/02/voa_0220 0 17 in IN (PP* - - - - * -
bn/voa/02/voa_0220 0 18 as RB (NP(QP* - - - - (DATE* -
bn/voa/02/voa_0220 0 19 many JJ *) - - - - * -
bn/voa/02/voa_0220 0 20 days NNS *)))))) day - 4 - *) 0)
bn/voa/02/voa_0220 0 21 . . *)) - - - - * -
bn/voa/02/voa_0220 0 0 Local JJ (TOP(S(NP* - - - - * (ARG0* * -
bn/voa/02/voa_0220 0 1 police NNS *) police - - - * *) * -
bn/voa/02/voa_0220 0 2 say VBP (VP* say 01 1 - * (V*) * -
bn/voa/02/voa_0220 0 3 it PRP (SBAR(S(NP*) - - - - * (ARG1* (ARG1*) -
bn/voa/02/voa_0220 0 4 's VBZ (VP* be 01 1 - * * (V*) -
bn/voa/02/voa_0220 0 5 not RB * - - - - * * (ARGM-NEG*) -
bn/voa/02/voa_0220 0 6 clear JJ (ADJP*) - - - - * * (ARG2*) -
bn/voa/02/voa_0220 0 7 who WP (SBAR(WHNP*) - - - - * * * -
bn/voa/02/voa_0220 0 8 was VBD (S(VP* be - 1 - * * * -
bn/voa/02/voa_0220 0 9 responsible JJ (ADJP* - - - - * * * -
bn/voa/02/voa_0220 0 10 for IN (PP* - - - - * * * -
bn/voa/02/voa_0220 0 11 the DT (NP* - - - - * * * (0
bn/voa/02/voa_0220 0 12 massacre NN *)))))))))) massacre - - - * *) * 0)
bn/voa/02/voa_0220 0 13 . . *)) - - - - * * * -
#end document
"""
real_document = CoNLLDocument(self.real_example)
expected = 0
head = nltk.ParentedTree.fromstring("(WHNP (WP who))")
mention_subtree = mention_property_computer.get_relevant_subtree(
Span(29, 34), real_document)
self.assertEqual(
expected,
mention_property_computer.get_head_index(head, mention_subtree))
def test_alias(self):
self.assertEqual(
False,
features.alias(
Mention(None, Span(0, 0), {
"tokens": ["he"],
"type": "PRO",
"citation_form": "he"
}),
Mention(None, Span(1, 1), {
"tokens": ["he"],
"type": "PRO",
"citation_form": "he"
})))
self.assertEqual(
False,
features.alias(
Mention(
None, Span(0, 2), {
"head": ["International", "Business", "Machines"],
"type": "NAM",
"ner": ["ORG", "ORG", "ORG"],
"head_index": 2
}),
Mention(
None, Span(3, 5), {
"head": ["International", "Business", "Machines"],
"type": "NAM",
"ner": ["ORG", "ORG", "ORG"],
"head_index": 2
})))
self.assertEqual(
True,
features.alias(
Mention(
None, Span(0, 2), {
"head": ["International", "Business", "Machines"],
"type": "NAM",
"ner": ["ORG", "ORG", "ORG"],
"head_index": 2
}),
Mention(
None, Span(3, 3), {
"head": ["IBM"],
"type": "NAM",
"ner": ["ORG"],
"head_index": 0
})))
def test_pronoun_same_canonical_form(self):
self.assertEqual(
True,
features.pronoun_same_canonical_form(
Mention(None, Span(0, 0), {
"tokens": ["he"],
"type": "PRO",
"citation_form": "he"
}),
Mention(None, Span(1, 1), {
"tokens": ["he"],
"type": "PRO",
"citation_form": "he"
})))
self.assertEqual(
True,
features.pronoun_same_canonical_form(
Mention(None, Span(0, 0), {
"tokens": ["he"],
"type": "PRO",
"citation_form": "he"
}),
Mention(None, Span(1, 1), {
"tokens": ["him"],
"type": "PRO",
"citation_form": "he"
})))
self.assertEqual(
False,
features.pronoun_same_canonical_form(
Mention(None, Span(0, 0), {
"tokens": ["US"],
"type": "NAM"
}), Mention(None, Span(1, 1), {
"tokens": ["us"],
"type": "PRO"
})))
def test_get_string_representation(self):
expected = """#begin document (/test2); part 000
test2 0 0 This NN (NP* - - - - - (0|(1)
test2 0 1 is NN * - - - - - 0)
test2 0 2 just NN * - - - - - -
test2 0 3 a NN * - - - - - -
test2 0 4 test NN * - - - - - (1
test2 0 5 . NN *) - - - - - (2|1)
test2 0 0 It NN (NP* - - - - - 2)
test2 0 1 shows NN * - - - - - (3)
test2 0 2 that NN * - - - - - (3)
test2 0 3 the NN * - - - - - -
test2 0 4 scorer NN * - - - - - -
test2 0 5 works NN * - - - - - -
test2 0 6 . NN *) - - - - - -
#end document
"""
self.complicated_mention_document.system_mentions = [
Mention(self.complicated_mention_document, Span(0, 0),
{"set_id": 1}),
Mention(self.complicated_mention_document, Span(0, 1),
{"set_id": 0}),
Mention(self.complicated_mention_document, Span(4, 5),
{"set_id": 1}),
Mention(self.complicated_mention_document, Span(5, 6),
{"set_id": 2}),
Mention(self.complicated_mention_document, Span(7, 7),
{"set_id": 3}),
Mention(self.complicated_mention_document, Span(8, 8),
{"set_id": 3}),
]
self.assertEqual(
expected,
self.complicated_mention_document.get_string_representation())
def test_head_match(self):
self.assertEqual(
True,
features.head_match(
Mention(
None, Span(0, 4), {
"tokens":
["the", "newly-elect", "leader", "'s", "wife"],
"head": ["wife"],
"type": "NOM",
"semantic_class": "PERSON"
}),
Mention(
None, Span(5, 6), {
"tokens": ["the", "wife"],
"head": ["wife"],
"type": "NOM",
"semantic_class": "PERSON"
})))
self.assertEqual(
False,
features.head_match(
Mention(
None, Span(0, 4), {
"tokens":
["the", "newly-elect", "leader", "'s", "wife"],
"head": ["wife"],
"type": "NOM",
"semantic_class": "PERSON"
}),
Mention(
None, Span(5, 5), {
"tokens": ["leader"],
"head": ["leader"],
"type": "NOM",
"semantic_class": "PERSON"
})))
self.assertEqual(
True,
features.head_match(
Mention(
None, Span(0, 0), {
"tokens": ["President"],
"head": ["President"],
"type": "NAM",
"semantic_class": "PERSON"
}),
Mention(
None, Span(1, 2), {
"tokens": ["the", "president"],
"head": ["president"],
"type": "NOM",
"semantic_class": "PERSON"
})))
self.assertEqual(
False,
features.head_match(
Mention(
None, Span(0, 0), {
"tokens": ["it"],
"head": ["it"],
"type": "PRO",
"semantic_class": "OBJECT"
}),
Mention(
None, Span(1, 1), {
"tokens": ["it"],
"head": ["it"],
"type": "PRO",
"semantic_class": "OBJECT"
})))
self.assertEqual(
False,
features.head_match(
Mention(
None, Span(0, 1), {
"tokens": ["10", "percent"],
"head": ["percent"],
"type": "NOM",
"semantic_class": "NUMERIC"
}),
Mention(
None, Span(2, 3), {
"tokens": ["Some", "percent"],
"head": ["percent"],
"type": "NOM",
"semantic_class": "NUMERIC"
})))
def test_parse(self):
self.assertEqual(Span(10, 12), Span.parse("(10, 12)"))
self.assertEqual(Span(10, 12), Span.parse("(10,12)"))
def test_not_modifier(self):
self.assertEqual(
True,
features.not_modifier(
Mention(
None, Span(10, 16), {
"tokens": [
"the", "long-awaited", "beginning", "of", "a",
"new", "century"
],
"type":
"NOM",
"head_span":
Span(12, 12),
"pos": ["DT", "JJ", "NN", "IN", "DT", "JJ", "NN"]
}),
Mention(
None, Span(0, 1), {
"tokens": ["the", "beginning"],
"type": "NOM",
"head_span": Span(1, 1),
"pos": ["DT", "NN"]
})))
self.assertEqual(
False,
features.not_modifier(
Mention(
None, Span(18, 19), {
"tokens": ["the", "beginning"],
"type": "NOM",
"head_span": Span(19, 19),
"pos": ["DT", "NN"]
}),
Mention(
None, Span(10, 16), {
"tokens": [
"the", "long-awaited", "beginning", "of", "a",
"new", "century"
],
"type":
"NOM",
"head_span":
Span(12, 12),
"pos": ["DT", "JJ", "NN", "IN", "DT", "JJ", "NN"]
}),
))
self.assertEqual(
False,
features.not_modifier(
Mention(
None, Span(18, 19), {
"tokens": ["cool", "people"],
"type": "NOM",
"head_span": Span(19, 19),
"pos": ["JJ", "NNS"]
}),
Mention(
None, Span(10, 11), {
"tokens": ["Cool", "people"],
"type": "NOM",
"head_span": Span(11, 11),
"pos": ["JJ", "NNS"]
}),
))
def test_mention_get_governor(self):
expected = "massacred"
self.assertEqual(
expected,
Mention.from_document(Span(0, 1),
self.real_document).attributes["governor"])
def test_not_compatible(self):
self.assertEqual(
True,
features.not_compatible(
Mention(
None, Span(0, 0), {
"tokens": ["he"],
"pos": ["PRP"],
"type": "PRO",
"number": "SINGULAR",
"gender": "MALE",
"semantic_class": "PERSON"
}),
Mention(
None, Span(1, 1), {
"tokens": ["she"],
"pos": ["PRP"],
"type": "PRO",
"number": "SINGULAR",
"gender": "FEMALE",
"semantic_class": "PERSON"
})))
self.assertEqual(
False,
features.not_compatible(
Mention(
None, Span(0, 0), {
"tokens": ["he"],
"pos": ["PRP"],
"type": "PRO",
"number": "SINGULAR",
"gender": "MALE",
"semantic_class": "PERSON"
}),
Mention(
None, Span(1, 1), {
"tokens": ["slawabu"],
"pos": ["NN"],
"type": "NOM",
"number": "UNKNOWN",
"gender": "UNKNOWN",
"semantic_class": "PERSON"
})))
self.assertEqual(
False,
features.not_compatible(
Mention(
None, Span(0, 0), {
"tokens": ["Jesus"],
"pos": ["NNP"],
"type": "NAM",
"number": "SINGULAR",
"gender": "MALE",
"semantic_class": "PERSON"
}),
Mention(
None, Span(1, 1), {
"tokens": ["Jesus"],
"pos": ["NNP"],
"type": "NAM",
"number": "SINGULAR",
"gender": "UNKNOWN",
"semantic_class": "NORP"
})))
def test_mention_get_head_span(self):
self.assertEqual(
Span(9, 10),
Mention.from_document(Span(
8, 10), self.for_head_document).attributes["head_span"])
def test_not_speaker(self):
self.assertEqual(
True,
features.not_speaker(
Mention(
None, Span(3, 3), {
"tokens": ["I"],
"type": "PRO",
"citation_form": "i",
"speaker": "snafu"
}),
Mention(
None, Span(0, 0), {
"tokens": ["I"],
"type": "PRO",
"citation_form": "i",
"speaker": "foo"
}),
))
self.assertEqual(
True,
features.not_speaker(
Mention(
None, Span(3, 3), {
"tokens": ["us"],
"type": "PRO",
"citation_form": "we",
"speaker": "snafu"
}),
Mention(
None, Span(0, 0), {
"tokens": ["we"],
"type": "PRO",
"citation_form": "we",
"speaker": "foo"
}),
))
self.assertEqual(
False,
features.not_speaker(
Mention(
None, Span(3, 3), {
"tokens": ["you"],
"type": "PRO",
"citation_form": "you",
"speaker": "snafu"
}),
Mention(
None, Span(0, 0), {
"tokens": ["I"],
"type": "PRO",
"citation_form": "i",
"speaker": "foo"
}),
))
self.assertEqual(
True,
features.not_speaker(
Mention(
None, Span(3, 3), {
"tokens": ["you"],
"type": "PRO",
"citation_form": "you",
"speaker": "snafu"
}),
Mention(
None, Span(0, 0), {
"tokens": ["I"],
"type": "PRO",
"citation_form": "i",
"speaker": "snafu"
}),
))
def test_is_coreferent_with(self):
self.assertEqual(
True,
Mention(None, Span(0, 0), {
"annotated_set_id": 1
}).is_coreferent_with(
Mention(None, Span(3, 4), {"annotated_set_id": 1})))
self.assertEqual(
False,
Mention(None, Span(0, 0), {
"annotated_set_id": 1
}).is_coreferent_with(
Mention(None, Span(3, 4), {"annotated_set_id": 0})))
self.assertEqual(
False,
Mention(None, Span(0, 0), {
"annotated_set_id": None
}).is_coreferent_with(
Mention(None, Span(3, 4), {"annotated_set_id": None})))
self.assertEqual(
True,
Mention(self.complicated_mention_document, Span(0, 0), {
"annotated_set_id": 1
}).is_coreferent_with(
Mention(self.complicated_mention_document, Span(3, 4),
{"annotated_set_id": 1})))
self.assertEqual(
False,
Mention(self.complicated_mention_document, Span(0, 0), {
"annotated_set_id": None
}).is_coreferent_with(
Mention(self.complicated_mention_document, Span(3, 4),
{"annotated_set_id": None})))
self.assertEqual(
False,
Mention(self.complicated_mention_document, Span(0, 0), {
"annotated_set_id": 1
}).is_coreferent_with(
Mention(self.real_document, Span(13, 20),
{"annotated_set_id": 1})))
def test_not_pronoun_distance(self):
self.assertEqual(
False,
features.not_pronoun_distance(
Mention(
None, Span(0, 0), {
"tokens": ["he"],
"type": "PRO",
"citation_form": "he",
"sentence_id": 10
}),
Mention(
None, Span(100, 100), {
"tokens": ["he"],
"type": "PRO",
"citation_form": "he",
"sentence_id": 0
})))
self.assertEqual(
True,
features.not_pronoun_distance(
Mention(
None, Span(100, 100), {
"tokens": ["it"],
"type": "PRO",
"citation_form": "it",
"sentence_id": 10
}),
Mention(None, Span(0, 0), {
"tokens": ["company"],
"type": "NOM",
"sentence_id": 0
})))
self.assertEqual(
False,
features.not_pronoun_distance(
Mention(
None, Span(100, 100), {
"tokens": ["them"],
"type": "PRO",
"citation_form": "they",
"sentence_id": 10
}),
Mention(None, Span(0, 0), {
"tokens": ["company"],
"type": "NOM",
"sentence_id": 0
})))
self.assertEqual(
False,
features.not_pronoun_distance(
Mention(
None, Span(100, 100), {
"tokens": ["them"],
"type": "PRO",
"citation_form": "they",
"sentence_id": 1
}),
Mention(None, Span(0, 0), {
"tokens": ["company"],
"type": "NOM",
"sentence_id": 0
})))
def test_extract_sentence_spans(self):
sentence_spans = [Span(0, 21), Span(22, 35)]
self.assertEqual(sentence_spans, self.real_document.sentence_spans)
def test_get_sentence_id_and_span(self):
expected = 1, Span(22, 35)
self.assertEqual(
expected, self.real_document.get_sentence_id_and_span(Span(23,
24)))
def test_parse(self):
self.assertEqual(Span(10, 12), Span.parse("(10, 12)"))
self.assertEqual(Span(10, 12), Span.parse("(10,12)"))
def test_span(self):
span = Span(0, 1)
self.assertEqual(0, span.begin)
self.assertEqual(1, span.end)
