2020-07-22 11:42:59 +00:00
|
|
|
# cython: infer_types=True, profile=True, binding=True
|
|
|
|
from typing import Optional
|
2020-04-02 12:46:32 +00:00
|
|
|
import srsly
|
2020-07-22 11:42:59 +00:00
|
|
|
from thinc.api import SequenceCategoricalCrossentropy, Model, Config
|
2020-01-29 16:06:46 +00:00
|
|
|
|
2020-03-02 10:48:10 +00:00
|
|
|
from ..tokens.doc cimport Doc
|
|
|
|
from ..vocab cimport Vocab
|
|
|
|
from ..morphology cimport Morphology
|
2020-04-02 12:46:32 +00:00
|
|
|
from ..parts_of_speech import IDS as POS_IDS
|
|
|
|
from ..symbols import POS
|
2020-03-02 10:48:10 +00:00
|
|
|
|
2020-07-22 11:42:59 +00:00
|
|
|
from ..language import Language
|
|
|
|
from ..errors import Errors
|
|
|
|
from .pipe import deserialize_config
|
|
|
|
from .tagger import Tagger
|
2019-03-07 09:46:27 +00:00
|
|
|
from .. import util
|
2018-09-24 21:14:06 +00:00
|
|
|
|
|
|
|
|
2020-07-22 11:42:59 +00:00
|
|
|
default_model_config = """
|
|
|
|
[model]
|
|
|
|
@architectures = "spacy.Tagger.v1"
|
|
|
|
|
|
|
|
[model.tok2vec]
|
|
|
|
@architectures = "spacy.HashCharEmbedCNN.v1"
|
|
|
|
pretrained_vectors = null
|
|
|
|
width = 128
|
|
|
|
depth = 4
|
|
|
|
embed_size = 7000
|
|
|
|
window_size = 1
|
|
|
|
maxout_pieces = 3
|
|
|
|
nM = 64
|
|
|
|
nC = 8
|
|
|
|
dropout = null
|
|
|
|
"""
|
|
|
|
DEFAULT_MORPH_MODEL = Config().from_str(default_model_config)["model"]
|
|
|
|
|
|
|
|
|
|
|
|
@Language.factory(
|
|
|
|
"morphologizer",
|
|
|
|
assigns=["token.morph", "token.pos"],
|
|
|
|
default_config={"model": DEFAULT_MORPH_MODEL}
|
|
|
|
)
|
|
|
|
def make_morphologizer(
|
|
|
|
nlp: Language,
|
|
|
|
model: Model,
|
|
|
|
name: str,
|
|
|
|
):
|
|
|
|
return Morphologizer(nlp.vocab, model, name)
|
|
|
|
|
2019-10-27 12:35:49 +00:00
|
|
|
|
2020-07-22 11:42:59 +00:00
|
|
|
class Morphologizer(Tagger):
|
2020-07-19 09:10:51 +00:00
|
|
|
POS_FEAT = "POS"
|
|
|
|
|
2020-07-22 11:42:59 +00:00
|
|
|
def __init__(
|
|
|
|
self,
|
|
|
|
vocab: Vocab,
|
|
|
|
model: Model,
|
|
|
|
name: str = "morphologizer",
|
|
|
|
*,
|
|
|
|
labels_morph: Optional[dict] = None,
|
|
|
|
labels_pos: Optional[dict] = None,
|
|
|
|
):
|
2018-09-24 21:14:06 +00:00
|
|
|
self.vocab = vocab
|
|
|
|
self.model = model
|
2020-07-22 11:42:59 +00:00
|
|
|
self.name = name
|
2020-04-02 12:46:32 +00:00
|
|
|
self._rehearsal_model = None
|
2020-07-19 09:10:51 +00:00
|
|
|
# to be able to set annotations without string operations on labels,
|
|
|
|
# store mappings from morph+POS labels to token-level annotations:
|
|
|
|
# 1) labels_morph stores a mapping from morph+POS->morph
|
|
|
|
# 2) labels_pos stores a mapping from morph+POS->POS
|
2020-07-22 11:42:59 +00:00
|
|
|
cfg = {"labels_morph": labels_morph or {}, "labels_pos": labels_pos or {}}
|
|
|
|
self.cfg = dict(sorted(cfg.items()))
|
2020-07-19 09:10:51 +00:00
|
|
|
# add mappings for empty morph
|
|
|
|
self.cfg["labels_morph"][Morphology.EMPTY_MORPH] = Morphology.EMPTY_MORPH
|
|
|
|
self.cfg["labels_pos"][Morphology.EMPTY_MORPH] = POS_IDS[""]
|
2018-09-24 21:14:06 +00:00
|
|
|
|
|
|
|
@property
|
|
|
|
def labels(self):
|
2020-07-19 09:10:51 +00:00
|
|
|
return tuple(self.cfg["labels_morph"].keys())
|
2020-04-02 12:46:32 +00:00
|
|
|
|
|
|
|
def add_label(self, label):
|
|
|
|
if not isinstance(label, str):
|
|
|
|
raise ValueError(Errors.E187)
|
|
|
|
if label in self.labels:
|
|
|
|
return 0
|
2020-07-19 09:10:51 +00:00
|
|
|
# normalize label
|
|
|
|
norm_label = self.vocab.morphology.normalize_features(label)
|
|
|
|
# extract separate POS and morph tags
|
|
|
|
label_dict = Morphology.feats_to_dict(label)
|
|
|
|
pos = label_dict.get(self.POS_FEAT, "")
|
|
|
|
if self.POS_FEAT in label_dict:
|
|
|
|
label_dict.pop(self.POS_FEAT)
|
|
|
|
# normalize morph string and add to morphology table
|
|
|
|
norm_morph = self.vocab.strings[self.vocab.morphology.add(label_dict)]
|
|
|
|
# add label mappings
|
|
|
|
if norm_label not in self.cfg["labels_morph"]:
|
|
|
|
self.cfg["labels_morph"][norm_label] = norm_morph
|
|
|
|
self.cfg["labels_pos"][norm_label] = POS_IDS[pos]
|
2020-04-02 12:46:32 +00:00
|
|
|
return 1
|
2018-09-24 21:14:06 +00:00
|
|
|
|
2020-07-22 11:42:59 +00:00
|
|
|
def begin_training(self, get_examples=lambda: [], pipeline=None, sgd=None):
|
2020-04-02 12:46:32 +00:00
|
|
|
for example in get_examples():
|
2020-06-26 17:34:12 +00:00
|
|
|
for i, token in enumerate(example.reference):
|
|
|
|
pos = token.pos_
|
2020-07-19 09:10:51 +00:00
|
|
|
morph = token.morph_
|
|
|
|
# create and add the combined morph+POS label
|
|
|
|
morph_dict = Morphology.feats_to_dict(morph)
|
2020-04-02 12:46:32 +00:00
|
|
|
if pos:
|
2020-07-19 09:10:51 +00:00
|
|
|
morph_dict[self.POS_FEAT] = pos
|
|
|
|
norm_label = self.vocab.strings[self.vocab.morphology.add(morph_dict)]
|
|
|
|
# add label->morph and label->POS mappings
|
|
|
|
if norm_label not in self.cfg["labels_morph"]:
|
|
|
|
self.cfg["labels_morph"][norm_label] = morph
|
|
|
|
self.cfg["labels_pos"][norm_label] = POS_IDS[pos]
|
2020-02-27 17:42:27 +00:00
|
|
|
self.set_output(len(self.labels))
|
|
|
|
self.model.initialize()
|
2020-07-22 11:42:59 +00:00
|
|
|
util.link_vectors_to_models(self.vocab)
|
2020-02-27 17:42:27 +00:00
|
|
|
if sgd is None:
|
|
|
|
sgd = self.create_optimizer()
|
|
|
|
return sgd
|
|
|
|
|
2020-04-02 12:46:32 +00:00
|
|
|
def set_annotations(self, docs, batch_tag_ids):
|
2018-09-24 21:14:06 +00:00
|
|
|
if isinstance(docs, Doc):
|
|
|
|
docs = [docs]
|
|
|
|
cdef Doc doc
|
|
|
|
cdef Vocab vocab = self.vocab
|
|
|
|
for i, doc in enumerate(docs):
|
2020-04-02 12:46:32 +00:00
|
|
|
doc_tag_ids = batch_tag_ids[i]
|
|
|
|
if hasattr(doc_tag_ids, "get"):
|
|
|
|
doc_tag_ids = doc_tag_ids.get()
|
|
|
|
for j, tag_id in enumerate(doc_tag_ids):
|
|
|
|
morph = self.labels[tag_id]
|
2020-07-19 09:10:51 +00:00
|
|
|
doc.c[j].morph = self.vocab.morphology.add(self.cfg["labels_morph"][morph])
|
|
|
|
doc.c[j].pos = self.cfg["labels_pos"][morph]
|
2020-04-02 12:46:32 +00:00
|
|
|
|
|
|
|
doc.is_morphed = True
|
2018-09-24 21:14:06 +00:00
|
|
|
|
2019-11-11 16:35:27 +00:00
|
|
|
def get_loss(self, examples, scores):
|
2020-07-08 11:59:28 +00:00
|
|
|
loss_func = SequenceCategoricalCrossentropy(names=self.labels, normalize=False)
|
|
|
|
truths = []
|
2020-06-26 17:34:12 +00:00
|
|
|
for eg in examples:
|
2020-07-08 11:59:28 +00:00
|
|
|
eg_truths = []
|
2020-06-26 17:34:12 +00:00
|
|
|
pos_tags = eg.get_aligned("POS", as_string=True)
|
|
|
|
morphs = eg.get_aligned("MORPH", as_string=True)
|
|
|
|
for i in range(len(morphs)):
|
|
|
|
pos = pos_tags[i]
|
|
|
|
morph = morphs[i]
|
2020-07-19 09:10:51 +00:00
|
|
|
# POS may align (same value for multiple tokens) when morph
|
|
|
|
# doesn't, so if either is None, treat both as None here so that
|
|
|
|
# truths doesn't end up with an unknown morph+POS combination
|
|
|
|
if pos is None or morph is None:
|
|
|
|
pos = None
|
|
|
|
morph = None
|
|
|
|
label_dict = Morphology.feats_to_dict(morph)
|
2020-04-02 12:46:32 +00:00
|
|
|
if pos:
|
2020-07-19 09:10:51 +00:00
|
|
|
label_dict[self.POS_FEAT] = pos
|
|
|
|
label = self.vocab.strings[self.vocab.morphology.add(label_dict)]
|
|
|
|
eg_truths.append(label)
|
2020-07-08 11:59:28 +00:00
|
|
|
truths.append(eg_truths)
|
|
|
|
d_scores, loss = loss_func(scores, truths)
|
|
|
|
if self.model.ops.xp.isnan(loss):
|
|
|
|
raise ValueError("nan value when computing loss")
|
2018-09-24 21:14:06 +00:00
|
|
|
return float(loss), d_scores
|
|
|
|
|
2020-07-06 11:06:25 +00:00
|
|
|
def to_bytes(self, exclude=tuple()):
|
2020-04-02 12:46:32 +00:00
|
|
|
serialize = {}
|
|
|
|
serialize["model"] = self.model.to_bytes
|
|
|
|
serialize["vocab"] = self.vocab.to_bytes
|
|
|
|
serialize["cfg"] = lambda: srsly.json_dumps(self.cfg)
|
|
|
|
return util.to_bytes(serialize, exclude)
|
|
|
|
|
2020-07-06 11:06:25 +00:00
|
|
|
def from_bytes(self, bytes_data, exclude=tuple()):
|
2020-04-02 12:46:32 +00:00
|
|
|
def load_model(b):
|
|
|
|
try:
|
|
|
|
self.model.from_bytes(b)
|
|
|
|
except AttributeError:
|
|
|
|
raise ValueError(Errors.E149)
|
|
|
|
|
|
|
|
deserialize = {
|
|
|
|
"vocab": lambda b: self.vocab.from_bytes(b),
|
|
|
|
"cfg": lambda b: self.cfg.update(srsly.json_loads(b)),
|
|
|
|
"model": lambda b: load_model(b),
|
|
|
|
}
|
|
|
|
util.from_bytes(bytes_data, deserialize, exclude)
|
|
|
|
return self
|
|
|
|
|
2020-07-06 11:06:25 +00:00
|
|
|
def to_disk(self, path, exclude=tuple()):
|
2020-04-02 12:46:32 +00:00
|
|
|
serialize = {
|
|
|
|
"vocab": lambda p: self.vocab.to_disk(p),
|
|
|
|
"model": lambda p: p.open("wb").write(self.model.to_bytes()),
|
|
|
|
"cfg": lambda p: srsly.write_json(p, self.cfg),
|
|
|
|
}
|
|
|
|
util.to_disk(path, serialize, exclude)
|
|
|
|
|
2020-07-06 11:06:25 +00:00
|
|
|
def from_disk(self, path, exclude=tuple()):
|
2020-04-02 12:46:32 +00:00
|
|
|
def load_model(p):
|
|
|
|
with p.open("rb") as file_:
|
|
|
|
try:
|
|
|
|
self.model.from_bytes(file_.read())
|
|
|
|
except AttributeError:
|
|
|
|
raise ValueError(Errors.E149)
|
|
|
|
|
|
|
|
deserialize = {
|
|
|
|
"vocab": lambda p: self.vocab.from_disk(p),
|
2020-07-22 11:42:59 +00:00
|
|
|
"cfg": lambda p: self.cfg.update(deserialize_config(p)),
|
2020-04-02 12:46:32 +00:00
|
|
|
"model": load_model,
|
|
|
|
}
|
|
|
|
util.from_disk(path, deserialize, exclude)
|
|
|
|
return self
|