easy-rl/projects/parl_tutorials/DQN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1、定义算法\n",
    "相比于Q learning，DQN本质上是为了适应更为复杂的环境，并且经过不断的改良迭代，到了Nature DQN（即Volodymyr Mnih发表的Nature论文）这里才算是基本完善。DQN主要改动的点有三个：\n",
    "* 使用深度神经网络替代原来的Q表：这个很容易理解原因\n",
    "* 使用了经验回放（Replay Buffer）：这个好处有很多，一个是使用一堆历史数据去训练，比之前用一次就扔掉好多了，大大提高样本效率，另外一个是面试常提到的，减少样本之间的相关性，原则上获取经验跟学习阶段是分开的，原来时序的训练数据有可能是不稳定的，打乱之后再学习有助于提高训练的稳定性，跟深度学习中划分训练测试集时打乱样本是一个道理。\n",
    "* 使用了两个网络：即策略网络和目标网络，每隔若干步才把每步更新的策略网络参数复制给目标网络，这样做也是为了训练的稳定，避免Q值的估计发散。想象一下，如果当前有个transition（这个Q learning中提过的，一定要记住！！！）样本导致对Q值进行了较差的过估计，如果接下来从经验回放中提取到的样本正好连续几个都这样的，很有可能导致Q值的发散（它的青春小鸟一去不回来了）。再打个比方，我们玩RPG或者闯关类游戏，有些人为了破纪录经常Save和Load，只要我出了错，我不满意我就加载之前的存档，假设不允许加载呢，就像DQN算法一样训练过程中会退不了，这时候是不是搞两个档，一个档每帧都存一下，另外一个档打了不错的结果再存，也就是若干个间隔再存一下，到最后用间隔若干步数再存的档一般都比每帧都存的档好些呢。当然你也可以再搞更多个档，也就是DQN增加多个目标网络，但是对于DQN则没有多大必要，多几个网络效果不见得会好很多。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 定义模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[32m[09-26 17:18:11 MainThread @utils.py:73]\u001b[0m paddlepaddle version: 2.3.2.\n"
     ]
    }
   ],
   "source": [
    "\n",
    "import paddle\n",
    "import paddle.nn as nn\n",
    "import paddle.nn.functional as F\n",
    "import parl\n",
    "\n",
    "class MLP(parl.Model):\n",
    "    \"\"\" Linear network to solve Cartpole problem.\n",
    "    Args:\n",
    "        input_dim (int): Dimension of observation space.\n",
    "        output_dim (int): Dimension of action space.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, input_dim, output_dim):\n",
    "        super(MLP, self).__init__()\n",
    "        hidden_dim1 = 256\n",
    "        hidden_dim2 = 256\n",
    "        self.fc1 = nn.Linear(input_dim, hidden_dim1)\n",
    "        self.fc2 = nn.Linear(hidden_dim1, hidden_dim2)\n",
    "        self.fc3 = nn.Linear(hidden_dim2, output_dim)\n",
    "\n",
    "    def forward(self, state):\n",
    "        x = F.relu(self.fc1(state))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 定义经验回放"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "class ReplayBuffer:\n",
    "    def __init__(self, capacity: int) -> None:\n",
    "        self.capacity = capacity\n",
    "        self.buffer = deque(maxlen=self.capacity)\n",
    "    def push(self,transitions):\n",
    "        '''_summary_\n",
    "        Args:\n",
    "            trainsitions (tuple): _description_\n",
    "        '''\n",
    "        self.buffer.append(transitions)\n",
    "    def sample(self, batch_size: int, sequential: bool = False):\n",
    "        if batch_size > len(self.buffer):\n",
    "            batch_size = len(self.buffer)\n",
    "        if sequential: # sequential sampling\n",
    "            rand = random.randint(0, len(self.buffer) - batch_size)\n",
    "            batch = [self.buffer[i] for i in range(rand, rand + batch_size)]\n",
    "            return zip(*batch)\n",
    "        else:\n",
    "            batch = random.sample(self.buffer, batch_size)\n",
    "            return zip(*batch)\n",
    "    def clear(self):\n",
    "        self.buffer.clear()\n",
    "    def __len__(self):\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3 定义智能体"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import random\n",
    "import parl\n",
    "import paddle\n",
    "import math\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "class DQNAgent(parl.Agent):\n",
    "    \"\"\"Agent of DQN.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, algorithm, memory,cfg):\n",
    "        super(DQNAgent, self).__init__(algorithm)\n",
    "        self.n_actions = cfg['n_actions']\n",
    "        self.epsilon = cfg['epsilon_start']\n",
    "        self.sample_count = 0  \n",
    "        self.epsilon_start = cfg['epsilon_start']\n",
    "        self.epsilon_end = cfg['epsilon_end']\n",
    "        self.epsilon_decay = cfg['epsilon_decay']\n",
    "        self.batch_size = cfg['batch_size']\n",
    "        self.global_step = 0\n",
    "        self.update_target_steps = 600\n",
    "        self.memory = memory # replay buffer\n",
    "\n",
    "    def sample_action(self, state):\n",
    "        self.sample_count += 1\n",
    "        # epsilon must decay(linear,exponential and etc.) for balancing exploration and exploitation\n",
    "        self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \\\n",
    "            math.exp(-1. * self.sample_count / self.epsilon_decay) \n",
    "        if  random.random() < self.epsilon:\n",
    "            action = np.random.randint(self.n_actions)\n",
    "        else:\n",
    "            action = self.predict_action(state)\n",
    "        return action\n",
    "\n",
    "    def predict_action(self, state):\n",
    "        state = paddle.to_tensor(state , dtype='float32')\n",
    "        q_values = self.alg.predict(state) # self.alg 是自带的算法\n",
    "        action = q_values.argmax().numpy()[0]\n",
    "        return action\n",
    "\n",
    "    def update(self):\n",
    "        \"\"\"Update model with an episode data\n",
    "        Args:\n",
    "            obs(np.float32): shape of (batch_size, obs_dim)\n",
    "            act(np.int32): shape of (batch_size)\n",
    "            reward(np.float32): shape of (batch_size)\n",
    "            next_obs(np.float32): shape of (batch_size, obs_dim)\n",
    "            terminal(np.float32): shape of (batch_size)\n",
    "        Returns:\n",
    "            loss(float)\n",
    "        \"\"\"\n",
    "        if len(self.memory) < self.batch_size: # when transitions in memory donot meet a batch, not update\n",
    "            return\n",
    "        \n",
    "        if self.global_step % self.update_target_steps == 0:\n",
    "            self.alg.sync_target()\n",
    "        self.global_step += 1\n",
    "        state_batch, action_batch, reward_batch, next_state_batch, done_batch = self.memory.sample(\n",
    "            self.batch_size)\n",
    "        action_batch = np.expand_dims(action_batch, axis=-1)\n",
    "        reward_batch = np.expand_dims(reward_batch, axis=-1)\n",
    "        done_batch = np.expand_dims(done_batch, axis=-1)\n",
    "\n",
    "        state_batch = paddle.to_tensor(state_batch, dtype='float32')\n",
    "        action_batch = paddle.to_tensor(action_batch, dtype='int32')\n",
    "        reward_batch = paddle.to_tensor(reward_batch, dtype='float32')\n",
    "        next_state_batch = paddle.to_tensor(next_state_batch, dtype='float32')\n",
    "        done_batch = paddle.to_tensor(done_batch, dtype='float32')\n",
    "        loss = self.alg.learn(state_batch, action_batch, reward_batch, next_state_batch, done_batch) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 定义训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(cfg, env, agent):\n",
    "    ''' 训练\n",
    "    '''\n",
    "    print(f\"开始训练！\")\n",
    "    print(f\"环境：{cfg['env_name']}，算法：{cfg['algo_name']}，设备：{cfg['device']}\")\n",
    "    rewards = []  # record rewards for all episodes\n",
    "    steps = []\n",
    "    for i_ep in range(cfg[\"train_eps\"]):\n",
    "        ep_reward = 0  # reward per episode\n",
    "        ep_step = 0\n",
    "        state = env.reset()  # reset and obtain initial state\n",
    "        for _ in range(cfg['ep_max_steps']):\n",
    "            ep_step += 1\n",
    "            action = agent.sample_action(state)  # sample action\n",
    "            next_state, reward, done, _ = env.step(action)  # update env and return transitions\n",
    "            agent.memory.push((state, action, reward,next_state, done))  # save transitions\n",
    "            state = next_state  # update next state for env\n",
    "            agent.update()  # update agent\n",
    "            ep_reward += reward  #\n",
    "            if done:\n",
    "                break\n",
    "        steps.append(ep_step)\n",
    "        rewards.append(ep_reward)\n",
    "        if (i_ep + 1) % 10 == 0:\n",
    "            print(f\"回合：{i_ep+1}/{cfg['train_eps']}，奖励：{ep_reward:.2f}，Epislon: {agent.epsilon:.3f}\")\n",
    "    print(\"完成训练！\")\n",
    "    env.close()\n",
    "    res_dic = {'episodes':range(len(rewards)),'rewards':rewards,'steps':steps}\n",
    "    return res_dic\n",
    "\n",
    "def test(cfg, env, agent):\n",
    "    print(\"开始测试！\")\n",
    "    print(f\"环境：{cfg['env_name']}，算法：{cfg['algo_name']}，设备：{cfg['device']}\")\n",
    "    rewards = []  # record rewards for all episodes\n",
    "    steps = []\n",
    "    for i_ep in range(cfg['test_eps']):\n",
    "        ep_reward = 0  # reward per episode\n",
    "        ep_step = 0\n",
    "        state = env.reset()  # reset and obtain initial state\n",
    "        for _ in range(cfg['ep_max_steps']):\n",
    "            ep_step+=1\n",
    "            action = agent.predict_action(state)  # predict action\n",
    "            next_state, reward, done, _ = env.step(action)  \n",
    "            state = next_state  \n",
    "            ep_reward += reward \n",
    "            if done:\n",
    "                break\n",
    "        steps.append(ep_step)\n",
    "        rewards.append(ep_reward)\n",
    "        print(f\"回合：{i_ep+1}/{cfg['test_eps']}，奖励：{ep_reward:.2f}\")\n",
    "    print(\"完成测试！\")\n",
    "    env.close()\n",
    "    return {'episodes':range(len(rewards)),'rewards':rewards,'steps':steps}\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 定义环境"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/jj/opt/anaconda3/envs/easyrl/lib/python3.7/site-packages/gym/envs/registration.py:250: DeprecationWarning: SelectableGroups dict interface is deprecated. Use select.\n",
      "  for plugin in metadata.entry_points().get(entry_point, []):\n"
     ]
    }
   ],
   "source": [
    "import gym\n",
    "import paddle\n",
    "import numpy as np\n",
    "import random\n",
    "import os\n",
    "from parl.algorithms import DQN\n",
    "def all_seed(env,seed = 1):\n",
    "    ''' omnipotent seed for RL, attention the position of seed function, you'd better put it just following the env create function\n",
    "    Args:\n",
    "        env (_type_): \n",
    "        seed (int, optional): _description_. Defaults to 1.\n",
    "    '''\n",
    "    print(f\"seed = {seed}\")\n",
    "    env.seed(seed) # env config\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    paddle.seed(seed)\n",
    "    \n",
    "def env_agent_config(cfg):\n",
    "    ''' create env and agent\n",
    "    '''\n",
    "    env = gym.make(cfg['env_name']) \n",
    "    if cfg['seed'] !=0: # set random seed\n",
    "        all_seed(env,seed=cfg[\"seed\"]) \n",
    "    n_states = env.observation_space.shape[0] # print(hasattr(env.observation_space, 'n'))\n",
    "    n_actions = env.action_space.n  # action dimension\n",
    "    print(f\"n_states: {n_states}, n_actions: {n_actions}\")\n",
    "    cfg.update({\"n_states\":n_states,\"n_actions\":n_actions}) # update to cfg paramters\n",
    "    model = MLP(n_states,n_actions)\n",
    "    algo = DQN(model, gamma=cfg['gamma'], lr=cfg['lr'])\n",
    "    memory =  ReplayBuffer(cfg[\"memory_capacity\"]) # replay buffer\n",
    "    agent = DQNAgent(algo,memory,cfg)  # create agent\n",
    "    return env, agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. 设置参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/jj/opt/anaconda3/envs/easyrl/lib/python3.7/site-packages/seaborn/rcmod.py:82: DeprecationWarning: distutils Version classes are deprecated. Use packaging.version instead.\n",
      "  if LooseVersion(mpl.__version__) >= \"3.0\":\n",
      "/Users/jj/opt/anaconda3/envs/easyrl/lib/python3.7/site-packages/setuptools/_distutils/version.py:351: DeprecationWarning: distutils Version classes are deprecated. Use packaging.version instead.\n",
      "  other = LooseVersion(other)\n"
     ]
    }
   ],
   "source": [
    "import argparse\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "def get_args():\n",
    "    \"\"\" \n",
    "    \"\"\"\n",
    "    parser = argparse.ArgumentParser(description=\"hyperparameters\")      \n",
    "    parser.add_argument('--algo_name',default='DQN',type=str,help=\"name of algorithm\")\n",
    "    parser.add_argument('--env_name',default='CartPole-v0',type=str,help=\"name of environment\")\n",
    "    parser.add_argument('--train_eps',default=200,type=int,help=\"episodes of training\") # 训练的回合数\n",
    "    parser.add_argument('--test_eps',default=20,type=int,help=\"episodes of testing\") # 测试的回合数\n",
    "    parser.add_argument('--ep_max_steps',default = 100000,type=int,help=\"steps per episode, much larger value can simulate infinite steps\")\n",
    "    parser.add_argument('--gamma',default=0.99,type=float,help=\"discounted factor\") # 折扣因子\n",
    "    parser.add_argument('--epsilon_start',default=0.95,type=float,help=\"initial value of epsilon\") #  e-greedy策略中初始epsilon\n",
    "    parser.add_argument('--epsilon_end',default=0.01,type=float,help=\"final value of epsilon\") # e-greedy策略中的终止epsilon\n",
    "    parser.add_argument('--epsilon_decay',default=200,type=int,help=\"decay rate of epsilon\") # e-greedy策略中epsilon的衰减率\n",
    "    parser.add_argument('--memory_capacity',default=200000,type=int) # replay memory的容量\n",
    "    parser.add_argument('--memory_warmup_size',default=200,type=int) # replay memory的预热容量\n",
    "    parser.add_argument('--batch_size',default=64,type=int,help=\"batch size of training\") # 训练时每次使用的样本数\n",
    "    parser.add_argument('--targe_update_fre',default=200,type=int,help=\"frequency of target network update\") # target network更新频率\n",
    "    parser.add_argument('--seed',default=10,type=int,help=\"seed\") \n",
    "    parser.add_argument('--lr',default=0.0001,type=float,help=\"learning rate\")\n",
    "    parser.add_argument('--device',default='cpu',type=str,help=\"cpu or gpu\")  \n",
    "    args = parser.parse_args([])                \n",
    "    args = {**vars(args)}  # type(dict)         \n",
    "    return args\n",
    "def smooth(data, weight=0.9):  \n",
    "    '''用于平滑曲线，类似于Tensorboard中的smooth\n",
    "\n",
    "    Args:\n",
    "        data (List):输入数据\n",
    "        weight (Float): 平滑权重，处于0-1之间，数值越高说明越平滑，一般取0.9\n",
    "\n",
    "    Returns:\n",
    "        smoothed (List): 平滑后的数据\n",
    "    '''\n",
    "    last = data[0]  # First value in the plot (first timestep)\n",
    "    smoothed = list()\n",
    "    for point in data:\n",
    "        smoothed_val = last * weight + (1 - weight) * point  # 计算平滑值\n",
    "        smoothed.append(smoothed_val)                    \n",
    "        last = smoothed_val                                \n",
    "    return smoothed\n",
    "\n",
    "def plot_rewards(rewards,cfg,path=None,tag='train'):\n",
    "    sns.set()\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(f\"{tag}ing curve on {cfg['device']} of {cfg['algo_name']} for {cfg['env_name']}\")\n",
    "    plt.xlabel('epsiodes')\n",
    "    plt.plot(rewards, label='rewards')\n",
    "    plt.plot(smooth(rewards), label='smoothed')\n",
    "    plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. 收获成果！"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "seed = 10\n",
      "n_states: 4, n_actions: 2\n",
      "开始训练！\n",
      "环境：CartPole-v0，算法：DQN，设备：cpu\n",
      "回合：10/200，奖励：10.00，Epislon: 0.062\n",
      "回合：20/200，奖励：85.00，Epislon: 0.014\n",
      "回合：30/200，奖励：41.00，Epislon: 0.011\n",
      "回合：40/200，奖励：31.00，Epislon: 0.010\n",
      "回合：50/200，奖励：22.00，Epislon: 0.010\n",
      "回合：60/200，奖励：10.00，Epislon: 0.010\n",
      "回合：70/200，奖励：10.00，Epislon: 0.010\n",
      "回合：80/200，奖励：22.00，Epislon: 0.010\n",
      "回合：90/200，奖励：30.00，Epislon: 0.010\n",
      "回合：100/200，奖励：20.00，Epislon: 0.010\n",
      "回合：110/200，奖励：15.00，Epislon: 0.010\n",
      "回合：120/200，奖励：45.00，Epislon: 0.010\n",
      "回合：130/200，奖励：73.00，Epislon: 0.010\n",
      "回合：140/200，奖励：180.00，Epislon: 0.010\n",
      "回合：150/200，奖励：163.00，Epislon: 0.010\n",
      "回合：160/200，奖励：191.00，Epislon: 0.010\n",
      "回合：170/200，奖励：200.00，Epislon: 0.010\n",
      "回合：180/200，奖励：200.00，Epislon: 0.010\n",
      "回合：190/200，奖励：200.00，Epislon: 0.010\n",
      "回合：200/200，奖励：200.00，Epislon: 0.010\n",
      "完成训练！\n",
      "开始测试！\n",
      "环境：CartPole-v0，算法：DQN，设备：cpu\n",
      "回合：1/20，奖励：200.00\n",
      "回合：2/20，奖励：200.00\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/jj/opt/anaconda3/envs/easyrl/lib/python3.7/site-packages/seaborn/rcmod.py:400: DeprecationWarning: distutils Version classes are deprecated. Use packaging.version instead.\n",
      "  if LooseVersion(mpl.__version__) >= \"3.0\":\n",
      "/Users/jj/opt/anaconda3/envs/easyrl/lib/python3.7/site-packages/setuptools/_distutils/version.py:351: DeprecationWarning: distutils Version classes are deprecated. Use packaging.version instead.\n",
      "  other = LooseVersion(other)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "回合：3/20，奖励：200.00\n",
      "回合：4/20，奖励：200.00\n",
      "回合：5/20，奖励：200.00\n",
      "回合：6/20，奖励：200.00\n",
      "回合：7/20，奖励：200.00\n",
      "回合：8/20，奖励：193.00\n",
      "回合：9/20，奖励：200.00\n",
      "回合：10/20，奖励：200.00\n",
      "回合：11/20，奖励：200.00\n",
      "回合：12/20，奖励：200.00\n",
      "回合：13/20，奖励：200.00\n",
      "回合：14/20，奖励：194.00\n",
      "回合：15/20，奖励：200.00\n",
      "回合：16/20，奖励：200.00\n",
      "回合：17/20，奖励：200.00\n",
      "回合：18/20，奖励：200.00\n",
      "回合：19/20，奖励：199.00\n",
      "回合：20/20，奖励：200.00\n",
      "完成测试！\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 获取参数\n",
    "cfg = get_args() \n",
    "# 训练\n",
    "env, agent = env_agent_config(cfg)\n",
    "res_dic = train(cfg, env, agent)\n",
    " \n",
    "plot_rewards(res_dic['rewards'], cfg, tag=\"train\")  \n",
    "# 测试\n",
    "res_dic = test(cfg, env, agent)\n",
    "plot_rewards(res_dic['rewards'], cfg, tag=\"test\")  # 画出结果"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.13 ('easyrl')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "8994a120d39b6e6a2ecc94b4007f5314b68aa69fc88a7f00edf21be39b41f49c"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}