def test_MultiCriterion(self): input = torch.rand(2, 10) target = torch.LongTensor((1, 8)) nll = nn.ClassNLLCriterion() nll2 = nn.CrossEntropyCriterion() mc = nn.MultiCriterion().add(nll, 0.5).add(nll2) output = mc.forward(input, target) output2 = nll.forward(input, target) / 2 + nll2.forward(input, target) self.assertEqual(output, output2) gradInput = mc.backward(input, target) gradInput2 = nll.backward(input, target).clone().div(2).add( nll2.backward(input, target)) self.assertEqual(gradInput, gradInput2) # test type mc.float() gradInput = gradInput.clone() input3 = input.float() target3 = target output3 = mc.forward(input3, target3) gradInput3 = mc.backward(input3, target3) self.assertEqual(output, output3) self.assertEqual(gradInput.float(), gradInput3) # Check that these don't raise errors mc.__repr__() str(mc)
def __init__(self, pipeline): """ :param pipeline: holds all necessary information for nnsimulation """ # global dictionary self.dictionary = pipeline.dictionary # vector length self.emb_dim = len(pipeline.emb_matrix[0]) self.emb_matrix = pipeline.emb_matrix # embedding matrix as lookup table self.emb_matrix_look = nn.LookupTable(len(pipeline.emb_matrix), self.emb_dim) self.emb_matrix_look.weight = self.emb_matrix # length of input sequence for RNN self.in_len = 5 # rnn properties # memory dimension self.mem_dim = 150 # learning rate self.learning_rate = 0.05 # word vector embedding learning rate self.emb_learning_rate = 0.0 # minibatch size self.batch_size = 25 # regulation strength self.reg = 1e-4 # simulation module hidden dimension self.sim_nhidden = 50 # optimization configuration self.optim_state = {self.learning_rate} # negative log likeligood optimization objective self.criterion = nn.ClassNLLCriterion() # models # initialize code learning model self.rnn = rnn.RNN_Example(self) # initialize classification model self.log_reg = lm.LogisticRegression()
def test_ParallelCriterion(self): input = [torch.rand(2, 10), torch.randn(2, 10)] target = [torch.LongTensor((1, 8)), torch.randn(2, 10)] nll = nn.ClassNLLCriterion() mse = nn.MSECriterion() pc = nn.ParallelCriterion().add(nll, 0.5).add(mse) output = pc.forward(input, target) output2 = nll.forward(input[0], target[0]) / 2 + mse.forward( input[1], target[1]) self.assertEqual(output, output2) gradInput2 = [ nll.backward(input[0], target[0]).clone().div(2), mse.backward(input[1], target[1]) ] gradInput = pc.backward(input, target) self.assertEqual(gradInput[0], gradInput2[0]) self.assertEqual(gradInput[1], gradInput2[1]) # test type pc.float() gradInput[0], gradInput[1] = gradInput[0].clone(), gradInput[1].clone() input3 = [input[0].float(), input[1].float()] target3 = [target[0], target[1].float()] output3 = pc.forward(input3, target3) gradInput3 = pc.backward(input3, target3) self.assertEqual(output, output3) self.assertEqual(gradInput[0].float(), gradInput3[0]) self.assertEqual(gradInput[1].float(), gradInput3[1]) # test repeatTarget input = [torch.rand(2, 10), torch.randn(2, 10)] target = torch.randn(2, 10) mse = nn.MSECriterion() pc = nn.ParallelCriterion(True).add(mse, 0.5).add(nn.MSECriterion()) output = pc.forward(input, target) output2 = mse.forward(input[0], target) / 2 + mse.forward( input[1], target) self.assertEqual(output, output2) gradInput = pc.backward(input, target) gradInput2 = [ mse.backward(input[0], target).clone().div(2), mse.backward(input[1], target) ] self.assertEqual(gradInput[0], gradInput2[0]) self.assertEqual(gradInput[1], gradInput2[1]) # table input input = [torch.randn(2, 10), [torch.rand(2, 10), torch.randn(2, 10)]] target = [ torch.LongTensor((2, 5)), [torch.LongTensor((1, 8)), torch.randn(2, 10)] ] nll2 = nn.ClassNLLCriterion() nll = nn.ClassNLLCriterion() mse = nn.MSECriterion() pc = nn.ParallelCriterion().add(nll, 0.5).add(mse) pc2 = nn.ParallelCriterion().add(nll2, 0.4).add(pc) output = pc2.forward(input, target) output2 = nll2.forward(input[0], target[0]) * 0.4 + nll.forward( input[1][0], target[1][0]) / 2 + mse.forward( input[1][1], target[1][1]) self.assertEqual(output, output2) gradInput2 = [ nll2.backward(input[0], target[0]).clone().mul(0.4), [ nll.backward(input[1][1], target[1][0]).clone().div(2), mse.backward(input[1][1], target[1][1]) ] ] gradInput = pc2.backward(input, target) self.assertEqual(gradInput[0], gradInput2[0]) self.assertEqual(gradInput[1][0], gradInput2[1][0]) self.assertEqual(gradInput[1][1], gradInput2[1][1]) # Check that these don't raise errors pc.__repr__() str(pc)