main.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 机器人自动走迷宫\n",
    "\n",
    "<br>\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "# 1. 实验介绍  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1 实验内容  \n",
    "在本实验中，要求使用Deep QLearning 算法，完成机器人自动走迷宫。\n",
    " \n",
    "<img src=\"https://imgbed.momodel.cn/20200914145238.png\" width=\"40%\"/>\n",
    "\n",
    "如上图所示，左上角的红色椭圆既是起点也是机器人的初始位置，右下角的绿色方块是出口。          \n",
    "游戏规则为：从起点开始，通过错综复杂的迷宫，到达目标点(出口)。\n",
    "        \n",
    "+ 在任一位置可执行动作包括：向上走 `'u'`、向右走 `'r'`、向下走 `'d'`、向左走 `'l'`。\n",
    "\n",
    "+ 执行不同的动作后，根据不同的情况会获得不同的奖励，具体而言，有以下几种情况。\n",
    "    - 撞墙\n",
    "    - 走到出口\n",
    "    - 其余情况\n",
    "    \n",
    "    \n",
    "+ 需要您实现**Deep QLearning 算法**的机器人，使机器人自动走到迷宫的出口。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 实验要求 \n",
    "+ 使用 Python 语言。\n",
    "+ 使用 Deep QLearning 算法完成机器人走迷宫。\n",
    "+ 算法部分需要自己实现，不能使用现成的包、工具或者接口。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3 实验环境\n",
    "可以使用 Keras、PyTorch等框架实现 Deep QLearning 算法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.4 注意事项\n",
    "+ Python 与 Python Package 的使用方式，可在右侧 `API文档` 中查阅。\n",
    "+ 当右上角的『Python 3』长时间指示为运行中的时候，造成代码无法执行时，可以重新启动 Kernel 解决（左上角『Kernel』-『Restart Kernel』）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.5 参考资料\n",
    "+  强化学习入门MDP：https://zhuanlan.zhihu.com/p/25498081\n",
    "+ QLearning 示例：http://mnemstudio.org/path-finding-q-learning-tutorial.htm\n",
    "+ QLearning 知乎解释：https://www.zhihu.com/question/26408259\n",
    "+ DeepQLearning 论文：https://files.momodel.cn/Playing%20Atari%20with%20Deep%20Reinforcement%20Learning.pdf\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "# 2. 实验内容\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "\n",
    "## 2.1 Maze 类介绍"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1.1 创建迷宫\n",
    "通过迷宫类 Maze 可以随机创建一个迷宫。\n",
    "\n",
    "1. 使用  Maze(maze_size=size)  来随机生成一个 size * size 大小的迷宫。\n",
    "2. 使用 print() 函数可以输出迷宫的 size 以及画出迷宫图\n",
    "3. 红色的圆是机器人初始位置\n",
    "4. 绿色的方块是迷宫的出口位置"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "deletable": false,
    "select": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-09-28 15:37:59.014236: W tensorflow/stream_executor/platform/default/dso_loader.cc:59] Could not load dynamic library 'libcudart.so.10.1'; dlerror: libcudart.so.10.1: cannot open shared object file: No such file or directory\n",
      "2022-09-28 15:37:59.014268: I tensorflow/stream_executor/cuda/cudart_stub.cc:29] Ignore above cudart dlerror if you do not have a GPU set up on your machine.\n"
     ]
    }
   ],
   "source": [
    "# 导入相关包 \n",
    "import os\n",
    "import random\n",
    "import numpy as np\n",
    "from Maze import Maze\n",
    "from Runner import Runner\n",
    "from QRobot import QRobot\n",
    "from ReplayDataSet import ReplayDataSet\n",
    "from torch_py.MinDQNRobot import MinDQNRobot as TorchRobot # PyTorch版本\n",
    "from keras_py.MinDQNRobot import MinDQNRobot as KerasRobot # Keras版本\n",
    "import matplotlib.pyplot as plt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 246,
       "width": 366
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maze of size (10, 10)\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "%config InlineBackend.figure_format = 'retina'\n",
    "\n",
    "\"\"\" 创建迷宫并展示 \"\"\"\n",
    "maze = Maze(maze_size=10) # 随机生成迷宫\n",
    "print(maze)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1.2 重要的成员方法\n",
    "在迷宫中已经初始化一个机器人，你要编写的算法实现在给定条件下控制机器人移动至目标点。\n",
    "\n",
    "Maze 类中重要的成员方法如下：\n",
    "\n",
    "1. sense_robot() ：获取机器人在迷宫中目前的位置。\n",
    "\n",
    "> return：机器人在迷宫中目前的位置。\n",
    "\n",
    "2. move_robot(direction) ：根据输入方向移动默认机器人，若方向不合法则返回错误信息。\n",
    "\n",
    "> direction：移动方向, 如:\"u\", 合法值为： ['u', 'r', 'd', 'l']\n",
    "\n",
    "> return：执行动作的奖励值\n",
    "\n",
    "3. can_move_actions(position)：获取当前机器人可以移动的方向\n",
    "\n",
    "> position：迷宫中任一处的坐标点 \n",
    "\n",
    "> return：该点可执行的动作，如：['u','r','d']\n",
    "\n",
    "4. is_hit_wall(self, location, direction)：判断该移动方向是否撞墙\n",
    "\n",
    "> location, direction：当前位置和要移动的方向，如(0,0) , \"u\"\n",
    "\n",
    "> return：True(撞墙) / False(不撞墙)\n",
    "\n",
    "5. draw_maze()：画出当前的迷宫\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**随机移动机器人，并记录下获得的奖励，展示出机器人最后的位置。**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the history of rewards: [-0.1, -0.1, -0.1, -0.1, -0.1, -0.1, -0.1, -0.1, -0.1, -0.1]\n",
      "the actions ['d', 'u', 'd', 'd', 'd', 'd', 'd', 'd', 'd', 'r']\n",
      "the end position of robot: (7, 1)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 246,
       "width": 366
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maze of size (10, 10)\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "rewards = [] # 记录每走一步的奖励值\n",
    "actions = [] # 记录每走一步的移动方向\n",
    "\n",
    "# 循环、随机移动机器人10次，记录下奖励\n",
    "for i in range(10):\n",
    "    valid_actions = maze.can_move_actions(maze.sense_robot())\n",
    "    action = random.choice(valid_actions)\n",
    "    rewards.append(maze.move_robot(action))\n",
    "    actions.append(action)\n",
    "\n",
    "print(\"the history of rewards:\", rewards)\n",
    "print(\"the actions\", actions)\n",
    "\n",
    "# 输出机器人最后的位置\n",
    "print(\"the end position of robot:\", maze.sense_robot())\n",
    "\n",
    "# 打印迷宫，观察机器人位置\n",
    "print(maze)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "## 2.2 强化学习算法介绍\n",
    "\n",
    "强化学习作为机器学习算法的一种，其模式也是让智能体在“训练”中学到“经验”，以实现给定的任务。    \n",
    "但不同于监督学习与非监督学习，在强化学习的框架中，我们更侧重通过智能体与环境的**交互**来学习。   \n",
    "通常在监督学习和非监督学习任务中，智能体往往需要通过给定的训练集，辅之以既定的训练目标（如最小化损失函数），通过给定的学习算法来实现这一目标。    \n",
    "然而在强化学习中，智能体则是通过其与环境交互得到的奖励进行学习。     \n",
    "这个环境可以是虚拟的（如虚拟的迷宫），也可以是真实的（自动驾驶汽车在真实道路上收集数据）。\n",
    "\n",
    "\n",
    "在强化学习中有五个核心组成部分，它们分别是：**环境（Environment）**、**智能体（Agent）**、**状态（State）**、**动作（Action）**和**奖励（Reward）**。\n",
    "\n",
    "在某一时间节点 $t$：\n",
    "    \n",
    "- 智能体在从环境中感知其所处的状态 $s_t$\n",
    "- 智能体根据某些准则选择动作 $a_t$\n",
    "- 环境根据智能体选择的动作，向智能体反馈奖励 $r_{t+1}$\n",
    "\n",
    "通过合理的学习算法，智能体将在这样的问题设置下，成功学到一个在状态 $s_t$ 选择动作 $a_t$ 的策略 $\\pi (s_t) = a_t$。\n",
    "\n",
    "<img src=\"https://imgbed.momodel.cn/20200914153419.png\" width=400px/>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "\n",
    "## 2.3 QLearning 算法\n",
    "\n",
    "Q-Learning 是一个值迭代（Value Iteration）算法。    \n",
    "与策略迭代（Policy Iteration）算法不同，值迭代算法会计算每个”状态“或是”状态-动作“的值（Value）或是效用（Utility），然后在执行动作的时候，会设法最大化这个值。    \n",
    "因此，对每个状态值的准确估计，是值迭代算法的核心。    \n",
    "通常会考虑**最大化动作的长期奖励**，即不仅考虑当前动作带来的奖励，还会考虑动作长远的奖励。\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3.1 Q 值的计算与迭代\n",
    "\n",
    "Q-learning 算法将状态（state）和动作（action）构建成一张 Q_table 表来存储 Q 值，Q 表的行代表状态（state），列代表动作（action）：\n",
    "\n",
    "<img src=\"https://imgbed.momodel.cn/20200914161241.png\" width=400px/>\n",
    "\n",
    "在 Q-Learning 算法中，将这个长期奖励记为 Q 值，其中会考虑每个 ”状态-动作“ 的 Q 值，具体而言，它的计算公式为：\n",
    "\n",
    "$$\n",
    "Q(s_{t},a) = R_{t+1} + \\gamma \\times\\max_a Q(a,s_{t+1})\n",
    "$$\n",
    "\n",
    "也就是对于当前的“状态-动作” $(s_{t},a)$，考虑执行动作 $a$ 后环境奖励 $R_{t+1}$，以及执行动作 $a$ 到达 $s_{t+1}$后，执行任意动作能够获得的最大的Q值 $\\max_a Q(a,s_{t+1})$，$\\gamma$ 为折扣因子。\n",
    "\n",
    "计算得到新的 Q 值之后，一般会使用更为保守地更新 Q 表的方法，即引入松弛变量 $alpha$ ，按如下的公式进行更新，使得 Q 表的迭代变化更为平缓。\n",
    "\n",
    "$$\n",
    "Q(s_{t},a) = (1-\\alpha) \\times Q(s_{t},a) + \\alpha \\times(R_{t+1} + \\gamma \\times\\max_a Q(a,s_{t+1}))\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "### 2.3.2 机器人动作的选择\n",
    "\n",
    "在强化学习中，**探索-利用** 问题是非常重要的问题。    \n",
    "具体来说，根据上面的定义，会尽可能地让机器人在每次选择最优的决策，来最大化长期奖励。    \n",
    "但是这样做有如下的弊端：    \n",
    "1. 在初步的学习中，Q 值是不准确的，如果在这个时候都按照 Q 值来选择，那么会造成错误。\n",
    "2. 学习一段时间后，机器人的路线会相对固定，则机器人无法对环境进行有效的探索。\n",
    "\n",
    "因此需要一种办法，来解决如上的问题，增加机器人的探索。   \n",
    "通常会使用 **epsilon-greedy** 算法：\n",
    "1. 在机器人选择动作的时候，以一部分的概率随机选择动作，以一部分的概率按照最优的 Q 值选择动作。\n",
    "2. 同时，这个选择随机动作的概率应当随着训练的过程逐步减小。\n",
    "\n",
    "<img src=\"http://imgbed.momodel.cn/20200602153554.png\" width=400>\n",
    "<img src=\"http://imgbed.momodel.cn/20200601144827.png\" width=400>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3.3  Q-Learning 算法的学习过程\n",
    "<img src=\"http://imgbed.momodel.cn/20200601170657.png\" width=900>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  2.3.4 Robot 类\n",
    "\n",
    "在本作业中提供了 QRobot 类，其中实现了 Q 表迭代和机器人动作的选择策略，可通过 `from QRobot import QRobot` 导入使用。\n",
    "\n",
    "**QRobot 类的核心成员方法**\n",
    "\n",
    "1. sense_state()：获取当前机器人所处位置\n",
    "\n",
    "> return：机器人所处的位置坐标，如： (0, 0)\n",
    "\n",
    "2. current_state_valid_actions()：获取当前机器人可以合法移动的动作\n",
    "\n",
    "> return：由当前合法动作组成的列表，如： ['u','r']\n",
    "\n",
    "3. train_update()：以**训练状态**，根据 QLearning 算法策略执行动作\n",
    "\n",
    "> return：当前选择的动作，以及执行当前动作获得的回报, 如： 'u', -1\n",
    "\n",
    "4. test_update()：以**测试状态**，根据 QLearning 算法策略执行动作\n",
    "\n",
    "> return：当前选择的动作，以及执行当前动作获得的回报, 如：'u', -1\n",
    "\n",
    "5. reset()\n",
    "\n",
    "> return：重置机器人在迷宫中的位置"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the choosed action:  u\n",
      "the returned reward:  u\n"
     ]
    }
   ],
   "source": [
    "from QRobot import QRobot\n",
    "from Maze import Maze\n",
    "\n",
    "maze = Maze(maze_size=5) # 随机生成迷宫\n",
    "\n",
    "robot = QRobot(maze) # 记得将 maze 变量修改为你创建迷宫的变量名\n",
    "\n",
    "action, reward = robot.train_update() # QLearning 算法一次Q值迭代和动作选择\n",
    "\n",
    "print(\"the choosed action: \", action)\n",
    "print(\"the returned reward: \", action)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true
   },
   "source": [
    "### 2.3.5 Runner 类\n",
    "\n",
    "QRobot 类实现了 QLearning 算法的 Q 值迭代和动作选择策略。在机器人自动走迷宫的训练过程中，需要不断的使用 QLearning 算法来迭代更新 Q 值表，以达到一个“最优”的状态，因此封装好了一个类 Runner 用于机器人的训练和可视化。可通过 `from Runner import Runner` 导入使用。\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Runner 类的核心成员方法：**\n",
    "\n",
    "1. run_training(training_epoch, training_per_epoch=150): 训练机器人，不断更新 Q 表，并讲训练结果保存在成员变量 train_robot_record 中\n",
    "\n",
    "> training_epoch, training_per_epoch: 总共的训练次数、每次训练机器人最多移动的步数\n",
    "\n",
    "2. run_testing()：测试机器人能否走出迷宫\n",
    "\n",
    "3. generate_gif(filename)：将训练结果输出到指定的 gif 图片中\n",
    "\n",
    "> filename：合法的文件路径,文件名需以 `.gif` 为后缀\n",
    "\n",
    "4. plot_results()：以图表展示训练过程中的指标：Success Times、Accumulated Rewards、Runing Times per Epoch\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "**设定训练参数、训练、查看结果**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7a9f1d069d2448738ffa83863f382d2f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, description='正在将训练过程转换为gif图, 请耐心等候...', max=354.0, style=ProgressStyle…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from QRobot import QRobot\n",
    "from Maze import Maze\n",
    "from Runner import Runner\n",
    "\n",
    "\"\"\"  Qlearning 算法相关参数： \"\"\"\n",
    "\n",
    "epoch = 10  # 训练轮数\n",
    "epsilon0 = 0.5  # 初始探索概率\n",
    "alpha = 0.5  # 公式中的 ⍺\n",
    "gamma = 0.9  # 公式中的 γ\n",
    "maze_size = 5  # 迷宫size\n",
    "\n",
    "\"\"\" 使用 QLearning 算法训练过程 \"\"\"\n",
    "\n",
    "g = Maze(maze_size=maze_size)\n",
    "r = QRobot(g, alpha=alpha, epsilon0=epsilon0, gamma=gamma)\n",
    "\n",
    "runner = Runner(r)\n",
    "runner.run_training(epoch, training_per_epoch=int(maze_size * maze_size * 1.5))\n",
    "\n",
    "# 生成训练过程的gif图, 建议下载到本地查看；也可以注释该行代码，加快运行速度。\n",
    "runner.generate_gif(filename=\"results/size5.gif\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 864x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 260,
       "width": 707
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "runner.plot_results() # 输出训练结果，可根据该结果对您的机器人进行分析。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "## 2.4 实现 Deep QLearning 算法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4.1 DQN 算法介绍\n",
    "强化学习是一个反复迭代的过程，每一次迭代要解决两个问题：给定一个策略求值函数，和根据值函数来更新策略。而 DQN 算法使用神经网络来近似值函数。([DQN 论文地址](https://files.momodel.cn/Playing%20Atari%20with%20Deep%20Reinforcement%20Learning.pdf))\n",
    "\n",
    "+ **DQN 算法流程**\n",
    "\n",
    "<img src=\"https://imgbed.momodel.cn/20200918101051.png\" width=\"60%\"/>\n",
    "\n",
    "+ **DQN 算法框架图**\n",
    "\n",
    "<img src=\"https://imgbed.momodel.cn/20200918101137.png\" width=\"60%\"/>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "### 2.4.2 完成 DQN 算法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**ReplayDataSet 类的核心成员方法**\n",
    "\n",
    "+ add(self, state, action_index, reward, next_state, is_terminal) 添加一条训练数据\n",
    "\n",
    "> state: 当前机器人位置\n",
    "\n",
    "> action_index: 选择执行动作的索引\n",
    "\n",
    "> reward： 执行动作获得的回报\n",
    "\n",
    "> next_state：执行动作后机器人的位置\n",
    "\n",
    "> is_terminal：机器人是否到达了终止节点（到达终点或者撞墙）\n",
    "\n",
    "+ random_sample(self, batch_size)：从数据集中随机抽取固定batch_size的数据\n",
    "\n",
    "> batch_size: 整数，不允许超过数据集中数据的个数\n",
    "\n",
    "+ **build_full_view(self, maze)：开启金手指，获取全图视野**\n",
    "\n",
    "> maze: 以 Maze 类实例化的对象"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(array([[0, 1]]), array([[1]], dtype=int8), array([[-10]]), array([[0, 1]]), array([[1]], dtype=int8))\n"
     ]
    }
   ],
   "source": [
    "\"\"\"ReplayDataSet 类的使用\"\"\"\n",
    "\n",
    "from ReplayDataSet import ReplayDataSet\n",
    "\n",
    "test_memory = ReplayDataSet(max_size=1e3) # 初始化并设定最大容量\n",
    "actions = ['u', 'r', 'd', 'l']  \n",
    "test_memory.add((0,1), actions.index(\"r\"), -10, (0,1), 1)  # 添加一条数据（state, action_index, reward, next_state）\n",
    "print(test_memory.random_sample(1)) # 从中随机抽取一条（因为只有一条数据）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### （1）实现简单的 DQNRobot\n",
    "\n",
    "作业中提供了简单的 DQNRobot 实现，其中依靠简单的两层全连接神经网络决策动作\n",
    "\n",
    "<div align=left>\n",
    "<center><img src=\"https://imgbed.momodel.cn/20201029220521.png\" width=\"241px\"/>\n",
    "</div>\n",
    "\n",
    "+ **该神经网络的输入：机器人当前的位置坐标，输出：执行四个动作（up、right、down、left）的评估分数**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "该部分我们支持 PyTorch 版本和 Keras 版本，大家可以选择自己擅长的深度学习框架！！！ 我们已经实现简单的 DQNRobot 部分，大家可以完善该部分代码！！！"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'hit_wall': 10.0, 'destination': -50.0, 'default': 1.0}\n",
      "action: d reward: 1.0\n",
      "action: r reward: 1.0\n",
      "action: r reward: 1.0\n",
      "action: r reward: 1.0\n",
      "action: r reward: 1.0\n",
      "action: l reward: 1.0\n",
      "action: r reward: 1.0\n",
      "action: l reward: 1.0\n",
      "action: r reward: 1.0\n",
      "action: l reward: 1.0\n",
      "action: r reward: 1.0\n",
      "action: l reward: 1.0\n",
      "action: r reward: 1.0\n",
      "action: l reward: 1.0\n",
      "action: r reward: 1.0\n",
      "action: l reward: 1.0\n",
      "action: r reward: 1.0\n",
      "action: l reward: 1.0\n",
      "action: r reward: 1.0\n",
      "action: l reward: 1.0\n",
      "action: r reward: 1.0\n",
      "action: l reward: 1.0\n",
      "action: r reward: 1.0\n",
      "action: l reward: 1.0\n",
      "action: r reward: 1.0\n"
     ]
    }
   ],
   "source": [
    "from torch_py.MinDQNRobot import MinDQNRobot as TorchRobot # PyTorch版本\n",
    "from keras_py.MinDQNRobot import MinDQNRobot as KerasRobot # Keras版本\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from Maze import Maze\n",
    "from Runner import Runner\n",
    "import os\n",
    "\n",
    "os.environ[\"KMP_DUPLICATE_LIB_OK\"] = \"TRUE\"  # 允许重复载入lib文件\n",
    "\n",
    "maze = Maze(maze_size=5) \n",
    "\n",
    "\n",
    "\"\"\"选择keras版本或者torch版本的机器人, MinRobot是尽量选择reward值最小的动作，对象初始化过程中修改了maze的reward参数\"\"\"\n",
    "# robot = KerasRobot(maze=maze)\n",
    "robot = TorchRobot(maze=maze)\n",
    "\n",
    "print(robot.maze.reward) # 输出最小值选择策略的reward值\n",
    "\n",
    "\"\"\"开启金手指，获取全图视野\"\"\"\n",
    "robot.memory.build_full_view(maze=maze) # \n",
    "\n",
    "\"\"\"training by runner\"\"\"\n",
    "runner = Runner(robot=robot)\n",
    "runner.run_training(training_epoch=10, training_per_epoch=75)\n",
    "\n",
    "\"\"\"Test Robot\"\"\"\n",
    "robot.reset()\n",
    "for _ in range(25):\n",
    "    a, r = robot.test_update()\n",
    "    print(\"action:\", a, \"reward:\", r)\n",
    "    if r == maze.reward[\"destination\"]:\n",
    "        print(\"success\")\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### （2）实现你自己的 DQNRobot\n",
    "\n",
    " + **题目要求:** 编程实现 DQN 算法在机器人自动走迷宫中的应用\n",
    " + **输入:** 由 Maze 类实例化的对象 maze\n",
    " + **要求不可更改的成员方法：**train_update()、test_update() **注：不能修改该方法的输入输出及方法名称，测试评分会调用这两个方法**。\n",
    " + **补充1:**若要自定义的参数变量，在 \\_\\_init\\_\\_() 中以 `self.xxx = xxx` 创建即可\n",
    " + **补充2:**实现你自己的DQNRobot时，要求继承 QRobot 类，QRobot 类包含了某些固定的方法如reset(重置机器人位置),sense_state(获取机器人当前位置).."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "deletable": false,
    "select": true
   },
   "outputs": [],
   "source": [
    "from QRobot import QRobot\n",
    "\n",
    "class Robot(QRobot):\n",
    "\n",
    "    def __init__(self, maze):\n",
    "        \"\"\"\n",
    "        初始化 Robot 类\n",
    "        :param maze:迷宫对象\n",
    "        \"\"\"\n",
    "        super(Robot, self).__init__(maze)\n",
    "        self.maze = maze\n",
    "\n",
    "    def train_update(self):\n",
    "        \"\"\"\n",
    "        以训练状态选择动作并更新Deep Q network的相关参数\n",
    "        :return :action, reward 如：\"u\", -1\n",
    "        \"\"\"\n",
    "        action, reward = \"u\", -1.0\n",
    "\n",
    "        # -----------------请实现你的算法代码--------------------------------------\n",
    "\n",
    "        # -----------------------------------------------------------------------\n",
    "\n",
    "        return action, reward\n",
    "\n",
    "    def test_update(self):\n",
    "        \"\"\"\n",
    "        以测试状态选择动作并更新Deep Q network的相关参数\n",
    "        :return : action, reward 如：\"u\", -1\n",
    "        \"\"\"\n",
    "        action, reward = \"u\", -1.0\n",
    "\n",
    "        # -----------------请实现你的算法代码--------------------------------------\n",
    "\n",
    "        # -----------------------------------------------------------------------\n",
    "\n",
    "        return action, reward\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### （3）测试您的 DQN 算法\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5b64395eb6a8444293fd6f6dda258366",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, description='正在将训练过程转换为gif图, 请耐心等候...', max=370.0, style=ProgressStyle…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from QRobot import QRobot\n",
    "from Maze import Maze\n",
    "from Runner import Runner\n",
    "\n",
    "\"\"\"  Deep Qlearning 算法相关参数： \"\"\"\n",
    "\n",
    "epoch = 10  # 训练轮数\n",
    "maze_size = 5  # 迷宫size\n",
    "training_per_epoch=int(maze_size * maze_size * 1.5)\n",
    "\n",
    "\"\"\" 使用 DQN 算法训练 \"\"\"\n",
    "\n",
    "g = Maze(maze_size=maze_size)\n",
    "r = Robot(g)\n",
    "runner = Runner(r)\n",
    "runner.run_training(epoch, training_per_epoch)\n",
    "\n",
    "# 生成训练过程的gif图, 建议下载到本地查看；也可以注释该行代码，加快运行速度。\n",
    "runner.generate_gif(filename=\"results/dqn_size10.gif\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 作业测试与提交"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 经过 `2.4` 测试使用 DQN 算法实现机器人走出迷宫！\n",
    "- 测试完成之后，点击左侧 `提交作业` 的标签中，把整个 Notebook 目标 cell 转化为 main.py 文件进行`系统测试`。\n",
    "- 平台测试时请记得勾选 main.py 文件需要依赖的其它文件等。\n",
    "- 通过测试就可以**提交作业**。\n",
    "-  提交作业时请记得提交勾选 **『程序报告.docx』**或者 **『程序报告.pdf』**。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**最后，祝愿您不仅能从中收获到满满的知识，而且收获到一个满意分数！**"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}