notebooks/Deep_Sarsa.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1、定义算法"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1、定义模型\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "class MLP(nn.Module):\n",
    "    def __init__(self, state_dim,action_dim,hidden_dim=128):\n",
    "        \"\"\" 初始化q网络，为全连接网络\n",
    "        \"\"\"\n",
    "        super(MLP, self).__init__()\n",
    "        self.fc1 = nn.Linear(state_dim, hidden_dim) # 输入层\n",
    "        self.fc2 = nn.Linear(hidden_dim,hidden_dim) # 隐藏层\n",
    "        self.fc3 = nn.Linear(hidden_dim, action_dim) # 输出层\n",
    "        \n",
    "    def forward(self, x):\n",
    "        # 各层对应的激活函数\n",
    "        x = F.relu(self.fc1(x)) \n",
    "        x = F.relu(self.fc2(x))\n",
    "        return self.fc3(x)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2、定义经验回放\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "import random\n",
    "class ReplayBuffer(object):\n",
    "    def __init__(self, capacity: int) -> None:\n",
    "        self.capacity = capacity\n",
    "        self.buffer = deque(maxlen=self.capacity)\n",
    "    def push(self,transitions):\n",
    "        ''' 存储transition到经验回放中\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: # 顺序采样\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",
    "        ''' 清空经验回放\n",
    "        '''\n",
    "        self.buffer.clear()\n",
    "    def __len__(self):\n",
    "        ''' 返回当前存储的量\n",
    "        '''\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.optim as optim\n",
    "import math\n",
    "import numpy as np\n",
    "class DQN:\n",
    "    def __init__(self,model,memory,cfg):\n",
    "\n",
    "        self.action_dim = cfg.action_dim  \n",
    "        self.device = torch.device(cfg.device) \n",
    "        self.gamma = cfg.gamma # 奖励的折扣因子\n",
    "        # e-greedy策略相关参数\n",
    "        self.sample_count = 0  # 用于epsilon的衰减计数\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.policy_net = model.to(self.device)\n",
    "        self.target_net = model.to(self.device)\n",
    "        # 复制参数到目标网络\n",
    "        for target_param, param in zip(self.target_net.parameters(),self.policy_net.parameters()): \n",
    "            target_param.data.copy_(param.data)\n",
    "        self.optimizer = optim.Adam(self.policy_net.parameters(), lr=cfg.lr) # 优化器\n",
    "        self.memory = memory # 经验回放\n",
    "    def sample_action(self, state):\n",
    "        ''' 采样动作\n",
    "        '''\n",
    "        self.sample_count += 1\n",
    "        # epsilon指数衰减\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",
    "            with torch.no_grad():\n",
    "                state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "                q_values = self.policy_net(state)\n",
    "                action = q_values.max(1)[1].item() # choose action corresponding to the maximum q value\n",
    "        else:\n",
    "            action = random.randrange(self.action_dim)\n",
    "        return action\n",
    "    @torch.no_grad() # 不计算梯度，该装饰器效果等同于with torch.no_grad()：\n",
    "    def predict_action(self, state):\n",
    "        ''' 预测动作\n",
    "        '''\n",
    "        state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "        q_values = self.policy_net(state)\n",
    "        action = q_values.max(1)[1].item() # choose action corresponding to the maximum q value\n",
    "        return action\n",
    "    def update(self):\n",
    "        if len(self.memory) < self.batch_size: \n",
    "            return\n",
    "        state_batch, action_batch, reward_batch, next_state_batch, done_batch = self.memory.sample(\n",
    "            self.batch_size)\n",
    "        state_batch = torch.tensor(np.array(state_batch), device=self.device, dtype=torch.float)\n",
    "        action_batch = torch.tensor(action_batch, device=self.device).unsqueeze(1)  \n",
    "        reward_batch = torch.tensor(reward_batch, device=self.device, dtype=torch.float).unsqueeze(1)  \n",
    "        next_state_batch = torch.tensor(np.array(next_state_batch), device=self.device, dtype=torch.float)\n",
    "        next_action_batch = self.policy_net(next_state_batch).detach().max(1)[1].unsqueeze(1)\n",
    "        done_batch = torch.tensor(np.float32(done_batch), device=self.device).unsqueeze(1)\n",
    "        q_values = self.policy_net(state_batch).gather(dim=1, index=action_batch) \n",
    "        next_q_values = self.target_net(next_state_batch).gather(dim=1, index=next_action_batch) \n",
    "        expected_q_values = reward_batch + self.gamma * next_q_values * (1-done_batch)\n",
    "        loss = nn.MSELoss()(q_values, expected_q_values)  \n",
    "        self.optimizer.zero_grad()  \n",
    "        loss.backward()\n",
    "        for param in self.policy_net.parameters():  \n",
    "            param.grad.data.clamp_(-1, 1)\n",
    "        self.optimizer.step()  "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2、定义训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(cfg, env, agent):\n",
    "    ''' 训练\n",
    "    '''\n",
    "    print(\"开始训练！\")\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    steps = []\n",
    "    for i_ep in range(cfg.train_eps):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state, info = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_steps):\n",
    "            ep_step += 1\n",
    "            action = agent.sample_action(state)  # 选择动作\n",
    "            next_state, reward, terminated, truncated , info = env.step(action)  # 更新环境，返回transition\n",
    "            agent.memory.push((state, action, reward, next_state, terminated))  # 保存transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            agent.update()  # 更新智能体\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if terminated:\n",
    "                break\n",
    "        if (i_ep + 1) % cfg.target_update == 0:  # 智能体目标网络更新\n",
    "            agent.target_net.load_state_dict(agent.policy_net.state_dict())\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",
    "    return {'rewards':rewards}\n",
    "\n",
    "def test(cfg, env, agent):\n",
    "    print(\"开始测试！\")\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    steps = []\n",
    "    for i_ep in range(cfg.test_eps):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state, info = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_steps):\n",
    "            ep_step+=1\n",
    "            action = agent.predict_action(state)  # 选择动作\n",
    "            next_state, reward, terminated, truncated , info = env.step(action)  # 更新环境，返回transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if terminated:\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 {'rewards':rewards}"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 定义环境"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gymnasium as gym\n",
    "import os\n",
    "def all_seed(seed = 1):\n",
    "    ''' 万能的seed函数\n",
    "    '''\n",
    "    if seed == 0: # 不设置seed\n",
    "        return \n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed) # config for CPU\n",
    "    torch.cuda.manual_seed(seed) # config for GPU\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n",
    "    # config for cudnn\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.enabled = False\n",
    "def env_agent_config(cfg):\n",
    "    env = gym.make(cfg.env_id) # 创建环境\n",
    "    all_seed(seed=cfg.seed)\n",
    "    state_dim = env.observation_space.shape[0]\n",
    "    action_dim = env.action_space.n\n",
    "    print(f\"状态空间维度：{state_dim}，动作空间维度：{action_dim}\")\n",
    "    setattr(cfg,\"state_dim\",state_dim) # 更新state_dim到cfg参数中\n",
    "    setattr(cfg,\"action_dim\",action_dim) # 更新action_dim到cfg参数中\n",
    "    model = MLP(state_dim, action_dim, hidden_dim = cfg.hidden_dim) # 创建模型\n",
    "    memory = ReplayBuffer(cfg.memory_capacity)\n",
    "    agent = DQN(model,memory,cfg)\n",
    "    return env,agent"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4、设置参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "import argparse\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "class Config:\n",
    "    def __init__(self) -> None:\n",
    "        self.algo_name = 'DeepSarsa' # 算法名称\n",
    "        self.env_id = 'CartPole-v1' # 环境id\n",
    "        self.seed = 1 # 随机种子，便于复现，0表示不设置\n",
    "        self.train_eps = 100 # 训练的回合数\n",
    "        self.test_eps = 20 # 测试的回合数\n",
    "        self.max_steps = 200 # 每个回合的最大步数，超过该数则游戏强制终止\n",
    "        self.gamma = 0.95 # 折扣因子\n",
    "        self.epsilon_start = 0.99  # e-greedy策略中初始epsilon\n",
    "        self.epsilon_end = 0.01 # e-greedy策略中的终止epsilon\n",
    "        self.epsilon_decay = 500 # e-greedy策略中epsilon的衰减率\n",
    "        self.memory_capacity = 100000 # 经验回放池的容量\n",
    "        self.hidden_dim = 256 # 神经网络的隐藏层维度\n",
    "        self.batch_size = 64 # 批次大小\n",
    "        self.target_update = 4 # 目标网络的更新频率\n",
    "        self.lr = 0.001 # 学习率\n",
    "        self.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\") # 检测gpu\n",
    "        \n",
    "def smooth(data, weight=0.9):  \n",
    "    '''用于平滑曲线，类似于Tensorboard中的smooth曲线\n",
    "    '''\n",
    "    last = data[0] \n",
    "    smoothed = []\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, tag='train'):\n",
    "    ''' 画图\n",
    "    '''\n",
    "    sns.set()\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(f\"{tag}ing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\")\n",
    "    plt.xlabel('episodes')\n",
    "    plt.plot(rewards, label='rewards')\n",
    "    plt.plot(smooth(rewards), label='smoothed')\n",
    "    plt.legend()\n",
    "    plt.show()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5、开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "状态空间维度：4，动作空间维度：2\n",
      "开始训练！\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "回合：10/100，奖励：17.00，Epislon：0.632\n",
      "回合：20/100，奖励：157.00，Epislon：0.081\n",
      "回合：30/100，奖励：200.00，Epislon：0.011\n",
      "回合：40/100，奖励：200.00，Epislon：0.010\n",
      "回合：50/100，奖励：200.00，Epislon：0.010\n",
      "回合：60/100，奖励：200.00，Epislon：0.010\n",
      "回合：70/100，奖励：200.00，Epislon：0.010\n",
      "回合：80/100，奖励：200.00，Epislon：0.010\n",
      "回合：90/100，奖励：200.00，Epislon：0.010\n",
      "回合：100/100，奖励：200.00，Epislon：0.010\n",
      "完成训练！\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "开始测试！\n",
      "回合：1/20，奖励：200.00\n",
      "回合：2/20，奖励：200.00\n",
      "回合：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，奖励：200.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，奖励：200.00\n",
      "回合：15/20，奖励：200.00\n",
      "回合：16/20，奖励：200.00\n",
      "回合：17/20，奖励：200.00\n",
      "回合：18/20，奖励：200.00\n",
      "回合：19/20，奖励：200.00\n",
      "回合：20/20，奖励：200.00\n",
      "完成测试\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 获取参数\n",
    "cfg = Config() \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.6.9 64-bit",
   "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.8.18"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}