def I210_metrics(alphas):
    out = np.zeros((len(alphas), 6))
    net, d, node, features = load_I210_modified()
    d[:, 2] = d[:, 2] / 4000.
    net2, small_capacity = multiply_cognitive_cost(net, features, 3000., 100.)
    save_metrics(alphas, net, net2, d, features, small_capacity, \
        'data/I210_modified/test_{}.csv', 'data/I210_modified/out.csv', skiprows=1)
def I210_parametric_study(alphas):
    # load the network and its properties
    g_r, d, node, feat = load_I210_modified()
    # modify the costs on non routed network
    g_nr, small_capacity = multiply_cognitive_cost(g_r, feat, 3000., 100.)
    #divide the demand by 4000 to computationally optimize
    d[:,2] = d[:,2] / 4000.

    for alpha in alphas:
        if alpha == 0.0:
            print 'non-routed = 1.0, routed = 0.0'
            f_nr = solver_3(g_nr, d, max_iter=1000, stop=1e-3)     
            fs=np.zeros((f_nr.shape[0],2))
            fs[:,0]=f_nr 
        elif alpha == 1.0:
            print 'non-routed = 0.0, routed = 1.0'
            f_r = solver_3(g_r, d, max_iter=1000, stop=1e-3)    
            fs=np.zeros((f_r.shape[0],2))
            fs[:,1]=f_r            
        else:
            print 'non-routed = {}, routed = {}'.format(1-alpha, alpha)
            d_nr, d_r = heterogeneous_demand(d, alpha)
            fs = gauss_seidel([g_nr,g_r], [d_nr,d_r], solver_3, max_iter=1000, \
                stop=1e-3, stop_cycle=1e-3, q=50, past=20)
        np.savetxt('data/I210_modified/test_{}.csv'.format(int(alpha*100)), fs, \
            delimiter=',', header='f_nr,f_r')
def I210_parametric_study(alphas):
    # load the network and its properties
    g_r, d, node, feat = load_I210_modified()
    # modify the costs on non routed network
    g_nr, small_capacity = multiply_cognitive_cost(g_r, feat, 3000., 100.)
    #divide the demand by 4000 to computationally optimize
    d[:, 2] = d[:, 2] / 4000.

    for alpha in alphas:
        if alpha == 0.0:
            print 'non-routed = 1.0, routed = 0.0'
            f_nr = solver_3(g_nr, d, max_iter=1000, stop=1e-3)
            fs = np.zeros((f_nr.shape[0], 2))
            fs[:, 0] = f_nr
        elif alpha == 1.0:
            print 'non-routed = 0.0, routed = 1.0'
            f_r = solver_3(g_r, d, max_iter=1000, stop=1e-3)
            fs = np.zeros((f_r.shape[0], 2))
            fs[:, 1] = f_r
        else:
            print 'non-routed = {}, routed = {}'.format(1 - alpha, alpha)
            d_nr, d_r = heterogeneous_demand(d, alpha)
            fs = gauss_seidel([g_nr,g_r], [d_nr,d_r], solver_3, max_iter=1000, \
                stop=1e-3, stop_cycle=1e-3, q=50, past=20)
        np.savetxt('data/I210_modified/test_{}.csv'.format(int(alpha*100)), fs, \
            delimiter=',', header='f_nr,f_r')
def I210_metrics(alphas):
    out = np.zeros((len(alphas),6))
    net, d, node, features = load_I210_modified()
    d[:,2] = d[:,2] / 4000. 
    net2, small_capacity = multiply_cognitive_cost(net, features, 3000., 100.)
    save_metrics(alphas, net, net2, d, features, small_capacity, \
        'data/I210_modified/test_{}.csv', 'data/I210_modified/out.csv', skiprows=1)
Example #5
0
def I210_metrics(alphas):
    net, d, node, features = load_I210()
    d[:, 2] = d[:, 2] / 4000.
    net2, small_capacity = multiply_cognitive_cost(net, features, 3000., 100.)
    save_metrics(alphas, net, net2, d, features, small_capacity,
                 'data/I210_attack/test_{}.csv', 'data/I210_attack/out.csv',
                 skiprows=1)
def parametric_study(alphas, g, d, node, geometry, thres, cog_cost, output, \
    stop=1e-2, stop_cycle=1e-2):
    g_nr, small_capacity = multiply_cognitive_cost(g, geometry, thres, cog_cost)
    if (type(alphas) is float) or (type(alphas) is int):
        alphas = [alphas]
    for alpha in alphas:
        #special case where in fact homogeneous game
        if alpha == 0.0:
            print 'non-routed = 1.0, routed = 0.0'
            f_nr = solver_3(g_nr, d, max_iter=1000, display=1, stop=stop)     
            fs=np.zeros((f_nr.shape[0],2))
            fs[:,0]=f_nr 
        elif alpha == 1.0:
            print 'non-routed = 0.0, routed = 1.0'
            f_r = solver_3(g, d, max_iter=1000, display=1, stop=stop)    
            fs=np.zeros((f_r.shape[0],2))
            fs[:,1]=f_r            
        #run solver
        else:
            print 'non-routed = {}, routed = {}'.format(1-alpha, alpha)
            d_nr, d_r = heterogeneous_demand(d, alpha)
            fs = gauss_seidel([g_nr,g], [d_nr,d_r], solver_3, max_iter=1000, \
                display=1, stop=stop, stop_cycle=stop_cycle, q=50, past=20)
        np.savetxt(output.format(int(alpha*100)), fs, \
            delimiter=',', header='f_nr,f_r')
def LA_metrics(alphas, input, output):
    net, d, node, features = load_LA_2()
    d[:,2] = d[:,2] / 4000.
    net2, small_capacity = multiply_cognitive_cost(net, features, 1000., 3000.)
    save_metrics(alphas, net, net2, d, features, small_capacity, input, \
        output, skiprows=1, \
        length_unit='Meter', time_unit='Second')
def LA_local_non_routed_costs(alphas, input, output):
    net, demand, node, features = load_LA_3()
    net2, small_capacity = multiply_cognitive_cost(net, features, 1000., 3000.)
    net_local = np.copy(net)
    for row in range(net.shape[0]):
        if small_capacity[row] == 0.0:
            net_local[row,3:] = net_local[row,3:] * 0.
    OD_non_routed_costs(alphas, net_local, net2, demand, input, output, verbose=1)
def LA_metrics(alphas, input, output):
    net, d, node, features = load_LA_3()
    # import pdb; pdb.set_trace()
    d[:, 2] = d[:, 2] / 4000.
    net2, small_capacity = multiply_cognitive_cost(net, features, 1000., 3000.)
    save_metrics(alphas, net, net2, d, features, small_capacity, input, \
        output, skiprows=1, \
        length_unit='Meter', time_unit='Second')
def LA_metrics_attack(alphas, input, output, beta):
    net, d, node, features = load_LA_4()
    # import pdb; pdb.set_trace()
    d[:,2] = d[:,2] / 4000.
    net2, small_capacity = multiply_cognitive_cost(net, features,beta, 1000., 3000.)
    save_metrics(alphas, net, net2, d, features, small_capacity, input, \
        output, skiprows=1, \
        length_unit='Meter', time_unit='Second')
def LA_ue_K(factors, thres, cog_cost, output):
    '''
    parametric study for computing equilibrium flows with different demand factors
    and cognitive cost
    '''
    net, demand, node, geom = load_LA_3()
    demand[:,2] = demand[:,2] / 4000.
    net2, small_capacity = multiply_cognitive_cost(net, geom, thres, cog_cost)
    single_class_parametric_study(factors, output, net2, demand)
def LA_ue_K(factors, thres, cog_cost, output):
    '''
    parametric study for computing equilibrium flows with different demand factors
    and cognitive cost
    '''
    net, demand, node, geom = load_LA_3()
    demand[:, 2] = demand[:, 2] / 4000.
    net2, small_capacity = multiply_cognitive_cost(net, geom, thres, cog_cost)
    single_class_parametric_study(factors, output, net2, demand)
Example #13
0
def chicago_metrics(alphas):
    '''
    study the test_*.csv files generated by chicago_parametric_study()
    in particular, display the average costs for each type of users
    '''
    net, d, node, features = load_chicago()
    d[:,2] = d[:,2] / 2000. # technically, it's 2*demand/4000
    net2, small_capacity = multiply_cognitive_cost(net, features, 2000., 1000.)
    save_metrics(alphas, net, net2, d, features, small_capacity, \
        'data/chicago/test_{}.csv', 'data/chicago/out.csv', skiprows=1)
def chicago_metrics(alphas):
    """
    study the test_*.csv files generated by chicago_parametric_study()
    in particular, display the average costs for each type of users
    """
    net, d, node, features = load_chicago()
    d[:, 2] = d[:, 2] / 2000.0  # technically, it's 2*demand/4000
    net2, small_capacity = multiply_cognitive_cost(net, features, 2000.0, 1000.0)
    save_metrics(
        alphas, net, net2, d, features, small_capacity, "data/chicago/test_{}.csv", "data/chicago/out.csv", skiprows=1
    )
def LA_OD_free_flow_costs(thres, cog_costs, output, verbose=0):
    '''
    computes OD costs (free-flow travel times) for non-routed users
    under different levels of cognitive costs for links with capacity under thres
    '''
    net, demand, node, geom = load_LA_3()
    costs = []
    for K in cog_costs:
        net2, small_capacity = multiply_cognitive_cost(net, geom, thres, K)
        costs.append(net2[:,3])
    free_flow_OD_costs(net, costs, demand, output, verbose)
def LA_OD_free_flow_costs(thres, cog_costs, output, verbose=0):
    '''
    computes OD costs (free-flow travel times) for non-routed users
    under different levels of cognitive costs for links with capacity under thres
    '''
    net, demand, node, geom = load_LA_3()
    costs = []
    for K in cog_costs:
        net2, small_capacity = multiply_cognitive_cost(net, geom, thres, K)
        costs.append(net2[:, 3])
    free_flow_OD_costs(net, costs, demand, output, verbose)
def LA_free_flow_costs(thres, cog_costs):
    '''
    study aiming at comparing the OD costs of all-or-nothing assignment
    between costs = travel times, and costs with multiplicative cognitive costs
    '''
    net, demand, node, geom = load_LA_2()
    g = construct_igraph(net)
    g2 = construct_igraph(net)
    od = construct_od(demand)
    print np.array(g.es["weight"]).dot(all_or_nothing(g, od))/ (np.sum(demand[:,2])*60.)
    for K in cog_costs:
        net2, small_capacity = multiply_cognitive_cost(net, geom, thres, K)
        g2.es["weight"] = net2[:,3]
        print np.array(g.es["weight"]).dot(all_or_nothing(g2, od))/ (np.sum(demand[:,2])*60.)
def LA_local_non_routed_costs(alphas, input, output):
    net, demand, node, features = load_LA_3()
    net2, small_capacity = multiply_cognitive_cost(net, features, 1000., 3000.)
    net_local = np.copy(net)
    for row in range(net.shape[0]):
        if small_capacity[row] == 0.0:
            net_local[row, 3:] = net_local[row, 3:] * 0.
    OD_non_routed_costs(alphas,
                        net_local,
                        net2,
                        demand,
                        input,
                        output,
                        verbose=1)
def total_link_flows(alphas, input, output):
    net, demand, node, features = load_LA_2()
    net2, small_capacity = multiply_cognitive_cost(net, features, 1000., 3000.)
    links = net.shape[0]
    n_alpha = len(alphas)
    out = np.zeros((links, 7+n_alpha))
    out[:,:3] = net[:,:3]
    out[:,3:6] = features
    out[:,6] = small_capacity
    col_alphas = ','.join(['X'+str(int(alpha*100)) for alpha in alphas])
    columns = 'link_id,from,to,capacity,length,fftt,local,' + col_alphas
    for i,alpha in enumerate(alphas):
        fs = np.loadtxt(input.format(int(alpha*100)), delimiter=',', skiprows=1)
        out[:,i+7] = np.sum(fs,1)
    np.savetxt(output, out, delimiter=',', header=columns, comments='')
def LA_free_flow_costs(thres, cog_costs):
    '''
    study aiming at comparing the OD costs of all-or-nothing assignment
    between costs = travel times, and costs with multiplicative cognitive costs
    '''
    net, demand, node, geom = load_LA_2()
    g = construct_igraph(net)
    g2 = construct_igraph(net)
    od = construct_od(demand)
    print np.array(g.es["weight"]).dot(all_or_nothing(
        g, od)) / (np.sum(demand[:, 2]) * 60.)
    for K in cog_costs:
        net2, small_capacity = multiply_cognitive_cost(net, geom, thres, K)
        g2.es["weight"] = net2[:, 3]
        print np.array(g.es["weight"]).dot(all_or_nothing(
            g2, od)) / (np.sum(demand[:, 2]) * 60.)
def save_metrics_beta_LA(alphas, betas, thres, input, output, skiprows=0, \
    length_unit='Mile', time_unit='Minute'):
    out = np.zeros((len(alphas) * len(betas), 13))
    for beta in betas:

        net, d, node, features = LA_metrics_attacks_all(beta, thres)
        net2, small_capacity = multiply_cognitive_cost(net, features, 1000.,
                                                       3000.)

        subset = small_capacity

        a = 0
        if alphas[0] == 0.0:
            alpha = 0.0
            print 'compute for nr = {}, r = {}'.format(1 - alphas[0],
                                                       alphas[0])
            fs = np.loadtxt(input.format(int(alpha*100),int(beta*100)), delimiter=',', \
                skiprows=skiprows)
            f = np.sum(fs, axis=1)
            compute_metrics_beta(0.0, beta, f, net, d, features, subset, out, 0, \
                length_unit=length_unit, time_unit=time_unit)
            a = 1

        b = 1 if alphas[-1] == 1.0 else 0
        for i, alpha in enumerate(alphas[a:len(alphas) - b]):
            print 'compute for nr = {}, r = {}'.format(1 - alpha, alpha)
            fs = np.loadtxt(input.format(int(alpha*100),int(beta*100)), delimiter=',', \
                skiprows=skiprows)
            f = np.sum(fs, axis=1)
            compute_metrics_beta(alpha, beta, f, net, d, features, subset, out, i+a, fs=fs, \
                length_unit=length_unit, time_unit=time_unit)

        if alphas[-1] == 1.0:
            alpha = 1.0
            print 'compute for nr = {}, r = {}'.format(1 - alphas[-1],
                                                       alphas[-1])
            fs = np.loadtxt(input.format(int(alpha*100),int(beta*100)), delimiter=',', \
                skiprows=skiprows)
            f = np.sum(fs, axis=1)
            compute_metrics_beta(1.0, beta, f, net, d, features, subset, out, -1, net2=net2, \
                length_unit=length_unit, time_unit=time_unit)

    colnames = 'ratio_routed,beta,tt_non_routed,tt_routed,tt,tt_local,tt_non_local,gas,gas_local,gas_non_local,'
    colnames = colnames + 'vmt,vmt_local,vmt_non_local'
    np.savetxt(output, out, delimiter=',', \
        header=colnames, \
        comments='')
Example #22
0
def main():
    for alpha in [.75]:
        # for alpha in np.linspace(0, .49, 50):
        # for alpha in np.linspace(.5, .99, 50):
        print "ALPHA:", alpha
        start_time2 = timeit.default_timer()

        graph = np.loadtxt('data/LA_net.csv', delimiter=',', skiprows=1)
        demand = np.loadtxt('data/LA_od_2.csv', delimiter=',', skiprows=1)
        graph[10787, -1] = graph[10787, -1] / (1.5**4)
        graph[3348, -1] = graph[3348, -1] / (1.2**4)
        node = np.loadtxt('data/LA_node.csv', delimiter=',')
        features = extract_features('data/LA_net.txt')

        # graph = np.loadtxt('data/Chicago_net.csv', delimiter=',', skiprows=1)
        # demand = np.loadtxt('data/Chicago_od.csv', delimiter=',', skiprows=1)
        # node = np.loadtxt('data/Chicago_node.csv', delimiter=',', skiprows=1)
        # features = extract_features('data/ChicagoSketch_net.txt')

        # features = table in the format [[capacity, length, FreeFlowTime]]

        # alpha = .2 # also known as r
        thres = 1000.
        cog_cost = 3000.

        demand[:, 2] = 0.5 * demand[:, 2] / 4000
        g_nr, small_capacity = multiply_cognitive_cost(graph, features, thres,
                                                       cog_cost)
        d_nr, d_r = heterogeneous_demand(demand, alpha)
        fs, hs, n_d = fw_heterogeneous_1([graph, g_nr], [d_r, d_nr],
                                         alpha,
                                         max_iter=30,
                                         display=1)
        print n_d

        output = {'f': fs, 'h': hs, 'n_d': n_d}

        with open('graph_stuff/LA_net_od_2_alpha_{}.txt'.format(alpha),
                  'w') as outfile:
            # with open('graph_stuff/Chicago_net_od_2_alpha_{}.txt'.format(alpha), 'w') as outfile:
            outfile.write(pickle.dumps(output))

        #end of timer
        elapsed2 = timeit.default_timer() - start_time2

        print("Execution took %s seconds" % elapsed2)
def save_metrics_beta_LA(alphas, betas, thres, input, output, skiprows=0, \
    length_unit='Mile', time_unit='Minute'):
    out = np.zeros((len(alphas)*len(betas),13))
    for beta in betas:

        net, d, node, features = LA_metrics_attacks_all(beta, thres)
        net2, small_capacity = multiply_cognitive_cost(net, features, 1000., 3000.)

        subset = small_capacity


        a = 0
        if alphas[0] == 0.0:
            alpha = 0.0
            print 'compute for nr = {}, r = {}'.format(1-alphas[0], alphas[0])
            fs = np.loadtxt(input.format(int(alpha*100),int(beta*100)), delimiter=',', \
                skiprows=skiprows)
            f = np.sum(fs, axis=1)
            compute_metrics_beta(0.0, beta, f, net, d, features, subset, out, 0, \
                length_unit=length_unit, time_unit=time_unit)
            a = 1

        b = 1 if alphas[-1] == 1.0 else 0
        for i,alpha in enumerate(alphas[a:len(alphas)-b]):
            print 'compute for nr = {}, r = {}'.format(1-alpha, alpha)
            fs = np.loadtxt(input.format(int(alpha*100),int(beta*100)), delimiter=',', \
                skiprows=skiprows)
            f = np.sum(fs, axis=1)
            compute_metrics_beta(alpha, beta, f, net, d, features, subset, out, i+a, fs=fs, \
                length_unit=length_unit, time_unit=time_unit)

        if alphas[-1] == 1.0:
            alpha = 1.0
            print 'compute for nr = {}, r = {}'.format(1-alphas[-1], alphas[-1])
            fs = np.loadtxt(input.format(int(alpha*100),int(beta*100)), delimiter=',', \
                skiprows=skiprows)
            f = np.sum(fs, axis=1)
            compute_metrics_beta(1.0, beta, f, net, d, features, subset, out, -1, net2=net2, \
                length_unit=length_unit, time_unit=time_unit)

    colnames = 'ratio_routed,beta,tt_non_routed,tt_routed,tt,tt_local,tt_non_local,gas,gas_local,gas_non_local,'
    colnames = colnames + 'vmt,vmt_local,vmt_non_local'
    np.savetxt(output, out, delimiter=',', \
        header=colnames, \
        comments='')
def total_link_flows(alphas, input, output):
    '''
    output numpy array with total link flows (non-routed + routed) of the form:
    link_id,from,to,capacity,length,fftt,local,X0,...,X100
    '''
    net, demand, node, features = load_LA_2()
    net2, small_capacity = multiply_cognitive_cost(net, features, 1000., 3000.)
    links = net.shape[0]
    n_alpha = len(alphas)
    out = np.zeros((links, 7 + n_alpha))
    out[:, :3] = net[:, :3]
    out[:, 3:6] = features
    out[:, 6] = small_capacity
    col_alphas = ','.join(['X' + str(int(alpha * 100)) for alpha in alphas])
    columns = 'link_id,from,to,capacity,length,fftt,local,' + col_alphas
    for i, alpha in enumerate(alphas):
        fs = np.loadtxt(input.format(int(alpha * 100)),
                        delimiter=',',
                        skiprows=1)
        out[:, i + 7] = np.sum(fs, 1)
    np.savetxt(output, out, delimiter=',', header=columns, comments='')
def I210_metrics(alphas):
    net, d, node, features = load_I210()
    d[:,2] = d[:,2] / 4000. 
    net2, small_capacity = multiply_cognitive_cost(net, features, 3000., 100.)
    save_metrics(alphas, net, net2, d, features, small_capacity, \
        'data/I210_attack/test_{}.csv', 'data/I210_attack/out.csv', skiprows=1)
def LA_non_routed_costs(alphas, input, output):
    net, demand, node, features = load_LA_3()
    net2, small_capacity = multiply_cognitive_cost(net, features, 1000., 3000.)
    OD_non_routed_costs(alphas, net, net2, demand, input, output, verbose=1)
Example #27
0
    node = np.loadtxt('data/LA_node.csv', delimiter=',')
    features = extract_features('data/LA_net.txt')

    # graph = np.loadtxt('data/Chicago_net.csv', delimiter=',', skiprows=1)
    # demand = np.loadtxt('data/Chicago_od.csv', delimiter=',', skiprows=1)
    # node = np.loadtxt('data/Chicago_node.csv', delimiter=',', skiprows=1)
    # features = extract_features('data/ChicagoSketch_net.txt')

    # features = table in the format [[capacity, length, FreeFlowTime]]

    # alpha = .2 # also known as r
    thres = 1000.
    cog_cost = 3000.

    demand[:, 2] = 0.5 * demand[:, 2] / 4000
    g_nr, small_capacity = multiply_cognitive_cost(graph, features, thres,
                                                   cog_cost)
    d_nr, d_r = heterogeneous_demand(demand, alpha)
    fs, hs, n_d = fw_heterogeneous_1([graph, g_nr], [d_r, d_nr],
                                     alpha,
                                     max_iter=30,
                                     display=1)
    # print n_d

    output = {'f': fs, 'h': hs, 'n_d': n_d}

    with open('graph_stuff/LA_net_od_2_alpha_{}.txt'.format(alpha),
              'w') as outfile:
        # with open('graph_stuff/Chicago_net_od_2_alpha_{}.txt'.format(alpha), 'w') as outfile:
        outfile.write(pickle.dumps(output))

    #end of timer
def chicago_non_routed_costs(alphas):
    net, demand, node, features = load_chicago()
    net2, small_capacity = multiply_cognitive_cost(net, features, 2000.0, 1000.0)
    OD_non_routed_costs(alphas, net, net2, demand, "data/chicago/test_{}.csv", "data/chicago/non_routed_costs.csv")
Example #29
0
def chicago_non_routed_costs(alphas):
    net, demand, node, features = load_chicago()
    net2, small_capacity = multiply_cognitive_cost(net, features, 2000., 1000.)
    OD_non_routed_costs(alphas, net, net2, demand, 'data/chicago/test_{}.csv',
                        'data/chicago/non_routed_costs.csv')
def LA_non_routed_costs(alphas, input, output):
    net, demand, node, features = load_LA_3()
    net2, small_capacity = multiply_cognitive_cost(net, features, 1000., 3000.)
    OD_non_routed_costs(alphas, net, net2, demand, input, output, verbose=1)
def LA_metrics_attack_2(alphas, input, output, thres, beta):
    net, d, node, features = LA_metrics_attacks_all(beta, thres)
    net2, small_capacity = multiply_cognitive_cost(net, features, 1000., 3000.)
    save_metrics(alphas, net, net2, d, features, small_capacity, input, \
        output, skiprows=1, \
        length_unit='Meter', time_unit='Second')
def LA_metrics_attack_2(alphas, input, output, thres, beta):
    net, d, node, features = LA_metrics_attacks_all(beta, thres)
    net2, small_capacity = multiply_cognitive_cost(net, features, 1000., 3000.)
    save_metrics(alphas, net, net2, d, features, small_capacity, input, \
        output, skiprows=1, \
        length_unit='Meter', time_unit='Second')