强化学习--Pytorch--DQN

DQN的学习效果还是很惊艳的，首先放上本次实验的代码。和官方给出的例子一样，是托举平衡杆的问题。
给出视频链接：强化学习DQN

import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
from torch.autograd import Variable
import gym
 
# 超参数
BATCH_SIZE = 32
LR = 0.01  # learning rate
# 强化学习的参数
EPSILON = 0.9  # greedy policy
GAMMA = 0.9  # reward discount
TARGET_REPLACE_ITER = 200  # target update frequency
MEMORY_CAPACITY = 2000
# 导入实验环境
env = gym.make('CartPole-v0')
env = env.unwrapped
N_ACTIONS = env.action_space.n
N_STATES = env.observation_space.shape[0]
 
 
class Net(nn.Module):
    def __init__(self, ):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(N_STATES, 10)
        self.fc1.weight.data.normal_(0, 0.1)  # 初始化
        self.out = nn.Linear(10, N_ACTIONS)
        self.out.weight.data.normal_(0, 0.1)  # 初始化
 
    def forward(self, x):
        x = self.fc1(x)
        x = F.relu(x)
        actions_value = self.out(x)
        return actions_value
 
class DQN(object):
    def __init__(self):
        self.eval_net, self.target_net = Net(), Net()
        # 记录学习到多少步
        self.learn_step_counter = 0  # for target update
        self.memory_counter = 0  # for storing memory
        # 初始化memory
        self.memory = np.zeros((MEMORY_CAPACITY, N_STATES * 2 + 2))
        self.optimizer = torch.optim.Adam(self.eval_net.parameters(), lr=LR) 
        self.loss_func = nn.MSELoss()
 
    def choose_action(self, x):
        x = Variable(torch.unsqueeze(torch.FloatTensor(x), 0))
        if np.random.uniform() < EPSILON:
            action_value = self.eval_net.forward(x)
            action = torch.max(action_value, 1)[1].data.numpy()[0]
        else: # random
            action = np.random.randint(0, N_ACTIONS)
        return action
 
    # s:当前状态， a:动作, r:reward奖励, s_:下一步状态
    def store_transaction(self, s, a, r, s_):
        transaction = np.hstack((s, [a, r], s_))   
        # replace the old memory with new memory
        index = self.memory_counter % MEMORY_CAPACITY
        self.memory[index, :] = transaction
        self.memory_counter += 1
 
    def learn(self):
        # target net update
        if self.learn_step_counter % TARGET_REPLACE_ITER == 0:
            self.target_net.load_state_dict(self.eval_net.state_dict()) 
        self.learn_step_counter += 1
        sample_index = np.random.choice(MEMORY_CAPACITY, BATCH_SIZE)   #从2000中随机抽取32个样本
        b_memory = self.memory[sample_index, :]        #通过索引找到对应的值
        b_s = Variable(torch.FloatTensor(b_memory[:, :N_STATES]))   
        b_a = Variable(torch.LongTensor(b_memory[:, N_STATES: N_STATES+1].astype(int)))
        b_r = Variable(torch.FloatTensor(b_memory[:, N_STATES + 1: N_STATES+2]))
        b_s_ = Variable(torch.FloatTensor(b_memory[:, -N_STATES: ]))
 
        q_eval = self.eval_net(b_s).gather(1, b_a)
        q_next = self.target_net(b_s_).detach()
        # here = q_next.max(1)[0]
        # there = torch.reshape(here,(32,1))
        # print(there)
        # there = torch.transpose(here,0,1)
        q_target = b_r + GAMMA * q_next.max(1)[0].reshape((32,1))
        # here = here*GAMMA
        loss = self.loss_func(q_eval, q_target)
        self.optimizer.zero_grad()
        loss.backward()
        self.optimizer.step()
 
 
dqn = DQN()
print('\nCollecting experience...')
for i_episode in range(4000):
    s = env.reset()
    while True:
        env.render()
 
        a = dqn.choose_action(s)
        # take action
        s_, r, done, info = env.step(a)
 
        # modify the reward
        x, x_dot, theta, theta_dot = s_
        r1 = (env.x_threshold - abs(x)) / env.x_threshold - 0.8
        r2 = (env.theta_threshold_radians - abs(theta)) / env.theta_threshold_radians - 0.5
        r = r1 + r2
 
        dqn.store_transaction(s, a, r, s_)
        print(str(dqn.memory_counter) +'\t'+ str(i_episode))
 
        if dqn.memory_counter > MEMORY_CAPACITY:
            dqn.learn()
 
        if done:
            break
        s = s_

1. DQN如上文所说，采用的是两个神经网络，在程序中为eval_net和target_net，两个神经网络具有相同的结构，不同之处是一个实时更新权重，一个间隔一定周期更新权重TARGET_REPLACE_ITER 。
2. DQN的精髓之处在于 Experience learning 和 Fix-Q target。首先，程序刚开始运行的时候，前2000步都是在积累经验，这个地方和记忆池是一个容量大小。也就是说前2000步，eval_net是一直都有输出的，给定state，输出action。然后通过Q-learning的思想进行贪婪选择，执行。而 target_net此时没有参与（有权重初值的）。当2000步骤之后，开始学习，也就是开始更新神经网络了。
3. 更新神经网络的时候，先从 记忆池 中随机抽取一定的记忆（batch = 32），然后用s输入给 eval_net，将 s_ 输入给target_net。得到 q_eval 和 q_next， 然后计算loss, 反向更新神经网络权重。这里需要注意的是，target_net 并不参与权重的更新，仍然保留着之前的参数，等到一定的间隔时候，才进行神经网络权值的直接copy。
4. 每次训练神经网络的时候都取出一批数据进行训练，一方面随机取出，大大减少了数据之间的相关性，另一方面，加快了训练的步伐，效果还是挺明显的。