29

我正在使用 Tensorflowtf.nn.ctc_beam_search_decoder()解码 RNN 的输出，执行一些多对多映射（即，每个网络单元的多个 softmax 输出）。

网络输出和 Beam 搜索解码器的简化版本是：

import numpy as np
import tensorflow as tf

batch_size = 4
sequence_max_len = 5
num_classes = 3

y_pred = tf.placeholder(tf.float32, shape=(batch_size, sequence_max_len, num_classes))
y_pred_transposed = tf.transpose(y_pred,
                                 perm=[1, 0, 2])  # TF expects dimensions [max_time, batch_size, num_classes]
logits = tf.log(y_pred_transposed)
sequence_lengths = tf.to_int32(tf.fill([batch_size], sequence_max_len))
decoded, log_probabilities = tf.nn.ctc_beam_search_decoder(logits,
                                                           sequence_length=sequence_lengths,
                                                           beam_width=3,
                                                           merge_repeated=False, top_paths=1)

decoded = decoded[0]
decoded_paths = tf.sparse_tensor_to_dense(decoded)  # Shape: [batch_size, max_sequence_len]

with tf.Session() as session:
    tf.global_variables_initializer().run()

    softmax_outputs = np.array([[[0.1, 0.1, 0.8], [0.8, 0.1, 0.1], [0.8, 0.1, 0.1], [0.8, 0.1, 0.1], [0.8, 0.1, 0.1]],
                                [[0.1, 0.2, 0.7], [0.1, 0.2, 0.7], [0.1, 0.2, 0.7], [0.1, 0.2, 0.7], [0.1, 0.2, 0.7]],
                                [[0.1, 0.7, 0.2], [0.1, 0.2, 0.7], [0.1, 0.2, 0.7], [0.1, 0.2, 0.7], [0.1, 0.2, 0.7]],
                                [[0.1, 0.2, 0.7], [0.1, 0.2, 0.7], [0.1, 0.2, 0.7], [0.1, 0.2, 0.7], [0.1, 0.2, 0.7]]])

    decoded_paths = session.run(decoded_paths, feed_dict = {y_pred: softmax_outputs})
    print(decoded_paths)

这种情况下的输出是：

[[0]
 [1]
 [1]
 [1]]

我的理解是输出张量应该是维度[batch_size, max_sequence_len]的，每一行都包含找到路径中相关类的索引。

在这种情况下，我希望输出类似于：

[[2, 0, 0, 0, 0],
 [2, 2, 2, 2, 2],
 [1, 2, 2, 2, 2],
 [2, 2, 2, 2, 2]]

我不了解如何ctc_beam_search_decoder工作？

4

1 回答 1

27

如tf.nn.ctc_beam_search_decoder 文档中所示，输出的形状不是[batch_size, max_sequence_len]。相反，它是

[batch_size, max_decoded_length[j]]

（j=0在你的情况下）。

基于本文第 2 节的开头（在github 存储库中引用），max_decoded_length[0]从上面以 为界max_sequence_len，但它们不一定相等。相关引文是：

令 S 是一组从固定分布 D_{XxZ} 中抽取的训练样例。输入空间 X = (R^m) 是所有 m 维实值向量序列的集合。目标空间 Z = L* 是标签（有限）字母 L 上所有序列的集合。通常，我们将 L* 的元素称为标签序列或标签。S 中的每个示例都由一对序列 (x, z) 组成。目标序列 z = (z1, z2, ..., zU)最多与输入序列 x = (x1, x2, ..., xT ) 一样长，即 U<=T。由于输入序列和目标序列的长度通常不同，因此没有先验方法来对齐它们。

其实max_decoded_length[0]要看具体的矩阵softmax_outputs。特别是，两个具有完全相同维度的矩阵可能会导致不同的max_decoded_length[0].

例如，如果您替换该行

softmax_outputs = np.array([[[0.1, 0.1, 0.8], [0.8, 0.1, 0.1], [0.8, 0.1, 0.1], [0.8, 0.1, 0.1], [0.8, 0.1, 0.1]],
                                [[0.1, 0.2, 0.7], [0.1, 0.2, 0.7], [0.1, 0.2, 0.7], [0.1, 0.2, 0.7], [0.1, 0.2, 0.7]],
                                [[0.1, 0.7, 0.2], [0.1, 0.2, 0.7], [0.1, 0.2, 0.7], [0.1, 0.2, 0.7], [0.1, 0.2, 0.7]],
                                [[0.1, 0.2, 0.7], [0.1, 0.2, 0.7], [0.1, 0.2, 0.7], [0.1, 0.2, 0.7], [0.1, 0.2, 0.7]]])

与行

np.random.seed(7)
r=np.random.randint(0,100,size=(4,5,3))
softmax_outputs=r/np.sum(r,2).reshape(4,5,1)

你会得到输出

[[1 0 1]
 [1 0 1]
 [1 0 0]
 [1 0 0]]

（在上面的示例中，softmax_outputs由 logits 组成，并且与您提供的矩阵具有完全相同的维度）。

另一方面，将种子更改为np.random.seed(50)给出输出

[[1 0]
 [1 0]
 [1 0]
 [0 1]]

附言

关于你问题的最后一部分：

在这种情况下，我希望输出类似于：

[[2, 0, 0, 0, 0],
 [2, 2, 2, 2, 2],
 [1, 2, 2, 2, 2],
 [2, 2, 2, 2, 2]]

请注意，根据文档， num_classes实际上表示num_labels + 1. 具体来说：

输入 Tensor 的最内层维度大小num_classes表示 num_labels + 1类别，其中num_labels是真实标签的数量，最大值 ( num_classes - 1) 保留给空白标签。

例如，对于包含 3 个标签 [a, b, c] 的词汇表， num_classes = 4标签索引为 {a: 0, b: 1, c: 2, blank: 3}。

因此，在您的情况下，真正的标签是 0 和 1，而 2 是为空白标签保留的。空白标签代表观察到没有标签的情况（此处第 3.1 节）：

CTC 网络有一个 softmax 输出层 (Bridle, 1990)，其单元比 L 中的标签多一个。第一个 |L| 的激活 单位被解释为在特定时间观察相应标签的概率。额外单元的激活是观察到“空白”或没有标签的概率。这些输出一起定义了将所有可能的标签序列与输入序列对齐的所有可能方式的概率。

于 2017-08-07T09:46:05.907 回答