model = EquiSeq2Seq(input_symmetry_group=input_symmetry_group,
output_symmetry_group=output_symmetry_group,
input_language=equivariant_commands,
encoder_hidden_size=experiment_arguments.hidden_size,
decoder_hidden_size=experiment_arguments.hidden_size,
output_language=equivariant_actions,
layer_type=experiment_arguments.layer_type,
use_attention=experiment_arguments.use_attention,
bidirectional=experiment_arguments.bidirectional)
# Move model to device and load weights
model.to(device)
model.load_state_dict(torch.load(model_path))
# Convert data to torch tensors
training_eval = [tensors_from_pair(pair, equivariant_commands, equivariant_actions) for pair in train_pairs]
testing_pairs = [tensors_from_pair(pair, equivariant_commands, equivariant_actions) for pair in test_pairs]
# Compute accuracy and print some translation
if args.compute_train_accuracy:
train_acc = test_accuracy(model, training_eval)
print("Model train accuracy: %s" % train_acc.item())
if args.compute_test_accuracy:
test_acc = test_accuracy(model, testing_pairs)
print("Model test accuracy: %s" % test_acc.item())
if args.print_param_nums:
print("Model contains %s params" % model.num_params)
for i in range(args.print_translations):
pair = random.choice(test_pairs)
print('>', pair[0])
print('=', pair[1])
model = EquiSeq2Seq(input_symmetry_group=input_symmetry_group,
output_symmetry_group=output_symmetry_group,
input_language=equivariant_commands,
encoder_hidden_size=experiment_arguments.hidden_size,
decoder_hidden_size=experiment_arguments.hidden_size,
output_language=equivariant_actions,
layer_type=experiment_arguments.layer_type,
use_attention=experiment_arguments.use_attention,
bidirectional=experiment_arguments.bidirectional)
# Move model to device and load weights
model.to(device)
model.load_state_dict(torch.load(model_path))
# Convert data to torch tensors
training_eval = [tensors_from_pair(pair, equivariant_commands, equivariant_actions)
for pair in train_pairs]
testing_pairs = [tensors_from_pair(pair, equivariant_commands, equivariant_actions)
for pair in test_pairs]
# Compute accuracy and print some translation
if args.compute_train_accuracy:
train_acc = test_accuracy(model, training_eval)
print("Model train accuracy: %s" % train_acc.item())
if args.compute_test_accuracy:
test_acc = test_accuracy(model, testing_pairs)
print("Model test accuracy: %s" % test_acc.item())
if args.print_param_nums:
print("Model contains %s params" % model.num_params)
for i in range(args.print_translations):
pair = random.choice(test_pairs)
model.to(device)
# Initialize optimizers
encoder_optimizer = torch.optim.Adam(model.encoder.parameters(),
lr=args.learning_rate)
decoder_optimizer = torch.optim.Adam(model.decoder.parameters(),
lr=args.learning_rate)
# Split off validation set
val_size = int(len(train_pairs) * args.validation_size)
random.shuffle(train_pairs)
train_pairs, val_pairs = train_pairs[val_size:], train_pairs[:val_size]
# Convert data to torch tensors
training_pairs = [
tensors_from_pair(random.choice(train_pairs), commands, actions)
for i in range(args.n_iters)
]
training_eval = [
tensors_from_pair(pair, commands, actions) for pair in train_pairs
]
validation_pairs = [
tensors_from_pair(pair, commands, actions) for pair in val_pairs
]
testing_pairs = [
tensors_from_pair(pair, commands, actions) for pair in test_pairs
]
# Initialize criterion
criterion = nn.NLLLoss().to(device)
output_symmetry_group=output_symmetry_group,
input_language=equivariant_eng,
encoder_hidden_size=experiment_arguments.hidden_size,
decoder_hidden_size=experiment_arguments.hidden_size,
output_language=equivariant_fra,
layer_type=experiment_arguments.layer_type,
use_attention=experiment_arguments.use_attention,
bidirectional=experiment_arguments.bidirectional)
# Move model to device and load weights
model.to(device)
model.load_state_dict(torch.load(model_path))
# Convert data to torch tensors
training_eval = [
tensors_from_pair(pair, equivariant_eng, equivariant_fra)
for pair in train_pairs
]
testing_pairs = [
tensors_from_pair(pair, equivariant_eng, equivariant_fra)
for pair in test_pairs
]
if experiment_arguments.split in ["add_book", "add_house"]:
new_prim_training_pairs = [
tensors_from_pair(new_prim_pair, equivariant_eng, equivariant_fra)
]
num_new_prim_pairs = int(args.p_new_prim * len(training_eval))
new_prim_training_pairs = new_prim_training_pairs * num_new_prim_pairs
model = train_new_prim(model, new_prim_training_pairs,
experiment_arguments)
encoder_hidden_size=experiment_arguments.hidden_size,
decoder_hidden_size=experiment_arguments.semantic_size,
output_language=fra_lang,
layer_type=experiment_arguments.layer_type,
use_attention=experiment_arguments.use_attention,
drop_rate=experiment_arguments.drop_rate,
bidirectional=experiment_arguments.bidirectional,
num_layers=experiment_arguments.num_layers)
# Move model to device and load weights
model.to(device)
model.load_state_dict(torch.load(model_path))
# Convert data to torch tensors
training_eval = [
tensors_from_pair(pair, eng_lang, fra_lang) for pair in train_pairs
]
testing_pairs = [
tensors_from_pair(pair, eng_lang, fra_lang) for pair in test_pairs
]
if experiment_arguments.split in ["add_book", "add_house"]:
num_new_prim_pairs = int(args.p_new_prim * len(training_eval))
new_prim_training_pairs = [
tensors_from_pair(new_prim_pair, eng_lang, fra_lang)
] * num_new_prim_pairs
model = train_new_prim(model, new_prim_training_pairs,
experiment_arguments)
# Compute accuracy and print some translations
if args.compute_train_accuracy:
# Initialize optimizers
encoder_optimizer = torch.optim.Adam(model.encoder.parameters(),
lr=args.learning_rate,
weight_decay=args.weight_decay)
decoder_optimizer = torch.optim.Adam(model.decoder.parameters(),
lr=args.learning_rate,
weight_decay=args.weight_decay)
# Split off validation set
val_size = int(len(train_pairs) * args.validation_size)
random.shuffle(train_pairs)
train_pairs, val_pairs = train_pairs[val_size:], train_pairs[:val_size]
# Convert data to torch tensors
training_pairs = [
tensors_from_pair(random.choice(train_pairs), equivariant_commands,
equivariant_actions) for i in range(args.n_iters)
]
training_eval = [
tensors_from_pair(pair, equivariant_commands, equivariant_actions)
for pair in train_pairs
]
validation_pairs = [
tensors_from_pair(pair, equivariant_commands, equivariant_actions)
for pair in val_pairs
]
testing_pairs = [
tensors_from_pair(pair, equivariant_commands, equivariant_actions)
for pair in test_pairs
]
# Initialize criterion
# Initialize optimizers
encoder_optimizer = torch.optim.Adam(model.encoder.parameters(),
lr=args.learning_rate,
weight_decay=args.weight_decay)
decoder_optimizer = torch.optim.Adam(model.decoder.parameters(),
lr=args.learning_rate,
weight_decay=args.weight_decay)
# Split off validation set
val_size = int(len(train_pairs) * args.validation_size)
random.shuffle(train_pairs)
train_pairs, val_pairs = train_pairs[val_size:], train_pairs[:val_size]
# Convert data to torch tensors
training_pairs = [
tensors_from_pair(random.choice(train_pairs), eng_lang, fra_lang)
for i in range(args.n_iters)
]
training_eval = [
tensors_from_pair(pair, eng_lang, fra_lang) for pair in train_pairs
]
validation_pairs = [
tensors_from_pair(pair, eng_lang, fra_lang) for pair in val_pairs
]
testing_pairs = [
tensors_from_pair(pair, eng_lang, fra_lang) for pair in test_pairs
]
# Initialize criterion
criterion = nn.NLLLoss().to(device)
# Initialize optimizers
encoder_optimizer = torch.optim.Adam(model.encoder.parameters(),
lr=args.learning_rate,
weight_decay=args.weight_decay)
decoder_optimizer = torch.optim.Adam(model.decoder.parameters(),
lr=args.learning_rate,
weight_decay=args.weight_decay)
# Split off validation set
val_size = int(len(train_pairs) * args.validation_size)
random.shuffle(train_pairs)
train_pairs, val_pairs = train_pairs[val_size:], train_pairs[:val_size]
# Convert data to torch tensors
training_pairs = [tensors_from_pair(random.choice(train_pairs),
equivariant_commands,
equivariant_actions)
for i in range(args.n_iters)]
training_eval = [tensors_from_pair(pair, equivariant_commands, equivariant_actions)
for pair in train_pairs]
validation_pairs = [tensors_from_pair(pair, equivariant_commands, equivariant_actions)
for pair in val_pairs]
testing_pairs = [tensors_from_pair(pair, equivariant_commands, equivariant_actions)
for pair in test_pairs]
# Initialize criterion
criterion = nn.NLLLoss().to(device)
# Initialize printing / plotting variables
plot_losses = []
print_loss_total = 0
output_language=actions,
layer_type=args.layer_type,
use_attention=args.use_attention,
drop_rate=args.drop_rate,
bidirectional=args.bidirectional,
num_layers=args.num_layers)
model.to(device)
# Initialize optimizers
encoder_optimizer = torch.optim.Adam(model.encoder.parameters(),
lr=args.learning_rate)
decoder_optimizer = torch.optim.Adam(model.decoder.parameters(),
lr=args.learning_rate)
# Convert data to torch tensors
training_triplets = [
tensors_from_pair(random.choice(train_pairs), commands, actions,
commands_syntax) for i in range(args.n_iters)
]
training_eval = [
tensors_from_pair(pair, commands, actions, commands_syntax)
for pair in train_pairs
]
testing_pairs = [
tensors_from_pair(pair, commands, actions, commands_syntax)
for pair in test_pairs
]
# Initialize criterion
criterion = nn.NLLLoss().to(device)
# Initialize printing / plotting variables
plot_losses = []
encoder_hidden_size=experiment_arguments.hidden_size,
decoder_hidden_size=experiment_arguments.semantic_size,
output_language=actions,
layer_type=experiment_arguments.layer_type,
use_attention=experiment_arguments.use_attention,
drop_rate=experiment_arguments.drop_rate,
bidirectional=experiment_arguments.bidirectional,
num_layers=experiment_arguments.num_layers)
# Move model to device and load weights
model.to(device)
model.load_state_dict(torch.load(model_path))
# Convert data to torch tensors
training_eval = [
tensors_from_pair(pair, commands, actions, commands_syntax)
for pair in train_pairs
]
testing_pairs = [
tensors_from_pair(pair, commands, actions, commands_syntax)
for pair in test_pairs
]
# Compute accuracy and print some translations
if args.compute_train_accuracy:
train_acc = test_accuracy(model, training_eval)
print("Model train accuracy: %s" % train_acc.item())
if args.compute_test_accuracy:
test_acc = test_accuracy(model, testing_pairs)
print("Model test accuracy: %s" % test_acc.item())
if args.print_param_nums:
model = BasicSeq2Seq(input_language=commands,
encoder_hidden_size=experiment_arguments.hidden_size,
decoder_hidden_size=experiment_arguments.semantic_size,
output_language=actions,
layer_type=experiment_arguments.layer_type,
use_attention=experiment_arguments.use_attention,
drop_rate=experiment_arguments.drop_rate,
bidirectional=experiment_arguments.bidirectional,
num_layers=experiment_arguments.num_layers)
# Move model to device and load weights
model.to(device)
model.load_state_dict(torch.load(model_path))
# Convert data to torch tensors
training_eval = [tensors_from_pair(pair, commands, actions)
for pair in train_pairs]
testing_pairs = [tensors_from_pair(pair, commands, actions)
for pair in test_pairs]
# Compute accuracy and print some translations
if args.compute_train_accuracy:
train_acc = test_accuracy(model, training_eval)
print("Model train accuracy: %s" % train_acc.item())
if args.compute_test_accuracy:
test_acc = test_accuracy(model, testing_pairs)
print("Model test accuracy: %s" % test_acc.item())
if args.print_param_nums:
print("Model contains %s params" % model.num_params)
for i in range(args.print_translations):
pair = random.choice(test_pairs)
