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))