def delete_node(cross_coordinate):
coordinates_del = []
coordinate_err = []
for i in range(len(cross_coordinate) - 1):
for j in range(i + 1, len(cross_coordinate)):
distance = tools.geodistance(cross_coordinate[i][2][0], cross_coordinate[i][2][1],
cross_coordinate[j][2][0], cross_coordinate[j][2][1])
if distance < 40:
print(distance)
print(cross_coordinate[i])
coordinates_del.append(cross_coordinate[i])
break
index = 1
for coordinate in coordinates_del:
# print(coordinate)
try:
cross_coordinate.remove(coordinate)
except Exception as ex:
coordinate_err.append(coordinate)
print(coordinate)
print("异常%s" % ex)
else:
# print("********************")
# print("remove success+"+str(index))
# print(coordinate)
# print("********************")
index += 1
return cross_coordinate, coordinates_del, coordinate_err
def get_transfer_time(self, task_size: int, state: int, tel_num: int) -> int:
state_lon = self.node_info_file.loc[state].loc['lon']
state_lat = self.node_info_file.loc[state].loc['lat']
tel_lon = self.tel_station_file.loc[tel_num].loc['lon']
tel_lat = self.tel_station_file.loc[tel_num].loc['lat']
distance = tools.geodistance(state_lon, state_lat, tel_lon, tel_lat)
print(distance)
x_1 = math.log(distance, 10)
transfer_speed = 20 * math.log(1 + (0.5 * (127 + 30 * math.log(distance, 10))) / 0.002, 2)
transfer_time = task_size/transfer_speed*1000
return transfer_time
def step(self, state, index, prior_state):
s_ = self.get_next_state(state, index)
# 获得终点相对于起点的方位角
azimuth_1 = tools.getDegree(self.cross_info[self.start_point][1],
self.cross_info[self.start_point][2],
self.cross_info[self.end_point][1],
self.cross_info[self.end_point][2])
# 获得当前状态相较于起点的方位角
azimuth_2 = tools.getDegree(self.cross_info[self.start_point][1],
self.cross_info[self.start_point][2],
self.cross_info[state][1],
self.cross_info[state][2])
# 获得下一状态相较于起点的方位角
azimuth_3 = tools.getDegree(
self.cross_info[self.start_point][1],
self.cross_info[self.start_point][2],
self.cross_info[self.next_state_list[state][index]][1],
self.cross_info[self.next_state_list[state][index]][2])
# 获得终点相较于当前状态的方位角
azimuth_4 = tools.getDegree(self.cross_info[state][1],
self.cross_info[state][2],
self.cross_info[self.end_point][1],
self.cross_info[self.end_point][2])
# 获得终点相对于下一状态的方位角
azimuth_5 = tools.getDegree(
self.cross_info[self.next_state_list[state][index]][1],
self.cross_info[self.next_state_list[state][index]][2],
self.cross_info[self.end_point][1],
self.cross_info[self.end_point][2])
# 获得下一节点相较于当前状态的方位角
azimuth_6 = tools.getDegree(
self.cross_info[state][1], self.cross_info[state][2],
self.cross_info[self.next_state_list[state][index]][1],
self.cross_info[self.next_state_list[state][index]][2])
# 获得起点与终点的直线距离
distance_1 = tools.geodistance(self.cross_info[self.start_point][1],
self.cross_info[self.start_point][2],
self.cross_info[self.end_point][1],
self.cross_info[self.end_point][2])
# 获得下一状态与终点之间的距离
distance_2 = tools.geodistance(
self.cross_info[self.next_state_list[state][index]][1],
self.cross_info[self.next_state_list[state][index]][2],
self.cross_info[self.end_point][1],
self.cross_info[self.end_point][2])
# 当前状态与终点之间的距离
distance_3 = tools.geodistance(self.cross_info[state][1],
self.cross_info[state][2],
self.cross_info[self.end_point][1],
self.cross_info[self.end_point][2])
# 当前状态与起点之间的距离
distance_4 = tools.geodistance(self.cross_info[state][1],
self.cross_info[state][2],
self.cross_info[self.start_point][1],
self.cross_info[self.start_point][2])
# 下一状态与起点之间的距离
distance_5 = tools.geodistance(
self.cross_info[self.next_state_list[state][index]][1],
self.cross_info[self.next_state_list[state][index]][2],
self.cross_info[self.start_point][1],
self.cross_info[self.start_point][2])
# azimuth_4和azimuth_6的夹角
angle = tools.get_angle(azimuth_4, azimuth_6)
tel_list = self.get_tels(state, index)
total_cost = configuration.Omega * self.get_distance(
state, index) + (1 - configuration.Omega) * 20 * 10
if s_ == prior_state:
# print("loop s_:", s_, "<--> prior_state:", prior_state)
reward = -0.1
done = False
# 如果到达终点，返回奖励1，并给予完成状态
elif s_ == self.end_point:
reward = 1
done = True
s_ = 'end_point'
print('get it')
# 靠近终点正向奖励
elif distance_2 < distance_3 and angle < 50:
reward = -1 / total_cost
done = False
# 远离终点惩罚
elif distance_2 > distance_3:
reward = -(2 / total_cost)
done = False
# 如果下一状态到终点的直线距离两倍于起点到终点的直线距离，跳出循环
elif distance_2 > distance_1 * 1.5:
reward = -1
done = True
s_ = 'terminal'
# 如果所选下一个action与终点角度差距过大，惩罚
elif 120 < abs(azimuth_6 - azimuth_4) < 260:
reward = -(2 / total_cost)
done = False
# 超距后，惩罚
elif distance_1 < distance_5:
reward = -(3 / total_cost)
done = False
# elif distance_2 > distance_3:
# reward = -(2 / self.get_distance(state, index))
# done = False
# elif (abs(angle_1 - angle_3) < 60 or 300 < abs(360 - (angle_1 - angle_3)) < 360) and \
# (abs(angle_1 - angle_2) or 300 < abs(360 - (angle_1 - angle_3)) < 360) and \
# distance_2 < distance_1 and distance_2 < distance_3:
# reward = 1 / self.get_distance(state, index)
# done = False
# elif abs(angle_1-angle_3) < 60 or abs(360-(angle_1-angle_3)) < 60:
# reward = 1 / self.get_distance(state, index)
# done = False
else:
reward = -(1 / total_cost)
done = False
return s_, reward, done
def get_shortest_node_on_same_way(cross_info):
relation = []
distance = []
# 获得way_name相同的路口之间的距离
for node in cross_info:
distance_ = []
for node_compare in cross_info:
if node[0] == node_compare[0]:
continue
else:
if node[2] == node_compare[2]:
distance_ = [
node[0], node_compare[0], node[1], node[2],
tools.geodistance(node[5], node[6], node_compare[5],
node_compare[6])
]
distance.append(distance_)
if node[2] == node_compare[4]:
distance_ = [
node[0], node_compare[0], node[1], node[2],
tools.geodistance(node[5], node[6], node_compare[5],
node_compare[6])
]
distance.append(distance_)
if node[4] == node_compare[2]:
distance_ = [
node[0], node_compare[0], node[3], node[4],
tools.geodistance(node[5], node[6], node_compare[5],
node_compare[6])
]
distance.append(distance_)
if node[4] == node_compare[4]:
distance_ = [
node[0], node_compare[0], node[3], node[4],
tools.geodistance(node[5], node[6], node_compare[5],
node_compare[6])
]
distance.append(distance_)
re = []
way_name = []
# 路口按照way_name归类
for ele in distance:
if [ele[0], ele[3]] not in way_name:
way_name.append([ele[0], ele[3]])
for i in range(len(way_name)):
re_ = []
for ele in distance:
if way_name[i] == [ele[0], ele[3]]:
re_.append(ele)
re.append(re_)
# 按照距离从小到大排序
re_sort = []
for ele in re:
in_x = []
temp = []
for ele_ in ele:
in_x.append(ele_[4])
in_x.sort()
if len(in_x) == 0:
print("*****")
continue
elif len(in_x) == 1:
re_sort.append(ele)
continue
elif len(in_x) >= 2:
for x in in_x:
for ele_ in ele:
if ele_[4] == x:
temp.append(ele_)
re_sort.append(temp)
for re_sort_ in re_sort:
relation_ = []
angle_1 = tools.getDegree(cross_info[re_sort_[0][0]][5],
cross_info[re_sort_[0][0]][6],
cross_info[re_sort_[0][1]][5],
cross_info[re_sort_[0][1]][6])
for re_sort_ele in re_sort_:
angle_2 = tools.getDegree(cross_info[re_sort_ele[0]][5],
cross_info[re_sort_ele[0]][6],
cross_info[re_sort_ele[1]][5],
cross_info[re_sort_ele[1]][6])
if abs(angle_1 - angle_2) >= 90:
relation_.append(re_sort_[0])
relation_.append(re_sort_ele)
relation.append(relation_)
break
if angle_2 == tools.getDegree(
cross_info[re_sort_ele[0]][5],
cross_info[re_sort_ele[0]][6],
cross_info[re_sort_[len(re_sort_) - 1][1]][5],
cross_info[re_sort_[len(re_sort_) - 1][1]][6]):
relation_.append(re_sort_[0])
relation.append(relation_)
break
return distance, re, re_sort, relation
# 路径数组
path.append(current_point)
# 根据node_id获得其value值 返回Series
action_list = q_table.loc[str(current_point)]
# 返回q_table中value值最大的索引
action = action_list.astype(float).idxmax()
c = current_point
next_point = df_re.iloc[current_point, (int(action) - 1) * 5 + 1]
temp = tools.geodistance(
lonA=(node_info_list[int(c)][1]),
latA=node_info_list[int(c)][2],
lonB=node_info_list[int(next_point)][1],
latB=node_info_list[int(next_point)][2]) * 1000
distance += temp
current_point = int(next_point)
if int(next_point) == end_point:
path.append(end_point)
break
except:
error_list.append(start_point)
print('---------------------')
print(start_point, '------>', end_point)
print('current point is', current_point)
print('action is', action)
def get_shortest_node_by_same_id(public_node_info):
distance = []
for node in public_node_info:
distance_ = []
for node_compare in public_node_info:
if node[0] == node_compare[0]:
continue
else:
# 比较way_id是否相同
# 第一轮比较
try:
if node[4] == node_compare[4]:
distance_ = [
node[0], node_compare[0],
int(node[4]), node[5],
tools.geodistance(node[1], node[2],
node_compare[1], node_compare[2])
]
distance.append(distance_)
except Exception as ex:
print(ex)
try:
if node[4] == node_compare[6]:
distance_ = [
node[0], node_compare[0],
int(node[4]), node[5],
tools.geodistance(node[1], node[2],
node_compare[1], node_compare[2])
]
distance.append(distance_)
except Exception as ex:
print(ex)
try:
if node[4] == node_compare[8]:
distance_ = [
node[0], node_compare[0],
int(node[4]), node[5],
tools.geodistance(node[1], node[2],
node_compare[1], node_compare[2])
]
distance.append(distance_)
except Exception as ex:
print(ex)
try:
if node[4] == node_compare[10]:
distance_ = [
node[0], node_compare[0],
int(node[4]), node[5],
tools.geodistance(node[1], node[2],
node_compare[1], node_compare[2])
]
distance.append(distance_)
except Exception as ex:
print(ex)
# try:
# if node[4] == node_compare[12]:
# distance_ = [node[0], node_compare[0], int(node[4]), node[5],
# tools.geodistance(node[1], node[2], node_compare[1], node_compare[2])]
# distance.append(distance_)
# except Exception as ex:
# print(ex)
# try:
# if node[4] == node_compare[14]:
# distance_ = [node[0], node_compare[0], int(node[4]), node[5],
# tools.geodistance(node[1], node[2], node_compare[1], node_compare[2])]
# distance.append(distance_)
# except Exception as ex:
# print(ex)
# 第二轮比较
try:
if node[6] == node_compare[4]:
distance_ = [
node[0], node_compare[0],
int(node[6]), node[7],
tools.geodistance(node[1], node[2],
node_compare[1], node_compare[2])
]
distance.append(distance_)
except Exception as ex:
print(ex)
try:
if node[6] == node_compare[6]:
distance_ = [
node[0], node_compare[0],
int(node[6]), node[7],
tools.geodistance(node[1], node[2],
node_compare[1], node_compare[2])
]
distance.append(distance_)
except Exception as ex:
print(ex)
try:
if node[6] == node_compare[8]:
distance_ = [
node[0], node_compare[0],
int(node[6]), node[7],
tools.geodistance(node[1], node[2],
node_compare[1], node_compare[2])
]
distance.append(distance_)
except Exception as ex:
print(ex)
try:
if node[6] == node_compare[10]:
distance_ = [
node[0], node_compare[0],
int(node[6]), node[7],
tools.geodistance(node[1], node[2],
node_compare[1], node_compare[2])
]
distance.append(distance_)
except Exception as ex:
print(ex)
# try:
# if node[6] == node_compare[12]:
# distance_ = [node[0], node_compare[0], int(node[6]), node[7],
# tools.geodistance(node[1], node[2], node_compare[1], node_compare[2])]
# distance.append(distance_)
# except Exception as ex:
# print(ex)
# try:
# if node[6] == node_compare[14]:
# distance_ = [node[0], node_compare[0], int(node[6]), node[7],
# tools.geodistance(node[1], node[2], node_compare[1], node_compare[2])]
# distance.append(distance_)
# except Exception as ex:
# print(ex)
# 第三轮比较
try:
if node[8] == node_compare[4]:
distance_ = [
node[0], node_compare[0],
int(node[8]), node[9],
tools.geodistance(node[1], node[2],
node_compare[1], node_compare[2])
]
distance.append(distance_)
except Exception as ex:
print(ex)
try:
if node[8] == node_compare[6]:
distance_ = [
node[0], node_compare[0],
int(node[8]), node[9],
tools.geodistance(node[1], node[2],
node_compare[1], node_compare[2])
]
distance.append(distance_)
except Exception as ex:
print(ex)
try:
if node[8] == node_compare[8]:
distance_ = [
node[0], node_compare[0],
int(node[8]), node[9],
tools.geodistance(node[1], node[2],
node_compare[1], node_compare[2])
]
distance.append(distance_)
except Exception as ex:
print(ex)
try:
if node[8] == node_compare[10]:
distance_ = [
node[0], node_compare[0],
int(node[8]), node[9],
tools.geodistance(node[1], node[2],
node_compare[1], node_compare[2])
]
distance.append(distance_)
except Exception as ex:
print(ex)
# try:
# if node[8] == node_compare[12]:
# distance_ = [node[0], node_compare[0], int(node[8]), node[9],
# tools.geodistance(node[1], node[2], node_compare[1], node_compare[2])]
# distance.append(distance_)
# except Exception as ex:
# print(ex)
# try:
# if node[8] == node_compare[14]:
# distance_ = [node[0], node_compare[0], int(node[8]), node[9],
# tools.geodistance(node[1], node[2], node_compare[1], node_compare[2])]
# distance.append(distance_)
# except Exception as ex:
# print(ex)
# 第四轮比较
try:
if node[10] == node_compare[4]:
distance_ = [
node[0], node_compare[0],
int(node[10]), node[11],
tools.geodistance(node[1], node[2],
node_compare[1], node_compare[2])
]
distance.append(distance_)
except Exception as ex:
print(ex)
try:
if node[10] == node_compare[6]:
distance_ = [
node[0], node_compare[0],
int(node[10]), node[11],
tools.geodistance(node[1], node[2],
node_compare[1], node_compare[2])
]
distance.append(distance_)
except Exception as ex:
print(ex)
try:
if node[10] == node_compare[8]:
distance_ = [
node[0], node_compare[0],
int(node[10]), node[11],
tools.geodistance(node[1], node[2],
node_compare[1], node_compare[2])
]
distance.append(distance_)
except Exception as ex:
print(ex)
try:
if node[10] == node_compare[10]:
distance_ = [
node[0], node_compare[0],
int(node[10]), node[11],
tools.geodistance(node[1], node[2],
node_compare[1], node_compare[2])
]
distance.append(distance_)
except Exception as ex:
print(ex)
# try:
# if node[10] == node_compare[12]:
# distance_ = [node[0], node_compare[0], int(node[10]), node[11],
# tools.geodistance(node[1], node[2], node_compare[1], node_compare[2])]
# distance.append(distance_)
# except Exception as ex:
# print(ex)
# try:
# if node[10] == node_compare[14]:
# distance_ = [node[0], node_compare[0], int(node[10]), node[11],
# tools.geodistance(node[1], node[2], node_compare[1], node_compare[2])]
# distance.append(distance_)
# except Exception as ex:
# print(ex)
# # 第五轮比较
# try:
# if node[12] == node_compare[4]:
# distance_ = [node[0], node_compare[0], int(node[12]), node[13],
# tools.geodistance(node[1], node[2], node_compare[1], node_compare[2])]
# distance.append(distance_)
# except Exception as ex:
# print(ex)
# try:
# if node[12] == node_compare[6]:
# distance_ = [node[0], node_compare[0], int(node[12]), node[13],
# tools.geodistance(node[1], node[2], node_compare[1], node_compare[2])]
# distance.append(distance_)
# except Exception as ex:
# print(ex)
# try:
# if node[12] == node_compare[8]:
# distance_ = [node[0], node_compare[0], int(node[12]), node[13],
# tools.geodistance(node[1], node[2], node_compare[1], node_compare[2])]
# distance.append(distance_)
# except Exception as ex:
# print(ex)
# try:
# if node[12] == node_compare[10]:
# distance_ = [node[0], node_compare[0], int(node[12]), node[13],
# tools.geodistance(node[1], node[2], node_compare[1], node_compare[2])]
# distance.append(distance_)
# except Exception as ex:
# print(ex)
# try:
# if node[12] == node_compare[12]:
# distance_ = [node[0], node_compare[0], int(node[12]), node[13],
# tools.geodistance(node[1], node[2], node_compare[1], node_compare[2])]
# distance.append(distance_)
# except Exception as ex:
# print(ex)
# try:
# if node[12] == node_compare[14]:
# distance_ = [node[0], node_compare[0], int(node[12]), node[13],
# tools.geodistance(node[1], node[2], node_compare[1], node_compare[2])]
# distance.append(distance_)
# except Exception as ex:
# print(ex)
# 第六轮比较
# try:
# if node[14] == node_compare[4]:
# distance_ = [node[0], node_compare[0], int(node[14]), node[15],
# tools.geodistance(node[1], node[2], node_compare[1], node_compare[2])]
# distance.append(distance_)
# except Exception as ex:
# print(ex)
# try:
# if node[14] == node_compare[6]:
# distance_ = [node[0], node_compare[0], int(node[14]), node[15],
# tools.geodistance(node[1], node[2], node_compare[1], node_compare[2])]
# distance.append(distance_)
# except Exception as ex:
# print(ex)
# try:
# if node[14] == node_compare[8]:
# distance_ = [node[0], node_compare[0], int(node[14]), node[15],
# tools.geodistance(node[1], node[2], node_compare[1], node_compare[2])]
# distance.append(distance_)
# except Exception as ex:
# print(ex)
# try:
# if node[14] == node_compare[10]:
# distance_ = [node[0], node_compare[0], int(node[14]), node[15],
# tools.geodistance(node[1], node[2], node_compare[1], node_compare[2])]
# distance.append(distance_)
# except Exception as ex:
# print(ex)
# try:
# if node[14] == node_compare[12]:
# distance_ = [node[0], node_compare[0], int(node[14]), node[15],
# tools.geodistance(node[1], node[2], node_compare[1], node_compare[2])]
# distance.append(distance_)
# except Exception as ex:
# print(ex)
# try:
# if node[14] == node_compare[14]:
# distance_ = [node[0], node_compare[0], int(node[14]), node[15],
# tools.geodistance(node[1], node[2], node_compare[1], node_compare[2])]
# distance.append(distance_)
# except Exception as ex:
# print(ex)
# 路口按照way_id归类
re = []
way_id = []
for ele in distance:
if [ele[0], ele[3]] not in way_id:
way_id.append([ele[0], ele[3]])
for i in range(len(way_id)):
re_ = []
for ele in distance:
if way_id[i] == [ele[0], ele[3]]:
re_.append(ele)
re.append(re_)
# 按照距离从小到大排序
re_sort = []
for ele in re:
in_x = []
temp = []
for ele_ in ele:
in_x.append(ele_[4])
in_x.sort()
if len(in_x) == 0:
print("*****")
continue
elif len(in_x) == 1:
re_sort.append(ele)
continue
elif len(in_x) >= 2:
for x in in_x:
for ele_ in ele:
if ele_[4] == x:
temp.append(ele_)
re_sort.append(temp)
return distance, re, re_sort
os.getcwd()) + '/dataset/' + configuration.CITY + '_public_node_info_.csv'
tel_file_path = os.path.dirname(os.getcwd()) + '/dataset/基站信息.csv'
df_cross = pd.read_csv(cross_file_path, encoding='utf-8')
df_cross.set_index('Unnamed: 0', inplace=True)
df_tel = pd.read_csv(tel_file_path, encoding='utf-8')
cross_list = np.array(df_cross).tolist()
tel_list = np.array(df_tel).tolist()
for cross in cross_list:
for tel in tel_list:
distance = tools.geodistance(lonA=cross[1],
latA=cross[2],
lonB=tel[2],
latB=tel[3])
print(distance)
if distance < 400:
print(cross, '------☆------', tel)
# tel = []
# i = 0
# for index_cr, row_cr in df_cross.iterrows():
# i += 1
# tel_ = []
# j = 0
# for index_tel, row_tel in df_tel.iterrows():
# j += 1
# distance = tools.geodistance(row_cr['lon'], row_cr['lat'], row_tel['lon'], row_tel['lat'])
# if distance < 400:
def step_2th(self, state, index, prior_state):
s_ = self.get_next_state(state, index)
# print('s_:', s_)
# 获得终点相较于当前状态的方位角
azimuth_4 = tools.getDegree(self.cross_info[state][1],
self.cross_info[state][2],
self.cross_info[self.end_point][1],
self.cross_info[self.end_point][2])
# 获得下一节点相较于当前状态的方位角
azimuth_6 = tools.getDegree(
self.cross_info[state][1], self.cross_info[state][2],
self.cross_info[self.next_state_list[state][index]][1],
self.cross_info[self.next_state_list[state][index]][2])
# 获得起点与终点的直线距离
distance_1 = tools.geodistance(self.cross_info[self.start_point][1],
self.cross_info[self.start_point][2],
self.cross_info[self.end_point][1],
self.cross_info[self.end_point][2])
# 获得下一状态与终点之间的距离
distance_2 = tools.geodistance(
self.cross_info[self.next_state_list[state][index]][1],
self.cross_info[self.next_state_list[state][index]][2],
self.cross_info[self.end_point][1],
self.cross_info[self.end_point][2])
# 当前状态与终点之间的距离
distance_3 = tools.geodistance(self.cross_info[state][1],
self.cross_info[state][2],
self.cross_info[self.end_point][1],
self.cross_info[self.end_point][2])
# 当前状态与起点之间的距离
distance_4 = tools.geodistance(self.cross_info[state][1],
self.cross_info[state][2],
self.cross_info[self.start_point][1],
self.cross_info[self.start_point][2])
# 下一状态与起点之间的距离
distance_5 = tools.geodistance(
self.cross_info[self.next_state_list[state][index]][1],
self.cross_info[self.next_state_list[state][index]][2],
self.cross_info[self.start_point][1],
self.cross_info[self.start_point][2])
# azimuth_4和azimuth_6的夹角
angle = tools.get_angle(azimuth_4, azimuth_6)
# 随机任务大小(10-100MB)
np.random.seed(state)
# task_size = np.random.randint(10, 100)
ch = Choose()
# 获得下一个状态范围内的基站并随机选择一个用来模拟延迟最小
tel_list = self.tel_list[self.get_next_state(state, index)]
# print(tel_list, '----', state, '-----', index, 'length', len(tel_list), 'type', type(tel_list))
# 如果数据集提供的数据在此范围无基站,自行生成基站和延迟
if len(tel_list) == 2:
# print(tel_list)
# tel = 7
# tel_delay_list = self.df_tel.iloc[int(tel), 3]
transfer_time = configuration.TASK_SIZE / (20 * math.log(
1 + (configuration.VEHICLE_POWER *
(127 + 30 * math.log(200, 10))) / 0.002, 2)) * 1000
queue_time = choose_tel.get_queue_time()
process_time = configuration.TASK_SIZE / configuration.CPU_CLOCK
tel_delay = transfer_time + queue_time + process_time
# print('空基站', tel_delay, 'task_size', task_size, 'transfer_time', transfer_time)
else:
tel_list = tel_list[1:-1]
tel_list = tel_list.split(',')
tel_delay = 999999
for tel in tel_list:
transfer_time = ch.get_transfer_time(configuration.TASK_SIZE,
state, int(tel))
# queue_time = choose_tel.get_queue_time()
# print(tel_list)
queue_time = choose_tel.get_real_queue(df_tel=self.df_tel,
tel=int(tel))
process_time = choose_tel.get_process_time(
configuration.TASK_SIZE, int(tel))
if tel_delay > transfer_time + queue_time + process_time:
tel_delay = transfer_time + queue_time + process_time
# print('实际基站', tel_delay)
# print(transfer_time+queue_time+process_time)
# tel = np.random.choice(tel_list)
# tel_delay_list = self.df_tel.iloc[int(tel), 3]
# tel_delay_list = tel_delay_list[1:-1]
# if tel_delay_list[0] == ' ':
# tel_delay_list = tel_delay_list[1:]
# tel_delay_list = tel_delay_list.replace(' ', ' ')
# tel_delay_list = tel_delay_list.split(' ')
# 在延迟列表中随机选择一个作为延迟
# tel_delay = transfer_time+queue_time+process_time
# print(tel_list)
# total_cost_pre = 0.8*self.get_distance(state, index) + 0.2*20*10
# total_cost = 0.8*self.get_distance(state, index) + 0.2*20*(tel_delay-10)
# gap = total_cost - total_cost_pre
# print(tel_delay)
distance = self.get_distance(state, index)
# 权重设置
total_cost = self.omega / 5 * distance + (1 - self.omega) / 5 * (
tel_delay - 10)
# print(total_cost)
# print('distance is', distance, 'and tel_delay is', tel_delay, 'and total cost is', total_cost)
# 如果到达终点，返回奖励1，并给予完成状态
if s_ == prior_state:
# print("loop s_:", s_, "<--> prior_state:", prior_state)
reward = -0.5
done = False
elif s_ == self.end_point:
reward = 1
done = True
s_ = 'end_point'
# print('get it')
# 靠近终点正向奖励
elif distance_2 < distance_3 and angle < 50:
if total_cost == 0:
reward = 0
else:
reward = 1 / total_cost
done = False
# 远离终点惩罚
elif distance_2 > distance_3:
if total_cost == 0:
reward = 0
else:
reward = -2 / total_cost
done = False
# 如果下一状态到终点的直线距离两倍于起点到终点的直线距离，跳出循环
elif distance_2 > distance_1 * 1.5:
if total_cost == 0:
reward = 0
else:
reward = -1
done = True
s_ = 'terminal'
# 如果所选下一个action与终点角度差距过大，惩罚
elif 120 < abs(azimuth_6 - azimuth_4) < 260:
if total_cost == 0:
reward = 0
else:
reward = -2 / total_cost
done = False
# 超距后，惩罚
elif distance_1 < distance_5:
if total_cost == 0:
reward = 0
else:
reward = -3 / total_cost
done = False
# elif distance_2 > distance_3:
# reward = -(2 / self.get_distance(state, index))
# done = False
# elif (abs(angle_1 - angle_3) < 60 or 300 < abs(360 - (angle_1 - angle_3)) < 360) and \
# (abs(angle_1 - angle_2) or 300 < abs(360 - (angle_1 - angle_3)) < 360) and \
# distance_2 < distance_1 and distance_2 < distance_3:
# reward = 1 / self.get_distance(state, index)
# done = False
# elif abs(angle_1-angle_3) < 60 or abs(360-(angle_1-angle_3)) < 60:
# reward = 1 / self.get_distance(state, index)
# done = False
else:
if total_cost == 0:
reward = 0
else:
reward = -1 / total_cost
done = False
return s_, reward, done, tel_delay, transfer_time, queue_time, process_time
for j in range(len(paths[i])):
if tel_list[i][j][0] == -1:
dijkstra_choose_tel.append(-1)
else:
for tel in tel_list[i][j]:
if len(tel_list[i][j]) == 1 and df_tel[
df_tel['index'].isin([tel])].empty:
dijkstra_choose_tel.append(-1)
elif df_tel[df_tel['index'].isin([tel])].empty:
dijkstra_choose_tel.append(-1)
else:
temp = 999999
distance = tools.geodistance(
df_co.loc[paths[i][j]]['lon'],
df_co.loc[paths[i][j]]['lat'],
df_tel.loc[df_tel.loc[df_tel['index'] ==
tel].index[0]]['lon'],
df_tel.loc[df_tel.loc[df_tel['index'] ==
tel].index[0]]['lat'])
if distance < temp:
temp = distance
if len(tel_list[i][j]) != 1 and not df_tel[
df_tel['index'].isin([
tel
])].empty and tel != tel_list[i][j][0]:
# print(tel)
# print(tel_list[i][j][0])
# print(dijkstra_choose_tel)
dijkstra_choose_tel.pop()
dijkstra_choose_tel.append(tel)
dijkstra_choose_tel_list.append(dijkstra_choose_tel)