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",
    "+ 使用基础搜索算法完成机器人走迷宫。\n",
    "+ 使用 Deep QLearning 算法完成机器人走迷宫。\n",
    "+ 算法部分需要自己实现，不能使用现成的包、工具或者接口。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3 实验环境\n",
    "可以使用 Python 实现基础算法的实现， 使用 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": [],
   "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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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 248,
       "width": 369
      },
      "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', 'd', 'd', 'd', 'u', 'u', 'u', 'u', 'r', 'l']\n",
      "the end position of robot: (0, 0)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 248,
       "width": 369
      },
      "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",
    "对于迷宫游戏，常见的三种的搜索算法有广度优先搜索、深度优先搜索和最佳优先搜索（A*)。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "在下面的代码示例中，将实现广度优先搜索算法；主要通过建立一颗搜索树并进行层次遍历实现。\n",
    "+ 每个节点表示为以 `Class SearchTree` 实例化的对象，类属性有：**当前节点位置、到达当前节点的动作、当前节点的父节点、当前节点的子节点**；\n",
    "+ `valid_actions():` 用以获取机器人可以行走的位置（即不能穿墙）；\n",
    "+ `expand():` 对于未拓展的子节点进行拓展；\n",
    "+ `backpropagation():` 回溯搜索路径。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.1 算法具体步骤\n",
    "\n",
    "首先以机器人起始位置建立根节点，并入队；接下来不断重复以下步骤直到判定条件:\n",
    "\n",
    "1. 将队首节点的位置标记已访问；判断队首是否为目标位置(出口)， **是** 则终止循环并记录回溯路径\n",
    "2. 判断队首节点是否为叶子节点，**是** 则拓展该叶子节点\n",
    "3. 如果队首节点有子节点，则将每个子节点插到队尾\n",
    "4. 将队首节点出队"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.2 编程实现广度优先搜索算法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# 机器人移动方向\n",
    "move_map = {\n",
    "    'u': (-1, 0), # up\n",
    "    'r': (0, +1), # right\n",
    "    'd': (+1, 0), # down\n",
    "    'l': (0, -1), # left\n",
    "}\n",
    "\n",
    "\n",
    "# 迷宫路径搜索树\n",
    "class SearchTree(object):\n",
    "\n",
    "\n",
    "    def __init__(self, loc=(), action='', parent=None):\n",
    "        \"\"\"\n",
    "        初始化搜索树节点对象\n",
    "        :param loc: 新节点的机器人所处位置\n",
    "        :param action: 新节点的对应的移动方向\n",
    "        :param parent: 新节点的父辈节点\n",
    "        \"\"\"\n",
    "\n",
    "        self.loc = loc  # 当前节点位置\n",
    "        self.to_this_action = action  # 到达当前节点的动作\n",
    "        self.parent = parent  # 当前节点的父节点\n",
    "        self.children = []  # 当前节点的子节点\n",
    "\n",
    "    def add_child(self, child):\n",
    "        \"\"\"\n",
    "        添加子节点\n",
    "        :param child:待添加的子节点\n",
    "        \"\"\"\n",
    "        self.children.append(child)\n",
    "\n",
    "    def is_leaf(self):\n",
    "        \"\"\"\n",
    "        判断当前节点是否是叶子节点\n",
    "        \"\"\"\n",
    "        return len(self.children) == 0\n",
    "\n",
    "\n",
    "def expand(maze, is_visit_m, node):\n",
    "    \"\"\"\n",
    "    拓展叶子节点，即为当前的叶子节点添加执行合法动作后到达的子节点\n",
    "    :param maze: 迷宫对象\n",
    "    :param is_visit_m: 记录迷宫每个位置是否访问的矩阵\n",
    "    :param node: 待拓展的叶子节点\n",
    "    \"\"\"\n",
    "    can_move = maze.can_move_actions(node.loc)\n",
    "    for a in can_move:\n",
    "        new_loc = tuple(node.loc[i] + move_map[a][i] for i in range(2))\n",
    "        if not is_visit_m[new_loc]:\n",
    "            child = SearchTree(loc=new_loc, action=a, parent=node)\n",
    "            node.add_child(child)\n",
    "\n",
    "\n",
    "def back_propagation(node):\n",
    "    \"\"\"\n",
    "    回溯并记录节点路径\n",
    "    :param node: 待回溯节点\n",
    "    :return: 回溯路径\n",
    "    \"\"\"\n",
    "    path = []\n",
    "    while node.parent is not None:\n",
    "        path.insert(0, node.to_this_action)\n",
    "        node = node.parent\n",
    "    return path\n",
    "\n",
    "\n",
    "def breadth_first_search(maze):\n",
    "    \"\"\"\n",
    "    对迷宫进行广度优先搜索\n",
    "    :param maze: 待搜索的maze对象\n",
    "    \"\"\"\n",
    "    start = maze.sense_robot()\n",
    "    root = SearchTree(loc=start)\n",
    "    queue = [root]  # 节点队列，用于层次遍历\n",
    "    h, w, _ = maze.maze_data.shape\n",
    "    is_visit_m = np.zeros((h, w), dtype=np.int)  # 标记迷宫的各个位置是否被访问过\n",
    "    path = []  # 记录路径\n",
    "    while True:\n",
    "        current_node = queue[0]\n",
    "        is_visit_m[current_node.loc] = 1  # 标记当前节点位置已访问\n",
    "\n",
    "        if current_node.loc == maze.destination:  # 到达目标点\n",
    "            path = back_propagation(current_node)\n",
    "            break\n",
    "\n",
    "        if current_node.is_leaf():\n",
    "            expand(maze, is_visit_m, current_node)\n",
    "\n",
    "        # 入队\n",
    "        for child in current_node.children:\n",
    "            queue.append(child)\n",
    "\n",
    "        # 出队\n",
    "        queue.pop(0)\n",
    "\n",
    "    return path\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**测试广度优先搜索算法**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "搜索出的路径： ['d', 'd', 'd', 'r', 'r', 'r', 'd', 'd', 'd', 'r', 'r', 'r', 'r', 'r', 'd', 'd', 'd', 'r']\n",
      "恭喜你，到达了目标点\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 248,
       "width": 369
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maze of size (10, 10)\n"
     ]
    }
   ],
   "source": [
    "maze = Maze(maze_size=10)\n",
    "height, width, _ = maze.maze_data.shape\n",
    "\n",
    "path_1 = breadth_first_search(maze)\n",
    "print(\"搜索出的路径：\", path_1)\n",
    "\n",
    "for action in path_1:\n",
    "    maze.move_robot(action)\n",
    "\n",
    "if maze.sense_robot() == maze.destination:\n",
    "    print(\"恭喜你，到达了目标点\")\n",
    "\n",
    "print(maze)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "## 2.3 题目一: 实现基础搜索算法(总分40分)\n",
    "* 题目要求： 任选深度优先搜索算法、最佳优先搜索 A* 算法其中一种实现机器人走迷宫\n",
    "\n",
    "* 输入：迷宫\n",
    "\n",
    "* 输出：到达目标点的路径\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3.1 编写您的基础搜索算法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "deletable": false,
    "select": true
   },
   "outputs": [],
   "source": [
    "def my_search(maze):\n",
    "    \"\"\"\n",
    "    任选深度优先搜索算法、最佳优先搜索（A*)算法实现其中一种\n",
    "    :param maze: 迷宫对象\n",
    "    :return :到达目标点的路径 如：[\"u\",\"u\",\"r\",...]\n",
    "    \"\"\"\n",
    "\n",
    "    path = []\n",
    "    \n",
    "    # -----------------请实现你的算法代码--------------------------------------\n",
    "    \n",
    "    \n",
    "    # -----------------------------------------------------------------------\n",
    "    return path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3.2 测试您编写的基础搜索算法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "搜索出的路径： []\n"
     ]
    }
   ],
   "source": [
    "maze = Maze(maze_size=10) # 从文件生成迷宫\n",
    "\n",
    "path_2 = my_search(maze)\n",
    "print(\"搜索出的路径：\", path_2)\n",
    "\n",
    "for action in path_2:\n",
    "    maze.move_robot(action)\n",
    "\n",
    "\n",
    "if maze.sense_robot() == maze.destination:\n",
    "    print(\"恭喜你，到达了目标点\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "## 2.4 强化学习算法介绍\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.5 QLearning 算法\n",
    "\n",
    "Q-Learning 是一个值迭代（Value Iteration）算法。    \n",
    "与策略迭代（Policy Iteration）算法不同，值迭代算法会计算每个”状态“或是”状态-动作“的值（Value）或是效用（Utility），然后在执行动作的时候，会设法最大化这个值。    \n",
    "因此，对每个状态值的准确估计，是值迭代算法的核心。    \n",
    "通常会考虑**最大化动作的长期奖励**，即不仅考虑当前动作带来的奖励，还会考虑动作长远的奖励。\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5.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.5.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.5.3  Q-Learning 算法的学习过程\n",
    "<img src=\"http://imgbed.momodel.cn/20200601170657.png\" width=900>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  2.5.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": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the choosed action:  d\n",
      "the returned reward:  d\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.5.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": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8b5a94a5609c46ad9d98e94154a98b71",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, description='正在将训练过程转换为gif图, 请耐心等候...', max=348.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": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 263,
       "width": 708
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "runner.plot_results() # 输出训练结果，可根据该结果对您的机器人进行分析。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "## 2.6 题目二: 实现 Deep QLearning 算法(总分60分)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.6.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.6.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": 11,
   "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": [
    "### 2.6.3 作业测试与提交"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 经过 `2.3` 与 `2.6` 分别测试使用基础算法、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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}