def test_reduction(self):
gt0 = torch.LongTensor([[0, -1, -1], [-1, 2, -1], [-1, -1, 3]])
gt = rnn.pad_sequence([gt0], padding_value=-1)
rule_prob0 = torch.FloatTensor([[0.8, 0.2], [0.5, 0.5], [0.5, 0.5]])
rule_prob = rnn.pad_sequence([rule_prob0])
token_prob0 = torch.FloatTensor([[0.1, 0.4, 0.5], [0.1, 0.2, 0.8],
[0.5, 0.4, 0.1]])
token_prob = rnn.pad_sequence([token_prob0])
reference_prob0 = torch.FloatTensor([[0.1, 0.4, 0.5, 0.0],
[0.0, 0.5, 0.4, 0.1],
[0.0, 0.0, 0.0, 1.0]])
reference_prob = rnn.pad_sequence([reference_prob0])
loss0 = Loss()
loss1 = Loss(reduction="sum")
loss2 = Loss(reduction="none")
objective0 = loss0(rule_probs=rule_prob,
token_probs=token_prob,
reference_probs=reference_prob,
ground_truth_actions=gt)
objective1 = loss1(rule_probs=rule_prob,
token_probs=token_prob,
reference_probs=reference_prob,
ground_truth_actions=gt)
objective2 = loss2(rule_probs=rule_prob,
token_probs=token_prob,
reference_probs=reference_prob,
ground_truth_actions=gt)
assert (1, ) == objective2.shape
assert np.allclose(objective0.item(), objective1.item())
def train(self, output_dir):
with tempfile.TemporaryDirectory() as tmpdir:
loss_fn = nn.Sequential(
OrderedDict([
("loss",
Apply(
module=Loss(),
in_keys=[
"rule_probs",
"token_probs",
"reference_probs",
"ground_truth_actions",
],
out_key="action_sequence_loss",
)),
("pick",
mlprogram.nn.Function(Pick("action_sequence_loss")))
]))
collate = Collate(word_nl_query=CollateOptions(True, 0, -1),
nl_query_features=CollateOptions(True, 0, -1),
reference_features=CollateOptions(True, 0, -1),
actions=CollateOptions(True, 0, -1),
previous_actions=CollateOptions(True, 0, -1),
previous_action_rules=CollateOptions(
True, 0, -1),
history=CollateOptions(False, 1, 0),
hidden_state=CollateOptions(False, 0, 0),
state=CollateOptions(False, 0, 0),
ground_truth_actions=CollateOptions(True, 0,
-1)).collate
qencoder, aencoder = \
self.prepare_encoder(train_dataset, Parser())
transform = Map(self.transform_cls(qencoder, aencoder, Parser()))
model = self.prepare_model(qencoder, aencoder)
optimizer = self.prepare_optimizer(model)
train_supervised(tmpdir,
output_dir,
train_dataset,
model,
optimizer,
loss_fn,
EvaluateSynthesizer(test_dataset,
self.prepare_synthesizer(
model, qencoder,
aencoder),
{"accuracy": Accuracy()},
top_n=[5]),
"accuracy@5",
lambda x: collate(transform(x)),
1,
Epoch(100),
evaluation_interval=Epoch(100),
snapshot_interval=Epoch(100),
threshold=1.0)
return qencoder, aencoder
def test_shape(self):
gt0 = torch.LongTensor([[0, -1, -1], [-1, 2, -1], [-1, -1, 3]])
gt = rnn.pad_sequence([gt0], padding_value=-1)
rule_prob0 = torch.FloatTensor([[0.8, 0.2], [0.5, 0.5], [0.5, 0.5]])
rule_prob = rnn.pad_sequence([rule_prob0])
token_prob0 = torch.FloatTensor([[0.1, 0.4, 0.5], [0.1, 0.2, 0.8],
[0.5, 0.4, 0.1]])
token_prob = rnn.pad_sequence([token_prob0])
reference_prob0 = torch.FloatTensor([[0.1, 0.4, 0.5, 0.0],
[0.0, 0.5, 0.4, 0.1],
[0.0, 0.0, 0.0, 1.0]])
reference_prob = rnn.pad_sequence([reference_prob0])
loss = Loss()
objective = loss(rule_probs=rule_prob,
token_probs=token_prob,
reference_probs=reference_prob,
ground_truth_actions=gt)
assert () == objective.shape
def pretrain(self, output_dir):
dataset = Dataset(4, 1, 2, 1, 45, seed=0)
"""
"""
train_dataset = ListDataset([
Environment(
{"ground_truth": Circle(1)},
set(["ground_truth"]),
),
Environment(
{"ground_truth": Rectangle(1, 2)},
set(["ground_truth"]),
),
Environment(
{"ground_truth": Rectangle(1, 1)},
set(["ground_truth"]),
),
Environment(
{"ground_truth": Rotation(45, Rectangle(1, 1))},
set(["ground_truth"]),
),
Environment(
{"ground_truth": Translation(1, 1, Rectangle(1, 1))},
set(["ground_truth"]),
),
Environment(
{"ground_truth": Difference(Circle(1), Circle(1))},
set(["ground_truth"]),
),
Environment(
{"ground_truth": Union(Rectangle(1, 2), Circle(1))},
set(["ground_truth"]),
),
Environment(
{"ground_truth": Difference(Rectangle(1, 1), Circle(1))},
set(["ground_truth"]),
),
])
with tempfile.TemporaryDirectory() as tmpdir:
interpreter = self.interpreter()
train_dataset = data_transform(
train_dataset,
Apply(
module=AddTestCases(interpreter),
in_keys=["ground_truth"],
out_key="test_cases",
is_out_supervision=False,
))
encoder = self.prepare_encoder(dataset, Parser())
collate = Collate(
test_case_tensor=CollateOptions(False, 0, 0),
variables_tensor=CollateOptions(True, 0, 0),
previous_actions=CollateOptions(True, 0, -1),
hidden_state=CollateOptions(False, 0, 0),
state=CollateOptions(False, 0, 0),
ground_truth_actions=CollateOptions(True, 0, -1)
)
collate_fn = Sequence(OrderedDict([
("to_episode", Map(self.to_episode(encoder,
interpreter))),
("flatten", Flatten()),
("transform", Map(self.transform(
encoder, interpreter, Parser()))),
("collate", collate.collate)
]))
model = self.prepare_model(encoder)
optimizer = self.prepare_optimizer(model)
train_supervised(
tmpdir, output_dir,
train_dataset, model, optimizer,
torch.nn.Sequential(OrderedDict([
("loss",
Apply(
module=Loss(
reduction="sum",
),
in_keys=[
"rule_probs",
"token_probs",
"reference_probs",
"ground_truth_actions",
],
out_key="action_sequence_loss",
)),
("normalize", # divided by batch_size
Apply(
[("action_sequence_loss", "lhs")],
"loss",
mlprogram.nn.Function(Div()),
constants={"rhs": 1})),
("pick",
mlprogram.nn.Function(
Pick("loss")))
])),
None, "score",
collate_fn,
1, Epoch(100), evaluation_interval=Epoch(10),
snapshot_interval=Epoch(100)
)
return encoder, train_dataset
def test_parameters(self):
loss = Loss()
assert 0 == len(dict(loss.named_parameters()))