├── README.md ├── sensor.py ├── gmap.py ├── main.py ├── center_dqn.py └── uav.py /README.md: -------------------------------------------------------------------------------- 1 | # Simulation-of-UAV-based-edge-data-processing-Dqn-based-path-planning-\\ 2 | 3 | Install tensorflow keras numpy mathplotlib 4 | 5 | Simulate the path planning and data scheduling 6 | 7 | UAVs are supposed to move straight along path in each time slot 8 | -------------------------------------------------------------------------------- /sensor.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | Created on Thu Oct 25 14:54:02 2018 4 | 5 | @author: wansh 6 | """ 7 | from gmap import j_region 8 | import numpy as np 9 | import random 10 | 11 | class sensor_agent: 12 | def __init__(self,position,C,region,data_rate,slot): 13 | self.position=position.copy() 14 | self.capacity=C 15 | self.rNo=j_region(self.position,region) 16 | self.databuf=0 17 | self.data_rate=data_rate[self.rNo] 18 | self.slot=slot 19 | self.wait=0 20 | 21 | 22 | def fresh_buf(self,UAVlist): #accumulate data in the former slot, transmit to UAV 23 | distance=[] 24 | num=len(UAVlist) 25 | self.databuf=self.databuf+np.random.poisson(self.data_rate*self.slot) 26 | # print(self.databuf) 27 | for i in range(num): 28 | p1=np.array([UAVlist[i].position[0],UAVlist[i].position[1]]) 29 | p2=np.array([self.position[0],self.position[1]]) 30 | distance.append(np.linalg.norm(p1-p2)) 31 | 32 | min_d=min(distance) 33 | temp=[] 34 | inf=1e15 35 | for i in range(num): 36 | md=min(distance) 37 | if md>min_d+1: 38 | break 39 | l0=distance.index(md) 40 | temp.append(l0) 41 | distance[l0]=inf 42 | min_idx=random.sample(temp,1)[0] 43 | if(min_d>UAVlist[min_idx].r): 44 | self.wait=self.wait+1 45 | return -1 46 | else: 47 | UAVlist[min_idx].data_buf=UAVlist[min_idx].data_buf+min(self.databuf,self.slot*self.capacity) 48 | pre_buf=self.databuf 49 | self.databuf=max(0,self.databuf-self.slot*self.capacity) 50 | self.wait=self.databuf*self.wait/pre_buf 51 | return min_idx 52 | -------------------------------------------------------------------------------- /gmap.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | Created on Tue Oct 23 09:43:48 2018 4 | 5 | @author: wansh 6 | """ 7 | import numpy as np 8 | 9 | #Generate the system map 10 | #Can be modified by varied map definition 11 | 12 | def genmap(width=500,hight=400,lw=4,lh=2): 13 | F_map={'width':width,'hight':hight} 14 | region=[] 15 | dw=width/lw 16 | dh=hight/lh 17 | for h in range(lh): 18 | for w in range(lw): 19 | left=(w-1)*dw 20 | right=left+dw 21 | down=(h-1)*dh 22 | up=down+dh 23 | new_region={} 24 | new_region['bl']=(1,0,-left,1) 25 | new_region['br']=(1,0,-right,-1) 26 | new_region['bd']=(0,1,-down,1) 27 | new_region['bu']=(0,1,-up,-1) 28 | region.append(new_region) 29 | 30 | region.append(F_map) 31 | return region 32 | 33 | def j_region(point,region): 34 | num_r=len(region)-1 35 | for j_r in range(num_r): 36 | bound=region[j_r] 37 | b1=((bound['bl'][0]*point[0]+bound['bl'][1]*point[1]+bound['bl'][2])*bound['bl'][3] >=0) 38 | b2=((bound['br'][0]*point[0]+bound['br'][1]*point[1]+bound['br'][2])*bound['br'][3] >=0) 39 | b3=((bound['bd'][0]*point[0]+bound['bd'][1]*point[1]+bound['bd'][2])*bound['bd'][3] >=0) 40 | b4=((bound['bu'][0]*point[0]+bound['bu'][1]*point[1]+bound['bu'][2])*bound['bu'][3] >=0) 41 | judg=(b1 and b2 and b3 and b4) 42 | if judg==1: 43 | return j_r 44 | return -1 45 | 46 | #Sensor position 47 | def position_sensor(region,num_sensor): 48 | ep=10.0 49 | num_r=len(region)-1 50 | width=region[num_r]['width'] 51 | hight=region[num_r]['hight'] 52 | position_w=np.random.uniform(0.0+ep,float(width)-ep,[num_sensor]) 53 | position_h=np.random.uniform(0.0+ep,float(hight)-ep,[num_sensor]) 54 | p_sensor={'W':position_w,'H':position_h} 55 | return p_sensor 56 | 57 | def gen_datarate(averate,region_rate): 58 | num=len(region_rate) 59 | for i in range(num): 60 | region_rate[i]=np.random.uniform(0.9*averate[i],1.2*averate[i]) 61 | return 1 62 | 63 | def gen_obs(num_region): 64 | region_obstacle=[[9.61,0.16,1,20],[12.08,0.11,1.6,23],[4.88,0.43,0.1,21]] 65 | obs=[] 66 | for i in range(num_region): 67 | type=np.random.randint(3) 68 | obs.append(region_obstacle[type]) 69 | return obs 70 | 71 | def gen_gama(g0,d0,the,d): #input position as array 72 | gam=np.random.exponential() 73 | # gama=gam*g0*((d0/np.linalg.norm(P_cen-P_self))**the) 74 | gama=gam*g0*((d0/d)**the) 75 | return gama 76 | 77 | def list_gama(g0,d0,the,UAVlist,P_cen): 78 | num_U=len(UAVlist) 79 | for i in range(num_U): 80 | P_self=np.array([UAVlist[i].position[0],UAVlist[i].position[1]]) 81 | d=max(50,np.linalg.norm(P_cen-P_self)) 82 | gama=gen_gama(g0,d0,the,d) 83 | UAVlist[i].gama=gama 84 | return 1 85 | 86 | def find_pos(position): 87 | x=np.floor(position[0]) 88 | y=np.floor(position[1]) 89 | return [int(x),int(y)] 90 | 91 | # The observations in discrete map nodes 92 | def W_wait(width,height,sensorlist): 93 | E_wait=np.zeros([height+1,width+1]) 94 | num_sen=len(sensorlist) 95 | step=1 96 | for i in range(num_sen): 97 | pos=find_pos(sensorlist[i].position) 98 | E_wait[pos[1],pos[0]] +=sensorlist[i].wait 99 | for j in range(step): 100 | j+=1 101 | E_wait[pos[1]+j,pos[0]+j] +=sensorlist[i].wait 102 | E_wait[max(0,pos[1]-j),max(0,pos[0]-j)] +=sensorlist[i].wait 103 | E_wait[max(0,pos[1]-j),pos[0]] +=sensorlist[i].wait 104 | E_wait[pos[1],max(0,pos[0]-j)] +=sensorlist[i].wait 105 | E_wait[pos[1],pos[0]+j] +=sensorlist[i].wait 106 | E_wait[pos[1]+j,pos[0]] +=sensorlist[i].wait 107 | return E_wait 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | -------------------------------------------------------------------------------- /main.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | Created on Thu Oct 25 16:29:07 2018 4 | 5 | @author: wansh 6 | """ 7 | 8 | import numpy as np 9 | import gmap as gp 10 | from center_dqn import Center_DQN 11 | from uav import UAV_agent 12 | from sensor import sensor_agent 13 | import matplotlib.pyplot as plt 14 | 15 | Ed=10000 #total slot 16 | ep0=0.97 17 | batch_size=12 #training samples per batch 18 | pl_step=5 #How many steps will The system plan the next destination 19 | T=300 #How many steps will the epslon be reset and the trained weights will be stored 20 | com_r=60 21 | num1=5 22 | num2=4 23 | region=gp.genmap(600,400,num1,num2) 24 | E_wait=np.ones([401,601]) 25 | P_cen=np.array([300,200]) 26 | t_bandwidth=2e6 27 | N0=2e-20 28 | f_max=2e9 #the max cal frequency of UAV 29 | k=1e-26 30 | cal_L=3000 31 | slot=0.5 32 | num_UAV=6 33 | omeg=1/num_UAV 34 | num_sensor=20000 35 | p_max=5 36 | alfmin=1e-3 37 | num_region=num1*num2 38 | C=2e3 39 | v=8 40 | V=10e9 41 | v1=v*np.sin(np.pi/4) 42 | region_obstacle=gp.gen_obs(num_region) 43 | region_rate=np.zeros([num_region]) 44 | averate=np.random.uniform(280,300,[num_region]) 45 | p_sensor=gp.position_sensor(region,num_sensor) 46 | vlist=[[0,0],[v,0],[v1,v1],[0,v],[-v1,v1],[-v,0],[-v1,-v1],[0,-v],[v1,-v1]] 47 | g0=1e-4 48 | d0=1 49 | the=4 50 | OUT=np.zeros([num_UAV]) 51 | reward=np.zeros([num_UAV]) 52 | reset_p_T=800 53 | 54 | #jud=70000 55 | gammalist=[0,0.1,0.2,0.3,0.5,0.6,0.7,0.8,0.9] 56 | Mentrd=np.zeros([num_UAV,Ed]) 57 | 58 | #generate UAV agent 59 | UAVlist=[] 60 | for i in range(num_UAV): 61 | UAVlist.append(UAV_agent(i,com_r,region_obstacle,region,omeg,slot,t_bandwidth,cal_L,k,f_max,p_max)) 62 | 63 | #generate sensor agent 64 | sensorlist=[] 65 | for i in range(num_sensor): 66 | sensorlist.append(sensor_agent([p_sensor['W'][i],p_sensor['H'][i]],C,region,averate,slot)) 67 | 68 | 69 | Center=Center_DQN((84,84,1),9,num_UAV,batch_size) 70 | #Center.load("./save/center-dqn.h5") 71 | prebuf=np.zeros([num_UAV]) 72 | data=np.zeros([num_UAV]) 73 | #pre_data=np.zeros([num_UAV]) 74 | 75 | #define record data buf 76 | cover=np.zeros([Ed]) 77 | 78 | #init plt 79 | plt.close() #clf() # 清图 cla() # 清坐标轴 close() # 关窗口 80 | fig=plt.figure() 81 | ax=fig.add_subplot(1,1,1) 82 | plt.xlim((0,600)) 83 | plt.ylim((0,400)) 84 | plt.grid(True) #添加网格 85 | plt.ion() #interactive mode on 86 | X=np.zeros([num_UAV]) 87 | Y=np.zeros([num_UAV]) 88 | fg=1 89 | 90 | for t in range(Ed): #move first, get the data, offload collected data 91 | gp.gen_datarate(averate,region_rate) 92 | # print(t) 93 | if t%T==0 and t>0: 94 | Center.epsilon=ep0 95 | Center.save("./save/center-dqn.h5") 96 | 97 | if t%pl_step==0: 98 | pre_feature=[] 99 | aft_feature=[] 100 | act_note=[] 101 | for i in range(num_UAV): 102 | pre_feature.append(UAVlist[i].map_feature(region_rate,UAVlist,E_wait)) #record former feature 103 | act=Center.act(pre_feature[i],fg) # get the action V 104 | act_note.append(act) #record the taken action 105 | 106 | for i in range(num_UAV): 107 | OUT[i]=UAVlist[i].fresh_position(vlist[act_note[i]],region_obstacle) #execute the action 108 | UAVlist[i].cal_hight() 109 | X[i]=UAVlist[i].position[0] 110 | Y[i]=UAVlist[i].position[1] 111 | UAVlist[i].fresh_buf() 112 | prebuf[i]=UAVlist[i].data_buf #the buf after fresh by server 113 | 114 | gp.list_gama(g0,d0,the,UAVlist,P_cen) 115 | 116 | for i in range(num_sensor): #fresh buf send data to UAV 117 | sensorlist[i].data_rate=region_rate[sensorlist[i].rNo] 118 | sensorlist[i].fresh_buf(UAVlist) 119 | cover[t]=cover[t]+sensorlist[i].wait 120 | cover[t]=cover[t]/num_sensor 121 | print(cover[t]) 122 | 123 | for i in range(num_UAV): 124 | reward[i]=reward[i]+UAVlist[i].data_buf-prebuf[i] 125 | Mentrd[i,t]=reward[i] 126 | # if sum(OUT)>=num_UAV/2: 127 | # fg=0 128 | # if np.random.rand()>0.82 and fg==0: 129 | # fg=1 130 | 131 | if t%pl_step==0: 132 | E_wait=gp.W_wait(600,400,sensorlist) 133 | rdw=sum(sum(E_wait)) 134 | print(t) 135 | for i in range(num_UAV): #calculate the reward : need the modify 136 | # aft_feature.append(UAVlist[i].map_feature(region_rate,UAVlist,E_wait)) #recode the current feature 137 | rd=reward[i]/1000 138 | reward[i]=0 139 | # UAVlist[i].reward=reward 140 | # reward=get_data/(pre_data[i]+1) 141 | # if OUT[i]>0: 142 | # rd=-200000 143 | 144 | # if get_data<700: 145 | # reward=-1 146 | # pre_data[i]=get_data 147 | UAVlist[i].reward=rd 148 | # l_queue[t]=l_queue[t]+UAVlist[i].data_buf 149 | # print("%f, %f, %f, %f"%(rd,UAVlist[i].data_buf,UAVlist[i].D_l,UAVlist[i].D_tr)) 150 | # if UAVlist[i].data_buf>jud: 151 | # reward=reward/(reward-jud) 152 | # if t>0: 153 | # Center.remember(pre_feature[i],act_note[i],rd,aft_feature[i],i) #record the training data 154 | # if t>1000: 155 | # Center.epsilon=ep0 156 | # Center.epsilon_decay=1 157 | # if t>batch_size*pl_step and t%pl_step==0: 158 | # for turn in range(num_UAV): 159 | ## Center.replay(batch_size,turn,t%reset_p_T) 160 | # Center.replay(batch_size,turn,t-batch_size*pl_step) 161 | 162 | if t>0: 163 | ax.clear() 164 | plt.xlim((0,600)) 165 | plt.ylim((0,400)) 166 | plt.grid(True) #添加网格 167 | 168 | ax.scatter(X,Y,c='b',marker='.') #散点图 169 | # if t>0: 170 | plt.pause(0.1) 171 | 172 | 173 | #np.save("record_rd3",Mentrd) 174 | np.save("cover_hungry_10",cover) 175 | fig=plt.figure() 176 | plt.plot(cover) 177 | plt.show() 178 | 179 | -------------------------------------------------------------------------------- /center_dqn.py: -------------------------------------------------------------------------------- 1 | import random 2 | import numpy as np 3 | from collections import deque 4 | from tensorflow import keras 5 | import tensorflow as tf 6 | from gmap import find_pos,j_region 7 | 8 | #EPISODES = 50 9 | 10 | 11 | class Center_DQN: 12 | def __init__(self, state_size, action_size,num_UAV,batch_size): 13 | self.state_size = state_size 14 | self.action_size = action_size 15 | # self.memory = deque(maxlen=124) 16 | self.memory=[] 17 | self.gamma = 0.8 # discount rate 18 | self.epsilon = 0.97 # exploration rate 19 | self.epsilon_min = 0.05 20 | self.epsilon_decay = 0.92 21 | self.N=36 22 | self.rtz=200 23 | self.jr=0 24 | self.num=0 25 | self.alpha=0.1 26 | self.pro=np.zeros([action_size]) 27 | self.loss=[] 28 | # self.learning_rate = 0.001 29 | self.model = self._build_model() 30 | self.tmodel= self._build_model() 31 | self.num_U=num_UAV 32 | for i in range(num_UAV): 33 | self.memory.append(deque(maxlen=batch_size+10)) 34 | 35 | def _build_model(self): #Set network of central training 36 | # Neural Net for Deep-Q learning Model 37 | model = keras.Sequential() 38 | model.add(keras.layers.Conv2D(32, (8,8), strides=4,activation='relu',input_shape = self.state_size)) 39 | # model.add(keras.layers.Dropout(0.25)) 40 | model.add(keras.layers.Conv2D(64, (4,4), strides=2,activation='relu')) 41 | model.add(keras.layers.Conv2D(64, (3,3), strides=1,activation='relu')) 42 | # model.add(keras.layers.MaxPooling2D(pool_size=(2, 2))) 43 | # model.add(keras.layers.Dropout(0.25)) 44 | model.add(keras.layers.Flatten()) 45 | model.add(keras.layers.Dense(512, activation='relu')) 46 | model.add(keras.layers.Dense(self.action_size, activation='linear')) 47 | model.compile(optimizer='rmsprop',loss='mse') 48 | return model 49 | 50 | def remember(self, state, action, reward, next_state,i): 51 | self.memory[i].append((state, action, reward, next_state)) 52 | 53 | 54 | 55 | 56 | def act(self, state,fg): 57 | nrd=np.random.rand() 58 | if nrd <= self.epsilon: 59 | return random.randrange(self.action_size) 60 | state=np.reshape(state,[1,self.state_size[0],self.state_size[1],self.state_size[2]]) 61 | act_values = self.model.predict(state) 62 | print(np.amax(act_values[0])) 63 | return np.argmax(act_values[0]) # returns action 64 | 65 | #training process 66 | def replay(self, batch_size, i1,t): 67 | self.alpha=1/np.sqrt((t+1)/5) 68 | if self.num==0: 69 | self.model.save_weights("./save/temp.h5") 70 | self.tmodel.load_weights("./save/temp.h5") 71 | minibatch = random.sample(self.memory[i1], batch_size) 72 | train_sp=np.zeros([batch_size,self.state_size[0],self.state_size[1],self.state_size[2]]) 73 | tg=np.zeros([batch_size,self.action_size]) 74 | # minibatch=self.memory[i] 75 | error=0 76 | i=0 77 | for state1, action, reward, next_state in minibatch: 78 | state=np.reshape(state1,[1,self.state_size[0],self.state_size[1],self.state_size[2]]) 79 | next_state=np.reshape(next_state,[1,self.state_size[0],self.state_size[1],self.state_size[2]]) 80 | pdc=self.model.predict(state)[0] 81 | self.pro[action]+=1 82 | w=sum(self.pro)/self.pro[action] 83 | # if reward<=0: 84 | # w=6 85 | ap=min(0.9,self.alpha*w) 86 | # ap=self.alpha 87 | target = ap*(reward + self.gamma * 88 | np.amax(self.tmodel.predict(next_state)[0]))+(1-ap)*pdc[action] #第一维是属于哪个batch 89 | target_f = self.model.predict(state) 90 | target_f[0][action] = target 91 | tg[i]=target_f[0] 92 | train_sp[i]=state1 93 | i+=1 94 | error+= abs((target-pdc[action])/ap) 95 | # self.model.fit(state, target_f, epochs=1, verbose=0) 96 | 97 | self.loss.append(error/batch_size) 98 | self.model.fit(train_sp, tg, epochs=1, verbose=0) 99 | if self.epsilon > self.epsilon_min and i1==self.num_U-1: 100 | self.epsilon *= self.epsilon_decay 101 | self.num +=1 102 | self.jr +=1 103 | if self.num==self.N: 104 | self.num=0 105 | # if self.jr==self.rtz: 106 | # self.jr=0 107 | # for i in range(self.action_size): 108 | # self.pro[i]=0 109 | 110 | def find_ld(self,UAVlist,alfmin): 111 | ld_L=1e50 112 | ld_U=-1e50 113 | num=len(UAVlist) 114 | for i in range(num): 115 | h=UAVlist[i].data_buf*UAVlist[i].bandwidth*UAVlist[i].slot 116 | M=UAVlist[i].gama*UAVlist[i].p_tr/(UAVlist[i].noise*UAVlist[i].bandwidth) 117 | ldl_t=h*np.log2(1+M/1)-h*M/(np.log(2)*(1+M)) 118 | ldu_t=h*(np.log2(1+M/alfmin)-M/(np.log(2)*(M+alfmin))) 119 | if ldl_tld_U: 122 | ld_U=ldu_t 123 | return [ld_L,ld_U] 124 | 125 | 126 | 127 | 128 | def cal_com(self,UAVlist,alfmin,ite=20): 129 | [ld_L,ld_U]=self.find_ld(UAVlist,alfmin) 130 | # print("%f,%f"%(ld_L,ld_U)) 131 | num=len(UAVlist) 132 | ite2=20 133 | for i in range(ite2): 134 | mid=(ld_L+ld_U)/2 135 | grad=0 136 | for j in range(num): 137 | grad=grad+UAVlist[j].cal_alpha(mid,alfmin,ite,1) 138 | if grad<=1 and grad>=0.8: 139 | break 140 | elif grad>1: 141 | ld_L=mid 142 | else: 143 | ld_U=mid 144 | return mid 145 | 146 | def para_com(self,UAVlist,noise,V,p_max,alfmin): #calculate UAV offloading 147 | num=len(UAVlist) 148 | for i in range(num): 149 | UAVlist[i].p_tr=p_max #cal ptr give values to noise.... 150 | 151 | for j in range(2): 152 | self.cal_com(UAVlist,alfmin) #cal ptr and alpha by dual decomposition 153 | for i in range(num): 154 | UAVlist[i].cal_ptr(p_max,V,noise) 155 | for i in range(num): 156 | UAVlist[i].cal_f(V) 157 | return j 158 | 159 | 160 | 161 | def load(self, name): 162 | self.model.load_weights(name) 163 | 164 | def save(self, name): 165 | self.model.save_weights(name) 166 | np.save("train_loss",self.loss) 167 | 168 | -------------------------------------------------------------------------------- /uav.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | Created on Wed Oct 24 10:34:15 2018 4 | 5 | @author: wansh 6 | """ 7 | from gmap import j_region 8 | from gmap import W_wait,find_pos 9 | import numpy as np 10 | 11 | class UAV_agent: 12 | def __init__(self,No,com_r,region_obstacle,region,omeg,slot,t_bandwidth,cal_L,k,f_max,p_max): 13 | self.No=No 14 | self.position=[np.random.uniform(0.0,region[-1]['width']),np.random.uniform(0.0,region[-1]['hight'])] 15 | self.r=com_r 16 | self.region_ifo=region 17 | self.region_No=j_region(self.position,region) 18 | self.obs=region_obstacle[self.region_No] 19 | self.data_buf=0 20 | self.hight=0 #modified by cal_hight 21 | self.v=[0,0] 22 | self.p_tr=p_max #modified by cal_ptr 23 | self.f=0 #modified by cal_f 24 | self.bandwidth=t_bandwidth 25 | self.slot=slot 26 | self.L=cal_L 27 | self.alpha=0.1 28 | self.gama=0.1 29 | self.noise=1 30 | self.D_l=0 #modified by fresh_buf 31 | self.D_tr=0 #modified by fresh_buf 32 | self.omeg=omeg 33 | self.k=k 34 | self.f_max=f_max 35 | self.formerstate=np.zeros((84,84,2)) 36 | self.nowstate=np.zeros((84,84,2)) 37 | self.reward=0 38 | 39 | def resetposition(self): #Set the initial UAV position in random mode 40 | self.position=[np.random.uniform(0.0,self.region_ifo[-1]['width']),np.random.uniform(0.0,self.region_ifo[-1]['hight'])] 41 | 42 | def cal_hight(self,b_up=1e4,ite=15): #calculate the optimal UAV height 43 | a=self.obs[0] 44 | b=self.obs[1] 45 | eta0=self.obs[2] 46 | eta1=self.obs[3] 47 | L=0 #<0 48 | H=b_up #>0 49 | for i in range(ite): 50 | mid=(L+H)/2.0 51 | ep=np.exp( -b*(np.arctan(mid)-a) ) 52 | div=2*mid*(eta1+(eta0-eta1)/(1+a*ep))+(eta0-eta1)*a*b*ep/((1+a*ep)**2) 53 | if div<0: 54 | L=mid 55 | elif div>0: 56 | H=mid 57 | else: 58 | self.hight=self.r*mid 59 | return self.hight 60 | 61 | self.hight=self.r*mid 62 | return self.hight 63 | 64 | def fresh_buf(self): #update the data queue 65 | self.D_l=self.slot*self.f/self.L 66 | self.D_tr=self.alpha*self.omeg*self.bandwidth*self.slot*np.log2(1+self.gama*self.p_tr/(self.alpha*self.noise*self.bandwidth)) 67 | self.data_buf=max(self.data_buf-self.D_l-self.D_tr,0) 68 | 69 | return self.data_buf 70 | 71 | def cal_f(self,V): #calculate local frequency 72 | cf=np.sqrt( (self.slot*self.data_buf)/(3*self.L*V*self.omeg*self.k) ) 73 | if cf<=self.f_max: 74 | self.f=cf 75 | return cf 76 | else: 77 | self.f=self.f_max 78 | return self.f_max 79 | 80 | def cal_ptr(self,p_max,V,noise): #calculate transmition power to the cloud center 81 | self.noise=noise 82 | ptr=self.bandwidth*self.alpha*(self.data_buf*self.slot)/(V*self.omeg*np.log(2))-self.bandwidth*self.alpha*noise/self.gama 83 | self.p_tr=min(p_max,max(ptr,0)) 84 | return self.p_tr 85 | 86 | def cal_alpha(self,dlambda,alfmin,ite,alpha_U): 87 | h=self.data_buf*self.bandwidth*self.slot #different only because of data_buf 88 | M=self.gama*self.p_tr/(self.noise*self.bandwidth) 89 | h=h 90 | M=M 91 | alpha_L=alfmin 92 | # v_L=-h*np.log2(1+M/alpha_L)+h*M/(np.log(2)*(alpha_L+M))+dlambda 93 | # v_U=-h*np.log2(1+M/alpha_U)+h*M/(np.log(2)*(alpha_U+M))+dlambda 94 | # if v_L>0: 95 | # self.alpha=alfmin 96 | # return alfmin 97 | # elif v_U<0: 98 | # self.alpha=alpha_U 99 | # return alpha_U 100 | for i in range(ite): 101 | mid=(alpha_L+alpha_U)/2 102 | v_mid=-np.log2(1+M/mid)+M/(np.log(2)*(mid+M))+dlambda/(h+1e-3) 103 | if v_mid<0: 104 | alpha_L=mid 105 | elif v_mid>0: 106 | alpha_U=mid 107 | else: 108 | self.alpha=mid 109 | return mid 110 | self.alpha=mid 111 | return mid 112 | 113 | 114 | #update the UAV position according to the path 115 | def fresh_position(self,v,region_obstacle): #out=1 represents moving out of map 116 | out=0 117 | self.v=[] 118 | self.v=v.copy() 119 | width=self.region_ifo[-1]['width'] 120 | hight=self.region_ifo[-1]['hight'] 121 | self.position[0]=self.position[0]+v[0] 122 | self.position[1]=self.position[1]+v[1] 123 | # l0=self.r/np.sqrt(2) 124 | l0=0 125 | if self.position[0]>=width-l0: 126 | self.position[0]=width-l0 127 | out=1 128 | elif self.position[0]<=l0: 129 | out=1 130 | self.position[0]=l0 131 | 132 | if self.position[1]>=hight-l0: 133 | self.position[1]=hight-l0 134 | out=1 135 | elif self.position[1]<=l0: 136 | out=1 137 | self.position[1]=l0 138 | 139 | self.region_No=j_region(self.position,self.region_ifo) 140 | self.obs=region_obstacle[self.region_No] 141 | return out 142 | 143 | 144 | 145 | #Generate the local observation (Can be varied by different observation definition) 146 | def map_feature(self,datarate,UAVlist,E_wait): #return 84 84 2 feature 147 | size_f=84 148 | size_h=size_f/2 149 | sight=3 150 | position=np.zeros([size_f,size_f,2]) 151 | feature=np.zeros([size_f,size_f,1]) 152 | inrange=[] 153 | num_uav=len(UAVlist) 154 | for i in range(num_uav): #find neighbor UAVs 155 | ps=UAVlist[i].position 156 | No=UAVlist[i].No 157 | if No==self.No: 158 | inrange.append(No) 159 | continue 160 | if ps[0]>=self.position[0]-(size_h-1)*sight-self.r and ps[0]<=self.position[0]+size_h*sight+self.r and ps[1]>=self.position[1]-(size_h-1)*sight-self.r and ps[1]<=self.position[1]+size_h*sight+self.r: 161 | inrange.append(No) 162 | for i in range(size_f): #define positions of each points in the feature 163 | position[:,i,0]=self.position[0]-(size_h-1)*sight+sight*i 164 | position[i,:,1]=self.position[1]+(size_h-1)*sight-sight*i 165 | for i in range(84): 166 | for j in range(84): 167 | if position[i,j,0]<0 or position[i,j,0]>self.region_ifo[-1]['width'] or position[i,j,1]<0 or position[i,j,1]>self.region_ifo[-1]['hight']: 168 | feature[i,j,0]=0 169 | continue 170 | r_no=j_region([position[i,j,0],position[i,j,1]],self.region_ifo) #the region No with the current point in 171 | pos=find_pos(position[i,j,:]) 172 | feature[i,j,0]=datarate[r_no]*E_wait[pos[1],pos[0]] 173 | for k in range(len(inrange)): 174 | d=np.linalg.norm(np.array([position[i,j,0]-UAVlist[inrange[k]].position[0],position[i,j,1]-UAVlist[inrange[k]].position[1]])) 175 | if d<=self.r: 176 | if inrange[k]==self.No: 177 | continue 178 | else: 179 | if feature[i,j,0]>0: 180 | feature[i,j,0]=0 181 | feature[i,j,0]=feature[i,j,0]-8000 182 | feature=feature/100 183 | # break 184 | return feature.copy() --------------------------------------------------------------------------------