Online Anomalous Subtrajectory Detection onRoad Networks with Deep Reinforcement Learning （二）

总体流程

是的，您描述的流程基本上是正确的。为了帮助您更清晰地理解，我可以将整个流程的步骤梳理如下：

1. RSRNet 编码

  • 在RSRNet中，首先输入的是原始的文本数据（如 texts）以及相应的标签（labels）和信号（signal）。
  • 通过词嵌入（embed_inputs）和LSTM网络（outputs）进行处理，得到对输入文本的编码。这个编码可能包含了文本信息以及信号信息。
  • 最终，LSTM的输出会与额外的信号向量（signal_vec）拼接，经过全连接层（self.logits），得到两个类别的预测值。
  • RSRNet的目标是通过计算交叉熵损失（loss）来优化模型参数，这部分损失是通过输入的标签（labels）和模型输出的logits进行计算的。

2. ASDNet 中的决策探索（explore函数）

  • 在ASDNet中，explore函数负责根据当前的状态（可能是编码后的文本表示以及其他信息）进行决策，即选择动作（行动）。
  • explore函数的输出是一个决策动作（通常是一个标签），这些决策是基于强化学习策略的探索过程。在这个过程中，可能会记录每个动作的过程和与之对应的奖励值。
  • 这些动作和奖励值为后续的损失计算和训练提供了依据。

3. 根据奖励计算损失（loss）

  • 在ASDNet中，learn函数结合了通过explore得到的动作（预测标签）和奖励（例如，模型根据正确与否获得的奖励）。
  • model.learn(model.sess_asd, reward, FLAGS.keep_prob) 中，奖励（reward）和编码后的输入值（来自RSRNet）一起用于计算损失。模型在训练过程中根据这些奖励来更新参数。
  • 损失函数可能与标准的分类损失（如交叉熵损失）结合，用来优化模型，使其不仅能够正确分类，还能够根据奖励反馈来调整策略。

总体流程总结：

  1. RSRNet 对输入文本进行编码，生成表示，并计算交叉熵损失。
  2. ASDNet 中的 explore 函数通过强化学习策略探索决策，输出预测标签并记录动作过程和奖励。
  3. learn 函数结合 RSRNet 的编码结果和 ASDNet 的奖励信号计算总损失，并用于模型的优化。

这个流程是基于强化学习框架，其中通过探索与奖励来驱动模型的训练，使得模型能够在不断的反馈中提高其决策能力。

该代码采用计算图的方式进行计算

编码 RSRNet

determine 做奖励的计算

reward = explore(model, observations, labels, text, SRN, batched_data)

策略优化 ASDNet 中 explore做的动作就是在做预测，并会记录这里的值用作后面的计算

是的，你理解得对。ep_as 存储的 动作 实际上就是模型在每个时间步预测的 标签，或者说是模型选择的 动作编号。在强化学习的背景下，"动作" 就是模型在某个状态下所采取的行为，而在你的代码中，这个“动作”对应的是 标签预测。

更详细的解释：

  • ep_as 存储了模型在每个时间步选择的动作编号，即模型的 预测标签。这个值是通过策略网络（policy network）根据当前的观测和标签信息选择的动作。
  • 例如，如果 ep_as 中的某个值为 0，这表示模型预测标签为 0（类别 0）；如果为 1，表示模型预测标签为 1（类别 1）。

关系：

  • 在训练过程中，模型根据输入的观测（ep_obs）和标签（ep_obs_label）选择一个动作（即预测的标签），然后根据 奖励（reward） 来调整模型的策略。
  • 通过与真实标签（ep_obs_label）进行对比，模型优化其策略来提高预测的准确性。

示例：

假设我们有一个二分类任务，ep_as 中的值代表了模型的预测标签：

ep_as: [0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1]

这些值表示模型在每个时间步预测的标签（动作）。例如，模型在第 4 个时间步预测的标签是 1，在第 5 个时间步预测的标签也是 1。

ep_obs_label：

它是实际的标签（真实标签），通过 one-hot 编码 表示：

ep_obs_label: [[1, 0], [1, 0], [1, 0], [0, 1], [0, 1], [1, 0], [0, 1], [1, 0], [1, 0], [0, 1], [0, 1], [0, 1], [1, 0], [1, 0], [0, 1]]

每一行是一个时间步的真实标签。如果真实标签是 1 类，那么它是 [0, 1]，如果是 0 类，它是 [1, 0]。

损失计算：

在强化学习中，ep_as 存储了模型的预测标签，而 ep_obs_label 存储了实际的标签。通过将这两个进行对比，计算损失，并在训练过程中通过反向传播来优化模型，使得 ep_as 更接近 ep_obs_label。

总结：

  • ep_as 代表模型在每个时间步 预测的标签（即模型选择的动作）。
  • ep_obs_label 是实际标签（目标标签）。
  • 通过训练，模型的目标是使得 ep_as 尽可能接近 ep_obs_label，以提高预测准确性。

在你提供的代码中，is_decision 函数用于判断是否需要做出决策，并且决定接下来的标签（last_label）。这一部分的代码实际上并不是在做完全随机的选择，而是在根据 图的结构 来做决策，并且策略是有一定的规则（deterministic）的，具体来说，它是基于 图的度数（degree） 以及当前标签（last_label）来决定的。

代码逻辑解析：

is_decision 的输入是：

  • pre：前一个节点（前一个词或状态）。
  • suf：后一个节点（后一个词或状态）。
  • last_label：上一时刻的标签。

根据输入，is_decision 会判断当前情况，并决定是否需要进行一个 决策，以及选择的标签是什么。具体来说，它根据节点的度数和前后连接关系来判断：

1. One-to-More：如果图中 pre 节点的出度大于 1，且 suf 节点的入度等于 1

if G.out_degree(pre) > 1 and G.in_degree(suf) == 1:
    if last_label == 1:
        return [False, last_label]  # 不做决策，保持当前标签
    else:
        return [True, None]  # 需要做决策，标签为 None（可能需要从多个候选标签中选择一个）

在这种情况下，如果当前标签（last_label）是 1，则保持当前标签，不做决策。否则，说明 pre 有多个后继（即存在多个候选），suf 只有一个前驱，此时需要做决策，标签设置为 None，表示可以选择一个新的标签。

2. One-to-One：如果 pre 节点的出度为 1，且 suf 节点的入度为 1

if G.out_degree(pre) == 1 and G.in_degree(suf) == 1:
    return [False, last_label]  # 不做决策，保持当前标签

在这种情况下，pre 和 suf 是一一对应的，标签不需要改变，返回当前的标签。

3. More-to-One：如果 pre 节点的出度为 1，且 suf 节点的入度大于 1

if G.out_degree(pre) == 1 and G.in_degree(suf) > 1:
    if last_label == 0:
        return [False, last_label]  # 不做决策，保持当前标签
    else:
        return [True, None]  # 需要做决策，标签为 None

在这种情况下，pre 只有一个后继节点，但 suf 有多个前驱节点。如果当前标签是 0，则不需要做决策，保持标签；如果当前标签是 1，则需要做决策，选择一个新的标签。

4. More-to-More：如果 pre 节点的出度和 suf 节点的入度都大于 1

if G.out_degree(pre) > 1 and G.in_degree(suf) > 1:
    return [True, None]  # 需要做决策，标签为 None

在这种情况下，pre 和 suf 都有多个后继和前驱节点，意味着存在多个可能的选择，必须做决策，标签为 None，表示可以从多个候选标签中选择一个。

总结：

  • is_decision 根据前后节点的度数和当前标签来判断是否需要进行决策。如果不需要决策，则返回 False 并保持当前标签。
  • 需要做决策时，返回 [True, None]，并表示需要从多个候选标签中选择一个。
  • 这里并没有完全的随机性，而是依赖于 图的结构 和 当前标签 来做出有规则的决策。

因此，策略是 确定性 的，并没有引入随机性。根据不同的条件，它会选择是否继续保持当前标签或做出新的决策。

是的，你的理解是正确的！可以总结为以下几个步骤：

1. 判断是否需要做决策：

  • 在每一步，首先通过 is_decision 判断是否需要做出决策。
    • 如果不需要做决策（即返回 False），那么就继续沿用前一个时刻的标签。
    • 如果需要做决策（即返回 True），则需要进一步决定当前时刻的标签是什么。

2. 如果需要做决策：

  • 如果 is_decision 返回 True，表示当前时刻的标签是通过模型的策略来选择的（即通过 choose_action 来决定是选择 0 还是 1）。
  • 在这种情况下，标签通常会是 None，直到通过 choose_action 来填充实际的标签值（0 或 1）。

3. 标签更新：

  • 当不需要做决策时（False），标签保持不变，模型沿用前一时刻的标签。
  • 当需要做决策时（True），通过策略网络计算当前的最优动作（标签），然后将其更新到 ep_as 中。

总结：

  • 不做决策：保持之前的标签。
  • 做决策：模型选择一个新的标签（通常是通过 choose_action）。

这个逻辑控制了模型在每个时刻是否需要更新标签（做决策）以及如何选择标签。

当然！以下是一个表格，展示了 is_decision 函数返回的不同情况以及它们如何影响标签的选择：

决策情况 判断条件 返回值 标签更新
不需要做决策 G.out_degree(pre) == 1 and G.in_degree(suf) == 1 或其他类似的情况 False, last_label 标签保持不变，沿用上一个时刻的标签 (last_label)
需要做决策（选择） G.out_degree(pre) > 1 and G.in_degree(suf) == 1 或其他类似的情况 True, None 需要通过模型策略选择标签（choose_action）
更多到更多的情况 G.out_degree(pre) > 1 and G.in_degree(suf) > 1 True, None 需要通过模型策略选择标签（choose_action）

解释：

  1. 不需要做决策：

    • 如果当前状态下不需要做决策（即返回 False），模型会保持当前标签不变（使用 last_label）。

  2. 需要做决策：

    • 如果判断为需要做决策（即返回 True），模型会根据当前状态选择一个新的标签，并通过 choose_action 来更新标签。
    • 标签在这种情况下会设为 None，直到通过 choose_action 获取到实际的标签（0 或 1）。

  3. 更多到更多的情况：

    • 在一些特殊情况（如多个输出与多个输入的关系）下，模型也需要做决策，标签会通过 choose_action 进行选择。

总结：

  • False：表示不需要做决策，标签保持不变。
  • True：表示需要做决策，标签需要通过策略网络来选择。

通过 is_decision 函数，模型会判断在当前时刻是否需要更新标签，并根据图的结构和前后文来决定是否选择新的标签。

策略优化 ASDNet

好的，接下来我将详细解读 session.run 中的各个输入和计算图的维度变化，解释每个张量的形状如何影响网络的前向传播。

1. 输入部分：feed_dict

在 session.run 中，你将以下数据传递给了计算图：

(1) self.tf_obs (观测数据)

  • 维度: (seq_len, 2 * n_features)
  • 解释: 这表示当前时间步的输入观测数据。每个时间步的观测是一个 256 维的特征向量，且你将它拼接了 self.tf_idx（标签的嵌入向量）后变成了 512 维的向量。这里 seq_len 表示当前回合（episode）中的时间步数，n_features = 256，因此观测数据的形状为 (seq_len, 2 * 256)。
  • 注释: np.array(self.ep_obs[n_round]) 中，ep_obs 是一个大小为 (15, 256) 的数组，每一行代表一个时间步的观测特征。2 * n_features = 512 是拼接后的形状。

(2) self.tf_idx (标签数据)

  • 维度: (seq_len, n_actions)
  • 解释: 这里的 self.tf_idx 存储的是每个时间步对应的标签的 one-hot 编码。每个标签是一个大小为 n_actions = 2 的向量。因此，如果 seq_len = 15，那么 self.tf_idx 的形状为 (15, 2)，表示 15 个时间步，每个时间步的标签是 2 维的 one-hot 编码。
  • 注释: np.array(self.ep_obs_label[n_round]) 中，ep_obs_label 存储的是每个时间步的标签，形状为 (15, 2)。

(3) self.tf_acts (动作选择)

  • 维度: (seq_len,)
  • 解释: self.tf_acts 存储的是模型在每个时间步选择的动作编号。这是一个大小为 seq_len 的一维数组，每个元素表示模型选择的动作编号。由于每个动作的编号是 0 或 1，所以它是一个整数数组，长度为 seq_len。
  • 注释: np.array(self.ep_as[n_round])，ep_as 是每个时间步模型选择的动作编号（0 或 1），因此它的形状是 (15,)。

(4) self.tf_vt (折扣奖励)

  • 维度: (seq_len,)
  • 解释: self.tf_vt 是强化学习中的折扣奖励，它与每个时间步的状态-动作对（(s, a)）相关联。通常这代表了当前时间步后未来奖励的期望。discounted_ep_rs 也有 seq_len 的长度，表示每个时间步的奖励。
  • 注释: discounted_ep_rs 的形状为 (15,)，它表示每个时间步的奖励。

(5) self.keep_prob (Dropout)

  • 维度: scalar
  • 解释: 这是用于控制 Dropout 的概率。在训练时，为了避免过拟合，某些神经元会被随机丢弃，keep_prob 控制每个神经元的保留概率。通常在训练时为 keep_prob = 0.5，在测试时为 keep_prob = 1.0。

2. 计算图中的层次

接下来，我们逐步分析计算图的计算部分。

(1) State 部分 — topic_vec 和 all_obs

topic_vec = tf.layers.dense(self.tf_idx, self.n_features, name='label_vec')
all_obs = tf.concat([self.tf_obs, topic_vec], 1)
  • self.tf_idx 的形状是 (seq_len, n_actions)，即 (15, 2)。
  • topic_vec 通过 tf.layers.dense(self.tf_idx, self.n_features) 计算，其中 n_features = 256，输出的形状是 (seq_len, 256)，即 (15, 256)。
  • 然后将 self.tf_obs 和 topic_vec 拼接，self.tf_obs 的形状是 (seq_len, 512)，因此拼接后的 all_obs 的形状是 (seq_len, 512 + 256) = (15, 768)。

(2) Policy 部分 — self.all_act_prob

self.all_act_prob = tf.nn.softmax(self.all_act, name='act_prob')
  • self.all_act 的形状是 (seq_len, n_actions)，即 (15, 2)。
  • self.all_act_prob 是通过 softmax 激活函数计算得到的，它将 self.all_act 转换为一个概率分布，表示每个动作的选择概率。因此，self.all_act_prob 的形状仍然是 (15, 2)。

(3) Loss 部分 — 计算 neg_log_prob 和 self.loss

neg_log_prob = tf.reduce_sum(-tf.log(self.all_act_prob)*tf.one_hot(self.tf_acts, self.n_actions), axis=1)
self.loss = tf.reduce_mean(neg_log_prob * self.tf_vt)

  • 计算 neg_log_prob:

    • self.all_act_prob 的形状是 (seq_len, n_actions)，即 (15, 2)。
    • tf.one_hot(self.tf_acts, self.n_actions) 会将 self.tf_acts（形状是 (seq_len,)）转化为 one-hot 编码。self.tf_acts 的形状为 (15,)，经过 one_hot 后会变为 (15, 2)。
    • tf.log(self.all_act_prob) 会计算 self.all_act_prob 中每个元素的对数，结果的形状是 (15, 2)。
    • -tf.log(self.all_act_prob) * tf.one_hot(self.tf_acts, self.n_actions) 计算了每个时间步的负对数概率。
    • tf.reduce_sum(..., axis=1) 进行按行求和，结果的形状为 (15,)，表示每个时间步的负对数概率。

  • 计算 self.loss:

    • neg_log_prob 的形状是 (15,)，它表示每个时间步的损失。
    • self.tf_vt 的形状是 (15,)，表示每个时间步的折扣奖励。
    • neg_log_prob * self.tf_vt 对每个时间步的负对数概率和奖励进行乘法，结果的形状是 (15,)。
    • tf.reduce_mean(...) 对这些乘积取平均，得到最终的损失值 self.loss，它是一个标量（即 ()，形状为 ()）。

3. 输出部分

最终，通过 session.run 计算得到的：

  • self.loss: 是当前回合的平均损失，形状为标量 ()，表示整个回合的损失值。
  • self.train_op: 是训练操作，它在 session.run 中执行，旨在根据当前的损失 self.loss 更新模型的参数。

总结：

  • 输入的各个张量（tf_obs、tf_idx、tf_acts、tf_vt）的形状是 (seq_len, ...) 或 (seq_len,)。
  • 在网络的前向传播中，数据通过多层计算，最终计算出每个时间步的动作概率分布、负对数概率、损失函数等。
  • 输出的 self.loss 是一个标量，表示当前回合的损失。self.train_op 是用于更新模型参数的操作。

通过这种方式，整个强化学习过程中的数据流和维度变化是相互关联的，最终优化的是网络的参数，以使得模型能够通过选择合适的动作来最大化累计奖励。

输入数据的维度

根据你提供的输出，我们可以详细解读每个输入数据的形状及其含义。

输出解读

1. ep_obs shape: (15, 256)

  • 含义：这表示在一个回合（episode）中有 15 个时间步（即序列的长度），每个时间步的观测数据包含 256 个特征。
  • 解释：ep_obs 存储了当前回合中所有时间步的观测数据。每个观测值是一个 256 维的向量。通常，观测值可能是从环境中获得的编码后的特征向量，包含了关于环境状态的信息。

2. ep_obs_label shape: (15, 2)

  • 含义：这表示在同一个回合中，有 15 个时间步，每个时间步都有 2 个标签索引（通常是 one-hot 编码）。
  • 解释：ep_obs_label 存储了每个时间步的标签信息，通常用于将观测数据与标签进行关联。在这里，每个时间步的标签有 2 个维度（可能表示动作空间的大小或者标签的种类）。如果是 one-hot 编码，那么每一行就是一个标签的 one-hot 向量。

3. ep_as shape: (15,)

  • 含义：这是一个包含 15 个元素的数组，每个元素表示在该时间步模型选择的动作编号。
  • 解释：ep_as 是模型在当前回合中选择的动作序列。在这里有 15 个时间步，所以 ep_as 的长度是 15，每个元素表示模型在对应时间步采取的动作编号。

4. discounted_ep_rs shape: (15,)

  • 含义：这是一个包含 15 个元素的数组，表示在每个时间步的 折扣奖励（discounted reward）。
  • 解释：discounted_ep_rs 存储了每个时间步的奖励值，通常是基于强化学习中的 折扣奖励策略计算的。每个时间步的奖励反映了模型在该时刻的表现。通常，奖励值会根据未来奖励的影响进行折扣。

综上：

  • ep_obs shape: (15, 256)：该回合有 15 个时间步，每个时间步的观测数据有 256 个特征。
  • ep_obs_label shape: (15, 2)：每个时间步的标签数据包含 2 个维度（可能是 2 个可能的标签类别）。
  • ep_as shape: (15,)：模型在该回合中每个时间步采取的动作，动作空间大小为 15。
  • discounted_ep_rs shape: (15,)：每个时间步的奖励，长度为 15，对应每个时间步的折扣奖励。

总结

  • 这个回合有 15 个时间步，每个时间步的输入由 256 个特征（观测数据）组成。
  • 每个时间步会选择一个动作，并且每个时间步都会根据强化学习的目标计算奖励。
  • ep_obs 和 ep_obs_label 提供了关于环境状态和标签的详细信息，而 ep_as 和 discounted_ep_rs 分别是模型的动作选择和奖励信号。

这些数据将用于计算模型的损失，并通过反向传播调整模型的参数，使得模型在环境中能够选择更合适的动作，从而最大化长期奖励。

从你提供的输出数据来看，以下是各个变量的具体内容和含义：

1. ep_obs (形状: (15, 256))

[ 4.80320975e-02, -1.00729167e-01, -1.31308213e-01,  1.62242539e-02, 
  -1.27876282e-01, -1.23955965e-01, -2.19669566e-02,  5.92805892e-02, 
  7.62588978e-02,  4.68192548e-02, -5.88752180e-02, -7.68580809e-02, 
  -1.71381980e-03,  2.08448246e-01, -7.45244697e-02, -1.79551542e-03, 
  -8.47585425e-02,  1.46021798e-01,  1.33467466e-02, -1.17891207e-01, 
  -5.87821007e-04]
  • ep_obs 代表了模型在每个时间步的 观测 数据（即输入特征），其形状为 (15, 256)。
  • 这表示你有 15个时间步，每个时间步的观测特征有 256维。
  • 每一行是一个时间步的观测数据，格式是一个包含 256 个浮点数的数组。根据你给出的例子，这些值看起来像是标准化或者通过神经网络提取的特征。

2. ep_obs_label (形状: (15, 2))

[array([1, 0]), array([1, 0]), array([1, 0]), array([1, 0]), 
 array([1, 0]), array([1, 0]), array([1, 0]), array([1, 0]), 
 array([1, 0]), array([1, 0]), array([1, 0]), array([0, 1]), 
 array([0, 1]), array([1, 0]), array([1, 0])]
  • ep_obs_label 存储了每个时间步的 标签（即真实标签），每个标签都是一个 one-hot 编码 向量，表示该时间步的类别。
  • 你使用了 2个类别（标签空间大小为2），因此每个标签是一个大小为 2 的 one-hot 向量。例如，第一个时间步的标签是 [1, 0]，表示标签为类别 0；第十二个时间步的标签是 [0, 1]，表示标签为类别 1。
  • ep_obs_label 的形状是 (15, 2)，表示有 15个时间步，每个时间步有 2个类别标签。

3. ep_as (形状: (15,))

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0]
  • ep_as 存储了每个时间步 模型选择的动作。它表示在每个时间步模型选择的动作编号。模型的动作是通过策略网络来选择的。
  • 这里的值是整数（0 或 1），表示在每个时间步模型选择的动作编号。例如，前 10 个时间步模型都选择了动作 0，而第 11 个时间步选择了动作 1。
  • ep_as 的形状是 (15,)，表示有 15个时间步，每个时间步有 一个动作编号。

4. discounted_ep_rs (形状: (15,))

[1.77854668 1.77854668 1.77854668 1.77854668 1.77854668 1.77854668
 1.77854668 1.77854668 1.77854668 1.77854668 1.77854668 1.77854668
 1.77854668 1.77854668 1.77854668]
  • discounted_ep_rs 表示 折扣奖励，它是强化学习中每个时间步的奖励值。根据代码中的 reward[n_round]，它是当前回合的全局奖励，可能已经经过折扣（如果折扣因子存在的话）。
  • 在你的输出中，所有的折扣奖励值都是相同的 1.77854668，这意味着模型在每个时间步的奖励值是恒定的（可能是某种标准化后的奖励值）。
  • discounted_ep_rs 的形状是 (15,)，表示有 15个时间步，每个时间步的奖励值。

总结：

  • ep_obs 存储了每个时间步的观测数据（特征），维度是 (15, 256)。
  • ep_obs_label 存储了每个时间步的实际标签（one-hot 编码），维度是 (15, 2)。
  • ep_as 存储了模型选择的动作（编号），维度是 (15,)。
  • discounted_ep_rs 存储了每个时间步的折扣奖励，维度是 (15,)。

这些数据在 learn 函数中作为输入，通过 feed_dict 被送入 TensorFlow 图中，用于计算损失和更新模型参数。

数据维度的变化

从您提供的 TensorFlow 输出信息来看，模型中各个张量的形状可以帮助我们理解数据的流动和计算过程。下面是每个张量的维度解释：

1. topic_vec

  • Shape: (?, 128)
  • 解释：
    • ? 代表 batch size，在 TensorFlow 中通常会使用 None 来表示不定大小的维度，意味着这一层支持不同大小的输入。
    • 128 是这一层的输出维度，也就是经过全连接层（tf.layers.dense）处理后的标签嵌入的维度。在这里，topic_vec 是通过对输入的标签向量（tf_idx）进行全连接变换得到的，转换后的结果是一个大小为 128 的向量。

2. all_obs

  • Shape: (?, 384)
  • 解释：
    • ? 仍然是 batch size，表示一次输入的数据量。
    • 384 是拼接后的特征维度。在这一步，all_obs 是由 self.tf_obs 和 topic_vec 拼接得到的。self.tf_obs 的维度是 (None, 256)，而 topic_vec 的维度是 (None, 128)，因此拼接后 all_obs 的维度是 (None, 256 + 128) = (None, 384)。

3. self.all_act

  • Shape: (?, 2)
  • 解释：
    • ? 是 batch size。
    • 2 是动作空间的大小，即模型可以选择的动作数量。在这一步，self.all_act 代表每个可能动作的“分数”或“Q值”，模型通过全连接层（tf.layers.dense）计算每个动作的预测值。因为您的模型有 2 个可能的动作，所以该层的输出是一个大小为 2 的向量。

4. self.all_act_prob

  • Shape: (?, 2)
  • 解释：
    • ? 仍然是 batch size。
    • 2 是动作空间的大小，即每个样本选择两个动作的概率。self.all_act_prob 是通过对 self.all_act 进行 softmax 操作得到的概率分布。该分布表示每个动作在当前状态下的选择概率，self.all_act_prob 的每个元素的和等于 1。

5. neg_log_prob

  • Shape: (?,)
  • 解释：
    • ? 代表 batch size。
    • 每个元素代表每个样本的负对数概率。neg_log_prob 是通过 -tf.log(self.all_act_prob) 和 tf.one_hot(self.tf_acts, self.n_actions) 计算得到的，表示模型选择的动作的负对数概率。最终，neg_log_prob 的维度是 (batch_size,)，每个样本一个负对数概率值。

6. self.loss

  • Shape: ()
  • 解释：
    • () 表示标量值。
    • self.loss 是损失函数的最终输出，表示整个批次的平均损失。该值是 neg_log_prob 和 self.tf_vt（即奖励）的乘积的均值。最终，损失值是一个标量，用于优化网络的参数。

综合解释：

从这些维度来看，模型的计算过程是这样的：

  1. 输入： self.tf_obs 和 self.tf_idx 分别提供了环境的观测和标签索引。
  2. 状态（State）： 通过将观测和标签向量拼接得到 all_obs，然后通过全连接层得到每个动作的预测值 self.all_act，它的维度为 (batch_size, 2)，即每个样本对应 2 个动作的分数。
  3. 策略（Policy）： 对动作的预测分数应用 softmax 得到 self.all_act_prob，它表示每个动作的选择概率。
  4. 损失（Loss）： 使用交叉熵损失（通过 neg_log_prob 计算）和奖励信号（self.tf_vt）计算最终的损失。

注意：

  • self.loss 是标量， 表示整个批次的平均损失。
  • 维度的大小表明这是一个批量训练模型，每个样本的损失会被求平均并用来更新网络的权重。

提醒：

  • 你可能会看到警告 The name tf.log is deprecated. Please use tf.math.log instead.，这是因为 tf.log 被标记为过时，建议使用 tf.math.log 进行替代。

关于合并标签是来源于真实标签还是预测标签的困惑

从您提供的代码来看，self.ep_obs_label 在 ASDNetwork 类的定义中已经初始化了，但是对于其来源（即 ep_obs_label 的具体数据流），并没有明确的说明。它似乎是用来保存每个样本的标签数据，并在模型的训练过程中进行更新。

具体来说，ep_obs_label 是一个保存标签的列表，其中每个元素对应一个样本的标签。它是在 store_transition 方法中存储的：

def store_transition(self, s, s_label, a, n_round):
    self.ep_obs[n_round].append(s)
    self.ep_as[n_round].append(a)
    self.ep_obs_label[n_round].append(s_label)

store_transition 方法将样本的观测数据 (s)、标签数据 (s_label)、动作 (a) 存储到 ep_obs, ep_as, 和 ep_obs_label 这三个列表中。在这个上下文中，ep_obs_label 存储的是每个样本的标签数据。

  • s_label（即标签数据）通过 store_transition 被添加到 ep_obs_label 中，并且每一轮的训练都会涉及这些数据。
  • ep_obs_label 是一个二维列表，存储了每个训练回合中的标签数据。

但是，代码中并没有显式说明 s_label 是从哪里来的。在 train_asd 或 pretrain_asd 中，它显然是通过调用 determine 或 pretrain_asd 等函数来传递的。

如果你想要进一步确认 ep_obs_label 的数据来源，可能需要查看调用 store_transition 方法的上下文（例如，输入数据是如何准备的），或者检查如何通过 labels 和 text 数据来产生标签。

请确认是否需要检查与 store_transition 相关的其他部分，或者提供更多上下文代码。如果有更多的代码片段，我可以帮助进一步分析。

self.ep_obs_label 这个变量的来源是你在 learn 函数中提到的 ep_obs_label[n_round]，而根据代码的上下文和命名规则，self.ep_obs_label 似乎应该是与观测数据对应的 标签数据，而不是来自于 RSRNetwork（虽然 RSRNetwork 可能与数据的处理相关）。让我们逐步分析：

1. ep_obs_label 的来源

在你提供的代码片段中，ep_obs_label 是从 self.ep_obs_label[n_round] 获取的。在 learn 函数中，ep_obs_label[n_round] 作为输入传递给 feed_dict，并被赋给 self.tf_idx：

outputs = session.run([self.loss, self.train_op], feed_dict={
    self.tf_obs: np.array(self.ep_obs[n_round]),    # 形状=[seq_len, 2*n_features]
    self.tf_idx: np.array(self.ep_obs_label[n_round]),  # 真实标签
    self.tf_acts: np.array(self.ep_as[n_round]),    # 动作
    self.tf_vt: discounted_ep_rs,                   # 折扣奖励
    self.keep_prob: keep_prob})

从这个代码段来看，ep_obs_label 存储的是每个时间步对应的 标签数据，它与 ep_obs（观测数据）是成对的。ep_obs_label 的形状应该是 [seq_len, n_labels]，其中 n_labels 是标签的数量，通常是类别数量。

2. ep_obs_label 可能来自哪里

虽然你提到它可能来自 RSRNetwork，但 ep_obs_label 更可能是从训练数据中加载得到的真实标签。RSRNetwork 可能用于处理和提取输入数据的特征（例如，ep_obs），而 ep_obs_label 则是直接来自于训练数据中的标签。

考虑到 ep_obs_label 是与训练数据和标签紧密相关的变量，它应该是来自于数据集中的 真实标签，而不是 RSRNetwork。RSRNetwork 可能参与到特征提取或其他处理，但真实标签一般会直接从训练数据中加载。

3. 数据流向

假设数据流是从数据集到模型的，标签数据应该是在数据加载时获取的。也就是说，ep_obs_label 应该是模型输入的 真实标签，它不依赖于 RSRNetwork，而是通过训练数据中的标签部分（例如 LABEL_TRAIN、LABEL_TRAIN_PRE 等）提供。

总结：

  • ep_obs_label 存储的是 真实标签，并作为输入传递给模型进行训练。
  • 它并不是来自 RSRNetwork，而是来自于训练数据（例如 LABEL_TRAIN）。
  • RSRNetwork 主要用于特征提取，ep_obs_label 则用于计算损失和训练。

如果你需要进一步确认 ep_obs_label 的具体来源，你可以在数据加载阶段或者模型初始化部分查看它是如何被赋值的。

posted @ 2024-11-29 16:29  GraphL  阅读(36)  评论(0)    收藏  举报