mirror of
https://github.com/explosion/spaCy.git
synced 2024-11-11 04:08:09 +03:00
397 lines
13 KiB
Python
397 lines
13 KiB
Python
import pytest
|
|
from spacy.training.example import Example
|
|
from spacy.tokens import Doc
|
|
from spacy.vocab import Vocab
|
|
|
|
|
|
def test_Example_init_requires_doc_objects():
|
|
vocab = Vocab()
|
|
with pytest.raises(TypeError):
|
|
Example(None, None)
|
|
with pytest.raises(TypeError):
|
|
Example(Doc(vocab, words=["hi"]), None)
|
|
with pytest.raises(TypeError):
|
|
Example(None, Doc(vocab, words=["hi"]))
|
|
|
|
|
|
def test_Example_from_dict_basic():
|
|
example = Example.from_dict(
|
|
Doc(Vocab(), words=["hello", "world"]), {"words": ["hello", "world"]}
|
|
)
|
|
assert isinstance(example.x, Doc)
|
|
assert isinstance(example.y, Doc)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"annots", [{"words": ["ice", "cream"], "weirdannots": ["something", "such"]}]
|
|
)
|
|
def test_Example_from_dict_invalid(annots):
|
|
vocab = Vocab()
|
|
predicted = Doc(vocab, words=annots["words"])
|
|
with pytest.raises(KeyError):
|
|
Example.from_dict(predicted, annots)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"pred_words", [["ice", "cream"], ["icecream"], ["i", "ce", "cream"]]
|
|
)
|
|
@pytest.mark.parametrize("annots", [{"words": ["icecream"], "tags": ["NN"]}])
|
|
def test_Example_from_dict_with_tags(pred_words, annots):
|
|
vocab = Vocab()
|
|
predicted = Doc(vocab, words=pred_words)
|
|
example = Example.from_dict(predicted, annots)
|
|
for i, token in enumerate(example.reference):
|
|
assert token.tag_ == annots["tags"][i]
|
|
aligned_tags = example.get_aligned("TAG", as_string=True)
|
|
assert aligned_tags == ["NN" for _ in predicted]
|
|
|
|
|
|
@pytest.mark.filterwarnings("ignore::UserWarning")
|
|
def test_aligned_tags():
|
|
pred_words = ["Apply", "some", "sunscreen", "unless", "you", "can", "not"]
|
|
gold_words = ["Apply", "some", "sun", "screen", "unless", "you", "cannot"]
|
|
gold_tags = ["VERB", "DET", "NOUN", "NOUN", "SCONJ", "PRON", "VERB"]
|
|
annots = {"words": gold_words, "tags": gold_tags}
|
|
vocab = Vocab()
|
|
predicted = Doc(vocab, words=pred_words)
|
|
example1 = Example.from_dict(predicted, annots)
|
|
aligned_tags1 = example1.get_aligned("TAG", as_string=True)
|
|
assert aligned_tags1 == ["VERB", "DET", "NOUN", "SCONJ", "PRON", "VERB", "VERB"]
|
|
# ensure that to_dict works correctly
|
|
example2 = Example.from_dict(predicted, example1.to_dict())
|
|
aligned_tags2 = example2.get_aligned("TAG", as_string=True)
|
|
assert aligned_tags2 == ["VERB", "DET", "NOUN", "SCONJ", "PRON", "VERB", "VERB"]
|
|
|
|
|
|
def test_aligned_tags_multi():
|
|
pred_words = ["Applysome", "sunscreen", "unless", "you", "can", "not"]
|
|
gold_words = ["Apply", "somesun", "screen", "unless", "you", "cannot"]
|
|
gold_tags = ["VERB", "DET", "NOUN", "SCONJ", "PRON", "VERB"]
|
|
annots = {"words": gold_words, "tags": gold_tags}
|
|
vocab = Vocab()
|
|
predicted = Doc(vocab, words=pred_words)
|
|
example = Example.from_dict(predicted, annots)
|
|
aligned_tags = example.get_aligned("TAG", as_string=True)
|
|
assert aligned_tags == [None, None, "SCONJ", "PRON", "VERB", "VERB"]
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"annots",
|
|
[
|
|
{
|
|
"words": ["I", "like", "London", "and", "Berlin", "."],
|
|
"deps": ["nsubj", "ROOT", "dobj", "cc", "conj", "punct"],
|
|
"heads": [1, 1, 1, 2, 2, 1],
|
|
}
|
|
],
|
|
)
|
|
def test_Example_from_dict_with_parse(annots):
|
|
vocab = Vocab()
|
|
predicted = Doc(vocab, words=annots["words"])
|
|
example = Example.from_dict(predicted, annots)
|
|
for i, token in enumerate(example.reference):
|
|
assert token.dep_ == annots["deps"][i]
|
|
assert token.head.i == annots["heads"][i]
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"annots",
|
|
[
|
|
{
|
|
"words": ["Sarah", "'s", "sister", "flew"],
|
|
"morphs": [
|
|
"NounType=prop|Number=sing",
|
|
"Poss=yes",
|
|
"Number=sing",
|
|
"Tense=past|VerbForm=fin",
|
|
],
|
|
}
|
|
],
|
|
)
|
|
def test_Example_from_dict_with_morphology(annots):
|
|
vocab = Vocab()
|
|
predicted = Doc(vocab, words=annots["words"])
|
|
example = Example.from_dict(predicted, annots)
|
|
for i, token in enumerate(example.reference):
|
|
assert str(token.morph) == annots["morphs"][i]
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"annots",
|
|
[
|
|
{
|
|
"words": ["This", "is", "one", "sentence", "this", "is", "another"],
|
|
"sent_starts": [1, 0, 0, 0, 1, 0, 0],
|
|
}
|
|
],
|
|
)
|
|
def test_Example_from_dict_with_sent_start(annots):
|
|
vocab = Vocab()
|
|
predicted = Doc(vocab, words=annots["words"])
|
|
example = Example.from_dict(predicted, annots)
|
|
assert len(list(example.reference.sents)) == 2
|
|
for i, token in enumerate(example.reference):
|
|
assert bool(token.is_sent_start) == bool(annots["sent_starts"][i])
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"annots",
|
|
[
|
|
{
|
|
"words": ["This", "is", "a", "sentence"],
|
|
"cats": {"cat1": 1.0, "cat2": 0.0, "cat3": 0.5},
|
|
}
|
|
],
|
|
)
|
|
def test_Example_from_dict_with_cats(annots):
|
|
vocab = Vocab()
|
|
predicted = Doc(vocab, words=annots["words"])
|
|
example = Example.from_dict(predicted, annots)
|
|
assert len(list(example.reference.cats)) == 3
|
|
assert example.reference.cats["cat1"] == 1.0
|
|
assert example.reference.cats["cat2"] == 0.0
|
|
assert example.reference.cats["cat3"] == 0.5
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"annots",
|
|
[
|
|
{
|
|
"words": ["I", "like", "New", "York", "and", "Berlin", "."],
|
|
"entities": [(7, 15, "LOC"), (20, 26, "LOC")],
|
|
}
|
|
],
|
|
)
|
|
def test_Example_from_dict_with_entities(annots):
|
|
vocab = Vocab()
|
|
predicted = Doc(vocab, words=annots["words"])
|
|
example = Example.from_dict(predicted, annots)
|
|
assert len(list(example.reference.ents)) == 2
|
|
# fmt: off
|
|
assert [example.reference[i].ent_iob_ for i in range(7)] == ["O", "O", "B", "I", "O", "B", "O"]
|
|
assert example.get_aligned("ENT_IOB") == [2, 2, 3, 1, 2, 3, 2]
|
|
# fmt: on
|
|
assert example.reference[2].ent_type_ == "LOC"
|
|
assert example.reference[3].ent_type_ == "LOC"
|
|
assert example.reference[5].ent_type_ == "LOC"
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"annots",
|
|
[
|
|
{
|
|
"words": ["I", "like", "New", "York", "and", "Berlin", "."],
|
|
"entities": [
|
|
(0, 4, "LOC"),
|
|
(21, 27, "LOC"),
|
|
], # not aligned to token boundaries
|
|
}
|
|
],
|
|
)
|
|
def test_Example_from_dict_with_entities_invalid(annots):
|
|
vocab = Vocab()
|
|
predicted = Doc(vocab, words=annots["words"])
|
|
with pytest.warns(UserWarning):
|
|
example = Example.from_dict(predicted, annots)
|
|
assert len(list(example.reference.ents)) == 0
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"annots",
|
|
[
|
|
{
|
|
"words": ["I", "like", "New", "York", "and", "Berlin", "."],
|
|
"entities": [
|
|
(7, 15, "LOC"),
|
|
(11, 15, "LOC"),
|
|
(20, 26, "LOC"),
|
|
], # overlapping
|
|
}
|
|
],
|
|
)
|
|
def test_Example_from_dict_with_entities_overlapping(annots):
|
|
vocab = Vocab()
|
|
predicted = Doc(vocab, words=annots["words"])
|
|
with pytest.raises(ValueError):
|
|
Example.from_dict(predicted, annots)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"annots",
|
|
[
|
|
{
|
|
"words": ["I", "like", "New", "York", "and", "Berlin", "."],
|
|
"spans": {
|
|
"cities": [(7, 15, "LOC"), (20, 26, "LOC")],
|
|
"people": [(0, 1, "PERSON")],
|
|
},
|
|
}
|
|
],
|
|
)
|
|
def test_Example_from_dict_with_spans(annots):
|
|
vocab = Vocab()
|
|
predicted = Doc(vocab, words=annots["words"])
|
|
example = Example.from_dict(predicted, annots)
|
|
assert len(list(example.reference.ents)) == 0
|
|
assert len(list(example.reference.spans["cities"])) == 2
|
|
assert len(list(example.reference.spans["people"])) == 1
|
|
for span in example.reference.spans["cities"]:
|
|
assert span.label_ == "LOC"
|
|
for span in example.reference.spans["people"]:
|
|
assert span.label_ == "PERSON"
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"annots",
|
|
[
|
|
{
|
|
"words": ["I", "like", "New", "York", "and", "Berlin", "."],
|
|
"spans": {
|
|
"cities": [(7, 15, "LOC"), (11, 15, "LOC"), (20, 26, "LOC")],
|
|
"people": [(0, 1, "PERSON")],
|
|
},
|
|
}
|
|
],
|
|
)
|
|
def test_Example_from_dict_with_spans_overlapping(annots):
|
|
vocab = Vocab()
|
|
predicted = Doc(vocab, words=annots["words"])
|
|
example = Example.from_dict(predicted, annots)
|
|
assert len(list(example.reference.ents)) == 0
|
|
assert len(list(example.reference.spans["cities"])) == 3
|
|
assert len(list(example.reference.spans["people"])) == 1
|
|
for span in example.reference.spans["cities"]:
|
|
assert span.label_ == "LOC"
|
|
for span in example.reference.spans["people"]:
|
|
assert span.label_ == "PERSON"
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"annots",
|
|
[
|
|
{
|
|
"words": ["I", "like", "New", "York", "and", "Berlin", "."],
|
|
"spans": [(0, 1, "PERSON")],
|
|
},
|
|
{
|
|
"words": ["I", "like", "New", "York", "and", "Berlin", "."],
|
|
"spans": {"cities": (7, 15, "LOC")},
|
|
},
|
|
{
|
|
"words": ["I", "like", "New", "York", "and", "Berlin", "."],
|
|
"spans": {"cities": [7, 11]},
|
|
},
|
|
{
|
|
"words": ["I", "like", "New", "York", "and", "Berlin", "."],
|
|
"spans": {"cities": [[7]]},
|
|
},
|
|
],
|
|
)
|
|
def test_Example_from_dict_with_spans_invalid(annots):
|
|
vocab = Vocab()
|
|
predicted = Doc(vocab, words=annots["words"])
|
|
with pytest.raises(ValueError):
|
|
Example.from_dict(predicted, annots)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"annots",
|
|
[
|
|
{
|
|
"words": ["I", "like", "New", "York", "and", "Berlin", "."],
|
|
"entities": [(7, 15, "LOC"), (20, 26, "LOC")],
|
|
"links": {
|
|
(7, 15): {"Q60": 1.0, "Q64": 0.0},
|
|
(20, 26): {"Q60": 0.0, "Q64": 1.0},
|
|
},
|
|
}
|
|
],
|
|
)
|
|
def test_Example_from_dict_with_links(annots):
|
|
vocab = Vocab()
|
|
predicted = Doc(vocab, words=annots["words"])
|
|
example = Example.from_dict(predicted, annots)
|
|
assert example.reference[0].ent_kb_id_ == ""
|
|
assert example.reference[1].ent_kb_id_ == ""
|
|
assert example.reference[2].ent_kb_id_ == "Q60"
|
|
assert example.reference[3].ent_kb_id_ == "Q60"
|
|
assert example.reference[4].ent_kb_id_ == ""
|
|
assert example.reference[5].ent_kb_id_ == "Q64"
|
|
assert example.reference[6].ent_kb_id_ == ""
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"annots",
|
|
[
|
|
{
|
|
"words": ["I", "like", "New", "York", "and", "Berlin", "."],
|
|
"links": {(7, 14): {"Q7381115": 1.0, "Q2146908": 0.0}},
|
|
}
|
|
],
|
|
)
|
|
def test_Example_from_dict_with_links_invalid(annots):
|
|
vocab = Vocab()
|
|
predicted = Doc(vocab, words=annots["words"])
|
|
with pytest.raises(ValueError):
|
|
Example.from_dict(predicted, annots)
|
|
|
|
|
|
def test_Example_from_dict_sentences():
|
|
vocab = Vocab()
|
|
predicted = Doc(vocab, words=["One", "sentence", ".", "one", "more"])
|
|
annots = {"sent_starts": [1, 0, 0, 1, 0]}
|
|
ex = Example.from_dict(predicted, annots)
|
|
assert len(list(ex.reference.sents)) == 2
|
|
|
|
# this currently throws an error - bug or feature?
|
|
# predicted = Doc(vocab, words=["One", "sentence", "not", "one", "more"])
|
|
# annots = {"sent_starts": [1, 0, 0, 0, 0]}
|
|
# ex = Example.from_dict(predicted, annots)
|
|
# assert len(list(ex.reference.sents)) == 1
|
|
|
|
predicted = Doc(vocab, words=["One", "sentence", "not", "one", "more"])
|
|
annots = {"sent_starts": [1, -1, 0, 0, 0]}
|
|
ex = Example.from_dict(predicted, annots)
|
|
assert len(list(ex.reference.sents)) == 1
|
|
|
|
|
|
def test_Example_missing_deps():
|
|
vocab = Vocab()
|
|
words = ["I", "like", "London", "and", "Berlin", "."]
|
|
deps = ["nsubj", "ROOT", "dobj", "cc", "conj", "punct"]
|
|
heads = [1, 1, 1, 2, 2, 1]
|
|
annots_head_only = {"words": words, "heads": heads}
|
|
annots_head_dep = {"words": words, "heads": heads, "deps": deps}
|
|
predicted = Doc(vocab, words=words)
|
|
|
|
# when not providing deps, the head information is considered to be missing
|
|
# in this case, the token's heads refer to themselves
|
|
example_1 = Example.from_dict(predicted, annots_head_only)
|
|
assert [t.head.i for t in example_1.reference] == [0, 1, 2, 3, 4, 5]
|
|
|
|
# when providing deps, the head information is actually used
|
|
example_2 = Example.from_dict(predicted, annots_head_dep)
|
|
assert [t.head.i for t in example_2.reference] == heads
|
|
|
|
|
|
def test_Example_missing_heads():
|
|
vocab = Vocab()
|
|
words = ["I", "like", "London", "and", "Berlin", "."]
|
|
deps = ["nsubj", "ROOT", "dobj", None, "conj", "punct"]
|
|
heads = [1, 1, 1, None, 2, 1]
|
|
annots = {"words": words, "heads": heads, "deps": deps}
|
|
predicted = Doc(vocab, words=words)
|
|
|
|
example = Example.from_dict(predicted, annots)
|
|
parsed_heads = [t.head.i for t in example.reference]
|
|
assert parsed_heads[0] == heads[0]
|
|
assert parsed_heads[1] == heads[1]
|
|
assert parsed_heads[2] == heads[2]
|
|
assert parsed_heads[4] == heads[4]
|
|
assert parsed_heads[5] == heads[5]
|
|
expected = [True, True, True, False, True, True]
|
|
assert [t.has_head() for t in example.reference] == expected
|
|
# Ensure that the missing head doesn't create an artificial new sentence start
|
|
expected = [True, False, False, False, False, False]
|
|
assert example.get_aligned_sent_starts() == expected
|