def main(): runs=10000 start_temp,alpha=10000,0.9995 city_file="test-input-1.txt" output_file = open("test-output-1.txt",'w') cities = getCities(city_file) if len(cities) > 1000: runs = 100000 new_start = lambda: random_start(len(cities)) routes = routing(cities) tour_function=lambda tour: -tour_length(routes,tour) score,path=anneal(new_start,random_tour_permutations,tour_function,runs,start_temp,alpha) score = score*-1 score_str=str(score) output_file.write(score_str) output_file.write("\n") for city in path: city_str = str(city) output_file.write(city_str) output_file.write("\n") output_file.close()
def tracts_mapping1(tractography1, tractography2, loss_function, neighbour, iterations_anneal_now,pre_map_file): ann = [100, 200, 400, 600, 800, 1000] iterations_anneal_pre = 0 if iterations_anneal_now<=100: dm12 = bundles_distances_mam(tractography1, tractography2) mapping12_coregistration_1nn = np.argmin(dm12, axis=1) else: k = (iterations_anneal_now/200) - 1 iterations_anneal_pre = ann[k] from dipy.io.pickles import load_pickle mapping12_coregistration_1nn = load_pickle(pre_map_file) iterations_anneal = iterations_anneal_now - iterations_anneal_pre print "Iteration: ", iterations_anneal_now, iterations_anneal_pre, iterations_anneal print "The previous coregistration gives a mapping12 with the following loss:" loss_coregistration_1nn = loss_function(mapping12_coregistration_1nn) print "loss =", loss_coregistration_1nn #iterations_anneal = 100 print "Simulated Annealing" np.random.seed(1) initial_state = mapping12_coregistration_1nn.copy() mapping12_best, energy_best = anneal(initial_state=initial_state, energy_function=loss_function, neighbour=neighbour, transition_probability=transition_probability, temperature=temperature_boltzmann, max_steps=iterations_anneal, energy_max=0.0, T0=200.0, log_every=1000) return mapping12_coregistration_1nn, loss_coregistration_1nn, mapping12_best, energy_best
def optimise_func(graph): ''' :param graph: :return: ''' resources = model.Resources() medical = model.Medical() # for initial run LGAs = graph.nodes() numLGAs = len(LGAs) # random lists randList1 = np.random.rand(numLGAs) randList1 /= sum(randList1) randList2 = np.random.rand(numLGAs) randList2 /= sum(randList2) proposedInterventionDict = { LGA: { Nurses: numNurses, Specialists: numSpec } for LGA, Nurses, Specialists, numNurses, numSpec in zip( LGAs, ['Nurses'] * numLGAs, ['Specialists'] * numLGAs, resources.nurses * randList1, resources.specialists * randList2) } # get all the required lga medical features medicalList = [ "GPs", "Specialists", "Hospitals", "DrugServices", "NSPs", "Undiagnosed", "ExpectedNewInfections" ] # dictionary to store medicalDict = {} for feature in medicalList: # assign all medical features to dictionary medicalDict[feature] = nx.get_node_attributes(graph, feature) # get forecasts separately forecasts = nx.get_node_attributes(graph, "Forecast") args = { 'proposedInterventionDict': proposedInterventionDict, 'forecasts': forecasts, 'resources': resources, 'medical': medical, 'medicalServices': medicalDict } #### Run optimisation optimalSolution, optimalCost = sim_anneal.anneal(objective_func, **args) return optimalSolution, optimalCost
def tracts_mapping(tractography1, tractography2, loss_function, neighbour, iterations_anneal): print print "The best coregistration+1NN gives a mapping12 with the following loss:" dm12 = bundles_distances_mam(tractography1, tractography2) mapping12_coregistration_1nn = np.argmin(dm12, axis=1) loss_coregistration_1nn = loss_function(mapping12_coregistration_1nn) print "loss =", loss_coregistration_1nn #iterations_anneal = 100 print "Simulated Annealing" np.random.seed(1) initial_state = mapping12_coregistration_1nn.copy() mapping12_best, energy_best = anneal(initial_state=initial_state, energy_function=loss_function, neighbour=neighbour, transition_probability=transition_probability, temperature=temperature_boltzmann, max_steps=iterations_anneal, energy_max=0.0, T0=200.0, log_every=1000) return mapping12_coregistration_1nn, loss_coregistration_1nn, mapping12_best, energy_best
def main(protein): protein_array = copy.deepcopy(protein) for i in range(4, len(protein)): best_score = 0 best_protein = [] for j in range(8): protein_object = functions.protein_place(protein[i]) new_protein = simulated_annealing.anneal(protein_object, i+10*j, 1) print "result:" print i,new_protein[0], new_protein[1] # folder_iter.write_csv(new_protein[2], 'result_anneal%s' %(i+10*j)) if new_protein[0]<best_score: best_score = new_protein[0] best_protein = copy.deepcopy(new_protein[1]) functions.Visualizer2D(new_protein[1], protein[i], new_protein[0], i+10*j + 800) functions.Visualizer2D(best_protein, protein[i], best_score, i+10*j + 900)
def main(): # length = 50 # h_concentration = 30 # protein_array = copy.copy(protein_generator.protein_generator(length, h_concentration, 100)) # result_array = [] # for protein in protein_array: # protein_object = functions.protein_place(protein) # print protein_object # configurations = 500 # start_pos = folder_iter.random_sampling(protein_object, configurations, 5) # # folder_iter.write_csv(start_pos, 'random_sampling%s' %protein) # theo = test.theo_score(protein) # score_saver = [protein, configurations] + [0]*(theo[0]+1) # print score_saver # for result in start_pos: # score_saver[abs(result[0])+2] += 1 # high_score = protein_generator.highscorefreq(score_saver) # result_array.append(score_saver) # folder_iter.write_csv(result_array, 'randomsampling_overview%s_%s' %(length, h_concentration)) protein_array = csv_move.make_array() # # csv_name = # f = open('results/final/randomsampling_overview50_20.csv','r') # data = csv.reader(f, delimiter=',') # for row in data: # if row[0] != 'protein': # protein_array.append(row[0]) # print protein_array for j in range(len(protein_array)): protein_object = functions.protein_place(protein_array[j]) print 'protein_object made' for i in range(14): new_protein = simulated_annealing.anneal(protein_object, 'test7%s' % (130 + i), 1) # print 'new_protein made' folder_iter.write_csv( new_protein[2], 'SA_50_20_15/result_anneal%s' % (protein_array[j] + str(i))) # print 'written to csv' functions.Visualizer2D(new_protein[1], protein_array[j], new_protein[0], 'anneal7%s' % (protein_array[j] + str(i))) print 'SA succes'
def main(protein): protein_array = copy.deepcopy(protein) for j in range(len(protein_array)): protein_object = functions.protein_place(protein_array[j]) print 'protein_object made' for i in range(20): new_protein = simulated_annealing.anneal(protein_object, 'test%s' % (130 + i), 1) # print 'new_protein made' folder_iter.write_csv( new_protein[2], 'result_anneal%s' % (protein_array[j] + str(i))) # print 'written to csv' functions.Visualizer2D(new_protein[1], protein_array[j], new_protein[0], 'anneal%s' % (protein_array[j] + str(i))) print 'hillclimber succes'
def hybrid_system(): # load data and functions slot_presentation, presentation_presentation, presentation_supervisor, supervisor_preference = dt.load() # initialize matrices slot_no = slot_presentation.shape[0] presentation_no = slot_presentation.shape[1] population_size = 10 population = np.empty([population_size, slot_no, presentation_no], dtype=np.int8) penalty_points = np.empty(population_size, dtype=int) # create initial population for i in range(population_size): chromosome = ga.generate_chromosome(slot_presentation) population[i] = chromosome penalty_point = \ penalty(chromosome, presentation_presentation, presentation_supervisor, supervisor_preference)[0] penalty_points[i] = penalty_point # sort initial population based on penalty points population = population[penalty_points.argsort()] penalty_points = penalty_points[penalty_points.argsort()] # run genetic algorithm for 100 generations ga_max_generations = 100 population, penalty_points, ga_plot_data = \ ga.reproduction(ga_max_generations, population, penalty_points, presentation_presentation, presentation_supervisor, supervisor_preference) # run simulated annealing after running genetic algorithm temperature = penalty_points[population_size - 1] - penalty_points[0] candidate = population[0] penalty_point = penalty_points[0] best_candidate, best_penalty_point, sa_plot_data = \ sa.anneal(temperature, candidate, penalty_point, presentation_presentation, presentation_supervisor, supervisor_preference) # write result data constraint_counts = \ penalty(best_candidate, presentation_presentation, presentation_supervisor, supervisor_preference) plot_data = np.concatenate([ga_plot_data, sa_plot_data]) dt.write(best_candidate, supervisor_preference, constraint_counts, plot_data)
import sys, os import time base_path = os.getcwd() if __name__ == '__main__': if len(sys.argv) > 1: rel_path = sys.argv[1] else: rel_path = 'data/kroA100.tsp' full_path = '/'.join((base_path, rel_path)) headers, cities = process_data(file_path=full_path) dists = Distances( cities=cities, total=headers['DIMENSION'], custom_alg=headers['EDGE_WEIGHT_TYPE'], ) start = time.time() solution = anneal( T=10000, min_T=0.00001, alpha=0.99, iterations=100, distances=dists, cities=cities, dimension=headers['DIMENSION'], # plot=True, ) print(time.time() - start)
print "Random Search." np.random.seed(1) # this is the random seed of the optimization process mapping12_best_rs, energy_best_rs = random_search(loss_function=loss_function, random_state_function=informed_random_mapping, iterations=iterations_random) print "Best loss:", energy_best_rs print print "The best coregistration+1NN gives a mapping12 with the following loss:" dm12 = bundles_distances_mam(tractography1, tractography2) mapping12_coregistration_1nn = np.argmin(dm12, axis=1) loss_coregistration_1nn = loss_function(mapping12_coregistration_1nn) print "loss =", loss_coregistration_1nn if do_simulated_annealing: print print "Simulated Annealing" np.random.seed(1) # this is the random seed of the optimization process # initial_state = random_mapping(size1, size2) #initial_state = mapping12_best_rs.copy() initial_state = mapping12_coregistration_1nn.copy() mapping12_best, energy_best = anneal(initial_state=initial_state, energy_function=loss_function, neighbour=neighbour4, transition_probability=transition_probability, temperature=temperature_boltzmann, max_steps=iterations_anneal, energy_max=0.0, T0=200.0, log_every=1000) ren = fvtk.ren() ren = visualize(ren,tractography1[:6],tractography2,mapping12_best) fvtk.show(ren) ren1 = fvtk.ren() ren1 = visualize(ren1,tractography1[6:12],tractography2,mapping12_best[6:]) fvtk.show(ren1)
# Fix schedule such as the time for sleeping schedule.put_act("Sleep", "00:00", "08:00") schedule.put_act("Lunch", "12:00", "13:00") schedule.put_act("Nap", "15:00", "16:00") schedule.put_act("Dinner", "18:00", "20:00") # Take in tasks tasks = set() tasks.add( Task("Essay", priority=3, end_date="2018-01-14", estimated_time=8 * 60, category="Assignment")) tasks.add( Task("Programming", priority=3, end_date="2018-01-19", estimated_time=4 * 60, category="Assignment")) tasks.add( Task("Writing", priority=3, end_date="2018-01-30", estimated_time=8 * 60, category="Assignment")) # Generate the Schedule and check with Machine Learning algorithm hill_climbing(schedule, tasks) schedule = anneal(schedule, list(tasks), 0.1, 0.1, 0.9) print(schedule)
def anneal(new_start,random_tour_permutations,tour_function,runs,start_temp,alpha): from simulated_annealing import anneal score,path=anneal(new_start,random_tour_permutations,tour_function,runs,start_temp,alpha) return score,path
# tasks.add(Task("Essay", priority=3, end_date="2018-01-20", estimated_time=10*60, category="Assignment")) # tasks.add(Task("Programming", priority=3, end_date="2018-01-20", estimated_time=10*60, category="Assignment")) # tasks.add(Task("Writing", priority=3, end_date="2018-01-20", estimated_time=10*60, category="Assignment")) # tasks.add(Task("Manga", priority=3, end_date="2018-01-20", estimated_time=10*60, category="Assignment")) training_x = [] training_y = [] while True: var_score, deadline_score, cont_score = random(), random(), random() # Generate the Schedule # Use machine learning algorithm to check the variability, deadline and continuity preference hill_climbing(schedule, tasks) schedule = anneal(schedule, list(tasks), var_score, deadline_score, cont_score) if len(training_x) < 100: print(schedule) else: prediction = predict(np.array([var_score, deadline_score, cont_score]), np.array(training_x), np.array(training_y)) if not prediction: continue else: print(schedule) satisfied = input("Are you satisfied with the schedule? (Y/N)\n") answer = None if satisfied == "Y":