def two_step_test(ind_obs, delaytype): """Estimate then determine the optimal toll pricing 1. Estimate the delay function 2. Compute the optimal toll pricing using the estimated latency function 3. Compute the real effect of the toll pricing on the true model """ # 1. Estimate error, theta = experiment(ind_obs, delaytype, display=True) # 2. Compute the optimal toll pricing using the estimated latency function tolls, tolls_collected, so_costs, costs, ue_costs = test_toll_pricing(theta, True, [1e-6]) # 3. Compute the real effect of the toll pricing on the true model tolls_collected2, so_costs2, costs2, ue_costs2 = [], [], [], [] if delaytype == 'Hyperbolic': g1, g2, g3, g4 = los_angeles((3.5, 3.0), 'Hyperbolic') if delaytype == 'Polynomial': g1, g2, g3, g4 = los_angeles(matrix([0.0, 0.0, 0.0, 0.15]), 'Polynomial') for toll, graph in zip(tolls, [g2,g3,g4]): Aeq, beq, ffdelays, pm, type = ue.get_data(graph) data = (Aeq, beq, ffdelays, pm, type) cost, x = tp.compute_cost(data, toll) costs2.append(cost) # tolled equilibrium tolls_collected2.append((toll.T*x)[0]) ue_costs2.append(tp.compute_cost(data)[0]) # ue equilibrium so_costs2.append(tp.compute_cost(data, 0.0, True)[0]) # so equilibrium print 'toll collected:', tolls_collected, tolls_collected2 print 'SO total travel time:', so_costs, so_costs2 print 'tolled total travel time:', costs, costs2 print 'UE total travel time:', ue_costs, ue_costs2
def experiment(indlinks_obs, delaytype, noise=0.0, display=False, soft=1000.0): """find parameters that minimizes the distance between x^obs_true in NOISY case and x^obs generated by each candidate function with PARTIAL observation Parameters ---------- indlinks_obs: indices of the observed links delaytype: type of the delay noise: std of the noise added to the measured link flows, ff delays, OD demands display: if True, display results soft: weight put on the observation """ if delaytype == 'Polynomial': true_theta = coef if delaytype == 'Hyperbolic': true_theta = (a,b) print 'generate graph...' g1, g2, g3, g4 = los_angeles(true_theta, delaytype) print 'compute ue...' l1, l2, l3, l4 = ue.solver(g1, update=True), ue.solver(g2, update=True), \ ue.solver(g3, update=True), ue.solver(g4, update=True) c1 = sum([link.delay*link.flow for link in g1.links.values()]) c2 = sum([link.delay*link.flow for link in g2.links.values()]) c3 = sum([link.delay*link.flow for link in g3.links.values()]) c4 = sum([link.delay*link.flow for link in g4.links.values()]) print 'ue costs: ', c1, c2, c3, c4 obs = [g1.indlinks[id] for id in indlinks_obs] obs = [int(i) for i in list(np.sort(obs))] x1,x2,x3,x4 = l1,l2,l3,l4 if noise > 0.0: x1, x2, x3, x4 = add_noise(l1,noise), add_noise(l2,noise), add_noise(l3,noise), add_noise(l4,noise) g1, g2, g3, g4 = los_angeles(true_theta, 'Polynomial', noise) theta, xs = invopt.main_solver([g1,g2,g3,g4], [x1[obs],x2[obs],x3[obs],x4[obs]], obs, degree, soft) u, v = matrix([l1,l2,l3,l4]), matrix(xs) error = np.linalg.norm(u-v, 1) / np.linalg.norm(u, 1) if display: display_results(error, true_theta, [theta], delaytype) return error, theta
def two_step_test(ind_obs, delaytype): """Estimate then determine the optimal toll pricing 1. Estimate the delay function 2. Compute the optimal toll pricing using the estimated latency function 3. Compute the real effect of the toll pricing on the true model """ # 1. Estimate error, theta = experiment(ind_obs, delaytype, display=True) # 2. Compute the optimal toll pricing using the estimated latency function tolls, tolls_collected, so_costs, costs, ue_costs = test_toll_pricing( theta, True, [1e-6]) # 3. Compute the real effect of the toll pricing on the true model tolls_collected2, so_costs2, costs2, ue_costs2 = [], [], [], [] if delaytype == 'Hyperbolic': g1, g2, g3, g4 = los_angeles((3.5, 3.0), 'Hyperbolic') if delaytype == 'Polynomial': g1, g2, g3, g4 = los_angeles(matrix([0.0, 0.0, 0.0, 0.15]), 'Polynomial') for toll, graph in zip(tolls, [g2, g3, g4]): Aeq, beq, ffdelays, pm, type = ue.get_data(graph) data = (Aeq, beq, ffdelays, pm, type) cost, x = tp.compute_cost(data, toll) costs2.append(cost) # tolled equilibrium tolls_collected2.append((toll.T * x)[0]) ue_costs2.append(tp.compute_cost(data)[0]) # ue equilibrium so_costs2.append(tp.compute_cost(data, 0.0, True)[0]) # so equilibrium print 'toll collected:', tolls_collected, tolls_collected2 print 'SO total travel time:', so_costs, so_costs2 print 'tolled total travel time:', costs, costs2 print 'UE total travel time:', ue_costs, ue_costs2
def experiment_estimation(indlinks_obs, delaytype, degree): """Demonstrate multi-objective optimization for structural estimation 1. Generate the graph of L.A. 2. Generate synthetic data in UE 3. Apply multi-objective solver Parameters ---------- indlinks_obs = indices of the observed links delaytype: type of the delay display: if True, display results """ if delaytype == 'Polynomial': true_theta = coef if delaytype == 'Hyperbolic': true_theta = (a, b) g1, g2, g3, g4 = los_angeles(true_theta, delaytype) x1, x2, x3, x4 = ue.solver(g1), ue.solver(g2), ue.solver(g3), ue.solver(g4) obs = [g1.indlinks[id] for id in indlinks_obs] obs = [int(i) for i in list(np.sort(obs))] w_multi = [0.001, .01, .1, .5, .9, .99, 0.999] # weight on the observation residual r_gap, r_obs, x_est, thetas = invopt.multi_objective_solver( [g1, g2, g3, g4], [x1[obs], x2[obs], x3[obs], x4[obs]], obs, degree, w_multi) print r_gap print r_obs u = matrix([x1, x2, x3, x4]) r_est = [np.linalg.norm(u - x, 1) / np.linalg.norm(u, 1) for x in x_est] print r_est display_results(r_est[4], true_theta, [thetas[4]], delaytype, w_multi[4])
def experiment_toll_pricing(ws_so, ws_toll): """Demonstrate multi-objective optimization for toll pricing model 1. Generate the graph of L.A. 2. Run multi-objective solver 3. Post-process results 4. Print results Parameters ---------- ws_so: list of weights for so objective ws_toll: list of weight for toll objective """ graph = los_angeles(coef, 'Polynomial')[3] r_gap, toll_est, loss_est, toll_res, loss_res, toll = tp.multi_objective_solver( graph, coef, ws_so, ws_toll) for i in range(len(ws_so)): for j in range(len(ws_toll)): if r_gap[i, j] < 0.0: r_gap[i, j] = 0.0 if toll_est[i, j] < 0.0: toll_est[i, j] = 0.0 if loss_est[i, j] < 0.0: loss_est[i, j] = 0.0 if toll_res[i, j] < 0.0: toll_res[i, j] = 0.0 if loss_res[i, j] < 0.0: loss_res[i, j] = 0.0 print r_gap print toll_est print loss_est print toll_res print loss_res
def experiment_estimation(indlinks_obs, delaytype, degree): """Demonstrate multi-objective optimization for structural estimation 1. Generate the graph of L.A. 2. Generate synthetic data in UE 3. Apply multi-objective solver Parameters ---------- indlinks_obs = indices of the observed links delaytype: type of the delay display: if True, display results """ if delaytype == 'Polynomial': true_theta = coef if delaytype == 'Hyperbolic': true_theta = (a,b) g1, g2, g3, g4 = los_angeles(true_theta, delaytype) x1, x2, x3, x4 = ue.solver(g1), ue.solver(g2), ue.solver(g3), ue.solver(g4) obs = [g1.indlinks[id] for id in indlinks_obs] obs = [int(i) for i in list(np.sort(obs))] w_multi = [0.001, .01, .1, .5, .9, .99, 0.999] # weight on the observation residual r_gap, r_obs, x_est, thetas = invopt.multi_objective_solver([g1,g2,g3,g4], [x1[obs],x2[obs],x3[obs],x4[obs]], obs, degree, w_multi) print r_gap print r_obs u = matrix([x1,x2,x3,x4]) r_est = [np.linalg.norm(u-x, 1) / np.linalg.norm(u, 1) for x in x_est] print r_est display_results(r_est[4], true_theta, [thetas[4]], delaytype, w_multi[4])
def test_toll_pricing(theta, display=False, ws=[1e-8, 1e-6, 1e-4]): """Test the toll pricing model 1. compute optimal toll 2. compute tolled_ue, ue, so total travel times 3. display results """ g1, g2, g3, g4 = los_angeles(theta, 'Polynomial') tolls, tolls_collected, costs, ue_costs, so_costs, weights = [], [], [], [], [], [] for graph in [g2,g3,g4]: ffdelays, slopes = graph.get_ffdelays(), graph.get_slopes() Aeq, beq = ue.constraints(graph) pm = invopt.compute_coefs(ffdelays, slopes, theta) data = (Aeq, beq, ffdelays, pm, 'Polynomial') toll, cost, toll_collected, weight = tp.main_solver(graph, theta, ws) tolls.append(toll) tolls_collected.append(toll_collected) weights.append(weight) costs.append(tp.compute_cost(data, toll)[0]) # tolled equilibrium ue_costs.append(tp.compute_cost(data)[0]) # ue equilibrium so_costs.append(tp.compute_cost(data, 0.0, True)[0]) # so equilibrium if display: print 'toll collected:', tolls_collected print 'SO total travel time:', so_costs print 'tolled total travel time:', costs print 'UE total travel time:', ue_costs print 'weight:', weights return tolls, tolls_collected, so_costs, costs, ue_costs
def test_toll_pricing(theta, display=False, ws=[1e-8, 1e-6, 1e-4]): """Test the toll pricing model 1. compute optimal toll 2. compute tolled_ue, ue, so total travel times 3. display results """ g1, g2, g3, g4 = los_angeles(theta, 'Polynomial') tolls, tolls_collected, costs, ue_costs, so_costs, weights = [], [], [], [], [], [] for graph in [g2, g3, g4]: ffdelays, slopes = graph.get_ffdelays(), graph.get_slopes() Aeq, beq = ue.constraints(graph) pm = invopt.compute_coefs(ffdelays, slopes, theta) data = (Aeq, beq, ffdelays, pm, 'Polynomial') toll, cost, toll_collected, weight = tp.main_solver(graph, theta, ws) tolls.append(toll) tolls_collected.append(toll_collected) weights.append(weight) costs.append(tp.compute_cost(data, toll)[0]) # tolled equilibrium ue_costs.append(tp.compute_cost(data)[0]) # ue equilibrium so_costs.append(tp.compute_cost(data, 0.0, True)[0]) # so equilibrium if display: print 'toll collected:', tolls_collected print 'SO total travel time:', so_costs print 'tolled total travel time:', costs print 'UE total travel time:', ue_costs print 'weight:', weights return tolls, tolls_collected, so_costs, costs, ue_costs
def experiment_toll_pricing(ws_so, ws_toll): """Demonstrate multi-objective optimization for toll pricing model 1. Generate the graph of L.A. 2. Run multi-objective solver 3. Post-process results 4. Print results Parameters ---------- ws_so: list of weights for so objective ws_toll: list of weight for toll objective """ graph = los_angeles(coef, 'Polynomial')[3] r_gap, toll_est, loss_est, toll_res, loss_res, toll = tp.multi_objective_solver(graph, coef, ws_so, ws_toll) for i in range(len(ws_so)): for j in range(len(ws_toll)): if r_gap[i,j] < 0.0: r_gap[i,j]=0.0 if toll_est[i,j] < 0.0: toll_est[i,j]=0.0 if loss_est[i,j] < 0.0: loss_est[i,j]=0.0 if toll_res[i,j] < 0.0: toll_res[i,j]=0.0 if loss_res[i,j] < 0.0: loss_res[i,j]=0.0 print r_gap print toll_est print loss_est print toll_res print loss_res
def generate_wp(demand=3, data=None, draw=False, voronoi=False, path=None): """Generate waypoints following the map of L.A. and draw the map Parameters: ---------- demand: OD demand data: (N0, N1, scale, regions, res, margin) N0: number of background samples N1: number of samples on links regions: list of regions, regions[k] = (geometry, N_region) res: (n1, n2) s.t. the width is divided into n1 cells and the height into n2 cells margin: margin around each cell draw: if True, draw graph and Voronoi voronoi: if voronoi = draw voronoi cells Return value: ------------ graph: Graph of L.A. WP: waypoint object with waypoints following the map of L.A. """ if data is None: N0, N1, scale, regions, res, margin = 20, 40, 0.2, [ ((3.5, 0.5, 6.5, 3.0), 20) ], (12, 6), 2.0 else: N0, N1, scale, regions, res, margin = data graph = los_angeles(theta, 'Polynomial', path=path)[demand] WP = w.sample_waypoints(graph, N0, N1, scale, regions) WP.build_partition(res, margin) if draw: WP.draw_waypoints(graph, voronoi=voronoi) return graph, WP
def test1(): g = los_angeles()[0] print g.links.values()[23].delay sink = 20 sources = [od[0] for od in g.ODs.keys() if od[1]==sink] As = sh.mainKSP(g, sources, sink, 10) for s in sources: print len(As[s]), As[s]
def main(): theta = matrix([0.0, 0.0, 0.0, 0.15, 0.0, 0.0]) graph = los_angeles()[3] ind_obs = {} ind_obs[0] = graph.indlinks.keys() ind_obs[1] = [(36,37,1), (13,14,1), (17,8,1), (24,17,1), (28,22,1), (14,13,1), (17,24,1), (24,40,1), (14,21,1), (16,23,1)] ind_obs[2] = [(17,24,1), (24,40,1), (14,21,1), (16,23,1)] ind_obs[3] = [(10,9,1), (19,18,1), (4,5,1), (29,21,1)] test_toll_pricing(theta, True)
def main(): theta = matrix([0.0, 0.0, 0.0, 0.15, 0.0, 0.0]) graph = los_angeles()[3] ind_obs = {} ind_obs[0] = graph.indlinks.keys() ind_obs[1] = [(36, 37, 1), (13, 14, 1), (17, 8, 1), (24, 17, 1), (28, 22, 1), (14, 13, 1), (17, 24, 1), (24, 40, 1), (14, 21, 1), (16, 23, 1)] ind_obs[2] = [(17, 24, 1), (24, 40, 1), (14, 21, 1), (16, 23, 1)] ind_obs[3] = [(10, 9, 1), (19, 18, 1), (4, 5, 1), (29, 21, 1)] test_toll_pricing(theta, True)
def draw_tolls(): """Draw tolls""" graph = los_angeles(coef, 'Polynomial')[3] w_so = [1e2] w_toll =[1e-2] r_gap, toll_est, loss_est, toll_res, loss_res, toll = tp.multi_objective_solver(graph, coef, w_so, w_toll) print toll print r_gap print toll_est print loss_est print toll_res print loss_res
def get_paths(SO, K, demand, return_paths=True, ffdelays=False, path=None, save_data=False, savepath=None): """This experiment does the following tests: 1. compute the UE/SO link flows using node-link formulation 2. get the link delays for the UE/SO link flow 3. find the K-shortest paths for these delays/marginal delays (used ones under UE/SO) 4. add these paths to the network 5. compute the UE/SO path flows using link-path formulation 6. check if we get the same UE/SO link flow Parameters: ----------- SO: if False, compute the UE, if True, compute the SO K: number of shortest paths demand: choice of OD demand return_paths: if True, return paths ffdelays: if True the k-shortest paths are obtained from ff delays Return value: ------------ """ print 'generate graph with demand', demand g = los_angeles(theta, 'Polynomial', path=path)[demand] if ffdelays: paths = get_shortest_paths(g, K) print 'compute UE' l1 = ue.solver(g, update=True, SO=SO) d1 = sum([link.delay*link.flow for link in g.links.values()]) if SO: for link in g.links.values(): link.delay = link.ffdelay*(1+0.75*(link.flow*link.delayfunc.slope)**4) print 'get {} shortest paths'.format(K) if not ffdelays: paths = get_shortest_paths(g, K) if return_paths: return paths for p in paths: g.add_path_from_nodes(p) g.visualize(general=True) print 'Generate link-path incidence matrix' P = path_solver.linkpath_incidence(g) x_true = path_solver.solver(g, update=True, SO=SO)[0] l2 = P*x_true d2 = sum([p.delay*p.flow for p in g.paths.values()]) if save_data: U, f = path_solver.path_to_OD_simplex(g) if savepath is None: savepath = 'data.pkl' data = {} data['U'] = np.array(matrix(U)) data['f'] = np.array(f).flatten() data['A'] = np.array(matrix(P)) data['b'] = np.array(l2).flatten() data['x_true'] = np.array(x_true).flatten() pickle.dump( data, open(savepath, "wb" ) ) #for i in range(P2.shape[0]): # print np.sum(P2[i,:]) return d1,d2,paths
def draw_tolls(): """Draw tolls""" graph = los_angeles(coef, 'Polynomial')[3] w_so = [1e2] w_toll = [1e-2] r_gap, toll_est, loss_est, toll_res, loss_res, toll = tp.multi_objective_solver( graph, coef, w_so, w_toll) print toll print r_gap print toll_est print loss_est print toll_res print loss_res
def experiment(indlinks_obs, delaytype, noise=0.0, display=False, soft=1000.0): """find parameters that minimizes the distance between x^obs_true in NOISY case and x^obs generated by each candidate function with PARTIAL observation Parameters ---------- indlinks_obs: indices of the observed links delaytype: type of the delay noise: std of the noise added to the measured link flows, ff delays, OD demands display: if True, display results soft: weight put on the observation """ if delaytype == 'Polynomial': true_theta = coef if delaytype == 'Hyperbolic': true_theta = (a, b) print 'generate graph...' g1, g2, g3, g4 = los_angeles(true_theta, delaytype) print 'compute ue...' l1, l2, l3, l4 = ue.solver(g1, update=True), ue.solver(g2, update=True), \ ue.solver(g3, update=True), ue.solver(g4, update=True) c1 = sum([link.delay * link.flow for link in g1.links.values()]) c2 = sum([link.delay * link.flow for link in g2.links.values()]) c3 = sum([link.delay * link.flow for link in g3.links.values()]) c4 = sum([link.delay * link.flow for link in g4.links.values()]) print 'ue costs: ', c1, c2, c3, c4 obs = [g1.indlinks[id] for id in indlinks_obs] obs = [int(i) for i in list(np.sort(obs))] x1, x2, x3, x4 = l1, l2, l3, l4 if noise > 0.0: x1, x2, x3, x4 = add_noise(l1, noise), add_noise(l2, noise), add_noise( l3, noise), add_noise(l4, noise) g1, g2, g3, g4 = los_angeles(true_theta, 'Polynomial', noise) theta, xs = invopt.main_solver([g1, g2, g3, g4], [x1[obs], x2[obs], x3[obs], x4[obs]], obs, degree, soft) u, v = matrix([l1, l2, l3, l4]), matrix(xs) error = np.linalg.norm(u - v, 1) / np.linalg.norm(u, 1) if display: display_results(error, true_theta, [theta], delaytype) return error, theta
def test_helper(demand, paths): g = los_angeles(theta, 'Polynomial')[demand] for p in paths: g.add_path_from_nodes(p) P = path_solver.linkpath_incidence(g) g.visualize(general=True) l1 = ue.solver(g, update=True) d1 = sum([link.delay*link.flow for link in g.links.values()]) l2 = P*path_solver.solver(g, update=True) d2 = sum([p.delay*p.flow for p in g.paths.values()]) l3 = ue.solver(g, update=True, SO=True) d3 = sum([link.delay*link.flow for link in g.links.values()]) l4 = P*path_solver.solver(g, update=True, SO=True) d4 = sum([p.delay*p.flow for p in g.paths.values()]) return l1,l2,l3,l4,d1,d2,d3,d4
def draw_los_angeles(): graph = los_angeles()[0] link_ids = {} link_ids[0] = graph.indlinks.keys() link_ids[1] = [(36,37,1), (13,14,1), (17,8,1), (24,17,1), (28,22,1), (14,13,1), (17,24,1), (24,40,1), (14,21,1), (16,23,1)] link_ids[2] = [(17,24,1), (24,40,1), (14,21,1), (16,23,1)] link_ids[3] = [(10,9,1), (19,18,1), (4,5,1), (29,21,1)] #d.draw(graph) #d.draw(graph, nodes=False) #print graph.indlinks #for k in range(4): d.draw(graph, link_ids[k], nodes=False) #d.draw_ODs(graph, 22) # link ids for CDC 2015: [65, 86, 87, 88, 99] #link_ids = [(6, 5, 1), (36, 16, 1), (23, 22, 1), (16, 15, 1), (17, 36, 1)] link_ids = [(43,24,1), (24,37,1), (37,23,1), (23,22,1), (42,17,1), (17,36,1), (36,16,1), (16,15,1), (9,41,1), (41,8,1), (8,35,1), (35,7,1)] for id in link_ids: print graph.indlinks[id] d.draw(graph, link_ids, nodes=False)
def test2(delaytype): if delaytype == 'Polynomial': theta = matrix([0.0, 0.0, 0.0, 0.15, 0.0, 0.0]) if delaytype == 'Hyperbolic': theta = (3.5, 3.0) g = los_angeles(theta, delaytype)[3] n = g.numlinks l, x = ue.solver(g, update=True, full=True) d.draw_delays(g, x[:n]) d.draw_delays(g, x[n:2*n]) d.draw_delays(g, x[2*n:]) #print l print max(mul(l,g.get_slopes())) print 'cost UE:', sum([link.delay*link.flow for link in g.links.values()]) l2, x2 = ue.solver(g, update=True, full=True, SO=True) d.draw_delays(g, x2[:n]) d.draw_delays(g, x2[n:2*n]) d.draw_delays(g, x2[2*n:]) #print l2 print max(mul(l2,g.get_slopes())) print 'cost SO:', sum([link.delay*link.flow for link in g.links.values()])
def test_feasible_pathflows(SO, demand, random=False): """Test function feasible_pathflows""" paths = find_UESOpaths(SO) g = los_angeles(theta, 'Polynomial')[demand] l1 = ue.solver(g, update=True, SO=SO) d1 = sum([link.delay*link.flow for link in g.links.values()]) for p in paths: g.add_path_from_nodes(p) g.visualize(general=True) P = linkpath_incidence(g) l2 = P*path_solver.solver(g, update=True, SO=SO, random=random) d2 = sum([p.delay*p.flow for p in g.paths.values()]) ind_obs, ls, ds = {}, [], [] ind_obs[0] = g.indlinks.keys() ind_obs[1] = [(36,37,1), (13,14,1), (17,8,1), (24,17,1), (28,22,1), (14,13,1), (17,24,1), (24,40,1), (14,21,1), (16,23,1)] ind_obs[2] = [(17,24,1), (24,40,1), (14,21,1), (16,23,1)] for i in range(len(ind_obs)): obs = [g.indlinks[id] for id in ind_obs[i]] obs = [int(i) for i in list(np.sort(obs))] ls.append(P*path_solver.feasible_pathflows(g, l1[obs], obs, True)) ds.append(sum([p.delay*p.flow for p in g.paths.values()])) print d1,d2,ds print np.linalg.norm(l1-l2), [np.linalg.norm(l1-ls[i]) for i in range(len(ind_obs))]
def find_UESOpaths(SO, return_paths=True, random=False, path=None): """ 1. take the union for all optimum shortest paths for UE/SO 2. compute UE/SO using node-link and link-path formulation for all demands 3. compare results Parameters: ----------- SO: if False, compute the UE, if True, compute the SO return_paths: if True, do only step 1 and return paths, if False, do steps 2 and 3 """ paths, ls, ds, ps = [], [], [], [] if SO: K = [0,0,0,10] #[2, 2, 4, 7] else: K = [0,0,0,5] #[2, 2, 2, 3] [5,5,5,5] for i in range(4): tmp = get_paths(SO, K[i], i, path=path) for p in tmp: if p not in paths: paths.append(p) if return_paths: return paths for i in range(4): g = los_angeles(theta, 'Polynomial')[i] for p in paths: g.add_path_from_nodes(p) P = linkpath_incidence(g) g.visualize(general=True) l1 = ue.solver(g, update=True, SO=SO) d1 = sum([link.delay*link.flow for link in g.links.values()]) p_flows = path_solver.solver(g, update=True, SO=SO, random=random) l2 = P*p_flows d2 = sum([p.delay*p.flow for p in g.paths.values()]) ls.append([l1,l2]) ds.append([d1,d2]) ps.append(p_flows) for i in range(4): print np.linalg.norm(ls[i][0] - ls[i][1]) print ds[i][0], ds[i][1] print len(paths)
''' import numpy as np import ue_solver as ue import inverse_opt as invopt from generate_graph import los_angeles import matplotlib.pyplot as plt from cvxopt import matrix import toll_pricing as tp from inverse_opt_test import display_results a, b = 3.5, 3.0 coef = matrix([0.0, 0.0, 0.0, 0.15, 0.0, 0.0]) graph = los_angeles(coef, 'Polynomial')[0] def experiment_estimation(indlinks_obs, delaytype, degree): """Demonstrate multi-objective optimization for structural estimation 1. Generate the graph of L.A. 2. Generate synthetic data in UE 3. Apply multi-objective solver Parameters ---------- indlinks_obs = indices of the observed links delaytype: type of the delay display: if True, display results """ if delaytype == 'Polynomial': true_theta = coef
Experiments for ECC 2015 ''' import numpy as np import ue_solver as ue import inverse_opt as invopt from generate_graph import los_angeles import matplotlib.pyplot as plt from cvxopt import matrix import toll_pricing as tp from inverse_opt_test import display_results a, b = 3.5, 3.0 coef = matrix([0.0, 0.0, 0.0, 0.15, 0.0, 0.0]) graph = los_angeles(coef, 'Polynomial')[0] def experiment_estimation(indlinks_obs, delaytype, degree): """Demonstrate multi-objective optimization for structural estimation 1. Generate the graph of L.A. 2. Generate synthetic data in UE 3. Apply multi-objective solver Parameters ---------- indlinks_obs = indices of the observed links delaytype: type of the delay display: if True, display results """ if delaytype == 'Polynomial': true_theta = coef