def test(model, test_set, tsp_database_path):
model.eval()
test_loss = 0
correct = 0
random.shuffle(test_set)
for data_file in test_set:
details = data_file.split('.')[0].split('_')
nb_cities, instance_id = int(details[1]), int(details[2])
ordered_path, total_weight = read_tsp_choco_solution_file(nb_cities, instance_id, tsp_database_path)
weight_matrix = ordered_path.get_weight_matrix()
input_data = Variable(torch.tensor(normalize_weight_matrix(weight_matrix).reshape((1, nb_cities * nb_cities)),
dtype=torch.float))
output = model(input_data)
target = Variable(torch.tensor(ordered_path.to_ordered_path_binary_matrix().get_candidate(), dtype=torch.float),
requires_grad=True)
candidate = OrderedPath(np.array(torch.argmax(output.detach(), dim=1), dtype=int).transpose(), weight_matrix)
test_loss += model.loss_function(output, target) # sum up batch loss
correct += int(candidate.is_solution())
test_set_size = len(test_set)
test_loss /= test_set_size
print('\n' + "test" + ' set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
test_loss, correct, test_set_size, 100. * correct / test_set_size))
return correct / test_set_size
def valid(model, valid_set, epoch, tsp_database_path):
model.eval()
valid_loss = 0
correct = 0
sum_duplicates = 0
sum_solution = 0
random.shuffle(valid_set)
for data_file in valid_set:
details = data_file.split('.')[0].split('_')
nb_cities, instance_id = int(details[1]), int(details[2])
ordered_path, total_weight = read_tsp_choco_solution_file(nb_cities, instance_id, tsp_database_path)
weight_matrix = ordered_path.get_weight_matrix()
input_data = Variable(torch.tensor(normalize_weight_matrix(weight_matrix).reshape((1, nb_cities * nb_cities)),
dtype=torch.float))
output = model(input_data)
target = Variable(torch.tensor(ordered_path.to_ordered_path_binary_matrix().get_candidate(), dtype=torch.float),
requires_grad=True)
candidate = OrderedPath(np.array(torch.argmax(output.detach(), dim=1), dtype=int).transpose(), weight_matrix)
valid_loss += model.loss_function(output, target) # sum up batch loss
sum_duplicates += candidate.get_nb_duplicates()
sum_solution += int(candidate.is_solution())
correct += int(candidate.is_solution())
valid_set_size = len(valid_set)
sum_solution /= valid_set_size
sum_duplicates /= valid_set_size
print('Valid phase indicators : Solution: {}, Nb duplicates: {}'.format(sum_solution,
sum_duplicates))
valid_loss /= valid_set_size
print('Epoch {} - valid set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
epoch, valid_loss, correct, valid_set_size, 100. * correct / valid_set_size))
return correct / valid_set_size, valid_loss, sum_duplicates
def train(model, train_set, optimizer, tsp_database_path):
model.train()
sum_duplicates = 0
sum_solution = 0
random.shuffle(train_set)
for data_file in train_set:
details = data_file.split('.')[0].split('_')
nb_cities, instance_id = int(details[1]), int(details[2])
ordered_path, total_weight = read_tsp_choco_solution_file(nb_cities, instance_id, tsp_database_path)
weight_matrix = ordered_path.get_weight_matrix()
input_data = Variable(torch.tensor(normalize_weight_matrix(weight_matrix).reshape((1, nb_cities * nb_cities)),
dtype=torch.float), requires_grad=True)
optimizer.zero_grad()
output = model(input_data) # calls the forward function
target = Variable(torch.tensor(ordered_path.to_ordered_path_binary_matrix().get_candidate(), dtype=torch.float),
requires_grad=True)
candidate = OrderedPath(np.array(torch.argmax(output.detach(), dim=1), dtype=int), weight_matrix)
sum_duplicates += candidate.get_nb_duplicates()
sum_solution += int(candidate.is_solution())
loss = model.loss_function(output, target)
loss.backward()
optimizer.step()
train_set_size = len(train_set)
print('Training indicators : Solution: {}, Nb duplicates: {}'.format(sum_solution / train_set_size,
sum_duplicates / train_set_size))
return model
def test(model, test_set, database_path):
model.eval()
random.shuffle(test_set)
sum_predictions = 0
test_loss = 0
for data_file in test_set:
nb_cities, instance_id = data_file[0], data_file[1]
visited_cities, current_city_one_hot, target_one_hot = data_file[
2], data_file[3], data_file[4]
ordered_path, total_weight = read_tsp_heuristic_solution_file(
nb_cities, instance_id, database_path)
formatted_weight_matrix = \
normalize_weight_matrix(ordered_path.get_weight_matrix()).reshape((1, nb_cities * nb_cities))
input_data = Variable(torch.tensor(np.concatenate(
(formatted_weight_matrix, visited_cities, current_city_one_hot),
axis=1),
dtype=torch.float),
requires_grad=True)
target = Variable(torch.tensor(target_one_hot, dtype=torch.float),
requires_grad=True)
output = model(input_data) # calls the forward function
test_loss += model.loss_function(output, target)
expected_next_city = int(torch.argmax(target, dim=1))
predicted_next_city = int(torch.argmax(output, dim=1))
sum_predictions += int(predicted_next_city == expected_next_city)
test_set_size = len(test_set)
test_loss /= test_set_size
print('\n' + "test" +
' set: Average loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\n'.format(
test_loss, sum_predictions, test_set_size, 100. *
sum_predictions / test_set_size))
return sum_predictions / test_set_size
def train(model, train_set, optimizer, database_path):
model.train()
random.shuffle(train_set)
sum_predictions = 0
for data_file in train_set:
nb_cities, instance_id = data_file[0], data_file[1]
visited_cities, current_city_one_hot, target_one_hot = data_file[
2], data_file[3], data_file[4]
ordered_path, total_weight = read_tsp_heuristic_solution_file(
nb_cities, instance_id, database_path)
formatted_weight_matrix = \
normalize_weight_matrix(ordered_path.get_weight_matrix()).reshape((1, nb_cities * nb_cities))
input_data = Variable(torch.tensor(np.concatenate(
(formatted_weight_matrix, visited_cities, current_city_one_hot),
axis=1),
dtype=torch.float),
requires_grad=True)
target = Variable(torch.tensor(target_one_hot, dtype=torch.float),
requires_grad=True)
optimizer.zero_grad()
output = model(input_data) # calls the forward function
loss = model.loss_function(output, target)
loss.backward()
optimizer.step()
expected_next_city = int(torch.argmax(target, dim=1))
predicted_next_city = int(torch.argmax(output, dim=1))
sum_predictions += int(predicted_next_city == expected_next_city)
train_set_size = len(train_set)
print('Training indicators : ' + 'Accuracy (predictions): {:.4f}%'.format(
(sum_predictions / train_set_size) * 100.))
return model
def test_normalize_weight_matrix(self):
self.assertTrue((normalize_weight_matrix(weight_matrix_3) == np.array([[0., 1., 0.75, 0.25, 0.5],
[1., 0., 1., 0.75, 0.5],
[0.75, 0.25, 0., 0.75, 0.75],
[0.25, 0.75, 1., 0., 0.25],
[0.5, 0.5, 0.5, 0.25, 0.]],
dtype=float)).all)