Full Code of robin-shaun/Multi-UAV-Task-Assignment-Benchmark for AI

Repository: robin-shaun/Multi-UAV-Task-Assignment-Benchmark
Branch: master
Commit: 60e1e8c2535c
Files: 9
Total size: 62.2 KB

Directory structure:
gitextract_hou5iokn/

├── .gitignore
├── aco.py
├── evaluate.py
├── ga.py
├── large_size_result.csv
├── medium_size_result.csv
├── pso.py
├── readme.md
└── small_size_result.csv

================================================
FILE CONTENTS
================================================

================================================
FILE: .gitignore
================================================
__pycache__

================================================
FILE: aco.py
================================================
import random
import numpy as np
import math
import time
import os

class ACO():
    def __init__(self, vehicle_num, target_num,vehicle_speed, target, time_lim):
        self.num_type_ant = vehicle_num
        self.num_city = target_num+1 #number of cities
        self.group = 200
        self.num_ant = self.group*self.num_type_ant #number of ants
        self.ant_vel = vehicle_speed
        self.cut_time = time_lim
        self.oneee = np.zeros((4,1))
        self.target = target
        self.alpha = 1 #pheromone 
        self.beta = 2  
        self.k1 = 0.03
        self.iter_max = 150
    #matrix of the distances between cities 
    def distance_matrix(self):
        dis_mat = []
        for i in range(self.num_city):
            dis_mat_each = []
            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_mat_each.append(dis)
            dis_mat.append(dis_mat_each)
        return dis_mat
    def run(self):
        print("ACO start, pid: %s" % os.getpid())
        start_time = time.time()
        #distances of nodes
        dis_list = self.distance_matrix()
        dis_mat = np.array(dis_list)
        value_init = self.target[:,2].transpose()
        delay_init = self.target[:,3].transpose()        
        pheromone_mat = np.ones((self.num_type_ant,self.num_city,self.num_city))
        #velocity of ants
        path_new = [[0]for i in range (self.num_type_ant)]
        count_iter = 0
        while count_iter < self.iter_max:
            path_sum = np.zeros((self.num_ant,1))
            time_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)]
            value = np.zeros((self.group,1))
            atten = np.ones((self.num_type_ant,1)) * 0.2
            for ant in range(self.num_ant):
                ant_type = ant % self.num_type_ant
                visit = 0
                if ant_type == 0:
                    unvisit_list=list(range(1,self.num_city))#have not visit
                for j in range(1,self.num_city):
            #choice of next city
                    trans_list=[]
                    tran_sum=0
                    trans=0
                    #if len(unvisit_list)==0:
                        #print('len(unvisit_list)==0')
                    for k in range(len(unvisit_list)):  # to decide which node to visit
                        trans +=np.power(pheromone_mat[ant_type][visit][unvisit_list[k]],self.alpha)*np.power(value_init[unvisit_list[k]]*self.ant_vel[ant_type]/(dis_mat[visit][unvisit_list[k]]*delay_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)
                    tran_sum = trans        
                    rand = random.uniform(0,tran_sum)
                    for t in range(len(trans_list)):
                        if(rand <= trans_list[t]):
                            visit_next = unvisit_list[t]
                            break
                        else:        
                            continue
                    path_mat[ant].append(visit_next)
                    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]
                    if time_sum[ant] > self.cut_time:
                        time_sum[ant]-=path_sum[ant] / self.ant_vel[ant_type] + delay_init[visit_next]                      
                        path_mat[ant].pop()                
                        break
                    value_sum[ant] += value_init[visit_next]
                    unvisit_list.remove(visit_next)#update
                    visit = visit_next
                if (ant_type) == self.num_type_ant-1:
                    small_group = int(ant/self.num_type_ant)
                    for k in range (self.num_type_ant):
                        value[small_group]+= value_sum[ant-k]
            #iteration
            if count_iter == 0:
                value_new = max(value)
                value = value.tolist()
                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].remove(0)
            else:
                if max(value) > value_new:
                    value_new = max(value)
                    value = value.tolist()
                    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].remove(0)

            #update pheromone
            pheromone_change = np.zeros((self.num_type_ant,self.num_city,self.num_city))
            for i in range(self.num_ant):
                length = len(path_mat[i])
                m = i%self.num_type_ant
                n = int(i/self.num_type_ant)
                for j in range(length-1):   
                    pheromone_change[m][path_mat[i][j]][path_mat[i][j+1]]+= value_init[path_mat[i][j+1]]*self.ant_vel[m]/(dis_mat[path_mat[i][j]][path_mat[i][j+1]]*delay_init[path_mat[i][j+1]])
                atten[m] += (value_sum[i]/(np.power((value_new-value[n]),4)+1))/self.group

            for k in range (self.num_type_ant):
                pheromone_mat[k]=(1-atten[k])*pheromone_mat[k]+pheromone_change[k]
            count_iter += 1

        print("ACO result:", path_new)
        end_time = time.time()
        print("ACO time:", end_time - start_time)
        return path_new, end_time - start_time



================================================
FILE: evaluate.py
================================================
import numpy as np
import matplotlib.pyplot as plt
import random
import pandas as pd
import copy
from multiprocessing import Pool
from ga import GA
from aco import ACO
from pso import PSO

class Env():
    def __init__(self, vehicle_num, target_num, map_size, visualized=True, time_cost=None, repeat_cost=None):
        self.vehicles_position = np.zeros(vehicle_num,dtype=np.int32)
        self.vehicles_speed = np.zeros(vehicle_num,dtype=np.int32)
        self.targets = np.zeros(shape=(target_num+1,4),dtype=np.int32)
        if vehicle_num==5:
            self.size='small'
        if vehicle_num==10:
            self.size='medium'
        if vehicle_num==15:
            self.size='large'
        self.map_size = map_size
        self.speed_range = [10, 15, 30]
        #self.time_lim = 1e6
        self.time_lim = self.map_size / self.speed_range[1]
        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.total_reward = 0
        self.reward = 0
        self.visualized = visualized
        self.time = 0
        self.time_cost = time_cost
        self.repeat_cost = repeat_cost
        self.end = False
        self.assignment = [[] for i in range(vehicle_num)]
        self.task_generator()
        
    def task_generator(self):
        for i in range(self.vehicles_speed.shape[0]):
            choose = random.randint(0,2)
            self.vehicles_speed[i] = self.speed_range[choose]
        for i in range(self.targets.shape[0]-1):
            self.targets[i+1,0] = random.randint(1,self.map_size) - 0.5*self.map_size # x position
            self.targets[i+1,1] = random.randint(1,self.map_size) - 0.5*self.map_size # y position
            self.targets[i+1,2] = random.randint(1,10) # reward
            self.targets[i+1,3] = random.randint(5,30) # time consumption to finish the mission  
        for i 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.targets_value = copy.deepcopy((self.targets[:,2]))
        
    def step(self, action):
        count = 0
        for j in range(len(action)):
            k = action[j]
            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
            if self.vehicles_lefttime[j] < 0:
                count = count + 1
                continue
            else:
                if k == 0:
                    self.reward = - self.repeat_cost
                else:
                    self.reward = self.targets[k,2] - delta_time * self.time_cost + self.targets[k,2]
                    if self.targets[k,2] == 0:
                        self.reward = self.reward - self.repeat_cost
                    self.vehicles_position[j] = k
                    self.targets[k,2] = 0
                self.total_reward = self.total_reward + self.reward
            self.assignment[j].append(action)
        if count == len(action):
            self.end = True
        
    def run(self, assignment, algorithm, play, rond):
        self.assignment = assignment
        self.algorithm = algorithm
        self.play = play
        self.rond = rond
        self.get_total_reward()
        if self.visualized:
            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):
        for i in range(len(self.assignment)):
            speed = self.vehicles_speed[i]
            for j in range(len(self.assignment[i])):
                position = self.targets[self.assignment[i][j],:4]
                self.total_reward = self.total_reward + position[2]
                if j == 0:
                    self.vehicles_lefttime[i] = self.vehicles_lefttime[i] - np.linalg.norm(position[:2]) / speed - position[3]
                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
            if self.end:
                self.total_reward = 0
                break
            
    def visualize(self):
        if self.assignment == None:
            plt.scatter(x=0,y=0,s=200,c='k')
            plt.scatter(x=self.targets[1:,0],y=self.targets[1:,1],s=self.targets[1:,2]*10,c='r')
            plt.title('Target distribution')
            plt.savefig('task_pic/'+self.size+'/'+self.algorithm+ "-%d-%d.png" % (self.play,self.rond))
            plt.cla()
        else:
            plt.title('Task assignment by '+self.algorithm +', total reward : '+str(self.total_reward))     
            plt.scatter(x=0,y=0,s=200,c='k')
            plt.scatter(x=self.targets[1:,0],y=self.targets[1:,1],s=self.targets[1:,2]*10,c='r')
            for i in range(len(self.assignment)):
                trajectory = np.array([[0,0,20]])
                for j in range(len(self.assignment[i])):
                    position = self.targets[self.assignment[i][j],:3]
                    trajectory = np.insert(trajectory,j+1,values=position,axis=0)  
                plt.scatter(x=trajectory[1:,0],y=trajectory[1:,1],s=trajectory[1:,2]*10,c='b')
                plt.plot(trajectory[:,0], trajectory[:,1]) 
            plt.savefig('task_pic/'+self.size+'/'+self.algorithm+ "-%d-%d.png" % (self.play,self.rond))
            plt.cla()
            
def evaluate(vehicle_num, target_num, map_size):
    if vehicle_num==5:
        size='small'
    if vehicle_num==10:
        size='medium'
    if vehicle_num==15:
        size='large'
    re_ga=[[] for i in range(10)]
    re_aco=[[] for i in range(10)]
    re_pso=[[] for i in range(10)]
    for i in range(10):
        env = Env(vehicle_num,target_num,map_size,visualized=True)
        for j in range(10):
            p=Pool(3)
            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',i+1,j+1)
            re_ga[i].append((env.total_reward,ga_result.get()[1]))
            env.reset()
            aco_task_assignmet = aco_result.get()[0]
            env.run(aco_task_assignmet,'ACO',i+1,j+1)
            re_aco[i].append((env.total_reward,aco_result.get()[1]))
            env.reset()
            pso_task_assignmet = pso_result.get()[0]
            env.run(pso_task_assignmet,'PSO',i+1,j+1)
            re_pso[i].append((env.total_reward,pso_result.get()[1]))
            env.reset()
    x_index=np.arange(10)
    ymax11=[]
    ymax12=[]
    ymax21=[]
    ymax22=[]
    ymax31=[]
    ymax32=[]
    ymean11=[]
    ymean12=[]
    ymean21=[]
    ymean22=[]
    ymean31=[]
    ymean32=[]
    for i in range(10):
        tmp1=[re_ga[i][j][0] for j in range(10)]
        tmp2=[re_ga[i][j][1] for j in range(10)]
        ymax11.append(np.amax(tmp1))
        ymax12.append(np.amax(tmp2))
        ymean11.append(np.mean(tmp1))
        ymean12.append(np.mean(tmp2))
        tmp1=[re_aco[i][j][0] for j in range(10)]
        tmp2=[re_aco[i][j][1] for j in range(10)]
        ymax21.append(np.amax(tmp1))
        ymax22.append(np.amax(tmp2))
        ymean21.append(np.mean(tmp1))
        ymean22.append(np.mean(tmp2))
        tmp1=[re_pso[i][j][0] for j in range(10)]
        tmp2=[re_pso[i][j][1] for j in range(10)]
        ymax31.append(np.amax(tmp1))
        ymax32.append(np.amax(tmp2))
        ymean31.append(np.mean(tmp1))
        ymean32.append(np.mean(tmp2))
    rects1=plt.bar(x_index,ymax11,width=0.1,color='b',label='ga_max_reward')
    rects2=plt.bar(x_index+0.1,ymax21,width=0.1,color='r',label='aco_max_reward')
    rects3=plt.bar(x_index+0.2,ymax31,width=0.1,color='g',label='pso_max_reward')
    plt.xticks(x_index+0.1,x_index)
    plt.legend()
    plt.title('max_reward_for_'+size+'_size')
    plt.savefig('max_reward_'+size+'.png')
    plt.cla()
    
    rects1=plt.bar(x_index,ymax12,width=0.1,color='b',label='ga_max_time')
    rects2=plt.bar(x_index+0.1,ymax22,width=0.1,color='r',label='aco_max_time')
    rects3=plt.bar(x_index+0.2,ymax32,width=0.1,color='g',label='pso_max_time')
    plt.xticks(x_index+0.1,x_index)
    plt.legend()
    plt.title('max_time_for_'+size+'_size')
    plt.savefig('max_time_'+size+'.png')
    plt.cla()
    
    rects1=plt.bar(x_index,ymean11,width=0.1,color='b',label='ga_mean_reward')
    rects2=plt.bar(x_index+0.1,ymean21,width=0.1,color='r',label='aco_mean_reward')
    rects3=plt.bar(x_index+0.2,ymean31,width=0.1,color='g',label='pso_mean_reward')
    plt.xticks(x_index+0.1,x_index)
    plt.legend()
    plt.title('mean_reward_for_'+size+'_size')
    plt.savefig('mean_reward_'+size+'.png')
    plt.cla()
    
    rects1=plt.bar(x_index,ymean12,width=0.1,color='b',label='ga_mean_time')
    rects2=plt.bar(x_index+0.1,ymean22,width=0.1,color='r',label='aco_mean_time')
    rects3=plt.bar(x_index+0.2,ymean32,width=0.1,color='g',label='pso_mean_time')
    plt.xticks(x_index+0.1,x_index)
    plt.legend()
    plt.title('mean_time_for_'+size+'_size')
    plt.savefig('mean_time_'+size+'.png')
    plt.cla()
    
    t_ga=[]
    r_ga=[]
    t_aco=[]
    r_aco=[]
    t_pso=[]
    r_pso=[]
    for i in range(10):
        for j in range(10):
            t_ga.append(re_ga[i][j][1])
            r_ga.append(re_ga[i][j][0])
            t_aco.append(re_aco[i][j][1])
            r_aco.append(re_aco[i][j][0])
            t_pso.append(re_pso[i][j][1])
            r_pso.append(re_pso[i][j][0])
    dataframe = pd.DataFrame({'ga_time':t_ga,'ga_reward':r_ga,'aco_time':t_aco,'aco_reward':r_aco,'pso_time':t_pso,'pso_reward':r_pso})
    dataframe.to_csv(size+'_size_result.csv',sep=',')
    
    
if __name__=='__main__':
    # small scale
    evaluate(5,30,5e3)
    # medium scale
    evaluate(10,60,1e4)
    # large scale
    evaluate(15,90,1.5e4)


================================================
FILE: ga.py
================================================
import numpy as np
import random
import time
import os


class GA():
    def __init__(self, vehicle_num, vehicles_speed, target_num, targets, time_lim):
        # vehicles_speed,targets in the type of narray
        self.vehicle_num = vehicle_num
        self.vehicles_speed = vehicles_speed
        self.target_num = target_num
        self.targets = targets
        self.time_lim = time_lim
        self.map = np.zeros(shape=(target_num+1, target_num+1), dtype=float)
        self.pop_size = 50
        self.p_cross = 0.6
        self.p_mutate = 0.005
        for i in range(target_num+1):
            self.map[i, i] = 0
            for j in range(i):
                self.map[j, i] = self.map[i, j] = np.linalg.norm(
                    targets[i, :2]-targets[j, :2])
        self.pop = np.zeros(
            shape=(self.pop_size, vehicle_num-1+target_num-1), dtype=np.int32)
        self.ff = np.zeros(self.pop_size, dtype=float)
        for i in range(self.pop_size):
            for j in range(vehicle_num-1):
                self.pop[i, j] = random.randint(0, target_num)
            for j in range(target_num-1):
                self.pop[i, vehicle_num+j -
                         1] = random.randint(0, target_num-j-1)
            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):
        ins = np.zeros(self.target_num+1, dtype=np.int32)
        seq = np.zeros(self.target_num, dtype=np.int32)
        ins[self.target_num] = 1
        for i in range(self.vehicle_num-1):
            ins[gene[i]] += 1
        rest = np.array(range(1, self.target_num+1))
        for i in range(self.target_num-1):
            seq[i] = rest[gene[i+self.vehicle_num-1]]
            rest = np.delete(rest, gene[i+self.vehicle_num-1])
        seq[self.target_num-1] = rest[0]
        i = 0  # index of vehicle
        pre = 0  # index of last target
        post = 0  # index of ins/seq
        t = 0
        reward = 0
        while i < self.vehicle_num:
            if ins[post] > 0:
                i += 1
                ins[post] -= 1
                pre = 0
                t = 0
            else:
                t += self.targets[pre, 3]
                past = self.map[pre, seq[post]]/self.vehicles_speed[i]
                t += past
                if t < self.time_lim:
                    reward += self.targets[seq[post], 2]
                pre = seq[post]
                post += 1
        return reward

    def selection(self):
        roll = np.zeros(self.tmp_size, dtype=float)
        roll[0] = self.tmp_ff[0]
        for i in range(1, self.tmp_size):
            roll[i] = roll[i-1]+self.tmp_ff[i]
        for i in range(self.pop_size):
            xx = random.uniform(0, roll[self.tmp_size-1])
            j = 0
            while xx > roll[j]:
                j += 1
            self.pop[i, :] = self.tmp_pop[j, :]
            self.ff[i] = self.tmp_ff[j]

    def mutation(self):
        for i in range(self.tmp_size):
            flag = False
            for j in range(self.vehicle_num-1):
                if random.random() < self.p_mutate:
                    self.tmp_pop[i, j] = random.randint(0, self.target_num)
                    flag = True
            for j in range(self.target_num-1):
                if random.random() < self.p_mutate:
                    self.tmp_pop[i, self.vehicle_num+j -
                                 1] = random.randint(0, self.target_num-j-1)
                    flag = True
            if flag:
                self.tmp_ff[i] = self.fitness(self.tmp_pop[i, :])

    def crossover(self):
        new_pop = []
        new_ff = []
        new_size = 0
        for i in range(0, self.pop_size, 2):
            if random.random() < self.p_cross:
                x1 = random.randint(0, self.vehicle_num-2)
                x2 = random.randint(0, self.target_num-2)+self.vehicle_num
                g1 = self.pop[i, :]
                g2 = self.pop[i+1, :]
                g1[x1:x2] = self.pop[i+1, x1:x2]
                g2[x1:x2] = self.pop[i, x1:x2]
                new_pop.append(g1)
                new_pop.append(g2)
                new_ff.append(self.fitness(g1))
                new_ff.append(self.fitness(g2))
                new_size += 2
        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[0:self.pop_size, :] = self.pop
        self.tmp_pop[self.pop_size:self.tmp_size, :] = np.array(new_pop)
        self.tmp_ff = np.zeros(self.tmp_size, dtype=float)
        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):
        print("GA start, pid: %s" % os.getpid())
        start_time = time.time()
        cut = 0
        count = 0
        while count < 500:
            self.crossover()
            self.mutation()
            self.selection()
            new_cut = self.tmp_ff.max()
            if cut < new_cut:
                cut = new_cut
                count = 0
                gene = self.tmp_pop[np.argmax(self.tmp_ff)]
            else:
                count += 1

        ins = np.zeros(self.target_num+1, dtype=np.int32)
        seq = np.zeros(self.target_num, dtype=np.int32)
        ins[self.target_num] = 1
        for i in range(self.vehicle_num-1):
            ins[gene[i]] += 1
        rest = np.array(range(1, self.target_num+1))
        for i in range(self.target_num-1):
            seq[i] = rest[gene[i+self.vehicle_num-1]]
            rest = np.delete(rest, gene[i+self.vehicle_num-1])
        seq[self.target_num-1] = rest[0]
        task_assignment = [[] for i in range(self.vehicle_num)]
        i = 0  # index of vehicle
        pre = 0  # index of last target
        post = 0  # index of ins/seq
        t = 0
        reward = 0
        while i < self.vehicle_num:
            if ins[post] > 0:
                i += 1
                ins[post] -= 1
                pre = 0
                t = 0
            else:
                t += self.targets[pre, 3]
                past = self.map[pre, seq[post]]/self.vehicles_speed[i]
                t += past
                if t < self.time_lim:
                    task_assignment[i].append(seq[post])
                    reward += self.targets[seq[post], 2]
                pre = seq[post]
                post += 1
        print("GA result:", task_assignment)
        end_time = time.time()
        print("GA time:", end_time - start_time)
        return task_assignment, end_time - start_time



================================================
FILE: large_size_result.csv
================================================
,aco_reward,aco_time,ga_reward,ga_time,pso_reward,pso_time
0,296,908.7814054489136,247,55.92802929878235,263,475.8543794155121
1,291,915.7366240024567,259,66.25442147254944,263,472.1400876045227
2,292,917.8597526550293,254,74.90953588485718,263,474.662939786911
3,289,929.387636423111,260,103.34872436523438,263,478.1414213180542
4,289,923.429899930954,251,60.22564744949341,263,468.2993767261505
5,288,921.4861361980438,256,101.24155569076538,263,480.2911822795868
6,293,899.2834107875824,255,80.45500588417053,263,467.8873429298401
7,289,920.9990880489349,258,104.65078663825989,263,473.22990322113037
8,289,915.464262008667,252,55.428141355514526,263,470.7831304073334
9,292,908.4859659671783,242,54.579482316970825,263,468.63810992240906
10,273,951.7187411785126,249,53.21723532676697,267,471.1878535747528
11,273,967.2745745182037,265,127.98299217224121,267,489.7042224407196
12,270,974.3173124790192,260,195.45258331298828,267,495.3276345729828
13,275,963.2233729362488,246,50.30011963844299,267,470.9858467578888
14,271,962.010968208313,248,73.91375541687012,267,471.8012545108795
15,271,962.2612085342407,252,77.44514584541321,267,481.26786375045776
16,267,945.5351057052612,245,58.64225435256958,267,477.9602701663971
17,277,948.2806112766266,255,67.99747490882874,267,468.89854645729065
18,271,967.6417164802551,252,129.3072385787964,267,478.41221261024475
19,274,963.3537228107452,253,133.60208249092102,267,479.5689525604248
20,290,966.2115695476532,250,122.1526083946228,260,489.93380999565125
21,287,943.0081570148468,250,62.05885910987854,260,477.671777009964
22,290,947.1903564929962,254,59.37166452407837,260,467.77480578422546
23,286,959.2566442489624,276,91.52135014533997,260,477.249960899353
24,288,954.6075274944305,268,48.26884913444519,260,464.37573313713074
25,284,936.1187009811401,273,57.24583983421326,260,477.16314125061035
26,286,954.3773159980774,259,82.08687591552734,260,475.90100502967834
27,289,949.4377288818359,254,53.36060166358948,260,470.7586085796356
28,290,952.0964720249176,273,65.8470516204834,260,474.4114272594452
29,290,944.5154075622559,275,43.74000549316406,260,468.4188332557678
30,327,994.9844787120819,294,81.43704128265381,301,474.0977404117584
31,323,1018.6526775360107,273,114.55374956130981,301,498.5897653102875
32,321,1009.1453545093536,285,94.25002026557922,301,486.3076343536377
33,327,1019.1480383872986,278,55.407536029815674,301,488.1904435157776
34,325,1007.914253950119,293,83.80115604400635,301,491.72301745414734
35,325,1024.5869517326355,282,148.9419755935669,301,497.10984230041504
36,323,1020.457249879837,295,108.69291090965271,301,496.7013669013977
37,326,1013.691241979599,271,73.25992369651794,301,494.8483748435974
38,323,1020.1873610019684,278,48.434046030044556,301,490.01100039482117
39,325,1021.3731291294098,292,115.58995175361633,301,488.44017720222473
40,278,976.9366610050201,264,138.9213318824768,273,499.79298758506775
41,275,965.3231558799744,262,145.9869430065155,273,498.0558907985687
42,280,962.862530708313,271,91.95361614227295,273,489.8705041408539
43,279,959.0885939598083,236,54.67619323730469,273,486.26035809516907
44,276,973.558468580246,255,105.7680230140686,273,491.402090549469
45,279,967.0545673370361,248,83.93505239486694,273,485.08744978904724
46,276,957.583824634552,239,93.60761904716492,273,494.0147354602814
47,275,965.79727602005,264,104.30339407920837,273,489.8355438709259
48,280,971.2357912063599,247,81.43815469741821,273,485.04322052001953
49,278,973.0727701187134,254,91.01016688346863,273,489.8650426864624
50,291,952.5716059207916,250,101.36161661148071,275,494.92200326919556
51,294,946.210232257843,254,66.17070937156677,275,481.7474868297577
52,294,946.330258846283,256,88.53258848190308,275,489.36784863471985
53,294,940.2625517845154,248,63.820109605789185,275,485.3837275505066
54,291,951.8322811126709,256,68.07165431976318,275,488.7123284339905
55,299,958.7923038005829,265,68.89578294754028,275,491.05396008491516
56,296,951.3731620311737,245,73.54164481163025,275,486.9369945526123
57,291,958.3713037967682,258,89.91634559631348,275,491.3002550601959
58,290,945.0339353084564,246,56.91977286338806,275,481.18742632865906
59,291,947.7742516994476,261,71.559574842453,275,481.191358089447
60,305,981.3974587917328,291,92.71349763870239,269,488.7560610771179
61,304,957.5966999530792,275,82.32165241241455,269,491.32160925865173
62,307,968.3465480804443,266,79.71064329147339,269,492.24424958229065
63,309,978.8897063732147,269,78.40533828735352,269,490.47363781929016
64,305,976.8462386131287,263,96.9474766254425,269,497.1219482421875
65,310,973.8594441413879,257,72.08272051811218,269,493.34489607810974
66,306,964.727823972702,276,96.79535627365112,269,496.8235650062561
67,309,980.2682957649231,271,110.70756220817566,269,489.6940174102783
68,304,985.0895121097565,266,146.9937801361084,269,510.74099040031433
69,304,970.6574778556824,259,80.50431251525879,269,480.4831213951111
70,331,1002.6550228595734,276,71.99679160118103,282,486.46082282066345
71,330,1068.6351492404938,297,123.51885652542114,282,506.458402633667
72,332,1023.2077965736389,285,78.46024966239929,282,492.73976039886475
73,331,1017.5172808170319,280,48.53227877616882,282,495.07808446884155
74,332,1011.5874664783478,309,67.04316973686218,282,494.5928440093994
75,330,1028.534333705902,274,72.79688119888306,282,492.562472820282
76,332,996.4580583572388,310,69.33413505554199,282,489.1693527698517
77,332,1006.4915940761566,293,63.24198341369629,282,486.631254196167
78,332,1007.7951982021332,278,54.046175479888916,282,487.0864179134369
79,327,1008.2880766391754,306,101.87895131111145,282,491.83132791519165
80,342,1024.3724205493927,311,84.77551889419556,307,490.72554993629456
81,346,1037.724690914154,321,93.26548743247986,307,497.81773042678833
82,345,1045.6583635807037,300,86.76090788841248,307,484.0392985343933
83,344,1043.5157623291016,310,91.16247344017029,307,490.33659172058105
84,344,1042.54065823555,322,59.16938662528992,307,484.3666524887085
85,344,1039.1224558353424,301,86.92423415184021,307,493.7003331184387
86,340,1043.6719121932983,320,77.55270719528198,307,483.9702203273773
87,344,1042.995453596115,306,104.2813949584961,307,494.0151512622833
88,347,1051.3341484069824,321,152.23194694519043,307,496.49487829208374
89,349,1040.0653417110443,349,86.07370352745056,307,498.4700348377228
90,327,981.0026612281799,277,82.25102162361145,310,486.8569030761719
91,327,981.1793773174286,291,83.74289011955261,310,487.12745547294617
92,327,976.752777338028,306,72.23682999610901,310,489.5701353549957
93,326,980.6637990474701,300,54.929299116134644,310,483.11501002311707
94,322,969.3974039554596,284,70.095294713974,310,484.54920268058777
95,324,970.2287967205048,277,90.13793587684631,310,491.29523491859436
96,323,978.8446981906891,279,76.42075634002686,310,490.77434039115906
97,325,968.8402066230774,275,64.63985276222229,310,498.89036893844604
98,324,979.2253255844116,286,160.1146640777588,310,496.08253359794617
99,325,982.7923681735992,275,45.25343370437622,310,482.38406586647034


================================================
FILE: medium_size_result.csv
================================================
,aco_reward,aco_time,ga_reward,ga_time,pso_reward,pso_time
0,216,448.3831191062927,206,49.305721282958984,193,148.66212391853333
1,215,450.0390589237213,201,47.92679977416992,193,148.18085885047913
2,215,446.2680039405823,197,44.56689190864563,193,147.05394744873047
3,214,439.6638705730438,206,30.478964805603027,193,145.65527486801147
4,216,446.25123286247253,213,49.142014026641846,193,146.94575667381287
5,215,449.3586504459381,191,35.995574951171875,193,147.08190488815308
6,215,444.68290305137634,199,47.1325957775116,193,149.1070830821991
7,215,440.68888783454895,191,40.503169775009155,193,146.32232356071472
8,216,444.11085629463196,207,30.60081696510315,193,145.07146883010864
9,216,442.4932496547699,203,41.649266719818115,193,148.24117517471313
10,181,394.1740880012512,182,41.235496282577515,179,145.92154598236084
11,179,398.2101173400879,182,58.84644627571106,179,149.12411260604858
12,182,396.67690896987915,185,28.317508935928345,179,146.20850467681885
13,181,402.9303925037384,178,50.20690608024597,179,150.27634143829346
14,183,399.2702867984772,198,61.198126792907715,179,150.24325561523438
15,181,392.7786009311676,193,27.70851445198059,179,145.60873198509216
16,186,394.2873070240021,187,40.75690317153931,179,146.5531108379364
17,182,400.4948661327362,189,68.48983502388,179,151.8164780139923
18,181,396.15389823913574,176,36.01111102104187,179,146.96473789215088
19,183,407.0688331127167,177,74.86308264732361,179,152.32446765899658
20,257,535.1680011749268,242,45.81318497657776,257,162.57035994529724
21,248,477.0249879360199,257,59.37494111061096,257,151.88625025749207
22,248,481.47851395606995,248,73.29448699951172,257,153.8765308856964
23,248,476.1490092277527,251,46.956031799316406,257,150.61592316627502
24,248,472.28077578544617,245,35.464972496032715,257,147.88373970985413
25,247,465.2167932987213,248,33.261672258377075,257,147.64871048927307
26,248,465.4674003124237,243,46.813090562820435,257,149.02625226974487
27,253,475.7856402397156,253,62.99959635734558,257,152.69138717651367
28,248,471.5851991176605,249,62.63740587234497,257,151.3696005344391
29,248,468.71898126602173,242,40.11980128288269,257,149.03825902938843
30,196,404.4883544445038,190,26.050060272216797,194,144.73951077461243
31,200,409.98085474967957,196,49.781771659851074,194,148.48935222625732
32,197,411.36246395111084,197,45.22318196296692,194,149.27837538719177
33,197,413.2939670085907,198,49.13954973220825,194,149.69017028808594
34,200,408.55559182167053,208,41.79141283035278,194,149.21917819976807
35,196,409.9758207798004,189,27.64315676689148,194,147.62873792648315
36,197,408.1155550479889,194,47.21198105812073,194,147.90398573875427
37,199,412.9177339076996,217,75.3260293006897,194,152.389484167099
38,195,413.65162658691406,197,56.222227573394775,194,148.9140920639038
39,196,406.7831847667694,196,33.56608486175537,194,146.55531525611877
40,162,376.0339472293854,166,32.595866680145264,170,144.9636528491974
41,162,377.5476269721985,183,36.15443444252014,170,147.16523098945618
42,162,380.8216028213501,169,73.12481117248535,170,151.93030548095703
43,163,377.19195222854614,167,26.03180742263794,170,146.38755416870117
44,162,375.4290704727173,165,31.497214555740356,170,145.87686395645142
45,162,381.92375802993774,177,65.6746084690094,170,151.02717685699463
46,162,377.6920804977417,167,41.89390730857849,170,149.11691117286682
47,162,379.4388999938965,168,47.881861448287964,170,146.81237983703613
48,163,386.09958243370056,176,90.63225603103638,170,154.9767725467682
49,162,376.02294278144836,178,49.68327236175537,170,147.34447741508484
50,163,395.1006145477295,170,60.02331042289734,166,149.5303943157196
51,164,398.0407438278198,173,58.35295605659485,166,148.20625829696655
52,161,387.7398009300232,160,36.16767406463623,166,146.93824124336243
53,160,397.3074097633362,181,87.42074513435364,166,151.60932040214539
54,161,394.0010869503021,161,35.39233636856079,166,145.9512619972229
55,168,397.33205008506775,180,93.66990065574646,166,153.4657781124115
56,165,391.67463517189026,177,34.15181350708008,166,146.88838911056519
57,160,394.11439633369446,179,75.18911981582642,166,150.38912177085876
58,163,391.3193950653076,169,50.267693281173706,166,146.59030938148499
59,161,389.8388180732727,169,43.60353207588196,166,146.73621797561646
60,214,458.1954791545868,224,53.538702964782715,213,148.77755308151245
61,216,457.9216077327728,217,74.3746817111969,213,172.45012044906616
62,210,419.3990144729614,198,35.978588342666626,213,148.06180047988892
63,219,429.85972452163696,218,87.86180424690247,213,153.94083642959595
64,214,424.77522015571594,209,65.07919359207153,213,151.17670392990112
65,218,418.9645538330078,201,33.109193086624146,213,146.59753608703613
66,213,419.9968156814575,211,60.90353274345398,213,151.33484530448914
67,213,419.75107407569885,219,41.44067192077637,213,148.6664433479309
68,215,418.3867540359497,215,53.756091594696045,213,149.20613074302673
69,217,426.778751373291,207,55.369181394577026,213,150.33477354049683
70,199,410.5372402667999,215,60.27366662025452,208,149.8002016544342
71,198,409.2937562465668,204,59.25821495056152,208,151.39743947982788
72,196,409.5259928703308,215,35.602235317230225,208,145.2328040599823
73,201,406.344420671463,223,48.74324607849121,208,148.4908196926117
74,199,408.3418302536011,220,70.71654105186462,208,151.31224751472473
75,198,404.72881293296814,194,29.9748272895813,208,145.87402033805847
76,200,407.07944345474243,199,32.814154624938965,208,148.0822048187256
77,198,410.07060742378235,221,83.80286979675293,208,152.27385711669922
78,198,403.81956219673157,205,46.65635085105896,208,149.30409383773804
79,197,410.29728984832764,225,53.520286560058594,208,148.7795009613037
80,152,380.2354018688202,157,35.35539889335632,169,147.90625596046448
81,150,384.5501811504364,159,48.30092000961304,169,149.15482306480408
82,151,376.554048538208,157,25.061031818389893,169,146.199316740036
83,152,379.9583477973938,160,32.2420814037323,169,147.88309359550476
84,154,381.87709069252014,159,46.78597569465637,169,148.42677807807922
85,150,384.82411456108093,176,71.57334589958191,169,152.0538854598999
86,154,380.4787724018097,153,32.610721588134766,169,145.2583565711975
87,154,381.19555377960205,160,35.47093892097473,169,146.1291468143463
88,154,375.84812235832214,158,32.85135459899902,169,146.2271864414215
89,150,377.0024824142456,172,31.29044246673584,169,146.2692093849182
90,188,408.0042040348053,172,33.111896276474,172,146.74985241889954
91,188,415.29174041748047,183,46.34089708328247,172,148.31623196601868
92,186,408.48268270492554,171,65.71342968940735,172,151.4460847377777
93,187,408.3678331375122,173,50.35272192955017,172,149.03712511062622
94,188,410.88290190696716,177,33.343971252441406,172,147.3882360458374
95,187,414.69072556495667,181,56.616501331329346,172,149.22642374038696
96,185,413.3330612182617,178,45.60746383666992,172,148.60242438316345
97,187,406.33209466934204,181,42.515186071395874,172,146.75966262817383
98,187,405.92414903640747,183,27.310251474380493,172,145.60900115966797
99,186,415.5781035423279,190,51.28600215911865,172,146.98746609687805


================================================
FILE: pso.py
================================================
# coding: utf-8
import numpy as np
import random
import math
import cmath
import time
import os
# ----------------------Optimization scheme----------------------------------
# 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---------------------------------


class PSO():
    def __init__(self, uav_num, target_num, targets, vehicles_speed, time_lim):
        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.c1 = 2
        self.c2 = 2
        self.r1 = 0.6
        self.r2 = 0.3
        self.k = 0   # Convergence factor
        self.wini = 0.9
        self.wend = 0.4

        self.X = np.zeros((self.pN, self.dim+self.uav_num-1)
                          )  # Position of all particles
        self.V = np.zeros((self.pN, self.dim+self.uav_num-1)
                          )  # Velocity of all particles
        # The historical optimal position of each individual
        self.pbest = np.zeros((self.pN, self.dim+self.uav_num-1))
        self.gbest = np.zeros((1, self.dim+self.uav_num-1))
        # Global optimal position
        self.gbest_ring = np.zeros((self.pN, self.dim+self.uav_num-1))
        # Historical optimal fitness of each individual
        self.p_fit = np.zeros(self.pN)
        self.fit = 0  # Global optimal fitness
        self.ring = []
        self.ring_fit = np.zeros(self.pN)
        # variation parameter
        self.p1 = 0.4  # Probability of mutation
        self.p2 = 0.5  # Proportion of individuals with variation in population
        self.p3 = 0.5  # Proportion of locations where variation occurs
        self.TEST = []
        self.test_num = 0
        self.uav_best = []

        self.time_out = np.zeros(self.uav_num)
        
        self.cal_time = 0
    # ------------------Get Initial parameter------------------

    def fun_get_initial_parameter(self):
        self.max_iter = 40*(self.uav_num+self.dim)
        if self.max_iter > 4100:
            self.max_iter = 4100

        # 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):
            m1 = X[i]
            m1 = int(m1)
            X2.append(Position_All[m1])
            del Position_All[m1]
        return X2
    # ---------------------Fitness_Computing Function-----------------------------

    def function(self, X):
        X_path, Sep = self.fun_Transfer(X)

        # Obtain the Real Flight Path Sequence of Particles
        X = self.position(X_path)
        # Get the search sequence of each UAV
        UAV = []
        l = 0
        for i in range(self.uav_num):
            UAV.append([])
            k = Sep[i]
            for j in range(k):
                UAV[i].append(X[l])
                l = l+1

        # Calculate Fitness
        fitness = 0
        for i in range(self.uav_num):
            k = Sep[i]
            t = 0
            for j in range(k):
                m1 = UAV[i][j]

                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):
        # Initialization of position(X), speed(V), history optimal(pbest) and global optimal(gbest)
        for i in range(self.pN):
            x = np.random.uniform(0, 1, self.dim+self.uav_num-1)
            self.X[i, :] = x
            v = np.random.uniform(0, 0.4, self.dim+self.uav_num-1)
            self.V[i, :] = v
            self.pbest[i] = self.X[i]

            tmp = self.function(self.X[i])
            self.p_fit[i] = tmp
            if tmp > self.fit:
                self.fit = tmp
                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):
            self.ring.append([])
            self.ring[i].append(i)
        # Initialize test_set
        self.TEST = np.zeros((self.test_num, self.dim+self.uav_num-1))
        for i in range(self.test_num):
            test = np.random.uniform(0, 1, self.dim+self.uav_num-1)
            self.TEST[i, :] = test

    # ----------------------Update Particle Position----------------------------------

    def iterator(self):
        fitness = []
        fitness_old = 0
        k = 0
        for t in range(self.max_iter):
            w = (self.wini-self.wend)*(self.max_iter-t)/self.max_iter+self.wend
            self.w = w
            # Variation
            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])
                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]
                        self.uav_best = self.fun_Data()

            # print
            fitness.append(self.fit)
            if self.fit == fitness_old:
                continue
            else:
                fitness_old = self.fit
        return fitness

    # ---------------------Data_Processing Function---------------------------
    def fun_Data(self):
        X_path, Sep = self.fun_Transfer(self.gbest)
        # Obtain the Real Flight Path Sequence of Particles
        X = self.position(X_path)
        # Get the search sequence of each UAV
        UAV = []
        l = 0
        for i in range(self.uav_num):
            UAV.append([])
            k = Sep[i]
            for j in range(k):
                UAV[i].append(X[l])
                l = l+1
        # Calculate UAV_Out
        UAV_Out = []
        for i in range(self.uav_num):
            k = Sep[i]
            t = 0
            UAV_Out.append([])
            for j in range(k):
                m1 = UAV[i][j]
                if j == 0:
                    t = t+self.Distance[0, m1] / \
                        self.vehicles_speed[i]+self.Stay_time[m1]
                else:
                    m2 = UAV[i][j-1]
                    t = t+self.Distance[m2][m1] / \
                        self.vehicles_speed[i]+self.Stay_time[m1]
                if t <= self.time_all:
                    UAV_Out[i].append(m1)
                    self.time_out[i] = t
        return UAV_Out
    # ---------------------TEST Function------------------------------

    def fun_TEST(self):
        Test_Value = []
        for i in range(self.test_num):
            Test_Value.append(self.function(self.TEST[i]))
        return Test_Value
    # ---------------------Main----------------------------------------

    def run(self):
        print("PSO start, pid: %s" % os.getpid())
        start_time = time.time()
        self.fun_get_initial_parameter()
        self.init_Population()
        fitness = self.iterator()
        end_time = time.time()
        #self.cal_time  = end_time - start_time
        #self.task_assignment = self.uav_best
        print("PSO result:", self.uav_best)
        print("PSO time:", end_time - start_time)
        return self.uav_best, end_time - start_time
        



================================================
FILE: readme.md
================================================
# Multi-UAV Task Assignment Benchmark
## 多无人机任务分配算法测试基准

## Introduction
A benchmark for multi-UAV task assignment is presented in order to evaluate different algorithms. An extended Team Orienteering Problem is modeled for a kind of multi-UAV task assignment problem. Three intelligent algorithms, i.e., Genetic Algorithm, Ant Colony Optimization and Particle Swarm Optimization are implemented to solve the problem. A series of experiments with different settings are conducted to evaluate three algorithms. The modeled problem and the evaluation results constitute a benchmark, which can be used to evaluate other algorithms used for multi-UAV task assignment problems.

Notice that three algorithms run at three CPU cores respectively, which means that there is no parallel optimization in this benchmark.

<img src="./task_pic/large/ACO-1-1.png" width="640" height="368" />  

<img src="./mean_reward_large.png" width="640" height="368" />  

<img src="./mean_time_large.png" width="640" height="368" />  

Please refer to the paper to see more detail.

K. Xiao, J. Lu, Y. Nie, L. Ma, X. Wang and G. Wang, "A Benchmark for Multi-UAV Task Assignment of an Extended Team Orienteering Problem," 2022 China Automation Congress (CAC), Xiamen, China, 2022, pp. 6966-6970, doi: 10.1109/CAC57257.2022.10054991.

ArXiv preprint **[ arXiv:2003.09700](https://arxiv.org/abs/2009.00363)** 


## Usage

### 1. Algorithm input and output

Algorithm input includes vehicle number (scalar),  speeds of vehicles ($n\times1$ array), target  number (scalar $n$),  targets ($(n+1)\times4$ array, the first line is depot, the first column is x position, the second column is y position, the third column is reward and the forth column is time consumption to finish the mission), time limit (scalar).  The code below is the initialization of the class GA in `ga.py`.

```python
def __init__(self, vehicle_num, vehicles_speed, target_num, targets, time_lim)
```

There should be a function called `run()` in the algorithm class, and the function should return task assignment plan(array, e.g. [[28, 19, 11], [25, 22, 7, 16, 17, 23], [21, 26, 12, 9, 6, 3], [5, 15, 1], [18, 20, 29]], each subset is a vehicle path) and computational time usage (scalar). 

### 2. Evaluate

You can replace one algorithm  below with another algorithm in `evaluate.py`, and then `python evaluate.py`. If you don't want to evaluate three algorithm together, you should modify the code properly( this is easy).    

```python
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',i+1,j+1)
re_ga[i].append((env.total_reward,ga_result.get()[1]))
env.reset()
aco_task_assignmet = aco_result.get()[0]
env.run(aco_task_assignmet,'ACO',i+1,j+1)
re_aco[i].append((env.total_reward,aco_result.get()[1]))
env.reset()
pso_task_assignmet = pso_result.get()[0]
env.run(pso_task_assignmet,'PSO',i+1,j+1)
re_pso[i].append((env.total_reward,pso_result.get()[1]))
```

### 3. About reinforcement learning

In `Env()` in `evaluate.py`, function `step` is used for reinforcement learning. Because this is still being developed, we cannot supply a demo. If your algorithm is reinforcement learning, you can try to train it with `Env()`. Your pull request and issue are welcome.

## Enhancement

This [repository](https://github.com/dietmarwo/Multi-UAV-Task-Assignment-Benchmark) does great enhancement and you can use it for high performance. Thanks to [dietmarwo](https://github.com/dietmarwo) for the nice work.

1) GA uses [numba](https://numba.pydata.org/) for a dramatic speedup. Parameters are adapted so that the
    execution time remains the same: popsize 50 -> 300, iterations 500 -> 6000
    For this reason GA now performs much better compared to the original version.

2) Experiments are configured so that wall time for small size is balanced. This means:
    increased effort for GA, decreased effort for ACO. For medium / large 
    problem size you see which algorithms scale badly: Increase execution time superlinear
    in relation to the problem size. Avoid these for large problems. 

3) Adds a standard continuous optimization algorithm: [BiteOpt](https://github.com/avaneev/biteopt) 
    from Aleksey Vaneev - using the same fitness function as GA.py. 
    BiteOpt is the only algorithm included which works well with a large problem size. 
    It is by far the simplest implementation, only the fitness function needs
    to be coded, since we can apply a continuous optimization library 
    [fcmaes](https://github.com/dietmarwo/fast-cma-es). Execute "pip install fcmaes" to use it. 

4) Uses NestablePool to enable BiteOpt multiprocessing: Many BiteOpt optimization runs
   are performed in parallel and the best result is returned. Set workers=1 
   if you want to test BiteOpt single threaded. 
   
5) All results are created using an AMD 5950x 16 core processor
    utilizing all cores: 29 parallel BiteOpt threads, the other 3 algorithms remain single threaded. 

6) Added test_bite.py where you can monitor the progress of BiteOpt applied to the problem.

7) Added test_mode.py where you can monitor the progress of fcmaes-MODE applied to the problem and compare it
   to BiteOpt for the same instance. fcmaes-MODE is a multi-objective optimizer applied to a 
   multi-objective variant of the problem.
   Objectives are: reward (to be maximized), maximal time (to be minimized), energy (to be minimized).
   The maximal time constraint from the single objective case is still valid.
   Energy consumption is approximated by `sum(dt*v*v)`


 



================================================
FILE: small_size_result.csv
================================================
,aco_reward,aco_time,ga_reward,ga_time,pso_reward,pso_time
0,89,88.16137266159058,119,12.685494184494019,107,13.414397716522217
1,88,91.05341100692749,106,9.964252710342407,107,16.068947315216064
2,89,91.91174960136414,109,14.250640153884888,107,16.815466165542603
3,89,92.22553205490112,110,21.893151998519897,107,17.22126531600952
4,89,92.13908076286316,101,10.614777565002441,107,16.337905406951904
5,89,92.50885510444641,121,15.014703512191772,107,17.107726097106934
6,90,92.41064667701721,109,17.080315113067627,107,17.380303859710693
7,89,92.84331011772156,119,20.32515835762024,107,16.93877387046814
8,88,92.46119904518127,114,19.172377824783325,107,16.968574047088623
9,90,94.00208711624146,127,21.729254484176636,107,17.066615104675293
10,96,89.81863832473755,117,22.284271717071533,107,17.06852388381958
11,99,88.96507263183594,113,19.54985523223877,107,17.087736129760742
12,96,88.38604950904846,109,14.674241304397583,107,16.747975826263428
13,97,89.2066752910614,110,11.188013553619385,107,16.291066884994507
14,96,89.45146775245667,115,18.54390525817871,107,17.09095311164856
15,97,91.43690013885498,118,34.3544921875,107,17.089507579803467
16,101,87.81503558158875,116,16.678542375564575,107,17.032145738601685
17,95,87.75125932693481,116,13.018948793411255,107,16.583208084106445
18,97,87.48667025566101,103,11.756951570510864,107,16.502718687057495
19,96,89.22999024391174,117,23.240997076034546,107,17.057995319366455
20,96,90.63653469085693,113,20.940587043762207,102,17.042691230773926
21,91,90.38828539848328,104,17.667251586914062,102,17.154610633850098
22,87,90.0098135471344,98,17.66662073135376,102,16.96206521987915
23,87,89.37335777282715,97,12.019228219985962,102,16.48302674293518
24,85,90.64067506790161,114,23.917268753051758,102,17.08442449569702
25,90,91.06858992576599,108,20.25761079788208,102,17.10637593269348
26,87,89.10331749916077,103,10.527708768844604,102,16.272404670715332
27,86,90.21255588531494,111,17.25125241279602,102,17.043729782104492
28,88,90.96662783622742,111,24.268309354782104,102,17.005598783493042
29,88,90.03387355804443,109,13.798240184783936,102,16.55376434326172
30,67,85.81624722480774,75,19.326607704162598,72,17.03825044631958
31,67,85.53707933425903,80,22.211409330368042,72,17.13922429084778
32,67,85.78650307655334,79,19.998062133789062,72,17.11928629875183
33,67,84.82013392448425,81,11.410378456115723,72,16.370493173599243
34,67,86.44931316375732,79,28.120026111602783,72,17.011059761047363
35,67,84.43776869773865,78,14.097299098968506,72,16.78164315223694
36,67,84.38073658943176,75,10.875871896743774,72,16.290704488754272
37,67,85.27193593978882,77,18.085707426071167,72,17.11751627922058
38,67,86.35783362388611,77,20.6546049118042,72,17.204835653305054
39,67,84.17668747901917,70,9.783939123153687,72,16.234663009643555
40,90,81.11320877075195,109,25.354978561401367,94,17.01652693748474
41,92,81.4474401473999,115,25.54797601699829,94,17.27031111717224
42,90,82.45976829528809,105,21.565988302230835,94,17.12051248550415
43,86,81.89453530311584,116,25.38959002494812,94,17.148070096969604
44,90,80.1114649772644,108,12.730968475341797,94,16.551698684692383
45,88,80.46094584465027,112,16.600263595581055,94,17.025696277618408
46,92,80.10696768760681,108,10.806996822357178,94,16.190462350845337
47,94,82.78089380264282,106,23.92259168624878,94,17.245839834213257
48,87,82.29063534736633,110,17.997102975845337,94,17.09163522720337
49,94,79.32447719573975,106,10.254770755767822,94,16.159439086914062
50,63,81.13122916221619,85,19.498087406158447,80,17.062880754470825
51,64,78.95552730560303,73,11.968117952346802,80,16.42030930519104
52,64,80.55506777763367,83,19.04611301422119,80,17.044256925582886
53,64,80.00666880607605,79,11.748615503311157,80,16.27301836013794
54,66,80.77283143997192,88,11.66093134880066,80,16.391525506973267
55,64,82.00660061836243,88,24.136553049087524,80,17.06270742416382
56,66,81.55947065353394,85,16.429919242858887,80,16.999276161193848
57,63,81.114262342453,87,22.340787172317505,80,17.043132543563843
58,63,81.04138517379761,78,18.89263892173767,80,17.08504867553711
59,64,80.52739334106445,93,13.616387367248535,80,16.57269597053528
60,82,86.7540352344513,99,13.066121578216553,94,16.544466018676758
61,81,87.89562153816223,104,25.433122873306274,94,17.053762197494507
62,82,86.26548409461975,99,12.918514966964722,94,16.66313886642456
63,83,87.24347186088562,106,21.98454189300537,94,17.103214263916016
64,82,86.60797476768494,98,12.473426580429077,94,16.57561159133911
65,84,87.11871242523193,103,10.223820686340332,94,16.257148027420044
66,81,88.71003365516663,94,24.597357988357544,94,17.143748998641968
67,82,86.51209807395935,96,14.048967838287354,94,16.72418999671936
68,81,86.93004393577576,91,17.69091010093689,94,17.053284645080566
69,81,87.69031119346619,89,13.707175254821777,94,16.6680109500885
70,79,85.87792015075684,86,9.261616945266724,91,16.168455839157104
71,79,88.14101362228394,96,23.5689058303833,91,17.132070302963257
72,79,88.25272393226624,96,26.78891372680664,91,17.096915006637573
73,79,89.53712511062622,96,28.207839250564575,91,17.064720630645752
74,79,87.57802844047546,97,14.012932777404785,91,16.740302085876465
75,79,87.26567029953003,86,12.413164615631104,91,16.392486333847046
76,79,86.66206288337708,89,11.749331951141357,91,16.469265460968018
77,79,87.8359739780426,85,17.515364170074463,91,17.102705717086792
78,80,88.0450918674469,94,23.927947282791138,91,17.082552194595337
79,79,87.65122652053833,93,17.091141939163208,91,17.03953456878662
80,74,84.19559216499329,91,26.049842834472656,83,16.9984188079834
81,75,82.51725816726685,85,16.961402416229248,83,17.110384464263916
82,75,82.8316662311554,89,23.545618057250977,83,17.114362478256226
83,73,82.98265886306763,84,23.422379732131958,83,17.07512879371643
84,73,81.70284986495972,92,18.57567572593689,83,17.09586262702942
85,76,83.29867267608643,90,24.692944288253784,83,17.056284427642822
86,76,81.04190707206726,93,11.550926208496094,83,16.41378617286682
87,74,82.97272729873657,94,18.214133262634277,83,17.02610754966736
88,72,81.47475123405457,86,10.687882900238037,83,16.277140855789185
89,73,82.54533529281616,89,17.926280975341797,83,17.130127668380737
90,88,89.74022126197815,128,20.152071475982666,107,17.193649530410767
91,88,88.83557057380676,115,14.007786512374878,107,16.752809762954712
92,89,89.99075937271118,120,21.46599245071411,107,17.087929248809814
93,89,90.57273888587952,116,22.19508957862854,107,17.231003284454346
94,91,89.41200828552246,109,13.885975360870361,107,16.87487244606018
95,88,89.83750343322754,115,20.845364570617676,107,17.157454013824463
96,91,91.00219821929932,124,27.728176832199097,107,17.07404375076294
97,93,91.0686559677124,117,25.557191371917725,107,17.23515510559082
98,87,90.42128872871399,112,15.197402715682983,107,16.944777965545654
99,90,89.05649876594543,100,14.382555484771729,107,16.822237491607666