游戏AI辅助开发实战：从感知到决策的强化学习入门

我经常被问到这样一个问题：想系统学习人工智能，到底应该从哪里入手最合适？看了那么多路线图、买了网课、收藏了一堆资源，结果还是停留在“看过”的阶段。我的答案一直很固定——挑一个你感兴趣、又足够完整的项目直接上手。而在所有方向里，游戏辅助工具开发是我认为性价比最高、最容易获得反馈、也最能覆盖人工智能核心流程的切入点。

它没有听起来那么玄乎，也不涉及任何灰色地带。我说的游戏辅助，指的是在单机游戏、自建训练环境里，让AI自己学会“看懂画面、做出决策、模拟操作”这件事。它正好覆盖人工智能的三大经典环节：感知（Perception）、决策（Decision Making）和控制（Control）。换句话说，你真把这条路走通了，相当于把图像识别、强化学习、自动控制这几个机器学习最核心的模块都亲手过了一遍。

这篇文章会从一个完整的项目视角，把游戏AI辅助工具开发的整体设计、核心技术、实操步骤以及坑点一次性讲清楚。无论你是人工智能专业的学生、刚入门的开发者、还是想转行做AI应用方向的技术人，这篇文章应该都能给你一条可以照着走的路。

1. 先想清楚：游戏辅助工具到底在解决什么问题

1.1 辅助不是外挂，边界在哪里

很多人一听到“游戏辅助工具”，第一反应是外挂、作弊、破坏游戏平衡。但实际在人工智能领域，游戏辅助开发的合法应用范围非常广，而且一直是学术界和工业界的重要研究方向。

一个旁观视角就是：很多游戏公司需要给NPC（非玩家角色）写“辅助AI”，让它们表现得更聪明、更自然，比如敌人会绕后、队友会团队协作。另一个视角是游戏测试：让AI自动在游戏中跑图、打怪、复现bug，比人工测试效率高出几个量级。还有一个视角就是研究者常用的：让AI在高仿真的游戏环境里学习，像Atari、Gym、Mujoco这类环境，本身就是为了让AI通过“看懂像素画面、学会操作”而设计的。

所以，我在这篇里讲的游戏辅助工具，核心场景是单机游戏、自建环境、强化学习研究demo，以及游戏公司的NPC智能开发。明确不为在线对战游戏编写破坏公平性的脚本，这是原则问题，也是这个方向能长期做下去的前提。

1.2 一个完整的游戏辅助系统长什么样

如果你把一个游戏AI辅助系统拆开，它本质上就是一个模仿人类玩家的闭环系统：

• 眼睛：从游戏画面中读取信息，也就是感知层；
• 大脑：根据当前画面决定下一步动作，这就是决策层；
• 手：把决策转换成实际的按键、鼠标操作，也就是控制层。

任何一个成熟的游戏AI项目，都逃不出这三层结构。比如玩吃金币小游戏，人类的流程是：眼睛看到金币的位置（视觉信息），大脑判断“往左走还是往上走”（策略），手按下键盘（执行）。AI完全复刻这套流程：截屏或者拿画面数据（感知），根据画面计算最佳移动方向（决策），模拟按键或者直接调用环境接口（控制）。

这三层各有一套完整的知识体系，又彼此衔接紧密。如果你只想做规则型脚本，那“感知”和“控制”两层就够了，但一旦游戏稍微复杂一点，规则脚本根本写不过来，这时候就需要真正的机器学习方案。

1.3 方案选型：为什么必然走到“感知-决策-控制”架构

早期有一些很粗暴的辅助脚本，靠的是读游戏内存，直接获取金币坐标、血量这些隐藏数据。这种方案速度快、精度高，但致命问题在于极度依赖游戏内部实现，版本更新就失效，而且明显属于作弊范畴。我们做人工智能学习，不应该往这个方向走。

替代方案是把游戏画面当作唯一的输入源，用人工智能技术去理解画面。这样做的优势很明显：一是通用性强，任何能看到画面的游戏，理论上都能套用同样的框架；二是更接近“人类玩家”的行为模式，这种人机交互方式在未来机器人、自动驾驶等场景中同样适用；三是在合规范围内，它只是利用了游戏对外开放的画面信息，不修改游戏本身。

所以选用“感知-决策-控制”三层架构不是一个设计偏好，而是整个AI学习路径的自然延伸。三者的联系也非常清晰：感知层输出的状态，直接决定决策层的策略质量；决策层输出的动作，又必须靠控制层精准执行。任何一个环节缺失，整个闭环都会断掉。

2. 感知层：让程序“看懂”游戏画面

2.1 输入源选择：读内存、抓屏幕、还是直接拿图像

感知层的第一件事，是决定数据从哪里来。

读取游戏内存是最不推荐的做法，它需要逆向工程，且严重依赖特定游戏版本，很容易踩合规红线。抓取屏幕是相对通用的方案，技术上可以用win32gui找窗口、Pillow抓图，或者直接用游戏引擎提供的渲染接口拿数据。第三种方案是使用自建训练环境，比如用Pygame写一个小游戏，直接在代码内部把画面数据传给AI，这是学习和研究阶段最好用的方式。

我的建议是：训练和调试阶段用自建环境，部署和验证阶段再考虑对接真实游戏窗口。原因很简单，AI训练需要大量样本，如果每次采样都要从头抓一帧屏幕，性能瓶颈会瞬间暴露出来。而在自建环境里，画面数据直接在内存中以数组形式存在，效率能高几十倍。

2.2 模板匹配与颜色过滤：最容易被低估的入门利器

很多人以为“感知”一定要上深度学习，其实不然。很多游戏场景的物体颜色、形状高度固定，用传统图像处理就能做到又快又准地识别。

拿我经常作为练习的“吃金币”小游戏举例：金币是黄色的圆，玩家是红色的方块，背景是深灰色。这时最合适的感知方案是HSV颜色过滤，而不是训练一个目标检测模型。RGB颜色空间对光照变化很敏感，而HSV把色相（Hue）、饱和度（Saturation）、明度（Value）分开了，更容易提取特定颜色的物体。

python复制import cv2
import numpy as np

def locate_coin(frame):
    # frame是从游戏环境拿到的RGB图像数组
    hsv = cv2.cvtColor(frame, cv2.COLOR_RGB2HSV)

    # 黄色在HSV中的色相范围大概是20~30
    lower_yellow = np.array([20, 100, 100])
    upper_yellow = np.array([30, 255, 255])
    mask = cv2.inRange(hsv, lower_yellow, upper_yellow)

    # 先腐蚀再膨胀，去掉噪点，保留完整轮廓
    mask = cv2.erode(mask, None, iterations=2)
    mask = cv2.dilate(mask, None, iterations=2)

    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    if len(contours) == 0:
        return None

    # 选取面积最大的轮廓，认为是当前金币
    c = max(contours, key=cv2.contourArea)
    (x, y), radius = cv2.minEnclosingCircle(c)
    if radius < 4 or cv2.contourArea(c) < 30:
        return None
    return int(x), int(y)

为什么先腐蚀再膨胀？因为画面里可能出现一些细小的噪音点，腐蚀能把它们去掉，但也会缩小目标边缘，所以再膨胀恢复一下原本的大小。这两步配合起来，是图像处理里非常经典的“开运算”操作。

传统视觉方式的最大优势是快且可控。在400x300的画面里，这种识别单帧耗时在毫秒级，配合强化学习训练完全够用。更重要的是，它能让你把注意力集中在“AI决策”上，而不是一开始就被复杂的模型调参拖住。

2.3 用目标检测代替传统图像处理的时机和方法

当然，传统视觉也有明显的天花板。如果游戏画面光照频繁变化、物体有旋转和遮挡，或者要识别多类目标，颜色阈值就扛不住了。

这时就需要目标检测模型顶上，常见的选择是YOLO系列。用YOLO的流程是：先标注样本（画框），训练模型，然后每帧推理输出目标的类别和坐标。这个过程比较费时间，但对复杂画面来说，识别能力会强很多。

什么时候该切换？我建议按这个标准来判断：如果HSV阈值加形态学处理能稳定识别超过95%的帧，就先用传统方案；如果要识别的目标种类超过3类、物体重叠严重、且你觉得调颜色阈值已经消耗了大量时间，就别犹豫，上目标检测。

3. 决策层：从规则脚本到强化学习代理

3.1 规则引擎：简单任务的及格线

感知层负责输出“金币在哪、玩家在哪”，决策层就要回答“下一步该干嘛”。

最简单的决策方式就是规则。拿到金币坐标(coin_x, coin_y)和玩家坐标(player_x, player_y)，算一下差值，判断是向左还是向右、向上还是向下：

python复制def rule_based_action(player_pos, coin_pos):
    dx = coin_pos[0] - player_pos[0]
    dy = coin_pos[1] - player_pos[1]
    if abs(dx) > abs(dy):
        return 0 if dx > 0 else 1   # 右或左
    else:
        return 2 if dy > 0 else 3   # 下或上

这种方案非常直观，训练也不用，调通就立竿见影。但规则引擎有两个硬伤：一是状态一多，规则就会指数级膨胀；二是它没法处理“未知局面”，几乎没有泛化能力。做入门验证可以，想深入学AI就不够了。

我见过一些教程，用规则脚本写了一个看起来还不错的打砖块AI，然后宣称强化学习多简单。这其实是混淆了感知和决策的价值。真正要学的是在那个环境里搭建决策网络、定义奖励、让AI自己探索出最优策略的过程。

3.2 为什么游戏是强化学习最好的训练场

游戏环境有一个让人欲罢不能的特性——奖励信号明确。吃一个金币加10分，碰到炸弹减分，赢了加更多。强化学习的核心就是让智能体在和环境的交互中最大化累计奖励，游戏正好提供了这个完美的闭环。

更重要的是，游戏环境可以无限重置。现实中你没法让一辆自动驾驶汽车反复撞树，但在游戏里，你可以开一万局、死一万次，每次死亡都变成一条训练数据。速度上也能做得很快：一个训练器可以并行开几十个环境同时采样，一夜之间跑出几百万帧数据。

这类学习方式对应到具体技术上就是强化学习（Reinforcement Learning）。目前研究最活跃的算法里，DQN（深度Q网络）、PPO（近端策略优化）、A3C（异步优势演员-评论家）都是从游戏场景里火起来的。其中DQN最适合作为入门第一站，因为它原理清晰、代码结构简洁，而且在图像输入类任务上有非常直观的效果。

3.3 DQN核心训练细节：奖励设计、经验回放、探索策略

DQN的思路不复杂：用一个深度神经网络来近似Q函数——也就是“在某个状态下，采取某个动作能获得多少未来收益”。每一步决策都选择Q值最大的动作，训练目标就是让这个Q值预测得越来越准。

但真正决定模型能不能训练出来的，往往是几个细节：

第一，经验回放（Experience Replay）。如果每拿到一条经验就立刻更新网络，样本之间存在强相关性，模型会陷入混乱。正确做法是用一个经验池存下最近几万条“状态-动作-奖励-下一状态”记录，每次随机抽取一批来训练，打破样本之间的相关性。

第二，奖励设计（Reward Shaping）。吃一个金币给1分也许就够，但如果任务很难完成、奖励稀疏，AI可能几万步都学不会。这时可以加一些小奖励，比如“每靠近金币一点就给0.01分”，引导AI往目标移动。但奖励也不宜设计得过密，否则AI可能学会在原地抖动刷分，而不是真正去吃金币。经典思路是“稀疏奖励为主，形状奖励为辅，两者配比在工程里反复调”。

第三，探索策略（Exploration Strategy）。如果你总是按照当前Q值选最大动作，AI会非常快地形成路径依赖，陷入局部最优——它可能永远只在屏幕左上角绕圈。常见做法是Epsilon-Greedy：以一定概率随机探索，以剩余概率选择Q值最大的动作。训练初期epsilon设大一点，比如0.9，让AI大量尝试；随着训练进程逐步衰减到0.05左右，让AI逐渐从“探索”转向“利用”。

python复制if random.random() < epsilon:
    action = env.action_space.sample()   # 随机探索
else:
    q_values = model(preprocess(obs))    # 利用当前策略
    action = torch.argmax(q_values).item()

这段代码就是探索-利用困境的核心实现。很多人训练不收敛，不是模型结构写错了，而是epsilon衰减策略设得不合理。衰减太快，AI还没摸清环境就开始“保守经营”，衰减太慢，训练后期还在盲目乱撞。

4. 控制层与工程化落地

4.1 从模型决策到游戏动作的三种落地方式

决策层输出的是一组离散动作编号：0表示左移，1表示右移，2表示上移，3表示下移。要把这些数字变成游戏里真实的移动，有三种落地方式：

第一种是直接调用环境接口。自建Pygame环境时，env.step(action)本身就是执行动作，这是研究阶段最优雅的方案。第二种是模拟键盘鼠标，Windows下可以用pyautogui或win32api发送虚拟按键，适合对接真实游戏窗口。第三种是读取游戏事件，比如从游戏日志或内存映射中获取状态、注入控制指令，这种方式最接近游戏开发本身的自动化测试，但要谨慎使用，且只适用于自己开发或明确授权研究的场景。

在工程落地时要特别注意帧同步问题。决策网络推理一次需要几十毫秒，如果每帧都推理，CPU占用会很高，还容易导致控制指令堆积。实际项目中，我习惯用一个简单的控制频率限制器：每0.1秒最多执行一次决策，其余时间保持上一帧的动作。这样既能大幅降低计算压力，也能让AI的行为看起来更稳定。

4.2 训练环境搭建：本地环境比真实游戏更适合起步

如果你一上来就想着直接控制《超级玛丽》或者《王者荣耀》，大概率会被画面解析、速度限制、反作弊机制搞得焦头烂额。更合理的路径是先在本地自建一个“玩具游戏”，把AI训练全链路跑通，再考虑迁移到更复杂的场景。

用Pygame做一个吃金币环境，核心逻辑非常简单：一块400x300的画布，一个红色玩家方块，一个黄色金币圆。玩家通过上下左右动作移动，吃到金币加10分，金币重新随机出现，500步没吃到就算本局结束。

python复制import gym
from gym import spaces
import numpy as np
import pygame

class CoinGame(gym.Env):
    def __init__(self, width=400, height=300):
        super().__init__()
        self.width = width
        self.height = height
        self.action_space = spaces.Discrete(4)
        self.observation_space = spaces.Box(
            low=0, high=255, shape=(height, width, 3), dtype=np.uint8
        )
        pygame.init()
        self.screen = pygame.display.set_mode((width, height))
        pygame.display.set_caption("Coin Game")
        self.clock = pygame.time.Clock()
        self.reset()

    def reset(self):
        self.player_pos = np.array([self.width // 2, self.height // 2], dtype=np.float32)
        self.coin_pos = self._random_pos()
        self.score = 0
        self.steps = 0
        return self._get_obs()

    def _random_pos(self):
        x = np.random.randint(20, self.width - 20)
        y = np.random.randint(20, self.height - 20)
        return np.array([x, y], dtype=np.float32)

    def _get_obs(self):
        self.screen.fill((30, 30, 30))
        pygame.draw.rect(self.screen, (220, 50, 50),
                        (self.player_pos[0], self.player_pos[1], 15, 15))
        pygame.draw.circle(self.screen, (255, 215, 0),
                           self.coin_pos.astype(int), 8)
        pygame.display.flip()
        obs = pygame.surfarray.array3d(self.screen)
        obs = np.transpose(obs, (1, 0, 2))
        return obs

    def step(self, action):
        if action == 0:
            self.player_pos[0] -= 4
        elif action == 1:
            self.player_pos[0] += 4
        elif action == 2:
            self.player_pos[1] -= 4
        elif action == 3:
            self.player_pos[1] += 4

        self.player_pos[0] = np.clip(self.player_pos[0], 0, self.width - 15)
        self.player_pos[1] = np.clip(self.player_pos[1], 0, self.height - 15)

        self.steps += 1
        reward = 0
        done = False

        if np.linalg.norm(self.player_pos - self.coin_pos) < 20:
            reward = 10
            self.score += 1
            self.coin_pos = self._random_pos()

        if self.steps >= 500:
            done = True

        return self._get_obs(), reward, done, {"score": self.score}

我把它封装成了OpenAI Gym的接口，这是一个非常有用的习惯。整个强化学习社区都围绕Gym接口展开，封装好环境之后，你以后可以无缝切换到任何成熟算法库，比如Stable-Baselines3，而不需要重写环境代码。如果你还不会Gym，这个例子本身就是最好的入门教材。

5. 实操：从零构建一个可靠的吃金币AI

5.1 环境准备与工具链选择

实操之前先把工具链准备好。基础版本是Python 3.9以上，需要安装这几个库：

• pygame：自建游戏环境；
• opencv-python：图像处理与目标提取；
• torch：深度学习框架，DQN网络依赖它；
• numpy：数组操作的基础库；
• gym：环境封装标准接口，可选但推荐。

bash复制pip install pygame opencv-python torch numpy gym

如果电脑有NVIDIA显卡，建议安装CUDA版PyTorch，训练速度能提升数倍。没有显卡也没关系，这里的输入分辨率比较低，CPU推理也完全跑得动。

5.2 图像识别模块实现

图像识别模块的目标是从环境返回的RGB数组里，提取金币的中心坐标。前面在感知层给出的locate_coin函数就是核心。在实际训练流程里，我还会把它和玩家位置检测封装到一起，组成一个PerceptionModule类。

python复制class PerceptionModule:
    def __init__(self):
        self.player_lower = (0, 100, 100)   # 红色玩家
        self.player_upper = (10, 255, 255)
        self.coin_lower = (20, 100, 100)    # 黄色金币
        self.coin_upper = (30, 255, 255)

    def extract(self, frame):
        hsv = cv2.cvtColor(frame, cv2.COLOR_RGB2HSV)
        coin_pos = self._locate(hsv, self.coin_lower, self.coin_upper)
        player_pos = self._locate(hsv, self.player_lower, self.player_upper)
        return player_pos, coin_pos

    def _locate(self, hsv, lower, upper):
        mask = cv2.inRange(hsv, lower, upper)
        mask = cv2.erode(mask, None, iterations=2)
        mask = cv2.dilate(mask, None, iterations=2)
        contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL,
                                       cv2.CHAIN_APPROX_SIMPLE)
        for c in sorted(contours, key=cv2.contourArea, reverse=True):
            area = cv2.contourArea(c)
            if area < 30:
                continue
            (x, y), r = cv2.minEnclosingCircle(c)
            if r < 4:
                continue
            return int(x), int(y)
        return None

这里我特意把所有阈值集中在一个类里，方便后续调整。实际过程中你会频繁遇到“金币被识别成玩家”“红色背景误判为玩家”这类问题，集中管理阈值能帮你快速定位。

5.3 DQN决策模块实现

决策模块是整条链路里最需要“设计感”的部分。我的DQN网络结构不复杂：三个卷积层负责从84x84的预处理图像中提取视觉特征，两个全连接层输出四个动作的Q值。

python复制import torch
import torch.nn as nn

class DQN(nn.Module):
    def __init__(self, n_actions=4):
        super().__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(3, 16, 8, stride=4), nn.ReLU(),
            nn.Conv2d(16, 32, 4, stride=2), nn.ReLU(),
            nn.Conv2d(32, 32, 3, stride=1), nn.ReLU(),
            nn.Flatten(),
        )
        self.fc = nn.Sequential(
            nn.Linear(32 * 7 * 7, 256), nn.ReLU(),
            nn.Linear(256, n_actions)
        )

    def forward(self, x):
        if x.dtype != torch.float32:
            x = x.float()
        x = x / 255.0          # 归一化到0-1
        return self.fc(self.conv(x))

训练时我会维护两个网络：当前网络和目标网络。目标网络的参数每隔一定步数从当前网络复制一次，用来计算TD目标。之所以这样做，是因为如果只有一个网络，每一步更新里“预测目标”和“当前预测”来自同一个源，会导致模型自我追逐，训练过程很不稳定。

下面是一个训练循环的最小实现，我把关键步骤都写了注释：

python复制def train_dqn(env, policy_net, target_net, optimizer,
              replay_buffer, episodes, batch_size=32, gamma=0.99):
    for episode in range(episodes):
        obs = env.reset()
        obs = cv2.resize(obs, (84, 84))
        done = False
        total_reward = 0

        while not done:
            # 探索与利用：epsilon从1.0线性衰减到0.05
            epsilon = max(0.05, 1.0 - episode / (episodes * 0.7))
            if np.random.random() < epsilon:
                action = env.action_space.sample()
            else:
                with torch.no_grad():
                    q = policy_net(torch.from_numpy(obs).permute(2, 0, 1).unsqueeze(0))
                    action = torch.argmax(q).item()

            next_obs, reward, done, _ = env.step(action)
            next_obs = cv2.resize(next_obs, (84, 84))
            replay_buffer.push(obs, action, reward, next_obs, done)

            if len(replay_buffer) > batch_size:
                batch_obs, batch_act, batch_rew, batch_next, batch_done = replay_buffer.sample(batch_size)
                current_q = policy_net(batch_obs).gather(1, batch_act)
                with torch.no_grad():
                    max_next_q = target_net(batch_next).max(1, keepdim=True)[0]
                    target_q = batch_rew + gamma * max_next_q * (1 - batch_done)
                loss = nn.MSELoss()(current_q, target_q)
                optimizer.zero_grad()
                loss.backward()
                optimizer.step()

            obs = next_obs
            total_reward += reward

        # 每隔10局同步一次目标网络
        if episode % 10 == 0:
            target_net.load_state_dict(policy_net.state_dict())

        print(f"Episode {episode}: reward={total_reward}")

这段代码看似简单，里面藏着几个非常重要的工程经验：

• 状态预处理必须保持一致。训练时resize到了84x84，推理时也必须做完全相同的预处理，否则模型表现会急剧下降。
• gather按动作索引取Q值，这是PyTorch里DQN训练的标准写法，能一次性取出当前动作对应的Q值。
• 目标网络同步不要每步都做，否则和只有一个网络没什么区别；每隔5到20局同步一次，训练会稳定很多。
• loss本身低不代表AI聪明，DQN里的loss是预测和TD目标之间的差，可能预测越准、动作越来越好；也可能因为奖励一直在涨，I target也在涨，loss反而居高不下。真正要看的是每局总奖励的上升趋势。

5.4 主循环流程衔接

最后把所有模块组装起来。整体流程是：环境返回画面帧 → 预处理 → 决策得到动作 → 执行动作 → 返回新画面 → 收集经验 → 更新网络。这个闭环每循环一次，就是一个完整的“eyes-brain-hand”流程。

组装时还要额外注意一点：cv2.resize默认使用线性插值，对图像类输入没问题；但如果你在做三通道图像预处理时不小心把通道顺序搞混了，就会导致颜色过滤直接失效。我在实际项目里统一约定：环境输出RGB，OpenCV处理时COLOR_RGB2HSV，PyTorch训练时permute(2, 0, 1)。三个环节的通道顺序不一致，是最常见的“玄学bug”来源，排查起来非常耗时间，建议一开始就统一。

6. 常见问题与排查技巧实录

这个项目我前后带过不少人跑过，也远程看过很多次“为什么我的AI不学”的求助。下面这四类问题出现频率最高，我把排查思路直接整理成一份速查表。

再补充几个我踩过的很现实的坑：

第一，动作方向和直觉相反。 Python的二维数组第一维是行（y轴），第二维是列（x轴）。在Pygame里画矩形用的坐标又是先x后y。我最初写动作更新时把x和y搞反了，AI训练了50轮，奖励始终是0。排查了半天，最后发现“上移”和“左移”被调换了。

第二，验证时要固定随机种子。 如果你的环境每次初始化都随机生成金币位置，模型训练过程中还好，但验证时需要固定几个种子，否则同一套权重跑出来的结果方差会非常大，你很难判断模型到底进没进步。

第三，别忘了设置训练时间上限。 我在训练循环里会加上time_limit参数，比如单局最多跑500步、整套训练最多跑2小时。否则AI一旦进入重复转圈的坏循环，训练会永远停不下来，场面一度非常尴尬。

关于公平性和合规性，最后再说一句。我做这个项目的初衷，是把人工智能的系统知识通过一个有趣的游戏场景串起来。它用来学强化学习、做NPC智能、做游戏测试自动化，都非常有价值；但一旦越过边界，去破坏在线对战游戏的公平性，性质就完全变了。技术本身没有好坏，关键在于用在哪。守住这条线，这个方向你可以放心地玩很久。

从Pygame环境搭建到DQN决策，再到常见问题排查，这套流程走完之后，你已经亲手点亮了人工智能感知、决策、控制三个核心环节，后续无论是去啃目标检测模型，还是转向PPO、A3C等更先进的强化学习算法，都有了扎实的抓手。