深度强化学习 DQN算法

目录

 

一.算法介绍

二.算法原理

三.代码实现[1]

参考

---

 

一.算法介绍

        DQN算法，英文名为Deep Q Network，被称为深度Q网络，其将深度神经网络结合了Q-learning。传统的Q-learning使用表格的方式记录状态、动作对应的Q值，这样的方法在处理大规模问题上会占用极大的内存，可能存在的状态数量过于庞大无法列出表格，即维度爆炸。因此科学家们将神经网络与Q-learning进行结合，用神经网络就不再需要表格来记录Q值。

二.算法原理

DQN算法与q-learning的训练原理都是最大化未来的奖励。

DQN算法与很多强化学习算法使用bellman方程迭代更新估计动作价值函数不同，因为动作价值函数是针对每一个单独序列单独估计，不适用于为了减少数据相关性而设置的经验池训练机制。在实践中常使用函数逼近器估计动作价值函数。具有权重的神经网络被称为Q网络，通过最小化每次迭代t处产生的损失函数来对Q网络进行训练。

其中，是迭代t的目标，对上式求梯度，得到损失值的梯度计算公式如下：

计算时，通过随机梯度下降优化损失函数。

三.代码实现[1]

import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
import gym
import copy
#超参数
BATCH_SIZE = 32
LR = 0.01
EPSILON = 0.9 #随机选取的概率，如果概率小于这个随机数，就采取greedy的行为
GAMMA = 0.9
TARGET_REPLACE_ITER = 100
MEMORY_CAPACITY = 2000
#导入openAI gym实验的模拟场所，'CartPole-v0'表示倒立摆的实验
env = gym.make('CartPole-v0')
#env = env.unwrapped
N_ACTIONS = env.action_space.n #小车的动作
N_STATES = env.observation_space.shape[0] #实验环境的状态
ENV_A_SHAPE = 0 if isinstance(env.action_space.sample(), int) else env.action_space.sample().shape
class Net(nn.Module):
    def __init__(self, ):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(N_STATES, 500)
        self.fc1.weight.data.normal_(0, 0.1)   # initialization
        self.out = nn.Linear(500, N_ACTIONS)
        self.out.weight.data.normal_(0, 0.1)   # initialization
    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):
        #DQN是Q-Leaarning的一种方法，但是有两个神经网络，一个是eval_net一个是target_net
        #两个神经网络相同，参数不同，是不是把eval_net的参数转化成target_net的参数，产生延迟的效果
        self.eval_net=Net()
        self.target_net =copy.deepcopy(self.eval_net)
        self.learn_step_counter = 0 #学习步数计数器
        self.memory_counter = 0 #记忆库中位值的计数器
        self.memory = np.zeros((MEMORY_CAPACITY,N_STATES * 2 + 2)) #初始化记忆库
        #记忆库初始化为全0，存储两个state的数值加上一个a(action)和一个r(reward)的数值
        self.optimizer = torch.optim.Adam(self.eval_net.parameters(),lr = LR)
        self.loss_func = nn.MSELoss() #优化器和损失函数    
    #接收环境中的观测值，并采取动作
    def choose_action(self,x):
        #x为观测值
        x = torch.unsqueeze(torch.FloatTensor(x),0)
        if np.random.uniform() < EPSILON:
            #随机值得到的数有百分之九十的可能性<0.9,所以该if成立的几率是90%
            #90%的情况下采取actions_value高的作为最终动作
            actions_value = self.eval_net.forward(x)
            action = torch.max(actions_value,1)[1].data.numpy()
            action = action[0] if ENV_A_SHAPE == 0 else action.reshape(ENV_A_SHAPE) # return the argmax index
        else:
            #其他10%采取随机选取动作
            action = np.random.randint(0,N_ACTIONS) #从动作中选一个动作
            action = action if ENV_A_SHAPE == 0 else action.reshape(ENV_A_SHAPE)
        return action    
    #记忆库，存储之前的记忆，学习之前的记忆库里的东西
    def store_transition(self,s,a,r,s_):
        transition = np.hstack((s, [a, r], s_))
        # 如果记忆库满了, 就覆盖老数据
        index = self.memory_counter % MEMORY_CAPACITY
        self.memory[index, :] = transition
        self.memory_counter += 1
    def learn(self):
         # target net 参数更新,每隔TARGET_REPLACE_ITE更新一下
        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
        #targetnet是时不时更新一下，evalnet是每一步都更新

        # 抽取记忆库中的批数据
        sample_index = np.random.choice(MEMORY_CAPACITY, BATCH_SIZE)
        b_memory = self.memory[sample_index, :] 
        #打包记忆，分开保存进b_s，b_a，b_r，b_s
        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:])

        # 针对做过的动作b_a, 来选 q_eval 的值, (q_eval 原本有所有动作的值)
        q_eval = self.eval_net(b_s).gather(1, b_a)  # shape (batch, 1)
        q_next = self.target_net(b_s_).detach()     # q_next 不进行反向传递误差, 所以 detach
        q_target = b_r + GAMMA * q_next.max(1)[0]   # shape (batch, 1)
        loss = self.loss_func(q_eval, q_target)

        # 计算, 更新 eval net
        self.optimizer.zero_grad()
        loss.backward() #误差反向传播
        self.optimizer.step()
    
dqn = DQN()

print('\nCollection experience...')
for i_episode in range(400000):
    s = env.reset() #得到环境的反馈，现在的状态
    ep_r = 0
    EPSILON=1.0-0.1/(i_episode+1)
    while True:
        #env.render() #环境渲染，可以看到屏幕上的环境
        a = dqn.choose_action(s) #根据dqn来接受现在的状态，得到一个行为
        s_,r,done,info = env.step(a) #根据环境的行为，给出一个反馈

        
        # 修改 reward, 使 DQN 快速学习
        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_transition(s,a,r,s_) #dqn存储现在的状态，行为，反馈，和环境导引的下一个状态
        
        ep_r += r
        
        if dqn.memory_counter > MEMORY_CAPACITY:
            dqn.learn()
            if done:
                print('Ep: ', i_episode,
                      '| Ep_r: ', round(ep_r, 2))
        
        if done:
            f = open('rewarddata.txt','a', encoding='utf-8')
            f.write(str(ep_r)+'\n')
            f.close()
            break
        
        s = s_ # 现在的状态赋值到下一个状态上去
#测试
while True:
    s = env.reset() #得到环境的反馈，现在的状态
    while True:
        env.render() #环境渲染，可以看到屏幕上的环境
        a = dqn.choose_action(s) #根据dqn来接受现在的状态，得到一个行为
        s_,r,done,info = env.step(a) #根据环境的行为，给出一个反馈
        if done:
            break

训练过程：

 

训练结果：

 

 

参考

[1]pytorch实现DQN_逆夏11111的博客-CSDN博客_dqn pytorch