def run():
"""
Run the experiment.
"""
is_ptr = False
np.random.seed(RANDOM_SEED)
max_val, max_length, pairs = read_data(name="test")
np.random.shuffle(pairs)
training_pairs = [tensors_from_pair(pair) for pair in pairs]
data_dim = max_val + 1
hidden_dim = embedding_dim = 256
encoder = Encoder(input_dim=data_dim,
embedding_dim=embedding_dim,
hidden_dim=hidden_dim).to(device)
if is_ptr:
decoder = PtrDecoder(output_dim=data_dim,
embedding_dim=embedding_dim,
hidden_dim=hidden_dim).to(device)
else:
decoder = AttnDecoder(output_dim=data_dim,
embedding_dim=embedding_dim,
hidden_dim=hidden_dim).to(device)
checkpoint = load_checkpoint("ptr" if is_ptr else "vanilla")
if checkpoint:
encoder.load_state_dict(checkpoint["encoder"])
decoder.load_state_dict(checkpoint["decoder"])
else:
print("Count not find checkpoint file.")
permutation_count, nondecreasing_count = 0, 0
for i in range(len(training_pairs)):
input_tensor, target_tensor = training_pairs[i]
output_tensor = evaluate(encoder=encoder,
decoder=decoder,
input_tensor=training_pairs[i][0],
is_ptr=is_ptr)
target, output = list(np.asarray(
input_tensor.data).squeeze()), output_tensor[:-1]
if is_permutation(target, output):
permutation_count += 1
if nondecreasing(output) == 0:
nondecreasing_count += 1
print("Permutation: %s" % (permutation_count / len(training_pairs)))
print("Nondecreasing: %s" % (nondecreasing_count / len(training_pairs)))
def train_iters(input_lang,
output_lang,
pairs,
encoder,
decoder,
n_iters,
print_every=1000,
plot_every=100,
learning_rate=0.01):
start = time.time()
plot_losses = []
print_loss_total = 0 # Reset every print_every
plot_loss_total = 0 # Reset every plot_every
encoder_optimizer = optim.SGD(encoder.parameters(), lr=learning_rate)
decoder_optimizer = optim.SGD(decoder.parameters(), lr=learning_rate)
training_pairs = [
tensors_from_pair(input_lang, output_lang, random.choice(pairs))
for i in range(n_iters)
]
criterion = nn.NLLLoss()
for iter in range(1, n_iters + 1):
training_pair = training_pairs[iter - 1]
input_tensor = training_pair[0]
target_tensor = training_pair[1]
loss = train(input_tensor, target_tensor, encoder, decoder,
encoder_optimizer, decoder_optimizer, criterion)
print_loss_total += loss
plot_loss_total += loss
if iter % print_every == 0:
print_loss_avg = print_loss_total / print_every
print_loss_total = 0
print('%s (%d %d%%) %.4f' %
(time_since(start, iter / n_iters), iter,
iter / n_iters * 100, print_loss_avg))
if iter % plot_every == 0:
plot_loss_avg = plot_loss_total / plot_every
plot_losses.append(plot_loss_avg)
plot_loss_total = 0
show_plot(plot_losses)
def run():
"""
Run the experiment.
"""
name = "train"
is_ptr = True
hidden_dim = embedding_dim = 256
n_epochs = 1
grad_clip = 2
teacher_force_ratio = 0.5
optimizer = optim.Adam
optimizer_params = {}
max_val, max_length, pairs = read_data(name)
set_max_length(max_length)
training_pairs = [tensors_from_pair(pair) for pair in pairs]
data_dim = max_val + 1
encoder = Encoder(input_dim=data_dim,
embedding_dim=embedding_dim,
hidden_dim=hidden_dim).to(device)
if is_ptr:
decoder = PtrDecoder(output_dim=data_dim,
embedding_dim=embedding_dim,
hidden_dim=hidden_dim).to(device)
else:
decoder = AttnDecoder(output_dim=data_dim,
embedding_dim=embedding_dim,
hidden_dim=hidden_dim).to(device)
train(encoder=encoder,
decoder=decoder,
optim=optimizer,
optim_params=optimizer_params,
weight_init=weight_init,
grad_clip=grad_clip,
is_ptr=True,
training_pairs=training_pairs,
n_epochs=n_epochs,
teacher_force_ratio=teacher_force_ratio,
print_every=50,
plot_every=50,
save_every=100)
def run():
"""
Run the experiment.
"""
is_ptr = True
np.random.seed(RANDOM_SEED)
max_val, max_length, pairs = read_data(name="test")
np.random.shuffle(pairs)
training_pairs = [tensors_from_pair(pair) for pair in pairs]
data_dim = max_val + 1
hidden_dim = embedding_dim = 256
encoder = Encoder(input_dim=data_dim,
embedding_dim=embedding_dim,
hidden_dim=hidden_dim).to(device)
if is_ptr:
decoder = PtrDecoder(output_dim=data_dim,
embedding_dim=embedding_dim,
hidden_dim=hidden_dim).to(device)
else:
decoder = AttnDecoder(output_dim=data_dim,
embedding_dim=embedding_dim,
hidden_dim=hidden_dim).to(device)
checkpoint = load_checkpoint("ptr" if is_ptr else "vanilla")
if checkpoint:
encoder.load_state_dict(checkpoint["encoder"])
decoder.load_state_dict(checkpoint["decoder"])
else:
print("Count not find checkpoint file.")
for i in range(10):
input_tensor, target_tensor = training_pairs[i]
output_tensor = evaluate(encoder=encoder,
decoder=decoder,
input_tensor=training_pairs[i][0],
is_ptr=is_ptr)
print(list(np.asarray(input_tensor.data).squeeze()),
output_tensor[:-1])
def run():
"""
Run the experiment.
"""
max_val, max_length, tasks = read_data(name="ewc", ewc=True)
tasks = [[tensors_from_pair(pair) for pair in pairs] for pairs in tasks]
set_max_length(max_length)
data_dim = max_val + 1
hidden_dim = embedding_dim = 256
encoder = Encoder(input_dim=data_dim,
embedding_dim=embedding_dim,
hidden_dim=hidden_dim).to(device)
decoder = PtrDecoder(output_dim=data_dim,
embedding_dim=embedding_dim,
hidden_dim=hidden_dim).to(device)
n_epochs = 1
grad_clip = 2
teacher_force_ratio = 0.5
optimizer = optim.Adam
optimizer_params = {}
train(encoder=encoder,
decoder=decoder,
optim=optimizer,
optim_params=optimizer_params,
importance=1,
weight_init=weight_init,
grad_clip=grad_clip,
is_ptr=True,
tasks=tasks,
n_epochs=n_epochs,
teacher_force_ratio=teacher_force_ratio,
print_every=50,
plot_every=50,
save_every=500)