def __init__(self, tgt_embeddings, **kwargs):
"""Construct an RNN decoder. It provides the input size, the rest is up to the impl.
The default implementation provides an RNN cell, followed by a linear projection, out to a softmax
:param input_dim: The input size
:param kwargs:
:return: void
"""
super().__init__()
self.hsz = kwargs['hsz']
self.arc_policy = create_seq2seq_arc_policy(**kwargs)
self.tgt_embeddings = tgt_embeddings
rnntype = kwargs.get('rnntype', 'lstm')
layers = kwargs.get('layers', 1)
feed_input = kwargs.get('feed_input', True)
dsz = tgt_embeddings.get_dsz()
if feed_input:
self.input_i = self._feed_input
dsz += self.hsz
else:
self.input_i = self._basic_input
pdrop = kwargs.get('dropout', 0.5)
self.decoder_rnn = rnn_cell(dsz, self.hsz, rnntype, layers, pdrop)
self.dropout = torch.nn.Dropout(pdrop)
self.init_attn(**kwargs)
do_weight_tying = bool(kwargs.get('tie_weights', True))
if do_weight_tying:
if self.hsz != self.tgt_embeddings.get_dsz():
raise ValueError("weight tying requires hsz == embedding dsz, got {} hsz and {} dsz".format(self.hsz, self.tgt_embeddings.get_dsz()))
self.preds = WeightTieDense(self.tgt_embeddings)
else:
self.preds = pytorch_linear(self.hsz, self.tgt_embeddings.get_vsz())
def __init__(self, tgt_embeddings, **kwargs):
pc = kwargs.pop('pc').add_subcollection(name=kwargs.get('name', 'rnn-decoder'))
super(RNNDecoder, self).__init__(pc)
self.hsz = kwargs['hsz']
self.arc_policy = create_seq2seq_arc_policy(**kwargs)
self.tgt_embeddings = tgt_embeddings
rnntype = kwargs.get('rnntype', 'lstm')
layers = kwargs['layers']
feed_input = kwargs.get('feed_input', True)
dsz = tgt_embeddings.get_dsz()
if feed_input:
self.input_i = self._feed_input
dsz += self.hsz
else:
self.input_i = self._basic_input
self.pdrop = kwargs.get('dropout', 0.5)
self.decoder_rnn = dy.VanillaLSTMBuilder(layers, dsz, self.hsz, self.pc)
self.init_attn(**kwargs)
do_weight_tying = bool(kwargs.get('tie_weights', False))
if do_weight_tying:
if self.hsz == tgt_embeddings.get_dsz():
self.preds = WeightShareLinear(tgt_embeddings.get_vsz(), tgt_embeddings.embeddings, self.pc, transform=squeeze_and_transpose, name=tgt_embeddings.pc.name())
else:
raise ValueError("weight tying only valid when prediction projection \
layer's hidden size == embedding weight dimensions")
else:
self.preds = Linear(self.tgt_embeddings.get_vsz(), self.hsz, self.pc)
def __init__(self, tgt_embedding, **kwargs):
super(RNNDecoder, self).__init__(tgt_embedding, **kwargs)
self.hsz = kwargs['hsz']
self.arc_policy = create_seq2seq_arc_policy(**kwargs)
self.final_decoder_state = None
self.do_weight_tying = bool(kwargs.get('tie_weights', False))
if self.do_weight_tying:
if self.hsz != self.tgt_embedding.get_dsz():
raise ValueError("weight tying requires hsz == embedding dsz, \
got {} hsz and {} dsz".format(self.hsz, self.tgt_embedding.get_dsz()))
def __init__(self, tgt_embedding, **kwargs):
super(RNNDecoder, self).__init__(tgt_embedding, **kwargs)
self.hsz = kwargs['hsz']
self.arc_policy = create_seq2seq_arc_policy(**kwargs)
self.final_decoder_state = None
self.do_weight_tying = bool(kwargs.get('tie_weights', False))
if self.do_weight_tying:
if self.hsz != self.tgt_embedding.get_dsz():
raise ValueError("weight tying requires hsz == embedding dsz, \
got {} hsz and {} dsz".format(self.hsz, self.tgt_embedding.get_dsz()))
def __init__(self, tgt_embedding, hsz, pdrop, rnntype='lstm', layers=1, vdrop=False, name='encoder', scope='RNNDecoder', **kwargs):
super().__init__(tgt_embedding, **kwargs)
self.hsz = hsz
self.pdrop = pdrop
self.rnntype = rnntype
self.layers = layers
self.vdrop = vdrop
self.arc_policy = create_seq2seq_arc_policy(**kwargs)
self.final_decoder_state = None
self.do_weight_tying = bool(kwargs.get('tie_weights', False))
if self.do_weight_tying:
if self.hsz != self.tgt_embedding.get_dsz():
raise ValueError("weight tying requires hsz == embedding dsz, \
got {} hsz and {} dsz".format(self.hsz, self.tgt_embedding.get_dsz()))
def __init__(self, tgt_embeddings, **kwargs):
"""Construct an RNN decoder. It provides the input size, the rest is up to the impl.
The default implementation provides an RNN cell, followed by a linear projection, out to a softmax
:param input_dim: The input size
:param kwargs:
:return: void
"""
super(RNNDecoder, self).__init__()
self.hsz = kwargs['hsz']
self.arc_policy = create_seq2seq_arc_policy(**kwargs)
self.tgt_embeddings = tgt_embeddings
rnntype = kwargs['rnntype']
layers = kwargs['layers']
feed_input = kwargs.get('feed_input', True)
dsz = tgt_embeddings.get_dsz()
if feed_input:
self.input_i = self._feed_input
dsz += self.hsz
else:
self.input_i = self._basic_input
pdrop = kwargs.get('dropout', 0.5)
self.decoder_rnn = pytorch_rnn_cell(dsz, self.hsz, rnntype, layers,
pdrop)
self.dropout = torch.nn.Dropout(pdrop)
self.init_attn(**kwargs)
do_weight_tying = bool(kwargs.get('tie_weights', False))
is_valid_tying = self.hsz == self.tgt_embeddings.get_dsz()
self.preds = pytorch_linear(self.hsz, self.tgt_embeddings.get_vsz())
if do_weight_tying:
if is_valid_tying:
tie_weight(self.preds, self.tgt_embeddings.embeddings)
else:
raise ValueError(
"weight tying only valid when prediction projection \
layer's hidden size == embedding weight dimensions")
def __init__(self, tgt_embeddings, **kwargs):
"""Construct an RNN decoder. It provides the input size, the rest is up to the impl.
The default implementation provides an RNN cell, followed by a linear projection, out to a softmax
:param input_dim: The input size
:param kwargs:
:return: void
"""
super(RNNDecoder, self).__init__()
self.hsz = kwargs['hsz']
self.arc_policy = create_seq2seq_arc_policy(**kwargs)
self.tgt_embeddings = tgt_embeddings
rnntype = kwargs['rnntype']
layers = kwargs['layers']
feed_input = kwargs.get('feed_input', True)
dsz = tgt_embeddings.get_dsz()
if feed_input:
self.input_i = self._feed_input
dsz += self.hsz
else:
self.input_i = self._basic_input
pdrop = kwargs.get('dropout', 0.5)
self.decoder_rnn = pytorch_rnn_cell(dsz, self.hsz, rnntype, layers, pdrop)
self.dropout = torch.nn.Dropout(pdrop)
self.init_attn(**kwargs)
do_weight_tying = bool(kwargs.get('tie_weights', False))
is_valid_tying = self.hsz == self.tgt_embeddings.get_dsz()
self.preds = pytorch_linear(self.hsz, self.tgt_embeddings.get_vsz())
if do_weight_tying:
if is_valid_tying:
tie_weight(self.preds, self.tgt_embeddings.embeddings)
else:
raise ValueError("weight tying only valid when prediction projection \
layer's hidden size == embedding weight dimensions")
