tensorflow - 如何解释tf.map_fn的结果？

Question

看代码:

import tensorflow as tf
import numpy as np

elems = tf.ones([1,2,3],dtype=tf.int64)
alternates = tf.map_fn(lambda x: (x, x, x), elems, dtype=(tf.int64, tf.int64, tf.int64))
with tf.Session() as sess:
    print(sess.run(alternates))

输出为:

(array([[[1, 1, 1],
        [1, 1, 1]]], dtype=int64), array([[[1, 1, 1],
        [1, 1, 1]]], dtype=int64), array([[[1, 1, 1],
        [1, 1, 1]]], dtype=int64))

我看不懂输出，谁能告诉我？

更新

elems 是一个张量，所以它应该沿着 axis-0 解包，我们会得到 [[1,1,1],[1,1,1]]，然后 map_fn 将 [[1,1,1],[1,1,1]] 传递给 lambda x:(x,x ,x)，这意味着x=[[1,1,1],[1,1,1]]，我认为map_fn的输出> 是

[[[1,1,1],[1,1,1]],
 [[1,1,1],[1,1,1]],
 [[1,1,1],[1,1,1]]]

输出的形状为[3,2,3]或shape(2,3)列表

但实际上，输出是一个张量列表，每个张量的形状为[1,2,3]。

或者换句话说:

import tensorflow as tf
import numpy as np

elems = tf.constant([1,2,3],dtype=tf.int64)
alternates = tf.map_fn(lambda x: (x, 2*x, -x), elems, dtype=(tf.int64, tf.int64, tf.int64))
with tf.Session() as sess:
    print(sess.run(alternates))

为什么输出是

(array([1, 2, 3], dtype=int64), 
 array([2, 4, 6], dtype=int64), 
 array([-1, -2, -3], dtype=int64))

而不是

(array([1, 2, -1], dtype=int64), 
 array([2, 4, -2], dtype=int64), 
 array([3, 6, -3], dtype=int64))

这两个问题是一样的。

更新2

import tensorflow as tf
import numpy as np

elems = [tf.constant([1,2,3],dtype=tf.int64)]
alternates = tf.map_fn(lambda x: x, elems, dtype=tf.int64)
with tf.Session() as sess:
    print(sess.run(alternates))

elems 是张量列表，因此根据 api，tf.constant([1,2,3],dtype=tf.int64) 将被解包沿 axis-0，因此 map_fn 将用作 [x for x in [1,2,3]]，但实际上它会引发错误。

ValueError: The two structures don't have the same nested structure. First struc
ture: <dtype: 'int64'>, second structure: [<tf.Tensor 'map/while/TensorArrayRead
V3:0' shape=() dtype=int64>].

出了什么问题？

更新3

import tensorflow as tf
import numpy as np

elems = (tf.constant([1,2,3],dtype=tf.int64),tf.constant([1,2,3],dtype=tf.int64))
alternates = tf.map_fn(lambda x: x, elems, dtype=(tf.int64, tf.int64))
with tf.Session() as sess:
    print(sess.run(alternates))

输出为

(array([1, 2, 3], dtype=int64), array([1, 2, 3], dtype=int64))

看起来 elems 没有解压，为什么？

import tensorflow as tf
import numpy as np

elems = (tf.constant([1,2,3],dtype=tf.int64),tf.constant([1,2,3],dtype=tf.int64))
alternates = tf.map_fn(lambda x: [x], elems, dtype=(tf.int64, tf.int64))
with tf.Session() as sess:
    print(sess.run(alternates))

它会引发错误

TypeError: The two structures don't have the same sequence type. First structure
 has type <class 'tuple'>, while second structure has type <class 'list'>.

谁能告诉我 tf.map_fn 是如何工作的？

Answer 1

首先，

elems = tf.ones([1,2,3],dtype=tf.int64)

elems 是一个形状为 1x2x3 的 3 维张量，即:

[[[1, 1, 1],
  [1, 1, 1]]]

那么，

alternates = tf.map_fn(lambda x: (x, x, x), elems, dtype=(tf.int64, tf.int64, tf.int64))

alternates 是一个由三个张量组成的元组，其形状与 elems 相同，每个张量都是根据给定的函数构建的。由于该函数只是返回一个重复输入三次的元组，这意味着三个张量将与 elems 相同。如果函数是 lambda x: (x, 2 * x, -x) ，那么第一个输出张量将与 elems 相同，第二个输出张量将是elems 而第三个则相反。

在所有这些情况下，最好使用常规操作而不是 tf.map_fn ;但是，在某些情况下，您可能有一个接受 N 维度张量的函数，并且您希望将其应用到一个 N + 1 维度的张量。

更新:

我认为您正在考虑tf.map_fn可以这么说，“反过来”。张量中的元素或行数与函数中的输出数之间不存在一一对应的关系；事实上，您可以传递一个返回包含任意数量元素的元组的函数。

以最后一个例子为例:

elems = tf.constant([1,2,3],dtype=tf.int64)
alternates = tf.map_fn(lambda x: (x, 2*x, -x), elems, dtype=(tf.int64, tf.int64, tf.int64))

tf.map_fn首先在第一个轴上拆分 elems，即分为 1、2 和 3，并将函数应用到他们每个人都得到:

(1, 2, -1)
(2, 4, -2)
(3, 6, -3)

请注意，正如我所说，每个元组都可以包含您想要的任意数量的元素。现在，最终输出是通过将结果连接到相同位置而产生的；所以你得到:

[1, 2, 3]
[2, 4, 6]
[-1, -2, -3]

同样，如果函数生成包含更多元素的元组，您将获得更多输出张量。

更新 2:

关于您的新示例:

import tensorflow as tf
import numpy as np

elems = (tf.constant([1,2,3],dtype=tf.int64),tf.constant([1,2,3],dtype=tf.int64))
alternates = tf.map_fn(lambda x: x, elems, dtype=(tf.int64, tf.int64))
with tf.Session() as sess:
    print(sess.run(alternates))

documentation说:

This method also allows multi-arity elems and output of fn. If elems is a (possibly nested) list or tuple of tensors, then each of these tensors must have a matching first (unpack) dimension. The signature of fn may match the structure of elems. That is, if elems is (t1, [t2, t3, [t4, t5]]), then an appropriate signature for fn is: fn = lambda (t1, [t2, t3, [t4, t5]]):.

此处 elems 是根据需要在第一维中具有相同大小的两个张量的元组。 tf.map_fn一次获取每个输入张量的一个元素(即两个元素的元组)并将给定函数应用于它，这应该返回与您在 dtypes 中传递的相同结构(两个元素的元组) ， 也);如果您没有给出dtypes，则预期输出与输入相同(同样，两个元素的元组，因此在您的情况下dtypes是可选的) 。无论如何，事情是这样的:

f((1, 1)) -> (1, 1)
f((2, 2)) -> (2, 2)
f((3, 3)) -> (3, 3)

这些结果被组合起来，连接结构中所有相应的元素；在这种情况下，第一个位置中的所有数字产生第一个输出，第二个位置中的所有数字产生第二个输出。最后，结果是所请求的结构(二元素元组)充满了这些串联:

([1, 2, 3], [1, 2, 3])