def show(self,export=False): """ Display a graph of the Markov Model. """ graph = [(node,val[0]) for node in self.node_cnx for val in self.node_cnx[node]] edge_labels = [round(val[1],2) for node in self.node_cnx for val in self.node_cnx[node]] draw_graph(graph,labels=edge_labels,export=export)
def run(self): s = Simulation(graph_type=self.type, graph_param=self.graph_param) g = s.build_graph() companies = s.generate_companies(g) graph_utils.draw_graph(g) s.generate_trucks(g, companies) cpy_companies = [(c[0], copy.deepcopy(c[1])) for c in companies] clients = s.generate_clients(g, cpy_companies) money_per_company = s.testCicle(g, s.generateMoneyPerCompany(), companies, cpy_companies, clients) minimum = [m[-1] for m in money_per_company] index_company = minimum.index(min(minimum)) # values for index_company for different values of profit margin values_pm_company = [] profitMaring_values = list(np.array(list(range(10, 50, 1))) / 10) for pm in profitMaring_values: companies[index_company][1].setProfitMargin(pm) money_per_company = s.testCicle(g, s.generateMoneyPerCompany(), companies, cpy_companies, clients) values_pm_company.append(money_per_company[index_company][-1]) gc.collect() legend = [[ "Company w/ worst profit: " + str(companies[index_company][1].pos) ]] s.drawPlot(profitMaring_values, values_pm_company, "Profit Margin", "Profit Margin", "Money", legend, per=0.05, color=graph_utils.colormap[companies[index_company][0]])
def draw_graph(self, outfile="./out.png"): edgeslist = [] # make a list of edges for u, vs in self.edges.items(): for v in vs: edgeslist.append((u, v)) draw_graph(self.nodes.values(), edgeslist)
def run(self): s = Simulation(graph_type=self.type, graph_param=self.graph_param) g = s.build_graph() companies = s.generate_companies(g) s.generate_trucks(g, companies) graph_utils.draw_graph(g) #graph_utils.show_graphs() cpy_companies = [(c[0], copy.deepcopy(c[1])) for c in companies] clients = s.generate_clients(g, cpy_companies) money_per_company = s.testCicle(g, s.generateMoneyPerCompany(), companies, cpy_companies, clients) gc.collect() legend = [(graph_utils.colormap[c[0]], c[1].name, c[1].pos) for c in companies] self.drawPlot(money_per_company, "Money vs Time", "Time", "Money", legend)
def run_hospital_decide_simulation(self, heuristic, nr_tiks=200): nr_tiks_per_pacient = self.max_weight * 3 self.reset_before_simulate() # Step 1: generate the rest of the agents and assign their postitions on the graph self.populate_charging_stations() self.generate_ambulances(hospital=self.hospital, nr_ambulances=self.nr_ambulances) number_of_patients = round(nr_tiks / nr_tiks_per_pacient) self.populate_patients(nr_tiks, number_of_patients) # Step 2: go through a series of iterations while ((self.get_tik() < nr_tiks) or self.patients): # or self.patients != []): print("\n TIK #" + str(self.get_tik())) if (self.patient_counter < number_of_patients and self.get_tik() == self.patient_generation_list[self.patient_counter]): self.generate_patient((self.min_weight + self.max_weight) / 2) # 1) hospital assigns goals to each ambulance self.hospital.execute(self.ambulances, self.patients, self.charging_stations, self.g, heuristic) # 2) each ambulance executes3 for a in self.ambulances: o = a.execute(self.hospital.get_hospital_pos()) if (o == "picked_up_success"): self.success += 1 self.patients.remove(a.get_patient()) elif (o == "picked_up_failed"): self.failed += 1 self.patients.remove(a.get_patient()) self.increment_tik() graph_utils.draw_graph(self.g) print("\n\nThe simulation ended with " + str(self.success) + " cases of success and " + str(self.failed) + " cases of failure")
def run(self): s = Simulation(graph_type=self.type, graph_param=self.graph_param) g = s.build_graph() while not nx.is_connected(g): g = s.build_graph() companies = s.generate_companies(g) s.generate_trucks(g, companies) graph_utils.draw_graph(g) cpy_companies = [(c[0], copy.deepcopy(c[1])) for c in companies] clients = s.generate_clients(g, cpy_companies) basic_preferences = [1 / s.n_companies for _ in range(s.n_companies)] for cli in clients: cli.setUtilities(basic_preferences) cli.risk = 1 money_per_company = s.testCicle(g, s.generateMoneyPerCompany(), companies, cpy_companies, clients) if not self.last: maximum = [m[-1] for m in money_per_company] index_best_company = maximum.index(max(maximum)) maximum[index_best_company] = 0 index_company = maximum.index(max(maximum)) else: minimum = [m[-1] for m in money_per_company] index_company = minimum.index(min(minimum)) # values for index_company for different values of preferences values_company_preferences = [] values_best_company = [] preferences_values = list(np.array(list(range(20, 101, 1))) / 100) for pref in preferences_values: for cli in clients: cli.utilities[index_company] = pref money_per_company = s.testCicle(g, s.generateMoneyPerCompany(), companies, cpy_companies, clients) values_company_preferences.append( money_per_company[index_company][-1]) if not self.last: values_best_company.append( money_per_company[index_best_company][-1]) gc.collect() if not self.last: self.legend[0] = self.legend[0] + str( companies[index_company][1].pos) self.legend[1] = self.legend[1] + str( companies[index_best_company][1].pos) self.drawPlot( preferences_values, values_company_preferences, values_best_company, "Preferences", "Preferences (%)", "Money", self.legend, color=[ graph_utils.colormap[companies[index_company][0]], graph_utils.colormap[companies[index_best_company][0]] ]) else: self.legend[0] = [ self.legend[0][0] + str(companies[index_company][1].pos) ] s.drawPlot(preferences_values, values_company_preferences, "Preferences", "Preferences (%)", "Money", self.legend, per=0.05, color=graph_utils.colormap[companies[index_company][0]])
p=0.2, min_weight=1, max_weight=10) # g = graph_utils.generate_weighted_barabasi_graph() companies = generate_companies(g, n_companies=5) generate_trucks(g, companies, n_trucks=7) clients = [ Client(n, [c[1] for c in companies], min_offer_val=20, max_offer_val=100) for n in g.nodes if "company" not in g.node[n] ] # graph_utils.draw_graph(g) p_remove = 0.02 # por random graph_utils.draw_graph(g) graph_utils.show_graphs() for i in range(10000): if not len(companies): print("NO MORE COMPANIES") break if len(companies) == 1: print( f"WINNER: {c} -- t={i} -- offers={companies[0][1].completedOffers}" ) if (randint(1, 99) / 100) < p_remove: do_edge_explosion(i, g) for cli in clients:
def run_cooperative_ambulances_simulation( self, nr_tiks=200, a_s=Ambulance.ActionSelection.selective, l_a=Ambulance.LearningApproach.QLearning): self.reset_before_simulate() nr_tiks_per_pacient = self.max_weight * 3 # Step 1: generate the rest of the agents and assign their postitions on the graph self.populate_charging_stations() self.generate_ambulances(hospital=self.hospital, nr_ambulances=self.nr_ambulances, g=self.g, pos_list=self.n_nodes, a_s=Ambulance.ActionSelection.selective, l_a=Ambulance.LearningApproach.QLearning) number_of_patients = round(nr_tiks / nr_tiks_per_pacient) self.populate_patients(nr_tiks, number_of_patients) # Step 2: let agents learn the positions where patients have more case and higher emergency self.populate_training_patients(self.n_training_patients) print("\nNumber of patients to be generated: " + str(self.n_training_patients)) print("\nLearning in progress...") print("\nThis might take a while...") for i in range(self.n_training_patients * 10): if self.patient_counter < self.n_training_patients and i == self.training_patient_generation_list[ self.patient_counter]: self.generate_patient((self.min_weight + self.max_weight) / 2, print_info=False) for a in self.ambulances: a.getLearningMetrics(self.g, self.patients, self.hospital) a.executeLearning() self.patients.clear() self.patient_counter = 0 for a in self.ambulances: a.set_exploitation() print("\nLearning completed\n\n") # Step 3: go through a series of iterations picked = 0 while (self.get_tik() < nr_tiks) or picked <= (number_of_patients - 1): print("\n TIK #" + str(self.get_tik())) if self.patient_counter < number_of_patients and self.get_tik( ) == self.patient_generation_list[self.patient_counter]: self.generate_patient((self.min_weight + self.max_weight) / 2) # 1) ambulances inform each other of their metrics metrics = [] for a in self.ambulances: metrics.append( a.send_metrics(self.g, self.patients, self.hospital)) # 2) ambulances decide which is the one executing for a in self.ambulances: a.collect_metrics_and_decide(metrics, self.patients, self.g, self.charging_stations) # 3) chosen ambulances execute for a in self.ambulances: o = a.execute(self.hospital.get_hospital_pos()) if o == "picked_up_success": self.success += 1 self.patients.remove(a.get_patient()) picked += 1 elif o == "picked_up_failed": self.failed += 1 self.patients.remove(a.get_patient()) picked += 1 self.increment_tik() graph_utils.draw_graph(self.g) print(self.patients) print("\n\nThe simulation ended with " + str(self.success) + " cases of success and " + str(self.failed) + " cases of failure\n")