TensorFlow 强化学习：6~10

六、异步方法

到目前为止，我们已经涵盖了大多数重要主题，例如马尔可夫决策过程，值迭代，Q 学习，策略梯度，深度 Q 网络和参与者批评算法。这些构成了强化学习算法的核心。在本章中，我们将继续从演员评论家算法中停止的地方继续搜索，并深入研究用于深度强化学习的高级异步方法及其最著名的变体异步优势演员评论家算法，通常称为 A3C 算法。

但是，在开始使用 A3C 算法之前，让我们修改第 4 章和“策略梯度”中涵盖的演员评论家算法的基础。如果您还记得，演员评论算法有两个组成部分：

演员
评论家

参与者采取当前的环境状态并确定要采取的最佳行动，而评论家则通过采取环境状态和行动来扮演策略评估角色，并返回一个分数，以描述该状态对某项行动的良好程度。如下图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-znhRHze2-1681786518135)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/5b448889-61bf-43ca-82f5-ce5d63662d33.png)]

换句话说，演员的行为像孩子，而评论家的行为像父母，孩子探索多种行为，父母批评不良行为并补充良好行为。因此，行动者批判算法既学习了策略函数，又学习了状态作用值函数。像策略梯度一样，参与者评论算法也通过梯度上升来更新其参数。在高维连续状态和动作空间的情况下，演员评论家方法非常有效。

因此，让我们从 Google DeepMind 发布的深度强化学习中的异步方法开始，该方法在表现和计算效率方面都超过了 DQN。

我们将在本章介绍以下主题：

为什么使用异步方法？
异步一步 Q 学习
异步一步 SARSA
异步 N 步 Q 学习
异步优势演员评论家
OpenAI Gym 中用于 CartPole v0 的 A3C

为什么使用异步方法？

Google DeepMind 和 MILA 的联合团队于 2016 年 6 月发布了用于深度强化学习的同步方法。它速度更快，并且能够在多核 CPU 上而不是使用 GPU 上显示出良好的效果。异步方法也适用于连续动作空间和离散动作空间。

如果我们回想起深度 Q 网络的方法，我们会使用经验回放作为存储所有经验的存储，然后使用其中的随机样本来训练我们的深度神经网络，从而反过来预测最大 Q 值。有利的行动。但是，随着时间的流逝，它具有高内存使用和大量计算的缺点。这背后的基本思想是克服这个问题。因此，不是使用经验回放，而是创建了环境的多个实例，并且多个智能体以异步方式并行执行操作（如下图所示）：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rk71iPRp-1681786518136)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/f1e415ce-be75-4cb7-b24e-7e81937e3c04.png)]

深度强化学习中异步方法的高级示意图

在异步方法中，为每个线程分配了一个进程，该进程包含一个学习器，该学习器表示与自己的环境副本进行交互的智能体网络。因此，这些多个学习器并行运行以探索他们自己的环境版本。这种并行方法允许智能体在任何给定的时间步长同时经历各种不同的状态，并涵盖了非策略学习和策略学习学习算法的基础。

如上所述，异步方法能够在多核 CPU（而不是 GPU）中显示出良好的效果。因此，异步方法非常快，因此成为最新的强化学习算法，因为到目前为止，深度强化学习算法的实现依赖于 GPU 驱动的机器和分布式架构，以见证所实现算法的更快收敛。

这些并行运行的多个学习器使用不同的探索策略，从而最大限度地提高了多样性。不同学习器的不同探索策略会更改参数，并且这些更新与时间相关的机会最少。因此，不需要经验回放记忆，并且我们依靠使用不同探索策略的并行学习来执行先前在 DQN 中使用的经验回放的角色。

使用并行学习器的好处如下：

减少训练时间。
不使用经验回放。因此，基于策略的强化学习方法也可以用于训练神经网络。

深度强化学习中异步方法的不同变体是：

异步一步 Q 学习
异步一步 SARSA
异步 N 步 Q 学习
异步优势演员评论家（A3C）

将变体 A3C 应用于各种 Atari 2600 游戏时，在多核 CPU 上获得了更好的基准测试结果，相对于早期的深度强化学习算法而言，其结果所需的时间要短得多，后者需要在 GPU 驱动的机器上运行。因此，由于依赖于昂贵的硬件资源（如 GPU）以及不同的复杂分布式架构，因此解决了该问题。由于所有这些优点，A3C 学习智能体是当前最先进的强化学习智能体。

异步单步 Q 学习

异步单步 Q 学习的架构与 DQN 非常相似。 DQN 中的智能体由一组主要网络和目标网络表示，其中一步损失的计算方法是主要网络预测的当前状态s的状态作用值与目标状态- 目标网络计算的当前状态的动作值。相对于策略网络的参数来计算损失的梯度，然后使用梯度下降优化器将损失最小化，从而导致主网络的参数更新。

异步单步 Q 学习中的区别在于，有多个此类学习智能体，例如，学习器并行运行并计算此损失。因此，梯度计算也并行发生在不同的线程中，其中每个学习智能体都与自己的环境副本进行交互。这些梯度在多个时间步长上在不同线程中的累积用于在固定时间步长后或剧集结束后更新策略网络参数。梯度的累积优于策略网络参数更新，因为这样可以避免覆盖每个学习器智能体执行的更改。

此外，将不同的探索策略添加到不同的线程可以使学习变得多样化且稳定。由于更好的探索，因此提高了表现，因为不同线程中的每个学习智能体都受到不同的探索策略。尽管有许多方法可以执行此操作，但一种简单的方法是在使用 ε 贪婪的同时为不同的线程使用不同的ε示例。

异步单步 Q 学习的伪代码如下所示。这里，以下是全局参数：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6pwMmUBg-1681786518136)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/4e2e2f05-a713-40a9-84b4-abd6e47f309f.png)]：策略网络的参数（权重和偏差）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lmvubNWa-1681786518137)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/ec675ec6-2574-4fe5-b97c-adfdfa98c693.png)]：目标网络的参数（权重和偏差）
T：整体时间步长计数器

代码语言：javascript复制

// Globally shared parameters , and T 
//  is initialized arbitrarily
// T is initialized 0

pseudo-code for each learner running parallel in each of the threads:

Initialize thread level time step counter t=0
Initialize  = 
Initialize network gradients 
Start with the initial state s

repeat until  :
    Choose action a with -greedy policy such that:

    Perform action a
    Receive new state s' and reward r
    Compute target y : 
    Compute the loss, 
    Accumulate the gradient w.r.t. : 
    s = s'
    T = T   1
    t = t   1

    if T mod  : 
        Update the parameters of target network :  = 
        # After every  time steps the parameters of target network is updated

    if t mod  or s = terminal state:
        Asynchronous update of  using 
        Clear gradients : 
        #at every  time step in the thread or if s is the terminal state
        #update  using accumulated gradients

异步单步 SARSA

异步单步 SARSA 的架构几乎与异步单步 Q 学习的架构相似，不同之处在于目标网络计算当前状态的目标状态作用值的方式。 SARSA 并未使用目标网络使用下一个状态s'的最大 Q 值，而是使用 ε 贪婪为下一个状态s'选择动作a'。下一个状态动作对的 Q 值Q(s', a')；Q(s', a', θ[t])用于计算当前状态的目标状态动作值。

异步单步 SARSA 的伪代码如下所示。这里，以下是全局参数：

θ：策略网络的参数（权重和偏差）
θ[t]：目标网络的参数（权重和偏差）
T：总时间步长计数器

代码语言：javascript复制

// Globally shared parameters , and T 
//  is initialized arbitrarily
// T is initialized 0

pseudo-code for each learner running parallel in each of the threads:

Initialize thread level time step counter t=0
Initialize  = 
Initialize network gradients 
Start with the initial state s
Choose action a with -greedy policy such that:

repeat until  :
    Perform action a
    Receive new state s' and reward r
    Choose action a' with -greedy policy such that:

    Compute target y : 
    Compute the loss, 
    Accumulate the gradient w.r.t. : 
    s = s'
    T = T   1
    t = t   1
    a = a'

    if T mod  : 
         Update the parameters of target network :  = 
         # After every  time steps the parameters of target network is updated

    if t mod  or s = terminal state:
         Asynchronous update of  using 
         Clear gradients : 
         #at every  time step in the thread or if s is the terminal state
         #update  using accumulated gradients

异步 N 步 Q 学习

异步 N 步 Q 学习的架构在某种程度上类似于异步单步 Q 学习的架构。区别在于，使用探索策略最多选择t[max]步骤或直到达到终端状态，才能选择学习智能体动作，以便计算策略网络参数的单个更新。此过程列出了自上次更新以来t[max]来自环境的奖励。然后，对于每个时间步长，将损失计算为该时间步长的折扣未来奖励与估计 Q 值之间的差。对于每个时间步长，此损失相对于特定于线程的网络参数的梯度将被计算和累积。有多个这样的学习智能体并行运行和累积梯度。这些累积的梯度用于执行策略网络参数的异步更新。

异步 N 步 Q 学习的伪代码如下所示。这里，以下是全局参数：

θ：策略网络的参数（权重和偏差）
θ[t]：目标网络的参数（权重和偏差）
T：总时间步长计数器
t：线程级时间步长计数器
T[max]：总时间步长的最大值
t[max]：线程中的最大时间步数

代码语言：javascript复制

// Globally shared parameters , and T 
//  is initialized arbitrarily
// T is initialized 0

pseudo-code for each learner running parallel in each of the threads:

Initialize thread level time step counter t = 1
Initialize  = 
Initialize  = 
Initialize network gradients 

repeat until  :
     Clear gradient : 
     Synchronize thread-specific parameters: 

     Get state 
     r = [] //list of rewards
     a = [] //list of actions
     s = [] //list of actions
     repeat until  is a terminal state or :
             Choose action  with -greedy policy such that:

             Perform action 
             Receive new state  and reward 
             Accumulate rewards by appending  to r
             Accumulate actions by appending  to a
             Accumulate actions by appending  to s
             t = t   1
             T = T   1

     Compute returns, R : 
     for  :

            Compute loss, 
            Accumulate gradients w.r.t.  :

     Asynchronous update of  using 
     if T mod  : 
         Update the parameters of target network :  = 
         # After every  time steps the parameters of target network is updated

异步优势演员评论家

在异步优势参与者批评者的架构中，每个学习智能体都包含一个参与者批评者，该学习器结合了基于值和基于策略的方法的优点。参与者网络将状态作为输入，并预测该状态的最佳动作，而评论家网络将状态和动作作为输入，并输出动作分数以量化该状态的动作效果。参与者网络使用策略梯度更新其权重参数，而评论家网络使用TD(0)来更新其权重参数，换言之，两个时间步长之间的值估计之差，如第 4 章“策略梯度”中所述。

在第 4 章和“策略梯度”中，我们研究了如何通过从策略梯度的预期未来收益中减去基线函数来更新策略梯度，从而在不影响预期收益的情况下减少方差的情况。梯度。预期的未来奖励和基线函数之间的差称为优势函数；它不仅告诉我们状态的好坏，而且还告诉我们该动作的预期好坏。

卷积神经网络既用于演员网络，又用于评论家网络。在每个t[max]步骤之后或直到达到终端状态之前，将更新策略和操作值参数。将与以下伪代码一起说明网络更新，熵和目标函数。此外，将策略π的熵H添加到目标函数中，以通过避免过早收敛到次优策略来改善探索。

因此，有多个这样的学习智能体程序运行，每个学习智能体程序都包含参与者关键网络，其中策略网络参数（即参与者网络参数）使用策略梯度进行更新，其中优势函数用于计算那些策略梯度。

异步单步 SARSA 的伪代码如下所示。这里，以下是全局参数：

θ：策略网络的参数（权重和偏差）
θ[v]：值函数逼近器的参数（权重和偏差）
T：总时间步长计数器

特定于线程的参数如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AmO7tyWa-1681786518137)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/98afa05f-22c6-488f-8943-f4d2397cb8bc.png)]：策略网络的线程特定参数
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mUZa90E2-1681786518137)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/9ce7dded-df9f-41f8-a8ab-b2950ec62a13.png)]：值函数近似器的线程特定参数

代码语言：javascript复制

//Globally shared parameters  and T
//  is initialized arbitrarily
//  is initialized arbitrarily
// T is initialized 0

pseudo-code for each learner running parallel in each of the threads:

//Thread specific parameters  and 
Initialize thread level time step counter t = 1
repeat until  :
    reset gradients :  and 
    synchronize thread specific parameters :  and 

    Get state 
    r = [] //list of rewards
    a = [] //list of actions
    s = [] //list of actions
    repeat until  is a terminal state or :
        Perform  according to policy 
        Receive new state  and reward 
        Accumulate rewards by appending  to r
        Accumulate actions by appending  to a
        Accumulate actions by appending  to s
        t = t   1
        T = T   1

    Compute returns, that is expected future rewards R such that:

    for  :

            Accumulate gradients w.r.t.  :

            Accumulate gradients w.r.t.  :

    Asynchronous update of  using  and  using

OpenAI Gym 中 Pong-v0 的 A3C

在第 4 章和“策略梯度”中，我们已经讨论过乒乓环境。我们将使用以下代码在 OpenAI Gym 中为 Pong-v0 创建 A3C：

代码语言：javascript复制

import multiprocessing
import threading
import tensorflow as tf
import numpy as np
import gym
import os
import shutil
import matplotlib.pyplot as plt

game_env = 'Pong-v0'
num_workers = multiprocessing.cpu_count()
max_global_episodes = 100000
global_network_scope = 'globalnet'
global_iteration_update = 20
gamma = 0.9
beta = 0.0001
lr_actor = 0.0001 # learning rate for actor
lr_critic = 0.0001 # learning rate for critic
global_running_rate = []
global_episode = 0

env = gym.make(game_env)

num_actions = env.action_space.n

tf.reset_default_graph()

输入状态图像预处理函数：

代码语言：javascript复制

def preprocessing_image(obs): #where I is the single frame of the game as the input
    """ prepro 210x160x3 uint8 frame into 6400 (80x80) 1D float vector """
    #the values below have been precomputed through trail and error by OpenAI team members
    obs = obs[35:195] 
    #cropping the image frame to an extent where it contains on the paddles and ball and area between them
    obs = obs[::2,::2,0] 
    #downsample by the factor of 2 and take only the R of the RGB channel.Therefore, now 2D frame
    obs[obs==144] = 0 #erase background type 1
    obs[obs==109] = 0 #erase background type 2
    obs[obs!=0] = 1 #everything else(other than paddles and ball) set to 1
    return obs.astype('float').ravel() #flattening to 1D

以下代码显示了actor-critic类，其中包含actor和critic网络的架构：

代码语言：javascript复制

class ActorCriticNetwork(object):
    def __init__(self, scope, globalAC=None):

        if scope == global_network_scope: # get global network
            with tf.variable_scope(scope):
                self.s = tf.placeholder(tf.float32, [None,6400], 'state')
                self.a_params, self.c_params = self._build_net(scope)[-2:]
        else: # local net, calculate losses
            with tf.variable_scope(scope):
                self.s = tf.placeholder(tf.float32, [None,6400], 'state')
                self.a_his = tf.placeholder(tf.int32, [None,], 'action')
                self.v_target = tf.placeholder(tf.float32, [None, 1], 'target_vector')

                self.a_prob, self.v, self.a_params, self.c_params = self._build_net(scope)

                td = tf.subtract(self.v_target, self.v, name='temporal_difference_error')
                with tf.name_scope('critic_loss'):
                    self.c_loss = tf.reduce_mean(tf.square(td))

                with tf.name_scope('actor_loss'):
                    log_prob = tf.reduce_sum(tf.log(self.a_prob) * tf.one_hot(self.a_his, num_actions, dtype=tf.float32), axis=1, keep_dims=True)
                    exp_v = log_prob * td
                    entropy = -tf.reduce_sum(self.a_prob * tf.log(self.a_prob   1e-5),
                                             axis=1, keep_dims=True) #exploration
                    self.exp_v = beta * entropy   exp_v
                    self.a_loss = tf.reduce_mean(-self.exp_v)

                with tf.name_scope('local_grad'):
                    self.a_grads = tf.gradients(self.a_loss, self.a_params)
                    self.c_grads = tf.gradients(self.c_loss, self.c_params)

            with tf.name_scope('sync'):
                with tf.name_scope('pull'):
                    self.pull_a_params_op = [l_p.assign(g_p) for l_p, g_p in zip(self.a_params, globalAC.a_params)]
                    self.pull_c_params_op = [l_p.assign(g_p) for l_p, g_p in zip(self.c_params, globalAC.c_params)]
                with tf.name_scope('push'):
                    self.update_a_op = actor_train.apply_gradients(zip(self.a_grads, globalAC.a_params))
                    self.update_c_op = critic_train.apply_gradients(zip(self.c_grads, globalAC.c_params))

    def _build_net(self, scope):
        w_init = tf.random_normal_initializer(0., .1)
        with tf.variable_scope('actor_network'):
            l_a = tf.layers.dense(self.s, 300, tf.nn.relu6, kernel_initializer=w_init, name='actor_layer')
            a_prob = tf.layers.dense(l_a, num_actions, tf.nn.softmax, kernel_initializer=w_init, name='ap')
        with tf.variable_scope('critic_network'):
            l_c = tf.layers.dense(self.s, 100, tf.nn.relu6, kernel_initializer=w_init, name='critic_layer')
            v = tf.layers.dense(l_c, 1, kernel_initializer=w_init, name='v') # state value
        a_params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=scope   '/actor')
        c_params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=scope   '/critic')
        return a_prob, v, a_params, c_params

    def update_global(self, feed_dict): # run local
        session.run([self.update_a_op, self.update_c_op], feed_dict) # local gradient applied to global net

    def pull_global(self): # run local
        session.run([self.pull_a_params_op, self.pull_c_params_op])

    def choose_action(self, s): # run local
        s = np.reshape(s,[-1])
        prob_weights = session.run(self.a_prob, feed_dict={self.s: s[np.newaxis, :]})
        action = np.random.choice(range(prob_weights.shape[1]),
                                  p=prob_weights.ravel()) # select action w.r.t the actions prob
        return action

代表每个线程中的进程的Worker类如下所示：

代码语言：javascript复制

class Worker(object):
    def __init__(self, name, globalAC):
        self.env = gym.make(game_env).unwrapped
        self.name = name
        self.AC = ActorCriticNetwork(name, globalAC)

    def work(self):
        global global_running_rate, global_episode
        total_step = 1
        buffer_s, buffer_a, buffer_r = [], [], []
        while not coordinator.should_stop() and global_episode < max_global_episodes:
            obs = self.env.reset()
            s = preprocessing_image(obs)
            ep_r = 0
            while True:
                if self.name == 'W_0':
                    self.env.render()
                a = self.AC.choose_action(s)

                #print(a.shape)

                obs_, r, done, info = self.env.step(a)
                s_ = preprocessing_image(obs_)
                if done and r<=0: 
                      r = -20
                ep_r  = r
                buffer_s.append(np.reshape(s,[-1]))
                buffer_a.append(a)
                buffer_r.append(r)

                if total_step % global_iteration_update == 0 or done: # update global and assign to local net
                    if done:
                        v_s_ = 0 # terminal
                    else:
                        s_ = np.reshape(s_,[-1])
                        v_s_ = session.run(self.AC.v, {self.AC.s: s_[np.newaxis, :]})[0, 0]
                    buffer_v_target = []
                    for r in buffer_r[::-1]: # reverse buffer r
                        v_s_ = r   gamma * v_s_
                        buffer_v_target.append(v_s_)
                    buffer_v_target.reverse()

                    buffer_s, buffer_a, buffer_v_target = np.vstack(buffer_s), np.array(buffer_a), np.vstack(buffer_v_target)
                    feed_dict = {
                        self.AC.s: buffer_s,
                        self.AC.a_his: buffer_a,
                        self.AC.v_target: buffer_v_target,
                    }
                    self.AC.update_global(feed_dict)

                    buffer_s, buffer_a, buffer_r = [], [], []
                    self.AC.pull_global()

                s = s_
                total_step  = 1
                if done:
                    if len(global_running_rate) == 0: # record running episode reward
                        global_running_rate.append(ep_r)
                    else:
                        global_running_rate.append(0.99 * global_running_rate[-1]   0.01 * ep_r)
                    print(
                        self.name,
                        "Ep:", global_episode,
                        "| Ep_r: %i" % global_running_rate[-1],
                          )
                    global_episode  = 1
                    break

以下代码显示了main函数，该函数创建线程池并将工作线程分配给不同的线程：

代码语言：javascript复制

if __name__ == "__main__":
    session = tf.Session()

    with tf.device("/cpu:0"):
        actor_train = tf.train.RMSPropOptimizer(lr_actor, name='RMSPropOptimiserActor')
        critic_train = tf.train.RMSPropOptimizer(lr_critic, name='RMSPropOptimiserCritic')
        acn_global = ActorCriticNetwork(global_network_scope) # we only need its params
        workers = []
        # Create worker
        for i in range(num_workers):
            i_name = 'W_%i' % i # worker name
            workers.append(Worker(i_name, acn_global))

    coordinator = tf.train.Coordinator()
    session.run(tf.global_variables_initializer())

    worker_threads = []
    for worker in workers:
        job = lambda: worker.work()
        t = threading.Thread(target=job)
        t.start()
        worker_threads.append(t)
    coordinator.join(worker_threads)

    plt.plot(np.arange(len(global_running_rate)), global_running_rate)
    plt.xlabel('step')
    plt.ylabel('Total moving reward')
    plt.show()

根据学习的输出的屏幕截图（绿色桨是我们的学习智能体）：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pfqO7afc-1681786518137)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/fae36238-a4f7-46b5-aeeb-0110aac10b23.png)]

总结

我们看到，使用并行学习器更新共享模型可以大大改善学习过程。我们了解了在深度学习中使用异步方法的原因及其不同的变体，包括异步单步 Q 学习，异步单步 SARSA，异步 N 步 Q 学习和异步优势参与者。我们还学习了实现 A3C 算法的方法，在该方法中，我们使智能体学习了 Breakout 和 Doom 游戏。

在接下来的章节中，我们将重点介绍不同的领域，以及如何以及可以应用深度强化学习。

七、一切都是机器人-真正的战略游戏

近年来，视频游戏行业以惊人的速度增长。根据 SuperData 的 2017 年度回顾报告，全球游戏行业创造了 1084 亿美元的收入。全球游戏市场研究机构 Newzoo 预测，到 2020 年，视频游戏行业的收入将超过 1400 亿美元。

实时策略游戏构成策略视频游戏类型的子类别，并且相对于回合制策略游戏而言，实时策略游戏现在变得越来越重要。在本章中，我们将讨论 AI 社区为何无法解决实时策略游戏，以及与其他算法相比，强化学习在学习和表现方面如何更好地解决该问题陈述。

我们将在本章介绍以下主题：

实时策略游戏
强化学习和其他方法
RTS 游戏中的强化学习

实时策略游戏

Brett Sperry 首先使用术语实时策略（RTS）作为宣传其游戏 Dune II 的标语。实时策略游戏涉及玩家使用实时策略来增加资产，保存资产并利用它们来摧毁对手的资产。它与需要在非常短的时间内做出的许多复杂的战术决策相关。

这与基于回合的策略游戏不同，在回合制策略游戏中，每个对手都有时间分析和采取行动，而其他对手则无法执行任何动作。在实时策略游戏中，动作和反应都实时发生，因为环境中的其他实体（即对手）也很活跃，并且会同时执行动作。在真实的策略游戏环境中，实体的形式多种多样，包括玩家，结构及其多样化的高维特征。因此，目标是采取最佳措施在游戏环境中生存，直到您取得胜利为止，而环境中的一个或多个实体正在对您不利。

实时策略游戏的特性使传统的规划方法效率低下，如下所示：

高维连续动作空间
高维连续状态空间
环境是不确定的
该环境是部分可观察的，玩家只能感知该环境的一部分（即游戏地图/世界）
因此，由于游戏环境的状态不断变化，因此系统应该是实时的，可以实时决定并执行动作。

实时策略游戏已经发展了很多，现在具有包含许多实体的复杂虚拟环境，可以模拟各种现实问题。因此，现实世界策略游戏已成为 AI 社区研究人员的良好测试平台，因为它们提供了复杂，多样，真实世界环境的仿真以测试其算法，从而创建更强大，更高效的算法。因此，这些模拟环境实际上有助于创建更好的学习智能体，这些学习智能体可以在这些环境中生存和获胜，而无需在现实世界中进行测试，这在创建和维护方面非常昂贵。

近几十年来，计算能力的提高使得实现高级 AI 算法成为可能。因此，它使他们成为解决实际策略游戏中国家行动复杂性和时间问题的最有效的候选人选择。大多数技术（例如 minimax 和基于案例的在线计划）都可以用来解决此问题，但是它们在有限的条件下可以高效运行。

在可用的技术中，强化学习在学习和计划中表现更好。我们已经知道，强化学习在涉及高维和连续状态动作空间时有许多成功的案例。

强化学习和其他方法

已经设计出许多方法来解决实时策略游戏的问题。强化学习之前的主要方法之一是基于案例的在线规划。基于案例的在线计划涉及基于案例的实时推理。在基于案例的推理中，使用了一组方法来学习计划。基于案例的在线计划在实现计划获取和执行的同时也实时地实现了此属性。

基于案例的在线规划

基于案例的推理包括四个步骤：

检索
重用
修订
保留

下图说明了这些步骤：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-83gZTq3Z-1681786518138)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/05aae01f-7184-41b5-aeeb-374aedd5a71c.png)]

基于案例的推理

在检索步骤中，从案例库中选择与问题相关的案例子集。在重用步骤中，将根据所选情况调整解决方案。然后，在修订步骤中，通过在实际环境中进行测试来验证适应的解决方案，并观察到量化预测解决方案准确率的反馈。保留步骤决定是否将此新解决的案例存储在案例库中。因此，基于案例的推理和计划涉及重用以前的计划，并使它们适应新情况。

基于案例的推理主要应用于静态域，也就是说，智能体有时间决定要采取的操作，与此同时，环境的状态也不会改变。但是现实世界中的问题是动态的，并且有时间限制。因此，基于案例的推理不适合实际的策略游戏，这导致基于案例的在线规划，其中与基于案例的推理不同，实时进行计划和执行。下图给出了基于案例的在线计划的架构：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oiLoihrs-1681786518138)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/2296ca03-8f44-4eff-b1f6-5e92a222af79.png)]

基于案例的在线计划

如图所示，基于案例的在线计划具有两个额外的流程，相对于基于案例的推理，这些流程有很小的变化，以实时实现计划和执行。这两个过程如下：

扩展：此过程将当前适应的解决方案作为输入，并找到未解决的子问题，即子目标，如果有任何可检索和可解决的未解决子目标。如果世界状态发生的变化足以使当前解决方案发生变化，它还会监视世界状态并将信号发送到适配模块。这称为延迟自适应，在运行期间执行。该流程模块使在线基于案例的计划在动态环境中工作。
执行：这将执行当前解决方案并根据执行结果更新其状态。如果子问题失败，导致当前解决方案在执行时失败，则此过程通过将当前信息发送到扩展模块以查找替代解决方案来更新当前解决方案，以缓解此问题。

实时策略游戏的缺点

所有先前方法效率低下的原因在于，决策是实时进行的，其中状态动作空间巨大且连续。先前的方法在有限的条件下是有效的，因为它们不能满足以下所有条件：

高维状态动作空间
对抗环境
部分可观察的环境
随机环境
即时

为了覆盖较大的状态操作空间，解决方案库中将需要大量规则。此外，没有探索策略可以找到最佳解决方案。因此，由于所有前面提到的与实时策略游戏相关的问题和复杂性，这些传统的 AI 方法很难实现。

为什么是强化学习？

强化学习相对于其他 AI 方法脱颖而出的原因如下：

避免使用基于规则的手动编码方法。
强化学习不需要存储游戏的特定规则。强化学习智能体学习多种交互，并增强其每次与环境交互时在环境中起作用的理解。
对于高维状态作用空间，可以将神经网络用作函数逼近器以得出最佳作用。
始终探索不同的策略以找到最佳策略。
强化学习已应用于需要状态行动计划的各个领域，例如机器人技术，自动驾驶汽车等。
此外，强化学习是一个非常活跃且庞大的研究领域，因此可以肯定，还有许多更好的算法尚待发展。

RTS 游戏中的强化学习

在这里，我们将讨论如何实现强化学习算法来解决实时策略游戏问题。让我们再次回顾强化学习的基本组成部分，它们如下：

状态S
动作A
奖励R
转移模型（如果基于策略，非策略学习不需要）

如果这些组件在接收来自给定游戏环境的信号时被学习智能体上的传感器感知和处理，则可以成功应用强化学习算法。传感器感知到的信号可以进行处理，以形成当前的环境状态，根据状态信息预测动作，并接收反馈，即在所采取动作的好坏之间进行奖励。这将更新状态-动作对值，即根据收到的反馈加强其学习。

此外，可以使用深度自编码器将较高维度的状态和操作空间编码为紧凑的较低维度。这将状态和动作空间的特征尺寸减小为重要特征。

深度自编码器

深度自编码器是一种由两个对称神经网络组成的深度神经网络，如下图所示，它能够将输入数据转换为尺寸也较小的更紧凑的表示形式。编码器网络首先将输入编码为紧凑的压缩表示形式，然后解码器网络将该表示形式解码回以输出原始输入。如下图所示，中间层连接了两个神经网络（编码器和解码器），其中包含输入数据的紧凑压缩表示形式：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YRp1TKqc-1681786518138)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/29ee99cf-f820-4ee5-961e-9f762dec4114.png)]

自编码器的架构

此处，X表示输入和输出层中的节点数，它等于输入数据的特征（维度）数，而N表示中间层中的节点数，它等于紧凑压缩表示形式所需的特征（尺寸）数。

例如，假设您输入的是游戏环境的28x28像素图像，即 784 像素。因此，示例编码器网络架构可以按以下顺序拥有节点（不必遵循该顺序）：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S8zP3ZgL-1681786518138)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/ceb7b4a7-7850-4895-9c83-b0776f17ab0f.png)]

在前面的示例编码器网络中，我们采用了维度 784 的输入，然后将其扩展为 1024 维度，然后通过网络的连续层分别减小为 512、256、128、64，最后是 32 维度。在这里，X为 784，N为 32。这里，我们的紧凑压缩表示形式仅相对于 784 维的输入数据由 32 维表示。

同样，我们的解码器网络架构与此相反，如下所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dZdeTqcm-1681786518139)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/2402276b-314f-4e45-bbd0-bfc839297449.png)]

训练深度的自编码器后，无需解码器网络。因此，我们的目标是训练网络，使解码器网络的输出与编码器网络的输入之间的损失最小。结果，中间层学会了创建更好的输入表示形式。因此，我们可以为输入特征向量检索特征向量的更好，紧凑和低维的表示形式。

强化学习如何更好？

以前，通过基于案例的在线计划，专家提供的人的踪迹是学习过程中最重要的组成部分。这些由专家提供，以创建解决方案列表。这样就创建了案例库并消耗了大量空间。而且，它还带有一个缺点，即它们没有捕获所有可能的痕迹，也就是说，特别是在连续的状态动作空间的情况下，状态和动作的组合。

但是，通过强化学习，不需要存储这些迹线，而且，高维和连续状态动作空间可以处理深度神经网络，该网络将其作为输入并输出最佳动作。此外，如果状态作用空间很大，并且需要减小尺寸以进一步减少计算时间，那么使用如前所示的深层自编码器会将输入数据转换为紧凑的低维向量。

强化学习中的奖励函数必须与每个状态相关联，以使从开始状态开始的动作通过一系列中间状态导致达到目标状态，从而使预期的奖励总和最大化，从而产生最佳路径。

基本的强化学习算法，例如 Q 学习和 SARSA 算法（在第 5 章，“Q 学习和深度 Q 网络”中进行了解释），与早期的在线案例学习相比，在收敛时间和比率方面表现更好。

此外，在深度强化学习领域中正在进行大量研究，该研究集中于使用图像进行智能体感知以在更复杂的领域中更好地工作。以前的自编码器方法有助于将非常复杂的域转换为更简单的域。此外，学习奖励函数和自编码器的其他变体，尤其是去噪堆叠式自编码器，将进一步改善结果。

此外，使用异步或分布式多主体强化学习方法（在第 6 章，“异步方法”中讨论），其中学习智能体与自己的环境副本并行工作，这将进一步减少收敛时间，并产生更好的结果。

总结

在本章中，我们讨论了真正的战略游戏以及 AI 社区的研究人员为何试图解决它们。我们还介绍了实际策略游戏的复杂性和属性以及不同的传统 AI 方法，例如基于案例的推理和基于在线案例的计划以解决它们及其缺点。我们讨论了强化学习成为该问题的最佳人选的原因，以及强化学习如何成功解决与早期传统 AI 方法失败有关的实时战略游戏相关的复杂性和问题。我们还了解了深层自编码器，以及如何使用它们来减少输入数据的维数并获得更好的输入表示。

在下一章中，我们将介绍使深度强化学习成为众人关注的最著名的话题，并使之成为 AI 算法的旗手，即 AlphaGo。

八、AlphaGo –最好的强化学习

游戏为许多人工智能（AI）算法提供了最佳的测试环境。这些模拟环境具有成本效益，并且可以安全方式测试算法。人工智能的主要目标是解决世界上最大的问题。人工智能的主要全球目标是：

消除贫困
消除饥饿
所有人的主要个性化医疗保健
素质教育
清洁能源
良好的基础设施
创新与创造力
减少不平等
保护地球
应对气候变化
和平与正义
好的工作
经济增长
解决水危机

研究技术和工业界正在努力实现更多的全球目标。现在，借助 AI 算法和更好的计算能力，随着时间的推移，向这些目标迈进的步伐越来越长。尽管这是一条很长的路要走，但随着最近的进步和发现，我们至少可以说我们走在正确的道路上，并且比十年前处于更好的位置。

如前所述，游戏是测试这些 AI 算法的最佳测试平台。除了具有成本效益之外，没有两个游戏是相同的，因此能够使用从一个游戏中学到的知识并将其应用于另一个游戏，这是一般智慧的标志。单个算法可以应用的游戏越多，它变得越通用。

我们第一次看到向人工智能（AGI）迈出了巨大的一步，当时 DeepMind 证明了他们的 AI 可以击败许多 Atari 游戏，使其成为现存最通用的 AI 系统。 DeepMind 在研究期刊 Nature 上发表了他们的论文《通过深度强化学习进行人类级别控制》，由 Silver 等展示了他们的 AI 智能体深度 Q 学习器，使用了深度强化学习算法，已成功应用于 50 种不同的 Atari 游戏，并在以下截图中显示了其中的 30 种，其表现均达到人类水平。通用人工智能的发展方向是 Google 购买 DeepMind 的原因：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hxVcbc3O-1681786518139)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/1ee7ccc9-af7f-42c3-85ed-94293d4cb9e2.jpg)]

比较 50 种不同的 Atari 游戏的表现：DQN 的表现根据专业人类玩家测试员规范化，《通过深度强化学习的人类水平控制》。

2016 年 3 月 9 日，我们见证了 Google DeepMind 的 AlphaGo 在古代中国游戏围棋中击败 18 届世界冠军 Lee Sedol 的历史。对于整个 AI 社区来说，这是一个伟大的里程碑。这是因为人们投入了毕生精力来掌握围棋游戏。由于其复杂性，围棋游戏具有很高的挑战性。根据 1997 年《纽约时报》的文章，科学家说，围棋是智力水平最高的游戏，要在围棋上击败人类至少要花一个世纪的时间。但是，由于有了 Google DeepMind，我们得以在不到二十年的时间内实现了这一壮举。以下是本章将涉及的主题：

什么是围棋？
AlphaGo-精通围棋
AlphaGo Zero

什么是围棋？

围棋游戏起源于中国大约 3000 年前。游戏规则很简单，如下所示：

围棋是一款两人游戏
默认棋盘尺寸为19x19行
一个玩家放置一块黑色的石头，而另一玩家放置一块白色的石头
目标是包围对手的石头，并覆盖棋盘上的大部分空白区域

以下是默认的板尺寸，为19x19行：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kOeND14A-1681786518139)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/8b34d4eb-9be7-4426-b5b0-be912a1bfc11.png)]

19x19围棋板

即使有这些简单的规则，围棋的游戏还是非常复杂的。在19x19围棋中，大约有2.08 x 10^170，而在宇宙中有10^80个原子，而在象棋中有10^120个可能的移动。因此，玩围棋游戏所需的智力深度已经吸引了人类多年的想象力。

围棋

1997 年，IBM 的 DeepBlue 在国际象棋比赛中击败了当时的世界冠军加里·卡斯帕罗夫。大约二十年后，Google DeepMind 的 AI 程序 AlphaGo 击败了 9 段围棋选手和前世界冠军 Lee Sedol。为了了解通过 AlphaGo 进行的 Google DeepMind 的巨大飞跃和成就，让我们首先了解这两个游戏之间的区别，然后再了解 DeepBlue 和 AlphaGo 的 AI 背后使用的架构。

国际象棋和围棋都需要两名球员。在国际象棋中，每个玩家都有十六种不同类型的十六种棋子，根据游戏规则它们具有不同的优势。目的是夺取对手的国王。另一方面，围棋从一个空白的棋盘开始，每个棋手依次一个人放置一块石头，并且所有石头都具有相同的强度，遵循相同的规则。此处的目标是在板上捕获尽可能多的区域。

因此，我们发现围棋的游戏规则比国际象棋简单，但我们没有看到的是复杂性，相对于国际象棋，围棋的复杂性很高。在每个游戏状态下，围棋玩家必须从 250 个可能的选择中选择一个棋步，而国际象棋则需要选择 35 个选择。围棋比赛持续约 150 步，而象棋比赛持续约 80 步。

正如我们之前研究的，在19x19围棋中大约有2.08 x 10^170个可能的移动，而宇宙中有10^80个原子和在国际象棋中有10^120个可能的移动。

DeepBlue 如何击败 Gary Kasparov？

在第 5 章， “Q 学习和深度 Q 网络”中，我们研究了游戏树和 minimax 算法。让我们回想一下那些了解 IBM DeepBlue AI 程序背后的架构的方法。

游戏树表示游戏的完整端到端表示，其中树中的每个节点表示特定的游戏状态（位置），链接节点的边表示在先前游戏状态下所采取的动作（动作），产生新游戏状态。根节点代表游戏的开始，下一级别的节点代表在游戏的开始状态下采取了所有不同的可能动作之后生成的可能状态，并且类似地生成了其他层中的节点。

对于井字游戏这样的简单游戏，由于复杂度较低，因此很容易创建游戏树。一旦游戏复杂性增加，就不可能创建游戏树。对于国际象棋，将需要10^120个不同的节点来创建游戏树。如此巨大的游戏树无法存储。

按照传统方法，了解游戏的游戏树对于创建玩 AI 的游戏非常重要，因为它有助于在任何给定状态下选择最佳动作。使用最小最大算法选择了最佳的移动方式，在每个回合中，它试图找出哪个移动方式可以最大程度地减少最坏的情况（这还包括输掉比赛）。

为此，它首先找出代表当前游戏状态的节点，然后以使遭受的损失最小化的方式采取行动。为此，需要遍历整个游戏树到叶子节点（最终游戏状态）以评估损失。因此，minimax 算法要求遍历游戏树以评估每一步的损失（最坏的情况），然后选择损失最小的那一步。

DeepBlue 搜索国际象棋的游戏树到最低深度（因为不可能创建整个国际象棋的游戏树）。然后，它使用评估函数来计算值，该值将替换下面的子树。此评估函数用于将下面的子树汇总为单个值。然后，它使用 minimax 算法引导最小的最坏情况，直到达到最大可能深度。

评估函数依赖于一些试探法。在 DeepBlue 中，评估函数分为 8000 个部分，专门针对某些特定位置进行设计。因此，为了更深入地了解游戏树，计算能力应该更高，甚至在此之后，还要根据监督下的不同游戏位置来设计游戏特定评估函数。因此，由于没有学习，它不能在其他领域（或游戏）上推广。

简而言之，为了解决国际象棋的复杂性，DeepBlue 对设计良好的评估函数的游戏树使用了蛮力方法。

为什么游戏树方法对围棋不利？

不能以游戏树方式接近。原因是所使用的更大的复杂性和蛮力方法无法进行任何学习。它执行的唯一任务是将游戏状态映射到游戏树中的节点。而且，DeepBlue 中使用的蛮力方法没有通用的评估函数，而是针对不同的游戏位置手工制作的。因此，先前的方法过于特定于游戏，因此此类方法无法扩大规模以玩围棋。

AlphaGo –精通围棋

在围棋的情况下，基于搜索树覆盖所有可能位置的传统 AI 方法会失败。原因是由于2.08 x 10^170 可能的移动以及因此而难以评估每个可能的棋盘位置的强度，因此搜索空间极其巨大。因此，传统的蛮力方法在围棋的巨大搜索空间中失败了。

因此，高级树搜索（例如具有深度神经网络的蒙特卡罗树搜索）被认为是捕捉人类用来玩围棋游戏的直觉的新颖方法。这些神经网络是卷积神经网络（CNN），并为棋盘拍摄图像，即棋盘的描述，并根据游戏的给定状态，通过一系列层激活它来找到最佳的动作。

AlphaGo 的架构中使用了两个神经网络，分别是：

策略网络：此神经网络决定要采取的下一步行动/行动
值网络：此神经网络从当前位置预测游戏的获胜者

AlphaGo 使用策略和值网络的方式是将搜索树的巨大复杂性降低到较小的可管理搜索空间。因此，它没有考虑每个步骤的数百个不同动作，而是考虑了策略网络建议的一些最佳可能动作。

此外，值网络减少了搜索的深度。在每个位置，值网络都试图预测哪个玩家将获胜，而不是遍历搜索树进行评估。因此，它能够返回一个值，该值量化可能的网络建议的移动量。

人类在游戏寿命方面存在弱点，也就是说，他们在长时间比赛中会感到疲倦，从而导致失误，而这并不是计算机的问题。而且，人类的时间有限。他们一生可以玩大约数千场围棋游戏，而 AlphaGo 一天可以玩一百万场游戏。因此，经过足够的处理，足够的训练，足够的搜索和足够的计算能力，AlphaGo 击败了世界上最好的专业围棋选手。

因此，应对给定的围棋极大复杂性也可以为在医学中使用这种方法铺平道路，通过深度强化学习来帮助患者接受个性化治疗，从而可以根据患者的病史和生物学史来产生最佳结果。

蒙特卡罗树搜索

在第 5 章， “Q 学习和深度 Q 网络”中，我们研究了蒙特卡洛树搜索。在这里，让我们再次对其进行修改，看看 AlphaGo 如何使用它来获得更好的结果。

蒙特卡洛树搜索是游戏树搜索的另一种方法。在这种方法中，我们对游戏进行了许多模拟，其中每个模拟都以当前游戏状态开始，以两个玩家之一作为获胜者结束。开始时，模拟是随机的，即为两个玩家随机选择动作。在每个模拟中，对于该模拟的每个游戏状态，都会存储相应的值。游戏状态（节点）的该值表示该节点的出现频率以及其中几次出现导致获胜的频率。这些值可为以后的模拟选择动作提供指导。运行的模拟次数越多，这些值在选择获胜举动时就会越优化。

蒙特卡洛树搜索（Monte Carlo Tree Search）更加侧重于一旦赢得胜利并趋向该方向的获胜行为，因此导致对已探索的现有行为的利用。为了探索新动作，在执行下一个动作时添加随机性很重要。这有助于增加对搜索中新动作的探索。

最大的优势之一是，蒙特卡洛树搜索不需要任何领域知识。它唯一需要做的就是对游戏进行大量模拟，并在遇到相应的情况时更新不同游戏状态的值。而且，它不需要整个游戏树就可以了解每个可能的游戏状态。存储象棋和围棋之类的游戏树是不可能的。相反，蒙特卡洛树搜索（Monte Carlo Tree Search）只是运行越来越多的模拟来优化节点（游戏状态）值，从而获得更好的结果。

AlphaGo 之前的围棋 AI 程序完全依赖于蒙特卡洛树搜索。这些是 Fuego，Pachi，Zen 和 Crazy Stone。其中，Pachi 是最强的，直到 AlphaGo 仅使用策略网络而不使用任何搜索方法将其击败。前面提到的围棋 AI 程序还依赖于一些领域知识，以便在蒙特卡洛模拟期间选择更好的结果并达到强大的业余水平。纯粹的蒙特卡洛树搜索（Monte Carlo Carlo Tree Search）不会通过经验模拟来学习，它只是优化位置（游戏状态/节点）。

AlphaGo 的架构和属性

所有方法都依赖于结合某些领域知识和人工干预的树搜索。 AlphaGo 使用树搜索和两种 CNN（策略和值网络）来指导树搜索。这些 CNN 类似于 DeepBlue 中使用的评估函数，但有一个区别，即 CNN 在手工制作 DeepBlue 中使用的评估函数时学习评估函数。

较早使用的树搜索是一种蛮力方法，而 CNN 是一种基于学习的方法，它提供了一种基于直觉的游戏方式。因此，第一个任务是减少搜索空间（围棋的搜索空间大约为10^170）。这可以通过两种方法来完成：

减少动作候选，即广度减少（避免在游戏树中探索它们时避免出现不必要的动作）
在时间之前减少评估函数，即深度减少（避免遍历整个游戏树来评估所采取的移动并根据当前游戏状态预测获胜状态）

策略网络并入当前游戏状态，并输出给定状态下每个可能动作的概率。具有较高概率的动作有较高的获胜机会。首先，使用专家玩家玩游戏的数据集，通过监督学习来训练策略网络。输入数据包含游戏板的图像，输出将采取的措施。来自 160000 个专家游戏的大约 3000 万个棋盘位置的训练数据集最初用于训练 AlphaGo 的策略网络。在专家数据集上进行训练后，通过自我扮演改进了预测可能学习到的动作的模型，在自我扮演的过程中，它与自身无数次比赛，以使用策略梯度从过去的错误中学习。因此，策略网络通过提供可能采取行动的可能性来帮助减少候选行动。

值网络提供当前状态的估计值，该值是黑人玩家在当前状态下赢得比赛的概率。策略和值网络的输入与当前游戏状态（具有当前石头位置的棋盘游戏的图像）相同。策略网络的输出是获胜的概率。因此，值网络的作用类似于评估函数，该函数是通过 3000 万个棋盘位置的监督学习集获得的。

因此，值网络输出直觉（赢和输的机会），而策略网络输出反思（训练游戏知识）。因此，AlphaGo 中直觉和反射的混合使其比任何基于搜索的方法都强大。但是在 AlphaGo 中，这些网络可根据所开发的直觉和学习的反射来帮助更快，优化树搜索。

下图是神经网络训练管道和架构：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sqnUvTNJ-1681786518139)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/f77be421-b1a7-498d-9548-eaf8ce014bb0.png)]

AlphaGo 的神经网络训练流水线和架构，摘录自 Google DeepMind 的 Silver 等人在 Nature 上发表的文章《AlphaGo》。

让我们讨论前面详细显示的 AlphaGo 的神经网络架构图：

a：快速部署策略ρ[π]和监督学习策略网络ρ[σ]在包含 3000 万个棋盘位置的数据集上接受专家训练，以像人类专家一样学习预测动作。通过学习的监督学习策略网络的权重初始化强化学习策略网络，并通过使用策略梯度来最大化策略质量，从而改进其策略ρ[ρ]策略网络的早期版本。通过使用此更新的策略网络进行自我播放，将生成一个新的数据集。数据集包含棋盘位置的图像及其相应的最终结果，即获胜或失败。最后，使用该自玩数据集通过回归训练值网络ν[θ]，以输出获胜的概率。
b：该流程的架构流程，其中策略网络将棋盘位置（游戏状态）的图像表示作为输入，并通过参数σ的卷积层传播（如果它是一个有监督的学习策略网络）或ρ（如果它是强化学习策略网络），并针对所有可能的动作a返回概率分布p[σ](a | s)或p[ρ](a | s)输出。值网络还使用参数θ的许多卷积层，返回标量值v[θ](s')，该标量值表示在给定位置s'中获胜或失败的结果（最终结果）的概率：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5AY73px1-1681786518139)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/8d06defa-4382-48e4-a4c2-2a831bdf246f.png)]

Silver 等人

让我们讨论前面详细显示的在 AlphaGo 中使用的蒙特卡罗树搜索（MCTS）：

a：在每次仿真过程中，遍历树时选择了该边，该边具有作用值Q和值u(P)之和的最大值。 u(P)是该边存储的先验概率P的函数。
b：扩展叶节点，即在策略网络p[σ]之后处理新节点，并将每个操作的输出概率存储为先验概率P。
c：在仿真结束时，以两种方式对叶节点进行评估：
- 使用值网络v[θ]
- 使用学习到的快速推广策略p[π]进行推广，直到游戏结束，并使用函数r计算获胜者
d：更新动作值Q，以跟踪该动作下方子树中所有评估值r(·)和v[θ](·)的平均值。

如前所述，对一个策略网络进行了 3000 万个游戏职位的训练。在不使用树搜索的情况下，AlphaGo 赢得了与 Pachi（最强的围棋 AI 程序）对战的 85% 的比赛，其中 Pachi 依靠基于蒙特卡洛搜索树的 100,000 次模拟。值网络接受了 3000 万个游戏位置的训练，并学习了预测获胜概率的模型。策略网络输出充当树搜索的指南。对于给定的游戏状态，策略网络为每个可能的移动提供了概率。这有助于减少树搜索期间的候选动作。

能耗分析– Lee Sedol 与 AlphaGo

下表是能耗分析（Lee Sedol 与 AlphaGo）：

Lee Sedol（9 段围棋棋手）	Google DeepMind 的 AlphaGo
每人每天的卡路里 ~ 2,500 kCal（平均 BMR）	假设：CPU ~ 100W，GPU ~ 300W，使用了 1,202 个 CPU 和 176 个 GPU
假设 Lee Sedol 在一场比赛中消耗了所有精力，因此为2,500 kCal * 4184 J/kCal ≈ 10 MJ	[1,202 * 100 176 * 300] W = [1,202 * 100 176 * 300] J/s = 173,000 J/s，考虑到它是至少四小时的游戏，因此，173,000 J/s * 3 * 3,600 s ≈ 2,500 MJ

AlphaGo Zero

第一代 AlphaGo 能够击败专业的围棋玩家。 2017 年 10 月，Google DeepMind 在 Nature 上发表了有关《AlphaGo Zero》的论文。 AlphaGo Zero 是 AlphaGo 的最新版本。早期版本的 AlphaGo 在接受过数以千计的从业余到专业游戏的人类游戏训练后，学会了玩游戏。但是 AlphaGo 的最终版本（即 AlphaGo Zero）从零开始学到了一切，这是从第一个基本原理开始的，既没有使用任何人工数据也没有任何人工干预，并且能够实现最高水平的表现。因此，AlphaGo Zero 通过与自己对战来学习玩围棋。最大的壮举之一是，AlphaGo Zero 在 19 小时内就能够学习更高级的围棋策略的基础知识，包括生与死，影响力和领土。在短短的三天内，AlphaGo Zero 击败了所有先前的 AlphaGo 版本，并在 40 天内超过了人类对围棋的一千年了解。

AlphaGo Zero 背后最重要的想法是，它完全从空白状态（即清晰的围棋棋盘）中学习，并通过自己的玩法自行弄清楚，而无需任何人类知识，没有任何人类游戏示例和数据，甚至没有任何人为干预。它从最初的基本原理中发现并发展了学习围棋游戏的直觉。这种从头开始的学习称为表格学习或白板学习。

Tabula rasa 学习对于任何 AI 智能体都是非常重要的，因为如果有一个智能体已实现 Tabula rasa 学习，则可以将其从围棋游戏移植到其他域环境（可能是其他任何游戏）。 Tabula rasa 学习将智能体与其所在领域的具体情况脱钩，并尝试开发一种算法，该算法足够通用，可以学习以实现与该环境相关的目标，并且可以在任何地方应用。

AlphaGo 项目背后的目标不是击败最佳的人类围棋选手，而是发现学习和做科学的意义以及对于计算机程序学习知识和直觉本质的意义。 AlphaGo Zero 不仅重新发现了人类倾向于玩的常见模式和空缺，还通过自行弄清它们来学习它们，并且还抛弃了许多已知的人类移动，而是优先选择了在数百万游戏中在数天之内发现的更好的移动。这些更好的举动甚至是人类所不知道的。

在短时间内，AlphaGo Zero 可以理解人类在数千年的游戏过程中积累的所有围棋知识。 AlphaGo Zero 本身发现了大部分知识，并发现了人类围棋玩家尚未发现的大多数举动。因此，除了比人类更快地适应知识之外，它还开发了新的知识，即知识创造，因此这种成就在许多方面被认为是新颖的。

因此，AlphaGo Zero 是第一个在围棋复杂而具有挑战性的领域中实现了非常高性能的计算机程序，已经开始了新的旅程，在该旅程中，我们可以开始解决一些具有挑战性的问题，这些问题要紧跟着一个顺序，而这些问题很少或更少。同样复杂的游戏，例如围棋，会对人类产生不利影响。

Google DeepMind 已经开始使用 AlphaGo Zero 来了解蛋白质折叠，因为错误折叠的蛋白质会导致许多疾病，例如阿尔茨海默氏病，帕金森氏病，II 型糖尿病和囊性纤维化。因此，使用基于 Tabras Rasa 的深度强化学习方法，可以了解蛋白质折叠，减少能量消耗，发现新元素或新材料以及更多其他内容。

AlphaGo Zero 的架构和属性

与先前版本的 AlphaGo 相比有五处变化。它们如下：

完全从自我游戏中训练，这不是人类专家的游戏数据，而是从头开始学习一切。较早的版本监督学习策略网络，该网络经过专家游戏训练。
没有手工制作的特征。
用残差卷积架构替换了普通卷积架构。
AlphaGo Zero 并没有将其单独的策略和值网络，而是将它们两者合并为一个大型网络。
简化了蒙特卡洛树搜索，该搜索使用此大型神经网络进行仿真。

网络输入包括：

19 x 19矩阵平面，代表棋盘
一个用于白色宝石的特征映射（在具有白色宝石的位置具有 1，在其他位置具有 0 的二进制矩阵）
一个用于黑宝石的特征映射（在具有黑宝石的位置具有 1，在其他位置具有 0 的二进制矩阵）
七个使用白色石头的玩家过去的特征映射（代表历史，因为它捕获了过去的七个动作）
七个使用黑石头的玩家过去特征映射（代表历史，因为它捕获了过去七个动作）
一个用于转弯指示的特征映射（转弯可以用 1 位表示，但此处已在整个特征映射上重复出现）

因此，网络输入由19 x 19 x (1 1 7 7 1) = 19 x 19 x 17张量表示。使用过去七个动作的特征映射的原因在于，这段历史就像一个注意力机制。

为什么我们使用残差架构而不是普通卷积架构？其背后的原因是残留的架构允许梯度信号直接穿过层。此外，即使在卷积层没有做任何有用的学习的早期阶段，重要的学习信号也会进入卷积层并直接进入其他层。详细解释残留架构超出了本书的范围。

因此，我们采用板的19 x 19 x 17张量表示形式的输入，并将其通过残差卷积网络，从而生成特征向量。该特征向量通过全连接层传递，以进行最终的特征提取，其中包含两件事：

值表示形式：AlphaGo 的可能性在当前棋盘位置赢得零的游戏。
策略向量：AlphaGo 可以在当前位置播放的所有可能动作的概率分布。

因此，目标将是获得较高的良好举动概率和较低的不良举动概率。在强化学习中，通过自玩这种较高复杂性的游戏来训练网络经常导致网络高度不稳定。在这里，简化的蒙特卡洛树搜索执行稳定网络权重的任务。

AlphaGo Zero 中的训练过程

接收板表示的输入，它是19 x 19 x 17张量。它经过残差卷积网络，然后全连接层最终输出策略向量和值表示。最初，策略向量将包含随机值，因为网络最初以随机权重开始。在获得给定状态下所有可能动作的策略向量后，假设具有高概率的动作也可能是强力动作，它会选择一组概率很高的可能动作：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LGZLOqUM-1681786518140)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/31213861-ace9-4d22-806f-cff174f04933.png)]

AlphaGo Zero 的自玩增强学习架构，摘录自 Google DeepMind 的 Silver 等人在 Nature 上发表的文章《AlphaGo Zero》

基于这些选定的移动集，接收不同的游戏状态，每个状态对应于它们的移动。由于您模拟了在先前状态下的移动，因此会产生许多不同的状态。现在，对于这些下一组状态，通过输入这些游戏状态的表示张量来重复前面的过程，并获得其策略向量。

因此，对于当前的棋盘位置，这种重复过程将爆发成一棵大树。运行更多的模拟，并且树将随着扩展呈指数扩展。因此，该想法是将该搜索树爆炸到一定深度，因为由于有限的计算能力，进一步的搜索将是不可能的。

AlphaGo 团队决定为每个单板位置评估进行大约 1600 次仿真。因此，对于每个单板状态，将运行蒙特卡洛树搜索，直到获得 1600 个模拟为止。之后，值网络决定哪个结果棋盘位置是最好的，即获胜的可能性最高。然后将所有这些值备份到树的顶部，直到当前的游戏状态（即正在评估的当前棋盘位置），并获得对真正有力的，但不是强势的动作的非常强的估计：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NZVnjn0B-1681786518140)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/925fa614-0a5c-4230-a5f8-b55fe744aab2.png)]

AlphaGo Zero 进行的蒙特卡罗树搜索，摘录自 Google DeepMind 的 Silver 等人在 Nature 上发表的文章《AlphaGo Zero》

总结

在本章中，我们研究了目前最好的强化学习架构，即 AlphaGo。我们了解了选择围棋的原因及其相对于象棋的复杂性。我们还了解了 DeepBlue AI 架构的工作原理，以及围棋需要一种不同的更好的架构和训练过程。我们研究了 AlphaGo 和 AlphaGo Zero 使用的架构和训练过程，还了解了版本之间的差异以及 AlphaGo Zero 如何超越其早期版本。

在下一章中，我们将研究如何在自动驾驶和自动驾驶汽车中使用和实现强化学习。

九、自动驾驶中的强化学习

在本章中，我们将介绍研究人员正在致力于使端到端自动驾驶成为可能的不同方法。我们已经看到许多公司，例如 Google，特斯拉，Uber，梅赛德斯·奔驰，奥迪，沃尔沃，博世，还有更多公司进入自动驾驶汽车领域。对于 AI 社区而言，端到端自动驾驶将是通往人工智能（AGI）的下一个里程碑。

纵观汽车行业的当前趋势，我们看到以下几点：

环境和气候友好型电动汽车正在增加
通过出租车聚合服务和拼车（即拼车）获利
利用 AI 和云技术进行无人驾驶汽车的颠覆性研究

乐高自动驾驶的主要功能如下：

传感器融合（传感器可以是相机，LIDAR，RADAR，GPS 等）
对象检测与分类
车辆路径规划-采取哪种操作，例如向左或向右转向，加速或制动，以及更多取决于：
- 操作的不同类型
- 操作的复杂性

自动驾驶中的机器学习

首先，为了开发端到端的无人驾驶汽车，在深入研究整个过程中使用强化学习之前，我们必须从高水平了解开发过程。下图描述了开发过程：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-osAM4N22-1681786518140)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/bad5916e-6b8d-4826-825e-0597efc5954d.png)]

如上图所示，该过程的第一步是传感器数据的收集。传感器包括摄像头，LIDAR，IMU，RADAR，GPS，CAN 和更多其他设备，这些设备可以以最佳方式捕获车辆状态以及周围环境。收到这些感官信号后，将对它们进行预处理，汇总，然后准备发送到下一个过程，包括机器学习（ML）和数据中心分析。在准备好的感觉信号上执行 ML 的这一步骤是关键部分，它涉及从输入数据进行状态估计，从而对其进行建模，预测可能的未来动作，最后根据预测的输出进行计划，即执行哪个动作从而使整体奖励最大化。

涉及自动驾驶时，ML 可以用于不同的任务。它们主要是以下内容：

传感器融合：聚类，模式识别和隔离
环境理解：图像处理，对象检测，对象分类和运动检测
轨迹规划：运动规划和控制
控制策略：强化和监督学习
驱动模型：图像处理和模式识别

此外，使用强化学习背后的最大原因是，由于以下几种不同的类型，它是处理多种车辆操纵的最佳人选：

换道时超车
交通拥堵
高速公路合并
高速公路分叉
车道缩小
在红色交通信号灯处停车
在停车标志处停在
放慢速度限制标志
在建筑或事故现场附近行驶时改变路线或安全驾驶
道路交叉口
合并为环岛的道路（环形路）

某些先前提到的车辆操作如下所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7HWvDed3-1681786518140)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/6c531670-6554-4814-b6c6-aca044ab1e58.jpg)] [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UBtMEXyz-1681786518140)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/e13af969-c3c6-4c6f-a209-f7e3679a6f78.jpeg)]

变道（左）和合并高速公路（右）时超车

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kh6a6yn3-1681786518141)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/95d9d843-d7ee-46c1-a8ac-27ef268e657b.jpeg)] [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6g7BYb5R-1681786518141)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/f4cf3a42-6ed0-42af-99ad-bbaa4d3bf5f1.jpeg)]

分叉的高速公路（左）和道路交叉点（右）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C7iDgOTT-1681786518141)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/7e094862-eca3-467b-9c36-a4b69824e4e0.jpeg)]

合并为环岛的道路（环形路）

自动驾驶中的强化学习

由于与环境的强大交互作用以及环境中的多个障碍和操作（如前所述），无法通过全面的有监督的学习方法来解决自动驾驶所带来的挑战。强化学习的奖励机制必须非常有效，这样智能体才能对内部个体的安全以及外部所有障碍（无论是人类，动物还是任何正在进行的构造）保持谨慎。

奖励的方法之一可能是：

智能体车辆与前方车辆相撞：高负面奖励
智能体车辆与前端和后端之间的距离都更安全：积极的回报
智能体车辆保持不安全的距离：中等的负面奖励
智能体车辆正在接近距离：负面奖励
智能体车辆加速：随着速度增加，正奖励减少，超过速度限制则负奖励

整合循环神经网络（RNN）来整合时间序列信息将使汽车能够处理部分可观察的场景。此外，使用注意力模型来关注相关信息还可以降低计算复杂度。如前所述，AI 的下一个，当然是最大的里程碑之一是创建端到端自动驾驶汽车。

创建自动驾驶智能体

驾驶车辆需要良好的技能，专注力和经验。因此，作为一项高技能的任务，创建自动驾驶智能体所涉及的过程可以大致分为三类，如下图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1ecf4AsF-1681786518141)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/a439e6b9-b14f-40fb-84e3-2d8ef4bf84ca.png)]

识别周围环境的组成部分，其中包括人行道，人，交通信号灯，任何建筑，道路边界，其他车辆等。对于 AI，由于使用卷积神经网络（CNN）和生成对抗网络（GAN）。 CNN 和 GAN 的成功可用于自动驾驶环境组件的识别过程。
预测环境的未来状态。识别当前环境状态的环境的当前组成部分很重要，但是将其用作输入并预测未来环境状态对于计划下一步行动也很有必要。解决此问题的基本方法之一是创建环境图。此外，我们可以合并深度神经网络，例如循环神经网络的变体，例如长短期记忆网络（LSTM）或门控循环单元（GRU），以整合和整合过去时间步长以及当前时间步长和预测未来中的数据。正如我们在第 1 章，“深度学习–架构和框架”中讨论的那样，由于长期依赖以及 LSTM 单元如何解决该问题，围绕梯度消失的问题仍然存在 RNN 的情况。 RNN 是集成时间序列数据的最新技术，它在 DeepTracking中显示了对象跟踪方面的改进。
规划是整个过程中最难的部分。该任务包括将识别和预测的结果集成在一起，以计划将来的动作序列以及下一个驾驶动作集（向左或向右转向，加速等等），以使导航安全且成功。这是一项艰巨的任务，因为整合和规划需要处理不可避免的情况才能安全到达目的地。强化学习最适合此类控制计划任务。我们已经了解了如何成功地部署强化学习来控制 50 场 Atari 游戏中的计划任务，以及 Google DeepMind 提供的最先进的 AlphaGo Zero。在这些情况下，我们目睹了深度学习在进行表示学习的同时进行强化学习的规划。

由于使用了多种类型的传感器，所有这些信息的集成对于自动驾驶至关重要。由于数据维数的差异，很难整合来自不同来源的感官输入。例如，摄像机输入为高维，而 LIDAR 输入为低维。提取相关信息并忽略不相关信息无疑会提高性能和准确率。它降低了计算和存储能力的利用率。因此，为了获取相关信息，注意模型适用于此目的，因为使用注意力机制的循环神经网络强化学习已成功应用于图像，从而仅关注相关部分。

为什么要强化学习？

我们已经讨论的一个重要原因是车辆操纵的可变性，无法以有监督的方式学习。在本节中，我们将详细介绍为什么强化学习是自动驾驶的最佳选择。

就 ML 而言，驾驶是一个多主体交互问题。考虑人类驾驶员在没有其他汽车在附近的车道上行驶。与交通繁忙时更改车道相比，这更容易。第二种情况之所以如此困难，是因为它还包括其他驾驶员的不确定行为和未知行为。因此，与您的车辆进行交互的车辆数量，车辆类型（大小）以及其相应驾驶员的行为都是巨大且高度可变的信息。由于这种高可变性，因此在此类数据上设计监督学习模型将无法涵盖所有不同类型的场景。在监督学习中，训练数据越多越好，但是可变性和数量很重要。因此，如果我们进行监督学习，则不可能涵盖所有情况。

当我们开车时，我们可以了解附近其他驾驶员的行为，这取决于他们的车辆在道路上行驶的方式。假设，如果车辆行驶非常快并经过其他车辆，那么您会认为其他车辆的驾驶员具有进取心和经验。因此，人脑执行此在线学习，从而了解环境及其组成部分。

需要这种类型的不断学习和计划，才能了解各种情况，从您无车行驶时到交通繁忙时的换道。因此，在这些情况下，人们可以通过经验学习，但是在某些情况下，人们也会感到困难？因此，潜在的挑战包括目前人类尚难解决的情况。这些情况包括在灾难性情况下驾驶，例如洪水，建筑坍塌或在没有 GPS 连接的情况下在新环境中导航等等。

因此，所有这些显式场景都不能被纳入学习模型，而需要诸如强化学习之类的方法来覆盖这些场景并通过从执行的不同动作中获得的奖励来增强其学习能力。

我们已经讨论了创建端到端自动驾驶车辆涉及的不同类别的任务。当前，将这些任务分离并分别处理，然后使用后处理层进行合并。一个基本且非常重要的缺点是这些孤立的任务可能无法正确组合。

因此，强化学习由于其行动奖励机制，可以根据所采取的驾驶行为和所获得的相应奖励进行建模，然后计划采取哪种行动。测试自动驾驶的奖励机制对于真实汽车来说是非常危险且昂贵的，因为奖励值应基于良好的驾驶和意外情况而保持稳定。因此，最好在 TORCS 或 Unity 等模拟环境中进行测试。

提出的自动驾驶框架

在本节中，我们将讨论 El Sallab 等人（2017）给出的提出的用于自动驾驶的深度强化学习框架。

以下是端到端深度神经网络的架构：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IftpUxKE-1681786518141)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/c0d1b6ca-7308-4b36-b494-851bef3b4473.png)]

El Sallab 等人（2017）的《对自动驾驶深度神经网络进行端到端训练》。

让我们详细讨论前面的架构。在这种情况下，输入是多个时间步长上环境状态的汇总。

空间聚合

该架构的第一个单元是空间聚合网络。它由两个网络组成，每个网络都用于以下子过程：

传感器融合
空间特征

总体状态包括车辆的状态以及周围环境的状态。车辆的状态包括位置，几何方向，速度，加速度，当前剩余燃料，当前转向方向等等。环境状态包括其组成部分，即对象，生物，障碍及其特征，即它们的位置，几何定向（无论是否运动）以及更多。周围物体的状态通过摄像机，激光雷达等来感知。因此，对于识别，预测和计划任务，需要将多个感官输入组合在一起。

传感器融合

此步骤包括融合来自不同传感器和过程的输入，并准备将其输入到深度神经网络。每个传感器信息以原始向量的形式捕获环境状态。完成所有这些原始向量的分组，并将其馈入深度神经网络。每个感官输入将形成一个单独的特征向量。因此，作为学习的结果，即成本最小化，发生了与那些传感器特征中的每一个相关联的权重的优化。这些学习的权重量化了相应传感器特征的相关性。就深度神经网络而言，CNN 是完成任务的最佳选择。

空间特征

卷积神经网络用于查找隐藏的表示，然后应用注意力机制。注意力机制指导网络的卷积层专注于数据的相关部分。使用注意力模型的优势在于，它减少了数据集的维数。结果，还减少了对原始数据的大量计算，包括卷积等。

运用注意力模型的最佳方法是使用动作和瞥见网络（说明超出了本书的范围，但有关动作和瞥见网络的更多详细信息，请转到此研究出版物《视频中的帧错误的动作检测的端到端学习》，并避免使用注意过滤器，因为注意过滤器不会降低计算的维数，并将卷积应用于整个数据。但是对于包含神经网络的动作和瞥见网络却不是这种情况，该网络学习学习数据的相关部分，从而引导卷积层专注于数据的这些相关部分。

周期性时间聚合

周期性时间聚合涉及跨不同时间步长聚集环境状态。让我们详细讨论其背后的原因。首先，获取环境状态并非易事，传感器读数可提供环境的最佳状态表示。因此，当前时间步的状态信息不足以获取环境的完整信息。因此，在多个时间步长上整合状态信息可捕获运动行为，这在环境状态在几秒钟内发生变化的自动驾驶中非常重要。

因此，通过增加重复性，可以处理 POMDP（部分可观察的马尔可夫决策过程）场景，这在驾驶中非常常见，因为无法完全观察到整个环境状态。传统的算法（如贝叶斯过滤器）用于处理这种情况，方法是随着时间的推移集成信息，但它们是从 MDP 框架（环境状态完全可见）中派生的。

因此，通过创建时间序列格式，我们可以使用 RNN 来使用过去状态信息和当前状态数据对长期依赖关系进行建模。众所周知，LSTM 具有足够的能力来处理长期依赖性，而不会遇到梯度消失的任何问题。这是因为 LSTM 具有单元状态和隐藏状态，在该状态下，对于每个新的时间步，LSTM 都会根据来自先前的隐藏状态和当前时间步的新传入数据的相关信息来更新其新的隐藏状态。此外，单元状态跨不同的时间步长存储相关数据，并且在单元状态中从存储的信息中忘记无关数据。因此，LSTM 完全控制要在其单元格和隐藏状态中包含哪些信息。

规划

先前的网络构成深度 Q 网络（DQN）的一部分，该网络将状态信息作为输入并将体验存储在体验缓冲区中。来自该经验缓冲区的样本数据用于训练 DQN 中使用的深度神经网络，该神经网络进而预测状态动作值。状态操作值有助于得出最佳策略，即为给定状态规划最佳操作。

基于 DQN 的方法适用于连续状态空间，但它要求动作空间是离散的。因此，在连续动作空间的情况下，首选参与者批评算法。回顾第 4 章，“策略梯度”的参与者评论算法，以下是参与者评论算法的示意图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ga1GKFdH-1681786518142)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/14723421-f8a4-45db-b3be-1e311e207484.png)]

演员评论算法包括：

充当评论者的网络更新状态动作的函数逼近器的权重参数向量
另一个充当参与者的网络按照评论者给出的方向更新策略参数向量

DeepTraffic –用于自动驾驶的 MIT 模拟器

DeepTraffic 是为课程《MIT 6.S094：用于自动驾驶汽车的深度学习》创建的，由 Lex Fridman 教授。课程内容和作业是公开的。 DeepTraffic 由于其排行榜而获得了很多欢迎。迄今为止，DeepTraffic 拥有 13,000 多个提交文件，竞争非常激烈。用户必须在convnet.js（由 Andrej Karpathy 创建的框架）中使用本节开头提到的链接中存在的编码依据来编写其神经网络。平均速度最高的座席在排行榜上居首。

诸如 DeepTraffic 之类的模拟可帮助训练不同的方法，以使汽车智能体迅速适应模拟环境。此外，它的竞争性元素随着时间的推移增加了更好的提交，超过了过去的最高得分。比赛很有趣，但在现实世界中，学生无法测试他们的深度强化学习脚本。因此，DeepTraffic 为下一代 AI 开发人员提供了使用不同方法的最佳测试平台，这肯定会导致未来的 AI 开发人员在现实世界中创造出自动驾驶汽车，而这要得益于这些模拟的学习。

众所周知，在现实世界中，自动驾驶汽车应该规划最安全的道路。因此，将需要大量修剪和更好的神经网络架构来实现该目标。 DeepTraffic 是朝着这个方向迈出的第一步，因此 AI 社区中感兴趣的人们可以玩耍并创建更好的学习架构和方法：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EPJPmHZe-1681786518142)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/9a9a574c-58d9-4843-ae56-952f31d006c3.png)]

DeepTraffic 环境的四个视角：模拟，占用网格，防撞系统以及代表增强学习状态的占用网格的一部分，策略网络可基于此学习估计期望的奖励，通过采取五种可用操作中的每一项。（DeepTraffic：Fridman 等人在这个页面上进行的具有深度强化学习的密集交通快速驾驶）。

DeepTraffic 由一条高速公路带组成，该高速公路带显示了同时行驶的七个车道和二十辆汽车（请参见上图的第一列），其时速限制为 80 mph（不允许任何车子超过该限制）。 DeepTraffic 是现实公路场景的简化模拟表示。此模拟的重点只是学习交通繁忙时的有效运动方式。所有汽车均可从以下五种动作中进行选择：

车道向左转
车道向右转
加速
减速
没做什么

对于其他汽车，将按照现实的模式随机选择动作，例如，由于随机选择动作，不会太频繁地改变车道。以红色（深灰色）显示的汽车由深度强化学习智能体控制。竞争对手获得以 DQN 实现的预定义神经网络。任务是配置不同的超参数并获得最佳表现，即最高平均速度。

总结

在本章中，我们谈到了与最大的 AI 问题之一即自动驾驶相关的主要概念和挑战。我们了解了问题所带来的挑战，还了解了用于使自动驾驶成功的当前方法。此外，我们从接收感官输入到计划开始，对过程的各个子任务进行了概述。我们还介绍了著名的 DeepTraffic 仿真，您可以在其中测试神经网络，以了解繁忙交通中的有效运动方式。自动驾驶本身就是一个不断发展的广泛研究主题，而涵盖所有这些内容超出了本书的范围。

在下一章中，我们将研究另一个发展中的研究热点，即在金融中使用人工智能，我们将学习强化如何帮助金融投资组合管理。

十、金融投资组合管理

金融投资组合是将资金分配到不同金融产品中的过程。在项目组合管理中实现深度学习一直是人工智能界的一个研究部门。随着强化学习的进步，在创建免费的无财务模型的强化学习框架以产生端到端的财务组合管理智能体方面，人们进行了积极的研究。

投资组合管理是一个连续的决策过程，将资金重新分配到众多不同的金融产品中，以期获得最大的回报。

传统的最新在线投资组合管理方法包括：

方法	重要算法
基准测试	买入并持有
	最佳股票
	恒定的平衡投资组合
关注获胜者	通用投资组合
	指数梯度
	跟随领导者
	跟随正则领导者
	聚合类型算法
跟随失败者	反相关
	被动正向平均回归
	置信加权平均回归
	在线移动平均回归
	稳健中值回归
模式匹配	非参数直方图对数最优策略
	基于非参数核的对数最优策略
	非参数最近邻对数最优策略
	相关驱动的非参数学习策略
	基于非参数核的半对数最优策略
	基于非参数核的 Markowitz 类型策略
	基于非参数核的 GV 类型策略
元学习	聚合算法
	快速通用算法
	在线梯度更新
	在线牛顿更新
	遵循领先的历史

跟随获胜者和跟随失败者是基于先前构建的财务模型，该模型可能会或可能不会在上表中提及的相应算法中使用机器学习技术。这些方法在不同金融市场中的有效性可以判断其效果。

模式匹配模型将历史数据样本作为输入，根据样本分布优化投资组合，并预测下一个时期的市场分布。元学习聚合了不同类别的多种策略，以实现稳定的表现。

当前，存在用于金融市场交易的深度学习方法，这些方法可以预测价格走势和趋势，但不能在不同的金融产品之间执行自动的资金分配和重新分配。由于我们拥有所有资产的历史价格，因此我们可以将包含它们的输入数据准备到循环神经网络中，该网络将预测下一时期的资产价格作为输出。这是机器学习中的监督回归问题。

这些模型的表现完全取决于未来资产价格的预测准确率，而不仅是在下一个时期。但是，未来的市场价格极难预测，因为它们不仅取决于历史价格，而且只能反映波动和流动，不包括也会驱动金融市场的情感因素。

需要注意的另一个重要点是，预测市场价格并不意味着预测市场行为。因此，需要领域知识和逻辑将预测价格转换为行动。结合深度强化学习，可根据最大化回报的目标使此逻辑转换自动化。

已经提出了许多成功的针对金融模型免费和完全基于机器学习的方法的尝试，用于算法交易。其中使用强化学习的主要问题是它们无法预测未来价格，并且仅适用于单一资产交易。因此，它们不能应用于投资组合管理，其中包括同时管理多个资产。

而且，投资组合管理是一个连续的动作空间问题，而不是一个离散的动作空间。大多数已建立的最先进的深度强化学习算法都可以很好地与离散的动作空间配合使用。但是，尽管我们已经为投资组合管理问题开发了连续操作空间离散化的过程，但是如果我们采用离散化过程，那么我们将失去许多可能的重要市场行为。这导致更大的信息丢失和不可用的风险。

投资组合管理，甚至任何设计的交易算法所需的算法，都应可在不同市场上扩展。传统算法曾经失败，因为无法在不同的市场上扩展，因为市场受资产类型和资产总数等因素支配，这些因素因市场而异。这是因为资产的模式和行为因市场而异，并且传统算法没有得到概括。此处的机器学习具有跨不同垂直方向（即不同金融市场）进行泛化的优势。

此外，如前所述，强化学习在金融投资组合管理中的应用在人工智能界的研究人员中很重要。在本章中，我们将讨论一个关于《针对金融投资组合管理问题的深度强化学习框架》的最新论文，该论文由西交利物浦大学的研究者发布。我们将介绍他们采取的方法及其相对于当前在线投资组合管理方法的表现，如下所示：

介绍
问题定义
数据准备
强化学习
进一步的改进

介绍

所提出的强化学习框架的核心是相同独立评估器（EIIE）拓扑。在这里，EIIE 是一个神经网络，它将资产历史记录作为输入并评估未来资产的潜在增长。每个资产的评估得分用于计算下一个交易期的投资组合权重。

投资组合权重（我们将在后面讨论）实际上是由强化学习驱动的投资组合管理智能体的市场行为。将购买目标权重增加的资产，而目标权重减小的资产将被出售。因此，最后交易期间的投资组合权重也作为 EIIE 的输入。因此，每个期间的投资组合权重存储在投资组合向量存储器（PVM）中。

EIIE 通过在线随机批量学习（OSBL）进行训练，其中强化学习框架的奖励函数是该时期的平均对数回报。由于奖励函数是动态的，因此，随着训练是通过梯度上升进行的，EIIE 也在不断发展。如前所述，EIIE 由一个神经网络组成，因此，对于当前框架，使用不同类型的神经网络测试了三种不同类型的 EIIE，即卷积神经网络（CNN），循环神经网络（RNN）和长短期记忆网络（LSTM），这是 RNN 单元。这种类型的框架可以轻松扩展到不同的市场，而不仅限于一个。

该提议框架的测试平台是一个名为 Poloniex 的加密货币交易市场。实验之前，通过在一定时间间隔内的交易量排名来选择硬币。实验在 30 分钟的交易时间内进行，并将 EIIE 的表现与前面提到的在线投资组合选择方法进行了比较。 EIIE 能够击败所有这些方法。

由于该框架不是在现实世界的金融市场中而是在加密货币市场中进行测试的，因此我们必须知道加密货币与传统金融资产之间的差异，以及为什么加密货币市场事先是算法投资组合管理实验的更好测试平台。它们如下：

加密货币的去中心化（不是控制协议的中央机构）
加密货币市场的开放性（更易进入的市场）
加密货币中的小批量货币丰富
加密货币市场一直都是开放的，因此，对于学习智能体来说，随着时间的流逝学习非常有用，这与受时间限制的现实世界不同。

问题定义

众所周知，投资组合管理是指跨多种金融产品（资产）对资金进行持续重新分配。在这项工作中，时间分为相等长度的时间段，其中每个时间段T = 30分钟。在每个时期的开始，交易智能体将资金重新分配到不同的资产上。资产的价格在一段时间内会波动，但要考虑四个重要的价格指标，它们足以表示该期间资产的价格变动。这些价格指标如下：

开盘价
最高价
最低价
收盘价

对于连续市场（例如我们的测试用例），资产在t期间的开盘价是其在前一时期t-1的收盘价。投资组合由m个资产组成。在时间段t中，所有m资产的收盘价都创建了价格向量v[t]。因此，v[t]的第i个元素即v[i, t]是该t时间段内第i个资产的收盘价。

同样，我们有向量v[t]^(hi)和v[t]^(lo)，其中：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-caHQ3Wzx-1681786518142)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/e15e5efc-ac35-4f33-ae54-852cbd21ec5f.png)]：包含时间段t中所有m资产的最高价格的向量
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tXuoRFjz-1681786518142)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/dad09205-78cb-49e8-bb91-ce4661d53f24.png)]：包含时间段t中所有m资产的最低价格的向量

投资组合中的第一个资产是特殊资产，从现在开始将被称为现金。之所以认为与众不同，是因为所有资产的价格均以现金面额报价。由于第一个资产定义了基础货币，因此v[t]，v[t]^(hi)和v[t]^(lo)的第一个元素将始终为 1，即：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iXyvzNDd-1681786518142)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/76ab6d97-24a6-497b-ad74-52ab45c8180b.png)]

在这里，比特币被认为是现金。因此，所有资产定价都将按照比特币进行。正如我们已经讨论过的，这是一个连续的市场，t 1期的开盘价将等于t期的收盘价。周期t的价格相对向量表示为y[t]，它是v[t]和v[t - 1]的按元素划分，如下所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-15fGT1TR-1681786518143)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/6f77290e-0f5f-4d51-a141-b0c16e69ce76.png)]

这是时间段t中资产的收盘价和时间段t-1中资产收盘价的按元素划分，换句话说，时间段t中资产的收盘价和开盘价的百分比。因此，y[t]的元素是时间段t中单个资产的收盘价和开盘价之比。 价格相对向量用于计算一个时期内投资组合总价值的变化。

令时间段t开头的投资组合值为p[t]。因此，忽略交易成本：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6JI4BAYh-1681786518143)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/d9dbe264-2382-4e91-98f6-280ea978c83e.png)]

在这里，w[t-1]是投资组合权重向量，也称为投资组合向量在时间段t的开始时，其第i元素是：w[i, t-1]是资产i在当前投资组合中的比例。因为w[t]是权重（比例）的向量，所以从定义上讲w[t]的元素总和将总和为 1，即Σ[i] w[t, i] = 1, ∀t。

时间段t的回报率由下式给出：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UASY3qr2-1681786518143)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/735240b8-2d1b-42a8-b94d-5b9214f6b3f6.png)]

对数回报率由下式给出：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-s7bvIWto-1681786518143)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/782cc33c-1733-4019-8983-4aa994c0cdee.png)]

初始投资组合权重向量w[0]表示进入市场之前，该金额是以交易货币（称为现金，此处现金为比特币）表示，因为初始投资金额以交易货币计算。由于金额是以交易货币为单位的，因此投资组合向量的第一个资产是指交易货币资产，因此：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hCnq1ZVo-1681786518143)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/c206bb58-ca68-4265-b11b-46ed01e17d1b.png)]

因此，如果没有交易成本，则最终投资组合价值将由下式给出：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LVRR1DVp-1681786518143)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/7cdf6685-9162-4e04-9fe7-43eb26e2b6c4.png)]

在此，p[0]是初始投资金额。因此，投资组合经理的目标是在给定的时间范围内最大化p[f]。实验中有两个假设：

零滞后：每笔定单在下单时均以最后价格执行，没有滞后，立即进行交易
零市场影响：交易智能体在市场上的投资金额微不足道，不会影响市场

数据准备

交易实验在名为 Poloniex 的加密货币交易所中进行了测试。为了测试当前方法，预先选择了m = 11具有最高交易量的非现金资产作为投资组合。由于第一基础资产是现金，即比特币，因此投资组合的大小为m 1 = 12。如果我们在交易量较大的市场（例如外汇市场）中进行了测试，则m将与市场中资产的总数一样大。

资产的历史数据被馈送到神经网络，该神经网络输出投资组合权重向量。在周期t结束时输入到神经网络的是张量X[t]，其阶数为 3（f，n，m），其中：

m是预选的非现金资产的数量
n是t之前的输入周期数（此处n = 50）
f = 3是特征数量

由于n = 50，即输入周期数为 50，每个周期为 30 分钟，因此总时间= 30 * 50 min = 1500 min = 25 h。时间段t上资产i的特征是其在时间段t中的收盘价，最高价和最低价。价格矩阵不直接输入到神经网络。价格变化决定了投资组合管理的表现。输入张量中的所有价格将由最新收盘价标准化，如下所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Wx3RM9nG-1681786518144)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/b2285ad8-4c43-4620-8916-314b84516b08.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7rZkMF5u-1681786518144)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/a1b135a0-2d42-4831-acbe-dab6f8640d17.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bwqxIB7K-1681786518144)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/8f3ee58f-7114-4611-97f6-e89b5e3b0fab.png)]

这里：

V[t]，V[t]^(hi)和V[t]^(lo)是归一化价格矩阵
1 = [1, 1, ..., 1]^T和Φ是逐元素除法运算符

因此，X[t]是三个归一化价格矩阵的栈：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QCPWP0Bk-1681786518144)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/d4c0367b-bfe2-4e38-8ee5-421da65351e6.png)]

投资组合管理智能体使用输入张量X[t]和上一个时间段的（即t-1），投资组合权重向量w[t-1]输出时间段t的投资组合权重向量w[t]。根据策略π。

因此：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CnpuHc0n-1681786518144)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/c7fed0cf-8769-4047-aae7-e5b165ef1cf7.png)]

并且由于（如前面的“问题定义”部分中所示）：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4He03hQf-1681786518145)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/5823adac-98b7-4222-b1ff-5a652a4def2a.png)]

因此，通过对前面的陈述进行强化学习的框架化，我们可以说先前的权重向量w[t-1]是在时间段t-1的动作，收到了立即奖励r[t]。

强化学习

在算法投资组合管理的实验中，投资组合管理智能体在强化学习的支持下在金融市场环境中执行交易操作。环境包括给定市场的所有可用资产。由于环境庞大而复杂，因此智能体程序无法完全观察状态，即获取状态的所有信息。而且，由于市场的全部订购历史太大而无法处理，因此从订购历史数据中进行子采样可以简化环境状态表示的处理。这些子采样方法包括：

周期性特征提取：将时间离散化为多个时段，然后提取每个时段的开盘价，最高价，最低价和收盘价
数据切片：仅考虑最近时间段的数据，并避免使用较旧的历史数据，以便进行环境的当前状态表示

智能体根据时段输出的投资组合权重向量w[t]，在时段t结束时，即在时段t 1的开始进行了一些买卖交易。神经网络。因此，主体在时间t的动作仅由投资组合权重向量w[t]表示。因此，在当前框架中，w[t-1]被视为环境的一部分，并作为输入输入到智能体中，以输出下一个时间段即w[t]的智能体的操作策略。因此，在时期t，即s[t]的状态由价格张量X[t]和前一时期w[t-1]的投资组合权重向量表示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8Uqpja8B-1681786518145)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/64a779b3-9055-47fd-831e-92c8c108a54d.png)]

和，

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7ZwR5iJi-1681786518145)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/d5f51e96-dd52-43ae-b0f9-9e032433e0d0.png)]

如前所述，投资组合管理智能体的目标是使最终投资组合价值最大化，即p[f]，其中：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZD8bsMDu-1681786518145)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/bba610ef-98f6-4e3c-9da9-080f917f3770.png)]

因此，在t[f]时间段内的总收益为p[f] / p[0]。因此，总回报对数的平均值为：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-59UQtAJM-1681786518145)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/c0709ff1-5108-418c-9a34-9e6a023f4e4c.png)]

因此，最大化最终投资组合价值可以转换为最大化总收益的对数平均值，其公式为：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZGwbpC0E-1681786518146)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/rl-tf/img/30dd553d-c641-400c-ad76-588c5edf5a11.png)]

创建了三个具有深度神经网络的三个不同变体的策略网络，分别是 CNN，RNN 和 LSTM。前一个时间段的输出是当前时间段内网络的输入。因此，使用策略梯度和深层 Q 网络中的经验回放的想法，创建了一个 PVM，用于存储网络输出，也就是说，它将包含每个时间步骤的投资组合权重向量。

PVM 是按时间步长顺序（即时间顺序）收集投资组合向量的集合。在训练周期的每个时间步t，策略网络从t-1的存储位置取最后时间段的投资组合权重向量w[t-1]，并进行覆盖t处的内存与输出投资组合权重向量w[t]的关系。由于策略网络参数的收敛，PVM 中的值随着训练时期的增加而收敛。

单个内存栈（例如 PVM）还有助于使用小批量提高训练过程的并行性，从而提高训练过程的效率。

对于有监督的学习，数据的排序以小批量为单位，但是在这里，数据需要按照训练过程中每批传递的时间步长进行排序。现在，由于数据是按时间序列格式的，因此从不同时间段开始的小批量是更可取的，因为它们涵盖了训练过程的独特数据。金融市场的持续性导致不断向智能体网络输入新数据，从而导致训练数据中的数据爆炸。

因此，提出了 OSBL，其中在时段t结束时，时段的价格变动将添加到训练集中。在完成时间段t 1的订单后，使用从该组中随机选择的小批量对策略网络进行训练。有关 OSBL 的完整详细研究超出了本书的范围，但是为了进一步探索，请阅读《金融组合管理问题的深层强化学习框架》中的 5.3 节。

使用所有三个不同的策略网络（即 CNN，RNN 和 LSTM）在加密货币交易所 Poloniex 上对该框架进行了测试。用于检查框架表现的投资组合的财务指标为：

投资组合价值：最终投资组合的价值
最大跌幅：在达到新峰值之前，从一个峰值（最高点）到波谷（最低点）的最大损失
夏普比率：风险收益率（可变性）比率

在前面提到的指标的基础上，将提出的框架的表现与现有的在线投资组合管理方法进行了比较，它能够成功击败现有的在线投资组合管理方法。因此，提出的强化学习框架能够解决一般的金融投资组合管理问题。

拟议框架的主要特点是：

多渠道，多市场输入
策略网络直接提供投资组合权重向量形式的市场行为
在此，仅使用了深度神经网络的三个变体，但也可以应用其他变体
随着投资组合规模的增加可线性扩展
PVM 在使用小批量的训练中增加了并行性功能
OSBL 帮助在线使用实时输入数据

进一步的改进

可以对以前的框架进行进一步的改进，也可以使用深度强化学习来创建端到端金融投资组合管理智能体的更好方法。它们如下：

当前框架假设为零滑点和零市场影响。因此，考虑市场影响和滑点将提供真实的交易样本，这将改善训练数据集。
使用行为者-批评类型的框架将有助于长期的市场反应。
在基本 RNN 上优于 LSTM 和 GRU 可以解决梯度消失的问题。

总结

在本章中，我们研究了最近发布的在金融组合管理中使用深度强化学习的方法之一。我们查看了金融投资组合管理中的问题陈述，投资组合经理的目标，并将问题陈述映射到强化学习任务。我们还了解了用于基准化表现的不同财务指标以及不同的现有在线投资组合管理方法。使用深度强化学习使财务组合自动化的研究主题是 AI 社区中要解决的最具挑战性的任务之一。因此，除了本章介绍的方法外，还要尝试研究算法交易中的其他传统机器学习方法。

在下一章中，我们将研究强化学习在机器人技术中的使用，当前的挑战及其提出的解决方案。

tensorflow 游戏强化学习算法网络

1 人点赞