pytorch 笔记： DQN（experience replay）
1 理论知识
DQN 笔记 State-action Value Function(Q-function)_UQI-LIUWJ的博客-CSDN博客
强化学习笔记 experience replay 经验回放_UQI-LIUWJ的博客-CSDN博客
2 导入库
import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
import gym3 定义参数
BATCH_SIZE = 32
# 从experience buffer 每一次提取，用于训练的batch大小
LR = 0.01
# 学习率
EPSILON = 0.9
# 贪婪策略指数，Q-learning的一个指数，用于指示是探索还是利用。
GAMMA = 0.9
# 折扣回报
TARGET_REPLACE_ITER = 100
# target network的更新频率
#在100轮以内固定target network，每100轮更新一次
MEMORY_CAPACITY = 2000
#replay buffer 大小
env = gym.make('CartPole-v0')
N_ACTIONS = env.action_space.n
#2
#每一个state时可以有几个动作
N_STATES = env.observation_space.shape[0]
#4
#每一个state是几维的向量4 用于计算action 权重的神经网络
Net的作用是输入某一时刻的state向量，输出是各个action的值
这里相比于policy network，这里输出的时候不用softmax，因为这里是需要Q最大的action就可以了
class Net(nn.Module):
def __init__(self, ):
super(Net, self).__init__()
self.fc1 = nn.Linear(N_STATES, 50)
self.out = nn.Linear(50, N_ACTIONS)
def forward(self, x):
x = self.fc1(x)
x = F.relu(x)
actions_value = self.out(x)
return actions_value5 创建Q-learning 模型
5.1 __init__
# 创建Q-learning的模型
class DQN(object):
def __init__(self):
# 两张网结构上是一样的，不过就是target_net是每100次更新一次，eval_net每次都更新
self.eval_net, self.target_net = Net(), Net()
#eval_net:实时更新的Q的network
#target_net:每TARGET_REPLACE_ITER轮更新一次的target network
self.learn_step_counter = 0
# 如果次数到了，更新target_net，那么target_net更新的轮数重置
self.memory_counter = 0
# relay buffer 计数器
self.memory = np.zeros((MEMORY_CAPACITY, N_STATES * 2 + 2))
# relay buffer
self.optimizer = torch.optim.Adam(self.eval_net.parameters(), lr=LR)
self.loss_func = nn.MSELoss()5.2 选择动作
# 选择动作
def choose_action(self, x):
x = torch.unsqueeze(torch.FloatTensor(x), 0)
#print(state.shape)
#torch.size([1,4])
#当前状态s对应的向量，通过unsqueeze操作变成[1,4]维的向量
#之前设置了EPSILON，用于控制是使用还是探索
if np.random.uniform() < EPSILON:
# 贪婪策略
actions_value = self.eval_net(x)
#eval_net是一个Net 类
#actions_value 是每个action的Q值 (即Q(s,a)))
action = torch.max(actions_value, 1)[1].data.numpy()
#表示Q值最大的那个action的index
action = action[0]
# return the argmax index，在本例中，就是0或者1
else:
# random
action = np.random.randint(0, N_ACTIONS)
#此时使用的是探索
return action 5.3 存储记忆
将transition的结果存入experience buffer中
def store_transition(self, s, a, r, s_):
#s和s_是两个ndarray（当前状态，使用了某个action之后的状态）
# a和r是两个数，action和reward
transition = np.hstack((s, [a, r], s_))
# 将参数打包起来，成为一个长一元ndarray
index = self.memory_counter % MEMORY_CAPACITY
#当前的transition需要存入/覆盖的位置
self.memory[index, :] = transition
self.memory_counter += 1
#更新memory5.4 模型学习
def learn(self):
# target parameter update
if self.learn_step_counter % TARGET_REPLACE_ITER == 0:
self.target_net.load_state_dict(self.eval_net.state_dict())
#如果到了该更新target network的时候了，那么把eval_net此时的参数赋给target_net
self.learn_step_counter += 1
# target network的计数
sample_index = np.random.choice(MEMORY_CAPACITY, BATCH_SIZE)
#从relay buffer中选择一个batch的样本index（可以重复）
b_memory = self.memory[sample_index, :]
#通过上一行的index，从relay buffer中提取出这一个batch的记录
b_s = torch.FloatTensor(b_memory[:, :N_STATES])
b_a = torch.LongTensor(b_memory[:, N_STATES:N_STATES+1].astype(int))
b_r = torch.FloatTensor(b_memory[:, N_STATES+1:N_STATES+2])
b_s_ = torch.FloatTensor(b_memory[:, -N_STATES:])
#分别对应了这一个batch中的原始状态，该状态采取的动作，该状态的reward，该状态采取该动作之后的状态
q_eval = self.eval_net(b_s).gather(1, b_a)
# (batch, 1)
# self.eval_net(b_s)的输出是一个(batch,2)的tensor，相应的Q(s,a)
# 这里gather的操作是根据b_a是0还是1选择每一行的0还是1，也就是选择maxQ(s,a)
q_next = self.target_net(b_s_).detach()
# detach的作用就是不反向传播去更新，因为target的更新在前面定义好了的，每100轮更新一次
#q_nexts 是Q(s_t+1,a),由于target network不进行更新，所以将q_next detach出来
q_target = b_r + GAMMA * q_next.max(1)[0].view(BATCH_SIZE, 1)
#r_t+Γ max Q(s_t+1,a)
# shape (batch, 1)
loss = self.loss_func(q_eval, q_target)
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
#pytorch老三样6 使用&训练DQN
dqn = DQN()
#创建一个DQN network
print('\nCollecting experience...')
for i_episode in range(400):
#采集400个序列
s = env.reset()
# 重置当前环境状态。
#s表示初始化这一个episode的环境
#array([ 2.3993547 , 0.35676894, 0.00279927, -0.2451453 ], dtype=float32)
ep_r = 0
# ep_r表示每个episode中的reward
for t in range(1000):
#一个epsiode里面有1000步
#env.render()
#渲染环境，如果你是再服务器上跑的，只想出结果，不想看动态推杆过程的话，可以注释掉
a = dqn.choose_action(s)
#根据当前的状态s，选择当前回合合适的action
s_, r, done, info = env.step(a)
# 四个返回的内容是state,reward,done(是否重置环境),info
x, x_dot, theta, theta_dot = s_
#s的四个状态
r1 = (env.x_threshold - abs(x)) / env.x_threshold - 0.8
# r1代表车的 x水平位移 与 x最大边距 的距离差的得分
r2 = (env.theta_threshold_radians - abs(theta)) / env.theta_threshold_radians - 0.5
# r2代表杆的 与垂直线之间的夹角
r = r1 + r2
#修改reward，因为如果使用默认的reward的话可能不好训练，所以这里使用了修改后的reward
#杆越竖直，越靠近中心，奖励应该越大
dqn.store_transition(s, a, r, s_)
#状态，该状态使用的action，该状态使用这个action之后的奖励，之后的状态
#这些信息存储起来，放入relay buffer中
ep_r += r
#当前这轮episode的reward++
if dqn.memory_counter > MEMORY_CAPACITY:
#表明relay buffer中已经满了，也即是已经采样了一些样本，之后再进行training，那么就可以一边采样一边训练了
dqn.learn()
if done:
print('Ep: ', i_episode, '| Ep_r: ', round(ep_r, 2))
if done:
break
s = s_
'''
Collecting experience...
Ep: 203 | Ep_r: 1.29
Ep: 204 | Ep_r: 1.67
Ep: 205 | Ep_r: 1.36
Ep: 206 | Ep_r: 8.36
Ep: 207 | Ep_r: 3.23
Ep: 208 | Ep_r: 2.25
Ep: 209 | Ep_r: 1.12
Ep: 210 | Ep_r: 1.82
Ep: 211 | Ep_r: 3.1
Ep: 212 | Ep_r: 4.04
Ep: 213 | Ep_r: 1.26
'''loss function 如下：
