def __init__(self, args):
super(DialogueClassifierNetwork, self).__init__()
self.args = args
self.dialogue_embedder = DialogueEmbedder(args)
## Define class networkict_
dict_ = {
"input_size": args.output_input_size,
"hidden_size": args.output_hidden_size,
"output_size": 1,
"num_layers": args.output_num_layers[0],
}
self.current_dl_trasnformer1 = model_factory.get_model_by_name(
args.output_layer[0], args, kwargs=dict_)
self.current_dl_trasnformer2 = model_factory.get_model_by_name(
args.output_layer[0], args, kwargs=dict_)
dict_ = {
"input_size": args.output_input_size,
"hidden_size": args.output_hidden_size,
"output_size": 1,
"num_layers": args.output_num_layers[0],
}
self.next_dl_trasnformer = model_factory.get_model_by_name(
args.output_layer[0], args, kwargs=dict_)
self.prev_dl_trasnformer = model_factory.get_model_by_name(
args.output_layer[0], args, kwargs=dict_)
def __init__(self, args):
super(DialogueBowNetwork, self).__init__()
self.dialogue_embedder = DialogueEmbedder(args)
self.args = args
## Define class network
dict_ = {"input_size": args.output_input_size, "hidden_size": args.output_hidden_size[0], "num_layers" : args.output_num_layers[0],
"output_size": args.output_size}
self.next_bow_scorer = model_factory.get_model_by_name(args.output_layer[0], args, kwargs = dict_)
self.prev_bow_scorer = model_factory.get_model_by_name(args.output_layer[0], args, kwargs = dict_)
def __init__(self, args):
super(DialogueActClassifierNetwork, self).__init__()
self.dialogue_embedder = DialogueEmbedder(args)
## Define class network
## output labels size
dict_ = {
"input_size": args.output_input_size,
"hidden_size": args.output_hidden_size[0],
"num_layers": args.output_num_layers[0],
"output_size": args.output_size
}
self.classifier = model_factory.get_model_by_name(args.output_layer[0],
args,
kwargs=dict_)
class DialogueClassifierNetwork(nn.Module):
def __init__(self, args):
super(DialogueClassifierNetwork, self).__init__()
self.args = args
self.dialogue_embedder = DialogueEmbedder(args)
## Define class networkict_
dict_ = {
"input_size": args.output_input_size,
"hidden_size": args.output_hidden_size,
"output_size": 1,
"num_layers": args.output_num_layers[0],
}
self.current_dl_trasnformer1 = model_factory.get_model_by_name(
args.output_layer[0], args, kwargs=dict_)
self.current_dl_trasnformer2 = model_factory.get_model_by_name(
args.output_layer[0], args, kwargs=dict_)
dict_ = {
"input_size": args.output_input_size,
"hidden_size": args.output_hidden_size,
"output_size": 1,
"num_layers": args.output_num_layers[0],
}
self.next_dl_trasnformer = model_factory.get_model_by_name(
args.output_layer[0], args, kwargs=dict_)
self.prev_dl_trasnformer = model_factory.get_model_by_name(
args.output_layer[0], args, kwargs=dict_)
def forward(self, *input):
[
token_embeddings, input_mask_variable, conversation_mask,
max_num_utterances_batch
] = input
conversation_batch_size = int(token_embeddings.shape[0] /
max_num_utterances_batch)
if self.args.fixed_utterance_encoder:
utterance_encodings = token_embeddings
else:
utterance_encodings = self.dialogue_embedder.utterance_encoder(
token_embeddings, input_mask_variable)
utterance_encodings = utterance_encodings.view(
conversation_batch_size, max_num_utterances_batch,
utterance_encodings.shape[1])
utterance_encodings_next = utterance_encodings[:, 1:, :].contiguous()
utterance_encodings_prev = utterance_encodings[:, 0:-1, :].contiguous()
conversation_encoded = self.dialogue_embedder([
token_embeddings, input_mask_variable, conversation_mask,
max_num_utterances_batch
])
conversation_encoded_forward = conversation_encoded[:, 0, :]
conversation_encoded_backward = conversation_encoded[:, 1, :]
#conversation_encoded_forward = conversation_encoded.view(conversation_encoded.shape[0], 1, -1).squeeze(1)
#conversation_encoded_backward = conversation_encoded.view(conversation_encoded.shape[0], 1, -1).squeeze(1)
conversation_encoded_forward_reassembled = conversation_encoded_forward.view(
conversation_batch_size, max_num_utterances_batch,
conversation_encoded_forward.shape[1])
conversation_encoded_backward_reassembled = conversation_encoded_backward.view(
conversation_batch_size, max_num_utterances_batch,
conversation_encoded_backward.shape[1])
# Shift to prepare next and previous utterence encodings
conversation_encoded_current1 = conversation_encoded_forward_reassembled[:,
0:
-1, :].contiguous(
)
conversation_encoded_next = conversation_encoded_forward_reassembled[:,
1:, :].contiguous(
)
conversation_mask_next = conversation_mask[:, 1:].contiguous()
conversation_encoded_current2 = conversation_encoded_backward_reassembled[:,
1:, :].contiguous(
)
conversation_encoded_previous = conversation_encoded_backward_reassembled[:,
0:
-1, :].contiguous(
)
# conversation_mask_previous = conversation_mask[:, 0:-1].contiguous()
# Gold Labels
gold_indices = variable(
LongTensor(range(conversation_encoded_current1.shape[1]))).view(
-1, 1).repeat(conversation_batch_size, 1)
# Linear transformation of both utterance representations
transformed_current1 = self.current_dl_trasnformer1(
conversation_encoded_current1)
transformed_current2 = self.current_dl_trasnformer2(
conversation_encoded_current2)
transformed_next = self.next_dl_trasnformer(conversation_encoded_next)
transformed_prev = self.prev_dl_trasnformer(
conversation_encoded_previous)
# transformed_next = self.next_dl_trasnformer(utterance_encodings_next)
# transformed_prev = self.prev_dl_trasnformer(utterance_encodings_prev)
# Output layer: Generate Scores for next and prev utterances
next_logits = torch.bmm(transformed_current1,
transformed_next.transpose(2, 1))
prev_logits = torch.bmm(transformed_current2,
transformed_prev.transpose(2, 1))
# Computing custom masked cross entropy
next_log_probs = F.log_softmax(next_logits, dim=2)
prev_log_probs = F.log_softmax(prev_logits, dim=2)
losses_next = -torch.gather(next_log_probs.view(
next_log_probs.shape[0] * next_log_probs.shape[1], -1),
dim=1,
index=gold_indices)
losses_prev = -torch.gather(prev_log_probs.view(
prev_log_probs.shape[0] * prev_log_probs.shape[1], -1),
dim=1,
index=gold_indices)
losses_masked = (losses_next.squeeze(1) * conversation_mask_next.view(conversation_mask_next.shape[0]*conversation_mask_next.shape[1]))\
+ (losses_prev.squeeze(1) * conversation_mask_next.view(conversation_mask_next.shape[0]*conversation_mask_next.shape[1]))
loss = losses_masked.sum() / (2 * conversation_mask_next.float().sum())
return loss
def evaluate(self, *input):
[
token_embeddings, input_mask_variable, conversation_mask,
max_num_utterances_batch
] = input
conversation_batch_size = int(token_embeddings.shape[0] /
max_num_utterances_batch)
if self.args.fixed_utterance_encoder:
utterance_encodings = token_embeddings
else:
utterance_encodings = self.dialogue_embedder.utterance_encoder(
token_embeddings, input_mask_variable)
utterance_encodings = utterance_encodings.view(
conversation_batch_size, max_num_utterances_batch,
utterance_encodings.shape[1])
utterance_encodings_next = utterance_encodings[:, 1:, :].contiguous()
utterance_encodings_prev = utterance_encodings[:, 0:-1, :].contiguous()
conversation_encoded = self.dialogue_embedder([
token_embeddings, input_mask_variable, conversation_mask,
max_num_utterances_batch
])
conversation_encoded_forward = conversation_encoded[:, 0, :]
conversation_encoded_backward = conversation_encoded[:, 1, :]
#conversation_encoded_forward = conversation_encoded.view(conversation_encoded.shape[0], 1, -1).squeeze(1)
#conversation_encoded_backward = conversation_encoded.view(conversation_encoded.shape[0], 1, -1).squeeze(1)
conversation_encoded_forward_reassembled = conversation_encoded_forward.view(
conversation_batch_size, max_num_utterances_batch,
conversation_encoded_forward.shape[1])
conversation_encoded_backward_reassembled = conversation_encoded_backward.view(
conversation_batch_size, max_num_utterances_batch,
conversation_encoded_backward.shape[1])
# Shift to prepare next and previous utterence encodings
conversation_encoded_current1 = conversation_encoded_forward_reassembled[:,
0:
-1, :]
conversation_encoded_next = conversation_encoded_forward_reassembled[:,
1:, :]
conversation_mask_next = conversation_mask[:, 1:].contiguous()
conversation_encoded_current2 = conversation_encoded_backward_reassembled[:,
1:, :]
conversation_encoded_previous = conversation_encoded_backward_reassembled[:,
0:
-1, :]
conversation_mask_previous = conversation_mask[:, 0:-1].contiguous()
# Linear transformation of both utterance representations
transformed_current1 = self.current_dl_trasnformer1(
conversation_encoded_current1)
transformed_current2 = self.current_dl_trasnformer2(
conversation_encoded_current2)
transformed_next = self.next_dl_trasnformer(conversation_encoded_next)
transformed_prev = self.prev_dl_trasnformer(
conversation_encoded_previous)
# transformed_next = self.next_dl_trasnformer(utterance_encodings_next)
# transformed_prev = self.prev_dl_trasnformer(utterance_encodings_prev)
# Output layer: Generate Scores for next and prev utterances
next_logits = torch.bmm(transformed_current1,
transformed_next.transpose(2, 1))
prev_logits = torch.bmm(transformed_current2,
transformed_prev.transpose(2, 1))
next_predictions = torch.sort(next_logits, dim=2,
descending=True)[1][:, 0]
prev_predictions = torch.sort(prev_logits, dim=2,
descending=True)[1][:, 0]
return next_predictions, prev_predictions