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)
