def compareSolution(fileName, sol, path, dropoff_mapping, list_locs,
output_directory):
input_file = utils.read_file(fileName)
#print('outputs/'+fileName[fileName.index('/')+1:fileName.index('.')+1]+'out')
if os.path.exists('outputs/' + fileName[fileName.index('/') +
1:fileName.index('.') + 1] +
'out'):
output_file = utils.read_file('outputs/' +
fileName[fileName.index('/') +
1:fileName.index('.') + 1] +
'out')
file_cost = output_validator.tests(input_file, output_file, [])
file_cost, meg = file_cost[0], file_cost[1]
print(fileName, ": ", meg)
if file_cost > sol:
print("better solution found by ",
100 * (file_cost - sol) / file_cost, "%")
output_file = utils.input_to_output(fileName, output_directory)
convertToFile(convert_locations_to_indices(path, list_locs),
dropoff_mapping, output_file, list_locs)
else:
print('No previous solution.')
output_file = utils.input_to_output(fileName, output_directory)
convertToFile(convert_locations_to_indices(path, list_locs),
dropoff_mapping, output_file, list_locs)
def solve_from_file(input_file, output_directory, params=[]):
# print('Processing', input_file)
input_data = utils.read_file(input_file)
number_of_kingdoms, list_of_kingdom_names, starting_kingdom, adjacency_matrix = data_parser(
input_data)
closed_walk, conquered_kingdoms = solve(list_of_kingdom_names,
starting_kingdom,
adjacency_matrix,
params=params)
if closed_walk == "Error":
print("Error")
else:
basename, filename = os.path.split(input_file)
output_filename = utils.input_to_output(filename)
output_file = f'{output_directory}/{output_filename}'
if not os.path.exists(output_directory):
os.makedirs(output_directory)
utils.write_data_to_file(output_file, closed_walk, ' ')
utils.write_to_file(output_file, '\n', append=True)
utils.write_data_to_file(output_file,
conquered_kingdoms,
' ',
append=True)
def improve_from_file(input_file, output_directory, parapms=[]):
print('Processing %s' % (input_file))
input_data = utils.read_file(input_file)
num_of_locations, num_houses, list_locations, list_houses, starting_car_location, adjacency_matrix = data_parser(
input_data)
car_path, drop_offs = solve(list_locations,
list_houses,
starting_car_location,
adjacency_matrix,
params=params)
G, _ = adjacency_matrix_to_graph(adjacency_matrix)
new_cost, _ = student_utils.cost_of_solution(G, car_path, drop_offs)
basename, filename = os.path.split(input_file)
output_filename = utils.input_to_output(filename, "")
output_file = f'{output_directory}/{output_filename}'
output_data = utils.read_file(output_file)
car_cycle = convert_locations_to_indices(car_cycle, list_locations)
old_cost, _ = student_utils.cost_of_solution(G, car_cycle, drop_offs)
if new_cost < old_cost:
print(input_file, "improved from", old_cost, 'to', new_cost)
if not os.path.exists(output_directory):
os.makedirs(output_directory)
convertToFile(car_path, drop_offs, output_file, list_locations)
else:
print("No improvments made for", input_file)
def validate_all_outputs(input_directory, output_directory, params=[]):
input_files = utils.get_files_with_extension(input_directory, '.in')
output_files = utils.get_files_with_extension(output_directory, '.out')
for file in output_files:
print(file)
output_directory += '/'
all_results = []
string = ''
for input_file in input_files:
basename, filename = os.path.split(input_file)
if '200' in filename:
continue
output_file = utils.input_to_output(input_file, output_directory)
print(input_file, output_file)
if output_file not in output_files:
print(f'No corresponding .out file for {input_file}')
results = (None, None,
f'No corresponding .out file for {input_file}')
else:
results = validate_output(input_file, output_file, params=params)
string += filename + " " + results[2] + "\n"
all_results.append((input_file, results))
utils.write_to_file('validations.out', string)
return all_results
def solve_from_file(input_file, output_directory, params=[]):
print("Processing", input_file)
input_data = utils.read_file(input_file)
(
num_of_locations,
num_houses,
list_locations,
list_houses,
starting_car_location,
adjacency_matrix,
) = data_parser(input_data)
car_path, drop_offs = solve(
list_locations,
list_houses,
starting_car_location,
adjacency_matrix,
params=params,
)
basename, filename = os.path.split(input_file)
if not os.path.exists(output_directory):
os.makedirs(output_directory)
output_file = utils.input_to_output(input_file, output_directory)
convertToFile(car_path, drop_offs, output_file, list_locations)
def validate_all_outputs(input_directory, output_directory, params=[]):
input_files = utils.get_files_with_extension(input_directory, '.in')
output_files = utils.get_files_with_extension(output_directory, '.out')
all_results = []
for input_file in input_files:
output_file = utils.input_to_output(input_file, output_directory)
print(input_file, output_file)
if output_file not in output_files:
print(f'No corresponding .out file for {input_file}')
results = (None, None,
f'No corresponding .out file for {input_file}')
else:
if False: # delete invalid outputs
try:
results = validate_output(input_file,
output_file,
params=params)
all_results.append((input_file, results))
except:
os.remove(output_file)
os.remove(output_file + ".optimal")
else:
results = validate_output(input_file,
output_file,
params=params)
all_results.append((input_file, results))
return all_results
def _outputCost(input_file,
output_files,
output_directory,
all_baseline,
i,
all_results,
inputs=[]):
output_file = utils.input_to_output(input_file,
output_directory).replace("\\", "/")
if output_file not in output_files:
print(f'No corresponding .out file for {input_file}')
results = (None, None, f'No corresponding .out file for {input_file}')
else:
cost = ov.validate_output(input_file, output_file, verbose=VERBOSE)[1]
#baselineCost = ov.validate_output(input_file, "./baseline_outputs/" + output_file.split("/")[-1])[1]
baselineCost = all_baseline[i]
#all_baseline.append(baselineCost)
if type(cost) is str:
raise Exception("<-- CUSTOM ERROR --> Solver output is string: " +
cost)
results = cost / baselineCost
print("Input: ", input_file, "\t Results: ", results)
all_results.append(min(results, 1))
inputs.append(input_file)
return min(results, 1)
def solve_from_file(input_file, output_directory, params=[]):
if params[1] != "ALL" and '_' + str(params[1]) not in input_file:
print('Skipping', input_file)
return
print('Processing', input_file)
input_data = utils.read_file(input_file)
num_of_locations, num_houses, list_locations, list_houses, starting_car_location, adjacency_matrix = data_parser(
input_data)
car_path, drop_offs = solve(input_file,
num_of_locations,
num_houses,
list_locations,
list_houses,
starting_car_location,
adjacency_matrix,
params=params)
basename, filename = os.path.split(input_file)
if not os.path.exists(output_directory):
os.makedirs(output_directory)
output_file = utils.input_to_output(input_file, output_directory)
convertToFile(car_path, drop_offs, output_file, list_locations)
def solve_from_file(input_file, output_directory, params=[]):
print('Processing', input_file)
basename, filename = os.path.split(input_file)
if not os.path.exists(output_directory):
os.makedirs(output_directory)
output_file = utils.input_to_output(input_file, output_directory)
optimal_tracker = output_file + ".optimal"
existing_optimal = ((not os.path.exists(optimal_tracker)) or (utils.read_file(optimal_tracker)[0][0] == "True"))
if os.path.exists(output_file) and existing_optimal:
if not os.path.exists(optimal_tracker):
utils.write_to_file(output_file + ".optimal", str(True))
print("Skipping, already solved optimal")
elif os.path.exists(output_file) and False:
print("Skipping non-optimal")
else:
input_data = utils.read_file(input_file)
num_of_locations, num_houses, list_locations, list_houses, starting_car_location, adjacency_matrix = data_parser(input_data)
sol = solve(list_locations, list_houses, starting_car_location, adjacency_matrix, params=params)
if sol:
car_path, drop_offs, is_optimal = sol
convertToFile(car_path, drop_offs, output_file, list_locations)
utils.write_to_file(output_file + ".optimal", str(is_optimal))
else:
print("no feasible solution")
def validate_all_outputs(input_directory,
output_directory,
cost_dir,
params=[]):
input_files = utils.get_files_with_extension(input_directory, '.in')
output_files = utils.get_files_with_extension(output_directory, '.out')
if os.path.isfile(cost_dir):
print('ERROR: ' + cost_dir + 'already exist!')
return
check_file = open(cost_dir, 'w')
all_results = []
for input_file in tqdm.tqdm(input_files):
output_file = utils.input_to_output(input_file, output_directory)
print(input_file, output_file)
if output_file not in output_files:
print(f'No corresponding .out file for {input_file}')
results = (None, None,
f'No corresponding .out file for {input_file}')
else:
input_error, cost, results = validate_output(input_file,
output_file,
params=params)
name = input_file.split('/')[-1]
check_file.write(name + ':' + str(cost) + '\n')
all_results.append((input_file, results))
check_file.close()
return all_results
def solve_from_file(input_file, output_directory, params=[]):
print('Processing', input_file)
input_data = utils.read_file(input_file)
num_of_locations, num_houses, list_locations, list_houses, starting_car_location, adjacency_matrix = data_parser(input_data)
car_path, drop_offs = solve(list_locations, list_houses, starting_car_location, adjacency_matrix, params=params)
#getting the new cost
G, _ = adjacency_matrix_to_graph(adjacency_matrix)
curr_cost, _ = cost_of_solution(G, car_path, drop_offs)
basename, filename = os.path.split(input_file)
if not os.path.exists(output_directory):
os.makedirs(output_directory)
output_file = utils.input_to_output(input_file, output_directory)
#checking if new cost is better or not
if os.path.isfile(output_file):
output_data = utils.read_file(output_file)
best_cost, _ = tests(input_data, output_data)
if curr_cost < best_cost:
convertToFile(car_path, drop_offs, output_file, list_locations)
print('Best cost so far: ' + str(best_cost), ', New cost: ' + str(curr_cost))
else:
convertToFile(car_path, drop_offs, output_file, list_locations)
print('New cost: ' + str(curr_cost))
def solve(input,
output,
list_of_locations,
list_of_homes,
starting_car_location,
adjacency_matrix,
params=[]):
"""
Write your algorithm here.
Input:
list_of_locations: A list of locations such that node i of the graph corresponds to name at index i of the list
list_of_homes: A list of homes
starting_car_location: The name of the starting location for the car
adjacency_matrix: The adjacency matrix from the input file
Output:
A list of locations representing the car path
A dictionary mapping drop-off location to a list of homes of TAs that got off at that particular location
NOTE: both outputs should be in terms of indices not the names of the locations themselves
"""
dth = DTH(input_filename=input,
output_filename=utils.input_to_output(input, output))
e = dth.energy()
if len(list_of_locations) <= 50:
dth.Tmax = (e / 10) # Max (starting) temperature
dth.Tmin = (e / 1000) # Min (ending) temperature
dth.steps = 10000 # Number of iterations
dth.updates = 1000
# Number of updates (by default an update prints to stdout)
dth.prob = 0.8
# dth.set_schedule(dth.auto(minutes=.2, steps=250))
# dth.steps = 500
# dth.updates = 500
elif len(list_of_locations) <= 100:
dth.Tmax = e / 10 # Max (starting) temperature
dth.Tmin = e / 1000 # Min (ending) temperature
dth.steps = 1000 # Number of iterations
dth.updates = 100 # Number of updates (by default an update prints to stdout)
# dth.set_schedule(dth.auto(minutes=.2, steps=250))
# dth.steps = 500
# dth.updates = 500
dth.prob = 0.8
else:
dth.Tmax = (e / 10) # Max (starting) temperature
dth.Tmin = (e / 1000) # Min (ending) temperature
dth.steps = 100 # Number of iterations
dth.updates = 100 # Number of updates (by default an update prints to stdout)
# dth.set_schedule(dth.auto(minutes=.2, steps=250))
# dth.steps = 500
# dth.updates = 500
dth.prob = 0.8
dth.copy_strategy = "slice"
car_cycle, cost = dth.anneal()
dth.gen_best_state_dropoff()
return car_cycle, dth.dropoff_mapping
def validate_all_outputs(input_directory, output_directory, params=[]):
input_files = utils.get_files_with_extension(input_directory, '.in')
output_files = utils.get_files_with_extension(output_directory, '.out')
all_results = []
for input_file in input_files:
output_file = utils.input_to_output(input_file, output_directory)
if output_file not in output_files:
print(f'No corresponding .out file for {input_file}')
results = (None, None, f'No corresponding .out file for {input_file}')
else:
results = validate_output(input_file, output_file, params=params)
all_results.append((input_file, results))
return all_results
def solve_from_file_score(input_file, output_directory, params=[]):
print('Processing', input_file)
input_data = utils.read_file(input_file)
num_of_locations, num_houses, list_locations, list_houses, starting_car_location, adjacency_matrix = data_parser(
input_data)
car_path, drop_offs = solve(list_locations,
list_houses,
starting_car_location,
adjacency_matrix,
params=params)
basename, filename = os.path.split(input_file)
if not os.path.exists(output_directory):
os.makedirs(output_directory)
output_file = utils.input_to_output(input_file, output_directory)
G = student_utils.adjacency_matrix_to_graph(adjacency_matrix)[0]
#convertToFile(car_path, drop_offs, output_file, list_locations)
return G, car_path, drop_offs
def validate_all_outputs(input_directory, output_directory, check_dir, params=[]):
input_files = utils.get_files_with_extension(input_directory, '.in')
output_files = utils.get_files_with_extension(output_directory, '.out')
# if os.path.isfile(check_dir):
# print('ERROR: ' + check_dir + ' already exist!')
# return
check_file = open(check_dir, 'w')
for input_file in tqdm.tqdm(input_files):
output_file = utils.input_to_output(input_file, output_directory)
# print(input_file, output_file)
if output_file not in output_files:
print(f'No corresponding .out file for {input_file}')
else:
cost = validate_output(input_file, output_file, params=params)
name = input_file.split('/')[-1]
check_file.write(name.replace('in', 'out') + ':' + str(cost) + '\n')
check_file.close()
def solve_from_file(input_file, output_directory, params=[]):
print(
"===============================================================================================================================================")
print(' In "solve_from_file, Processing...making new complete_home_graph and feeding it to "solve"\n', input_file)
message, error, num_of_locations, num_houses, old_list_locations, new_list_locations, list_houses, starting_car_location, \
adjacency_matrix, shortest_paths_between_homes, complete_home_graph, old_graph, new_starting_point_index = chgg.complete_home_graph_generator_from_file(
input_file, params=[])
print(message)
car_path, drop_offs = solve(old_list_locations, new_list_locations, list_houses, starting_car_location,
adjacency_matrix,
shortest_paths_between_homes, old_graph, new_starting_point_index)
basename, filename = os.path.split(input_file)
if not os.path.exists(output_directory):
os.makedirs(output_directory)
output_file = utils.input_to_output(input_file, output_directory)
# save result as .out file
convertToFile(car_path, drop_offs, output_file, old_list_locations)
# outputs message if .out is not valid
result = ov.validate_output(input_file, output_file)
print (" *** Validate_output Message :\n " + result[3])
def solve_from_file(input_file, output_directory, params=[]):
print('\nProcessing', input_file)
conn = sqlite3.connect('models.sqlite')
c = conn.cursor()
input_file_name = input_file.split('/')[-1]
optimal = c.execute('SELECT optimal FROM models WHERE input_file = (?)',
(input_file_name, )).fetchone()
conn.close()
# skip over optimal inputs
if optimal and optimal[0] and "--no-skip" not in params:
print('SKIPPPING', input_file_name)
return
input_data = utils.read_file(input_file)
num_of_locations, num_houses, list_locations, list_houses, starting_car_location, adjacency_matrix = data_parser(
input_data)
improved, car_path, drop_offs = solve(list_locations,
list_houses,
starting_car_location,
adjacency_matrix,
input_file_name,
params=params)
# only write out file if we got a better cost
if not improved:
print(input_file_name, 'DIDN\'T IMPROVE')
return
basename, filename = os.path.split(input_file)
if not os.path.exists(output_directory):
os.makedirs(output_directory)
output_file = utils.input_to_output(input_file, output_directory)
convertToFile(car_path, drop_offs, output_file, list_locations)
def compare_by_file(input_file, compare1, compare2, output_directory, params=[]):
print('Processing', input_file)
global fromcomp1
global fromcomp2
global totalcost1
global totalcost2
global totalcostcombined
global equallygood
input_data = utils.read_file(input_file)
compare_data1 = utils.read_file(compare1)
compare_data2 = utils.read_file(compare2)
number_of_kingdoms, list_of_kingdom_names, starting_kingdom, adjacency_matrix = data_parser(input_data)
G = adjacency_matrix_to_graph(adjacency_matrix)
comp1_kingdom_tour_name = compare_data1[0]
comp1_conquered_kingdoms_name = compare_data1[1]
comp2_kingdom_tour_name = compare_data2[0]
comp2_conquered_kingdoms_name = compare_data2[1]
comp1_kingdom_tour_index = convert_kingdom_names_to_indices(comp1_kingdom_tour_name, list_of_kingdom_names)
comp1_conquered_kingdoms_index = convert_kingdom_names_to_indices(comp1_conquered_kingdoms_name, list_of_kingdom_names)
comp2_kingdom_tour_index = convert_kingdom_names_to_indices(comp2_kingdom_tour_name, list_of_kingdom_names)
comp2_conquered_kingdoms_index = convert_kingdom_names_to_indices(comp2_conquered_kingdoms_name, list_of_kingdom_names)
cost1 = cost_of_solution(G, comp1_kingdom_tour_index, comp1_conquered_kingdoms_index)[0]
cost2 = cost_of_solution(G, comp2_kingdom_tour_index, comp2_conquered_kingdoms_index)[0]
if cost1 == 'infinite':
print(compare1)
raise Exception("not a valid outputs!!!")
elif cost2 =='infinite':
print(compare2)
raise Exception("not a valid outputs!!!")
basename, filename = os.path.split(input_file)
output_filename = utils.input_to_output(filename)
output_file = '{}/{}'.format(output_directory, output_filename)
if not os.path.exists(output_directory):
os.makedirs(output_directory)
totalcost1 += cost1
totalcost2 += cost2
if cost1 < cost2:
totalcostcombined += cost1
fromcomp1 += 1
utils.write_data_to_file(output_file, comp1_kingdom_tour_name, ' ')
utils.write_to_file(output_file, '\n', append=True)
utils.write_data_to_file(output_file, comp1_conquered_kingdoms_name, ' ', append=True)
else :
if cost1 == cost2 :
equallygood +=1
else:
fromcomp2 += 1
totalcostcombined += cost2
utils.write_data_to_file(output_file, comp2_kingdom_tour_name, ' ')
utils.write_to_file(output_file, '\n', append=True)
utils.write_data_to_file(output_file, comp2_conquered_kingdoms_name, ' ', append=True)
def _outputCost(input_file, output_directories):
output_files = [utils.input_to_output(input_file, output_directory).replace("\\", "/") for output_directory in output_directories]
costs = [ov.validate_output(input_file, output_file, verbose=VERBOSE)[1] for output_file in output_files]
print("Input: ", input_file, "\t Results: ", min(costs) / costs[-1], "\t from: ", costs.index(min(costs)))
return min(costs) / costs[-1], costs.index(min(costs))
