强化学习 | 基于 Q-Learning 算法解决 Treasure on Right 游戏

Hi，大家好，我是半亩花海。在本篇技术博客中，我们将探讨如何使用 Q-Learning 算法来解决 Treasure on Right 游戏，实现一个简单的强化学习。

---

一、游戏背景

Treasure on Right 游戏——一个简单的命令行寻宝游戏，是一个经典的强化学习示例，它模拟了一个智能体在有限状态空间中寻找宝藏的过程。游戏环境由一个线性状态空间组成，智能体可以执行两个动作：向左移动或向右移动。目标是让智能体学会在状态空间中移动，找到宝藏，它位于状态空间的最右侧。

---

二、Q-Learning 算法简介

Q-Learning 是一种基于值函数的强化学习算法，用于解决智能体与环境交互的问题。它通过迭代更新状态-动作对的 Q 值来优化策略。Q 值表示在特定状态下采取特定动作的长期回报，智能体通过学习最优的 Q 值来选择最佳动作。

---

三、代码拆解

1. 导入必要的库

首先导入 pandas、numpy 和 time 库，以便进行数据处理、数组操作和控制程序运行时间。

import pandas as pd
import numpy as np
import time

2. 定义常量和参数

在这个部分，我们定义了游戏中所需的常量和参数，包括状态数量、动作集合、epsilon 贪婪度、学习率、奖励衰减因子等。

N_STATES = 6                 # 状态数量
ACTIONS = ["left", "right"]  # 动作集合
EPSILON = 0.9                # epsilon-greedy算法中的贪婪度
ALPHA = 0.1                  # 学习率
GAMMA = 0.9                  # 奖励衰减因子
MAX_EPISODES = 15            # 最大训练轮数
FRESH_TIME = 0.3             # 每一步的时间间隔
TerminalFlag = "terminal"    # 终止状态标识

3. 创建Q表

我们定义了一个函数来创建 Q 表格，用于存储状态-动作对的 Q 值。初始时，所有的 Q 值都被初始化为 0。

def build_q_table(n_states, actions):
    return pd.DataFrame(  
        np.zeros((n_states, len(actions))),  
        columns=actions  
    )

4. 选择动作

这个函数根据当前状态和 Q 表格选择动作。我们使用 ε-greedy 策略，以一定的概率随机选择动作，以便在探索和利用之间取得平衡。

def choose_action(state, q_table):
    state_table = q_table.loc[state, :]
    if (np.random.uniform() > EPSILON) or ((state_table == 0).all()):
        action_name = np.random.choice(ACTIONS)
    else:
        action_name = state_table.idxmax()
    return action_name

5. 获取环境反馈

这个函数模拟了智能体与环境的交互过程，根据智能体采取的动作返回下一个状态和相应的奖励。

def get_env_feedback(S, A):
    if A == "right":
        if S == N_STATES - 2:
            S_, R = TerminalFlag, 1
        else:
            S_, R = S + 1, 0
    else:
        S_, R = max(0, S - 1), 0
    return S_, R

6. 更新环境

这个函数用于更新环境的显示，以便智能体能够观察到当前状态。

def update_env(S, episode, step_counter):
    env_list = ["-"] * (N_STATES - 1) + ["T"]  
    if S == TerminalFlag:  
        interaction = 'Episode %s: total_steps = %s' % (episode + 1, step_counter)  
        print(interaction)  
        time.sleep(2)  
    else:  
        env_list[S] = '0'  
        interaction = ''.join(env_list)  
        print(interaction)  
        time.sleep(FRESH_TIME)  

7. Q-learning主循环

这个函数包含了整个Q-learning的主要逻辑，包括选择动作、获取环境反馈和更新Q值等步骤。

def rl():
    q_table = build_q_table(N_STATES, ACTIONS)

    for episode in range(MAX_EPISODES): 
        step_counter = 0
        S = 0
        is_terminated = False
        update_env(S, episode, step_counter)  

        while not is_terminated:  
            A = choose_action(S, q_table)  
            S_, R = get_env_feedback(S, A)  
            q_predict = q_table.loc[S, A]  

            if S_ != TerminalFlag:  
                q_target = R + GAMMA * q_table.loc[S_, :].max()  
            else:  
                q_target = R  
                is_terminated = True  

            q_table.loc[S, A] += ALPHA * (q_target - q_predict)  
            S = S_  
            update_env(S, episode, step_counter + 1)  
            step_counter += 1  

    return q_table

8. 主程序入口

在这部分代码中，我们运行整个程序，执行Q-learning算法并输出最终的Q表格。

if __name__ == '__main__':
    q_table = rl()  
    print(q_table)  

---

四、项目意义和应用价值

Treasure on Right 游戏作为一个简单的强化学习示例，展示了 Q-Learning 算法在解决智能体与环境交互问题中的应用。通过实现这个项目，我们可以深入理解强化学习算法的工作原理，并了解如何利用这种算法解决实际问题。Q-Learning 算法及其变体在许多领域都有广泛的应用，如机器人控制、自动驾驶、游戏设计等。通过掌握这种算法，我们可以为各种应用场景开发智能决策系统，从而提高效率、优化资源利用，甚至解决复杂的实时决策问题。

在学术界和工业界，Q-Learning 算法已经被广泛应用，并且不断被改进和扩展，以解决更加复杂的问题。因此，掌握 Q-Learning 算法对于从事人工智能和机器学习领域的工程师和研究人员来说是非常重要的。

---

五、完整代码

# 使用Q-Learning算法来实现treasure on right游戏(宝藏在最右边的位置:训练一个智能体去获得这个宝藏)
import pandas as pd
import numpy as np
import time

N_STATES = 6                 # 状态数量
ACTIONS = ["left", "right"]  # 动作集合
EPSILON = 0.9                # epsilon-greedy算法中的贪婪度
ALPHA = 0.1                  # 学习率
GAMMA = 0.9                  # 奖励衰减因子
MAX_EPISODES = 15            # 最大训练轮数
FRESH_TIME = 0.3             # 每一步的时间间隔
TerminalFlag = "terminal"    # 终止状态标识


# 创建Q表
def build_q_table(n_states, actions):
    return pd.DataFrame(  # 创建一个DataFrame对象
        np.zeros((n_states, len(actions))),  # 用0初始化一个n_states行，len(actions)列的数组
        columns=actions  # 设置DataFrame的列名为动作列表
    )


# 根据当前状态选择动作
def choose_action(state, q_table):
    state_table = q_table.loc[state, :]  # 获取Q表中对应状态行的值
    if (np.random.uniform() > EPSILON) or ((state_table == 0).all()):  # 判断是否随机选择动作
        action_name = np.random.choice(ACTIONS)  # 如果满足条件，随机选择一个动作
    else:
        action_name = state_table.idxmax()  # 否则选择具有最大值的动作
    return action_name  # 返回选择的动作


# 获取环境的反馈，包括下一个状态和奖励
def get_env_feedback(S, A):
    if A == "right":  # 如果动作是向右移动
        if S == N_STATES - 2:  # 如果当前状态是倒数第二个状态
            S_, R = TerminalFlag, 1  # 下一个状态是终止状态，奖励为1
        else:  # 否则
            S_, R = S + 1, 0  # 下一个状态向右移动一步，奖励为0
    else:  # 如果动作不是向右移动
        S_, R = max(0, S - 1), 0  # 下一个状态向左移动一步，奖励为0
    return S_, R  # 返回下一个状态和奖励

# 更新环境
def update_env(S, episode, step_counter):
    env_list = ["-"] * (N_STATES - 1) + ["T"]  # 创建一个环境列表，长度为N_STATES-1，最后一个元素为终止标志"T"
    if S == TerminalFlag:  # 如果当前状态为终止状态
        interaction = 'Episode %s: total_steps = %s' % (episode + 1, step_counter)  # 打印本次训练的步数
        print(interaction)  # 打印信息
        time.sleep(2)  # 等待2秒
    else:  # 如果当前状态不是终止状态
        env_list[S] = '0'  # 在环境列表中将当前状态位置标记为'0'
        interaction = ''.join(env_list)  # 将环境列表转换为字符串
        print(interaction)  # 打印环境状态
        time.sleep(FRESH_TIME)  # 等待一段时间


# Q-learning主循环
def rl():
    # 创建Q表: 存储的表记录的是, 在状态S下, 每个行为A的Q值
    q_table = build_q_table(N_STATES, ACTIONS)

    for episode in range(MAX_EPISODES):       # 对于每一轮训练(episode)
        step_counter = 0                      # 记录每个episode的步数
        S = 0                                 # 初始状态
        is_terminated = False                 # 用于判断是否到达终止状态
        update_env(S, episode, step_counter)  # 更新环境显示

        # 在未到达终止状态的情况下进行循环
        while not is_terminated:            # 如果未到达终止状态
            A = choose_action(S, q_table)   # 选择动作
            S_, R = get_env_feedback(S, A)  # 获取环境反馈（下一个状态和奖励）
            q_predict = q_table.loc[S, A]   # 获取Q值的预测值

            # 根据下一个状态是否为终止状态更新Q值的目标值
            if S_ != TerminalFlag:                               # 如果下一个状态不是终止状态
                q_target = R + GAMMA * q_table.loc[S_, :].max()  # 使用贝尔曼方程计算目标Q值
            else:                                                # 如果下一个状态是终止状态
                q_target = R                                     # 目标Q值为即时奖励
                is_terminated = True                             # 到达终止状态

            q_table.loc[S, A] += ALPHA * (q_target - q_predict)  # 使用Q-learning更新Q表
            S = S_                                               # 更新当前状态
            update_env(S, episode, step_counter + 1)             # 更新环境显示
            step_counter += 1                                    # 步数加1

    return q_table


if __name__ == '__main__':
    q_table = rl()  # 运行Q-learning算法
    print(q_table)  # 打印Q表