def debug(self, source, target, sfeat, rfeat):
operations = [it['oracle_dependency'] for it in rfeat]
# Processing Data
source_OPI = OpMapping.TOKSeqs2OPISeqs(source)
LVT = ActionPool(source_OPI, self.options)
self.setLVT(LVT)
padded_source_OPI, len_source = Padding.padding(source_OPI)
target_OPI = OpMapping.OPPSeqs2OPISeqs(operations)
target_OPI = LVT.sharp(target_OPI)
padded_target_OPI, len_target = Padding.padding(target_OPI)
shifted_target_OPI = Padding.rightShiftCut(padded_target_OPI, OTHER)
mask = (padded_target_OPI >= 3).float()
padded_target_ACT = OpMapping.OPITensor2ACTTensor(padded_target_OPI)
padded_target_TOK = OpMapping.OPITensor2TOKTensor(padded_target_OPI)
outputs_1, outputs_2 = self.forward(padded_source_OPI,
len_source,
shifted_target_OPI,
len_target,
debugMode=True)
preds_ACT_1 = outputs_1[0]
preds_TOK_1 = outputs_1[1]
# Updating
loss_ACT = calcLossPair(preds_ACT_1, padded_target_ACT, len_target)
loss_TOK = calcLossPair(preds_TOK_1,
padded_target_TOK,
len_target,
mask_=mask)
loss_1 = (loss_ACT[0] + loss_TOK[0]) / (loss_ACT[1])
preds_ACT_2 = outputs_2[0]
preds_TOK_2 = outputs_2[1]
# Updating
loss_ACT = calcLossPair(preds_ACT_2, padded_target_ACT, len_target)
loss_TOK = calcLossPair(preds_TOK_2,
padded_target_TOK,
len_target,
mask_=mask)
loss_2 = (loss_ACT[0] + loss_TOK[0]) / (loss_ACT[1])
diff = torch.abs(outputs_1[3] - outputs_2[3])[0]
n = diff.size()[0]
m = diff.size()[1]
'''
print n, m
for i in range(n):
for j in range(m):
if float(diff[i][j])>1e-4:
print i,j, float(diff[i][j])
'''
return loss_1, loss_2
def getLoss(self, source, target, sfeat, rfeat):
'''
Decoder Input: shift_target_OPI;
Decoder Output: sharped_target_OPI
'''
operations = [it['action_map'] for it in rfeat]
source_OPI = OpMapping.TOKSeqs2OPISeqs(source)
LVT = ActionPool(source_OPI, self.options)
self.setLVT(LVT)
padded_source_OPI, len_source = Padding.padding(source_OPI)
target_OPI = OpMapping.OPPSeqs2OPISeqs(operations)
padded_target_OPI, len_target = Padding.padding(target_OPI)
# ADD ROOT Operation Before the Sequence
shifted_target_OPI = Padding.rightShiftCut(padded_target_OPI,
OpMapping.ROOT)
sharped_OPI = LVT.sharp(target_OPI)
padded_sharped_target_OPI, len_target = Padding.padding(sharped_OPI)
outputs, states_pass = self.forward(padded_source_OPI, len_source,
shifted_target_OPI, len_target)
preds_ACT = outputs[0]
preds_TOK = outputs[1]
mask = (padded_target_OPI >= 3).float()
goldstandard_ACT = OpMapping.OPITensor2ACTTensor(
padded_sharped_target_OPI)
goldstandard_TOK = OpMapping.OPITensor2TOKTensor(
padded_sharped_target_OPI)
# Updating
loss_ACT = calcLossPair(preds_ACT, goldstandard_ACT, len_target)
loss_TOK = calcLossPair(preds_TOK,
goldstandard_TOK,
len_target,
mask_=mask)
return (loss_ACT[0] + loss_TOK[0]) / (loss_ACT[1])