DQN代码注释_power control d2d dqn code

Intelligent Power Control for Spectrum Sharing in Cognitive Radios:A Deep Reinforcement Learning Approach——源码和注释

简介：（1）主要为文献《Intelligent Power Control for Spectrum Sharing in Cognitive Radios:A Deep Reinforcement Learning Approach》在github上的开源代码进行了注释，注释中添加了自己对于问题的一些理解和疑问。这个Python源码的程序入口为main函数。main函数中调用了DQN、Power_control两个作者独立完成的包和numpy、random两个python自带的包。对于这个源码，还有部分位置没有添加好注释，需要再花一点时间理解和消化代码的意义。（2）除了为这部分源码添加注释以外，最近还学习了教材《Python编程：从入门到实践》的一部分，尝试构造几个DQN和深度学习的模板，方便以后使用。

第一部分：DQN 包

import tensorflow as tf 
import numpy as np 
import random
from collections import deque #后面的部分可以直接调用，不在需要使用collections.deque了

GAMMA = 0.8  #在更新Q函数时的折损参数
OBSERVE = 300 
EXPLORE = 100000 
FINAL_EPSILON = 0.0 
INITIAL_EPSILON = 0.8 
REPLAY_MEMORY = 400 
BATCH_SIZE = 256 

class BrainDQN:

   def __init__(self,actions,Sensor):
        
      self.replayMemory = deque()  #replayMemory是一个双向进出的队列
      self.timeStep = 0
      self.epsilon = INITIAL_EPSILON
      self.recording = EXPLORE
      self.sensor_dim = Sensor
      self.actions = actions
      self.hidden1 = 256
      self.hidden2 = 256
      self.hidden3 = 512
        
      self.createQNetwork()

   def createQNetwork(self):  #以tf的方式搭建graph，然后完成初始化，这里的步骤只是在create，并没有开始跑

      W_fc1 = self.weight_variable([self.sensor_dim,self.hidden1])
      b_fc1 = self.bias_variable([self.hidden1])

      W_fc2 = self.weight_variable([self.hidden1,self.hidden2])
      b_fc2 = self.bias_variable([self.hidden2])
        
      W_fc3 = self.weight_variable([self.hidden2,self.hidden3])
      b_fc3 = self.bias_variable([self.hidden3])
        
      W_fc4 = self.weight_variable([self.hidden3,self.actions])
      b_fc4 = self.bias_variable([self.actions])  #设置Q网络的权重

      self.stateInput = tf.placeholder("float",[None,self.sensor_dim])      #DQN的输入值：是这10个感应器的结果
                                                                            #placeholder和feed_dic是一对相互搭配使用的函数，前者申请了一个必要的空间来放置需要的数据。后者则实时输入数据

      h_fc1 = tf.nn.relu(tf.matmul(self.stateInput,W_fc1) + b_fc1)
      h_fc2 = tf.nn.relu(tf.matmul(h_fc1,W_fc2) + b_fc2)
      h_fc3 = tf.nn.tanh(tf.matmul(h_fc2,W_fc3) + b_fc3)               #前面是在赋初始值，现在便把这个网络的隐藏层搭建好了
        
      self.QValue = tf.matmul(h_fc3,W_fc4) + b_fc4                     #现在是确定了输出值，输出值是QValue

      self.actionInput = tf.placeholder("float",[None,self.actions])
      self.yInput = tf.placeholder("float", [None])     #？？？？这里又定义了yInput和actionInput
      Q_action = tf.reduce_sum(tf.multiply(self.QValue, self.actionInput), reduction_indices = 1) #reduce_sum函数求和，后面的reduction_indices代表了求和的维度
      self.cost = tf.reduce_mean(tf.square(self.yInput - Q_action))  #这个self.cost就是我们使用adam算法要优化的东西，这里采用了一个求平均值函数
      self.trainStep = tf.train.AdamOptimizer(learning_rate=10**-5).minimize(self.cost)  #攒够数据调参的时候，使用的就是这个地方的Adam函数，learning_rate定义的是学习率，后面的minimize是指明了优化的变量是self.cost???那么在这里，调谁的参？

      self.session = tf.InteractiveSession()
      self.session.run(tf.global_variables_initializer())  #初始化语句

   def trainQNetwork(self):  #数据攒够了以后，就开始调用这个部分来训练q网络，没有输入的参数，故直接调用。返回值是self.loss，这里已经开始跑这个程序了
      minibatch = random.sample(self.replayMemory,BATCH_SIZE)  #随机地从replayMemory中取出BATCH_SIZE的数据，minibatch是一个BATCH_SIZE的数组，这里还没有对replayMemory进行赋值
      state_batch = [data[0] for data in minibatch]
      action_batch = [data[1] for data in minibatch]
      reward_batch = [data[2] for data in minibatch]
      nextState_batch = [data[3] for data in minibatch]  #猜测：定义了data数组，这个数组的0.1.2.3号元素分别存放了从minibatch中取得的s、a、r、s+1

      y_batch = []
      QValue_batch = self.QValue.eval(feed_dict={self.stateInput:nextState_batch})  #？？？？这里的.eval是什么意思
      for i in range(0,BATCH_SIZE):

         y_batch.append(reward_batch[i] + GAMMA * np.max(QValue_batch[i]))

      _, self.loss = self.session.run([self.trainStep,self.cost],feed_dict={
         self.yInput : y_batch,
         self.actionInput : action_batch,
         self.stateInput : state_batch
         })   #self.loss = self.session.run([self.trainStep,self.cost],feed_dict={self.yInput : y_batch,self.actionInput : action_batch,self.stateInput : state_batch}) ，要run的是trainStep和self.cost,但输入数据的数组不明白为什么是三组，且使用冒号连接在了一起。
      return self.loss
       #这之前的两个大函数trainqnetwork和creatqnetwork都没有调用后面的函数。

   def setPerception(self,nextObservation,action,reward):
      loss = 0
      newState = nextObservation
      self.replayMemory.append((self.currentState,action,reward,newState))
      if len(self.replayMemory) > REPLAY_MEMORY:
         self.replayMemory.popleft()
      if self.timeStep > OBSERVE:
            
         loss = self.trainQNetwork()    #如果时间步大于300，那么训练一次q网络？？？如何和积攒够400个数据联系在一起

      self.currentState = newState
      self.timeStep += 1  #时间步加1
      return loss  #loss=self.loss
        

   def getAction(self):  #Q网络已经生成结果，此时便是要决定是选择Q网络的输出结果还是按照某种概率去探索新的世界：得到当前时刻应该采取的动作
      QValue = self.QValue.eval(feed_dict= {self.stateInput:[self.currentState]})  #？？？？这里的.eval是什么意思
      action = np.zeros(self.actions)
      if random.random() <= self.epsilon:
         action_index = random.randrange(self.actions)  #rando.randrange函数返回递增集合中的一个随机数，这里的action_index相当于从action许用的下标中随机选中了一个，然后在下面的语句action[action_index]中调用
         action[action_index] = 1  #action集中某个元素被置为1表示选用这个集合中的这个元素作为当前的动作
      else:
         action_index = np.argmax(QValue)  #这时选用Q网络输出值中最大值作为当前的动作
         action[action_index] = 1
         
      if self.epsilon > FINAL_EPSILON and self.timeStep > OBSERVE:
         self.epsilon -= (INITIAL_EPSILON - FINAL_EPSILON)/EXPLORE   #根据步骤来更新epsilon
         self.recording = self.recording-1  #迭代的次数加一。换言之，每次迭代都需要调用这个getaction函数一次，迭代标志就是在这里改变的。

      return action,self.recording  #返回action表（本质上就是告知了应该选择哪个动作，然后再参照这个动作和环境进行互动）和剩余迭代次数。
    
   def getAction_test(self,observation):  #这里是所有的迭代次数已经完成，把agent投放到了环境当中实打实地去进行工作时的调用
      QValue = self.QValue.eval(feed_dict= {self.stateInput:[observation]})
      action = np.zeros(self.actions)
      action_index = np.argmax(QValue)   #这里不再采用贪心算法，直接采用q网络输出值中的最好动作即可
      action[action_index] = 1

      return action
    
   def setInitState(self,observation):  #把观察到的情况输入到这个函数中作为当前时间的状态值，然后参与到上面replayMemory的工作中去。
      self.currentState = observation

   def weight_variable(self,shape):  #和下面的bias_variable一样，都是在createQnetwork时使用的辅助函数，需要调用TF包中的相关函数
      initial = tf.truncated_normal(shape)
      return tf.Variable(initial)

   def bias_variable(self,shape):
      initial = tf.constant(0.01, shape = shape)
      return tf.Variable(initial

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

第二部分：power_control包

import random
import numpy as np
import math

class GameState: #环境生成模拟器
    def __init__(self,P_1,P_2,Noise,Sensor):  #初始化函数，将需要的增益、噪声、数量等参数输入
        
        self.P_1 = P_1
        self.P_2 = P_2
        self.length_P_1 = len(self.P_1)
        self.length_P_2 = len(self.P_2)
        
        self.h_11 = 1;self.h_12 = 1
        self.h_21 = 1;self.h_22 = 1
        
        self.ita_1 = 1.2
        self.ita_2 = 0.7
        
        self.sigma_sq_1 = 0.01
        self.sigma_sq_2 = 0.01
        
        self.lam = 0.1
        self.alpha = 0.5  #这个alpha是什么？

        self.num_sensor = Sensor
        self.noise = Noise
        
        self.P,self.sigma = self.dis()  #初始化时级调用了self.dis
        
    def dis(self):  #猜测：这个diss就是代表了discover，就是这个sense node感知到的具体结果，具体结果的表达式就是38行的sigma数组，这个数组中存放了感知的所有结果
        d = [[random.uniform(100,300) for _ in range(self.num_sensor)] for _ in range(2)]  #d阵代表了距离
        P = np.zeros((2,self.num_sensor))
        for i in range(0,self.num_sensor):
            P[0][i] = ((self.lam/(4*math.pi)/d[0][i])**2)  #P阵是一个二维数组，第一行存放的是主用户的信道衰落，第二行存放的是次用户的信道衰落
            P[1][i] = ((self.lam/(4*math.pi)/d[1][i])**2)
        sigma = np.zeros((self.num_sensor))
        for i in range(0,self.num_sensor):
            sigma[i] = ( P[0][i]*self.P_1[0]+P[1][i]*self.P_2[0] )/ self.noise
        return P,sigma

        # 猜测，感知节点也不知道PUS和SUS使用功率的具体情况，它所能测到的其实就是这个表达是的“值”，只不过我们在仿真的过程中是知道这个值诞生的原因的。
        # 换言之，我们在构造DQN时，这种输入的state是可以很模糊的。在这里我们不需要知道PUS和SUs具体的情况，我们只需要知道当前固定频段上的噪声结果（包括了环境噪声和使用这个频段所有用户通信功率造成的噪声）。
        # 再进一步考虑，我们可不可以设置这样一种并行的DQN？比如现在我们面临5个频段，在每个时刻，都在每个频段上去训练这个DQN网络，单个的DQN网络输出的结果是在这个频段上最优的许用功率，然后在这个DQN外面
        # 再嵌套一个？优先级列表？选择器来决定使用哪个频段。从而把这个问题分解为了2个步骤，第一步先求每个频段的最优功率，第二步再选择最优频段
        # 需要解决的问题：
        # （1）可否参考ADMM算法，分步解决需要解决的问题，细化更多的部分
        # （2）分步在每个频段上做DQN时，环境的变化如何处理？换言之，这个MDP过程需要输出一个结果，但这个action结果是需要优先级选择器来决定的
        # （3）是否存在分部DQN的东西？
    def ini(self):
        self.p_1 = self.P_1[random.randint(0,self.length_P_1-1)]
        self.p_2 = self.P_2[random.randint(0,self.length_P_2-1)]

    def ini_test(self):
        self.p_1_test = self.P_1[random.randint(0,self.length_P_1-1)]
        self.p_2_test = self.P_2[random.randint(0,self.length_P_2-1)]
    
    def frame_step(self, input_actions, policy, i):
        if i == True:
            if policy == 1:
                self.p_1 = self.update_p1_v1(self.p_2)
            if policy == 2:
                self.p_1 = self.update_p1_v2(self.p_1,self.p_2)
            action = np.flatnonzero(input_actions)[0]   # Return indices that are non-zero in the flattened version of a.
            # 返回非零元素的下标。
            self.p_2 = self.P_2[action]
        observation = self.compute_observation(self.p_1,self.p_2)
        reward = self.compute_reward(self.p_1,self.p_2)
        
        terminal = (reward==10)
        
        return observation,reward,terminal
    
    def frame_step_test(self, input_actions, policy, i):
        if i == True:
            if policy == 1:
                self.p_1_test = self.update_p1_v1(self.p_2_test)
            if policy == 2:
                self.p_1_test = self.update_p1_v2(self.p_1_test,self.p_2_test)
            action = np.flatnonzero(input_actions)[0]
            self.p_2_test = self.P_2[action]
        observation = self.compute_observation(self.p_1_test,self.p_2_test)
        reward = self.compute_reward(self.p_1_test,self.p_2_test)
        
        terminal = (reward==10)  # 当reward==10时，作为terminal的标志。
        
        return observation,reward,terminal
    
    def compute_observation(self,x,y):   # 感知器观察到的环境状态，存储在observation数组中，输入是PU和SU正在使用的功率
        observation = np.zeros((self.num_sensor))
        for i in range(0,self.num_sensor):
            observation[i] = self.P[0][i] * x + self.P[1][i] * y + random.gauss(0,self.sigma[i])  #Pnrk表示目前的状态空间
            if observation[i]<0:
                observation[i] =0
            observation[i] = observation[i]*(10**7)#乘了10的七次方
        return observation
    
    def compute_reward(self,x,y):
        success_1,success_2 = self.compute_SINR(x,y)
        reward = self.alpha * success_1 + (1-self.alpha) * success_2
        if reward == 0.5:
            reward = 0
        if reward == 1:
            reward = 10
        return reward
    
    def update_p1_v1(self,y):  #主用户的第一种更新方式
        p_1_n = self.ita_1/((abs(self.h_11)**2)/((abs(self.h_21)**2)*y + self.sigma_sq_1))
        v = []
        for ind in range(self.length_P_1):
            v.append(max(p_1_n-self.P_1[ind],0))
        p_1_new = self.P_1[v.index(min(v))]
        return p_1_new
    
    def update_p1_v2(self,x,y):  #主用户的第二种更新方式
        ind_p_1 = self.P_1.index(x)
        tSINR_1 = ((abs(self.h_11)**2)*x/((abs(self.h_21)**2)*y + self.sigma_sq_1))
        tao = x * self.ita_1 / tSINR_1
        if tao>=x and ind_p_1+1<=self.length_P_1-1 and tao<=self.P_1[ind_p_1+1] :
            x = self.P_1[ind_p_1+1]
        elif ind_p_1-1>=0 and tao<=self.P_1[ind_p_1-1] :
            x = self.P_1[ind_p_1-1]
        return x
    
    def compute_SINR(self,x,y):
        success_1 = ( (abs(self.h_11)**2)*x/((abs(self.h_21)**2)*y + self.sigma_sq_1)) >= self.ita_1
        success_2 = ( (abs(self.h_22)**2)*y/((abs(self.h_12)**2)*x + self.sigma_sq_2)) >= self.ita_2
        return success_1,success_2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

第三部分：main函数

from power_control import GameState
from DQN import BrainDQN
import numpy as np
import matplotlib.pyplot as plt

P_1 = [round(0.1*i/2.0,2) for i in range(1,9)]
P_2 = [round(0.1*i/2.0,2) for i in range(1,9)]  #round返回浮点数的四舍五入值
actions = len(P_2) #返回数组P_2的长度，这里的长度是9

Loss = []
Success = []
Fre = []

noise = 3      
num_sensor = 10  # N 
policy = 2      # choose power change policy for PU, it should be 1(Multi-step) or 2(Single step)

brain = BrainDQN(actions,num_sensor) #DQN模拟生成器，需要告知动作空间的个数、感知器的数量
com = GameState(P_1,P_2,noise,num_sensor)#一个环境模拟生成器，告知PU和SU的功率表，噪声，感知器的数量。
terminal =True
recording = 100000  #迭代次数标记，这里需要迭代100000次，然后使用下面的100000-recording来表示当前正在迭代的次数

while(recording>0):   #每次迭代都需要执行这个函数段
    # initialization
    if(terminal ==True):
        com.ini() #环境模拟生成器的初始化
        observation0, reward0, terminal = com.frame_step(np.zeros(actions),policy,False)
        brain.setInitState(observation0)

    # train  train和test是分开的，train完以后，Q网络就训练完了，这时候可以直接投放到环境中去运作
    action,recording = brain.getAction()  #每次迭代都按照DQN包中的函数来得到本次迭代选择的action（返回值是一个数组，这个数组里面被赋值为1的action便是本次迭代选择的动作）
    nextObservation,reward,terminal = com.frame_step(action,policy,True)  #取得了action列表，我们就要按照和这个action和环境互动了
    loss = brain.setPerception(nextObservation,action,reward)  #得到本次的loss值

    # test  只有在500的整数倍时，才test一次。？？？？那么攒够一定的次数才调参是怎样呢？
    if (recording+1)%500==0:
        
        Loss.append(loss) #append把元素添加到列表末尾
        print("iteration : %d , loss : %f ." %(100000-recording, loss))
        
        success = 0.0
        fre = 0
        num = 1000.0
        for ind in range(1000):   #每次test阶段，都使用1000个时间点，来得到把agent放到环境里时的实际情况，这里的run和最终的test不一样，这里只是验证当前训练步骤下能不能收敛（通过成功率、平均步数来衡量成功率）
            T = 0
            com.ini_test()
            observation0_test, reward_test, terminal_test = com.frame_step_test(np.zeros(actions),policy,False)
            while (terminal_test !=True) and T<20:
                action_test = brain.getAction_test(observation0_test)
                observation0_test,reward_test,terminal_test = com.frame_step_test(action_test,policy,True)
                T +=1
            if terminal_test==True:
                success +=1
                fre +=T
        if success == 0:
            fre = 0
        else:
            fre = fre/success
        success = success/num
        Success.append(success)
        Fre.append(fre)
        print("success : %f , step : %f ." %(success , fre))
        
plt.plot(Loss)    #最后一次test时生成Loss的结果生成图片
plt.show()

plt.plot(Success)
plt.show()

plt.plot(Fre)
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71