【机器学习】机器人自动走迷宫

机器人自动走迷宫

问题描述

在本实验中，要求分别使用基础搜索算法和 Deep QLearning 算法，完成机器人自动走迷宫。

如上图所示，左上角的红色椭圆既是起点也是机器人的初始位置，右下角的绿色方块是出口。
游戏规则为：从起点开始，通过错综复杂的迷宫，到达目标点(出口)。

• 在任一位置可执行动作包括：向上走 'u'、向右走 'r'、向下走 'd'、向左走 'l'。

• 执行不同的动作后，根据不同的情况会获得不同的奖励，具体而言，有以下几种情况。

  • 撞墙
  • 走到出口
  • 其余情况

• 需要您分别实现基于基础搜索算法和 Deep QLearning 算法的机器人，使机器人自动走到迷宫的出口。

代码

# 导入相关包 
import os
import random
import numpy as np
from Maze import Maze
from Runner import Runner
from QRobot import QRobot
from ReplayDataSet import ReplayDataSet
from torch_py.MinDQNRobot import MinDQNRobot as TorchRobot # PyTorch版本
from keras_py.MinDQNRobot import MinDQNRobot as KerasRobot # Keras版本
import matplotlib.pyplot as plt


import numpy as np
class SearchTree(object):

    def __init__(self, loc=(), action='', parent=None):
        """
        初始化搜索树节点对象
        :param loc: 新节点的机器人所处位置
        :param action: 新节点的对应的移动方向
        :param parent: 新节点的父辈节点
        """

        self.loc = loc  # 当前节点位置
        self.to_this_action = action  # 到达当前节点的动作
        self.parent = parent  # 当前节点的父节点
        self.children = []  # 当前节点的子节点

    def add_child(self, child):
        """
        添加子节点
        :param child:待添加的子节点
        """
        self.children.append(child)

    def is_leaf(self):
        """
        判断当前节点是否是叶子节点
        """
        return len(self.children) == 0


def expand(maze, is_visit_m, node):
    """
    拓展叶子节点，即为当前的叶子节点添加执行合法动作后到达的子节点
    :param maze: 迷宫对象
    :param is_visit_m: 记录迷宫每个位置是否访问的矩阵
    :param node: 待拓展的叶子节点
    """
    move_map = {
        'u': (-1, 0),  # up
        'r': (0, +1),  # right
        'd': (+1, 0),  # down
        'l': (0, -1),  # left
    }
    can_move = maze.can_move_actions(node.loc)
    for a in can_move:
        new_loc = tuple(node.loc[i] + move_map[a][i] for i in range(2))
        if not is_visit_m[new_loc]:
            child = SearchTree(loc=new_loc, action=a, parent=node)
            node.add_child(child)


def back_propagation(node):
    """
    回溯并记录节点路径
    :param node: 待回溯节点
    :return: 回溯路径
    """
    path = []
    while node.parent is not None:
        path.insert(0, node.to_this_action)
        node = node.parent
    return path


def my_search(maze):
    start = maze.sense_robot()
    root = SearchTree(loc=start)
    stack = [root]
    h, w, _ = maze.maze_data.shape
    is_visit_m = np.zeros((h, w), dtype=np.int32)  # 标记迷宫的各个位置是否被访问过
    path = []  # 记录路径
    while True:
        current_node = stack[-1]
        is_visit_m[current_node.loc] = 1  # 标记当前节点位置已访问
        if current_node.loc == maze.destination:  # 到达目标点
            path = back_propagation(current_node)
            break
        current_node.children=[]
        expand(maze, is_visit_m, current_node)
        if current_node.is_leaf():
            stack.pop(-1)
        else:
            for child in current_node.children:
                stack.append(child)
               
    return path


# 导入相关包 
import os
import random
import numpy as np
import torch
from QRobot import QRobot
from ReplayDataSet import ReplayDataSet
from torch_py.MinDQNRobot import MinDQNRobot as TorchRobot # PyTorch版本
import matplotlib.pyplot as plt
class Robot(TorchRobot):

    def __init__(self, maze):
        """
        初始化 Robot 类
        :param maze:迷宫对象
        """
        super(Robot, self).__init__(maze)
        maze.set_reward(reward={
            "hit_wall": 10.,
            "destination": -maze.maze_size ** 2 *10,
            "default": 1.,
        })
        self.maze = maze
        self.epsilon = 0
        """开启金手指，获取全图视野"""
        self.memory.build_full_view(maze=maze)
        self.train()
        

    def train(self):      
        # 训练，直到能走出这个迷宫
        while True:
            self._learn(batch=len(self.memory) )
            success = False
            self.reset()
            for _ in range(self.maze.maze_size ** 2 ):
                a, r = self.test_update()
                if r == self.maze.reward["destination"]:
                    return 

    def train_update(self):
        state = self.sense_state()
        action = self._choose_action(state)
        reward = self.maze.move_robot(action)
        
        return action, reward
    
    
    def test_update(self):
        state = np.array(self.sense_state(), dtype=np.int16)
        state = torch.from_numpy(state).float().to(self.device)

        self.eval_model.eval()
        with torch.no_grad():
            q_value = self.eval_model(state).cpu().data.numpy()

        action = self.valid_action[np.argmin(q_value).item()]
        reward = self.maze.move_robot(action)
        return action, reward

代码思路

这段代码实现了一个机器人自动走迷宫的程序，它包含了两个主要部分：基于搜索树的迷宫搜索算法和基于深度强化学习的迷宫探索算法。下面是这两部分的代码思路总结：

1. 基于搜索树的迷宫搜索算法

这部分代码定义了一个SearchTree类来构建搜索树，并通过深度优先搜索（DFS）算法来找到从起点到终点的路径。

• SearchTree类：用于表示搜索树的节点，包含位置（loc）、到达该位置的动作（to_this_action）和父节点（parent）。
• add_child方法：向当前节点添加子节点。
• is_leaf方法：判断当前节点是否为叶子节点（即没有子节点）。
• expand函数：扩展叶子节点，为当前叶子节点添加所有合法动作后到达的子节点。
• back_propagation函数：从目标节点回溯到起点，记录路径。
• my_search函数：使用深度优先搜索算法在迷宫中寻找路径。它初始化一个根节点，然后使用栈来管理节点的扩展和回溯，直到找到目标点。

2. 基于深度强化学习的迷宫探索算法

这部分代码实现了一个Robot类，该类继承自TorchRobot（一个基于PyTorch的深度强化学习机器人），用于训练和测试机器人在迷宫中的导航能力。

• Robot类：初始化时设置迷宫对象，并定义奖励机制。epsilon参数用于控制探索和利用的平衡，这里设置为0，意味着机器人总是选择最优动作。
• train方法：训练机器人直到它能成功走出迷宫。在训练过程中，机器人通过与环境的交互学习最优策略。
• train_update方法：在训练过程中，选择动作、执行动作、获取奖励，并更新Q值。
• test_update方法：在测试过程中，机器人根据学到的策略选择动作，并执行动作以验证是否能够成功走出迷宫。

运行结果