191 lines
7.8 KiB
Python
191 lines
7.8 KiB
Python
import numpy as np
|
||
from bus_line_match import pipei
|
||
import pandas as pd
|
||
import networkx as nx
|
||
from objective_func import objective_func
|
||
from convert_to_partition import convert_to_partition
|
||
from boundary_adjustment_fitness import boundary_fitness
|
||
from adregionf import adregionf
|
||
|
||
def boundary_adjustment_fitness(yanlinks,x):
|
||
unique_values, unique_indices = np.unique(yanlinks[:, 11], return_index=True)
|
||
Tvb = 0
|
||
velocity= {}
|
||
for i in unique_values:
|
||
selected_values = yanlinks[yanlinks[:, 11] == i][:, 5]
|
||
velocity_only = np.average(selected_values)
|
||
velocity[i]= velocity_only
|
||
min_velocity_key = min(velocity, key=velocity.get)
|
||
data_path = r''
|
||
df2 = pd.read_csv(data_path + 'links_test1.csv')
|
||
df2['L'] = yanlinks[:, 11]
|
||
df2.to_csv(data_path + 'links_test1.csv', index=False)
|
||
node = np.load('node.npy')
|
||
adregion = np.zeros((len(yanlinks), len(yanlinks)))
|
||
for i in range(len(yanlinks)):
|
||
temp1 = np.where(node[:, 0] == node[i, 0])[0]
|
||
temp2 = np.where(node[:, 1] == node[i, 0])[0]
|
||
temp3 = np.where(node[:, 0] == node[i, 1])[0]
|
||
temp4 = np.where(node[:, 1] == node[i, 1])[0]
|
||
temp = np.unique(np.intersect1d(np.arange(i + 1, len(node)), np.concatenate((temp1, temp2, temp3, temp4))))
|
||
# 这里temp是个一维数组，所以不能直接访问
|
||
# if 5026 in temp:
|
||
# temp = temp[temp != 5026]
|
||
if temp.size > 0:
|
||
adregion[i, temp - 1] = 1
|
||
adregion[temp - 1, i] = 1
|
||
|
||
# adregionf主要作用是更新 adregion 矩阵，用于记录节点之间的连接关系,通过这样的操作，
|
||
# 可以保证连接关系的权值与遗传算法的优化结果保持一致。
|
||
adregion = adregionf(yanlinks, node)
|
||
|
||
pipei()
|
||
|
||
bus_line_partition = pd.read_csv('bus_line_partition.csv', header=None, encoding='gbk')
|
||
bus_line_partition = bus_line_partition.drop(bus_line_partition.columns[0], axis=1)
|
||
bus_line_partition = bus_line_partition .fillna(0)
|
||
bus_line_partition = bus_line_partition.astype(int)
|
||
bus_line_partition = bus_line_partition.values
|
||
|
||
bus_line_sequence = pd.read_csv('bus_road_sequence.csv', header=None, encoding='gbk')
|
||
bus_line_sequence = bus_line_sequence.drop(bus_line_sequence.columns[0], axis=1)
|
||
bus_line_sequence = bus_line_sequence .fillna(0)
|
||
bus_line_sequence = bus_line_sequence.astype(int)
|
||
bus_line_sequence = bus_line_sequence.values
|
||
|
||
road_velocity =yanlinks[:, [4, 5]]
|
||
|
||
partition = convert_to_partition(yanlinks)
|
||
G = nx.DiGraph()
|
||
for row in yanlinks:
|
||
G.add_edge(row[0], row[1], weight=1) # weight=row[3]
|
||
G = G.to_undirected()
|
||
|
||
|
||
|
||
dadr = np.load('dadr.npy')
|
||
|
||
# 删除全为零的行
|
||
dadr = dadr[~np.all(dadr == 0, axis=1)]
|
||
# 删除全为零的列
|
||
dadr = dadr[:, ~np.all(dadr == 0, axis=0)]
|
||
adr = dadr
|
||
# 这里的dadr矩阵没有重置过的所以是有问题的
|
||
badr = np.zeros((len(np.unique(x)), len(np.unique(x))))
|
||
# if len(np.unique(x)) != 8:
|
||
# print('1')
|
||
# pass
|
||
|
||
for i in range(len(adr)):
|
||
for j in range(len(adr)):
|
||
if adr[i, j] != 0:
|
||
if x[i] != x[j]:
|
||
|
||
badr[x[i]-1, x[j]-1] = 1
|
||
badr[x[j]-1, x[i]-1] = 1
|
||
|
||
wu = np.where(badr[:, int(min_velocity_key) - 1] == 1)[0]
|
||
bus_line_partition_id = []
|
||
route_sequence = []
|
||
|
||
for index, row in enumerate(bus_line_partition):
|
||
if int(min_velocity_key)in row:
|
||
bus_line_partition_id.append(index)
|
||
route_sequence.append(bus_line_sequence[index, :])
|
||
route_sequence = np.array(route_sequence)
|
||
|
||
# 初始化一个与 route_velocity 形状相同的新数组
|
||
bus_line_route_velocity = np.zeros(route_sequence.shape, dtype=float)
|
||
|
||
# 遍历 route_velocity 中的每个值
|
||
road_velocity_dict = {row[0]: row[1] for row in road_velocity}
|
||
|
||
for ii, row in enumerate(route_sequence):
|
||
for j, value in enumerate(row):
|
||
# 直接在字典中查找 value
|
||
bus_line_route_velocity[ii, j] = road_velocity_dict.get(value, 0)
|
||
|
||
bus_line_partition_id = bus_line_partition[bus_line_partition_id]
|
||
unique_matching_rows=[]
|
||
for index, row in enumerate(bus_line_partition_id):
|
||
unique_row = np.array([x for i, x in enumerate(row) if x not in row[:i]])
|
||
unique_matching_rows.append(unique_row)
|
||
|
||
bus_region_direction = [np.array([x for x in array if x in wu]) for array in unique_matching_rows]
|
||
max_length = max(len(item) for item in bus_region_direction)
|
||
|
||
# 使用0填充长度不足的部分，并将数组转换为二维数组
|
||
bus_region_direction = np.array([np.pad(item, (0, max_length - len(item)), 'constant', constant_values=0) for item in bus_region_direction])
|
||
sorted_bus_region_direction = np.sort(bus_region_direction, axis=1)
|
||
unique_sorted_bus_region_direction = np.unique(sorted_bus_region_direction, axis=0)
|
||
same_direction_fitness = {}
|
||
behindfun = 0
|
||
solution = boundary_fitness(yanlinks)
|
||
frontfun = solution
|
||
noi = 1
|
||
while behindfun < frontfun:
|
||
frontfun = boundary_fitness(yanlinks)
|
||
x1 = frontfun
|
||
print(f"boundary adjustment {noi} times")
|
||
noi+=1
|
||
one_direction_velocity_mean={}
|
||
# 初始化一个空字典来存储non_zero_values
|
||
non_zero_values_dict = {}
|
||
|
||
for aa, row in enumerate(unique_sorted_bus_region_direction):
|
||
matching_row_indices = np.where(np.all(sorted_bus_region_direction == row, axis=1))[0]
|
||
same_direction_bus_line_route_velocity = bus_line_route_velocity[matching_row_indices]
|
||
same_direction_bus_line_partition_id = bus_line_partition_id[matching_row_indices]
|
||
line_proportion = same_direction_bus_line_route_velocity.shape[0] / bus_line_route_velocity.shape[0]
|
||
matching_indices = np.where(same_direction_bus_line_partition_id == int(min_velocity_key))
|
||
matching_values = same_direction_bus_line_route_velocity[matching_indices]
|
||
non_zero_values = matching_values[matching_values != 0]
|
||
one_direction_velocity_mean[aa] = np.mean(non_zero_values)
|
||
|
||
# 将non_zero_values存储到字典中，键为aa
|
||
non_zero_values_dict[aa] = non_zero_values
|
||
|
||
min_key = min(one_direction_velocity_mean, key=one_direction_velocity_mean.get)
|
||
|
||
# 在循环结束后，通过min_key获取其对应的non_zero_values
|
||
min_key_non_zero_values = non_zero_values_dict[min_key]
|
||
matching_indices = np.where(np.isin(road_velocity[:, 1], min_key_non_zero_values))
|
||
|
||
# 使用这些索引从 road_velocity 的第一列获取相应的值
|
||
matching_values = road_velocity[matching_indices, 0]
|
||
matching_values_1d = np.squeeze(matching_values)
|
||
|
||
for i in matching_values_1d:
|
||
i = int(i)-1
|
||
ar = yanlinks[i, 4] - 1
|
||
af = yanlinks[i, 11]
|
||
|
||
ad = adregion[int(ar), :]
|
||
ad[int(ar)] = af
|
||
a = np.unique(ad)
|
||
if len(a) > 2:
|
||
unique_elements, counts = np.unique(ad, return_counts=True)
|
||
# pandas和numpy不一样
|
||
unia = pd.DataFrame({'Value': unique_elements, 'Count': counts, })
|
||
unia = unia[unia.iloc[:, 0] != 0]
|
||
unia = unia.values
|
||
if unia[unia[:, 0] == af, 1] == 2:
|
||
a = a[a != 0]
|
||
ti = []
|
||
for j in range(len(a)):
|
||
if a[j] == af:
|
||
tiao = x1
|
||
else:
|
||
yanlinks[i, 11] = a[j]
|
||
solution = boundary_fitness(yanlinks)
|
||
tiao = solution
|
||
ti.append(tiao)
|
||
x1, y = np.min(ti), np.argmin(ti)
|
||
|
||
yanlinks[i, 11] = a[y]
|
||
adregion = adregionf(yanlinks, node)
|
||
behindfun = x1
|
||
|
||
|
||
|
||
return yanlinks |