def __init__(self, token_embedder: TextFieldEmbedder,
encoder: Seq2SeqEncoder,
span_decoder: Topdown_Span_Parser_Factory,
span_extractor: SpanExtractor,
remote_parser: Remote_Parser_Factory, evaluator: any,
vocab: Vocabulary) -> None:
super().__init__(vocab)
self.token_embedder = token_embedder
self.encoder = encoder
self.span_decoder = span_decoder(span_extractor.get_output_dim(),
vocab)
self.span_extractor = span_extractor
self.remote_parser = remote_parser(span_extractor.get_output_dim(),
vocab)
self.evaluator = evaluator
def test_bidirectional_endpoint_span_extractor_can_build_from_params(self):
params = Params({
"type": "bidirectional_endpoint",
"input_dim": 4,
"num_width_embeddings": 5,
"span_width_embedding_dim": 3,
})
extractor = SpanExtractor.from_params(params)
assert isinstance(extractor, BidirectionalEndpointSpanExtractor)
assert extractor.get_output_dim() == 2 + 2 + 3
def test_endpoint_span_extractor_can_build_from_params(self):
params = Params({
"type": "endpoint",
"input_dim": 7,
"num_width_embeddings": 5,
"span_width_embedding_dim": 3
})
extractor = SpanExtractor.from_params(params)
assert isinstance(extractor, EndpointSpanExtractor)
assert extractor.get_output_dim() == 10
def test_bidirectional_endpoint_span_extractor_can_build_from_params(self):
params = Params({
"type": "bidirectional_endpoint",
"input_dim": 4,
"num_width_embeddings": 5,
"span_width_embedding_dim": 3
})
extractor = SpanExtractor.from_params(params)
assert isinstance(extractor, BidirectionalEndpointSpanExtractor)
assert extractor.get_output_dim() == 2 + 2 + 3
def test_locally_normalised_span_extractor_can_build_from_params(self):
params = Params({
"type": "self_attentive",
"input_dim": 7,
"num_width_embeddings": 5,
"span_width_embedding_dim": 3,
})
extractor = SpanExtractor.from_params(params)
assert isinstance(extractor, SelfAttentiveSpanExtractor)
assert extractor.get_output_dim(
) == 10 # input_dim + span_width_embedding_dim
def __init__(self,
subword_embeddings: TextFieldEmbedder,
subword_aggregator: SpanExtractor,
vocab: Vocabulary = None,
freeze_encoder: bool = True):
super().__init__(vocab)
self.subword_embeddings = subword_embeddings
self._freeze_encoder = freeze_encoder
# turn off gradients if don't want to fine tune encoder
for parameter in self.subword_embeddings.parameters():
parameter.requires_grad = not self._freeze_encoder
self.subword_aggregator = subword_aggregator
self.classifier = TimeDistributed(
torch.nn.Linear(in_features=subword_aggregator.get_output_dim(),
out_features=vocab.get_vocab_size("labels")))
self.accuracy = CategoricalAccuracy()
def from_params(cls, vocab, params: Params) -> 'SpanAe':
source_embedder_params = params.pop("source_embedder")
source_embedder = TextFieldEmbedder.from_params(
vocab, source_embedder_params)
encoder = Seq2SeqEncoder.from_params(params.pop("encoder"))
max_decoding_steps = params.pop("max_decoding_steps")
target_namespace = params.pop("target_namespace", "tokens")
# If no attention function is specified, we should not use attention, not attention with
# default similarity function.
attention_function_type = params.pop("attention_function", None)
if attention_function_type is not None:
attention_function = SimilarityFunction.from_params(
attention_function_type)
else:
attention_function = None
scheduled_sampling_ratio = params.pop_float("scheduled_sampling_ratio",
0.0)
spans_extractor, spans_scorer_feedforward = None, None
spans_extractor_params = params.pop("span_extractor", None)
if spans_extractor_params is not None:
spans_extractor = SpanExtractor.from_params(spans_extractor_params)
spans_scorer_params = params.pop("span_scorer_feedforward", None)
if spans_scorer_params is not None:
spans_scorer_feedforward = FeedForward.from_params(
spans_scorer_params)
spans_per_word = params.pop_float("spans_per_word")
params.assert_empty(cls.__name__)
return cls(vocab,
source_embedder=source_embedder,
encoder=encoder,
max_decoding_steps=max_decoding_steps,
spans_per_word=spans_per_word,
target_namespace=target_namespace,
attention_function=attention_function,
scheduled_sampling_ratio=scheduled_sampling_ratio,
spans_extractor=spans_extractor,
spans_scorer_feedforward=spans_scorer_feedforward)
def test_locally_normalised_span_extractor_can_build_from_params(self):
params = Params({"type": "self_attentive", "input_dim": 5})
extractor = SpanExtractor.from_params(params)
assert isinstance(extractor, SelfAttentiveSpanExtractor)
def test_locally_normalised_span_extractor_can_build_from_params(self):
params = Params({"type": "self_attentive", "input_dim": 5})
extractor = SpanExtractor.from_params(params)
assert isinstance(extractor, SelfAttentiveSpanExtractor)
def __init__(self,
vocab: Vocabulary,
params: Params,
regularizer: RegularizerApplicator = None):
super(JointDCS, self).__init__(vocab=vocab, regularizer=regularizer)
# Base text Field Embedder
text_field_embedder_params = params.pop("text_field_embedder")
text_field_embedder = BasicTextFieldEmbedder.from_params(
vocab=vocab, params=text_field_embedder_params)
self._text_field_embedder = text_field_embedder
# Encoder
encoder_params = params.pop("encoder")
encoder = Seq2SeqEncoder.from_params(encoder_params)
self._encoder = encoder
self._tag_representation_dim = params.pop('tag_representation_dim')
self._arc_representation_dim = params.pop('arc_representation_dim')
self._dropout = params.pop('dropout')
self._input_dropout = params.pop('input_dropout')
############
# DSP Stuffs
############
dsp_params = params.pop("dsp")
init_params = dsp_params.pop("initializer", None)
self._initializer = (InitializerApplicator.from_params(init_params)
if init_params is not None else
InitializerApplicator())
pos_params = dsp_params.pop("pos_tag_embedding")
self._pos_tag_embedding = Embedding.from_params(vocab, pos_params)
# Tagger DSP - Biaffine Tagger
tagger_dsp = BiaffineParser(
vocab=vocab,
task_type='dsp',
text_field_embedder=self._text_field_embedder,
encoder=self._encoder,
tag_representation_dim=self._tag_representation_dim,
arc_representation_dim=self._arc_representation_dim,
pos_tag_embedding=self._pos_tag_embedding,
dropout=self._dropout,
input_dropout=self._input_dropout,
initializer=self._initializer)
self._tagger_dsp = tagger_dsp
# arc shared
self._arc_attention = tagger_dsp.arc_attention
self._head_arc_feedforward = tagger_dsp.head_arc_feedforward
self._child_arc_feedforward = tagger_dsp.child_arc_feedforward
############
# SRL Stuffs
############
srl_params = params.pop("srl")
# init_params = srl_params.pop("initializer", None)
# self._initializer = (
# InitializerApplicator.from_params(init_params) if init_params is not None else InitializerApplicator()
# )
# pos_params = srl_params.pop("pos_tag_embedding")
# self._pos_tag_embedding = Embedding.from_params(vocab, pos_params)
# Tagger: SRL - Biaffine Tagger
tagger_srl = BiaffineParser(
vocab=vocab,
task_type='srl',
text_field_embedder=self._text_field_embedder,
encoder=self._encoder,
tag_representation_dim=self._tag_representation_dim,
arc_representation_dim=self._arc_representation_dim,
pos_tag_embedding=self._pos_tag_embedding,
dropout=self._dropout,
input_dropout=self._input_dropout,
initializer=self._initializer)
tagger_srl.arc_attention = self._arc_attention
tagger_srl.head_arc_feedforward = self._head_arc_feedforward
tagger_srl.child_arc_feedforward = self._child_arc_feedforward
self._tagger_srl = tagger_srl
############
# CSP Stuffs
############
csp_params = params.pop("csp")
init_params = csp_params.pop("initializer", None)
self._initializer = (InitializerApplicator.from_params(init_params)
if init_params is not None else
InitializerApplicator())
# pos_params = csp_params.pop("pos_tag_embedding")
# self._pos_tag_embedding = Embedding.from_params(vocab, pos_params)
span_params = csp_params.pop("span_extractor")
self._span_extractor = SpanExtractor.from_params(span_params)
feed_forward_params = csp_params.pop("feedforward")
self._feed_forward = FeedForward.from_params(feed_forward_params)
# Tagger: CSP - SpanConstituencyParser Tagger
tagger_csp = SpanConstituencyParser(
vocab=vocab,
text_field_embedder=self._text_field_embedder,
span_extractor=self._span_extractor,
encoder=self._encoder,
feedforward=self._feed_forward,
pos_tag_embedding=self._pos_tag_embedding,
initializer=self._initializer)
self._tagger_csp = tagger_csp
logger.info("Multi-Task Learning Model has been instantiated.")