def alg_odlink_default(network_name, bool_display=True): data = read_data(network_name) link_node_pair = data['link_node_pair'] link_capacity = data['link_capacity'] link_free = data['link_free_flow_time'] od_node_pair = data['od_node_pair'] od_demand = data['od_demand'] od_number = data['od_number'] link_number = data['link_number'] node_number = data['node_number'] parameter = set_parameter() para_a = parameter['a'] para_b = parameter['b'] matrix = gen_matrix(data) node_odlink_relation = matrix['node_odlink_relation'] node_oddemand = matrix['node_oddemand'] od_odlink_relation = matrix['od_odlink_relation'] start_time = time.time() x_odlink = cp.Variable(link_number * od_number) x_link = od_odlink_relation @ x_odlink objective = cp.Minimize( cp.sum(link_free * x_link) + cp.sum(link_free * para_a / (para_b + 1) * link_capacity * cp.power(x_link / link_capacity, para_b + 1))) constraints = [ x_odlink >= 0, node_odlink_relation @ x_odlink - node_oddemand == 0 ] result = cp.Problem( objective=objective, constraints=constraints).solve() # reltol=1e-15, abstol=1e-15 target_value = objective.value link_flow = od_odlink_relation @ x_odlink.value runtime = time.time() - start_time if bool_display: print('----alg_odlink_default----') print(f'target_value: {target_value}') print(f'link_flow: {link_flow}') print(f'runtime: {runtime}') print('--------')
# @Time : 2020/3/10 16:12 # @Author : gzzang # @File : verification # @Project : traffic_assignment from preparation import read_data from preparation import set_parameter import pickle import numpy as np data = read_data() link_node_pair = data['link_node_pair'] link_capacity = data['link_capacity'] link_free = data['link_free_flow_time'] od_node_pair = data['od_node_pair'] od_demand = data['od_demand'] od_number = data['od_number'] link_number = data['link_number'] node_number = data['node_number'] parameter = set_parameter() para_a = parameter['a'] para_b = parameter['b'] with open('flow.pkl', 'rb') as f: current_link_flow = pickle.load(f) function_value = np.sum(link_free * current_link_flow) + np.sum( link_free * para_a / (para_b + 1) * link_capacity * np.power(current_link_flow / link_capacity, para_b + 1)) print(function_value)
def alg_odlink_fw_optimization(network_name, bool_display=True, bool_display_iteration=True): data = read_data(network_name) link_node_pair = data['link_node_pair'] link_capacity = data['link_capacity'] link_free = data['link_free_flow_time'] od_node_pair = data['od_node_pair'] od_demand = data['od_demand'] od_number = data['od_number'] link_number = data['link_number'] node_number = data['node_number'] parameter = set_parameter() para_a = parameter['a'] para_b = parameter['b'] matrix = gen_matrix(data) node_odlink_relation = matrix['node_odlink_relation'] node_oddemand = matrix['node_oddemand'] od_odlink_relation = matrix['od_odlink_relation'] def cal_odlink_flow(current_odlink_flow): """ 根据路段时间计算基于最短路的全有全无路段流量 :param link_time: :return: """ def derivative(xx_odlink): return link_free * (1 + para_a * (od_odlink_relation @ xx_odlink / link_capacity)**para_b) @ od_odlink_relation x_odlink_flow = cp.Variable(link_number * od_number) odlink_derivative = derivative(current_odlink_flow) objective = cp.Minimize(odlink_derivative @ x_odlink_flow) constraints = [ x_odlink_flow >= 0, node_odlink_relation @ x_odlink_flow - node_oddemand == 0 ] cp.Problem(objective=objective, constraints=constraints).solve() return x_odlink_flow.value current_odlink_flow = cal_odlink_flow(np.zeros(link_number * od_number)) target_gap = 1e-7 iteration_number = 1000 termination_bool = False optimum_bool = False iteration_index = 0 while not (termination_bool or optimum_bool): optimal_vertex = cal_odlink_flow(current_odlink_flow) direction = optimal_vertex - current_odlink_flow current_odlink_flow, temp_value = algorithm_line_search( current_odlink_flow, direction, od_odlink_relation, link_free, para_a, para_b, link_capacity) if iteration_index == 0: gap = 1 else: gap = np.abs((temp_value - optimal_value) / optimal_value) if gap < target_gap: optimum_bool = True elif iteration_index == iteration_number: termination_bool = True optimal_value = temp_value iteration_index += 1 if bool_display_iteration: print('--------') print(f"gap:{gap}") print(f"iteration_index:{iteration_index}") print('--------') if bool_display: print('----alg_odlink_fw_optimization----') print(f"optimum_bool:{optimum_bool}") print(f"iteration_index:{iteration_index}") print(f"optimal_vertex:{optimal_vertex}") print(f"direction:{direction}") print(f'final:{current_odlink_flow}') print(f'value:{optimal_value}') print('--------')
def alg_link_fw_sp(network_name, bool_display=True, bool_display_iteration=True): data = read_data(network_name) link_node_pair = data['link_node_pair'] link_capacity = data['link_capacity'] link_free = data['link_free_flow_time'] od_node_pair = data['od_node_pair'] od_demand = data['od_demand'] od_number = data['od_number'] link_number = data['link_number'] node_number = data['node_number'] parameter = set_parameter() para_a = parameter['a'] para_b = parameter['b'] g = ig.Graph() g.add_vertices(node_number) g.add_edges(link_node_pair) def cal_direction_link_flow(link_flow): """ 根据路段时间计算基于最短路的全有全无路段流量 :param link_flow: :return: """ def cal_link_time(link_flow): return link_free * (1 + para_a * (link_flow / link_capacity)**para_b) g.es['weight'] = cal_link_time(link_flow) optimal_link_flow = np.zeros_like(link_flow) for od, demand in zip(od_node_pair, od_demand): shortest_path_link_flow = np.zeros_like(link_flow) shortest_path_link_flow[g.get_shortest_paths( od[0], to=od[1], weights='weight', output='epath')[0]] = demand optimal_link_flow += shortest_path_link_flow return optimal_link_flow - link_flow start_time = time.time() current_link_flow = cal_direction_link_flow(np.zeros_like(link_free)) target_gap = 1e-7 iteration_number = 1000 termination_bool = False optimum_bool = False iteration_index = 0 while not (termination_bool or optimum_bool): direction_link_flow = cal_direction_link_flow(current_link_flow) current_link_flow, temp_value = algorithm_line_search_link( current_link_flow, direction_link_flow, link_free, para_a, para_b, link_capacity) if iteration_index == 0: gap = 1 else: gap = np.abs((temp_value - optimal_value) / optimal_value) if gap < target_gap: optimum_bool = True elif iteration_index == iteration_number: termination_bool = True optimal_value = temp_value iteration_index += 1 if bool_display_iteration: print() print(f"gap:{gap}") print(f"iteration_index:{iteration_index}") if bool_display: print('----alg_link_fw_sp----') print(f"direction_link_flow:{direction_link_flow}") print(f'final:{current_link_flow}') print(f'value:{optimal_value}') print('--------') print(f'runtime:{time.time() - start_time}')
def alg_link_cg(network_name, bool_display=True, bool_display_iteration=True, bool_route_result_output=False): data = read_data(network_name) link_node_pair = data['link_node_pair'] link_capacity = data['link_capacity'] link_free = data['link_free_flow_time'] od_node_pair = data['od_node_pair'] od_demand = data['od_demand'] od_number = data['od_number'] link_number = data['link_number'] node_number = data['node_number'] parameter = set_parameter() para_a = parameter['a'] para_b = parameter['b'] g = ig.Graph() g.add_vertices(node_number) g.add_edges(link_node_pair) def cal_sp_of_one_od(link_flow, node_list): link_time = link_free * (1 + para_a * (link_flow / link_capacity)**para_b) g.es['weight'] = link_time node_incidence = np.zeros_like(link_flow, dtype=bool) node_incidence[g.get_shortest_paths(node_list[0], to=node_list[1], weights='weight', output='epath')[0]] = True return node_incidence start_time = time.time() initial_od_list_route_link_incidence = [] zero_link_flow = np.zeros_like(link_free) for one_pair_list in od_node_pair: sp_link_incidence = cal_sp_of_one_od(zero_link_flow, one_pair_list) initial_od_list_route_link_incidence.append( sp_link_incidence.reshape([1, link_number])) initial_route_link_incidence = np.vstack( initial_od_list_route_link_incidence) current_link_flow = od_demand @ initial_route_link_incidence current_od_list_route_link_incidence = initial_od_list_route_link_incidence iteration_number = 20 target_gap = 1e-20 termination_bool = False optimum_bool = False iteration_index = 0 while not (termination_bool or optimum_bool): for od_index, (one_route_link_incidence, one_pair_list) in enumerate( zip(current_od_list_route_link_incidence, od_node_pair)): sp_link_incidence = cal_sp_of_one_od(current_link_flow, one_pair_list) if not np.any( np.all(one_route_link_incidence == sp_link_incidence, axis=1)): current_od_list_route_link_incidence[od_index] = np.vstack( (one_route_link_incidence, sp_link_incidence)) route_link_incidence = np.vstack(current_od_list_route_link_incidence) od_route_number = np.array([ one_route_link_array.shape[0] for one_route_link_array in current_od_list_route_link_incidence ]) route_number = np.sum(od_route_number) od_route_incidence = np.zeros([od_number, route_number], dtype=bool) temp = 0 for od_index, value in enumerate(od_route_number): od_route_incidence[od_index, temp:(temp + value)] = True temp += value data_with_route_variable = data data_with_route_variable['od_route_incidence'] = od_route_incidence data_with_route_variable['route_link_incidence'] = route_link_incidence data_with_route_variable['route_number'] = route_link_incidence.shape[ 0] # current_route_flow, temp_value = algorithm_route_vi(data_with_route_variable, bool_display=False, # bool_display_iteration=False) # current_route_flow, temp_value = algorithm_route_mp(data_with_route_variable, bool_display=False) current_route_flow, temp_value = algorithm_route_msa( data_with_route_variable, bool_display=False) current_link_flow = current_route_flow @ route_link_incidence if iteration_index != 0: gap = np.abs((temp_value - optimal_value) / optimal_value) else: gap = 1 if gap < target_gap: optimum_bool = True elif iteration_index == iteration_number: termination_bool = True optimal_value = temp_value iteration_index += 1 if bool_display: if bool_display_iteration: print('----iteration_alg_link_cg_default----') print(f"iteration_index:{iteration_index}") print(f'gap:{gap}') print(f"od_route_number:{od_route_number}") print(f"current_link_flow:{current_link_flow}") print(f"optimal_value:{optimal_value}") print('--------') if bool_display: print('----alg_link_cg_default----') print(f'optimum_bool:{optimum_bool}') print(f'gap:{gap}') print(f"iteration_index:{iteration_index}") print(f"od_route_number:{od_route_number}") print(f"current_link_flow:{current_link_flow}") print(f"optimal_value:{optimal_value}") print(f'runtime:{time.time() - start_time}') print('--------') if bool_route_result_output: print('--------') print(f'bool_route_result_output:{bool_route_result_output}') print('--------') output_path = 'output' if not os.path.exists(output_path): os.makedirs(output_path) pd.DataFrame({ string: value for string, value in zip(( 'route_index', 'link_index'), np.nonzero(route_link_incidence)) }).to_csv(output_path + '/' + network_name + '_route_link_relation.csv', index=False) pd.DataFrame({ string: value for string, value in zip(( 'od_index', 'route_index'), np.nonzero(od_route_incidence)) }).to_csv(output_path + '/' + network_name + '_od_route_relation.csv', index=False)
ax3.plot(mean_predicted_value, fraction_of_positives) ax3.plot([0, 1], [0, 1], color='gray', linestyle='--') ax3.set_xlabel('Mean Predicted Value') ax3.set_ylabel('Fraction of positives') fig.tight_layout(pad=0) if outputfile: fig.savefig(outputfile) else: plt.show() if __name__ == '__main__': df = read_data('signal.csv', 'background.csv') df = drop_useless(df) print(80*'=') print('{:^80}'.format('GaussianNB')) print(80*'=') gnb = GaussianNB() df_nb_label = df.dropna(axis=1)['label'] df_nb = df.dropna(axis=1).drop('label', axis=1) print('{} remaining features after dropping columns NaNs.'.format( len(df_nb.columns) )) nb_aucs = classifier_crossval_performance( df_nb.values, df_nb_label.values, classifier=gnb
cval = StratifiedKFold(y, n_folds=n_folds, shuffle=True) with Parallel(n_jobs=n_jobs) as pool: performances = pool( delayed(evaluate)(X, y, train, test) for train, test in cval ) performances = pd.Panel(dict(enumerate(performances))) return performances if __name__ == '__main__': data = drop_useless(read_data('./signal.csv', './background.csv')) nb = GaussianNB() classifiers = { 'RandomForest': RandomForestClassifier( n_estimators=100, criterion='entropy', n_jobs=2, ), # 'ExtraTrees': ExtraTreesClassifier( # n_estimators=100, criterion='entropy', n_jobs=-1 # ), 'AdaBoost': GradientBoostingClassifier( n_estimators=100, loss='exponential', ), 'NaiveBayes': GaussianNB() }