​#2021SC@SDUSC

这部分将分析rnn_cell.py和rnn_layers.py部分

RNN cells. py

RNNCell 表示 .NestedMap 中的循环状态。 zero_state(theta, batch_size) 返回初始状态，由每个子类定义。 从状态中，每个子类都定义了GetOutput() 来提取输出张量。 RNNCell.FProp 定义了前向函数:: (theta, state0, 输入) -> state1, extras 所有参数和返回值都是.NestedMap。 每个子类都定义了这些 .NestedMap 应该具有的字段。 extras 是一个 .NestedMap，其中包含一些 FProp 计算以促进反向传播的中间结果。 zero_state(theta, batch_size)、state0 和 state1 都是兼容的 .NestedMap（参见 .NestedMap.IsCompatible）。 即，它们递归地具有相同的键。 此外，这些 .NestedMap 中相应的张量具有相同的形状和数据类型。

@classmethod
  def Params(cls):
    p = super().Params()
    p.Define('inputs_arity', 1,
             'number of tensors expected for the inputs.act to FProp.')
    p.Define('num_input_nodes', 0, 'Number of input nodes.')
    p.Define(
        'num_output_nodes', 0,
        'Number of output nodes. If num_hidden_nodes is 0, also used as '
        'cell size.')
    p.Define(
        'reset_cell_state', False,
        ('Set True to support resetting cell state in scenarios where multiple '
         'inputs are packed into a single training example. The RNN layer '
         'should provide reset_mask inputs in addition to act and padding if '
         'this flag is set.'))
    p.Define(
        'zero_state_init_params', py_utils.DefaultRNNCellStateInit(),
        'Parameters that define how the initial state values are set '
        'for each cell. Must be one of the static functions defined in '
        'py_utils.RNNCellStateInit.')
    return p

def FProp(self, theta, state0, inputs):
这里的默认实现假设 cell forward 函数由两个函数组成： _Gates（_Mix（theta，state0，inputs），theta，state0，inputs） _Mix 的结果存放在 extras 中以方便反向传播。 如果 reset_cell_state 为 True，则可选地应用 _ResetState。除了其他输入之外，RNN 层还应提供“reset_mask”输入。 reset_mask 输入在运行 _Mix() 和 _Gates() 之前应该被重置为默认值（零）的时间步长为 0，否则为 1。这是为了支持诸如打包输入之类的用例，其中在单个输入示例序列中输入多个样本，并且需要相互屏蔽。例如，如果打包在一起的两个例子是 [‘good’, ‘day’] -> [‘guten-tag’] 和 [‘thanks’] -> [‘danke’] 产生 [‘good’, 'day ', ‘thanks’] -> [‘guten-tag’, ‘danke’]，源 reset_mask 将为 [1, 1, 0]，目标重置掩码将为 [1, 0]。这些 id 旨在为彼此不同的示例启用屏蔽计算。 参数： theta：一个.NestedMap 对象，包含该层及其子层的权重值。 state0：之前的循环状态。一个.NestedMap。 输入：单元格的输入。一个.NestedMap。 返回： 元组 (state1, extras)。 - state1：​​下一个循环状态。一个.NestedMap。 - 附加：中间结果以促进反向传播。一个.NestedMap。

assert isinstance(inputs.act, list)
    assert self.params.inputs_arity == len(inputs.act)
    if self.params.reset_cell_state:
      state0_modified = self._ResetState(state0.DeepCopy(), inputs)
    else:
      state0_modified = state0
    xmw = self._Mix(theta, state0_modified, inputs)
    state1 = self._Gates(xmw, theta, state0_modified, inputs)
    return state1, py_utils.NestedMap()

def _GetBias(self, theta): 获取要添加的偏置向量。
包括forget_gate_bias 之类的调整。 直接使用 this 而不是 ‘b’ 变量，因为以这种方式包含调整允许 const-prop 在推理时消除调整。 参数： theta：一个.NestedMap 对象，包含该层及其子层的权重值。 返回： 偏置向量。

p = self.params
    if p.enable_lstm_bias:
      b = theta.b
    else:
      b = tf.zeros([self.num_gates * self.hidden_size], dtype=p.dtype)
    if p.forget_gate_bias != 0.0:
      # Apply the forget gate bias directly to the bias vector.
      if not p.couple_input_forget_gates:
        # Normal 4 gate bias (i_i, i_g, f_g, o_g).
        adjustment = (
            tf.ones([4, self.hidden_size], dtype=p.dtype) * tf.expand_dims(
                tf.constant([0., 0., p.forget_gate_bias, 0.], dtype=p.dtype),
                axis=1))
      else:
        # 3 gates with coupled input/forget (i_i, f_g, o_g).
        adjustment = (
            tf.ones([3, self.hidden_size], dtype=p.dtype) * tf.expand_dims(
                tf.constant([0., p.forget_gate_bias, 0.], dtype=p.dtype),
                axis=1))
      adjustment = tf.reshape(adjustment, [self.num_gates * self.hidden_size])
      b = b + adjustment

    return b

rnn_layers.py

函数GeneratePackedInputResetMask从 segment_id 生成 RNN 单元的掩码输入。
参数：
segment_id：形状为 [time, batch_size, 1] 的张量。
is_reverse：如果输入以相反的顺序馈送到 RNN，则为真。
返回：
reset_mask - 形状为 [time, batch_size, 1] 的张量。 对于样本设置为 0
需要重置状态的地方（在示例边界处），否则为 1。

segment_id_left = segment_id[:-1]
  segment_id_right = segment_id[1:]

  # Mask is a [t-1, bs, 1] tensor.
  reset_mask = tf.cast(
      tf.equal(segment_id_left, segment_id_right), dtype=segment_id.dtype)
  mask_padding_shape = tf.concat(
      [tf.ones([1], dtype=tf.int32),
       tf.shape(segment_id)[1:]], axis=0)
  mask_padding = tf.ones(mask_padding_shape, dtype=segment_id.dtype)
  if is_reverse:
    reset_mask = tf.concat([reset_mask, mask_padding], axis=0)
  else:
    reset_mask = tf.concat([mask_padding, reset_mask], axis=0)
  return reset_mask

Class RNN：
静态展开的RNN
形参：

def Params(cls):
    p = super().Params()
    p.Define('cell', rnn_cell.LSTMCellSimple.Params(),
             'Configs for the RNN cell.')
    p.Define(
        'sequence_length', 0,
        'Sequence length to unroll. If > 0, then will unroll to this fixed '
        'size. If 0, then will unroll to accommodate the size of the inputs '
        'for each call to FProp.')
    p.Define('reverse', False,
             'Whether or not to unroll the sequence in reversed order.')
    p.Define('packed_input', False, 'To reset states for packed inputs.')
    return p

初始化：

def __init__(self, params):
    super().__init__(params)
    p = self.params
    assert not p.packed_input, ('Packed inputs are currently not supported by '
                                'Static RNN')
    p.cell.reset_cell_state = p.packed_input
    assert p.sequence_length >= 0
    self.CreateChild('cell', p.cell)

函数FProp计算 RNN 前向传递。
参数： theta：一个.NestedMap 对象，包含该层及其子层的权重值。 输入：单个张量或基数等于的张量元组 rnn_cell.inputs_arity。 对于每个输入张量，假设第一维是时间、第二维批次和第三维深度。 填充：张量。 第一个暗淡是时间，第二个暗淡是批次，第三个暗淡预计为 1。 state0：如果不是 None，则为 .NestedMap 中的初始 rnn 状态。 默认为单元格的零状态。 返回： [时间、batch、dim]的张量。 最终的循环状态。

 p = self.params
    assert isinstance(self.cell, rnn_cell.RNNCell)
    if p.sequence_length == 0:
      if isinstance(inputs, (tuple, list)):
        sequence_length = len(inputs)
      else:
        sequence_length = py_utils.GetShape(inputs)[0]
    else:
      sequence_length = p.sequence_length
    assert sequence_length >= 1, ('Sequence length must be defined or inputs '
                                  'must have fixed shapes.')
    with tf.name_scope(p.name):
      inputs_sequence = tf.unstack(inputs, num=sequence_length)
      paddings_sequence = tf.unstack(paddings, num=sequence_length)
      # We start from all 0 states.
      if state0:
        state = state0
      else:
        inputs0 = py_utils.NestedMap(
            act=[inputs_sequence[0]], padding=paddings_sequence[0])
        state = self.cell.zero_state(theta.cell, self.cell.batch_size(inputs0))
      outputs = [None] * sequence_length
      if p.reverse:
        sequence = range(sequence_length - 1, -1, -1)
      else:
        sequence = range(0, sequence_length, 1)
      for idx in sequence:
        cur_input = py_utils.NestedMap(act=[inputs[idx]], padding=paddings[idx])
        state, _ = self.cell.FProp(theta.cell, state, cur_input)
        outputs[idx] = self.cell.GetOutput(state)
      return tf.stack(outputs), state