Day4：强化学习之Qlearning走迷宫

一、迷宫游戏

1.环境已知

迷宫环境是定义好的，障碍物位置和空位置是已知的；

# 定义迷宫
grid = [
    [0, 0, 0, 1, 0],
    [0, 1, 0, 1, 0],
    [0, 1, 0, 0, 0],
    [0, 0, 0, 1, 0],
    [0, 1, 1, 1, 0]
]

2.奖励方式已知

如果碰到障碍物则得-1，如果到终点则得10分，正常走一步-0.1分。

 # 检查是否越界或碰到障碍
        if 0 <= row < self.rows and 0 <= col < self.cols and self.grid[row][col] == 0:
            # 满足在边界内部，且网格为空（对应数值为0）
            self.state = (row, col) #可以走到这个位置
        else:
            return self.state, -1, False  # 碰到障碍或越界，返回惩罚-1，标记未完成

        # 检查是否到达终点
        if self.state == self.goal:
            return self.state, 10, True  # 到达终点，返回奖励10，标记完成
        else:
            return self.state, -0.1, False  # 正常移动，返回小惩罚-0.1，标记未完成

3.动作选择策略

ε-greedy策略选择动作。

 def choose_action(self, state):
        # 根据ε-greedy策略选择动作，以epsilon的概率选择探索，以1-epsilon的概率选择利用
        # 一般随着时间的推移，epsilon逐渐减小，即减小探索，增大利用概率
        # 如果随机抽样小于epsilon，则选择探索，即随机抽取动作
        if random.uniform(0, 1) < self.epsilon: 
            return random.choice([0, 1, 2, 3])  # 探索
        # 如果随机抽样大于等于epsilon，则选择利用，即利用现有规则进行动作选择
        else:
            return np.argmax(self.q_table[state])  # 利用，state是当前状态，为二维坐标

4.Q值更新方法

# Q值更新参数方法 q(st,at)=q(st,at)+alpha*(reward+gamma*max(q)-q(st，at))
                self.q_table[state][action] += self.alpha * (reward + self.gamma * best_next_q - self.q_table[state][action])
                state = next_state # 状态更新 

5.Qlearning计算流程图

二、代码实现

import numpy as np
import random

# 定义迷宫环境
class Maze:
    def __init__(self, grid, start, goal):
        self.grid = grid  # 迷宫网格，0表示空地，1表示障碍
        self.start = start  # 起点
        self.goal = goal  # 终点
        self.rows, self.cols = len(grid), len(grid[0]) # 网格行、列边界
        self.state = start  # 当前状态
        

    def reset(self):
        # 重置迷宫状态
        self.state = self.start
        return self.state

    def step(self, action):
        # 根据动作移动智能体
        row, col = self.state
        if action == 0:  # 上
            row -= 1 # 行减1
        elif action == 1:  # 下
            row += 1 # 行加1
        elif action == 2:  # 左
            col -= 1 # 列-1
        elif action == 3:  # 右
            col += 1 # 列+1

        # 检查是否越界或碰到障碍
        if 0 <= row < self.rows and 0 <= col < self.cols and self.grid[row][col] == 0:
            # 满足在边界内部，且网格为空（对应数值为0）
            self.state = (row, col) #可以走到这个位置
        else:
            return self.state, -1, False  # 碰到障碍或越界，返回惩罚-1，标记未完成

        # 检查是否到达终点
        if self.state == self.goal:
            return self.state, 10, True  # 到达终点，返回奖励10，标记完成
        else:
            return self.state, -0.1, False  # 正常移动，返回小惩罚-0.1，标记未完成

    def render(self):
        # 可视化迷宫
        for r in range(self.rows): # 遍历状态
            for c in range(self.cols): # 遍历动作
                if (r, c) == self.state: # 对于当前位置，用字母A表示
                    print("A", end=" ")  # 智能体位置
                elif (r, c) == self.goal: #对于目标位置用字母G表示
                    print("G", end=" ")  # 终点
                elif self.grid[r][c] == 1: # 对于障碍物用＃表示
                    print("#", end=" ")  # 障碍
                else: # 对于空地用0表示
                    print("0", end=" ")  # 空地
            print()
        print()

# Q-learning算法
class QLearning:
    def __init__(self, maze, alpha=0.1, gamma=0.99, epsilon=0.1):
        self.maze = maze # 迷宫环境
        self.alpha = alpha  # 学习率
        self.gamma = gamma  # 折扣因子
        self.epsilon = epsilon  # 探索概率
        self.q_table = np.zeros((maze.rows, maze.cols, 4))  # Q表，4个动作，三个维度

    def choose_action(self, state):
        # 根据ε-greedy策略选择动作，以epsilon的概率选择探索，以1-epsilon的概率选择利用
        # 一般随着时间的推移，epsilon逐渐减小，即减小探索，增大利用概率
        # 如果随机抽样小于epsilon，则选择探索，即随机抽取动作
        if random.uniform(0, 1) < self.epsilon: 
            return random.choice([0, 1, 2, 3])  # 探索
        # 如果随机抽样大于等于epsilon，则选择利用，即利用现有规则进行动作选择
        else:
            return np.argmax(self.q_table[state])  # 利用，state是当前状态，为二维坐标

    def train(self, episodes):
        # 训练
        for episode in range(episodes):
            state = self.maze.reset() # 重置状态
            done = False # 训练完成标志
            total_reward = 0 # 总奖励

            while not done:
                action = self.choose_action(state) # 选择动作，根据1-epsilon策略
                next_state, reward, done = self.maze.step(action) #根据动作移动智能体
                total_reward += reward

                # Q-learning更新规则
                best_next_q = np.max(self.q_table[next_state]) # Qtable里面下一状态对应Q的最大值
                # Q值更新参数方法 q(st,at)=q(st,at)+alpha*(reward+gamma*max(q)-q(st，at))
                self.q_table[state][action] += self.alpha * (reward + self.gamma * best_next_q - self.q_table[state][action])
                state = next_state # 状态更新 
            # 每当完成100回合，则输出一次总奖励数据
            if (episode + 1) % 100 == 0:
                print(f"Episode {episode + 1}: Total Reward = {total_reward}")

    def test(self):
        # 测试训练后的策略
        state = self.maze.reset()
        done = False
        steps = []

        while not done:
            action = np.argmax(self.q_table[state]) #选择Q表中最大的动作
            next_state, _, done = self.maze.step(action) 
            steps.append(action)
            state = next_state
            self.maze.render() # 可视化迷宫

        print("Steps taken:", steps) #输出动作集合，每一步动作都被储存倒steps【】列表中

# 定义迷宫
grid = [
    [0, 0, 0, 1, 0],
    [0, 1, 0, 1, 0],
    [0, 1, 0, 0, 0],
    [0, 0, 0, 1, 0],
    [0, 1, 1, 1, 0]
]
start = (0, 0) # 起点
goal = (4, 4) # 终点

# 创建迷宫和Q-learning对象
maze = Maze(grid, start, goal)
ql = QLearning(maze)

# 训练和测试
ql.train(episodes=1000) #训练1000轮
ql.test() #测试

三、结果展示