El robot recorre automáticamente el laberinto basado en Python

Dirección de descarga de recursos : https://download.csdn.net/download/sheziqiong/85631466

El robot camina automáticamente por el laberinto.

un tema de fondo

1.1 Tema experimental

En este experimento, se requiere utilizar el algoritmo de búsqueda básica y el algoritmo Deep QLearning para completar el laberinto automático del robot.

Figura 1 mapa (tamaño 10)

Como se muestra en la figura anterior, la elipse roja en la esquina superior izquierda es tanto el punto de partida como la posición inicial del robot, y el cuadrado verde en la esquina inferior derecha es la salida.

Las reglas del juego son: comience desde el punto de partida, atraviese el intrincado laberinto y llegue al punto de destino (salida).

• Las acciones que se pueden realizar en cualquier posición incluyen: subir 'u', ir a la derecha 'r', bajar 'd', ir a la izquierda 'l'.

• Después de realizar diferentes acciones, se obtendrán diferentes recompensas de acuerdo a las diferentes situaciones, en concreto, se encuentran las siguientes situaciones.

  • Golpear la pared
  • camina hacia la salida
  • otros casos

• Debe implementar el robot basado en el algoritmo de búsqueda básica y el algoritmo Deep QLearning , para que el robot pueda ir automáticamente a la salida del laberinto.

1.2 Requisitos experimentales

• Usa el lenguaje Python .
• Usa el algoritmo de búsqueda básico para completar el laberinto del robot.
• Utilice el algoritmo Deep QLearning para completar el laberinto de robots.
• La parte del algoritmo debe implementarse por sí misma, y ​​no se pueden usar paquetes, herramientas o interfaces listos para usar.

1.3 El experimento utiliza importantes paquetes de python

import os
import random
import numpy as np
import torch

Introducción a dos laberintos

A través de la clase laberinto Maze puede crear un laberinto al azar.

1. Use Maze(maze_size=size) para generar aleatoriamente un laberinto de tamaño * tamaño.
2. Utilice la función imprimir () para generar el tamaño del laberinto y dibujar el mapa del laberinto
3. El círculo rojo es la posición inicial del robot.
4. El cuadrado verde es la posición de salida del laberinto.

Figura 2 mapa gif (tamaño 10)

Los métodos miembros importantes en la clase Maze son los siguientes:

1. sense_robot() : Obtiene la posición actual del robot en el laberinto.

return: La posición actual del robot en el laberinto.

2. move_robot(direction): mueve el robot predeterminado de acuerdo con la dirección de entrada y devuelve un mensaje de error si la dirección no es válida.

dirección: dirección del movimiento, como: "u", valor legal: ['u', 'r', 'd', 'l']

retorno: el valor de la recompensa por ejecutar la acción

3. can_move_actions(position): Obtener la dirección en la que el robot actual puede moverse

posición: punto de coordenadas en cualquier lugar del laberinto

retorno: la acción que se puede realizar en este punto, como: ['u','r','d']

4. is_hit_wall(self, location, direction): determina si la dirección del movimiento golpea una pared

ubicación, dirección: la ubicación actual y la dirección para moverse, como (0,0), "u"

retorno: Verdadero (golpear la pared) / Falso (no golpear la pared)

5. draw_maze(): dibuja el laberinto actual

Introducción a los tres algoritmos

3.1 Algoritmo primero en profundidad

Pasos específicos del algoritmo:

• Seleccione un vértice $V_{}$Como punto de partida, visita y marca el vértice;

• Con Vi como el vértice actual, busque $V_{}$Cada punto adyacente $V_{}$, si $V_{}$no ha sido visitado, entonces visite y marque el punto adyacente $V_{}$, si $V_{}$ha sido visitado, luego busque $V_{}$el siguiente punto adyacente de ;

• Con $V_{}$Para el vértice actual, repita el paso anterior), hasta que la gráfica y $V_{}$Se visitan todos los vértices con caminos interconectados;

• Si todavía hay vértices en el gráfico que no se han visitado (en el caso de no conectividad), puede tomar un vértice no visitado en el gráfico como punto de partida y repetir el proceso anterior hasta que se visiten todos los vértices del gráfico. .

complejidad del tiempo:

El tiempo requerido para encontrar los vecinos de cada vértice es $O\left(n^2\right)$, n es el número de vértices y la complejidad temporal del algoritmo es$O\left(n^2\right)$

3.2 Algoritmo QLearning de aprendizaje por refuerzo

Q-Learning es un algoritmo de iteración de valor. A diferencia del algoritmo de Iteración de políticas (Policy Iteration), el algoritmo de iteración de valores calculará el valor (Valor) o la utilidad (Utilidad) de cada "estado" o "acción de estado", y luego intentará maximizar este valor. Por lo tanto, la estimación precisa de cada valor de estado es el núcleo del algoritmo de iteración de valores. Por lo general, se considera la recompensa a largo plazo de maximizar la acción , es decir, no solo se considera la recompensa que trae la acción actual, sino también la recompensa a largo plazo de la acción.

3.2.1 Cálculo e iteración del valor Q

El algoritmo Q-learning crea el estado (estado) y la acción (acción) en una tabla Q_table para almacenar el valor Q. La fila de la tabla Q representa el estado (estado) y la columna representa la acción (acción):

En el algoritmo Q-Learning , esta recompensa a largo plazo se registra como el valor Q, que considerará el valor Q de cada “estado-acción”, en concreto, su fórmula de cálculo es: Q ( st , a ) = R t
$$q\_{\_}_{},un)=R_{t+}+C\times \underset{a}{}Q(un,s_{t+})$$

Es decir, para el "estado-acción" actual $(s_{},a)$ , considere realizar la acción$una$ recompensa posambiental$R_{t+}$, y ejecutar la acción $a$ llega$s_{t+}$Después de eso, el valor máximo de Q ${\mathrm{máximo}}_{}Q(un,s_{t+})$，$\gamma$ es el factor de descuento.

Después de calcular el nuevo valor Q, generalmente se usa un método más conservador para actualizar la tabla Q, es decir, la introducción de la variable de holgura $alfa\; seactualiza\; de\; acuerdo\; con\; la\; siguiente\; fórmula,\; lo\; que\; haceque\; el\; cambio\; iterativode$ la tabla Q sea más suave$.$
$$q\_{\_}_{},un)=(1-un)\times q\_{\_}_{},un)+a\times (R_{t+}+C\times \underset{a}{}Q(un,s_{t+}\left)\right)$$

3.2.2 Selección de acciones del robot

En el aprendizaje por refuerzo, el problema de exploración-explotación es un problema muy importante. Específicamente, de acuerdo con la definición anterior, el robot hará todo lo posible para elegir la decisión óptima cada vez para maximizar la recompensa a largo plazo. Pero hacerlo tiene las siguientes desventajas:

1. En el aprendizaje inicial, el valor Q no es preciso, si elige de acuerdo con el valor Q en este momento, causará errores.
2. Después de aprender durante un período de tiempo, la ruta del robot será relativamente fija, por lo que el robot no podrá explorar el entorno de manera efectiva.

Por lo tanto, se necesita un método para resolver los problemas anteriores y aumentar la exploración del robot. Por lo general, se utiliza el algoritmo epsilon-greedy :

1. Cuando el robot elige una acción, la acción se selecciona aleatoriamente con una parte de la probabilidad y la acción se selecciona de acuerdo con el valor Q óptimo con una parte de la probabilidad.
2. Al mismo tiempo, la probabilidad de elegir una acción aleatoria debería disminuir gradualmente con el proceso de entrenamiento.

3.2.3 Proceso de aprendizaje del algoritmo Q-Learning

3.2.4 Clase de robot

La clase QRobot se proporciona en esta asignación , que implementa la iteración de la tabla Q y la estrategia de selección de acciones del robot, que se pueden from QRobot import QRobotusar mediante la importación.

Métodos de miembros principales de la clase QRobot

1. sense_state(): Obtener la ubicación actual del robot

retorno: las coordenadas de posición del robot, tales como: (0, 0)

2. current_state_valid_actions(): Obtenga las acciones que el robot actual puede mover legalmente

retorno: Una lista de acciones legales actualmente, como: ['u', 'r']

3. train_update(): Ejecuta acciones de acuerdo con la estrategia del algoritmo QLearning en el estado de entrenamiento

retorno: la acción seleccionada actualmente y la recompensa por ejecutar la acción actual, como: 'u', -1

4. test_update (): ejecuta acciones de acuerdo con la estrategia del algoritmo QLearning en el estado de prueba

retorno: la acción actualmente seleccionada, y el retorno obtenido al ejecutar la acción actual, como: 'u', -1

5. reiniciar()

volver: restablecer la posición del robot en el laberinto

3.2.5 Clase de corredor

La clase QRobot implementa la iteración del valor Q y la estrategia de selección de acciones del algoritmo QLearning . Durante el proceso de entrenamiento del robot que camina automáticamente por el laberinto, es necesario usar continuamente el algoritmo QLearning para actualizar iterativamente la tabla de valores Q para lograr un estado "óptimo", por lo que se empaqueta una clase Runner para el entrenamiento y la visualización del robot. Disponible víafrom Runner import Runnerimportación.

Métodos de miembros principales de la clase Runner:

1. run_training(training_epoch, training_per_epoch=150): entrene al robot, actualice constantemente la tabla Q y guarde el resultado del entrenamiento en la variable miembro train_robot_record

training_epoch, training_per_epoch: el número total de tiempos de entrenamiento, el número máximo de pasos que el robot se mueve cada vez

2. run_testing(): prueba si el robot puede salir del laberinto

3. generar_gif (nombre de archivo): envía el resultado del entrenamiento a la imagen gif especificada

nombre de archivo: ruta legal del archivo, el nombre del archivo debe .giftener

4. plot_results(): Muestra los indicadores durante el proceso de entrenamiento en un gráfico: Tiempos de Éxito, Recompensas Acumuladas, Tiempos de Ejecución por Época

3.3 DQN

El algoritmo DQN utiliza una red neuronal para aproximar la función de valor y el diagrama de bloques del algoritmo es el siguiente.

En este experimento, la red neuronal provista se usa para predecir los puntajes de evaluación de cuatro acciones y generar los puntajes de evaluación al mismo tiempo.

Métodos de miembros principales de la clase ReplayDataSet

• add(self, state, action_index, reward, next_state, is_terminal) agrega un dato de entrenamiento

estado: posición actual del robot

action_index: Seleccione el índice para ejecutar la acción

recompensa: la recompensa por realizar la acción

next_state: la posición del robot después de realizar la acción

is_terminal: si el robot ha llegado al nodo terminal (alcanzó el final o golpeó la pared)

• random_sample(self, batch_size): extrae aleatoriamente datos fijos de tamaño de lote del conjunto de datos

batch_size: entero, no se permite exceder el número de datos en el conjunto de datos

• build_full_view (self, maze): abre el truco para obtener la vista completa

laberinto: un objeto instanciado con la clase Maze

Cuatro resultados de solución

4.1 Profundidad primero

Escriba un algoritmo de búsqueda primero en profundidad y pruébelo, y use la pila para iterar capa por capa, y finalmente busque la ruta. El proceso principal es que el nodo de entrada se usa como nodo raíz y luego verifica si el nodo ha sido explorado y si hay nodos secundarios.Si se cumplen las condiciones, el nodo se expandirá y los nodos secundarios del nodo serán empujados a la pila en orden. Si se explora un nodo, pero el nodo no es el punto final y no hay un nodo secundario que se pueda expandir, extraiga este punto de la pila y opere en un bucle hasta encontrar el punto final.

Los resultados de la prueba son los siguientes:

• Si maze_size=5, ejecuta el algoritmo de búsqueda básica, el resultado final es el siguiente:

搜索出的路径： ['r', 'd', 'r', 'd', 'd', 'r', 'r', 'd']
恭喜你，到达了目标点
Maze of size (5, 5)

Figura 3 Mapa de búsqueda básico (tamaño 5)

• Si maze_size=10, ejecuta el algoritmo de búsqueda básica, el resultado final es el siguiente:

搜索出的路径： ['r', 'r', 'r', 'r', 'r', 'r', 'r', 'd', 'r', 'd', 'd', 'd', 'r', 'd', 'd', 'd', 'l', 'd', 'd', 'r']
恭喜你，到达了目标点
Maze of size (10, 10)

Figura 4 Mapa de búsqueda básica (tamaño 10)

• Si maze_size=20, ejecuta el algoritmo de búsqueda básica, el resultado final es el siguiente:

搜索出的路径： ['d', 'r', 'u', 'r', 'r', 'r', 'r', 'd', 'r', 'd', 'r', 'r', 'r', 'r', 'd', 'd', 'r', 'd', 'd', 'd', 'd', 'r', 'r', 'r', 'r', 'r', 'd', 'r', 'r', 'd', 'r', 'd', 'd', 'l', 'l', 'd', 'd', 'd', 'd', 'd', 'r', 'd', 'd', 'r']
恭喜你，到达了目标点
Maze of size (20, 20)

Figura 5 Mapa de búsqueda básico (tamaño 20)

Parte del código es el siguiente:

def myDFS(maze):
        """
        对迷宫进行深度优先搜索
        :param maze: 待搜索的maze对象
        """
        start = maze.sense_robot()
        root = SearchTree(loc=start)
        queue = [root]  # 节点堆栈，用于层次遍历
        h, w, _ = maze.maze_data.shape
        is_visit_m = np.zeros((h, w), dtype=np.int)  # 标记迷宫的各个位置是否被访问过
        path = []  # 记录路径
        peek = 0
        while True:
            current_node = queue[peek]  # 栈顶元素作为当前节点
            #is_visit_m[current_node.loc] = 1  # 标记当前节点位置已访问
            if current_node.loc == maze.destination:  # 到达目标点
                path = back_propagation(current_node)
                break
            if current_node.is_leaf() and is_visit_m[current_node.loc] == 0:  # 如果该点存在叶子节点且未拓展
                is_visit_m[current_node.loc] = 1  # 标记该点已拓展
                child_number = expand(maze, is_visit_m, current_node)
                peek+=child_number  # 开展一些列入栈操作
                for child in current_node.children:
                    queue.append(child)  # 叶子节点入栈
            else:
                queue.pop(peek)  # 如果无路可走则出栈
                peek-=1
        return path

4.2 Aprendizaje Q

En el proceso de entrenamiento del algoritmo, primero lea la posición actual del robot y luego agregue el estado actual a la tabla de valores Q. Si el estado actual ya existe en la tabla, no es necesario agregarlo repetidamente. Después de eso, el robot generado debe realizar acciones, devolver el valor de recompensa del mapa y encontrar la posición actual del robot. Luego verifique y actualice la tabla de valores Q nuevamente, atenuando la posibilidad de seleccionar acciones aleatoriamente.

En el proceso de implementación del algoritmo QLearning , se modifica y ajusta principalmente la actualización del cálculo de la tabla de valores Q. La tabla de valores Q ajustada tiene un rendimiento excelente en tiempo de ejecución, velocidad de cálculo rápida, alta precisión y alta estabilidad. A continuación, se ajusta la tasa de disminución de la probabilidad de seleccionar aleatoriamente una acción. Debido a que durante la prueba se descubrió que si la tasa de disminución es demasiado lenta, la aleatoriedad será demasiado fuerte, lo que indirectamente debilitará el efecto de la recompensa. Por lo tanto, después del ajuste, se encontró que la tasa de disminución de 0.5 es una excelente y valor estable.

Parte del código es el siguiente:

    def train_update(self):
        """
        以训练状态选择动作，并更新相关参数
        :return :action, reward 如："u", -1
        """
        self.state = self.maze.sense_robot()  # 获取机器人当初所处迷宫位置

        # 检索Q表，如果当前状态不存在则添加进入Q表
        if self.state not in self.q_table:
            self.q_table[self.state] = {
    
    a: 0.0 for a in self.valid_action}

        action = random.choice(self.valid_action) if random.random() < self.epsilon else max(self.q_table[self.state], key=self.q_table[self.state].get)  # action为机器人选择的动作
        reward = self.maze.move_robot(action)  # 以给定的方向移动机器人,reward为迷宫返回的奖励值
        next_state = self.maze.sense_robot()  # 获取机器人执行指令后所处的位置

        # 检索Q表，如果当前的next_state不存在则添加进入Q表
        if next_state not in self.q_table:
            self.q_table[next_state] = {
    
    a: 0.0 for a in self.valid_action}

        # 更新 Q 值表
        current_r = self.q_table[self.state][action]
        update_r = reward + self.gamma * float(max(self.q_table[next_state].values()))
        self.q_table[self.state][action] = self.alpha * self.q_table[self.state][action] +(1 - self.alpha) * (update_r - current_r)

        self.epsilon *= 0.5  # 衰减随机选择动作的可能性

        return action, reward

Los resultados de la prueba son los siguientes:

• Si maze_size=3, ejecuta el algoritmo de búsqueda de aprendizaje por refuerzo, el resultado final es el siguiente:

Figura 6 Mapa gif de búsqueda de aprendizaje por refuerzo (tamaño 3)

Figura 7 Resultados del entrenamiento

• Si maze_size=5, ejecuta el algoritmo de búsqueda de aprendizaje por refuerzo, el resultado final es el siguiente:

Figura 8 Mapa gif de búsqueda de aprendizaje por refuerzo (tamaño 5)

Figura 9 Resultados del entrenamiento

• Si maze_size=10, ejecuta el algoritmo de búsqueda de aprendizaje por refuerzo, el resultado final es el siguiente:

Figura 10 Mapa gif de búsqueda de aprendizaje por refuerzo (tamaño 10)

Figura 11 Resultados del entrenamiento

• Si maze_size=11, ejecuta el algoritmo de búsqueda de aprendizaje por refuerzo, el resultado final es el siguiente:

Figura 12 Mapa gif de búsqueda de aprendizaje por refuerzo (tamaño 11)

Figura 13 Resultados del entrenamiento

Después de la prueba, el algoritmo de búsqueda de aprendizaje por refuerzo puede proporcionar rápidamente un camino para salir del laberinto y la tasa de éxito aumenta gradualmente a medida que aumenta el número de rondas de entrenamiento. Cuando el número de rondas de entrenamiento es suficiente, la tasa de precisión final puede alcanzar el 100 %.

4.3 DQN

Sobre la base de Q-Learning , las redes neuronales se utilizan para estimar los puntajes de evaluación de las acciones posteriores a la toma de decisiones. Simplemente reemplácelo con la salida de la red neuronal en la parte correspondiente de Q-Learning .

Los resultados de la prueba son los siguientes:

• Si maze_size=3, ejecuta el algoritmo DQN , el resultado final es el siguiente:

  

  Figura 14 Resultados del entrenamiento

• Si maze_size=5, ejecuta el algoritmo DQN , el resultado final es el siguiente:

  

  Figura 15 Resultados del entrenamiento

• Si maze_size=10, ejecuta el algoritmo DQN , el resultado final es el siguiente:

  

  Figura 16 Resultados del entrenamiento

4.4 Enviar el resultado de la prueba

4.4.1 Prueba de algoritmo de búsqueda básica

Figura 17 Ruta del algoritmo de búsqueda básica

0 segundos

4.4.2 Algoritmos de aprendizaje por refuerzo (elemental)

Figura 18 Algoritmo de aprendizaje por refuerzo (primario)

0 segundos

4.4.3 Algoritmos de aprendizaje por refuerzo (intermedio)

Figura 19 Algoritmo de aprendizaje por refuerzo (intermedio)

0 segundos

4.4.4 Algoritmos de aprendizaje por refuerzo (avanzado)

Figura 20 Algoritmo de aprendizaje por refuerzo (avanzado)

0 segundos

4.4.5 Algoritmo DQN (primario)

Figura 21 Algoritmo DQN (primario)

2 segundos

4.4.6 Algoritmo DQN (Intermedio)

Figura 22 Algoritmo DQN (intermedio)

3 segundos

4.4.7 Algoritmo DQN (avanzado)

Figura 23 Algoritmo DQN (avanzado)

Dirección de descarga de recursos : https://download.csdn.net/download/sheziqiong/85631466