def create_scenario_from_sndlib_instance(sndlib_instance_name): model, graph = parse_problem( "./input/sndlib/problems/model.xml", "./input/sndlib/instances-xml/{0}/{0}.xml".format( sndlib_instance_name)) substrate = sub_pkg.Substrate(sndlib_instance_name) node_coordinates = {} for node in graph.nodes(): substrate.add_node(node) node_coordinates[node] = graph.node[node]["position"] for edge in graph.edges(): u, v = edge long_u, lat_u = node_coordinates[u] long_v, lat_v = node_coordinates[v] edge_costs = None print(graph.graph["coordinatesType"]) if graph.graph["coordinatesType"] == "pixel": edge_costs = euclid_distance(long_u, lat_u, long_v, lat_v) elif graph.graph["coordinatesType"] == "geographical": edge_costs = sub_reader_pkg.haversine(long_u, lat_u, long_v, lat_v) else: raise Exception("Unknown!") print("costs {} for |({},{})-({},{})|".format(edge_costs, long_u, lat_u, long_v, lat_v)) substrate.add_edge(u, v, cost=edge_costs) substrate.add_edge(v, u, cost=edge_costs) cum_demand = 0 requests = [] for demand in graph.graph["demands"]: id, source, target, demand, _ = demand print("{} {} {} {}".format(id, source, target, demand)) requests.append( req_pkg.Request(source, target, capacity=demand, max_deviation=0.0)) cum_demand += demand mbs = {} for node in substrate.get_nodes(): mbs[node] = 4 * cum_demand / len(graph.nodes()) scen = scen_pkg.Scenario(sndlib_instance_name + "_prototype", substrate, requests, mbs) return scen
def try_algorithms(): import os filename = "sndlib.cpickle" scen = None if os.path.exists(filename): with open(filename) as f: scen = pickle.loads(f.read()) else: scen = create_scenario_from_sndlib_instance("nobel-eu") with open(filename, "w") as f: f.write(pickle.dumps(scen)) #mc = mip_pkg.ExactDeploymentMIP_diff_weights(scen, mip_gap=0.001) #mc.run() for dev in [i / 10 for i in range(20)]: for repetition in range(25): print("\n\n\n\n\nSTARTING \tdev: {}\trep: {}\n\n\n\n\n".format( dev, repetition)) requests = [] for request in scen.requests: if random.random() < 0.5: requests.append(request) request.max_deviation = dev demand = sum([request.capacity for request in requests]) middleboxes = dict(scen.middleboxes) for mb in middleboxes.keys(): middleboxes[mb] = 4 * demand / len(scen.middleboxes.keys()) scenario = scen_pkg.Scenario(id=scen.id, substrate=scen.substrate, requests=requests, middleboxes=middleboxes) alg = greedy_diff_weights_pkg.Greedy_diff_weights(scenario) result = alg.run() mip = mip_pkg.ExactDeploymentMIP_diff_weights(scenario=scenario) result_mip = mip.run() if len(result.active_mbs) > len(result_mip.active_mbs): raise Exception("More costly solution found!")
def construct_scenarios(self, test_scenarios_a_priori=True): counter = 0 print(self.probability_for_pair) print(self.capacity_factor) print(self.suitable_substrates) print(self.number_of_repetitions) print(self.max_deviation) for prob, cap_factor, substrate_name, repetition in itertools.product( self.probability_for_pair, self.capacity_factor, self.suitable_substrates.names, range(self.number_of_repetitions)): #print self.substrate_filter if self.substrate_filter is not None and substrate_name not in self.substrate_filter: continue substrate = self.suitable_substrates.substrates[substrate_name] while True: #print substrate_name pairs = [] handled_nodes = [] for u in substrate.nodes: handled_nodes.append(u) for v in substrate.nodes: if v in handled_nodes: continue if random.random() <= prob: pairs.append((u, v)) #req = req_pkg.Request(u, v, random.uniform(md_lb, md_ub), capacity=1) #requests.append(req) successful_generation = False for deviation in self.max_deviation: if counter > 0 and counter % 100 == 0: if self.substrate_filter is not None: print( f"Having created {counter} of {len(self.max_deviation) * len(self.capacity_factor) * len(self.probability_for_pair)*len(self.substrate_filter)*self.number_of_repetitions} many scenarios" ) else: print( f"Having created {counter} of {len(self.max_deviation) * len(self.capacity_factor) * len(self.probability_for_pair)*len(self.suitable_substrates.names)*self.number_of_repetitions} many scenarios" ) number_of_nodes = substrate.get_number_of_nodes() capacity = math.ceil((number_of_nodes - 1) * 2 * prob + (number_of_nodes * number_of_nodes - 2 * number_of_nodes - 1) / 2 * prob * cap_factor) requests = [] md_lb, md_ub = deviation, deviation for (u, v) in pairs: req = req_pkg.Request(u, v, random.uniform(md_lb, md_ub), capacity=1) requests.append(req) middleboxes = {} for u in substrate.nodes: middleboxes[u] = capacity scenario = scen_pkg.Scenario(counter, substrate, requests, middleboxes) if deviation == self.max_deviation[0]: mip = std_mip_pkg.ExactDeploymentMIP(scenario) result = mip.run() if result is not None: successful_generation = True self.scenario_keys.append((prob, deviation, cap_factor, substrate_name, repetition)) self.scenarios[(prob, deviation, cap_factor, substrate_name, repetition)] = scenario counter += 1 if successful_generation: break
def construct_scenarios(self, test_scenarios_a_priori=True): counter = 0 print(self.probability_for_pair) print(self.capacity_factor) print(self.number_of_repetitions) print(self.max_deviation) prototypical_scenarios = {} for substrate_name in self.substrate_filter: scenario = sndlib_pkg.create_scenario_from_sndlib_instance(substrate_name) prototypical_scenarios[substrate_name] = scenario for prob, cap_factor, substrate_name, repetition in itertools.product(self.probability_for_pair, self.capacity_factor, self.substrate_filter, range(self.number_of_repetitions)): prototypical_scenario = prototypical_scenarios[substrate_name] substrate = prototypical_scenario.substrate print(f"\n\n\n\n\nstarting to generate {prob} {cap_factor} {substrate_name} {repetition}\n\n\n\n\n") while True: #print substrate_name pairs = [] handled_nodes = [] for req in prototypical_scenario.requests: if random.random() <= prob: pairs.append((req.tail, req.head, req.capacity)) print(pairs) successful_generation = False for deviation in self.max_deviation: if counter > 0 and counter % 100 == 0: if self.substrate_filter is not None: print(f"Having created {counter} of {len(self.max_deviation) * len(self.capacity_factor) * len(self.probability_for_pair)*len(self.substrate_filter)*self.number_of_repetitions} many scenarios") else: print(f"Having created {counter} of {len(self.max_deviation) * len(self.capacity_factor) * len(self.probability_for_pair)*len(self.suitable_substrates.names)*self.number_of_repetitions} many scenarios") number_of_nodes = substrate.get_number_of_nodes() requests = [] cum_capacity = 0.0 md_lb, md_ub = deviation, deviation for (u,v, cap) in pairs: req = req_pkg.Request(u, v, random.uniform(md_lb, md_ub), capacity=cap) requests.append(req) cum_capacity += cap capacity = 4 * cum_capacity / number_of_nodes middleboxes = {} for u in substrate.nodes: middleboxes[u] = capacity scenario = scen_pkg.Scenario(counter, substrate, requests, middleboxes) #util_pkg.prettyPrint(scenario) if deviation == self.max_deviation[0]: mip = mip_pkg.ExactDeploymentMIP_diff_weights(scenario, mip_gap=1.0) result = mip.run() if result is not None: successful_generation = True else: break self.scenario_keys.append((prob, deviation, cap_factor, substrate_name, repetition)) self.scenarios[(prob,deviation,cap_factor,substrate_name,repetition)] = scenario counter += 1 if successful_generation: break