forked from xtdrone/XTDrone
实验三种算法的任务分配
This commit is contained in:
parent
f29623b0b4
commit
ed00504247
Binary file not shown.
|
After Width: | Height: | Size: 38 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 74 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 46 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 74 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 84 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 41 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 73 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 82 KiB |
|
|
@ -1,243 +1,136 @@
|
||||||
import random
|
import random
|
||||||
|
|
||||||
import numpy as np
|
import numpy as np
|
||||||
|
|
||||||
import math
|
import math
|
||||||
|
import time
|
||||||
|
import os
|
||||||
|
|
||||||
class Aco():
|
class ACO():
|
||||||
|
|
||||||
def __init__(self, vehicle_num, target_num,vehicle_speed, target, time_lim):
|
def __init__(self, vehicle_num, target_num,vehicle_speed, target, time_lim):
|
||||||
|
|
||||||
self.num_type_ant = vehicle_num
|
self.num_type_ant = vehicle_num
|
||||||
|
|
||||||
self.num_city = target_num+1 #number of cities
|
self.num_city = target_num+1 #number of cities
|
||||||
|
|
||||||
self.group = 200
|
self.group = 200
|
||||||
|
|
||||||
self.num_ant = self.group*self.num_type_ant #number of ants
|
self.num_ant = self.group*self.num_type_ant #number of ants
|
||||||
|
|
||||||
self.ant_vel = vehicle_speed
|
self.ant_vel = vehicle_speed
|
||||||
|
|
||||||
self.cut_time = time_lim
|
self.cut_time = time_lim
|
||||||
|
|
||||||
self.oneee = np.zeros((4,1))
|
self.oneee = np.zeros((4,1))
|
||||||
|
|
||||||
self.target = target
|
self.target = target
|
||||||
|
|
||||||
self.alpha = 1 #pheromone
|
self.alpha = 1 #pheromone
|
||||||
|
self.beta = 2 #qiwangyinzi
|
||||||
self.beta = 1 #qiwangyinzi
|
|
||||||
|
|
||||||
self.k1 = 0.03
|
self.k1 = 0.03
|
||||||
|
self.iter_max = 150
|
||||||
self.iter_max = 300
|
#matrix of the distances between cities
|
||||||
|
|
||||||
#matrix of the distances between cities
|
|
||||||
|
|
||||||
def distance_matrix(self):
|
def distance_matrix(self):
|
||||||
|
|
||||||
dis_mat = []
|
dis_mat = []
|
||||||
|
|
||||||
for i in range(self.num_city):
|
for i in range(self.num_city):
|
||||||
|
|
||||||
dis_mat_each = []
|
dis_mat_each = []
|
||||||
|
|
||||||
for j in range(self.num_city):
|
for j in range(self.num_city):
|
||||||
|
|
||||||
dis = math.sqrt(pow(self.target[i][0]-self.target[j][0],2)+pow(self.target[i][1]-self.target[j][1],2))
|
dis = math.sqrt(pow(self.target[i][0]-self.target[j][0],2)+pow(self.target[i][1]-self.target[j][1],2))
|
||||||
|
|
||||||
dis_mat_each.append(dis)
|
dis_mat_each.append(dis)
|
||||||
|
|
||||||
dis_mat.append(dis_mat_each)
|
dis_mat.append(dis_mat_each)
|
||||||
|
|
||||||
return dis_mat
|
return dis_mat
|
||||||
|
def run(self):
|
||||||
def get_assignment_aco(self):
|
print("ACO start, pid: %s" % os.getpid())
|
||||||
|
start_time = time.time()
|
||||||
#distances of nodes
|
#distances of nodes
|
||||||
|
|
||||||
dis_list = self.distance_matrix()
|
dis_list = self.distance_matrix()
|
||||||
|
|
||||||
dis_mat = np.array(dis_list)
|
dis_mat = np.array(dis_list)
|
||||||
|
|
||||||
value_init = self.target[:,2].transpose()
|
value_init = self.target[:,2].transpose()
|
||||||
|
|
||||||
delay_init = self.target[:,3].transpose()
|
delay_init = self.target[:,3].transpose()
|
||||||
|
|
||||||
pheromone_mat = np.ones((self.num_type_ant,self.num_city))
|
pheromone_mat = np.ones((self.num_type_ant,self.num_city))
|
||||||
|
|
||||||
#velocity of ants
|
#velocity of ants
|
||||||
path_new = [[0]for i in range (self.num_type_ant)]
|
path_new = [[0]for i in range (self.num_type_ant)]
|
||||||
|
|
||||||
count_iter = 0
|
count_iter = 0
|
||||||
|
|
||||||
while count_iter < self.iter_max:
|
while count_iter < self.iter_max:
|
||||||
|
|
||||||
path_sum = np.zeros((self.num_ant,1))
|
path_sum = np.zeros((self.num_ant,1))
|
||||||
|
|
||||||
time_sum = np.zeros((self.num_ant,1))
|
time_sum = np.zeros((self.num_ant,1))
|
||||||
|
|
||||||
value_sum = np.zeros((self.num_ant,1))
|
value_sum = np.zeros((self.num_ant,1))
|
||||||
|
|
||||||
path_mat=[[0]for i in range (self.num_ant)]
|
path_mat=[[0]for i in range (self.num_ant)]
|
||||||
|
|
||||||
value = np.zeros((self.group,1))
|
value = np.zeros((self.group,1))
|
||||||
|
atten = np.ones((self.num_type_ant,1)) * 0.2
|
||||||
for ant in range(self.num_ant):
|
for ant in range(self.num_ant):
|
||||||
|
|
||||||
ant_type = ant % self.num_type_ant
|
ant_type = ant % self.num_type_ant
|
||||||
|
|
||||||
visit = 0
|
visit = 0
|
||||||
|
|
||||||
if ant_type == 0:
|
if ant_type == 0:
|
||||||
|
|
||||||
unvisit_list=list(range(1,self.num_city))#have not visit
|
unvisit_list=list(range(1,self.num_city))#have not visit
|
||||||
|
|
||||||
for j in range(1,self.num_city):
|
for j in range(1,self.num_city):
|
||||||
|
|
||||||
#choice of next city
|
#choice of next city
|
||||||
|
|
||||||
trans_list=[]
|
trans_list=[]
|
||||||
|
|
||||||
tran_sum=0
|
tran_sum=0
|
||||||
|
|
||||||
trans=0
|
trans=0
|
||||||
|
|
||||||
#if len(unvisit_list)==0:
|
#if len(unvisit_list)==0:
|
||||||
#print('len(unvisit_list)==0')
|
#print('len(unvisit_list)==0')
|
||||||
|
|
||||||
for k in range(len(unvisit_list)): # to decide which node to visit
|
for k in range(len(unvisit_list)): # to decide which node to visit
|
||||||
|
|
||||||
#trans +=np.power(pheromone_mat[ant_type][visit][unvisit_list[k]],alpha)*np.power(k1*value_mat[visit][unvisit_list[k]],beta)
|
#trans +=np.power(pheromone_mat[ant_type][visit][unvisit_list[k]],alpha)*np.power(k1*value_mat[visit][unvisit_list[k]],beta)
|
||||||
trans +=np.power(pheromone_mat[ant_type][unvisit_list[k]],self.alpha)*np.power(0.05*value_init[unvisit_list[k]],self.beta)
|
trans +=np.power(pheromone_mat[ant_type][unvisit_list[k]],self.alpha)*np.power(0.05*value_init[unvisit_list[k]],self.beta)
|
||||||
|
|
||||||
trans_list.append(trans)
|
trans_list.append(trans)
|
||||||
|
|
||||||
tran_sum = trans
|
tran_sum = trans
|
||||||
|
|
||||||
rand = random.uniform(0,tran_sum)
|
rand = random.uniform(0,tran_sum)
|
||||||
|
|
||||||
for t in range(len(trans_list)):
|
for t in range(len(trans_list)):
|
||||||
|
|
||||||
if(rand <= trans_list[t]):
|
if(rand <= trans_list[t]):
|
||||||
|
|
||||||
visit_next = unvisit_list[t]
|
visit_next = unvisit_list[t]
|
||||||
|
|
||||||
break
|
break
|
||||||
|
|
||||||
else:
|
else:
|
||||||
|
|
||||||
continue
|
continue
|
||||||
|
|
||||||
path_mat[ant].append(visit_next)
|
path_mat[ant].append(visit_next)
|
||||||
|
|
||||||
path_sum[ant] += dis_mat[path_mat[ant][j-1]][path_mat[ant][j]]
|
path_sum[ant] += dis_mat[path_mat[ant][j-1]][path_mat[ant][j]]
|
||||||
|
|
||||||
time_sum[ant] += path_sum[ant] / self.ant_vel[ant_type] + delay_init[visit_next]
|
time_sum[ant] += path_sum[ant] / self.ant_vel[ant_type] + delay_init[visit_next]
|
||||||
|
|
||||||
if time_sum[ant] > self.cut_time:
|
if time_sum[ant] > self.cut_time:
|
||||||
|
|
||||||
time_sum[ant]-=path_sum[ant] / self.ant_vel[ant_type] + delay_init[visit_next]
|
time_sum[ant]-=path_sum[ant] / self.ant_vel[ant_type] + delay_init[visit_next]
|
||||||
|
|
||||||
path_mat[ant].pop()
|
path_mat[ant].pop()
|
||||||
|
|
||||||
break
|
break
|
||||||
|
|
||||||
value_sum[ant] += value_init[visit_next]
|
value_sum[ant] += value_init[visit_next]
|
||||||
|
|
||||||
unvisit_list.remove(visit_next)#update
|
unvisit_list.remove(visit_next)#update
|
||||||
|
|
||||||
visit = visit_next
|
visit = visit_next
|
||||||
|
|
||||||
if (ant_type) == self.num_type_ant-1:
|
if (ant_type) == self.num_type_ant-1:
|
||||||
|
|
||||||
small_group = int(ant/self.num_type_ant)
|
small_group = int(ant/self.num_type_ant)
|
||||||
|
|
||||||
for k in range (self.num_type_ant):
|
for k in range (self.num_type_ant):
|
||||||
|
|
||||||
value[small_group]+= value_sum[ant-k]
|
value[small_group]+= value_sum[ant-k]
|
||||||
|
#iteration
|
||||||
|
|
||||||
#diedai
|
#print(max(value))
|
||||||
|
|
||||||
print(max(value))
|
|
||||||
|
|
||||||
if count_iter == 0:
|
if count_iter == 0:
|
||||||
|
|
||||||
value_new = max(value)
|
value_new = max(value)
|
||||||
|
|
||||||
value = value.tolist()
|
value = value.tolist()
|
||||||
|
|
||||||
for k in range (0,self.num_type_ant):
|
for k in range (0,self.num_type_ant):
|
||||||
|
|
||||||
path_new[k] = path_mat[value.index(value_new)*self.num_type_ant+k]
|
path_new[k] = path_mat[value.index(value_new)*self.num_type_ant+k]
|
||||||
|
|
||||||
path_new[k].remove(0)
|
path_new[k].remove(0)
|
||||||
|
|
||||||
#time[k] = time_sum[value.index(value_new)*self.num_type_ant+k]
|
#time[k] = time_sum[value.index(value_new)*self.num_type_ant+k]
|
||||||
|
|
||||||
else:
|
else:
|
||||||
|
|
||||||
if max(value) > value_new:
|
if max(value) > value_new:
|
||||||
|
|
||||||
value_new = max(value)
|
value_new = max(value)
|
||||||
|
|
||||||
value = value.tolist()
|
value = value.tolist()
|
||||||
|
|
||||||
for k in range (0,self.num_type_ant):
|
for k in range (0,self.num_type_ant):
|
||||||
|
|
||||||
path_new[k] = path_mat[value.index(value_new)*self.num_type_ant+k]
|
path_new[k] = path_mat[value.index(value_new)*self.num_type_ant+k]
|
||||||
|
|
||||||
path_new[k].remove(0)
|
path_new[k].remove(0)
|
||||||
|
|
||||||
#time[k] = time_sum[value.index(value_new)*self.num_type_ant+k]
|
#time[k] = time_sum[value.index(value_new)*self.num_type_ant+k]
|
||||||
|
|
||||||
# update pheromone
|
#update pheromone
|
||||||
|
pheromone_change = np.zeros((self.num_type_ant,self.num_city))
|
||||||
pheromone_change=np.zeros((self.num_type_ant,self.num_city))
|
|
||||||
|
|
||||||
for i in range(self.num_ant):
|
for i in range(self.num_ant):
|
||||||
|
|
||||||
length = len(path_mat[i])
|
length = len(path_mat[i])
|
||||||
|
|
||||||
m = i%self.num_type_ant
|
m = i%self.num_type_ant
|
||||||
|
|
||||||
n = int(i/self.num_type_ant)
|
n = int(i/self.num_type_ant)
|
||||||
|
|
||||||
for j in range(length-1):
|
for j in range(length-1):
|
||||||
|
#a=value_sum[i]/(np.power((value[n]-value_new),2)+1)
|
||||||
if value[n] == value_new:
|
|
||||||
|
|
||||||
atten = 0.1
|
|
||||||
|
|
||||||
else:
|
|
||||||
|
|
||||||
atten = 0.3
|
|
||||||
|
|
||||||
#a=value_sum[i]/(np.power((value[n]-value_new),2)+1)
|
|
||||||
|
|
||||||
pheromone_change[m][path_mat[i][j+1]]+= self.k1*value_init[path_mat[i][j+1]]
|
pheromone_change[m][path_mat[i][j+1]]+= self.k1*value_init[path_mat[i][j+1]]
|
||||||
|
atten[m] += (value_sum[i]/(np.power((value_new-value[n]),4)+1))/self.group
|
||||||
|
#print(atten[m])
|
||||||
for m in range (self.num_type_ant):
|
for k in range (self.num_type_ant):
|
||||||
|
|
||||||
#print('pheromone_change[m]:',pheromone_change[m])
|
#print('pheromone_change[m]:',pheromone_change[m])
|
||||||
|
pheromone_mat[k]=(1-atten[k])*pheromone_mat[k]+pheromone_change[k]
|
||||||
pheromone_mat[m]=(1-atten)*pheromone_mat[m]+pheromone_change[m]
|
|
||||||
|
|
||||||
count_iter += 1
|
count_iter += 1
|
||||||
|
|
||||||
print('count_iter:',count_iter)
|
#print('count_iter:',count_iter)
|
||||||
|
|
||||||
print('the largest value：',value_new)
|
#print('the largest value?',value_new)
|
||||||
|
|
||||||
print('the best road：',path_new)
|
|
||||||
|
|
||||||
#print('time_limit:',self.cut_time)
|
|
||||||
|
|
||||||
#print('time：',time)
|
|
||||||
|
|
||||||
return path_new
|
|
||||||
|
|
||||||
|
#print('the best road?',path_new)
|
||||||
|
print("ACO result:", path_new)
|
||||||
|
#self.task_assignment = task_assignment
|
||||||
|
end_time = time.time()
|
||||||
|
#self.cal_time = end_time - start_time
|
||||||
|
print("ACO time:", end_time - start_time)
|
||||||
|
return path_new, end_time - start_time
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -3,6 +3,11 @@ import matplotlib.pyplot as plt
|
||||||
import random
|
import random
|
||||||
import time
|
import time
|
||||||
import pandas as pd
|
import pandas as pd
|
||||||
|
import copy
|
||||||
|
from multiprocessing import Pool
|
||||||
|
from ga import GA
|
||||||
|
from aco import ACO
|
||||||
|
from pso import PSO
|
||||||
|
|
||||||
class Env():
|
class Env():
|
||||||
def __init__(self, vehicle_num, target_num, map_size, visualized=True, time_cost=None, repeat_cost=None):
|
def __init__(self, vehicle_num, target_num, map_size, visualized=True, time_cost=None, repeat_cost=None):
|
||||||
|
|
@ -12,7 +17,7 @@ class Env():
|
||||||
self.map_size = map_size
|
self.map_size = map_size
|
||||||
self.speed_range = [10, 15, 30]
|
self.speed_range = [10, 15, 30]
|
||||||
#self.time_lim = 1e6
|
#self.time_lim = 1e6
|
||||||
self.time_lim = self.map_size / self.speed_range[1] * 2
|
self.time_lim = self.map_size / self.speed_range[1]
|
||||||
self.vehicles_lefttime = np.ones(vehicle_num,dtype=np.float32) * self.time_lim
|
self.vehicles_lefttime = np.ones(vehicle_num,dtype=np.float32) * self.time_lim
|
||||||
self.distant_mat = np.zeros((target_num+1,target_num+1),dtype=np.float32)
|
self.distant_mat = np.zeros((target_num+1,target_num+1),dtype=np.float32)
|
||||||
self.total_reward = 0
|
self.total_reward = 0
|
||||||
|
|
@ -21,7 +26,7 @@ class Env():
|
||||||
self.time = 0
|
self.time = 0
|
||||||
self.time_cost = time_cost
|
self.time_cost = time_cost
|
||||||
self.repeat_cost = repeat_cost
|
self.repeat_cost = repeat_cost
|
||||||
self.done = False
|
self.end = False
|
||||||
self.assignment = [[] for i in range(vehicle_num)]
|
self.assignment = [[] for i in range(vehicle_num)]
|
||||||
self.task_generator()
|
self.task_generator()
|
||||||
|
|
||||||
|
|
@ -37,29 +42,30 @@ class Env():
|
||||||
for i in range(self.targets.shape[0]):
|
for i in range(self.targets.shape[0]):
|
||||||
for j in range(self.targets.shape[0]):
|
for j in range(self.targets.shape[0]):
|
||||||
self.distant_mat[i,j] = np.linalg.norm(self.targets[i,:2]-self.targets[j,:2])
|
self.distant_mat[i,j] = np.linalg.norm(self.targets[i,:2]-self.targets[j,:2])
|
||||||
|
self.targets_value = copy.deepcopy((self.targets[:,2]))
|
||||||
|
|
||||||
def step(self, action):
|
def step(self, action):
|
||||||
count = 0
|
count = 0
|
||||||
for j in range(len(self.action)):
|
for j in range(len(action)):
|
||||||
k = self.action[j]
|
k = action[j]
|
||||||
delta_time = self.distant_mat[self.vehicles_position[j],k] / self.vehicles_speed[j] + self.targets[k,3]
|
delta_time = self.distant_mat[self.vehicles_position[j],k] / self.vehicles_speed[j] + self.targets[k,3]
|
||||||
self.vehicles_lefttime[j] = self.vehicles_lefttime[j] - delta_time
|
self.vehicles_lefttime[j] = self.vehicles_lefttime[j] - delta_time
|
||||||
if self.vehicles_lefttime < 0:
|
if self.vehicles_lefttime[j] < 0:
|
||||||
count = count + 1
|
count = count + 1
|
||||||
continue
|
continue
|
||||||
else:
|
else:
|
||||||
if k == 0:
|
if k == 0:
|
||||||
self.reward = - self.repeat_cost
|
self.reward = - self.repeat_cost
|
||||||
else:
|
else:
|
||||||
self.reward = self.targets[k,2] - delta_time * self.time_cost
|
self.reward = self.targets[k,2] - delta_time * self.time_cost + self.targets[k,2]
|
||||||
if self.targets[k,2] == 0:
|
if self.targets[k,2] == 0:
|
||||||
self.total_reward = self.total_reward - self.repeat_cost
|
self.reward = self.reward - self.repeat_cost
|
||||||
self.vehicles_position[j] = k
|
self.vehicles_position[j] = k
|
||||||
self.targets[k,2] = 0
|
self.targets[k,2] = 0
|
||||||
self.total_reward = self.total_reward + self.rewards
|
self.total_reward = self.total_reward + self.reward
|
||||||
self.assignment[j].append(action)
|
self.assignment[j].append(action)
|
||||||
if count == len(self.action):
|
if count == len(action):
|
||||||
self.done = True
|
self.end = True
|
||||||
|
|
||||||
def run(self, assignment, algorithm):
|
def run(self, assignment, algorithm):
|
||||||
self.assignment = assignment
|
self.assignment = assignment
|
||||||
|
|
@ -68,19 +74,29 @@ class Env():
|
||||||
if self.visualized:
|
if self.visualized:
|
||||||
self.visualize()
|
self.visualize()
|
||||||
|
|
||||||
|
def reset(self):
|
||||||
|
self.vehicles_position = np.zeros(self.vehicles_position.shape[0],dtype=np.int32)
|
||||||
|
self.vehicles_lefttime = np.ones(self.vehicles_position.shape[0],dtype=np.float32) * self.time_lim
|
||||||
|
self.targets[:,2] = self.targets_value
|
||||||
|
self.total_reward = 0
|
||||||
|
self.reward = 0
|
||||||
|
self.end = False
|
||||||
|
|
||||||
def get_total_reward(self):
|
def get_total_reward(self):
|
||||||
for i in range(len(self.assignment)):
|
for i in range(len(self.assignment)):
|
||||||
speed = self.vehicles_speed[i]
|
speed = self.vehicles_speed[i]
|
||||||
for j in range(len(self.assignment[i])):
|
for j in range(len(self.assignment[i])):
|
||||||
k = self.assignment[i][j]
|
position = self.targets[self.assignment[i][j],:4]
|
||||||
self.total_reward = self.total_reward + self.targets[k,2]
|
self.total_reward = self.total_reward + position[2]
|
||||||
self.vehicles_lefttime[i] = self.vehicles_lefttime[i] - self.distant_mat[self.vehicles_position[i],k] / speed - self.targets[k,3]
|
if j == 0:
|
||||||
if self.vehicles_lefttime[i] < 0:
|
self.vehicles_lefttime[i] = self.vehicles_lefttime[i] - np.linalg.norm(position[:2]) / speed - position[3]
|
||||||
self.done = True
|
else:
|
||||||
|
self.vehicles_lefttime[i] = self.vehicles_lefttime[i] - np.linalg.norm(position[:2]-position_last[:2]) / speed - position[3]
|
||||||
|
position_last = position
|
||||||
|
if self.vehicles_lefttime[i] > self.time_lim:
|
||||||
|
self.end = True
|
||||||
break
|
break
|
||||||
self.vehicles_position[i] = k
|
if self.end:
|
||||||
if self.done:
|
|
||||||
self.total_reward = 0
|
self.total_reward = 0
|
||||||
break
|
break
|
||||||
|
|
||||||
|
|
@ -104,6 +120,76 @@ class Env():
|
||||||
plt.show()
|
plt.show()
|
||||||
|
|
||||||
if __name__=='__main__':
|
if __name__=='__main__':
|
||||||
|
# Test 1
|
||||||
|
p = Pool(2)
|
||||||
|
vehicle_num = 5
|
||||||
|
target_num = 30
|
||||||
|
map_size = 5e3
|
||||||
|
env = Env(vehicle_num,target_num,map_size,visualized=True)
|
||||||
|
ga = GA(vehicle_num,env.vehicles_speed,target_num,env.targets,env.time_lim)
|
||||||
|
aco = ACO(vehicle_num,target_num,env.vehicles_speed,env.targets,env.time_lim)
|
||||||
|
pso = PSO(vehicle_num,target_num ,env.targets,env.vehicles_speed,env.time_lim)
|
||||||
|
ga_result = p.apply_async(ga.run)
|
||||||
|
#aco_result = p.apply_async(aco.run)
|
||||||
|
pso_result = p.apply_async(pso.run)
|
||||||
|
p.close()
|
||||||
|
p.join()
|
||||||
|
ga_task_assignmet = ga_result.get()[0]
|
||||||
|
env.run(ga_task_assignmet,'GA')
|
||||||
|
#env.reset()
|
||||||
|
#aco_task_assignmet = aco_result.get()[0]
|
||||||
|
#env.run(aco_task_assignmet,'ACO')
|
||||||
|
env.reset()
|
||||||
|
pso_task_assignmet = pso_result.get()[0]
|
||||||
|
env.run(pso_task_assignmet,'PSO')
|
||||||
|
|
||||||
|
# Test 2
|
||||||
|
p = Pool(2)
|
||||||
|
vehicle_num = 10
|
||||||
|
target_num = 60
|
||||||
|
map_size = 1e4
|
||||||
|
env = Env(vehicle_num,target_num,map_size,visualized=True)
|
||||||
|
ga = GA(vehicle_num,env.vehicles_speed,target_num,env.targets,env.time_lim)
|
||||||
|
#aco = ACO(vehicle_num,target_num,env.vehicles_speed,env.targets,env.time_lim)
|
||||||
|
pso = PSO(vehicle_num,target_num ,env.targets,env.vehicles_speed,env.time_lim)
|
||||||
|
ga_result = p.apply_async(ga.run)
|
||||||
|
#aco_result = p.apply_async(aco.run)
|
||||||
|
pso_result = p.apply_async(pso.run)
|
||||||
|
p.close()
|
||||||
|
p.join()
|
||||||
|
ga_task_assignmet = ga_result.get()[0]
|
||||||
|
env.run(ga_task_assignmet,'GA')
|
||||||
|
#env.reset()
|
||||||
|
#aco_task_assignmet = ga_result.get()[0]
|
||||||
|
#env.run(aco_task_assignmet,'ACO')
|
||||||
|
env.reset()
|
||||||
|
pso_task_assignmet = pso_result.get()[0]
|
||||||
|
env.run(pso_task_assignmet,'PSO')
|
||||||
|
|
||||||
|
# Test 3
|
||||||
|
p = Pool(2)
|
||||||
|
vehicle_num = 15
|
||||||
|
target_num = 90
|
||||||
|
map_size = 1.5e4
|
||||||
|
env = Env(vehicle_num,target_num,map_size,visualized=True)
|
||||||
|
ga = GA(vehicle_num,env.vehicles_speed,target_num,env.targets,env.time_lim)
|
||||||
|
#aco = ACO(vehicle_num,target_num,env.vehicles_speed,env.targets,env.time_lim)
|
||||||
|
pso = PSO(vehicle_num,target_num ,env.targets,env.vehicles_speed,env.time_lim)
|
||||||
|
ga_result = p.apply_async(ga.run)
|
||||||
|
#aco_result = p.apply_async(aco.run)
|
||||||
|
pso_result = p.apply_async(pso.run)
|
||||||
|
p.close()
|
||||||
|
p.join()
|
||||||
|
ga_task_assignmet = ga_result.get()[0]
|
||||||
|
env.run(ga_task_assignmet,'GA')
|
||||||
|
#env.reset()
|
||||||
|
#aco_task_assignmet = ga_result.get()[0]
|
||||||
|
#env.run(aco_task_assignmet,'ACO')
|
||||||
|
env.reset()
|
||||||
|
pso_task_assignmet = pso_result.get()[0]
|
||||||
|
env.run(pso_task_assignmet,'PSO')
|
||||||
|
|
||||||
|
'''
|
||||||
time_record = []
|
time_record = []
|
||||||
reward_record = []
|
reward_record = []
|
||||||
for i in range(100):
|
for i in range(100):
|
||||||
|
|
@ -120,3 +206,4 @@ if __name__=='__main__':
|
||||||
reward_record.append(env.total_reward)
|
reward_record.append(env.total_reward)
|
||||||
dataframe = pd.DataFrame({'time':time_record,'reward':reward_record})
|
dataframe = pd.DataFrame({'time':time_record,'reward':reward_record})
|
||||||
dataframe.to_csv(algorithm+'.csv',sep=',')
|
dataframe.to_csv(algorithm+'.csv',sep=',')
|
||||||
|
'''
|
||||||
|
|
@ -1,161 +1,179 @@
|
||||||
import numpy as np
|
import numpy as np
|
||||||
import random
|
import random
|
||||||
|
import time
|
||||||
|
import os
|
||||||
|
|
||||||
|
|
||||||
class ga():
|
class GA():
|
||||||
def __init__(self,vehicle_num,vehicles_speed,target_num,targets,time_lim):
|
def __init__(self, vehicle_num, vehicles_speed, target_num, targets, time_lim):
|
||||||
#vehicles_speed,targets in the type of narray
|
# vehicles_speed,targets in the type of narray
|
||||||
self.vehicle_num=vehicle_num
|
self.vehicle_num = vehicle_num
|
||||||
self.vehicles_speed=vehicles_speed
|
self.vehicles_speed = vehicles_speed
|
||||||
self.target_num=target_num
|
self.target_num = target_num
|
||||||
self.targets=targets
|
self.targets = targets
|
||||||
self.time_lim=time_lim
|
self.time_lim = time_lim
|
||||||
self.map=np.zeros(shape=(target_num+1,target_num+1),dtype=float)
|
self.map = np.zeros(shape=(target_num+1, target_num+1), dtype=float)
|
||||||
self.pop_size=100
|
self.pop_size = 50
|
||||||
self.p_cross=0.6
|
self.p_cross = 0.6
|
||||||
self.p_mutate=0.005
|
self.p_mutate = 0.005
|
||||||
for i in range(target_num+1):
|
for i in range(target_num+1):
|
||||||
self.map[i,i]=0
|
self.map[i, i] = 0
|
||||||
for j in range(i):
|
for j in range(i):
|
||||||
self.map[j,i]=self.map[i,j]=np.linalg.norm(targets[i,:2]-targets[j,:2])
|
self.map[j, i] = self.map[i, j] = np.linalg.norm(
|
||||||
self.pop=np.zeros(shape=(self.pop_size,vehicle_num-1+target_num-1),dtype=np.int32)
|
targets[i, :2]-targets[j, :2])
|
||||||
self.ff=np.zeros(self.pop_size,dtype=float)
|
self.pop = np.zeros(
|
||||||
for i in range(self.pop_size):
|
shape=(self.pop_size, vehicle_num-1+target_num-1), dtype=np.int32)
|
||||||
for j in range(vehicle_num-1):
|
self.ff = np.zeros(self.pop_size, dtype=float)
|
||||||
self.pop[i,j]=random.randint(0,target_num)
|
for i in range(self.pop_size):
|
||||||
for j in range(target_num-1):
|
for j in range(vehicle_num-1):
|
||||||
self.pop[i,vehicle_num+j-1]=random.randint(0,target_num-j-1)
|
self.pop[i, j] = random.randint(0, target_num)
|
||||||
self.ff[i]=self.fitness(self.pop[i,:])
|
for j in range(target_num-1):
|
||||||
self.tmp_pop=np.array([])
|
self.pop[i, vehicle_num+j -
|
||||||
self.tmp_ff=np.array([])
|
1] = random.randint(0, target_num-j-1)
|
||||||
self.tmp_size=0
|
self.ff[i] = self.fitness(self.pop[i, :])
|
||||||
|
self.tmp_pop = np.array([])
|
||||||
|
self.tmp_ff = np.array([])
|
||||||
|
self.tmp_size = 0
|
||||||
|
|
||||||
def fitness(self,gene):
|
def fitness(self, gene):
|
||||||
ins=np.zeros(self.target_num+1,dtype=np.int32)
|
ins = np.zeros(self.target_num+1, dtype=np.int32)
|
||||||
seq=np.zeros(self.target_num,dtype=np.int32)
|
seq = np.zeros(self.target_num, dtype=np.int32)
|
||||||
ins[self.target_num]=1
|
ins[self.target_num] = 1
|
||||||
for i in range(self.vehicle_num-1):
|
for i in range(self.vehicle_num-1):
|
||||||
ins[gene[i]]+=1
|
ins[gene[i]] += 1
|
||||||
rest=np.array(range(1,self.target_num+1))
|
rest = np.array(range(1, self.target_num+1))
|
||||||
for i in range(self.target_num-1):
|
for i in range(self.target_num-1):
|
||||||
seq[i]=rest[gene[i+self.vehicle_num-1]]
|
seq[i] = rest[gene[i+self.vehicle_num-1]]
|
||||||
rest=np.delete(rest,gene[i+self.vehicle_num-1])
|
rest = np.delete(rest, gene[i+self.vehicle_num-1])
|
||||||
seq[self.target_num-1]=rest[0]
|
seq[self.target_num-1] = rest[0]
|
||||||
i=0 #index of vehicle
|
i = 0 # index of vehicle
|
||||||
pre=0 #index of last target
|
pre = 0 # index of last target
|
||||||
post=0 #index of ins/seq
|
post = 0 # index of ins/seq
|
||||||
t=0
|
t = 0
|
||||||
reward=0
|
reward = 0
|
||||||
while i<self.vehicle_num:
|
while i < self.vehicle_num:
|
||||||
if ins[post]>0:
|
if ins[post] > 0:
|
||||||
i+=1
|
i += 1
|
||||||
ins[post]-=1
|
ins[post] -= 1
|
||||||
pre=0
|
pre = 0
|
||||||
t=0
|
t = 0
|
||||||
else:
|
else:
|
||||||
t+=self.targets[pre,3]
|
t += self.targets[pre, 3]
|
||||||
past=self.map[pre,seq[post]]/self.vehicles_speed[i]
|
past = self.map[pre, seq[post]]/self.vehicles_speed[i]
|
||||||
t+=past
|
t += past
|
||||||
if t<self.time_lim:
|
if t < self.time_lim:
|
||||||
reward+=self.targets[seq[post],2]
|
reward += self.targets[seq[post], 2]
|
||||||
pre=seq[post]
|
pre = seq[post]
|
||||||
post+=1
|
post += 1
|
||||||
return reward
|
return reward
|
||||||
|
|
||||||
def selection(self):
|
def selection(self):
|
||||||
roll=np.zeros(self.tmp_size,dtype=float)
|
roll = np.zeros(self.tmp_size, dtype=float)
|
||||||
roll[0]=self.tmp_ff[0]
|
roll[0] = self.tmp_ff[0]
|
||||||
for i in range(1,self.tmp_size):
|
for i in range(1, self.tmp_size):
|
||||||
roll[i]=roll[i-1]+self.tmp_ff[i]
|
roll[i] = roll[i-1]+self.tmp_ff[i]
|
||||||
for i in range(self.pop_size):
|
for i in range(self.pop_size):
|
||||||
xx=random.uniform(0,roll[self.tmp_size-1])
|
xx = random.uniform(0, roll[self.tmp_size-1])
|
||||||
j=0
|
j = 0
|
||||||
while xx>roll[j]:
|
while xx > roll[j]:
|
||||||
j+=1
|
j += 1
|
||||||
self.pop[i,:]=self.tmp_pop[j,:]
|
self.pop[i, :] = self.tmp_pop[j, :]
|
||||||
self.ff[i]=self.tmp_ff[j]
|
self.ff[i] = self.tmp_ff[j]
|
||||||
|
|
||||||
def mutation(self):
|
def mutation(self):
|
||||||
for i in range(self.tmp_size):
|
for i in range(self.tmp_size):
|
||||||
flag=False
|
flag = False
|
||||||
for j in range(self.vehicle_num-1):
|
for j in range(self.vehicle_num-1):
|
||||||
if random.random()<self.p_mutate:
|
if random.random() < self.p_mutate:
|
||||||
self.tmp_pop[i,j]=random.randint(0,self.target_num)
|
self.tmp_pop[i, j] = random.randint(0, self.target_num)
|
||||||
flag=True
|
flag = True
|
||||||
for j in range(self.target_num-1):
|
for j in range(self.target_num-1):
|
||||||
if random.random()<self.p_mutate:
|
if random.random() < self.p_mutate:
|
||||||
self.tmp_pop[i,self.vehicle_num+j-1]=random.randint(0,self.target_num-j-1)
|
self.tmp_pop[i, self.vehicle_num+j -
|
||||||
flag=True
|
1] = random.randint(0, self.target_num-j-1)
|
||||||
if flag:
|
flag = True
|
||||||
self.tmp_ff[i]=self.fitness(self.tmp_pop[i,:])
|
if flag:
|
||||||
|
self.tmp_ff[i] = self.fitness(self.tmp_pop[i, :])
|
||||||
|
|
||||||
def crossover(self):
|
def crossover(self):
|
||||||
new_pop=[]
|
new_pop = []
|
||||||
new_ff=[]
|
new_ff = []
|
||||||
new_size=0
|
new_size = 0
|
||||||
for i in range(0,self.pop_size,2):
|
for i in range(0, self.pop_size, 2):
|
||||||
if random.random()<self.p_cross:
|
if random.random() < self.p_cross:
|
||||||
x1=random.randint(0,self.vehicle_num-2)
|
x1 = random.randint(0, self.vehicle_num-2)
|
||||||
x2=random.randint(0,self.target_num-2)+self.vehicle_num
|
x2 = random.randint(0, self.target_num-2)+self.vehicle_num
|
||||||
g1=self.pop[i,:]
|
g1 = self.pop[i, :]
|
||||||
g2=self.pop[i+1,:]
|
g2 = self.pop[i+1, :]
|
||||||
g1[x1:x2]=self.pop[i+1,x1:x2]
|
g1[x1:x2] = self.pop[i+1, x1:x2]
|
||||||
g2[x1:x2]=self.pop[i,x1:x2]
|
g2[x1:x2] = self.pop[i, x1:x2]
|
||||||
new_pop.append(g1)
|
new_pop.append(g1)
|
||||||
new_pop.append(g2)
|
new_pop.append(g2)
|
||||||
new_ff.append(self.fitness(g1))
|
new_ff.append(self.fitness(g1))
|
||||||
new_ff.append(self.fitness(g2))
|
new_ff.append(self.fitness(g2))
|
||||||
new_size+=2
|
new_size += 2
|
||||||
self.tmp_size=self.pop_size+new_size
|
self.tmp_size = self.pop_size+new_size
|
||||||
self.tmp_pop=np.zeros(shape=(self.tmp_size,self.vehicle_num-1+self.target_num-1),dtype=np.int32)
|
self.tmp_pop = np.zeros(
|
||||||
self.tmp_pop[0:self.pop_size,:]=self.pop
|
shape=(self.tmp_size, self.vehicle_num-1+self.target_num-1), dtype=np.int32)
|
||||||
self.tmp_pop[self.pop_size:self.tmp_size,:]=np.array(new_pop)
|
self.tmp_pop[0:self.pop_size, :] = self.pop
|
||||||
self.tmp_ff=np.zeros(self.tmp_size,dtype=float)
|
self.tmp_pop[self.pop_size:self.tmp_size, :] = np.array(new_pop)
|
||||||
self.tmp_ff[0:self.pop_size]=self.ff
|
self.tmp_ff = np.zeros(self.tmp_size, dtype=float)
|
||||||
self.tmp_ff[self.pop_size:self.tmp_size]=np.array(new_ff)
|
self.tmp_ff[0:self.pop_size] = self.ff
|
||||||
|
self.tmp_ff[self.pop_size:self.tmp_size] = np.array(new_ff)
|
||||||
|
|
||||||
def run(self):
|
def run(self):
|
||||||
cut=0
|
print("GA start, pid: %s" % os.getpid())
|
||||||
e=self.tmp_ff>cut
|
start_time = time.time()
|
||||||
while e.sum()<=self.tmp_size*0.5:
|
cut = 0
|
||||||
self.crossover()
|
count = 0
|
||||||
self.mutation()
|
while count < 500:
|
||||||
self.selection()
|
self.crossover()
|
||||||
cut=self.tmp_ff.max()*0.9
|
self.mutation()
|
||||||
e=self.tmp_ff>cut
|
self.selection()
|
||||||
i=0
|
new_cut = self.tmp_ff.max()
|
||||||
for j in range(self.tmp_size):
|
if cut < new_cut:
|
||||||
if self.tmp_ff[i]<self.tmp_ff[j]:
|
cut = new_cut
|
||||||
i=j
|
count = 0
|
||||||
gene=self.tmp_pop[i]
|
gene = self.tmp_pop[np.argmax(self.tmp_ff)]
|
||||||
|
else:
|
||||||
|
count += 1
|
||||||
|
#print(cut)
|
||||||
|
|
||||||
ins=np.zeros(self.target_num+1,dtype=np.int32)
|
ins = np.zeros(self.target_num+1, dtype=np.int32)
|
||||||
seq=np.zeros(self.target_num,dtype=np.int32)
|
seq = np.zeros(self.target_num, dtype=np.int32)
|
||||||
ins[self.target_num]=1
|
ins[self.target_num] = 1
|
||||||
for i in range(self.vehicle_num-1):
|
for i in range(self.vehicle_num-1):
|
||||||
ins[gene[i]]+=1
|
ins[gene[i]] += 1
|
||||||
rest=np.array(range(1,self.target_num+1))
|
rest = np.array(range(1, self.target_num+1))
|
||||||
for i in range(self.target_num-1):
|
for i in range(self.target_num-1):
|
||||||
seq[i]=rest[gene[i+self.vehicle_num-1]]
|
seq[i] = rest[gene[i+self.vehicle_num-1]]
|
||||||
rest=np.delete(rest,gene[i+self.vehicle_num-1])
|
rest = np.delete(rest, gene[i+self.vehicle_num-1])
|
||||||
seq[self.target_num-1]=rest[0]
|
seq[self.target_num-1] = rest[0]
|
||||||
task_assignment=[[] for i in range(self.vehicle_num)]
|
task_assignment = [[] for i in range(self.vehicle_num)]
|
||||||
i=0 #index of vehicle
|
i = 0 # index of vehicle
|
||||||
pre=0 #index of last target
|
pre = 0 # index of last target
|
||||||
post=0 #index of ins/seq
|
post = 0 # index of ins/seq
|
||||||
t=0
|
t = 0
|
||||||
while i<self.vehicle_num:
|
reward = 0
|
||||||
if ins[post]>0:
|
while i < self.vehicle_num:
|
||||||
i+=1
|
if ins[post] > 0:
|
||||||
ins[post]-=1
|
i += 1
|
||||||
pre=0
|
ins[post] -= 1
|
||||||
t=0
|
pre = 0
|
||||||
else:
|
t = 0
|
||||||
t+=self.targets[pre,3]
|
else:
|
||||||
past=self.map[pre,seq[post]]/self.vehicles_speed[i]
|
t += self.targets[pre, 3]
|
||||||
t+=past
|
past = self.map[pre, seq[post]]/self.vehicles_speed[i]
|
||||||
if t<self.time_lim:
|
t += past
|
||||||
task_assignment[i].append(seq[post])
|
if t < self.time_lim:
|
||||||
pre=seq[post]
|
task_assignment[i].append(seq[post])
|
||||||
post+=1
|
reward += self.targets[seq[post], 2]
|
||||||
return task_assignment
|
pre = seq[post]
|
||||||
|
post += 1
|
||||||
|
#print(reward)
|
||||||
|
print("GA result:", task_assignment)
|
||||||
|
#self.task_assignment = task_assignment
|
||||||
|
end_time = time.time()
|
||||||
|
#self.cal_time = end_time - start_time
|
||||||
|
print("GA time:", end_time - start_time)
|
||||||
|
return task_assignment, end_time - start_time
|
||||||
|
|
|
||||||
|
|
@ -1,289 +1,387 @@
|
||||||
# coding: utf-8
|
# coding: utf-8
|
||||||
import numpy as np
|
import numpy as np
|
||||||
import random
|
import random
|
||||||
import matplotlib.pyplot as plt
|
|
||||||
import math
|
import math
|
||||||
import cmath
|
import cmath
|
||||||
from environment import Env
|
import time
|
||||||
# ----------------------优化方案----------------------------------
|
import os
|
||||||
# 发现粒子群算法优化结果不好，收敛没有到全局最优
|
# ----------------------Optimization scheme----------------------------------
|
||||||
# 优化思路：1. 增加收敛因子k；2. 动态改变惯性因子w
|
# Optimization ideas：
|
||||||
|
# 1. Increase the convergence factor k；
|
||||||
|
# 2. Dynamic change of inertia factor W；
|
||||||
|
# 3. Using PSO local search algorithm(Ring method)
|
||||||
|
# 4. The probability of position variation is added
|
||||||
|
# ----------------------Set PSO Parameter---------------------------------
|
||||||
|
|
||||||
|
|
||||||
# ----------------------PSO参数设置---------------------------------
|
|
||||||
class PSO():
|
class PSO():
|
||||||
def __init__(self, pN, dim, max_iter,uav_num,Distance,
|
def __init__(self, uav_num, target_num, targets, vehicles_speed, time_lim):
|
||||||
v,Value,test_num,time_all):
|
self.uav_num = uav_num
|
||||||
|
self.dim = target_num
|
||||||
|
self.targets = targets
|
||||||
|
self.vehicles_speed = vehicles_speed
|
||||||
|
self.time_all = time_lim
|
||||||
|
self.pN = 2*(self.uav_num+self.dim) # Number of particles
|
||||||
|
self.max_iter = 0 # Number of iterations
|
||||||
|
# Target distance list (dim+1）*（dim+1)
|
||||||
|
self.Distance = np.zeros((target_num+1, target_num+1))
|
||||||
|
self.Value = np.zeros(target_num+1) # Value list of targets 1*dim+1
|
||||||
|
self.Stay_time = []
|
||||||
|
# UAV flight speed matrix
|
||||||
self.w = 0.8
|
self.w = 0.8
|
||||||
self.c1 = 2
|
self.c1 = 2
|
||||||
self.c2 = 2
|
self.c2 = 2
|
||||||
self.r1 = 0.6
|
self.r1 = 0.6
|
||||||
self.r2 = 0.3
|
self.r2 = 0.3
|
||||||
self.pN = pN # 方案数量
|
self.k = 0 # Convergence factor
|
||||||
self.dim = dim # 方案维度
|
self.wini = 0.9
|
||||||
self.max_iter = max_iter # 迭代次数
|
self.wend = 0.4
|
||||||
self.X = np.zeros((self.pN, self.dim)) # 所有粒子的位置
|
|
||||||
self.V = np.zeros((self.pN, self.dim)) # 所有粒子的速度
|
self.X = np.zeros((self.pN, self.dim+self.uav_num-1)
|
||||||
self.pbest = np.zeros((self.pN, self.dim)) # 个体经历的最佳位置
|
) # Position of all particles
|
||||||
self.gbest = np.zeros((1, self.dim)) # 个体经历的全局最佳位置
|
self.V = np.zeros((self.pN, self.dim+self.uav_num-1)
|
||||||
self.p_fit = np.zeros(self.pN) # 每个个体的历史最佳适应值
|
) # Velocity of all particles
|
||||||
self.fit = 0 # 全局最佳适应值
|
# The historical optimal position of each individual
|
||||||
self.uav_num=uav_num
|
self.pbest = np.zeros((self.pN, self.dim+self.uav_num-1))
|
||||||
self.time_all=time_all
|
self.gbest = np.zeros((1, self.dim+self.uav_num-1))
|
||||||
self.Distance=Distance # Distance是(dim+1）*（dim+1)的对称矩阵
|
# Global optimal position
|
||||||
self.v=v # 无人机真正飞行速度 m/s
|
self.gbest_ring = np.zeros((self.pN, self.dim+self.uav_num-1))
|
||||||
self.Value=Value # 目标位置的价值数组 1*dim
|
# Historical optimal fitness of each individual
|
||||||
self.TEST=[]
|
self.p_fit = np.zeros(self.pN)
|
||||||
self.test_num=test_num
|
self.fit = 0 # Global optimal fitness
|
||||||
self.dim1=dim
|
self.ring = []
|
||||||
self.add_num=0
|
self.ring_fit = np.zeros(self.pN)
|
||||||
self.time_all=time_all
|
# variation parameter
|
||||||
self.k=0 # 收敛因子
|
self.p1 = 0.4 # Probability of mutation
|
||||||
self.wini=0.9
|
self.p2 = 0.5 # Proportion of individuals with variation in population
|
||||||
self.wend=0.4
|
self.p3 = 0.5 # Proportion of locations where variation occurs
|
||||||
# --------------------取整---------------------------------
|
self.TEST = []
|
||||||
def fun_Ceil(self):
|
self.test_num = 0
|
||||||
num1=self.dim/self.uav_num
|
self.uav_best = []
|
||||||
num1=math.ceil(num1)
|
|
||||||
dim1=num1*self.uav_num
|
self.time_out = np.zeros(self.uav_num)
|
||||||
num1=dim1-self.dim
|
|
||||||
self.add_num=num1
|
self.cal_time = 0
|
||||||
self.dim1=dim1
|
# ------------------Get Initial parameter------------------
|
||||||
# -------------------排序式转排列式--------------------------
|
|
||||||
def position(self,X):
|
def fun_get_initial_parameter(self):
|
||||||
Position_All=list(range(1,self.dim+1))
|
# self.max_iter=1000
|
||||||
X2=[]
|
self.max_iter = 40*(self.uav_num+self.dim)
|
||||||
|
if self.max_iter > 4100:
|
||||||
|
self.max_iter = 4100
|
||||||
|
|
||||||
|
# self.test_num=10000
|
||||||
|
# Get Stay_time Arrary & Distance Arrary & Value Arrary
|
||||||
|
Targets = self.targets
|
||||||
|
self.Stay_time = Targets[:, 3]
|
||||||
|
self.Distance = np.zeros((self.dim+1, self.dim+1))
|
||||||
|
self.Value = np.zeros(self.dim+1)
|
||||||
|
for i in range(self.dim+1):
|
||||||
|
self.Value[i] = Targets[i, 2]
|
||||||
|
for j in range(i):
|
||||||
|
self.Distance[i][j] = (
|
||||||
|
Targets[i, 0]-Targets[j, 0])*(Targets[i, 0]-Targets[j, 0])
|
||||||
|
self.Distance[i][j] = self.Distance[i][j] + \
|
||||||
|
(Targets[i, 1]-Targets[j, 1])*(Targets[i, 1]-Targets[j, 1])
|
||||||
|
self.Distance[i][j] = math.sqrt(self.Distance[i][j])
|
||||||
|
self.Distance[j][i] = self.Distance[i][j]
|
||||||
|
# ------------------Transfer_Function---------------------
|
||||||
|
|
||||||
|
def fun_Transfer(self, X):
|
||||||
|
# Converting continuous sequence X into discrete sequence X_path
|
||||||
|
X1 = X[0:self.dim]
|
||||||
|
X_path = []
|
||||||
|
l1 = len(X1)
|
||||||
|
for i in range(l1):
|
||||||
|
m = X1[i]*(self.dim-i)
|
||||||
|
m = math.floor(m)
|
||||||
|
X_path.append(m)
|
||||||
|
# Converting the continuous interpolation sequence X into discrete interpolation sequence X_rank
|
||||||
|
X2 = X[self.dim:]
|
||||||
|
l1 = len(X2)
|
||||||
|
X_rank = []
|
||||||
|
for i in range(l1):
|
||||||
|
|
||||||
|
m = X2[i]*(self.dim+1)
|
||||||
|
|
||||||
|
m1 = math.floor(m)
|
||||||
|
X_rank.append(m1)
|
||||||
|
# Rank and Complement
|
||||||
|
c = sorted(X_rank)
|
||||||
|
l1 = len(c)
|
||||||
|
Rank = []
|
||||||
|
Rank.append(0)
|
||||||
|
for i in range(l1):
|
||||||
|
Rank.append(c[i])
|
||||||
|
Rank.append(self.dim)
|
||||||
|
# Get Separate_Arrary
|
||||||
|
Sep = []
|
||||||
|
for i in range(l1+1):
|
||||||
|
sep = Rank[i+1]-Rank[i]
|
||||||
|
Sep.append(sep)
|
||||||
|
return X_path, Sep
|
||||||
|
|
||||||
|
# -------------------Obtain the Real Flight Path Sequence of Particles--------------------------
|
||||||
|
def position(self, X):
|
||||||
|
Position_All = list(range(1, self.dim+1))
|
||||||
|
X2 = []
|
||||||
for i in range(self.dim):
|
for i in range(self.dim):
|
||||||
m1=X[i]
|
m1 = X[i]
|
||||||
m1=int(m1)
|
m1 = int(m1)
|
||||||
X2.append(Position_All[m1-1])
|
X2.append(Position_All[m1])
|
||||||
del Position_All[m1-1]
|
del Position_All[m1]
|
||||||
return X2
|
return X2
|
||||||
|
# ---------------------Fitness_Computing Function-----------------------------
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
# ---------------------目标函数-----------------------------
|
|
||||||
def function(self, X):
|
def function(self, X):
|
||||||
# X 是一个方案，x[i]
|
X_path, Sep = self.fun_Transfer(X)
|
||||||
# 由无人机排序式转为排列式
|
|
||||||
X=self.position(X)
|
# Obtain the Real Flight Path Sequence of Particles
|
||||||
# 把X扩充到可以整除的数组
|
X = self.position(X_path)
|
||||||
for i in range(self.add_num):
|
# Get the search sequence of each UAV
|
||||||
X.append(i+self.dim+1)
|
UAV = []
|
||||||
# 由方案导出五个无人机各自搜索路径
|
l = 0
|
||||||
UAV=[]
|
|
||||||
k=0
|
|
||||||
for i in range(self.uav_num):
|
for i in range(self.uav_num):
|
||||||
UAV.append([])
|
UAV.append([])
|
||||||
for j in range(self.dim1//self.uav_num):
|
k = Sep[i]
|
||||||
UAV[i].append(X[k])
|
for j in range(k):
|
||||||
k=k+1
|
UAV[i].append(X[l])
|
||||||
# 计算某一个方案的目标函数值
|
l = l+1
|
||||||
l1=len(UAV[0])
|
|
||||||
value=0
|
# Calculate Fitness
|
||||||
|
fitness = 0
|
||||||
for i in range(self.uav_num):
|
for i in range(self.uav_num):
|
||||||
t=self.Distance[0][UAV[i][0]]/self.v
|
k = Sep[i]
|
||||||
for j in range(l1-1):
|
t = 0
|
||||||
if t<=self.time_all:
|
for j in range(k):
|
||||||
d1=UAV[i][j]
|
m1 = UAV[i][j]
|
||||||
d2=UAV[i][j+1]
|
|
||||||
if d2<=self.dim:
|
|
||||||
distance=self.Distance[d1][d2]
|
|
||||||
t=t+distance/self.v
|
|
||||||
value=value+self.Value[UAV[i][j]-1]
|
|
||||||
return value
|
|
||||||
|
|
||||||
|
if j == 0:
|
||||||
|
t = t+self.Distance[0, m1] / \
|
||||||
|
self.vehicles_speed[i]+self.Stay_time[m1]
|
||||||
|
else:
|
||||||
|
m1 = UAV[i][j]
|
||||||
|
m2 = UAV[i][j-1]
|
||||||
|
t = t+self.Distance[m1][m2] / \
|
||||||
|
self.vehicles_speed[i]+self.Stay_time[m1]
|
||||||
|
if t <= self.time_all:
|
||||||
|
fitness = fitness+self.Value[m1]
|
||||||
|
return fitness
|
||||||
|
# ----------------------------variation-------------------------------------------
|
||||||
|
|
||||||
|
def variation_fun(self):
|
||||||
|
p1 = np.random.uniform(0, 1) # Probability of mutation
|
||||||
|
if p1 < self.p1:
|
||||||
|
for i in range(self.pN):
|
||||||
|
# Proportion of individuals with variation in population
|
||||||
|
p2 = np.random.uniform(0, 1)
|
||||||
|
if p2 < self.p2:
|
||||||
|
# Numbers of locations where variation occurs
|
||||||
|
m = int(self.p3*(self.dim+self.uav_num-1))
|
||||||
|
for j in range(m):
|
||||||
|
replace_position = math.floor(
|
||||||
|
np.random.uniform(0, 1)*(self.dim+self.uav_num-1))
|
||||||
|
replace_value = np.random.uniform(0, 1)
|
||||||
|
self.X[i][replace_position] = replace_value
|
||||||
|
# Update pbest & gbest
|
||||||
|
for i in range(self.pN):
|
||||||
|
temp = self.function(self.X[i])
|
||||||
|
self.ring_fit[i] = temp
|
||||||
|
if temp > self.p_fit[i]:
|
||||||
|
self.p_fit[i] = temp
|
||||||
|
self.pbest[i] = self.X[i]
|
||||||
|
# Update gbest
|
||||||
|
if self.p_fit[i] > self.fit:
|
||||||
|
self.gbest = self.X[i]
|
||||||
|
self.fit = self.p_fit[i]
|
||||||
|
|
||||||
|
# ---------------------Population Initialization----------------------------------
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
# ---------------------初始化种群----------------------------------
|
|
||||||
def init_Population(self):
|
def init_Population(self):
|
||||||
# 取整
|
# Initialization of position(X), speed(V), history optimal(pbest) and global optimal(gbest)
|
||||||
self.fun_Ceil()
|
|
||||||
# 初始化位置和历史最优、全局最优
|
|
||||||
for i in range(self.pN):
|
for i in range(self.pN):
|
||||||
for j in range(self.dim):
|
x = np.random.uniform(0, 1, self.dim+self.uav_num-1)
|
||||||
self.X[i][j] = int(random.randint(1,self.dim-j))
|
self.X[i, :] = x
|
||||||
#self.V[i][j] = random.uniform(0, 1)
|
v = np.random.uniform(0, 0.4, self.dim+self.uav_num-1)
|
||||||
|
self.V[i, :] = v
|
||||||
self.pbest[i] = self.X[i]
|
self.pbest[i] = self.X[i]
|
||||||
|
|
||||||
tmp = self.function(self.X[i])
|
tmp = self.function(self.X[i])
|
||||||
self.p_fit[i] = tmp
|
self.p_fit[i] = tmp
|
||||||
if tmp > self.fit:
|
if tmp > self.fit:
|
||||||
self.fit = tmp
|
self.fit = tmp
|
||||||
self.gbest = self.X[i]
|
self.gbest = self.X[i]
|
||||||
# 初始化速度
|
# Calculate the convergence factor k
|
||||||
|
phi = self.c1+self.c2
|
||||||
|
k = abs(phi*phi-4*phi)
|
||||||
|
k = cmath.sqrt(k)
|
||||||
|
k = abs(2-phi-k)
|
||||||
|
k = 2/k
|
||||||
|
self.k = k
|
||||||
|
# Initialize ring_matrix
|
||||||
for i in range(self.pN):
|
for i in range(self.pN):
|
||||||
for j in range(self.dim):
|
self.ring.append([])
|
||||||
self.V[i][j] =random.uniform(-0.3*(self.dim-j),0.3*(self.dim-j))
|
self.ring[i].append(i)
|
||||||
self.V[i][j]=int(self.V[i][j])
|
# Initialize test_set
|
||||||
# 计算收敛因子k
|
self.TEST = np.zeros((self.test_num, self.dim+self.uav_num-1))
|
||||||
phi=self.c1+self.c2
|
|
||||||
k=abs(phi*phi-4*phi)
|
|
||||||
k=cmath.sqrt(k)
|
|
||||||
k=abs(2-phi-k)
|
|
||||||
k=2/k
|
|
||||||
self.k=k
|
|
||||||
# 初始化测试集
|
|
||||||
for i in range(self.test_num):
|
for i in range(self.test_num):
|
||||||
self.TEST.append([])
|
test = np.random.uniform(0, 1, self.dim+self.uav_num-1)
|
||||||
for j in range(self.dim):
|
self.TEST[i, :] = test
|
||||||
self.TEST[i].append(int(random.randint(1,self.dim-j)))
|
|
||||||
|
|
||||||
#self.V[i][j] = random.uniform(0, 1)
|
# ----------------------Update Particle Position----------------------------------
|
||||||
|
|
||||||
|
|
||||||
# ----------------------更新粒子位置----------------------------------
|
|
||||||
|
|
||||||
def iterator(self):
|
def iterator(self):
|
||||||
fitness = []
|
fitness = []
|
||||||
|
fitness_old = 0
|
||||||
|
k = 0
|
||||||
for t in range(self.max_iter):
|
for t in range(self.max_iter):
|
||||||
# 更新惯性因子w
|
w = (self.wini-self.wend)*(self.max_iter-t)/self.max_iter+self.wend
|
||||||
w=(self.wini-self.wend)*(self.max_iter-t)/self.max_iter+self.wend # w的变化规律是线性递减的
|
self.w = w
|
||||||
self.w=w # 用计算出的w更新属性
|
# Variation
|
||||||
for i in range(self.pN): # 更新gbest\pbest
|
self.variation_fun()
|
||||||
|
l1 = len(self.ring[0])
|
||||||
|
# Local PSO algorithm
|
||||||
|
# Update ring_arrary
|
||||||
|
if l1 < self.pN:
|
||||||
|
if not(t % 2):
|
||||||
|
k = k+1
|
||||||
|
for i in range(self.pN):
|
||||||
|
m1 = i-k
|
||||||
|
if m1 < 0:
|
||||||
|
m1 = self.pN+m1
|
||||||
|
m2 = i+k
|
||||||
|
if m2 > self.pN-1:
|
||||||
|
m2 = m2-self.pN
|
||||||
|
self.ring[i].append(m1)
|
||||||
|
self.ring[i].append(m2)
|
||||||
|
# Update gbest_ring
|
||||||
|
l_ring = len(self.ring[0])
|
||||||
|
for i in range(self.pN):
|
||||||
|
fitness1 = 0
|
||||||
|
for j in range(l_ring):
|
||||||
|
m1 = self.ring[i][j]
|
||||||
|
fitness2 = self.ring_fit[m1]
|
||||||
|
if fitness2 > fitness1:
|
||||||
|
self.gbest_ring[i] = self.X[m1]
|
||||||
|
fitness1 = fitness2
|
||||||
|
# Update velocity
|
||||||
|
for i in range(self.pN):
|
||||||
|
self.V[i] = self.k*(self.w * self.V[i] + self.c1 * self.r1 * (self.pbest[i] - self.X[i])) + \
|
||||||
|
self.c2 * self.r2 * (self.gbest_ring[i] - self.X[i])
|
||||||
|
# Update position
|
||||||
|
self.X[i] = self.X[i] + self.V[i]
|
||||||
|
|
||||||
|
# Global PSO algorithm
|
||||||
|
else:
|
||||||
|
# Update velocity
|
||||||
|
for i in range(self.pN):
|
||||||
|
self.V[i] = self.k*(self.w * self.V[i] + self.c1 * self.r1 * (self.pbest[i] - self.X[i])) + \
|
||||||
|
self.c2 * self.r2 * (self.gbest - self.X[i])
|
||||||
|
# Update position
|
||||||
|
self.X[i] = self.X[i] + self.V[i]
|
||||||
|
|
||||||
|
# Set position boundary
|
||||||
|
for i in range(self.pN):
|
||||||
|
for j in range(self.dim+self.uav_num-1):
|
||||||
|
if self.X[i][j] >= 1:
|
||||||
|
self.X[i][j] = 0.999
|
||||||
|
if self.X[i][j] < 0:
|
||||||
|
self.X[i][j] = 0
|
||||||
|
# Update pbest & gbest
|
||||||
|
for i in range(self.pN):
|
||||||
temp = self.function(self.X[i])
|
temp = self.function(self.X[i])
|
||||||
if temp > self.p_fit[i]: # 更新个体最优
|
self.ring_fit[i] = temp
|
||||||
|
if temp > self.p_fit[i]:
|
||||||
self.p_fit[i] = temp
|
self.p_fit[i] = temp
|
||||||
self.pbest[i] = self.X[i]
|
self.pbest[i] = self.X[i]
|
||||||
if self.p_fit[i] > self.fit: # 更新全局最优
|
# Update gbest
|
||||||
|
if self.p_fit[i] > self.fit:
|
||||||
self.gbest = self.X[i]
|
self.gbest = self.X[i]
|
||||||
self.fit = self.p_fit[i]
|
self.fit = self.p_fit[i]
|
||||||
|
self.uav_best = self.fun_Data()
|
||||||
|
|
||||||
for i in range(self.pN):
|
# print
|
||||||
# 速度更新
|
|
||||||
self.V[i] = self.k*(self.w * self.V[i] + self.c1 * self.r1 * (self.pbest[i] - self.X[i])) + \
|
|
||||||
self.c2 * self.r2 * (self.gbest - self.X[i])
|
|
||||||
# 设置速度边界
|
|
||||||
for j in range(self.dim):
|
|
||||||
v_max=int(0.3*(self.dim-j))
|
|
||||||
v_min=-v_max
|
|
||||||
self.V[i][j]=int(self.V[i][j])
|
|
||||||
if self.V[i][j] > v_max:
|
|
||||||
self.V[i][j] = v_max
|
|
||||||
if self.V[i][j] < v_min:
|
|
||||||
self.V[i][j] = v_min
|
|
||||||
|
|
||||||
# 位置更新
|
|
||||||
self.X[i] = self.X[i] + self.V[i]
|
|
||||||
# 设置位置边界
|
|
||||||
for j in range(self.dim):
|
|
||||||
self.X[i][j]=int(self.X[i][j])
|
|
||||||
if self.X[i][j] > self.dim-j:
|
|
||||||
self.X[i][j] = self.dim-j
|
|
||||||
if self.X[i][j] < 1:
|
|
||||||
self.X[i][j] = 1
|
|
||||||
|
|
||||||
|
|
||||||
fitness.append(self.fit)
|
fitness.append(self.fit)
|
||||||
'''
|
if self.fit == fitness_old:
|
||||||
print(self.X[0], end=" ")
|
continue
|
||||||
print(self.fit) # 输出最优值
|
else:
|
||||||
'''
|
fitness_old = self.fit
|
||||||
self.gbest=self.position(self.gbest)
|
|
||||||
return fitness
|
return fitness
|
||||||
# ---------------------数据处理---------------------------
|
|
||||||
|
# ---------------------Data_Processing Function---------------------------
|
||||||
def fun_Data(self):
|
def fun_Data(self):
|
||||||
for i in range(self.add_num):
|
X_path, Sep = self.fun_Transfer(self.gbest)
|
||||||
self.gbest.append(i+self.dim+1)
|
# Obtain the Real Flight Path Sequence of Particles
|
||||||
UAV=[]
|
X = self.position(X_path)
|
||||||
k=0
|
# Get the search sequence of each UAV
|
||||||
|
UAV = []
|
||||||
|
l = 0
|
||||||
for i in range(self.uav_num):
|
for i in range(self.uav_num):
|
||||||
UAV.append([])
|
UAV.append([])
|
||||||
for j in range(self.dim1//self.uav_num):
|
k = Sep[i]
|
||||||
UAV[i].append(self.gbest[k])
|
for j in range(k):
|
||||||
k=k+1
|
UAV[i].append(X[l])
|
||||||
l1=len(UAV[0])
|
l = l+1
|
||||||
best=[]
|
# Calculate UAV_Out
|
||||||
|
UAV_Out = []
|
||||||
for i in range(self.uav_num):
|
for i in range(self.uav_num):
|
||||||
t=self.Distance[0][UAV[i][0]]/self.v
|
k = Sep[i]
|
||||||
best.append([])
|
t = 0
|
||||||
for j in range(l1-1):
|
UAV_Out.append([])
|
||||||
if t<=self.time_all:
|
for j in range(k):
|
||||||
best[i].append(UAV[i][j])
|
m1 = UAV[i][j]
|
||||||
d1=UAV[i][j]
|
if j == 0:
|
||||||
d2=UAV[i][j+1]
|
t = t+self.Distance[0, m1] / \
|
||||||
if d2<=self.dim:
|
self.vehicles_speed[i]+self.Stay_time[m1]
|
||||||
distance=self.Distance[d1][d2]
|
else:
|
||||||
t=t+distance/self.v
|
m2 = UAV[i][j-1]
|
||||||
for i in range(self.uav_num):
|
t = t+self.Distance[m2][m1] / \
|
||||||
l1=len(best[i])
|
self.vehicles_speed[i]+self.Stay_time[m1]
|
||||||
k=0
|
if t <= self.time_all:
|
||||||
for j in range(l1):
|
UAV_Out[i].append(m1)
|
||||||
if best[i][k]>self.dim:
|
self.time_out[i] = t
|
||||||
del best[i][k]
|
return UAV_Out
|
||||||
k=k-1
|
# ---------------------TEST Function------------------------------
|
||||||
k=k+1
|
|
||||||
return best
|
|
||||||
|
|
||||||
|
|
||||||
# ---------------------测试------------------------------
|
|
||||||
def fun_TEST(self):
|
def fun_TEST(self):
|
||||||
Test_Value=[]
|
Test_Value = []
|
||||||
for i in range(self.test_num):
|
for i in range(self.test_num):
|
||||||
Test_Value.append(self.function(self.TEST[i]))
|
Test_Value.append(self.function(self.TEST[i]))
|
||||||
return Test_Value
|
return Test_Value
|
||||||
# ----------------------程序执行-----------------------
|
# ---------------------Main----------------------------------------
|
||||||
# --------------------定义初始参数---------------------
|
|
||||||
uav_num = 10
|
|
||||||
target_num = 45
|
|
||||||
env = Env(uav_num,target_num,100,1000)
|
|
||||||
env.targets
|
|
||||||
env.vehicles_speed
|
|
||||||
# 定义总搜索时间
|
|
||||||
time_all=np.random.randint(0.6*10*dim,0.8*10*dim)
|
|
||||||
Value=[]
|
|
||||||
for i in range(dim):
|
|
||||||
Value.append(np.random.randint(0,200))
|
|
||||||
Distance=np.zeros((dim+1,dim+1))
|
|
||||||
for i in range(dim+1):
|
|
||||||
for j in range(i+1,dim+1):
|
|
||||||
Distance[i][j]=np.random.uniform(200,400)
|
|
||||||
Distance[j][i]=Distance[i][j]
|
|
||||||
# -----------------------PSO优化----------------------
|
|
||||||
my_pso = PSO(pN, dim, max_iter,uav_num,Distance,
|
|
||||||
v,Value,test_num,time_all)
|
|
||||||
my_pso.init_Population()
|
|
||||||
fitness = my_pso.iterator()
|
|
||||||
best=my_pso.fun_Data()
|
|
||||||
# --------------------------测试---------------------
|
|
||||||
|
|
||||||
print("fitness is",fitness)
|
def run(self):
|
||||||
for i in range(uav_num):
|
print("PSO start, pid: %s" % os.getpid())
|
||||||
print("第",i+1,"架无人机的搜索路径为:",best[i])
|
start_time = time.time()
|
||||||
Test_Value=my_pso.fun_TEST()
|
self.fun_get_initial_parameter()
|
||||||
l1=len(fitness)
|
self.init_Population()
|
||||||
k=0
|
fitness = self.iterator()
|
||||||
Test_Value_out=[]
|
end_time = time.time()
|
||||||
for i in range(test_num):
|
#self.cal_time = end_time - start_time
|
||||||
if Test_Value[i]>fitness[l1-1]:
|
#self.task_assignment = self.uav_best
|
||||||
k=k+1
|
print("PSO result:", self.uav_best)
|
||||||
Test_Value_out.append(Test_Value[i])
|
print("PSO time:", end_time - start_time)
|
||||||
print("测试结果超过优化后的目标值的个数是：",k,"个")
|
return self.uav_best, end_time - start_time
|
||||||
if k > 0:
|
|
||||||
print("这些测试结果分别是：",Test_Value_out)
|
|
||||||
#print("测试的适应值是",Test_Value)
|
|
||||||
|
|
||||||
# ------------------测试---------------------
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
# -------------Result-------------------------
|
||||||
|
if __name__ == '__main__':
|
||||||
|
# ----------------------------------TEST--------------------------------
|
||||||
# -------------------画图--------------------
|
'''
|
||||||
'''
|
Test_Value=my_pso.fun_TEST()
|
||||||
plt.figure(1)
|
l1=len(fitness)
|
||||||
plt.title("Figure1")
|
k=0
|
||||||
plt.xlabel("iterators", size=14)
|
Test_Value_out=[]
|
||||||
plt.ylabel("fitness", size=14)
|
for i in range(test_num):
|
||||||
t = np.array([t for t in range(0, 100)])
|
if Test_Value[i]>fitness[l1-1]:
|
||||||
fitness = np.array(fitness)
|
k=k+1
|
||||||
plt.plot(t, fitness, color='b', linewidth=3)
|
Test_Value_out.append(Test_Value[i])
|
||||||
plt.show()
|
print("测试结果超过优化后的目标值的个数是：",k,"个")
|
||||||
'''
|
if k > 0:
|
||||||
|
print("这些测试结果分别是：",Test_Value_out)
|
||||||
|
#print("测试的适应值是",Test_Value)
|
||||||
|
env.run(my_pso.uav_best,'pso')
|
||||||
|
print(env.vehicles_time)
|
||||||
|
print('time_limit:',env.time_lim)
|
||||||
|
'''
|
||||||
|
|
|
||||||
Loading…
Reference in New Issue