单双层RNN API对比介绍

本文以PaddlePaddle的双层RNN单元测试为示例,用多对效果完全相同的、分别使用单双层RNN作为网络配置的模型,来讲解如何使用双层RNN。本文中所有的例子,都只是介绍双层RNN的API接口,并不是使用双层RNN解决实际的问题。如果想要了解双层RNN在具体问题中的使用,请参考algo_hrnn_demo。本文中示例所使用的单元测试文件是test_RecurrentGradientMachine.cpp

示例1:双层RNN,子序列间无Memory

在双层RNN中的经典情况是将内层的每一个时间序列数据,分别进行序列操作;并且内层的序列操作之间独立无依赖,即不需要使用Memory。

在本示例中,单层RNN和双层RNN的网络配置,都是将每一句分好词后的句子,使用LSTM作为encoder,压缩成一个向量。区别是RNN使用两层序列模型,将多句话看成一个整体同时使用encoder压缩。二者语意上完全一致。这组语义相同的示例配置如下:

读取双层序列数据

首先,本示例中使用的原始数据如下:

  • 本例中的原始数据一共有10个样本。每个样本由两部分组成,一个label(此处都为2)和一个已经分词后的句子。这个数据也被单层RNN网络直接使用。
2  	酒店 有 很 舒适 的 床垫 子 , 床上用品 也 应该 是 一人 一 换 , 感觉 很 利落 对 卫生 很 放心 呀 。
2  	很 温馨 , 也 挺 干净 的 * 地段 不错 , 出来 就 有 全家 , 离 地铁站 也 近 , 交通 很方便 * 就是 都 不 给 刷牙 的 杯子 啊 , 就 第一天 给 了 一次性杯子 *
2  	位置 方便 , 强烈推荐 , 十一 出去玩 的 时候 选 的 , 对面 就是 华润万家 , 周围 吃饭 的 也 不少 。
2  	交通便利 , 吃 很 便利 , 乾 浄 、 安静 , 商务 房 有 电脑 、 上网 快 , 价格 可以 , 就 早餐 不 好吃 。 整体 是 不错 的 。 適 合 出差 來 住 。
2  	本来 准备 住 两 晚 , 第 2 天 一早 居然 停电 , 且 无 通知 , 只有 口头 道歉 。 总体来说 性价比 尚可 , 房间 较 新 , 还是 推荐 .
2  	这个 酒店 去过 很多 次 了 , 选择 的 主要原因 是 离 客户 最 便宜 相对 又 近 的 酒店
2  	挺好 的 汉庭 , 前台 服务 很 热情 , 卫生 很 整洁 , 房间 安静 , 水温 适中 , 挺好 !
2  	HowardJohnson 的 品质 , 服务 相当 好 的 一 家 五星级 。 房间 不错 、 泳池 不错 、 楼层 安排 很 合理 。 还有 就是 地理位置 , 简直 一 流 。 就 在 天一阁 、 月湖 旁边 , 离 天一广场 也 不远 。 下次 来 宁波 还会 住 。
2  	酒店 很干净 , 很安静 , 很 温馨 , 服务员 服务 好 , 各方面 都 不错 *
2  	挺好 的 , 就是 没 窗户 , 不过 对 得 起 这 价格
  • 双层序列数据一共有4个样本。 每个样本间用空行分开,整体数据和原始数据完全一样。但于双层序列的LSTM来说,第一个样本同时encode两条数据成两个向量。这四条数据同时处理的句子数量为[2, 3, 2, 3]
2  	酒店 有 很 舒适 的 床垫 子 , 床上用品 也 应该 是 一人 一 换 , 感觉 很 利落 对 卫生 很 放心 呀 。
2  	很 温馨 , 也 挺 干净 的 * 地段 不错 , 出来 就 有 全家 , 离 地铁站 也 近 , 交通 很方便 * 就是 都 不 给 刷牙 的 杯子 啊 , 就 第一天 给 了 一次性杯子 *

2  	位置 方便 , 强烈推荐 , 十一 出去玩 的 时候 选 的 , 对面 就是 华润万家 , 周围 吃饭 的 也 不少 。
2  	交通便利 , 吃 很 便利 , 乾 浄 、 安静 , 商务 房 有 电脑 、 上网 快 , 价格 可以 , 就 早餐 不 好吃 。 整体 是 不错 的 。 適 合 出差 來 住 。
2  	本来 准备 住 两 晚 , 第 2 天 一早 居然 停电 , 且 无 通知 , 只有 口头 道歉 。 总体来说 性价比 尚可 , 房间 较 新 , 还是 推荐 .

2  	这个 酒店 去过 很多 次 了 , 选择 的 主要原因 是 离 客户 最 便宜 相对 又 近 的 酒店
2  	挺好 的 汉庭 , 前台 服务 很 热情 , 卫生 很 整洁 , 房间 安静 , 水温 适中 , 挺好 !

2  	HowardJohnson 的 品质 , 服务 相当 好 的 一 家 五星级 。 房间 不错 、 泳池 不错 、 楼层 安排 很 合理 。 还有 就是 地理位置 , 简直 一 流 。 就 在 天一阁 、 月湖 旁边 , 离 天一广场 也 不远 。 下次 来 宁波 还会 住 。
2  	酒店 很干净 , 很安静 , 很 温馨 , 服务员 服务 好 , 各方面 都 不错 *
2  	挺好 的 , 就是 没 窗户 , 不过 对 得 起 这 价格

其次,对于两种不同的输入数据类型,不同DataProvider对比如下(sequenceGen.py):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
def hook(settings, dict_file, **kwargs):
    settings.word_dict = dict_file
    settings.input_types = [
        integer_value_sequence(len(settings.word_dict)), integer_value(3)
    ]
    settings.logger.info('dict len : %d' % (len(settings.word_dict)))


@provider(init_hook=hook, should_shuffle=False)
def process(settings, file_name):
    with open(file_name, 'r') as fdata:
        for line in fdata:
            label, comment = line.strip().split('\t')
            label = int(''.join(label.split()))
            words = comment.split()
            words = [
                settings.word_dict[w] for w in words if w in settings.word_dict
            ]
            yield words, label
  • 这是普通的单层时间序列的DataProvider代码,其说明如下:
    • DataProvider共返回两个数据,分别是words和label。即上述代码中的第19行。
      • words是原始数据中的每一句话,所对应的词表index数组。它是integer_value_sequence类型的,即整数数组。words即为这个数据中的单层时间序列。
      • label是原始数据中对于每一句话的分类标签,它是integer_value类型的。
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
## for hierarchical sequence network
def hook2(settings, dict_file, **kwargs):
    settings.word_dict = dict_file
    settings.input_types = [
        integer_value_sub_sequence(len(settings.word_dict)),
        integer_value_sequence(3)
    ]
    settings.logger.info('dict len : %d' % (len(settings.word_dict)))


@provider(init_hook=hook2, should_shuffle=False)
def process2(settings, file_name):
    with open(file_name) as fdata:
        labels = []
        sentences = []
        for line in fdata:
            if (len(line)) > 1:
                label, comment = line.strip().split('\t')
                label = int(''.join(label.split()))
                words = comment.split()
                words = [
                    settings.word_dict[w] for w in words
                    if w in settings.word_dict
                ]
                labels.append(label)
                sentences.append(words)
            else:
                yield sentences, labels
                labels = []
                sentences = []
  • 对于同样的数据,双层时间序列的DataProvider的代码。其说明如下:
    • DataProvider共返回两组数据,分别是sentences和labels。即在双层序列的原始数据中,每一组内的所有句子和labels
    • sentences是双层时间序列的数据。由于它内部包含了每组数据中的所有句子,且每个句子表示为对应的词表索引数组,因此它是integer_value_sub_sequence 类型的,即双层时间序列。
    • labels是每组内每个句子的标签,故而是一个单层时间序列。

模型配置的模型配置

首先,我们看一下单层RNN的配置。代码中9-15行(高亮部分)即为单层RNN序列的使用代码。这里使用了PaddlePaddle预定义好的RNN处理函数。在这个函数中,RNN对于每一个时间步通过了一个LSTM网络。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
data = data_layer(name="word", size=dict_dim)

emb = embedding_layer(input=data, size=word_dim)

# (lstm_input + lstm) is equal to lstmemory 
with mixed_layer(size=hidden_dim * 4) as lstm_input:
    lstm_input += full_matrix_projection(input=emb)

lstm = lstmemory_group(
    input=lstm_input,
    size=hidden_dim,
    act=TanhActivation(),
    gate_act=SigmoidActivation(),
    state_act=TanhActivation())

lstm_last = last_seq(input=lstm)

with mixed_layer(
        size=label_dim, act=SoftmaxActivation(), bias_attr=True) as output:
    output += full_matrix_projection(input=lstm_last)

outputs(
    classification_cost(
        input=output, label=data_layer(
            name="label", size=1)))

其次,我们看一下语义相同的双层RNN的网络配置:

  • PaddlePaddle中的许多layer并不在意输入是否是时间序列,例如embedding_layer。在这些layer中,所有的操作都是针对每一个时间步来进行的。
  • 在该配置的7-26行(高亮部分),将双层时间序列数据先变换成单层时间序列数据,再对每一个单层时间序列进行处理。
    • 使用recurrent_group这个函数进行变换,在变换时需要将输入序列传入。由于我们想要的变换是双层时间序列=> 单层时间序列,所以我们需要将输入数据标记成SubsequenceInput
    • 在本例中,我们将原始数据的每一组,通过recurrent_group进行拆解,拆解成的每一句话再通过一个LSTM网络。这和单层RNN的配置是等价的。
  • 与单层RNN的配置类似,我们只需要使用LSTM encode成的最后一个向量。所以对recurrent_group进行了last_seq操作。但和单层RNN不同,我们是对每一个子序列取最后一个元素,因此agg_level=AggregateLevel.EACH_SEQUENCE
  • 至此,lstm_last便和单层RNN配置中的lstm_last具有相同的结果了。
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
data = data_layer(name="word", size=dict_dim)

emb_group = embedding_layer(input=data, size=word_dim)


# (lstm_input + lstm) is equal to lstmemory 
def lstm_group(lstm_group_input):
    with mixed_layer(size=hidden_dim * 4) as group_input:
        group_input += full_matrix_projection(input=lstm_group_input)

    lstm_output = lstmemory_group(
        input=group_input,
        name="lstm_group",
        size=hidden_dim,
        act=TanhActivation(),
        gate_act=SigmoidActivation(),
        state_act=TanhActivation())
    return lstm_output


lstm_nest_group = recurrent_group(
    input=SubsequenceInput(emb_group), step=lstm_group, name="lstm_nest_group")
# hasSubseq ->(seqlastins) seq
lstm_last = last_seq(
    input=lstm_nest_group, agg_level=AggregateLevel.EACH_SEQUENCE)

# seq ->(expand) hasSubseq

示例2:双层RNN,子序列间有Memory

本示例意图使用单层RNN和双层RNN实现两个完全等价的全连接RNN。

  • 对于单层RNN,输入数据为一个完整的时间序列,例如[4, 5, 2, 0, 9, 8, 1, 4]
  • 对于双层RNN,输入数据为在单层RNN数据里面,任意将一些数据组合成双层时间序列,例如[ [4, 5, 2], [0, 9], [8, 1, 4]]

模型配置的模型配置

我们选取单双层序列配置中的不同部分,来对比分析两者语义相同的原因。

  • 单层RNN:过了一个很简单的recurrent_group。每一个时间步,当前的输入y和上一个时间步的输出rnn_state做了一个全链接。
def step(y):
    mem = memory(name="rnn_state", size=hidden_dim)
    out = fc_layer(input=[y, mem],
                    size=hidden_dim,
                    act=TanhActivation(),
                    bias_attr=True,
                    name="rnn_state")
    return out

out = recurrent_group(
    name="rnn",
    step=step,
    input=emb)
  • 双层RNN,外层memory是一个元素:
    • 内层inner_step的recurrent_group和单层序列的几乎一样。除了boot_layer=outer_mem,表示将外层的outer_mem作为内层memory的初始状态。外层outer_step中,outer_mem是一个子句的最后一个向量,即整个双层group是将前一个子句的最后一个向量,作为下一个子句memory的初始状态。
    • 从输入数据上看,单双层序列的句子是一样的,只是双层序列将其又做了子序列划分。因此双层序列的配置中,必须将前一个子句的最后一个元素,作为boot_layer传给下一个子句的memory,才能保证和单层序列的配置中“每个时间步都用了上一个时间步的输出结果”一致。
def outer_step(x):
    outer_mem = memory(name="outer_rnn_state", size=hidden_dim)
    def inner_step(y):
        inner_mem = memory(name="inner_rnn_state",
                           size=hidden_dim,
                           boot_layer=outer_mem)
        out = fc_layer(input=[y, inner_mem],
                        size=hidden_dim,
                        act=TanhActivation(),
                        bias_attr=True,
                        name="inner_rnn_state")
        return out

    inner_rnn_output = recurrent_group(
        step=inner_step,
        name="inner",
        input=x)
    last = last_seq(input=inner_rnn_output, name="outer_rnn_state")

    # "return last" won't work, because recurrent_group only support the input 
    # sequence type is same as return sequence type.
    return inner_rnn_output

out = recurrent_group(
    name="outer",
    step=outer_step,
    input=SubsequenceInput(emb))

警告

PaddlePaddle目前只支持在每个时间步中,Memory的时间序列长度一致的情况。

示例3:双层RNN,输入不等长

输入不等长 是指recurrent_group的多个输入序列,在每个时间步的子序列长度可以不相等。但序列输出时,需要指定与某一个输入的序列信息是一致的。使用targetInlink可以指定哪一个输入和输出序列信息一致,默认指定第一个输入。

示例3的配置分别为单层不等长RNN双层不等长RNN

示例3对于单层RNN和双层RNN数据完全相同。

  • 对于单层RNN的数据一共有两个样本,他们分别是[1, 2, 4, 5, 2], [5, 4, 1, 3, 1][0, 2, 2, 5, 0, 1, 2], [1, 5, 4, 2, 3, 6, 1]。对于每一个单层RNN的数据,均有两组特征。
  • 在单层数据的基础上,双层RNN数据随意加了一些隔断,例如将第一条数据转化为[[0, 2], [2, 5], [0, 1, 2]],[[1, 5], [4], [2, 3, 6, 1]]
  • 需要注意的是PaddlePaddle目前只支持子序列数目一样的多输入双层RNN。例如本例中的两个特征,均有三个子序列。每个子序列长度可以不一致,但是子序列的数目必须一样。

模型配置

和示例2中的配置类似,示例3的配置使用了单层RNN和双层RNN,实现两个完全等价的全连接RNN。

  • 单层RNN:
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
def step(x1, x2):
    def calrnn(y):
        mem = memory(name='rnn_state_' + y.name, size=hidden_dim)
        out = fc_layer(
            input=[y, mem],
            size=hidden_dim,
            act=TanhActivation(),
            bias_attr=True,
            name='rnn_state_' + y.name)
        return out

    encoder1 = calrnn(x1)
    encoder2 = calrnn(x2)
    return [encoder1, encoder2]


encoder1_rep, encoder2_rep = recurrent_group(
    name="stepout", step=step, input=[emb1, emb2])
  • 双层RNN:
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
def outer_step(x1, x2):
    index = [0]

    def inner_step(ipt):
        index[0] += 1
        i = index[0]
        outer_mem = memory(name="outer_rnn_state_%d" % i, size=hidden_dim)

        def inner_step_impl(y):
            inner_mem = memory(
                name="inner_rnn_state_" + y.name,
                size=hidden_dim,
                boot_layer=outer_mem)
            out = fc_layer(
                input=[y, inner_mem],
                size=hidden_dim,
                act=TanhActivation(),
                bias_attr=True,
                name='inner_rnn_state_' + y.name)
            return out

        encoder = recurrent_group(
            step=inner_step_impl, name='inner_%d' % i, input=ipt)
        last = last_seq(name="outer_rnn_state_%d" % i, input=encoder)
        return encoder, last

    encoder1, sentence_last_state1 = inner_step(ipt=x1)
    encoder2, sentence_last_state2 = inner_step(ipt=x2)

    encoder1_expand = expand_layer(
        input=sentence_last_state1, expand_as=encoder2)

    return [encoder1_expand, encoder2]


encoder1_rep, encoder2_rep = recurrent_group(
    name="outer",
    step=outer_step,
    input=[SubsequenceInput(emb1), SubsequenceInput(emb2)],
    targetInlink=emb2)

在上面代码中,单层和双层序列的使用和示例2中的示例类似,区别是同时处理了两个输入。而对于双层序列,两个输入的子序列长度也并不相同。但是,我们使用了targetInlink参数设置了外层recurrent_group的输出格式。所以外层输出的序列形状,和emb2的序列形状一致。

词汇表

Memory

Memory是PaddlePaddle实现RNN时候使用的一个概念。RNN即时间递归神经网络,通常要求时间步之间具有一些依赖性,即当前时间步下的神经网络依赖前一个时间步神经网络中某一个神经元输出。如下图所示。

digraph G{
	subgraph cluster_timestep0 {
		label="recurrent timestep i-1"
		bgcolor=lightgray
		node [style=filled,color=white]
		fc0_0 [label="fc 0"]
		fc0_1 [label="fc 1"]
		fc0_2 [label="fc 2"]

		fc0_0 -> fc0_1
		fc0_1 -> fc0_2
	}

	subgraph cluster_timestep1 {
		label="recurrent timestep i"
		node [style=filled];
		fc1_0 [label="fc 0"]
		fc1_1 [label="fc 1"]
		fc1_2 [label="fc 2"]
		color=blue

		fc1_0 -> fc1_1
		fc1_1 -> fc1_2
	}

	subgraph cluster_timestep2 {
		label="recurrent timestep i+1"
		bgcolor=lightgray
		node [style=filled,color=white]
		fc2_0 [label="fc 0"]
		fc2_1 [label="fc 1"]
		fc2_2 [label="fc 2"]

		fc2_0 -> fc2_1
		fc2_1 -> fc2_2
	}
	
	
	fc0_1 -> fc1_1 [style="dotted" constraint=false]
	fc1_1 -> fc2_1 [style="dotted" constraint=false]

}

上图中虚线的连接,即是跨越时间步的网络连接。PaddlePaddle在实现RNN的时候,将这种跨越时间步的连接用一个特殊的神经网络单元实现。这个神经网络单元就叫Memory。Memory可以缓存上一个时刻某一个神经元的输出,然后在下一个时间步输入给另一个神经元。使用Memory的RNN实现便如下图所示。

digraph G{
	subgraph cluster_timestep0 {
		label="recurrent timestep i-1"
		bgcolor=lightgray
		node [style=filled,color=white]
		fc0_0 [label="fc 0"]
		fc0_1 [label="fc 1"]
		fc0_2 [label="fc 2"]
		m0 [label="memory"]
		fc0_0 -> fc0_1
		fc0_1 -> fc0_2
		fc0_1 -> m0
		m0 -> fc0_1
	}

	subgraph cluster_timestep1 {
		label="recurrent timestep i"
		node [style=filled];
		fc1_0 [label="fc 0"]
		fc1_1 [label="fc 1"]
		fc1_2 [label="fc 2"]
		m1 [label="memory"]
		color=blue
		fc1_0 -> fc1_1
		fc1_1 -> fc1_2
		fc1_1 -> m1
		m1 -> fc1_1
	}

	subgraph cluster_timestep2 {
		label="recurrent timestep i+1"
		bgcolor=lightgray
		node [style=filled,color=white]
		fc2_0 [label="fc 0"]
		fc2_1 [label="fc 1"]
		fc2_2 [label="fc 2"]
		m2 [label="memory"]
		fc2_0 -> fc2_1
		fc2_1 -> fc2_2
		fc2_1 -> m2
		m2 -> fc2_1
	}
	
	
	m0 -> m1 [style="dotted" constraint=false]
	m1 -> m2 [style="dotted" constraint=false]

}

使用这种方式,PaddlePaddle可以比较简单的判断哪些输出是应该跨越时间步的,哪些不是。

时间步

参考时间序列。

时间序列

时间序列(time series)是指一系列的特征数据。这些特征数据之间的顺序是有意义的。即特征的数组,而不是特征的集合。而这每一个数组元素,或者每一个系列里的特征数据,即为一个时间步(time step)。值得注意的是,时间序列、时间步的概念,并不真正的和『时间』有关。只要一系列特征数据中的『顺序』是有意义的,即为时间序列的输入。

举例说明,例如文本分类中,我们通常将一句话理解成一个时间序列。比如一句话中的每一个单词,会变成词表中的位置。而这一句话就可以表示成这些位置的数组。例如 [9, 2, 3, 5, 3]

关于时间序列(time series)的更详细准确的定义,可以参考 维基百科页面 Time series 或者 维基百科中文页面 时间序列

另外,Paddle中经常会将时间序列成为 Sequence 。他们在Paddle的文档和API中是一个概念。

RNN

RNN 在PaddlePaddle的文档中,一般表示 Recurrent neural network,即时间递归神经网络。详细介绍可以参考 维基百科页面 Recurrent neural network 或者 中文维基百科页面 中关于时间递归神经网络的介绍。

RNN 一般在PaddlePaddle中,指对于一个时间序列输入数据,每一个时间步之间的神经网络具有一定的相关性。例如,某一个神经元的一个输入为上一个时间步网络中某一个神经元的输出。或者,从每一个时间步来看,神经网络的网络结构中具有有向环结构。

双层RNN

双层RNN顾名思义,即RNN之间有一次嵌套关系。输入数据整体上是一个时间序列,而对于每一个内层特征数据而言,也是一个时间序列。即二维数组,或者数组的数组这个概念。 而双层RNN是可以处理这种输入数据的网络结构。

例如,对于段落的文本分类,即将一段话进行分类。我们将一段话看成句子的数组,每个句子又是单词的数组。这便是一种双层RNN的输入数据。而将这个段落的每一句话用lstm编码成一个向量,再对每一句话的编码向量用lstm编码成一个段落的向量。再对这个段落向量进行分类,即为这个双层RNN的网络结构。