def create_ev_model(opt, fields):
src_vocab_size = len(fields['src'].vocab)
tgt_vocab_size = len(fields['tgt'].vocab)
padding_idx = fields['src'].vocab.stoi[fields['src'].vocab.PAD]
enc_embedding, dec_embedding = \
create_emb_for_encoder_and_decoder(src_vocab_size,
tgt_vocab_size,
opt.embedding_size,
opt.embedding_size,
padding_idx)
encoder_ref = EncoderRNN("GRU", opt.embedding_size, opt.hidden_size, 1,
opt.dropout_ev, opt.bidirectional)
attention_src = GlobalAttention(opt.embedding_size, attn_type="mlp")
attention_ref = GlobalAttention(opt.embedding_size, attn_type="mlp")
ev_generator = editVectorGenerator(enc_embedding, dec_embedding,
encoder_ref,
attention_src, attention_ref,
nn.Dropout(opt.dropout_ev))
bridge = nn.Sequential(nn.Linear(2 * opt.embedding_size, opt.aux_size),
nn.ReLU())
encoder_src = create_encoder(opt)
decoder = AuxDecoderRNN(opt.rnn_type, opt.atten_model,
opt.embedding_size + opt.aux_size, opt.hidden_size,
opt.num_layers, opt.dropout)
generator = create_generator(opt.hidden_size, tgt_vocab_size)
model = evNMTModel(enc_embedding, dec_embedding, encoder_src, decoder,
generator, ev_generator, bridge, fields)
model.apply(weights_init)
return model
def __init__(self,
rnn_type,
attn_type,
input_size,
hidden_size,
num_layers=1,
dropout=0.1,
src_attention=False,
mem_gate=False,
gate_vector=False,
return_original=False):
super(KVAttnDecoderRNN, self).__init__()
# Basic attributes.
self.rnn_type = rnn_type
self.attn_type = attn_type
self.num_layers = num_layers
self.hidden_size = hidden_size
self.dropout = nn.Dropout(dropout)
self.rnn = getattr(nn, rnn_type)(input_size=input_size,
hidden_size=hidden_size,
num_layers=num_layers,
dropout=dropout)
self.src_attention = src_attention
if src_attention:
self.src_attn = GlobalAttention(hidden_size, attn_type)
self.mem_attn = GlobalAttention(hidden_size,
"general",
context_gate=mem_gate,
gate_vector=gate_vector)
self.return_original = return_original
def create_template_generator(opt, fields):
src_vocab_size = len(fields['src'].vocab)
tgt_vocab_size = len(fields['tgt'].vocab)
padding_idx = fields['src'].vocab.stoi[fields['src'].vocab.PAD]
enc_embedding, dec_embedding = \
create_emb_for_encoder_and_decoder(src_vocab_size,
tgt_vocab_size,
opt.embedding_size,
opt.embedding_size,
padding_idx)
encoder_ref = EncoderRNN("GRU", opt.embedding_size, opt.hidden_size, 1,
opt.dropout_ev, opt.bidirectional)
attention_src = GlobalAttention(opt.embedding_size, attn_type="mlp")
attention_ref = GlobalAttention(opt.embedding_size, attn_type="mlp")
ev_generator = editVectorGenerator(enc_embedding, dec_embedding,
encoder_ref,
attention_src, attention_ref,
nn.Dropout(opt.dropout_ev))
masker = nn.Sequential(
nn.Linear(3 * opt.embedding_size, opt.embedding_size), nn.ReLU(),
nn.Linear(opt.embedding_size, 1), nn.Sigmoid())
model = templateGenerator(ev_generator, masker, nn.Dropout(opt.dropout_ev))
model.apply(weights_init)
return model
def create_joint_template_response_model(opt, fields):
src_vocab_size = len(fields['src'].vocab)
tgt_vocab_size = len(fields['tgt'].vocab)
padding_idx = fields['src'].vocab.stoi[fields['src'].vocab.PAD]
enc_embedding, dec_embedding = create_emb_for_encoder_and_decoder(
src_vocab_size, tgt_vocab_size, opt.embedding_size, opt.embedding_size,
padding_idx)
encoder_src = create_encoder(opt)
if opt.use_ev:
decoder = AuxMemDecoderRNN(opt.rnn_type, opt.atten_model,
opt.embedding_size + opt.aux_size,
opt.hidden_size, opt.num_layers,
opt.dropout, opt.src_attention,
opt.mem_gate, opt.gate_vector)
bridge = nn.Sequential(nn.Linear(2 * opt.embedding_size, opt.aux_size),
nn.ReLU())
else:
decoder = KVAttnDecoderRNN(opt.rnn_type, opt.atten_model,
opt.embedding_size, opt.hidden_size,
opt.num_layers, opt.dropout,
opt.src_attention, opt.mem_gate,
opt.gate_vector)
bridge = None
encoder_ref = EncoderRNN("GRU", opt.embedding_size, opt.hidden_size, 1,
opt.dropout_ev, opt.bidirectional)
attention_src = GlobalAttention(opt.embedding_size, attn_type="mlp")
attention_ref = GlobalAttention(opt.embedding_size, attn_type="mlp")
ev_generator = editVectorGenerator(enc_embedding, dec_embedding,
encoder_ref,
attention_src, attention_ref,
nn.Dropout(opt.dropout_ev))
generator = create_generator(opt.hidden_size, tgt_vocab_size)
masker = nn.Sequential(
nn.Linear(3 * opt.embedding_size, opt.embedding_size), nn.ReLU(),
nn.Linear(opt.embedding_size, 1), nn.Sigmoid())
model = jointTemplateResponseGenerator(ev_generator, masker,
nn.Dropout(opt.dropout_ev),
enc_embedding, dec_embedding,
encoder_src, decoder, generator,
bridge, fields)
model.apply(weights_init)
return model
def __init__(self,
rnn_type,
attn_type,
embedding_size,
hidden_size,
num_layers=1,
dropout=0.1):
super(InputFeedDecoder, self).__init__()
# Basic attributes.
self.rnn_type = rnn_type
self.attn_type = attn_type
self.num_layers = num_layers
self.embedding_size = embedding_size
self.hidden_size = hidden_size
self.dropout = nn.Dropout(dropout)
self.rnn = self._build_rnn(rnn_type, self._input_size, hidden_size,
num_layers, dropout)
self.attn = GlobalAttention(hidden_size, attn_type)
def __init__(self,
rnn_type,
attn_type,
input_size,
hidden_size,
num_layers=1,
dropout=0.1):
super(AuxDecoderRNN, self).__init__()
# Basic attributes.
self.rnn_type = rnn_type
self.attn_type = attn_type
self.num_layers = num_layers
self.hidden_size = hidden_size
self.dropout = nn.Dropout(dropout)
self.rnn = getattr(nn, rnn_type)(input_size=input_size,
hidden_size=hidden_size,
num_layers=num_layers,
dropout=dropout)
if self.attn_type != 'none':
self.attn = GlobalAttention(hidden_size, attn_type)
def __init__(self,
rnn_type,
attn_type,
scheduler_type,
input_size,
hidden_size,
num_layers=1,
dropout=0.1):
super(ScheduledDecoder, self).__init__()
# Basic attributes.
self.rnn_type = rnn_type
self.attn_type = attn_type
self.num_layers = num_layers
self.hidden_size = hidden_size
self.dropout = nn.Dropout(dropout)
self.rnn = self._build_rnn(rnn_type, input_size, hidden_size,
num_layers, dropout)
if self.attn_type != 'none':
self.attn = GlobalAttention(hidden_size, attn_type)
self.ratio_scheduler = self.build_ratio_scheduler(scheduler_type)
self.teacher_forcing_ratio = 1.0